blob: fc1056f5c96a3c750c3c5c9009048b234a7fd745 [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;
658
659 object->backer = object->dentry;
660 } else {
661 BUG(); // TODO: open file in data-class subdir
662 }
663 }
664
665 object->new = 0;
666 fscache_obtained_object(&object->fscache);
667
David Howells466b77b2015-03-17 22:26:21 +0000668 _leave(" = 0 [%lu]", d_backing_inode(object->dentry)->i_ino);
David Howells9ae326a2009-04-03 16:42:41 +0100669 return 0;
670
David Howells182d9192015-02-19 23:47:31 +0000671no_space_error:
672 fscache_object_mark_killed(&object->fscache, FSCACHE_OBJECT_NO_SPACE);
David Howells9ae326a2009-04-03 16:42:41 +0100673create_error:
674 _debug("create error %d", ret);
675 if (ret == -EIO)
676 cachefiles_io_error(cache, "Create/mkdir failed");
677 goto error;
678
David Howellsfee096d2009-11-19 18:12:05 +0000679mark_active_timed_out:
680 _debug("mark active timed out");
681 goto release_dentry;
682
David Howells9ae326a2009-04-03 16:42:41 +0100683check_error:
684 _debug("check error %d", ret);
685 write_lock(&cache->active_lock);
686 rb_erase(&object->active_node, &cache->active_nodes);
687 clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags);
688 wake_up_bit(&object->flags, CACHEFILES_OBJECT_ACTIVE);
689 write_unlock(&cache->active_lock);
David Howellsfee096d2009-11-19 18:12:05 +0000690release_dentry:
David Howells9ae326a2009-04-03 16:42:41 +0100691 dput(object->dentry);
692 object->dentry = NULL;
693 goto error_out;
694
695delete_error:
696 _debug("delete error %d", ret);
697 goto error_out2;
698
699lookup_error:
700 _debug("lookup error %ld", PTR_ERR(next));
701 ret = PTR_ERR(next);
702 if (ret == -EIO)
703 cachefiles_io_error(cache, "Lookup failed");
704 next = NULL;
705error:
David Howells5153bc82015-03-06 14:08:58 +0000706 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100707 dput(next);
708error_out2:
709 dput(dir);
710error_out:
David Howells9ae326a2009-04-03 16:42:41 +0100711 _leave(" = error %d", -ret);
712 return ret;
713}
714
715/*
716 * get a subdirectory
717 */
718struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
719 struct dentry *dir,
720 const char *dirname)
721{
722 struct dentry *subdir;
723 unsigned long start;
David Howells82140442010-12-24 14:48:35 +0000724 struct path path;
David Howells9ae326a2009-04-03 16:42:41 +0100725 int ret;
726
727 _enter(",,%s", dirname);
728
729 /* search the current directory for the element name */
David Howells5153bc82015-03-06 14:08:58 +0000730 mutex_lock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100731
732 start = jiffies;
733 subdir = lookup_one_len(dirname, dir, strlen(dirname));
734 cachefiles_hist(cachefiles_lookup_histogram, start);
735 if (IS_ERR(subdir)) {
736 if (PTR_ERR(subdir) == -ENOMEM)
737 goto nomem_d_alloc;
738 goto lookup_error;
739 }
740
741 _debug("subdir -> %p %s",
David Howells466b77b2015-03-17 22:26:21 +0000742 subdir, d_backing_inode(subdir) ? "positive" : "negative");
David Howells9ae326a2009-04-03 16:42:41 +0100743
744 /* we need to create the subdir if it doesn't exist yet */
David Howells466b77b2015-03-17 22:26:21 +0000745 if (d_is_negative(subdir)) {
David Howells9ae326a2009-04-03 16:42:41 +0100746 ret = cachefiles_has_space(cache, 1, 0);
747 if (ret < 0)
748 goto mkdir_error;
749
750 _debug("attempt mkdir");
751
David Howells82140442010-12-24 14:48:35 +0000752 path.mnt = cache->mnt;
753 path.dentry = dir;
754 ret = security_path_mkdir(&path, subdir, 0700);
755 if (ret < 0)
756 goto mkdir_error;
David Howells5153bc82015-03-06 14:08:58 +0000757 ret = vfs_mkdir(d_inode(dir), subdir, 0700);
David Howells9ae326a2009-04-03 16:42:41 +0100758 if (ret < 0)
759 goto mkdir_error;
760
David Howells466b77b2015-03-17 22:26:21 +0000761 ASSERT(d_backing_inode(subdir));
David Howells9ae326a2009-04-03 16:42:41 +0100762
763 _debug("mkdir -> %p{%p{ino=%lu}}",
764 subdir,
David Howells466b77b2015-03-17 22:26:21 +0000765 d_backing_inode(subdir),
766 d_backing_inode(subdir)->i_ino);
David Howells9ae326a2009-04-03 16:42:41 +0100767 }
768
David Howells5153bc82015-03-06 14:08:58 +0000769 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100770
771 /* we need to make sure the subdir is a directory */
David Howells466b77b2015-03-17 22:26:21 +0000772 ASSERT(d_backing_inode(subdir));
David Howells9ae326a2009-04-03 16:42:41 +0100773
David Howellsce40fa72015-01-29 12:02:36 +0000774 if (!d_can_lookup(subdir)) {
Fabian Frederick6ff66ac2014-09-25 16:05:27 -0700775 pr_err("%s is not a directory\n", dirname);
David Howells9ae326a2009-04-03 16:42:41 +0100776 ret = -EIO;
777 goto check_error;
778 }
779
780 ret = -EPERM;
David Howells466b77b2015-03-17 22:26:21 +0000781 if (!d_backing_inode(subdir)->i_op->setxattr ||
782 !d_backing_inode(subdir)->i_op->getxattr ||
783 !d_backing_inode(subdir)->i_op->lookup ||
784 !d_backing_inode(subdir)->i_op->mkdir ||
785 !d_backing_inode(subdir)->i_op->create ||
786 (!d_backing_inode(subdir)->i_op->rename &&
787 !d_backing_inode(subdir)->i_op->rename2) ||
788 !d_backing_inode(subdir)->i_op->rmdir ||
789 !d_backing_inode(subdir)->i_op->unlink)
David Howells9ae326a2009-04-03 16:42:41 +0100790 goto check_error;
791
David Howells466b77b2015-03-17 22:26:21 +0000792 _leave(" = [%lu]", d_backing_inode(subdir)->i_ino);
David Howells9ae326a2009-04-03 16:42:41 +0100793 return subdir;
794
795check_error:
796 dput(subdir);
797 _leave(" = %d [check]", ret);
798 return ERR_PTR(ret);
799
800mkdir_error:
David Howells5153bc82015-03-06 14:08:58 +0000801 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100802 dput(subdir);
Fabian Frederick6ff66ac2014-09-25 16:05:27 -0700803 pr_err("mkdir %s failed with error %d\n", dirname, ret);
David Howells9ae326a2009-04-03 16:42:41 +0100804 return ERR_PTR(ret);
805
806lookup_error:
David Howells5153bc82015-03-06 14:08:58 +0000807 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100808 ret = PTR_ERR(subdir);
Fabian Frederick6ff66ac2014-09-25 16:05:27 -0700809 pr_err("Lookup %s failed with error %d\n", dirname, ret);
David Howells9ae326a2009-04-03 16:42:41 +0100810 return ERR_PTR(ret);
811
812nomem_d_alloc:
David Howells5153bc82015-03-06 14:08:58 +0000813 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100814 _leave(" = -ENOMEM");
815 return ERR_PTR(-ENOMEM);
816}
817
818/*
819 * find out if an object is in use or not
820 * - if finds object and it's not in use:
821 * - returns a pointer to the object and a reference on it
822 * - returns with the directory locked
823 */
824static struct dentry *cachefiles_check_active(struct cachefiles_cache *cache,
825 struct dentry *dir,
826 char *filename)
827{
828 struct cachefiles_object *object;
829 struct rb_node *_n;
830 struct dentry *victim;
831 unsigned long start;
832 int ret;
833
Al Viroa4555892014-10-21 20:11:25 -0400834 //_enter(",%pd/,%s",
835 // dir, filename);
David Howells9ae326a2009-04-03 16:42:41 +0100836
837 /* look up the victim */
David Howells5153bc82015-03-06 14:08:58 +0000838 mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT);
David Howells9ae326a2009-04-03 16:42:41 +0100839
840 start = jiffies;
841 victim = lookup_one_len(filename, dir, strlen(filename));
842 cachefiles_hist(cachefiles_lookup_histogram, start);
843 if (IS_ERR(victim))
844 goto lookup_error;
845
846 //_debug("victim -> %p %s",
David Howells466b77b2015-03-17 22:26:21 +0000847 // victim, d_backing_inode(victim) ? "positive" : "negative");
David Howells9ae326a2009-04-03 16:42:41 +0100848
849 /* if the object is no longer there then we probably retired the object
850 * at the netfs's request whilst the cull was in progress
851 */
David Howells466b77b2015-03-17 22:26:21 +0000852 if (d_is_negative(victim)) {
David Howells5153bc82015-03-06 14:08:58 +0000853 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100854 dput(victim);
855 _leave(" = -ENOENT [absent]");
856 return ERR_PTR(-ENOENT);
857 }
858
859 /* check to see if we're using this object */
860 read_lock(&cache->active_lock);
861
862 _n = cache->active_nodes.rb_node;
863
864 while (_n) {
865 object = rb_entry(_n, struct cachefiles_object, active_node);
866
867 if (object->dentry > victim)
868 _n = _n->rb_left;
869 else if (object->dentry < victim)
870 _n = _n->rb_right;
871 else
872 goto object_in_use;
873 }
874
875 read_unlock(&cache->active_lock);
876
877 //_leave(" = %p", victim);
878 return victim;
879
880object_in_use:
881 read_unlock(&cache->active_lock);
David Howells5153bc82015-03-06 14:08:58 +0000882 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100883 dput(victim);
884 //_leave(" = -EBUSY [in use]");
885 return ERR_PTR(-EBUSY);
886
887lookup_error:
David Howells5153bc82015-03-06 14:08:58 +0000888 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100889 ret = PTR_ERR(victim);
890 if (ret == -ENOENT) {
891 /* file or dir now absent - probably retired by netfs */
892 _leave(" = -ESTALE [absent]");
893 return ERR_PTR(-ESTALE);
894 }
895
896 if (ret == -EIO) {
897 cachefiles_io_error(cache, "Lookup failed");
898 } else if (ret != -ENOMEM) {
Fabian Frederick6ff66ac2014-09-25 16:05:27 -0700899 pr_err("Internal error: %d\n", ret);
David Howells9ae326a2009-04-03 16:42:41 +0100900 ret = -EIO;
901 }
902
903 _leave(" = %d", ret);
904 return ERR_PTR(ret);
905}
906
907/*
908 * cull an object if it's not in use
909 * - called only by cache manager daemon
910 */
911int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir,
912 char *filename)
913{
914 struct dentry *victim;
915 int ret;
916
Al Viroa4555892014-10-21 20:11:25 -0400917 _enter(",%pd/,%s", dir, filename);
David Howells9ae326a2009-04-03 16:42:41 +0100918
919 victim = cachefiles_check_active(cache, dir, filename);
920 if (IS_ERR(victim))
921 return PTR_ERR(victim);
922
923 _debug("victim -> %p %s",
David Howells466b77b2015-03-17 22:26:21 +0000924 victim, d_backing_inode(victim) ? "positive" : "negative");
David Howells9ae326a2009-04-03 16:42:41 +0100925
926 /* okay... the victim is not being used so we can cull it
927 * - start by marking it as stale
928 */
929 _debug("victim is cullable");
930
931 ret = cachefiles_remove_object_xattr(cache, victim);
932 if (ret < 0)
933 goto error_unlock;
934
935 /* actually remove the victim (drops the dir mutex) */
936 _debug("bury");
937
David Howells182d9192015-02-19 23:47:31 +0000938 ret = cachefiles_bury_object(cache, dir, victim, false,
939 FSCACHE_OBJECT_WAS_CULLED);
David Howells9ae326a2009-04-03 16:42:41 +0100940 if (ret < 0)
941 goto error;
942
943 dput(victim);
944 _leave(" = 0");
945 return 0;
946
947error_unlock:
David Howells5153bc82015-03-06 14:08:58 +0000948 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100949error:
950 dput(victim);
951 if (ret == -ENOENT) {
952 /* file or dir now absent - probably retired by netfs */
953 _leave(" = -ESTALE [absent]");
954 return -ESTALE;
955 }
956
957 if (ret != -ENOMEM) {
Fabian Frederick6ff66ac2014-09-25 16:05:27 -0700958 pr_err("Internal error: %d\n", ret);
David Howells9ae326a2009-04-03 16:42:41 +0100959 ret = -EIO;
960 }
961
962 _leave(" = %d", ret);
963 return ret;
964}
965
966/*
967 * find out if an object is in use or not
968 * - called only by cache manager daemon
969 * - returns -EBUSY or 0 to indicate whether an object is in use or not
970 */
971int cachefiles_check_in_use(struct cachefiles_cache *cache, struct dentry *dir,
972 char *filename)
973{
974 struct dentry *victim;
975
Al Viroa4555892014-10-21 20:11:25 -0400976 //_enter(",%pd/,%s",
977 // dir, filename);
David Howells9ae326a2009-04-03 16:42:41 +0100978
979 victim = cachefiles_check_active(cache, dir, filename);
980 if (IS_ERR(victim))
981 return PTR_ERR(victim);
982
David Howells5153bc82015-03-06 14:08:58 +0000983 mutex_unlock(&d_inode(dir)->i_mutex);
David Howells9ae326a2009-04-03 16:42:41 +0100984 dput(victim);
985 //_leave(" = 0");
986 return 0;
987}