blob: c4b893453e0eefda8475b3537e934f2bfc46d268 [file] [log] [blame]
David Howells9ae326a2009-04-03 16:42:41 +01001/* CacheFiles path walking and related routines
2 *
3 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public Licence
8 * as published by the Free Software Foundation; either version
9 * 2 of the Licence, or (at your option) any later version.
10 */
11
12#include <linux/module.h>
13#include <linux/sched.h>
14#include <linux/file.h>
15#include <linux/fs.h>
16#include <linux/fsnotify.h>
17#include <linux/quotaops.h>
18#include <linux/xattr.h>
19#include <linux/mount.h>
20#include <linux/namei.h>
21#include <linux/security.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090022#include <linux/slab.h>
David Howells9ae326a2009-04-03 16:42:41 +010023#include "internal.h"
24
David Howellsd0e27b72009-11-19 18:12:02 +000025#define CACHEFILES_KEYBUF_SIZE 512
26
27/*
28 * dump debugging info about an object
29 */
30static noinline
31void __cachefiles_printk_object(struct cachefiles_object *object,
32 const char *prefix,
33 u8 *keybuf)
34{
35 struct fscache_cookie *cookie;
36 unsigned keylen, loop;
37
Fabian Frederick4e1eb882014-06-06 14:37:32 -070038 pr_err("%sobject: OBJ%x\n", prefix, object->fscache.debug_id);
39 pr_err("%sobjstate=%s fl=%lx wbusy=%x ev=%lx[%lx]\n",
David Howellscaaef692013-05-10 19:50:26 +010040 prefix, object->fscache.state->name,
Tejun Heo8b8edef2010-07-20 22:09:01 +020041 object->fscache.flags, work_busy(&object->fscache.work),
David Howellsc2d35bf2012-12-05 13:34:47 +000042 object->fscache.events, object->fscache.event_mask);
Fabian Frederick4e1eb882014-06-06 14:37:32 -070043 pr_err("%sops=%u inp=%u exc=%u\n",
David Howellsd0e27b72009-11-19 18:12:02 +000044 prefix, object->fscache.n_ops, object->fscache.n_in_progress,
45 object->fscache.n_exclusive);
Fabian Frederick4e1eb882014-06-06 14:37:32 -070046 pr_err("%sparent=%p\n",
David Howellsd0e27b72009-11-19 18:12:02 +000047 prefix, object->fscache.parent);
48
49 spin_lock(&object->fscache.lock);
50 cookie = object->fscache.cookie;
51 if (cookie) {
Fabian Frederick4e1eb882014-06-06 14:37:32 -070052 pr_err("%scookie=%p [pr=%p nd=%p fl=%lx]\n",
David Howellsd0e27b72009-11-19 18:12:02 +000053 prefix,
54 object->fscache.cookie,
55 object->fscache.cookie->parent,
56 object->fscache.cookie->netfs_data,
57 object->fscache.cookie->flags);
David Howells509bf242013-09-20 14:18:00 +010058 if (keybuf && cookie->def)
David Howellsd0e27b72009-11-19 18:12:02 +000059 keylen = cookie->def->get_key(cookie->netfs_data, keybuf,
60 CACHEFILES_KEYBUF_SIZE);
61 else
62 keylen = 0;
63 } else {
Fabian Frederick4e1eb882014-06-06 14:37:32 -070064 pr_err("%scookie=NULL\n", prefix);
David Howellsd0e27b72009-11-19 18:12:02 +000065 keylen = 0;
66 }
67 spin_unlock(&object->fscache.lock);
68
69 if (keylen) {
Fabian Frederick4e1eb882014-06-06 14:37:32 -070070 pr_err("%skey=[%u] '", prefix, keylen);
David Howellsd0e27b72009-11-19 18:12:02 +000071 for (loop = 0; loop < keylen; loop++)
Fabian Frederick4e1eb882014-06-06 14:37:32 -070072 pr_cont("%02x", keybuf[loop]);
73 pr_cont("'\n");
David Howellsd0e27b72009-11-19 18:12:02 +000074 }
75}
76
77/*
78 * dump debugging info about a pair of objects
79 */
80static noinline void cachefiles_printk_object(struct cachefiles_object *object,
81 struct cachefiles_object *xobject)
82{
83 u8 *keybuf;
84
85 keybuf = kmalloc(CACHEFILES_KEYBUF_SIZE, GFP_NOIO);
86 if (object)
87 __cachefiles_printk_object(object, "", keybuf);
88 if (xobject)
89 __cachefiles_printk_object(xobject, "x", keybuf);
90 kfree(keybuf);
91}
92
David Howells9ae326a2009-04-03 16:42:41 +010093/*
David Howellsc61ea312010-05-11 16:51:39 +010094 * mark the owner of a dentry, if there is one, to indicate that that dentry
95 * has been preemptively deleted
96 * - the caller must hold the i_mutex on the dentry's parent as required to
97 * call vfs_unlink(), vfs_rmdir() or vfs_rename()
98 */
99static void cachefiles_mark_object_buried(struct cachefiles_cache *cache,
David Howells182d9192015-02-19 23:47:31 +0000100 struct dentry *dentry,
101 enum fscache_why_object_killed why)
David Howellsc61ea312010-05-11 16:51:39 +0100102{
103 struct cachefiles_object *object;
104 struct rb_node *p;
105
Al Viroa4555892014-10-21 20:11:25 -0400106 _enter(",'%pd'", dentry);
David Howellsc61ea312010-05-11 16:51:39 +0100107
108 write_lock(&cache->active_lock);
109
110 p = cache->active_nodes.rb_node;
111 while (p) {
112 object = rb_entry(p, struct cachefiles_object, active_node);
113 if (object->dentry > dentry)
114 p = p->rb_left;
115 else if (object->dentry < dentry)
116 p = p->rb_right;
117 else
118 goto found_dentry;
119 }
120
121 write_unlock(&cache->active_lock);
122 _leave(" [no owner]");
123 return;
124
125 /* found the dentry for */
126found_dentry:
127 kdebug("preemptive burial: OBJ%x [%s] %p",
128 object->fscache.debug_id,
David Howellscaaef692013-05-10 19:50:26 +0100129 object->fscache.state->name,
David Howellsc61ea312010-05-11 16:51:39 +0100130 dentry);
131
David Howells493f7bc2013-05-10 19:50:26 +0100132 if (fscache_object_is_live(&object->fscache)) {
Fabian Frederick4e1eb882014-06-06 14:37:32 -0700133 pr_err("\n");
Fabian Frederick0227d6ab2014-06-06 14:37:33 -0700134 pr_err("Error: Can't preemptively bury live object\n");
David Howellsc61ea312010-05-11 16:51:39 +0100135 cachefiles_printk_object(object, NULL);
David Howells182d9192015-02-19 23:47:31 +0000136 } else {
137 if (why != FSCACHE_OBJECT_IS_STALE)
138 fscache_object_mark_killed(&object->fscache, why);
David Howellsc61ea312010-05-11 16:51:39 +0100139 }
140
141 write_unlock(&cache->active_lock);
142 _leave(" [owner marked]");
143}
144
145/*
David Howells9ae326a2009-04-03 16:42:41 +0100146 * record the fact that an object is now active
147 */
David Howellsfee096d2009-11-19 18:12:05 +0000148static int cachefiles_mark_object_active(struct cachefiles_cache *cache,
149 struct cachefiles_object *object)
David Howells9ae326a2009-04-03 16:42:41 +0100150{
151 struct cachefiles_object *xobject;
152 struct rb_node **_p, *_parent = NULL;
153 struct dentry *dentry;
154
155 _enter(",%p", object);
156
157try_again:
158 write_lock(&cache->active_lock);
159
David Howellsd0e27b72009-11-19 18:12:02 +0000160 if (test_and_set_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags)) {
Fabian Frederick0227d6ab2014-06-06 14:37:33 -0700161 pr_err("Error: Object already active\n");
David Howellsd0e27b72009-11-19 18:12:02 +0000162 cachefiles_printk_object(object, NULL);
David Howells9ae326a2009-04-03 16:42:41 +0100163 BUG();
David Howellsd0e27b72009-11-19 18:12:02 +0000164 }
David Howells9ae326a2009-04-03 16:42:41 +0100165
166 dentry = object->dentry;
167 _p = &cache->active_nodes.rb_node;
168 while (*_p) {
169 _parent = *_p;
170 xobject = rb_entry(_parent,
171 struct cachefiles_object, active_node);
172
173 ASSERT(xobject != object);
174
175 if (xobject->dentry > dentry)
176 _p = &(*_p)->rb_left;
177 else if (xobject->dentry < dentry)
178 _p = &(*_p)->rb_right;
179 else
180 goto wait_for_old_object;
181 }
182
183 rb_link_node(&object->active_node, _parent, _p);
184 rb_insert_color(&object->active_node, &cache->active_nodes);
185
186 write_unlock(&cache->active_lock);
David Howellsfee096d2009-11-19 18:12:05 +0000187 _leave(" = 0");
188 return 0;
David Howells9ae326a2009-04-03 16:42:41 +0100189
190 /* an old object from a previous incarnation is hogging the slot - we
191 * need to wait for it to be destroyed */
192wait_for_old_object:
David Howellsa30efe22014-09-30 14:50:30 +0100193 if (fscache_object_is_live(&xobject->fscache)) {
Fabian Frederick4e1eb882014-06-06 14:37:32 -0700194 pr_err("\n");
Fabian Frederick0227d6ab2014-06-06 14:37:33 -0700195 pr_err("Error: Unexpected object collision\n");
David Howellsd0e27b72009-11-19 18:12:02 +0000196 cachefiles_printk_object(object, xobject);
David Howells9ae326a2009-04-03 16:42:41 +0100197 BUG();
198 }
199 atomic_inc(&xobject->usage);
200 write_unlock(&cache->active_lock);
201
David Howellsfee096d2009-11-19 18:12:05 +0000202 if (test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags)) {
203 wait_queue_head_t *wq;
204
205 signed long timeout = 60 * HZ;
206 wait_queue_t wait;
207 bool requeue;
208
209 /* if the object we're waiting for is queued for processing,
210 * then just put ourselves on the queue behind it */
Tejun Heo8b8edef2010-07-20 22:09:01 +0200211 if (work_pending(&xobject->fscache.work)) {
David Howellsfee096d2009-11-19 18:12:05 +0000212 _debug("queue OBJ%x behind OBJ%x immediately",
213 object->fscache.debug_id,
214 xobject->fscache.debug_id);
215 goto requeue;
216 }
217
218 /* otherwise we sleep until either the object we're waiting for
Tejun Heo8b8edef2010-07-20 22:09:01 +0200219 * is done, or the fscache_object is congested */
David Howellsfee096d2009-11-19 18:12:05 +0000220 wq = bit_waitqueue(&xobject->flags, CACHEFILES_OBJECT_ACTIVE);
221 init_wait(&wait);
222 requeue = false;
223 do {
224 prepare_to_wait(wq, &wait, TASK_UNINTERRUPTIBLE);
225 if (!test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags))
226 break;
Tejun Heo8b8edef2010-07-20 22:09:01 +0200227
228 requeue = fscache_object_sleep_till_congested(&timeout);
David Howellsfee096d2009-11-19 18:12:05 +0000229 } while (timeout > 0 && !requeue);
230 finish_wait(wq, &wait);
231
232 if (requeue &&
233 test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags)) {
234 _debug("queue OBJ%x behind OBJ%x after wait",
235 object->fscache.debug_id,
236 xobject->fscache.debug_id);
237 goto requeue;
238 }
239
240 if (timeout <= 0) {
Fabian Frederick4e1eb882014-06-06 14:37:32 -0700241 pr_err("\n");
Fabian Frederick0227d6ab2014-06-06 14:37:33 -0700242 pr_err("Error: Overlong wait for old active object to go away\n");
David Howellsfee096d2009-11-19 18:12:05 +0000243 cachefiles_printk_object(object, xobject);
244 goto requeue;
245 }
246 }
247
248 ASSERT(!test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags));
David Howells9ae326a2009-04-03 16:42:41 +0100249
250 cache->cache.ops->put_object(&xobject->fscache);
251 goto try_again;
David Howellsfee096d2009-11-19 18:12:05 +0000252
253requeue:
254 clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags);
255 cache->cache.ops->put_object(&xobject->fscache);
256 _leave(" = -ETIMEDOUT");
257 return -ETIMEDOUT;
David Howells9ae326a2009-04-03 16:42:41 +0100258}
259
260/*
261 * delete an object representation from the cache
262 * - file backed objects are unlinked
263 * - directory backed objects are stuffed into the graveyard for userspace to
264 * delete
265 * - unlocks the directory mutex
266 */
267static int cachefiles_bury_object(struct cachefiles_cache *cache,
268 struct dentry *dir,
David Howellsc61ea312010-05-11 16:51:39 +0100269 struct dentry *rep,
David Howells182d9192015-02-19 23:47:31 +0000270 bool preemptive,
271 enum fscache_why_object_killed why)
David Howells9ae326a2009-04-03 16:42:41 +0100272{
273 struct dentry *grave, *trap;
David Howells82140442010-12-24 14:48:35 +0000274 struct path path, path_to_graveyard;
David Howells9ae326a2009-04-03 16:42:41 +0100275 char nbuffer[8 + 8 + 1];
276 int ret;
277
Al Viroa4555892014-10-21 20:11:25 -0400278 _enter(",'%pd','%pd'", dir, rep);
David Howells9ae326a2009-04-03 16:42:41 +0100279
David Howellsc61ea312010-05-11 16:51:39 +0100280 _debug("remove %p from %p", rep, dir);
281
David Howells9ae326a2009-04-03 16:42:41 +0100282 /* non-directories can just be unlinked */
David Howellse36cb0b2015-01-29 12:02:35 +0000283 if (!d_is_dir(rep)) {
David Howells9ae326a2009-04-03 16:42:41 +0100284 _debug("unlink stale object");
David Howells9ae326a2009-04-03 16:42:41 +0100285
David Howells82140442010-12-24 14:48:35 +0000286 path.mnt = cache->mnt;
287 path.dentry = dir;
288 ret = security_path_unlink(&path, rep);
289 if (ret < 0) {
290 cachefiles_io_error(cache, "Unlink security error");
291 } else {
David Howells5153bc82015-03-06 14:08:58 +0000292 ret = vfs_unlink(d_inode(dir), rep, NULL);
David Howells82140442010-12-24 14:48:35 +0000293
294 if (preemptive)
David Howells182d9192015-02-19 23:47:31 +0000295 cachefiles_mark_object_buried(cache, rep, why);
David Howells82140442010-12-24 14:48:35 +0000296 }
David Howellsc61ea312010-05-11 16:51:39 +0100297
David Howells5153bc82015-03-06 14:08:58 +0000298 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100299
300 if (ret == -EIO)
301 cachefiles_io_error(cache, "Unlink failed");
302
303 _leave(" = %d", ret);
304 return ret;
305 }
306
307 /* directories have to be moved to the graveyard */
308 _debug("move stale object to graveyard");
David Howells5153bc82015-03-06 14:08:58 +0000309 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100310
311try_again:
312 /* first step is to make up a grave dentry in the graveyard */
313 sprintf(nbuffer, "%08x%08x",
314 (uint32_t) get_seconds(),
315 (uint32_t) atomic_inc_return(&cache->gravecounter));
316
317 /* do the multiway lock magic */
318 trap = lock_rename(cache->graveyard, dir);
319
320 /* do some checks before getting the grave dentry */
321 if (rep->d_parent != dir) {
322 /* the entry was probably culled when we dropped the parent dir
323 * lock */
324 unlock_rename(cache->graveyard, dir);
325 _leave(" = 0 [culled?]");
326 return 0;
327 }
328
David Howellsce40fa72015-01-29 12:02:36 +0000329 if (!d_can_lookup(cache->graveyard)) {
David Howells9ae326a2009-04-03 16:42:41 +0100330 unlock_rename(cache->graveyard, dir);
331 cachefiles_io_error(cache, "Graveyard no longer a directory");
332 return -EIO;
333 }
334
335 if (trap == rep) {
336 unlock_rename(cache->graveyard, dir);
337 cachefiles_io_error(cache, "May not make directory loop");
338 return -EIO;
339 }
340
341 if (d_mountpoint(rep)) {
342 unlock_rename(cache->graveyard, dir);
343 cachefiles_io_error(cache, "Mountpoint in cache");
344 return -EIO;
345 }
346
347 grave = lookup_one_len(nbuffer, cache->graveyard, strlen(nbuffer));
348 if (IS_ERR(grave)) {
349 unlock_rename(cache->graveyard, dir);
350
351 if (PTR_ERR(grave) == -ENOMEM) {
352 _leave(" = -ENOMEM");
353 return -ENOMEM;
354 }
355
356 cachefiles_io_error(cache, "Lookup error %ld",
357 PTR_ERR(grave));
358 return -EIO;
359 }
360
David Howells466b77b2015-03-17 22:26:21 +0000361 if (d_is_positive(grave)) {
David Howells9ae326a2009-04-03 16:42:41 +0100362 unlock_rename(cache->graveyard, dir);
363 dput(grave);
364 grave = NULL;
365 cond_resched();
366 goto try_again;
367 }
368
369 if (d_mountpoint(grave)) {
370 unlock_rename(cache->graveyard, dir);
371 dput(grave);
372 cachefiles_io_error(cache, "Mountpoint in graveyard");
373 return -EIO;
374 }
375
376 /* target should not be an ancestor of source */
377 if (trap == grave) {
378 unlock_rename(cache->graveyard, dir);
379 dput(grave);
380 cachefiles_io_error(cache, "May not make directory loop");
381 return -EIO;
382 }
383
384 /* attempt the rename */
David Howells82140442010-12-24 14:48:35 +0000385 path.mnt = cache->mnt;
386 path.dentry = dir;
387 path_to_graveyard.mnt = cache->mnt;
388 path_to_graveyard.dentry = cache->graveyard;
Miklos Szeredi0b3974e2014-04-01 17:08:43 +0200389 ret = security_path_rename(&path, rep, &path_to_graveyard, grave, 0);
David Howells82140442010-12-24 14:48:35 +0000390 if (ret < 0) {
391 cachefiles_io_error(cache, "Rename security error %d", ret);
392 } else {
David Howells5153bc82015-03-06 14:08:58 +0000393 ret = vfs_rename(d_inode(dir), rep,
394 d_inode(cache->graveyard), grave, NULL, 0);
David Howells82140442010-12-24 14:48:35 +0000395 if (ret != 0 && ret != -ENOMEM)
396 cachefiles_io_error(cache,
397 "Rename failed with error %d", ret);
David Howells9ae326a2009-04-03 16:42:41 +0100398
David Howells82140442010-12-24 14:48:35 +0000399 if (preemptive)
David Howells182d9192015-02-19 23:47:31 +0000400 cachefiles_mark_object_buried(cache, rep, why);
David Howells82140442010-12-24 14:48:35 +0000401 }
David Howellsc61ea312010-05-11 16:51:39 +0100402
David Howells9ae326a2009-04-03 16:42:41 +0100403 unlock_rename(cache->graveyard, dir);
404 dput(grave);
405 _leave(" = 0");
406 return 0;
407}
408
409/*
410 * delete an object representation from the cache
411 */
412int cachefiles_delete_object(struct cachefiles_cache *cache,
413 struct cachefiles_object *object)
414{
415 struct dentry *dir;
416 int ret;
417
David Howellsc61ea312010-05-11 16:51:39 +0100418 _enter(",OBJ%x{%p}", object->fscache.debug_id, object->dentry);
David Howells9ae326a2009-04-03 16:42:41 +0100419
420 ASSERT(object->dentry);
David Howells466b77b2015-03-17 22:26:21 +0000421 ASSERT(d_backing_inode(object->dentry));
David Howells9ae326a2009-04-03 16:42:41 +0100422 ASSERT(object->dentry->d_parent);
423
424 dir = dget_parent(object->dentry);
425
David Howells5153bc82015-03-06 14:08:58 +0000426 mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT);
David Howells8f9941a2010-02-19 18:14:21 +0000427
David Howells182d9192015-02-19 23:47:31 +0000428 if (test_bit(FSCACHE_OBJECT_KILLED_BY_CACHE, &object->fscache.flags)) {
David Howellsc61ea312010-05-11 16:51:39 +0100429 /* object allocation for the same key preemptively deleted this
430 * object's file so that it could create its own file */
431 _debug("object preemptively buried");
David Howells5153bc82015-03-06 14:08:58 +0000432 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells8f9941a2010-02-19 18:14:21 +0000433 ret = 0;
David Howellsc61ea312010-05-11 16:51:39 +0100434 } else {
435 /* we need to check that our parent is _still_ our parent - it
436 * may have been renamed */
437 if (dir == object->dentry->d_parent) {
438 ret = cachefiles_bury_object(cache, dir,
David Howells182d9192015-02-19 23:47:31 +0000439 object->dentry, false,
440 FSCACHE_OBJECT_WAS_RETIRED);
David Howellsc61ea312010-05-11 16:51:39 +0100441 } else {
442 /* it got moved, presumably by cachefilesd culling it,
443 * so it's no longer in the key path and we can ignore
444 * it */
David Howells5153bc82015-03-06 14:08:58 +0000445 mutex_unlock(&d_inode(dir)->i_mutex);
David Howellsc61ea312010-05-11 16:51:39 +0100446 ret = 0;
447 }
David Howells8f9941a2010-02-19 18:14:21 +0000448 }
David Howells9ae326a2009-04-03 16:42:41 +0100449
450 dput(dir);
451 _leave(" = %d", ret);
452 return ret;
453}
454
455/*
456 * walk from the parent object to the child object through the backing
457 * filesystem, creating directories as we go
458 */
459int cachefiles_walk_to_object(struct cachefiles_object *parent,
460 struct cachefiles_object *object,
461 const char *key,
462 struct cachefiles_xattr *auxdata)
463{
464 struct cachefiles_cache *cache;
465 struct dentry *dir, *next = NULL;
David Howells82140442010-12-24 14:48:35 +0000466 struct path path;
David Howells9ae326a2009-04-03 16:42:41 +0100467 unsigned long start;
468 const char *name;
469 int ret, nlen;
470
David Howellsc61ea312010-05-11 16:51:39 +0100471 _enter("OBJ%x{%p},OBJ%x,%s,",
472 parent->fscache.debug_id, parent->dentry,
473 object->fscache.debug_id, key);
David Howells9ae326a2009-04-03 16:42:41 +0100474
475 cache = container_of(parent->fscache.cache,
476 struct cachefiles_cache, cache);
David Howells82140442010-12-24 14:48:35 +0000477 path.mnt = cache->mnt;
David Howells9ae326a2009-04-03 16:42:41 +0100478
479 ASSERT(parent->dentry);
David Howells466b77b2015-03-17 22:26:21 +0000480 ASSERT(d_backing_inode(parent->dentry));
David Howells9ae326a2009-04-03 16:42:41 +0100481
David Howellse36cb0b2015-01-29 12:02:35 +0000482 if (!(d_is_dir(parent->dentry))) {
David Howells9ae326a2009-04-03 16:42:41 +0100483 // TODO: convert file to dir
484 _leave("looking up in none directory");
485 return -ENOBUFS;
486 }
487
488 dir = dget(parent->dentry);
489
490advance:
491 /* attempt to transit the first directory component */
492 name = key;
493 nlen = strlen(key);
494
495 /* key ends in a double NUL */
496 key = key + nlen + 1;
497 if (!*key)
498 key = NULL;
499
500lookup_again:
501 /* search the current directory for the element name */
502 _debug("lookup '%s'", name);
503
David Howells5153bc82015-03-06 14:08:58 +0000504 mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT);
David Howells9ae326a2009-04-03 16:42:41 +0100505
506 start = jiffies;
507 next = lookup_one_len(name, dir, nlen);
508 cachefiles_hist(cachefiles_lookup_histogram, start);
509 if (IS_ERR(next))
510 goto lookup_error;
511
David Howells466b77b2015-03-17 22:26:21 +0000512 _debug("next -> %p %s", next, d_backing_inode(next) ? "positive" : "negative");
David Howells9ae326a2009-04-03 16:42:41 +0100513
514 if (!key)
David Howells466b77b2015-03-17 22:26:21 +0000515 object->new = !d_backing_inode(next);
David Howells9ae326a2009-04-03 16:42:41 +0100516
517 /* if this element of the path doesn't exist, then the lookup phase
518 * failed, and we can release any readers in the certain knowledge that
519 * there's nothing for them to actually read */
David Howells466b77b2015-03-17 22:26:21 +0000520 if (d_is_negative(next))
David Howells9ae326a2009-04-03 16:42:41 +0100521 fscache_object_lookup_negative(&object->fscache);
522
523 /* we need to create the object if it's negative */
524 if (key || object->type == FSCACHE_COOKIE_TYPE_INDEX) {
525 /* index objects and intervening tree levels must be subdirs */
David Howells466b77b2015-03-17 22:26:21 +0000526 if (d_is_negative(next)) {
David Howells9ae326a2009-04-03 16:42:41 +0100527 ret = cachefiles_has_space(cache, 1, 0);
528 if (ret < 0)
David Howells182d9192015-02-19 23:47:31 +0000529 goto no_space_error;
David Howells9ae326a2009-04-03 16:42:41 +0100530
David Howells82140442010-12-24 14:48:35 +0000531 path.dentry = dir;
532 ret = security_path_mkdir(&path, next, 0);
533 if (ret < 0)
534 goto create_error;
David Howells9ae326a2009-04-03 16:42:41 +0100535 start = jiffies;
David Howells5153bc82015-03-06 14:08:58 +0000536 ret = vfs_mkdir(d_inode(dir), next, 0);
David Howells9ae326a2009-04-03 16:42:41 +0100537 cachefiles_hist(cachefiles_mkdir_histogram, start);
538 if (ret < 0)
539 goto create_error;
540
David Howells466b77b2015-03-17 22:26:21 +0000541 ASSERT(d_backing_inode(next));
David Howells9ae326a2009-04-03 16:42:41 +0100542
543 _debug("mkdir -> %p{%p{ino=%lu}}",
David Howells466b77b2015-03-17 22:26:21 +0000544 next, d_backing_inode(next), d_backing_inode(next)->i_ino);
David Howells9ae326a2009-04-03 16:42:41 +0100545
David Howellsce40fa72015-01-29 12:02:36 +0000546 } else if (!d_can_lookup(next)) {
Fabian Frederick6ff66ac2014-09-25 16:05:27 -0700547 pr_err("inode %lu is not a directory\n",
David Howells466b77b2015-03-17 22:26:21 +0000548 d_backing_inode(next)->i_ino);
David Howells9ae326a2009-04-03 16:42:41 +0100549 ret = -ENOBUFS;
550 goto error;
551 }
552
553 } else {
554 /* non-index objects start out life as files */
David Howells466b77b2015-03-17 22:26:21 +0000555 if (d_is_negative(next)) {
David Howells9ae326a2009-04-03 16:42:41 +0100556 ret = cachefiles_has_space(cache, 1, 0);
557 if (ret < 0)
David Howells182d9192015-02-19 23:47:31 +0000558 goto no_space_error;
David Howells9ae326a2009-04-03 16:42:41 +0100559
David Howells82140442010-12-24 14:48:35 +0000560 path.dentry = dir;
561 ret = security_path_mknod(&path, next, S_IFREG, 0);
562 if (ret < 0)
563 goto create_error;
David Howells9ae326a2009-04-03 16:42:41 +0100564 start = jiffies;
David Howells5153bc82015-03-06 14:08:58 +0000565 ret = vfs_create(d_inode(dir), next, S_IFREG, true);
David Howells9ae326a2009-04-03 16:42:41 +0100566 cachefiles_hist(cachefiles_create_histogram, start);
567 if (ret < 0)
568 goto create_error;
569
David Howells466b77b2015-03-17 22:26:21 +0000570 ASSERT(d_backing_inode(next));
David Howells9ae326a2009-04-03 16:42:41 +0100571
572 _debug("create -> %p{%p{ino=%lu}}",
David Howells466b77b2015-03-17 22:26:21 +0000573 next, d_backing_inode(next), d_backing_inode(next)->i_ino);
David Howells9ae326a2009-04-03 16:42:41 +0100574
David Howellsce40fa72015-01-29 12:02:36 +0000575 } else if (!d_can_lookup(next) &&
David Howellse36cb0b2015-01-29 12:02:35 +0000576 !d_is_reg(next)
David Howells9ae326a2009-04-03 16:42:41 +0100577 ) {
Fabian Frederick6ff66ac2014-09-25 16:05:27 -0700578 pr_err("inode %lu is not a file or directory\n",
David Howells466b77b2015-03-17 22:26:21 +0000579 d_backing_inode(next)->i_ino);
David Howells9ae326a2009-04-03 16:42:41 +0100580 ret = -ENOBUFS;
581 goto error;
582 }
583 }
584
585 /* process the next component */
586 if (key) {
587 _debug("advance");
David Howells5153bc82015-03-06 14:08:58 +0000588 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100589 dput(dir);
590 dir = next;
591 next = NULL;
592 goto advance;
593 }
594
595 /* we've found the object we were looking for */
596 object->dentry = next;
597
598 /* if we've found that the terminal object exists, then we need to
599 * check its attributes and delete it if it's out of date */
600 if (!object->new) {
Al Viroa4555892014-10-21 20:11:25 -0400601 _debug("validate '%pd'", next);
David Howells9ae326a2009-04-03 16:42:41 +0100602
603 ret = cachefiles_check_object_xattr(object, auxdata);
604 if (ret == -ESTALE) {
605 /* delete the object (the deleter drops the directory
606 * mutex) */
607 object->dentry = NULL;
608
David Howells182d9192015-02-19 23:47:31 +0000609 ret = cachefiles_bury_object(cache, dir, next, true,
610 FSCACHE_OBJECT_IS_STALE);
David Howells9ae326a2009-04-03 16:42:41 +0100611 dput(next);
612 next = NULL;
613
614 if (ret < 0)
615 goto delete_error;
616
617 _debug("redo lookup");
David Howells182d9192015-02-19 23:47:31 +0000618 fscache_object_retrying_stale(&object->fscache);
David Howells9ae326a2009-04-03 16:42:41 +0100619 goto lookup_again;
620 }
621 }
622
623 /* note that we're now using this object */
David Howellsfee096d2009-11-19 18:12:05 +0000624 ret = cachefiles_mark_object_active(cache, object);
David Howells9ae326a2009-04-03 16:42:41 +0100625
David Howells5153bc82015-03-06 14:08:58 +0000626 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100627 dput(dir);
628 dir = NULL;
629
David Howellsfee096d2009-11-19 18:12:05 +0000630 if (ret == -ETIMEDOUT)
631 goto mark_active_timed_out;
632
David Howells9ae326a2009-04-03 16:42:41 +0100633 _debug("=== OBTAINED_OBJECT ===");
634
635 if (object->new) {
636 /* attach data to a newly constructed terminal object */
637 ret = cachefiles_set_object_xattr(object, auxdata);
638 if (ret < 0)
639 goto check_error;
640 } else {
641 /* always update the atime on an object we've just looked up
642 * (this is used to keep track of culling, and atimes are only
643 * updated by read, write and readdir but not lookup or
644 * open) */
Al Viro68ac1232012-03-15 08:21:57 -0400645 path.dentry = next;
646 touch_atime(&path);
David Howells9ae326a2009-04-03 16:42:41 +0100647 }
648
649 /* open a file interface onto a data file */
650 if (object->type != FSCACHE_COOKIE_TYPE_INDEX) {
David Howellse36cb0b2015-01-29 12:02:35 +0000651 if (d_is_reg(object->dentry)) {
David Howells9ae326a2009-04-03 16:42:41 +0100652 const struct address_space_operations *aops;
653
654 ret = -EPERM;
David Howells466b77b2015-03-17 22:26:21 +0000655 aops = d_backing_inode(object->dentry)->i_mapping->a_ops;
David Howells9ae326a2009-04-03 16:42:41 +0100656 if (!aops->bmap)
657 goto check_error;
NeilBrown95201a42015-11-04 15:20:34 +0000658 if (object->dentry->d_sb->s_blocksize > PAGE_SIZE)
659 goto check_error;
David Howells9ae326a2009-04-03 16:42:41 +0100660
661 object->backer = object->dentry;
662 } else {
663 BUG(); // TODO: open file in data-class subdir
664 }
665 }
666
667 object->new = 0;
668 fscache_obtained_object(&object->fscache);
669
David Howells466b77b2015-03-17 22:26:21 +0000670 _leave(" = 0 [%lu]", d_backing_inode(object->dentry)->i_ino);
David Howells9ae326a2009-04-03 16:42:41 +0100671 return 0;
672
David Howells182d9192015-02-19 23:47:31 +0000673no_space_error:
674 fscache_object_mark_killed(&object->fscache, FSCACHE_OBJECT_NO_SPACE);
David Howells9ae326a2009-04-03 16:42:41 +0100675create_error:
676 _debug("create error %d", ret);
677 if (ret == -EIO)
678 cachefiles_io_error(cache, "Create/mkdir failed");
679 goto error;
680
David Howellsfee096d2009-11-19 18:12:05 +0000681mark_active_timed_out:
682 _debug("mark active timed out");
683 goto release_dentry;
684
David Howells9ae326a2009-04-03 16:42:41 +0100685check_error:
686 _debug("check error %d", ret);
687 write_lock(&cache->active_lock);
688 rb_erase(&object->active_node, &cache->active_nodes);
689 clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags);
690 wake_up_bit(&object->flags, CACHEFILES_OBJECT_ACTIVE);
691 write_unlock(&cache->active_lock);
David Howellsfee096d2009-11-19 18:12:05 +0000692release_dentry:
David Howells9ae326a2009-04-03 16:42:41 +0100693 dput(object->dentry);
694 object->dentry = NULL;
695 goto error_out;
696
697delete_error:
698 _debug("delete error %d", ret);
699 goto error_out2;
700
701lookup_error:
702 _debug("lookup error %ld", PTR_ERR(next));
703 ret = PTR_ERR(next);
704 if (ret == -EIO)
705 cachefiles_io_error(cache, "Lookup failed");
706 next = NULL;
707error:
David Howells5153bc82015-03-06 14:08:58 +0000708 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100709 dput(next);
710error_out2:
711 dput(dir);
712error_out:
David Howells9ae326a2009-04-03 16:42:41 +0100713 _leave(" = error %d", -ret);
714 return ret;
715}
716
717/*
718 * get a subdirectory
719 */
720struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
721 struct dentry *dir,
722 const char *dirname)
723{
724 struct dentry *subdir;
725 unsigned long start;
David Howells82140442010-12-24 14:48:35 +0000726 struct path path;
David Howells9ae326a2009-04-03 16:42:41 +0100727 int ret;
728
729 _enter(",,%s", dirname);
730
731 /* search the current directory for the element name */
David Howells5153bc82015-03-06 14:08:58 +0000732 mutex_lock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100733
734 start = jiffies;
735 subdir = lookup_one_len(dirname, dir, strlen(dirname));
736 cachefiles_hist(cachefiles_lookup_histogram, start);
737 if (IS_ERR(subdir)) {
738 if (PTR_ERR(subdir) == -ENOMEM)
739 goto nomem_d_alloc;
740 goto lookup_error;
741 }
742
743 _debug("subdir -> %p %s",
David Howells466b77b2015-03-17 22:26:21 +0000744 subdir, d_backing_inode(subdir) ? "positive" : "negative");
David Howells9ae326a2009-04-03 16:42:41 +0100745
746 /* we need to create the subdir if it doesn't exist yet */
David Howells466b77b2015-03-17 22:26:21 +0000747 if (d_is_negative(subdir)) {
David Howells9ae326a2009-04-03 16:42:41 +0100748 ret = cachefiles_has_space(cache, 1, 0);
749 if (ret < 0)
750 goto mkdir_error;
751
752 _debug("attempt mkdir");
753
David Howells82140442010-12-24 14:48:35 +0000754 path.mnt = cache->mnt;
755 path.dentry = dir;
756 ret = security_path_mkdir(&path, subdir, 0700);
757 if (ret < 0)
758 goto mkdir_error;
David Howells5153bc82015-03-06 14:08:58 +0000759 ret = vfs_mkdir(d_inode(dir), subdir, 0700);
David Howells9ae326a2009-04-03 16:42:41 +0100760 if (ret < 0)
761 goto mkdir_error;
762
David Howells466b77b2015-03-17 22:26:21 +0000763 ASSERT(d_backing_inode(subdir));
David Howells9ae326a2009-04-03 16:42:41 +0100764
765 _debug("mkdir -> %p{%p{ino=%lu}}",
766 subdir,
David Howells466b77b2015-03-17 22:26:21 +0000767 d_backing_inode(subdir),
768 d_backing_inode(subdir)->i_ino);
David Howells9ae326a2009-04-03 16:42:41 +0100769 }
770
David Howells5153bc82015-03-06 14:08:58 +0000771 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100772
773 /* we need to make sure the subdir is a directory */
David Howells466b77b2015-03-17 22:26:21 +0000774 ASSERT(d_backing_inode(subdir));
David Howells9ae326a2009-04-03 16:42:41 +0100775
David Howellsce40fa72015-01-29 12:02:36 +0000776 if (!d_can_lookup(subdir)) {
Fabian Frederick6ff66ac2014-09-25 16:05:27 -0700777 pr_err("%s is not a directory\n", dirname);
David Howells9ae326a2009-04-03 16:42:41 +0100778 ret = -EIO;
779 goto check_error;
780 }
781
782 ret = -EPERM;
David Howells466b77b2015-03-17 22:26:21 +0000783 if (!d_backing_inode(subdir)->i_op->setxattr ||
784 !d_backing_inode(subdir)->i_op->getxattr ||
785 !d_backing_inode(subdir)->i_op->lookup ||
786 !d_backing_inode(subdir)->i_op->mkdir ||
787 !d_backing_inode(subdir)->i_op->create ||
788 (!d_backing_inode(subdir)->i_op->rename &&
789 !d_backing_inode(subdir)->i_op->rename2) ||
790 !d_backing_inode(subdir)->i_op->rmdir ||
791 !d_backing_inode(subdir)->i_op->unlink)
David Howells9ae326a2009-04-03 16:42:41 +0100792 goto check_error;
793
David Howells466b77b2015-03-17 22:26:21 +0000794 _leave(" = [%lu]", d_backing_inode(subdir)->i_ino);
David Howells9ae326a2009-04-03 16:42:41 +0100795 return subdir;
796
797check_error:
798 dput(subdir);
799 _leave(" = %d [check]", ret);
800 return ERR_PTR(ret);
801
802mkdir_error:
David Howells5153bc82015-03-06 14:08:58 +0000803 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100804 dput(subdir);
Fabian Frederick6ff66ac2014-09-25 16:05:27 -0700805 pr_err("mkdir %s failed with error %d\n", dirname, ret);
David Howells9ae326a2009-04-03 16:42:41 +0100806 return ERR_PTR(ret);
807
808lookup_error:
David Howells5153bc82015-03-06 14:08:58 +0000809 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100810 ret = PTR_ERR(subdir);
Fabian Frederick6ff66ac2014-09-25 16:05:27 -0700811 pr_err("Lookup %s failed with error %d\n", dirname, ret);
David Howells9ae326a2009-04-03 16:42:41 +0100812 return ERR_PTR(ret);
813
814nomem_d_alloc:
David Howells5153bc82015-03-06 14:08:58 +0000815 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100816 _leave(" = -ENOMEM");
817 return ERR_PTR(-ENOMEM);
818}
819
820/*
821 * find out if an object is in use or not
822 * - if finds object and it's not in use:
823 * - returns a pointer to the object and a reference on it
824 * - returns with the directory locked
825 */
826static struct dentry *cachefiles_check_active(struct cachefiles_cache *cache,
827 struct dentry *dir,
828 char *filename)
829{
830 struct cachefiles_object *object;
831 struct rb_node *_n;
832 struct dentry *victim;
833 unsigned long start;
834 int ret;
835
Al Viroa4555892014-10-21 20:11:25 -0400836 //_enter(",%pd/,%s",
837 // dir, filename);
David Howells9ae326a2009-04-03 16:42:41 +0100838
839 /* look up the victim */
David Howells5153bc82015-03-06 14:08:58 +0000840 mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT);
David Howells9ae326a2009-04-03 16:42:41 +0100841
842 start = jiffies;
843 victim = lookup_one_len(filename, dir, strlen(filename));
844 cachefiles_hist(cachefiles_lookup_histogram, start);
845 if (IS_ERR(victim))
846 goto lookup_error;
847
848 //_debug("victim -> %p %s",
David Howells466b77b2015-03-17 22:26:21 +0000849 // victim, d_backing_inode(victim) ? "positive" : "negative");
David Howells9ae326a2009-04-03 16:42:41 +0100850
851 /* if the object is no longer there then we probably retired the object
852 * at the netfs's request whilst the cull was in progress
853 */
David Howells466b77b2015-03-17 22:26:21 +0000854 if (d_is_negative(victim)) {
David Howells5153bc82015-03-06 14:08:58 +0000855 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100856 dput(victim);
857 _leave(" = -ENOENT [absent]");
858 return ERR_PTR(-ENOENT);
859 }
860
861 /* check to see if we're using this object */
862 read_lock(&cache->active_lock);
863
864 _n = cache->active_nodes.rb_node;
865
866 while (_n) {
867 object = rb_entry(_n, struct cachefiles_object, active_node);
868
869 if (object->dentry > victim)
870 _n = _n->rb_left;
871 else if (object->dentry < victim)
872 _n = _n->rb_right;
873 else
874 goto object_in_use;
875 }
876
877 read_unlock(&cache->active_lock);
878
879 //_leave(" = %p", victim);
880 return victim;
881
882object_in_use:
883 read_unlock(&cache->active_lock);
David Howells5153bc82015-03-06 14:08:58 +0000884 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100885 dput(victim);
886 //_leave(" = -EBUSY [in use]");
887 return ERR_PTR(-EBUSY);
888
889lookup_error:
David Howells5153bc82015-03-06 14:08:58 +0000890 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100891 ret = PTR_ERR(victim);
892 if (ret == -ENOENT) {
893 /* file or dir now absent - probably retired by netfs */
894 _leave(" = -ESTALE [absent]");
895 return ERR_PTR(-ESTALE);
896 }
897
898 if (ret == -EIO) {
899 cachefiles_io_error(cache, "Lookup failed");
900 } else if (ret != -ENOMEM) {
Fabian Frederick6ff66ac2014-09-25 16:05:27 -0700901 pr_err("Internal error: %d\n", ret);
David Howells9ae326a2009-04-03 16:42:41 +0100902 ret = -EIO;
903 }
904
905 _leave(" = %d", ret);
906 return ERR_PTR(ret);
907}
908
909/*
910 * cull an object if it's not in use
911 * - called only by cache manager daemon
912 */
913int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir,
914 char *filename)
915{
916 struct dentry *victim;
917 int ret;
918
Al Viroa4555892014-10-21 20:11:25 -0400919 _enter(",%pd/,%s", dir, filename);
David Howells9ae326a2009-04-03 16:42:41 +0100920
921 victim = cachefiles_check_active(cache, dir, filename);
922 if (IS_ERR(victim))
923 return PTR_ERR(victim);
924
925 _debug("victim -> %p %s",
David Howells466b77b2015-03-17 22:26:21 +0000926 victim, d_backing_inode(victim) ? "positive" : "negative");
David Howells9ae326a2009-04-03 16:42:41 +0100927
928 /* okay... the victim is not being used so we can cull it
929 * - start by marking it as stale
930 */
931 _debug("victim is cullable");
932
933 ret = cachefiles_remove_object_xattr(cache, victim);
934 if (ret < 0)
935 goto error_unlock;
936
937 /* actually remove the victim (drops the dir mutex) */
938 _debug("bury");
939
David Howells182d9192015-02-19 23:47:31 +0000940 ret = cachefiles_bury_object(cache, dir, victim, false,
941 FSCACHE_OBJECT_WAS_CULLED);
David Howells9ae326a2009-04-03 16:42:41 +0100942 if (ret < 0)
943 goto error;
944
945 dput(victim);
946 _leave(" = 0");
947 return 0;
948
949error_unlock:
David Howells5153bc82015-03-06 14:08:58 +0000950 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100951error:
952 dput(victim);
953 if (ret == -ENOENT) {
954 /* file or dir now absent - probably retired by netfs */
955 _leave(" = -ESTALE [absent]");
956 return -ESTALE;
957 }
958
959 if (ret != -ENOMEM) {
Fabian Frederick6ff66ac2014-09-25 16:05:27 -0700960 pr_err("Internal error: %d\n", ret);
David Howells9ae326a2009-04-03 16:42:41 +0100961 ret = -EIO;
962 }
963
964 _leave(" = %d", ret);
965 return ret;
966}
967
968/*
969 * find out if an object is in use or not
970 * - called only by cache manager daemon
971 * - returns -EBUSY or 0 to indicate whether an object is in use or not
972 */
973int cachefiles_check_in_use(struct cachefiles_cache *cache, struct dentry *dir,
974 char *filename)
975{
976 struct dentry *victim;
977
Al Viroa4555892014-10-21 20:11:25 -0400978 //_enter(",%pd/,%s",
979 // dir, filename);
David Howells9ae326a2009-04-03 16:42:41 +0100980
981 victim = cachefiles_check_active(cache, dir, filename);
982 if (IS_ERR(victim))
983 return PTR_ERR(victim);
984
David Howells5153bc82015-03-06 14:08:58 +0000985 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100986 dput(victim);
987 //_leave(" = 0");
988 return 0;
989}