David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 1 | /* 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 Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 22 | #include <linux/slab.h> |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 23 | #include "internal.h" |
| 24 | |
David Howells | d0e27b7 | 2009-11-19 18:12:02 +0000 | [diff] [blame] | 25 | #define CACHEFILES_KEYBUF_SIZE 512 |
| 26 | |
| 27 | /* |
| 28 | * dump debugging info about an object |
| 29 | */ |
| 30 | static noinline |
| 31 | void __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 | |
| 38 | printk(KERN_ERR "%sobject: OBJ%x\n", |
| 39 | prefix, object->fscache.debug_id); |
Tejun Heo | 8b8edef | 2010-07-20 22:09:01 +0200 | [diff] [blame] | 40 | printk(KERN_ERR "%sobjstate=%s fl=%lx wbusy=%x ev=%lx[%lx]\n", |
David Howells | caaef69 | 2013-05-10 19:50:26 +0100 | [diff] [blame] | 41 | prefix, object->fscache.state->name, |
Tejun Heo | 8b8edef | 2010-07-20 22:09:01 +0200 | [diff] [blame] | 42 | object->fscache.flags, work_busy(&object->fscache.work), |
David Howells | c2d35bf | 2012-12-05 13:34:47 +0000 | [diff] [blame] | 43 | object->fscache.events, object->fscache.event_mask); |
David Howells | d0e27b7 | 2009-11-19 18:12:02 +0000 | [diff] [blame] | 44 | printk(KERN_ERR "%sops=%u inp=%u exc=%u\n", |
| 45 | prefix, object->fscache.n_ops, object->fscache.n_in_progress, |
| 46 | object->fscache.n_exclusive); |
| 47 | printk(KERN_ERR "%sparent=%p\n", |
| 48 | prefix, object->fscache.parent); |
| 49 | |
| 50 | spin_lock(&object->fscache.lock); |
| 51 | cookie = object->fscache.cookie; |
| 52 | if (cookie) { |
| 53 | printk(KERN_ERR "%scookie=%p [pr=%p nd=%p fl=%lx]\n", |
| 54 | prefix, |
| 55 | object->fscache.cookie, |
| 56 | object->fscache.cookie->parent, |
| 57 | object->fscache.cookie->netfs_data, |
| 58 | object->fscache.cookie->flags); |
David Howells | 509bf24 | 2013-09-20 14:18:00 +0100 | [diff] [blame] | 59 | if (keybuf && cookie->def) |
David Howells | d0e27b7 | 2009-11-19 18:12:02 +0000 | [diff] [blame] | 60 | keylen = cookie->def->get_key(cookie->netfs_data, keybuf, |
| 61 | CACHEFILES_KEYBUF_SIZE); |
| 62 | else |
| 63 | keylen = 0; |
| 64 | } else { |
| 65 | printk(KERN_ERR "%scookie=NULL\n", prefix); |
| 66 | keylen = 0; |
| 67 | } |
| 68 | spin_unlock(&object->fscache.lock); |
| 69 | |
| 70 | if (keylen) { |
| 71 | printk(KERN_ERR "%skey=[%u] '", prefix, keylen); |
| 72 | for (loop = 0; loop < keylen; loop++) |
| 73 | printk("%02x", keybuf[loop]); |
| 74 | printk("'\n"); |
| 75 | } |
| 76 | } |
| 77 | |
| 78 | /* |
| 79 | * dump debugging info about a pair of objects |
| 80 | */ |
| 81 | static noinline void cachefiles_printk_object(struct cachefiles_object *object, |
| 82 | struct cachefiles_object *xobject) |
| 83 | { |
| 84 | u8 *keybuf; |
| 85 | |
| 86 | keybuf = kmalloc(CACHEFILES_KEYBUF_SIZE, GFP_NOIO); |
| 87 | if (object) |
| 88 | __cachefiles_printk_object(object, "", keybuf); |
| 89 | if (xobject) |
| 90 | __cachefiles_printk_object(xobject, "x", keybuf); |
| 91 | kfree(keybuf); |
| 92 | } |
| 93 | |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 94 | /* |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 95 | * mark the owner of a dentry, if there is one, to indicate that that dentry |
| 96 | * has been preemptively deleted |
| 97 | * - the caller must hold the i_mutex on the dentry's parent as required to |
| 98 | * call vfs_unlink(), vfs_rmdir() or vfs_rename() |
| 99 | */ |
| 100 | static void cachefiles_mark_object_buried(struct cachefiles_cache *cache, |
| 101 | struct dentry *dentry) |
| 102 | { |
| 103 | struct cachefiles_object *object; |
| 104 | struct rb_node *p; |
| 105 | |
| 106 | _enter(",'%*.*s'", |
| 107 | dentry->d_name.len, dentry->d_name.len, dentry->d_name.name); |
| 108 | |
| 109 | write_lock(&cache->active_lock); |
| 110 | |
| 111 | p = cache->active_nodes.rb_node; |
| 112 | while (p) { |
| 113 | object = rb_entry(p, struct cachefiles_object, active_node); |
| 114 | if (object->dentry > dentry) |
| 115 | p = p->rb_left; |
| 116 | else if (object->dentry < dentry) |
| 117 | p = p->rb_right; |
| 118 | else |
| 119 | goto found_dentry; |
| 120 | } |
| 121 | |
| 122 | write_unlock(&cache->active_lock); |
| 123 | _leave(" [no owner]"); |
| 124 | return; |
| 125 | |
| 126 | /* found the dentry for */ |
| 127 | found_dentry: |
| 128 | kdebug("preemptive burial: OBJ%x [%s] %p", |
| 129 | object->fscache.debug_id, |
David Howells | caaef69 | 2013-05-10 19:50:26 +0100 | [diff] [blame] | 130 | object->fscache.state->name, |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 131 | dentry); |
| 132 | |
David Howells | 493f7bc | 2013-05-10 19:50:26 +0100 | [diff] [blame] | 133 | if (fscache_object_is_live(&object->fscache)) { |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 134 | printk(KERN_ERR "\n"); |
| 135 | printk(KERN_ERR "CacheFiles: Error:" |
| 136 | " Can't preemptively bury live object\n"); |
| 137 | cachefiles_printk_object(object, NULL); |
| 138 | } else if (test_and_set_bit(CACHEFILES_OBJECT_BURIED, &object->flags)) { |
| 139 | printk(KERN_ERR "CacheFiles: Error:" |
| 140 | " Object already preemptively buried\n"); |
| 141 | } |
| 142 | |
| 143 | write_unlock(&cache->active_lock); |
| 144 | _leave(" [owner marked]"); |
| 145 | } |
| 146 | |
| 147 | /* |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 148 | * record the fact that an object is now active |
| 149 | */ |
David Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 150 | static int cachefiles_mark_object_active(struct cachefiles_cache *cache, |
| 151 | struct cachefiles_object *object) |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 152 | { |
| 153 | struct cachefiles_object *xobject; |
| 154 | struct rb_node **_p, *_parent = NULL; |
| 155 | struct dentry *dentry; |
| 156 | |
| 157 | _enter(",%p", object); |
| 158 | |
| 159 | try_again: |
| 160 | write_lock(&cache->active_lock); |
| 161 | |
David Howells | d0e27b7 | 2009-11-19 18:12:02 +0000 | [diff] [blame] | 162 | if (test_and_set_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags)) { |
| 163 | printk(KERN_ERR "CacheFiles: Error: Object already active\n"); |
| 164 | cachefiles_printk_object(object, NULL); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 165 | BUG(); |
David Howells | d0e27b7 | 2009-11-19 18:12:02 +0000 | [diff] [blame] | 166 | } |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 167 | |
| 168 | dentry = object->dentry; |
| 169 | _p = &cache->active_nodes.rb_node; |
| 170 | while (*_p) { |
| 171 | _parent = *_p; |
| 172 | xobject = rb_entry(_parent, |
| 173 | struct cachefiles_object, active_node); |
| 174 | |
| 175 | ASSERT(xobject != object); |
| 176 | |
| 177 | if (xobject->dentry > dentry) |
| 178 | _p = &(*_p)->rb_left; |
| 179 | else if (xobject->dentry < dentry) |
| 180 | _p = &(*_p)->rb_right; |
| 181 | else |
| 182 | goto wait_for_old_object; |
| 183 | } |
| 184 | |
| 185 | rb_link_node(&object->active_node, _parent, _p); |
| 186 | rb_insert_color(&object->active_node, &cache->active_nodes); |
| 187 | |
| 188 | write_unlock(&cache->active_lock); |
David Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 189 | _leave(" = 0"); |
| 190 | return 0; |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 191 | |
| 192 | /* an old object from a previous incarnation is hogging the slot - we |
| 193 | * need to wait for it to be destroyed */ |
| 194 | wait_for_old_object: |
David Howells | 493f7bc | 2013-05-10 19:50:26 +0100 | [diff] [blame] | 195 | if (fscache_object_is_live(&object->fscache)) { |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 196 | printk(KERN_ERR "\n"); |
| 197 | printk(KERN_ERR "CacheFiles: Error:" |
| 198 | " Unexpected object collision\n"); |
David Howells | d0e27b7 | 2009-11-19 18:12:02 +0000 | [diff] [blame] | 199 | cachefiles_printk_object(object, xobject); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 200 | BUG(); |
| 201 | } |
| 202 | atomic_inc(&xobject->usage); |
| 203 | write_unlock(&cache->active_lock); |
| 204 | |
David Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 205 | if (test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags)) { |
| 206 | wait_queue_head_t *wq; |
| 207 | |
| 208 | signed long timeout = 60 * HZ; |
| 209 | wait_queue_t wait; |
| 210 | bool requeue; |
| 211 | |
| 212 | /* if the object we're waiting for is queued for processing, |
| 213 | * then just put ourselves on the queue behind it */ |
Tejun Heo | 8b8edef | 2010-07-20 22:09:01 +0200 | [diff] [blame] | 214 | if (work_pending(&xobject->fscache.work)) { |
David Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 215 | _debug("queue OBJ%x behind OBJ%x immediately", |
| 216 | object->fscache.debug_id, |
| 217 | xobject->fscache.debug_id); |
| 218 | goto requeue; |
| 219 | } |
| 220 | |
| 221 | /* otherwise we sleep until either the object we're waiting for |
Tejun Heo | 8b8edef | 2010-07-20 22:09:01 +0200 | [diff] [blame] | 222 | * is done, or the fscache_object is congested */ |
David Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 223 | wq = bit_waitqueue(&xobject->flags, CACHEFILES_OBJECT_ACTIVE); |
| 224 | init_wait(&wait); |
| 225 | requeue = false; |
| 226 | do { |
| 227 | prepare_to_wait(wq, &wait, TASK_UNINTERRUPTIBLE); |
| 228 | if (!test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags)) |
| 229 | break; |
Tejun Heo | 8b8edef | 2010-07-20 22:09:01 +0200 | [diff] [blame] | 230 | |
| 231 | requeue = fscache_object_sleep_till_congested(&timeout); |
David Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 232 | } while (timeout > 0 && !requeue); |
| 233 | finish_wait(wq, &wait); |
| 234 | |
| 235 | if (requeue && |
| 236 | test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags)) { |
| 237 | _debug("queue OBJ%x behind OBJ%x after wait", |
| 238 | object->fscache.debug_id, |
| 239 | xobject->fscache.debug_id); |
| 240 | goto requeue; |
| 241 | } |
| 242 | |
| 243 | if (timeout <= 0) { |
| 244 | printk(KERN_ERR "\n"); |
| 245 | printk(KERN_ERR "CacheFiles: Error: Overlong" |
| 246 | " wait for old active object to go away\n"); |
| 247 | cachefiles_printk_object(object, xobject); |
| 248 | goto requeue; |
| 249 | } |
| 250 | } |
| 251 | |
| 252 | ASSERT(!test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags)); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 253 | |
| 254 | cache->cache.ops->put_object(&xobject->fscache); |
| 255 | goto try_again; |
David Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 256 | |
| 257 | requeue: |
| 258 | clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags); |
| 259 | cache->cache.ops->put_object(&xobject->fscache); |
| 260 | _leave(" = -ETIMEDOUT"); |
| 261 | return -ETIMEDOUT; |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 262 | } |
| 263 | |
| 264 | /* |
| 265 | * delete an object representation from the cache |
| 266 | * - file backed objects are unlinked |
| 267 | * - directory backed objects are stuffed into the graveyard for userspace to |
| 268 | * delete |
| 269 | * - unlocks the directory mutex |
| 270 | */ |
| 271 | static int cachefiles_bury_object(struct cachefiles_cache *cache, |
| 272 | struct dentry *dir, |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 273 | struct dentry *rep, |
| 274 | bool preemptive) |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 275 | { |
| 276 | struct dentry *grave, *trap; |
David Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 277 | struct path path, path_to_graveyard; |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 278 | char nbuffer[8 + 8 + 1]; |
| 279 | int ret; |
| 280 | |
| 281 | _enter(",'%*.*s','%*.*s'", |
| 282 | dir->d_name.len, dir->d_name.len, dir->d_name.name, |
| 283 | rep->d_name.len, rep->d_name.len, rep->d_name.name); |
| 284 | |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 285 | _debug("remove %p from %p", rep, dir); |
| 286 | |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 287 | /* non-directories can just be unlinked */ |
| 288 | if (!S_ISDIR(rep->d_inode->i_mode)) { |
| 289 | _debug("unlink stale object"); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 290 | |
David Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 291 | path.mnt = cache->mnt; |
| 292 | path.dentry = dir; |
| 293 | ret = security_path_unlink(&path, rep); |
| 294 | if (ret < 0) { |
| 295 | cachefiles_io_error(cache, "Unlink security error"); |
| 296 | } else { |
J. Bruce Fields | b21996e | 2011-09-20 09:14:34 -0400 | [diff] [blame] | 297 | ret = vfs_unlink(dir->d_inode, rep, NULL); |
David Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 298 | |
| 299 | if (preemptive) |
| 300 | cachefiles_mark_object_buried(cache, rep); |
| 301 | } |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 302 | |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 303 | mutex_unlock(&dir->d_inode->i_mutex); |
| 304 | |
| 305 | if (ret == -EIO) |
| 306 | cachefiles_io_error(cache, "Unlink failed"); |
| 307 | |
| 308 | _leave(" = %d", ret); |
| 309 | return ret; |
| 310 | } |
| 311 | |
| 312 | /* directories have to be moved to the graveyard */ |
| 313 | _debug("move stale object to graveyard"); |
| 314 | mutex_unlock(&dir->d_inode->i_mutex); |
| 315 | |
| 316 | try_again: |
| 317 | /* first step is to make up a grave dentry in the graveyard */ |
| 318 | sprintf(nbuffer, "%08x%08x", |
| 319 | (uint32_t) get_seconds(), |
| 320 | (uint32_t) atomic_inc_return(&cache->gravecounter)); |
| 321 | |
| 322 | /* do the multiway lock magic */ |
| 323 | trap = lock_rename(cache->graveyard, dir); |
| 324 | |
| 325 | /* do some checks before getting the grave dentry */ |
| 326 | if (rep->d_parent != dir) { |
| 327 | /* the entry was probably culled when we dropped the parent dir |
| 328 | * lock */ |
| 329 | unlock_rename(cache->graveyard, dir); |
| 330 | _leave(" = 0 [culled?]"); |
| 331 | return 0; |
| 332 | } |
| 333 | |
| 334 | if (!S_ISDIR(cache->graveyard->d_inode->i_mode)) { |
| 335 | unlock_rename(cache->graveyard, dir); |
| 336 | cachefiles_io_error(cache, "Graveyard no longer a directory"); |
| 337 | return -EIO; |
| 338 | } |
| 339 | |
| 340 | if (trap == rep) { |
| 341 | unlock_rename(cache->graveyard, dir); |
| 342 | cachefiles_io_error(cache, "May not make directory loop"); |
| 343 | return -EIO; |
| 344 | } |
| 345 | |
| 346 | if (d_mountpoint(rep)) { |
| 347 | unlock_rename(cache->graveyard, dir); |
| 348 | cachefiles_io_error(cache, "Mountpoint in cache"); |
| 349 | return -EIO; |
| 350 | } |
| 351 | |
| 352 | grave = lookup_one_len(nbuffer, cache->graveyard, strlen(nbuffer)); |
| 353 | if (IS_ERR(grave)) { |
| 354 | unlock_rename(cache->graveyard, dir); |
| 355 | |
| 356 | if (PTR_ERR(grave) == -ENOMEM) { |
| 357 | _leave(" = -ENOMEM"); |
| 358 | return -ENOMEM; |
| 359 | } |
| 360 | |
| 361 | cachefiles_io_error(cache, "Lookup error %ld", |
| 362 | PTR_ERR(grave)); |
| 363 | return -EIO; |
| 364 | } |
| 365 | |
| 366 | if (grave->d_inode) { |
| 367 | unlock_rename(cache->graveyard, dir); |
| 368 | dput(grave); |
| 369 | grave = NULL; |
| 370 | cond_resched(); |
| 371 | goto try_again; |
| 372 | } |
| 373 | |
| 374 | if (d_mountpoint(grave)) { |
| 375 | unlock_rename(cache->graveyard, dir); |
| 376 | dput(grave); |
| 377 | cachefiles_io_error(cache, "Mountpoint in graveyard"); |
| 378 | return -EIO; |
| 379 | } |
| 380 | |
| 381 | /* target should not be an ancestor of source */ |
| 382 | if (trap == grave) { |
| 383 | unlock_rename(cache->graveyard, dir); |
| 384 | dput(grave); |
| 385 | cachefiles_io_error(cache, "May not make directory loop"); |
| 386 | return -EIO; |
| 387 | } |
| 388 | |
| 389 | /* attempt the rename */ |
David Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 390 | path.mnt = cache->mnt; |
| 391 | path.dentry = dir; |
| 392 | path_to_graveyard.mnt = cache->mnt; |
| 393 | path_to_graveyard.dentry = cache->graveyard; |
Miklos Szeredi | 0b3974e | 2014-04-01 17:08:43 +0200 | [diff] [blame] | 394 | ret = security_path_rename(&path, rep, &path_to_graveyard, grave, 0); |
David Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 395 | if (ret < 0) { |
| 396 | cachefiles_io_error(cache, "Rename security error %d", ret); |
| 397 | } else { |
| 398 | ret = vfs_rename(dir->d_inode, rep, |
Miklos Szeredi | 520c8b1 | 2014-04-01 17:08:42 +0200 | [diff] [blame] | 399 | cache->graveyard->d_inode, grave, NULL, 0); |
David Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 400 | if (ret != 0 && ret != -ENOMEM) |
| 401 | cachefiles_io_error(cache, |
| 402 | "Rename failed with error %d", ret); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 403 | |
David Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 404 | if (preemptive) |
| 405 | cachefiles_mark_object_buried(cache, rep); |
| 406 | } |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 407 | |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 408 | unlock_rename(cache->graveyard, dir); |
| 409 | dput(grave); |
| 410 | _leave(" = 0"); |
| 411 | return 0; |
| 412 | } |
| 413 | |
| 414 | /* |
| 415 | * delete an object representation from the cache |
| 416 | */ |
| 417 | int cachefiles_delete_object(struct cachefiles_cache *cache, |
| 418 | struct cachefiles_object *object) |
| 419 | { |
| 420 | struct dentry *dir; |
| 421 | int ret; |
| 422 | |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 423 | _enter(",OBJ%x{%p}", object->fscache.debug_id, object->dentry); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 424 | |
| 425 | ASSERT(object->dentry); |
| 426 | ASSERT(object->dentry->d_inode); |
| 427 | ASSERT(object->dentry->d_parent); |
| 428 | |
| 429 | dir = dget_parent(object->dentry); |
| 430 | |
David Howells | 6511de3 | 2009-11-19 18:11:58 +0000 | [diff] [blame] | 431 | mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT); |
David Howells | 8f9941a | 2010-02-19 18:14:21 +0000 | [diff] [blame] | 432 | |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 433 | if (test_bit(CACHEFILES_OBJECT_BURIED, &object->flags)) { |
| 434 | /* object allocation for the same key preemptively deleted this |
| 435 | * object's file so that it could create its own file */ |
| 436 | _debug("object preemptively buried"); |
David Howells | 8f9941a | 2010-02-19 18:14:21 +0000 | [diff] [blame] | 437 | mutex_unlock(&dir->d_inode->i_mutex); |
| 438 | ret = 0; |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 439 | } else { |
| 440 | /* we need to check that our parent is _still_ our parent - it |
| 441 | * may have been renamed */ |
| 442 | if (dir == object->dentry->d_parent) { |
| 443 | ret = cachefiles_bury_object(cache, dir, |
| 444 | object->dentry, false); |
| 445 | } else { |
| 446 | /* it got moved, presumably by cachefilesd culling it, |
| 447 | * so it's no longer in the key path and we can ignore |
| 448 | * it */ |
| 449 | mutex_unlock(&dir->d_inode->i_mutex); |
| 450 | ret = 0; |
| 451 | } |
David Howells | 8f9941a | 2010-02-19 18:14:21 +0000 | [diff] [blame] | 452 | } |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 453 | |
| 454 | dput(dir); |
| 455 | _leave(" = %d", ret); |
| 456 | return ret; |
| 457 | } |
| 458 | |
| 459 | /* |
| 460 | * walk from the parent object to the child object through the backing |
| 461 | * filesystem, creating directories as we go |
| 462 | */ |
| 463 | int cachefiles_walk_to_object(struct cachefiles_object *parent, |
| 464 | struct cachefiles_object *object, |
| 465 | const char *key, |
| 466 | struct cachefiles_xattr *auxdata) |
| 467 | { |
| 468 | struct cachefiles_cache *cache; |
| 469 | struct dentry *dir, *next = NULL; |
David Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 470 | struct path path; |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 471 | unsigned long start; |
| 472 | const char *name; |
| 473 | int ret, nlen; |
| 474 | |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 475 | _enter("OBJ%x{%p},OBJ%x,%s,", |
| 476 | parent->fscache.debug_id, parent->dentry, |
| 477 | object->fscache.debug_id, key); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 478 | |
| 479 | cache = container_of(parent->fscache.cache, |
| 480 | struct cachefiles_cache, cache); |
David Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 481 | path.mnt = cache->mnt; |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 482 | |
| 483 | ASSERT(parent->dentry); |
| 484 | ASSERT(parent->dentry->d_inode); |
| 485 | |
| 486 | if (!(S_ISDIR(parent->dentry->d_inode->i_mode))) { |
| 487 | // TODO: convert file to dir |
| 488 | _leave("looking up in none directory"); |
| 489 | return -ENOBUFS; |
| 490 | } |
| 491 | |
| 492 | dir = dget(parent->dentry); |
| 493 | |
| 494 | advance: |
| 495 | /* attempt to transit the first directory component */ |
| 496 | name = key; |
| 497 | nlen = strlen(key); |
| 498 | |
| 499 | /* key ends in a double NUL */ |
| 500 | key = key + nlen + 1; |
| 501 | if (!*key) |
| 502 | key = NULL; |
| 503 | |
| 504 | lookup_again: |
| 505 | /* search the current directory for the element name */ |
| 506 | _debug("lookup '%s'", name); |
| 507 | |
David Howells | 6511de3 | 2009-11-19 18:11:58 +0000 | [diff] [blame] | 508 | mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 509 | |
| 510 | start = jiffies; |
| 511 | next = lookup_one_len(name, dir, nlen); |
| 512 | cachefiles_hist(cachefiles_lookup_histogram, start); |
| 513 | if (IS_ERR(next)) |
| 514 | goto lookup_error; |
| 515 | |
| 516 | _debug("next -> %p %s", next, next->d_inode ? "positive" : "negative"); |
| 517 | |
| 518 | if (!key) |
| 519 | object->new = !next->d_inode; |
| 520 | |
| 521 | /* if this element of the path doesn't exist, then the lookup phase |
| 522 | * failed, and we can release any readers in the certain knowledge that |
| 523 | * there's nothing for them to actually read */ |
| 524 | if (!next->d_inode) |
| 525 | fscache_object_lookup_negative(&object->fscache); |
| 526 | |
| 527 | /* we need to create the object if it's negative */ |
| 528 | if (key || object->type == FSCACHE_COOKIE_TYPE_INDEX) { |
| 529 | /* index objects and intervening tree levels must be subdirs */ |
| 530 | if (!next->d_inode) { |
| 531 | ret = cachefiles_has_space(cache, 1, 0); |
| 532 | if (ret < 0) |
| 533 | goto create_error; |
| 534 | |
David Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 535 | path.dentry = dir; |
| 536 | ret = security_path_mkdir(&path, next, 0); |
| 537 | if (ret < 0) |
| 538 | goto create_error; |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 539 | start = jiffies; |
| 540 | ret = vfs_mkdir(dir->d_inode, next, 0); |
| 541 | cachefiles_hist(cachefiles_mkdir_histogram, start); |
| 542 | if (ret < 0) |
| 543 | goto create_error; |
| 544 | |
| 545 | ASSERT(next->d_inode); |
| 546 | |
| 547 | _debug("mkdir -> %p{%p{ino=%lu}}", |
| 548 | next, next->d_inode, next->d_inode->i_ino); |
| 549 | |
| 550 | } else if (!S_ISDIR(next->d_inode->i_mode)) { |
| 551 | kerror("inode %lu is not a directory", |
| 552 | next->d_inode->i_ino); |
| 553 | ret = -ENOBUFS; |
| 554 | goto error; |
| 555 | } |
| 556 | |
| 557 | } else { |
| 558 | /* non-index objects start out life as files */ |
| 559 | if (!next->d_inode) { |
| 560 | ret = cachefiles_has_space(cache, 1, 0); |
| 561 | if (ret < 0) |
| 562 | goto create_error; |
| 563 | |
David Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 564 | path.dentry = dir; |
| 565 | ret = security_path_mknod(&path, next, S_IFREG, 0); |
| 566 | if (ret < 0) |
| 567 | goto create_error; |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 568 | start = jiffies; |
Al Viro | 312b63f | 2012-06-10 18:09:36 -0400 | [diff] [blame] | 569 | ret = vfs_create(dir->d_inode, next, S_IFREG, true); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 570 | cachefiles_hist(cachefiles_create_histogram, start); |
| 571 | if (ret < 0) |
| 572 | goto create_error; |
| 573 | |
| 574 | ASSERT(next->d_inode); |
| 575 | |
| 576 | _debug("create -> %p{%p{ino=%lu}}", |
| 577 | next, next->d_inode, next->d_inode->i_ino); |
| 578 | |
| 579 | } else if (!S_ISDIR(next->d_inode->i_mode) && |
| 580 | !S_ISREG(next->d_inode->i_mode) |
| 581 | ) { |
| 582 | kerror("inode %lu is not a file or directory", |
| 583 | next->d_inode->i_ino); |
| 584 | ret = -ENOBUFS; |
| 585 | goto error; |
| 586 | } |
| 587 | } |
| 588 | |
| 589 | /* process the next component */ |
| 590 | if (key) { |
| 591 | _debug("advance"); |
| 592 | mutex_unlock(&dir->d_inode->i_mutex); |
| 593 | dput(dir); |
| 594 | dir = next; |
| 595 | next = NULL; |
| 596 | goto advance; |
| 597 | } |
| 598 | |
| 599 | /* we've found the object we were looking for */ |
| 600 | object->dentry = next; |
| 601 | |
| 602 | /* if we've found that the terminal object exists, then we need to |
| 603 | * check its attributes and delete it if it's out of date */ |
| 604 | if (!object->new) { |
| 605 | _debug("validate '%*.*s'", |
| 606 | next->d_name.len, next->d_name.len, next->d_name.name); |
| 607 | |
| 608 | ret = cachefiles_check_object_xattr(object, auxdata); |
| 609 | if (ret == -ESTALE) { |
| 610 | /* delete the object (the deleter drops the directory |
| 611 | * mutex) */ |
| 612 | object->dentry = NULL; |
| 613 | |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 614 | ret = cachefiles_bury_object(cache, dir, next, true); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 615 | dput(next); |
| 616 | next = NULL; |
| 617 | |
| 618 | if (ret < 0) |
| 619 | goto delete_error; |
| 620 | |
| 621 | _debug("redo lookup"); |
| 622 | goto lookup_again; |
| 623 | } |
| 624 | } |
| 625 | |
| 626 | /* note that we're now using this object */ |
David Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 627 | ret = cachefiles_mark_object_active(cache, object); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 628 | |
| 629 | mutex_unlock(&dir->d_inode->i_mutex); |
| 630 | dput(dir); |
| 631 | dir = NULL; |
| 632 | |
David Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 633 | if (ret == -ETIMEDOUT) |
| 634 | goto mark_active_timed_out; |
| 635 | |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 636 | _debug("=== OBTAINED_OBJECT ==="); |
| 637 | |
| 638 | if (object->new) { |
| 639 | /* attach data to a newly constructed terminal object */ |
| 640 | ret = cachefiles_set_object_xattr(object, auxdata); |
| 641 | if (ret < 0) |
| 642 | goto check_error; |
| 643 | } else { |
| 644 | /* always update the atime on an object we've just looked up |
| 645 | * (this is used to keep track of culling, and atimes are only |
| 646 | * updated by read, write and readdir but not lookup or |
| 647 | * open) */ |
Al Viro | 68ac123 | 2012-03-15 08:21:57 -0400 | [diff] [blame] | 648 | path.dentry = next; |
| 649 | touch_atime(&path); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 650 | } |
| 651 | |
| 652 | /* open a file interface onto a data file */ |
| 653 | if (object->type != FSCACHE_COOKIE_TYPE_INDEX) { |
| 654 | if (S_ISREG(object->dentry->d_inode->i_mode)) { |
| 655 | const struct address_space_operations *aops; |
| 656 | |
| 657 | ret = -EPERM; |
| 658 | aops = object->dentry->d_inode->i_mapping->a_ops; |
| 659 | if (!aops->bmap) |
| 660 | goto check_error; |
| 661 | |
| 662 | object->backer = object->dentry; |
| 663 | } else { |
| 664 | BUG(); // TODO: open file in data-class subdir |
| 665 | } |
| 666 | } |
| 667 | |
| 668 | object->new = 0; |
| 669 | fscache_obtained_object(&object->fscache); |
| 670 | |
| 671 | _leave(" = 0 [%lu]", object->dentry->d_inode->i_ino); |
| 672 | return 0; |
| 673 | |
| 674 | create_error: |
| 675 | _debug("create error %d", ret); |
| 676 | if (ret == -EIO) |
| 677 | cachefiles_io_error(cache, "Create/mkdir failed"); |
| 678 | goto error; |
| 679 | |
David Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 680 | mark_active_timed_out: |
| 681 | _debug("mark active timed out"); |
| 682 | goto release_dentry; |
| 683 | |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 684 | check_error: |
| 685 | _debug("check error %d", ret); |
| 686 | write_lock(&cache->active_lock); |
| 687 | rb_erase(&object->active_node, &cache->active_nodes); |
| 688 | clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags); |
| 689 | wake_up_bit(&object->flags, CACHEFILES_OBJECT_ACTIVE); |
| 690 | write_unlock(&cache->active_lock); |
David Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 691 | release_dentry: |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 692 | dput(object->dentry); |
| 693 | object->dentry = NULL; |
| 694 | goto error_out; |
| 695 | |
| 696 | delete_error: |
| 697 | _debug("delete error %d", ret); |
| 698 | goto error_out2; |
| 699 | |
| 700 | lookup_error: |
| 701 | _debug("lookup error %ld", PTR_ERR(next)); |
| 702 | ret = PTR_ERR(next); |
| 703 | if (ret == -EIO) |
| 704 | cachefiles_io_error(cache, "Lookup failed"); |
| 705 | next = NULL; |
| 706 | error: |
| 707 | mutex_unlock(&dir->d_inode->i_mutex); |
| 708 | dput(next); |
| 709 | error_out2: |
| 710 | dput(dir); |
| 711 | error_out: |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 712 | _leave(" = error %d", -ret); |
| 713 | return ret; |
| 714 | } |
| 715 | |
| 716 | /* |
| 717 | * get a subdirectory |
| 718 | */ |
| 719 | struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache, |
| 720 | struct dentry *dir, |
| 721 | const char *dirname) |
| 722 | { |
| 723 | struct dentry *subdir; |
| 724 | unsigned long start; |
David Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 725 | struct path path; |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 726 | int ret; |
| 727 | |
| 728 | _enter(",,%s", dirname); |
| 729 | |
| 730 | /* search the current directory for the element name */ |
| 731 | mutex_lock(&dir->d_inode->i_mutex); |
| 732 | |
| 733 | start = jiffies; |
| 734 | subdir = lookup_one_len(dirname, dir, strlen(dirname)); |
| 735 | cachefiles_hist(cachefiles_lookup_histogram, start); |
| 736 | if (IS_ERR(subdir)) { |
| 737 | if (PTR_ERR(subdir) == -ENOMEM) |
| 738 | goto nomem_d_alloc; |
| 739 | goto lookup_error; |
| 740 | } |
| 741 | |
| 742 | _debug("subdir -> %p %s", |
| 743 | subdir, subdir->d_inode ? "positive" : "negative"); |
| 744 | |
| 745 | /* we need to create the subdir if it doesn't exist yet */ |
| 746 | if (!subdir->d_inode) { |
| 747 | ret = cachefiles_has_space(cache, 1, 0); |
| 748 | if (ret < 0) |
| 749 | goto mkdir_error; |
| 750 | |
| 751 | _debug("attempt mkdir"); |
| 752 | |
David Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 753 | path.mnt = cache->mnt; |
| 754 | path.dentry = dir; |
| 755 | ret = security_path_mkdir(&path, subdir, 0700); |
| 756 | if (ret < 0) |
| 757 | goto mkdir_error; |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 758 | ret = vfs_mkdir(dir->d_inode, subdir, 0700); |
| 759 | if (ret < 0) |
| 760 | goto mkdir_error; |
| 761 | |
| 762 | ASSERT(subdir->d_inode); |
| 763 | |
| 764 | _debug("mkdir -> %p{%p{ino=%lu}}", |
| 765 | subdir, |
| 766 | subdir->d_inode, |
| 767 | subdir->d_inode->i_ino); |
| 768 | } |
| 769 | |
| 770 | mutex_unlock(&dir->d_inode->i_mutex); |
| 771 | |
| 772 | /* we need to make sure the subdir is a directory */ |
| 773 | ASSERT(subdir->d_inode); |
| 774 | |
| 775 | if (!S_ISDIR(subdir->d_inode->i_mode)) { |
| 776 | kerror("%s is not a directory", dirname); |
| 777 | ret = -EIO; |
| 778 | goto check_error; |
| 779 | } |
| 780 | |
| 781 | ret = -EPERM; |
Al Viro | 627bf81 | 2014-02-01 04:43:32 -0500 | [diff] [blame] | 782 | if (!subdir->d_inode->i_op->setxattr || |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 783 | !subdir->d_inode->i_op->getxattr || |
| 784 | !subdir->d_inode->i_op->lookup || |
| 785 | !subdir->d_inode->i_op->mkdir || |
| 786 | !subdir->d_inode->i_op->create || |
| 787 | !subdir->d_inode->i_op->rename || |
| 788 | !subdir->d_inode->i_op->rmdir || |
| 789 | !subdir->d_inode->i_op->unlink) |
| 790 | goto check_error; |
| 791 | |
| 792 | _leave(" = [%lu]", subdir->d_inode->i_ino); |
| 793 | return subdir; |
| 794 | |
| 795 | check_error: |
| 796 | dput(subdir); |
| 797 | _leave(" = %d [check]", ret); |
| 798 | return ERR_PTR(ret); |
| 799 | |
| 800 | mkdir_error: |
| 801 | mutex_unlock(&dir->d_inode->i_mutex); |
| 802 | dput(subdir); |
| 803 | kerror("mkdir %s failed with error %d", dirname, ret); |
| 804 | return ERR_PTR(ret); |
| 805 | |
| 806 | lookup_error: |
| 807 | mutex_unlock(&dir->d_inode->i_mutex); |
| 808 | ret = PTR_ERR(subdir); |
| 809 | kerror("Lookup %s failed with error %d", dirname, ret); |
| 810 | return ERR_PTR(ret); |
| 811 | |
| 812 | nomem_d_alloc: |
| 813 | mutex_unlock(&dir->d_inode->i_mutex); |
| 814 | _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 | */ |
| 824 | static 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 | |
| 834 | //_enter(",%*.*s/,%s", |
| 835 | // dir->d_name.len, dir->d_name.len, dir->d_name.name, filename); |
| 836 | |
| 837 | /* look up the victim */ |
J. Bruce Fields | 6bd5e82 | 2013-05-10 19:50:25 +0100 | [diff] [blame] | 838 | mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 839 | |
| 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", |
| 847 | // victim, victim->d_inode ? "positive" : "negative"); |
| 848 | |
| 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 | */ |
| 852 | if (!victim->d_inode) { |
| 853 | mutex_unlock(&dir->d_inode->i_mutex); |
| 854 | 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 | |
| 880 | object_in_use: |
| 881 | read_unlock(&cache->active_lock); |
| 882 | mutex_unlock(&dir->d_inode->i_mutex); |
| 883 | dput(victim); |
| 884 | //_leave(" = -EBUSY [in use]"); |
| 885 | return ERR_PTR(-EBUSY); |
| 886 | |
| 887 | lookup_error: |
| 888 | mutex_unlock(&dir->d_inode->i_mutex); |
| 889 | 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) { |
| 899 | kerror("Internal error: %d", ret); |
| 900 | 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 | */ |
| 911 | int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir, |
| 912 | char *filename) |
| 913 | { |
| 914 | struct dentry *victim; |
| 915 | int ret; |
| 916 | |
| 917 | _enter(",%*.*s/,%s", |
| 918 | dir->d_name.len, dir->d_name.len, dir->d_name.name, filename); |
| 919 | |
| 920 | victim = cachefiles_check_active(cache, dir, filename); |
| 921 | if (IS_ERR(victim)) |
| 922 | return PTR_ERR(victim); |
| 923 | |
| 924 | _debug("victim -> %p %s", |
| 925 | victim, victim->d_inode ? "positive" : "negative"); |
| 926 | |
| 927 | /* okay... the victim is not being used so we can cull it |
| 928 | * - start by marking it as stale |
| 929 | */ |
| 930 | _debug("victim is cullable"); |
| 931 | |
| 932 | ret = cachefiles_remove_object_xattr(cache, victim); |
| 933 | if (ret < 0) |
| 934 | goto error_unlock; |
| 935 | |
| 936 | /* actually remove the victim (drops the dir mutex) */ |
| 937 | _debug("bury"); |
| 938 | |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 939 | ret = cachefiles_bury_object(cache, dir, victim, false); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 940 | if (ret < 0) |
| 941 | goto error; |
| 942 | |
| 943 | dput(victim); |
| 944 | _leave(" = 0"); |
| 945 | return 0; |
| 946 | |
| 947 | error_unlock: |
| 948 | mutex_unlock(&dir->d_inode->i_mutex); |
| 949 | error: |
| 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) { |
| 958 | kerror("Internal error: %d", ret); |
| 959 | 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 | */ |
| 971 | int cachefiles_check_in_use(struct cachefiles_cache *cache, struct dentry *dir, |
| 972 | char *filename) |
| 973 | { |
| 974 | struct dentry *victim; |
| 975 | |
| 976 | //_enter(",%*.*s/,%s", |
| 977 | // dir->d_name.len, dir->d_name.len, dir->d_name.name, filename); |
| 978 | |
| 979 | victim = cachefiles_check_active(cache, dir, filename); |
| 980 | if (IS_ERR(victim)) |
| 981 | return PTR_ERR(victim); |
| 982 | |
| 983 | mutex_unlock(&dir->d_inode->i_mutex); |
| 984 | dput(victim); |
| 985 | //_leave(" = 0"); |
| 986 | return 0; |
| 987 | } |