blob: 5bf2b41e66d392d0b013a140648c1768bc62b5fd [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,
100 struct dentry *dentry)
101{
102 struct cachefiles_object *object;
103 struct rb_node *p;
104
105 _enter(",'%*.*s'",
106 dentry->d_name.len, dentry->d_name.len, dentry->d_name.name);
107
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);
136 } else if (test_and_set_bit(CACHEFILES_OBJECT_BURIED, &object->flags)) {
Fabian Frederick0227d6ab2014-06-06 14:37:33 -0700137 pr_err("Error: Object already preemptively buried\n");
David Howellsc61ea312010-05-11 16:51:39 +0100138 }
139
140 write_unlock(&cache->active_lock);
141 _leave(" [owner marked]");
142}
143
144/*
David Howells9ae326a2009-04-03 16:42:41 +0100145 * record the fact that an object is now active
146 */
David Howellsfee096d2009-11-19 18:12:05 +0000147static int cachefiles_mark_object_active(struct cachefiles_cache *cache,
148 struct cachefiles_object *object)
David Howells9ae326a2009-04-03 16:42:41 +0100149{
150 struct cachefiles_object *xobject;
151 struct rb_node **_p, *_parent = NULL;
152 struct dentry *dentry;
153
154 _enter(",%p", object);
155
156try_again:
157 write_lock(&cache->active_lock);
158
David Howellsd0e27b72009-11-19 18:12:02 +0000159 if (test_and_set_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags)) {
Fabian Frederick0227d6ab2014-06-06 14:37:33 -0700160 pr_err("Error: Object already active\n");
David Howellsd0e27b72009-11-19 18:12:02 +0000161 cachefiles_printk_object(object, NULL);
David Howells9ae326a2009-04-03 16:42:41 +0100162 BUG();
David Howellsd0e27b72009-11-19 18:12:02 +0000163 }
David Howells9ae326a2009-04-03 16:42:41 +0100164
165 dentry = object->dentry;
166 _p = &cache->active_nodes.rb_node;
167 while (*_p) {
168 _parent = *_p;
169 xobject = rb_entry(_parent,
170 struct cachefiles_object, active_node);
171
172 ASSERT(xobject != object);
173
174 if (xobject->dentry > dentry)
175 _p = &(*_p)->rb_left;
176 else if (xobject->dentry < dentry)
177 _p = &(*_p)->rb_right;
178 else
179 goto wait_for_old_object;
180 }
181
182 rb_link_node(&object->active_node, _parent, _p);
183 rb_insert_color(&object->active_node, &cache->active_nodes);
184
185 write_unlock(&cache->active_lock);
David Howellsfee096d2009-11-19 18:12:05 +0000186 _leave(" = 0");
187 return 0;
David Howells9ae326a2009-04-03 16:42:41 +0100188
189 /* an old object from a previous incarnation is hogging the slot - we
190 * need to wait for it to be destroyed */
191wait_for_old_object:
David Howells493f7bc2013-05-10 19:50:26 +0100192 if (fscache_object_is_live(&object->fscache)) {
Fabian Frederick4e1eb882014-06-06 14:37:32 -0700193 pr_err("\n");
Fabian Frederick0227d6ab2014-06-06 14:37:33 -0700194 pr_err("Error: Unexpected object collision\n");
David Howellsd0e27b72009-11-19 18:12:02 +0000195 cachefiles_printk_object(object, xobject);
David Howells9ae326a2009-04-03 16:42:41 +0100196 BUG();
197 }
198 atomic_inc(&xobject->usage);
199 write_unlock(&cache->active_lock);
200
David Howellsfee096d2009-11-19 18:12:05 +0000201 if (test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags)) {
202 wait_queue_head_t *wq;
203
204 signed long timeout = 60 * HZ;
205 wait_queue_t wait;
206 bool requeue;
207
208 /* if the object we're waiting for is queued for processing,
209 * then just put ourselves on the queue behind it */
Tejun Heo8b8edef2010-07-20 22:09:01 +0200210 if (work_pending(&xobject->fscache.work)) {
David Howellsfee096d2009-11-19 18:12:05 +0000211 _debug("queue OBJ%x behind OBJ%x immediately",
212 object->fscache.debug_id,
213 xobject->fscache.debug_id);
214 goto requeue;
215 }
216
217 /* otherwise we sleep until either the object we're waiting for
Tejun Heo8b8edef2010-07-20 22:09:01 +0200218 * is done, or the fscache_object is congested */
David Howellsfee096d2009-11-19 18:12:05 +0000219 wq = bit_waitqueue(&xobject->flags, CACHEFILES_OBJECT_ACTIVE);
220 init_wait(&wait);
221 requeue = false;
222 do {
223 prepare_to_wait(wq, &wait, TASK_UNINTERRUPTIBLE);
224 if (!test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags))
225 break;
Tejun Heo8b8edef2010-07-20 22:09:01 +0200226
227 requeue = fscache_object_sleep_till_congested(&timeout);
David Howellsfee096d2009-11-19 18:12:05 +0000228 } while (timeout > 0 && !requeue);
229 finish_wait(wq, &wait);
230
231 if (requeue &&
232 test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags)) {
233 _debug("queue OBJ%x behind OBJ%x after wait",
234 object->fscache.debug_id,
235 xobject->fscache.debug_id);
236 goto requeue;
237 }
238
239 if (timeout <= 0) {
Fabian Frederick4e1eb882014-06-06 14:37:32 -0700240 pr_err("\n");
Fabian Frederick0227d6ab2014-06-06 14:37:33 -0700241 pr_err("Error: Overlong wait for old active object to go away\n");
David Howellsfee096d2009-11-19 18:12:05 +0000242 cachefiles_printk_object(object, xobject);
243 goto requeue;
244 }
245 }
246
247 ASSERT(!test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags));
David Howells9ae326a2009-04-03 16:42:41 +0100248
249 cache->cache.ops->put_object(&xobject->fscache);
250 goto try_again;
David Howellsfee096d2009-11-19 18:12:05 +0000251
252requeue:
253 clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags);
254 cache->cache.ops->put_object(&xobject->fscache);
255 _leave(" = -ETIMEDOUT");
256 return -ETIMEDOUT;
David Howells9ae326a2009-04-03 16:42:41 +0100257}
258
259/*
260 * delete an object representation from the cache
261 * - file backed objects are unlinked
262 * - directory backed objects are stuffed into the graveyard for userspace to
263 * delete
264 * - unlocks the directory mutex
265 */
266static int cachefiles_bury_object(struct cachefiles_cache *cache,
267 struct dentry *dir,
David Howellsc61ea312010-05-11 16:51:39 +0100268 struct dentry *rep,
269 bool preemptive)
David Howells9ae326a2009-04-03 16:42:41 +0100270{
271 struct dentry *grave, *trap;
David Howells82140442010-12-24 14:48:35 +0000272 struct path path, path_to_graveyard;
David Howells9ae326a2009-04-03 16:42:41 +0100273 char nbuffer[8 + 8 + 1];
274 int ret;
275
276 _enter(",'%*.*s','%*.*s'",
277 dir->d_name.len, dir->d_name.len, dir->d_name.name,
278 rep->d_name.len, rep->d_name.len, rep->d_name.name);
279
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 */
283 if (!S_ISDIR(rep->d_inode->i_mode)) {
284 _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 {
J. Bruce Fieldsb21996e2011-09-20 09:14:34 -0400292 ret = vfs_unlink(dir->d_inode, rep, NULL);
David Howells82140442010-12-24 14:48:35 +0000293
294 if (preemptive)
295 cachefiles_mark_object_buried(cache, rep);
296 }
David Howellsc61ea312010-05-11 16:51:39 +0100297
David Howells9ae326a2009-04-03 16:42:41 +0100298 mutex_unlock(&dir->d_inode->i_mutex);
299
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");
309 mutex_unlock(&dir->d_inode->i_mutex);
310
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
329 if (!S_ISDIR(cache->graveyard->d_inode->i_mode)) {
330 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
361 if (grave->d_inode) {
362 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 {
393 ret = vfs_rename(dir->d_inode, rep,
Miklos Szeredi520c8b12014-04-01 17:08:42 +0200394 cache->graveyard->d_inode, 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)
400 cachefiles_mark_object_buried(cache, rep);
401 }
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);
421 ASSERT(object->dentry->d_inode);
422 ASSERT(object->dentry->d_parent);
423
424 dir = dget_parent(object->dentry);
425
David Howells6511de32009-11-19 18:11:58 +0000426 mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
David Howells8f9941a2010-02-19 18:14:21 +0000427
David Howellsc61ea312010-05-11 16:51:39 +0100428 if (test_bit(CACHEFILES_OBJECT_BURIED, &object->flags)) {
429 /* 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 Howells8f9941a2010-02-19 18:14:21 +0000432 mutex_unlock(&dir->d_inode->i_mutex);
433 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,
439 object->dentry, false);
440 } else {
441 /* it got moved, presumably by cachefilesd culling it,
442 * so it's no longer in the key path and we can ignore
443 * it */
444 mutex_unlock(&dir->d_inode->i_mutex);
445 ret = 0;
446 }
David Howells8f9941a2010-02-19 18:14:21 +0000447 }
David Howells9ae326a2009-04-03 16:42:41 +0100448
449 dput(dir);
450 _leave(" = %d", ret);
451 return ret;
452}
453
454/*
455 * walk from the parent object to the child object through the backing
456 * filesystem, creating directories as we go
457 */
458int cachefiles_walk_to_object(struct cachefiles_object *parent,
459 struct cachefiles_object *object,
460 const char *key,
461 struct cachefiles_xattr *auxdata)
462{
463 struct cachefiles_cache *cache;
464 struct dentry *dir, *next = NULL;
David Howells82140442010-12-24 14:48:35 +0000465 struct path path;
David Howells9ae326a2009-04-03 16:42:41 +0100466 unsigned long start;
467 const char *name;
468 int ret, nlen;
469
David Howellsc61ea312010-05-11 16:51:39 +0100470 _enter("OBJ%x{%p},OBJ%x,%s,",
471 parent->fscache.debug_id, parent->dentry,
472 object->fscache.debug_id, key);
David Howells9ae326a2009-04-03 16:42:41 +0100473
474 cache = container_of(parent->fscache.cache,
475 struct cachefiles_cache, cache);
David Howells82140442010-12-24 14:48:35 +0000476 path.mnt = cache->mnt;
David Howells9ae326a2009-04-03 16:42:41 +0100477
478 ASSERT(parent->dentry);
479 ASSERT(parent->dentry->d_inode);
480
481 if (!(S_ISDIR(parent->dentry->d_inode->i_mode))) {
482 // TODO: convert file to dir
483 _leave("looking up in none directory");
484 return -ENOBUFS;
485 }
486
487 dir = dget(parent->dentry);
488
489advance:
490 /* attempt to transit the first directory component */
491 name = key;
492 nlen = strlen(key);
493
494 /* key ends in a double NUL */
495 key = key + nlen + 1;
496 if (!*key)
497 key = NULL;
498
499lookup_again:
500 /* search the current directory for the element name */
501 _debug("lookup '%s'", name);
502
David Howells6511de32009-11-19 18:11:58 +0000503 mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
David Howells9ae326a2009-04-03 16:42:41 +0100504
505 start = jiffies;
506 next = lookup_one_len(name, dir, nlen);
507 cachefiles_hist(cachefiles_lookup_histogram, start);
508 if (IS_ERR(next))
509 goto lookup_error;
510
511 _debug("next -> %p %s", next, next->d_inode ? "positive" : "negative");
512
513 if (!key)
514 object->new = !next->d_inode;
515
516 /* if this element of the path doesn't exist, then the lookup phase
517 * failed, and we can release any readers in the certain knowledge that
518 * there's nothing for them to actually read */
519 if (!next->d_inode)
520 fscache_object_lookup_negative(&object->fscache);
521
522 /* we need to create the object if it's negative */
523 if (key || object->type == FSCACHE_COOKIE_TYPE_INDEX) {
524 /* index objects and intervening tree levels must be subdirs */
525 if (!next->d_inode) {
526 ret = cachefiles_has_space(cache, 1, 0);
527 if (ret < 0)
528 goto create_error;
529
David Howells82140442010-12-24 14:48:35 +0000530 path.dentry = dir;
531 ret = security_path_mkdir(&path, next, 0);
532 if (ret < 0)
533 goto create_error;
David Howells9ae326a2009-04-03 16:42:41 +0100534 start = jiffies;
535 ret = vfs_mkdir(dir->d_inode, next, 0);
536 cachefiles_hist(cachefiles_mkdir_histogram, start);
537 if (ret < 0)
538 goto create_error;
539
540 ASSERT(next->d_inode);
541
542 _debug("mkdir -> %p{%p{ino=%lu}}",
543 next, next->d_inode, next->d_inode->i_ino);
544
545 } else if (!S_ISDIR(next->d_inode->i_mode)) {
Fabian Frederick0227d6ab2014-06-06 14:37:33 -0700546 pr_err("inode %lu is not a directory",
David Howells9ae326a2009-04-03 16:42:41 +0100547 next->d_inode->i_ino);
548 ret = -ENOBUFS;
549 goto error;
550 }
551
552 } else {
553 /* non-index objects start out life as files */
554 if (!next->d_inode) {
555 ret = cachefiles_has_space(cache, 1, 0);
556 if (ret < 0)
557 goto create_error;
558
David Howells82140442010-12-24 14:48:35 +0000559 path.dentry = dir;
560 ret = security_path_mknod(&path, next, S_IFREG, 0);
561 if (ret < 0)
562 goto create_error;
David Howells9ae326a2009-04-03 16:42:41 +0100563 start = jiffies;
Al Viro312b63f2012-06-10 18:09:36 -0400564 ret = vfs_create(dir->d_inode, next, S_IFREG, true);
David Howells9ae326a2009-04-03 16:42:41 +0100565 cachefiles_hist(cachefiles_create_histogram, start);
566 if (ret < 0)
567 goto create_error;
568
569 ASSERT(next->d_inode);
570
571 _debug("create -> %p{%p{ino=%lu}}",
572 next, next->d_inode, next->d_inode->i_ino);
573
574 } else if (!S_ISDIR(next->d_inode->i_mode) &&
575 !S_ISREG(next->d_inode->i_mode)
576 ) {
Fabian Frederick0227d6ab2014-06-06 14:37:33 -0700577 pr_err("inode %lu is not a file or directory",
David Howells9ae326a2009-04-03 16:42:41 +0100578 next->d_inode->i_ino);
579 ret = -ENOBUFS;
580 goto error;
581 }
582 }
583
584 /* process the next component */
585 if (key) {
586 _debug("advance");
587 mutex_unlock(&dir->d_inode->i_mutex);
588 dput(dir);
589 dir = next;
590 next = NULL;
591 goto advance;
592 }
593
594 /* we've found the object we were looking for */
595 object->dentry = next;
596
597 /* if we've found that the terminal object exists, then we need to
598 * check its attributes and delete it if it's out of date */
599 if (!object->new) {
600 _debug("validate '%*.*s'",
601 next->d_name.len, next->d_name.len, next->d_name.name);
602
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 Howellsc61ea312010-05-11 16:51:39 +0100609 ret = cachefiles_bury_object(cache, dir, next, true);
David Howells9ae326a2009-04-03 16:42:41 +0100610 dput(next);
611 next = NULL;
612
613 if (ret < 0)
614 goto delete_error;
615
616 _debug("redo lookup");
617 goto lookup_again;
618 }
619 }
620
621 /* note that we're now using this object */
David Howellsfee096d2009-11-19 18:12:05 +0000622 ret = cachefiles_mark_object_active(cache, object);
David Howells9ae326a2009-04-03 16:42:41 +0100623
624 mutex_unlock(&dir->d_inode->i_mutex);
625 dput(dir);
626 dir = NULL;
627
David Howellsfee096d2009-11-19 18:12:05 +0000628 if (ret == -ETIMEDOUT)
629 goto mark_active_timed_out;
630
David Howells9ae326a2009-04-03 16:42:41 +0100631 _debug("=== OBTAINED_OBJECT ===");
632
633 if (object->new) {
634 /* attach data to a newly constructed terminal object */
635 ret = cachefiles_set_object_xattr(object, auxdata);
636 if (ret < 0)
637 goto check_error;
638 } else {
639 /* always update the atime on an object we've just looked up
640 * (this is used to keep track of culling, and atimes are only
641 * updated by read, write and readdir but not lookup or
642 * open) */
Al Viro68ac1232012-03-15 08:21:57 -0400643 path.dentry = next;
644 touch_atime(&path);
David Howells9ae326a2009-04-03 16:42:41 +0100645 }
646
647 /* open a file interface onto a data file */
648 if (object->type != FSCACHE_COOKIE_TYPE_INDEX) {
649 if (S_ISREG(object->dentry->d_inode->i_mode)) {
650 const struct address_space_operations *aops;
651
652 ret = -EPERM;
653 aops = object->dentry->d_inode->i_mapping->a_ops;
654 if (!aops->bmap)
655 goto check_error;
656
657 object->backer = object->dentry;
658 } else {
659 BUG(); // TODO: open file in data-class subdir
660 }
661 }
662
663 object->new = 0;
664 fscache_obtained_object(&object->fscache);
665
666 _leave(" = 0 [%lu]", object->dentry->d_inode->i_ino);
667 return 0;
668
669create_error:
670 _debug("create error %d", ret);
671 if (ret == -EIO)
672 cachefiles_io_error(cache, "Create/mkdir failed");
673 goto error;
674
David Howellsfee096d2009-11-19 18:12:05 +0000675mark_active_timed_out:
676 _debug("mark active timed out");
677 goto release_dentry;
678
David Howells9ae326a2009-04-03 16:42:41 +0100679check_error:
680 _debug("check error %d", ret);
681 write_lock(&cache->active_lock);
682 rb_erase(&object->active_node, &cache->active_nodes);
683 clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags);
684 wake_up_bit(&object->flags, CACHEFILES_OBJECT_ACTIVE);
685 write_unlock(&cache->active_lock);
David Howellsfee096d2009-11-19 18:12:05 +0000686release_dentry:
David Howells9ae326a2009-04-03 16:42:41 +0100687 dput(object->dentry);
688 object->dentry = NULL;
689 goto error_out;
690
691delete_error:
692 _debug("delete error %d", ret);
693 goto error_out2;
694
695lookup_error:
696 _debug("lookup error %ld", PTR_ERR(next));
697 ret = PTR_ERR(next);
698 if (ret == -EIO)
699 cachefiles_io_error(cache, "Lookup failed");
700 next = NULL;
701error:
702 mutex_unlock(&dir->d_inode->i_mutex);
703 dput(next);
704error_out2:
705 dput(dir);
706error_out:
David Howells9ae326a2009-04-03 16:42:41 +0100707 _leave(" = error %d", -ret);
708 return ret;
709}
710
711/*
712 * get a subdirectory
713 */
714struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
715 struct dentry *dir,
716 const char *dirname)
717{
718 struct dentry *subdir;
719 unsigned long start;
David Howells82140442010-12-24 14:48:35 +0000720 struct path path;
David Howells9ae326a2009-04-03 16:42:41 +0100721 int ret;
722
723 _enter(",,%s", dirname);
724
725 /* search the current directory for the element name */
726 mutex_lock(&dir->d_inode->i_mutex);
727
728 start = jiffies;
729 subdir = lookup_one_len(dirname, dir, strlen(dirname));
730 cachefiles_hist(cachefiles_lookup_histogram, start);
731 if (IS_ERR(subdir)) {
732 if (PTR_ERR(subdir) == -ENOMEM)
733 goto nomem_d_alloc;
734 goto lookup_error;
735 }
736
737 _debug("subdir -> %p %s",
738 subdir, subdir->d_inode ? "positive" : "negative");
739
740 /* we need to create the subdir if it doesn't exist yet */
741 if (!subdir->d_inode) {
742 ret = cachefiles_has_space(cache, 1, 0);
743 if (ret < 0)
744 goto mkdir_error;
745
746 _debug("attempt mkdir");
747
David Howells82140442010-12-24 14:48:35 +0000748 path.mnt = cache->mnt;
749 path.dentry = dir;
750 ret = security_path_mkdir(&path, subdir, 0700);
751 if (ret < 0)
752 goto mkdir_error;
David Howells9ae326a2009-04-03 16:42:41 +0100753 ret = vfs_mkdir(dir->d_inode, subdir, 0700);
754 if (ret < 0)
755 goto mkdir_error;
756
757 ASSERT(subdir->d_inode);
758
759 _debug("mkdir -> %p{%p{ino=%lu}}",
760 subdir,
761 subdir->d_inode,
762 subdir->d_inode->i_ino);
763 }
764
765 mutex_unlock(&dir->d_inode->i_mutex);
766
767 /* we need to make sure the subdir is a directory */
768 ASSERT(subdir->d_inode);
769
770 if (!S_ISDIR(subdir->d_inode->i_mode)) {
Fabian Frederick0227d6ab2014-06-06 14:37:33 -0700771 pr_err("%s is not a directory", dirname);
David Howells9ae326a2009-04-03 16:42:41 +0100772 ret = -EIO;
773 goto check_error;
774 }
775
776 ret = -EPERM;
Al Viro627bf812014-02-01 04:43:32 -0500777 if (!subdir->d_inode->i_op->setxattr ||
David Howells9ae326a2009-04-03 16:42:41 +0100778 !subdir->d_inode->i_op->getxattr ||
779 !subdir->d_inode->i_op->lookup ||
780 !subdir->d_inode->i_op->mkdir ||
781 !subdir->d_inode->i_op->create ||
782 !subdir->d_inode->i_op->rename ||
783 !subdir->d_inode->i_op->rmdir ||
784 !subdir->d_inode->i_op->unlink)
785 goto check_error;
786
787 _leave(" = [%lu]", subdir->d_inode->i_ino);
788 return subdir;
789
790check_error:
791 dput(subdir);
792 _leave(" = %d [check]", ret);
793 return ERR_PTR(ret);
794
795mkdir_error:
796 mutex_unlock(&dir->d_inode->i_mutex);
797 dput(subdir);
Fabian Frederick0227d6ab2014-06-06 14:37:33 -0700798 pr_err("mkdir %s failed with error %d", dirname, ret);
David Howells9ae326a2009-04-03 16:42:41 +0100799 return ERR_PTR(ret);
800
801lookup_error:
802 mutex_unlock(&dir->d_inode->i_mutex);
803 ret = PTR_ERR(subdir);
Fabian Frederick0227d6ab2014-06-06 14:37:33 -0700804 pr_err("Lookup %s failed with error %d", dirname, ret);
David Howells9ae326a2009-04-03 16:42:41 +0100805 return ERR_PTR(ret);
806
807nomem_d_alloc:
808 mutex_unlock(&dir->d_inode->i_mutex);
809 _leave(" = -ENOMEM");
810 return ERR_PTR(-ENOMEM);
811}
812
813/*
814 * find out if an object is in use or not
815 * - if finds object and it's not in use:
816 * - returns a pointer to the object and a reference on it
817 * - returns with the directory locked
818 */
819static struct dentry *cachefiles_check_active(struct cachefiles_cache *cache,
820 struct dentry *dir,
821 char *filename)
822{
823 struct cachefiles_object *object;
824 struct rb_node *_n;
825 struct dentry *victim;
826 unsigned long start;
827 int ret;
828
829 //_enter(",%*.*s/,%s",
830 // dir->d_name.len, dir->d_name.len, dir->d_name.name, filename);
831
832 /* look up the victim */
J. Bruce Fields6bd5e822013-05-10 19:50:25 +0100833 mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
David Howells9ae326a2009-04-03 16:42:41 +0100834
835 start = jiffies;
836 victim = lookup_one_len(filename, dir, strlen(filename));
837 cachefiles_hist(cachefiles_lookup_histogram, start);
838 if (IS_ERR(victim))
839 goto lookup_error;
840
841 //_debug("victim -> %p %s",
842 // victim, victim->d_inode ? "positive" : "negative");
843
844 /* if the object is no longer there then we probably retired the object
845 * at the netfs's request whilst the cull was in progress
846 */
847 if (!victim->d_inode) {
848 mutex_unlock(&dir->d_inode->i_mutex);
849 dput(victim);
850 _leave(" = -ENOENT [absent]");
851 return ERR_PTR(-ENOENT);
852 }
853
854 /* check to see if we're using this object */
855 read_lock(&cache->active_lock);
856
857 _n = cache->active_nodes.rb_node;
858
859 while (_n) {
860 object = rb_entry(_n, struct cachefiles_object, active_node);
861
862 if (object->dentry > victim)
863 _n = _n->rb_left;
864 else if (object->dentry < victim)
865 _n = _n->rb_right;
866 else
867 goto object_in_use;
868 }
869
870 read_unlock(&cache->active_lock);
871
872 //_leave(" = %p", victim);
873 return victim;
874
875object_in_use:
876 read_unlock(&cache->active_lock);
877 mutex_unlock(&dir->d_inode->i_mutex);
878 dput(victim);
879 //_leave(" = -EBUSY [in use]");
880 return ERR_PTR(-EBUSY);
881
882lookup_error:
883 mutex_unlock(&dir->d_inode->i_mutex);
884 ret = PTR_ERR(victim);
885 if (ret == -ENOENT) {
886 /* file or dir now absent - probably retired by netfs */
887 _leave(" = -ESTALE [absent]");
888 return ERR_PTR(-ESTALE);
889 }
890
891 if (ret == -EIO) {
892 cachefiles_io_error(cache, "Lookup failed");
893 } else if (ret != -ENOMEM) {
Fabian Frederick0227d6ab2014-06-06 14:37:33 -0700894 pr_err("Internal error: %d", ret);
David Howells9ae326a2009-04-03 16:42:41 +0100895 ret = -EIO;
896 }
897
898 _leave(" = %d", ret);
899 return ERR_PTR(ret);
900}
901
902/*
903 * cull an object if it's not in use
904 * - called only by cache manager daemon
905 */
906int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir,
907 char *filename)
908{
909 struct dentry *victim;
910 int ret;
911
912 _enter(",%*.*s/,%s",
913 dir->d_name.len, dir->d_name.len, dir->d_name.name, filename);
914
915 victim = cachefiles_check_active(cache, dir, filename);
916 if (IS_ERR(victim))
917 return PTR_ERR(victim);
918
919 _debug("victim -> %p %s",
920 victim, victim->d_inode ? "positive" : "negative");
921
922 /* okay... the victim is not being used so we can cull it
923 * - start by marking it as stale
924 */
925 _debug("victim is cullable");
926
927 ret = cachefiles_remove_object_xattr(cache, victim);
928 if (ret < 0)
929 goto error_unlock;
930
931 /* actually remove the victim (drops the dir mutex) */
932 _debug("bury");
933
David Howellsc61ea312010-05-11 16:51:39 +0100934 ret = cachefiles_bury_object(cache, dir, victim, false);
David Howells9ae326a2009-04-03 16:42:41 +0100935 if (ret < 0)
936 goto error;
937
938 dput(victim);
939 _leave(" = 0");
940 return 0;
941
942error_unlock:
943 mutex_unlock(&dir->d_inode->i_mutex);
944error:
945 dput(victim);
946 if (ret == -ENOENT) {
947 /* file or dir now absent - probably retired by netfs */
948 _leave(" = -ESTALE [absent]");
949 return -ESTALE;
950 }
951
952 if (ret != -ENOMEM) {
Fabian Frederick0227d6ab2014-06-06 14:37:33 -0700953 pr_err("Internal error: %d", ret);
David Howells9ae326a2009-04-03 16:42:41 +0100954 ret = -EIO;
955 }
956
957 _leave(" = %d", ret);
958 return ret;
959}
960
961/*
962 * find out if an object is in use or not
963 * - called only by cache manager daemon
964 * - returns -EBUSY or 0 to indicate whether an object is in use or not
965 */
966int cachefiles_check_in_use(struct cachefiles_cache *cache, struct dentry *dir,
967 char *filename)
968{
969 struct dentry *victim;
970
971 //_enter(",%*.*s/,%s",
972 // dir->d_name.len, dir->d_name.len, dir->d_name.name, filename);
973
974 victim = cachefiles_check_active(cache, dir, filename);
975 if (IS_ERR(victim))
976 return PTR_ERR(victim);
977
978 mutex_unlock(&dir->d_inode->i_mutex);
979 dput(victim);
980 //_leave(" = 0");
981 return 0;
982}