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 | |
Fabian Frederick | 4e1eb88 | 2014-06-06 14:37:32 -0700 | [diff] [blame] | 38 | 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 Howells | caaef69 | 2013-05-10 19:50:26 +0100 | [diff] [blame] | 40 | prefix, object->fscache.state->name, |
Tejun Heo | 8b8edef | 2010-07-20 22:09:01 +0200 | [diff] [blame] | 41 | object->fscache.flags, work_busy(&object->fscache.work), |
David Howells | c2d35bf | 2012-12-05 13:34:47 +0000 | [diff] [blame] | 42 | object->fscache.events, object->fscache.event_mask); |
Fabian Frederick | 4e1eb88 | 2014-06-06 14:37:32 -0700 | [diff] [blame] | 43 | pr_err("%sops=%u inp=%u exc=%u\n", |
David Howells | d0e27b7 | 2009-11-19 18:12:02 +0000 | [diff] [blame] | 44 | prefix, object->fscache.n_ops, object->fscache.n_in_progress, |
| 45 | object->fscache.n_exclusive); |
Fabian Frederick | 4e1eb88 | 2014-06-06 14:37:32 -0700 | [diff] [blame] | 46 | pr_err("%sparent=%p\n", |
David Howells | d0e27b7 | 2009-11-19 18:12:02 +0000 | [diff] [blame] | 47 | prefix, object->fscache.parent); |
| 48 | |
| 49 | spin_lock(&object->fscache.lock); |
| 50 | cookie = object->fscache.cookie; |
| 51 | if (cookie) { |
Fabian Frederick | 4e1eb88 | 2014-06-06 14:37:32 -0700 | [diff] [blame] | 52 | pr_err("%scookie=%p [pr=%p nd=%p fl=%lx]\n", |
David Howells | d0e27b7 | 2009-11-19 18:12:02 +0000 | [diff] [blame] | 53 | prefix, |
| 54 | object->fscache.cookie, |
| 55 | object->fscache.cookie->parent, |
| 56 | object->fscache.cookie->netfs_data, |
| 57 | object->fscache.cookie->flags); |
David Howells | 509bf24 | 2013-09-20 14:18:00 +0100 | [diff] [blame] | 58 | if (keybuf && cookie->def) |
David Howells | d0e27b7 | 2009-11-19 18:12:02 +0000 | [diff] [blame] | 59 | keylen = cookie->def->get_key(cookie->netfs_data, keybuf, |
| 60 | CACHEFILES_KEYBUF_SIZE); |
| 61 | else |
| 62 | keylen = 0; |
| 63 | } else { |
Fabian Frederick | 4e1eb88 | 2014-06-06 14:37:32 -0700 | [diff] [blame] | 64 | pr_err("%scookie=NULL\n", prefix); |
David Howells | d0e27b7 | 2009-11-19 18:12:02 +0000 | [diff] [blame] | 65 | keylen = 0; |
| 66 | } |
| 67 | spin_unlock(&object->fscache.lock); |
| 68 | |
| 69 | if (keylen) { |
Fabian Frederick | 4e1eb88 | 2014-06-06 14:37:32 -0700 | [diff] [blame] | 70 | pr_err("%skey=[%u] '", prefix, keylen); |
David Howells | d0e27b7 | 2009-11-19 18:12:02 +0000 | [diff] [blame] | 71 | for (loop = 0; loop < keylen; loop++) |
Fabian Frederick | 4e1eb88 | 2014-06-06 14:37:32 -0700 | [diff] [blame] | 72 | pr_cont("%02x", keybuf[loop]); |
| 73 | pr_cont("'\n"); |
David Howells | d0e27b7 | 2009-11-19 18:12:02 +0000 | [diff] [blame] | 74 | } |
| 75 | } |
| 76 | |
| 77 | /* |
| 78 | * dump debugging info about a pair of objects |
| 79 | */ |
| 80 | static 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 Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 93 | /* |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 94 | * 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 | */ |
| 99 | static 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 */ |
| 126 | found_dentry: |
| 127 | kdebug("preemptive burial: OBJ%x [%s] %p", |
| 128 | object->fscache.debug_id, |
David Howells | caaef69 | 2013-05-10 19:50:26 +0100 | [diff] [blame] | 129 | object->fscache.state->name, |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 130 | dentry); |
| 131 | |
David Howells | 493f7bc | 2013-05-10 19:50:26 +0100 | [diff] [blame] | 132 | if (fscache_object_is_live(&object->fscache)) { |
Fabian Frederick | 4e1eb88 | 2014-06-06 14:37:32 -0700 | [diff] [blame] | 133 | pr_err("\n"); |
Fabian Frederick | 0227d6ab | 2014-06-06 14:37:33 -0700 | [diff] [blame] | 134 | pr_err("Error: Can't preemptively bury live object\n"); |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 135 | cachefiles_printk_object(object, NULL); |
| 136 | } else if (test_and_set_bit(CACHEFILES_OBJECT_BURIED, &object->flags)) { |
Fabian Frederick | 0227d6ab | 2014-06-06 14:37:33 -0700 | [diff] [blame] | 137 | pr_err("Error: Object already preemptively buried\n"); |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 138 | } |
| 139 | |
| 140 | write_unlock(&cache->active_lock); |
| 141 | _leave(" [owner marked]"); |
| 142 | } |
| 143 | |
| 144 | /* |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 145 | * record the fact that an object is now active |
| 146 | */ |
David Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 147 | static int cachefiles_mark_object_active(struct cachefiles_cache *cache, |
| 148 | struct cachefiles_object *object) |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 149 | { |
| 150 | struct cachefiles_object *xobject; |
| 151 | struct rb_node **_p, *_parent = NULL; |
| 152 | struct dentry *dentry; |
| 153 | |
| 154 | _enter(",%p", object); |
| 155 | |
| 156 | try_again: |
| 157 | write_lock(&cache->active_lock); |
| 158 | |
David Howells | d0e27b7 | 2009-11-19 18:12:02 +0000 | [diff] [blame] | 159 | if (test_and_set_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags)) { |
Fabian Frederick | 0227d6ab | 2014-06-06 14:37:33 -0700 | [diff] [blame] | 160 | pr_err("Error: Object already active\n"); |
David Howells | d0e27b7 | 2009-11-19 18:12:02 +0000 | [diff] [blame] | 161 | cachefiles_printk_object(object, NULL); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 162 | BUG(); |
David Howells | d0e27b7 | 2009-11-19 18:12:02 +0000 | [diff] [blame] | 163 | } |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 164 | |
| 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 Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 186 | _leave(" = 0"); |
| 187 | return 0; |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 188 | |
| 189 | /* an old object from a previous incarnation is hogging the slot - we |
| 190 | * need to wait for it to be destroyed */ |
| 191 | wait_for_old_object: |
David Howells | 493f7bc | 2013-05-10 19:50:26 +0100 | [diff] [blame] | 192 | if (fscache_object_is_live(&object->fscache)) { |
Fabian Frederick | 4e1eb88 | 2014-06-06 14:37:32 -0700 | [diff] [blame] | 193 | pr_err("\n"); |
Fabian Frederick | 0227d6ab | 2014-06-06 14:37:33 -0700 | [diff] [blame] | 194 | pr_err("Error: Unexpected object collision\n"); |
David Howells | d0e27b7 | 2009-11-19 18:12:02 +0000 | [diff] [blame] | 195 | cachefiles_printk_object(object, xobject); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 196 | BUG(); |
| 197 | } |
| 198 | atomic_inc(&xobject->usage); |
| 199 | write_unlock(&cache->active_lock); |
| 200 | |
David Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 201 | 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 Heo | 8b8edef | 2010-07-20 22:09:01 +0200 | [diff] [blame] | 210 | if (work_pending(&xobject->fscache.work)) { |
David Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 211 | _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 Heo | 8b8edef | 2010-07-20 22:09:01 +0200 | [diff] [blame] | 218 | * is done, or the fscache_object is congested */ |
David Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 219 | 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 Heo | 8b8edef | 2010-07-20 22:09:01 +0200 | [diff] [blame] | 226 | |
| 227 | requeue = fscache_object_sleep_till_congested(&timeout); |
David Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 228 | } 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 Frederick | 4e1eb88 | 2014-06-06 14:37:32 -0700 | [diff] [blame] | 240 | pr_err("\n"); |
Fabian Frederick | 0227d6ab | 2014-06-06 14:37:33 -0700 | [diff] [blame] | 241 | pr_err("Error: Overlong wait for old active object to go away\n"); |
David Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 242 | cachefiles_printk_object(object, xobject); |
| 243 | goto requeue; |
| 244 | } |
| 245 | } |
| 246 | |
| 247 | ASSERT(!test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags)); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 248 | |
| 249 | cache->cache.ops->put_object(&xobject->fscache); |
| 250 | goto try_again; |
David Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 251 | |
| 252 | requeue: |
| 253 | clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags); |
| 254 | cache->cache.ops->put_object(&xobject->fscache); |
| 255 | _leave(" = -ETIMEDOUT"); |
| 256 | return -ETIMEDOUT; |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 257 | } |
| 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 | */ |
| 266 | static int cachefiles_bury_object(struct cachefiles_cache *cache, |
| 267 | struct dentry *dir, |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 268 | struct dentry *rep, |
| 269 | bool preemptive) |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 270 | { |
| 271 | struct dentry *grave, *trap; |
David Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 272 | struct path path, path_to_graveyard; |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 273 | 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 Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 280 | _debug("remove %p from %p", rep, dir); |
| 281 | |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 282 | /* non-directories can just be unlinked */ |
| 283 | if (!S_ISDIR(rep->d_inode->i_mode)) { |
| 284 | _debug("unlink stale object"); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 285 | |
David Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 286 | 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 Fields | b21996e | 2011-09-20 09:14:34 -0400 | [diff] [blame] | 292 | ret = vfs_unlink(dir->d_inode, rep, NULL); |
David Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 293 | |
| 294 | if (preemptive) |
| 295 | cachefiles_mark_object_buried(cache, rep); |
| 296 | } |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 297 | |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 298 | 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 | |
| 311 | try_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 Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 385 | path.mnt = cache->mnt; |
| 386 | path.dentry = dir; |
| 387 | path_to_graveyard.mnt = cache->mnt; |
| 388 | path_to_graveyard.dentry = cache->graveyard; |
Miklos Szeredi | 0b3974e | 2014-04-01 17:08:43 +0200 | [diff] [blame] | 389 | ret = security_path_rename(&path, rep, &path_to_graveyard, grave, 0); |
David Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 390 | if (ret < 0) { |
| 391 | cachefiles_io_error(cache, "Rename security error %d", ret); |
| 392 | } else { |
| 393 | ret = vfs_rename(dir->d_inode, rep, |
Miklos Szeredi | 520c8b1 | 2014-04-01 17:08:42 +0200 | [diff] [blame] | 394 | cache->graveyard->d_inode, grave, NULL, 0); |
David Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 395 | if (ret != 0 && ret != -ENOMEM) |
| 396 | cachefiles_io_error(cache, |
| 397 | "Rename failed with error %d", ret); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 398 | |
David Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 399 | if (preemptive) |
| 400 | cachefiles_mark_object_buried(cache, rep); |
| 401 | } |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 402 | |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 403 | 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 | */ |
| 412 | int cachefiles_delete_object(struct cachefiles_cache *cache, |
| 413 | struct cachefiles_object *object) |
| 414 | { |
| 415 | struct dentry *dir; |
| 416 | int ret; |
| 417 | |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 418 | _enter(",OBJ%x{%p}", object->fscache.debug_id, object->dentry); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 419 | |
| 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 Howells | 6511de3 | 2009-11-19 18:11:58 +0000 | [diff] [blame] | 426 | mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT); |
David Howells | 8f9941a | 2010-02-19 18:14:21 +0000 | [diff] [blame] | 427 | |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 428 | 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 Howells | 8f9941a | 2010-02-19 18:14:21 +0000 | [diff] [blame] | 432 | mutex_unlock(&dir->d_inode->i_mutex); |
| 433 | ret = 0; |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 434 | } 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 Howells | 8f9941a | 2010-02-19 18:14:21 +0000 | [diff] [blame] | 447 | } |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 448 | |
| 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 | */ |
| 458 | int 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 Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 465 | struct path path; |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 466 | unsigned long start; |
| 467 | const char *name; |
| 468 | int ret, nlen; |
| 469 | |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 470 | _enter("OBJ%x{%p},OBJ%x,%s,", |
| 471 | parent->fscache.debug_id, parent->dentry, |
| 472 | object->fscache.debug_id, key); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 473 | |
| 474 | cache = container_of(parent->fscache.cache, |
| 475 | struct cachefiles_cache, cache); |
David Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 476 | path.mnt = cache->mnt; |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 477 | |
| 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 | |
| 489 | advance: |
| 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 | |
| 499 | lookup_again: |
| 500 | /* search the current directory for the element name */ |
| 501 | _debug("lookup '%s'", name); |
| 502 | |
David Howells | 6511de3 | 2009-11-19 18:11:58 +0000 | [diff] [blame] | 503 | mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 504 | |
| 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 Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 530 | path.dentry = dir; |
| 531 | ret = security_path_mkdir(&path, next, 0); |
| 532 | if (ret < 0) |
| 533 | goto create_error; |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 534 | 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 Frederick | 6ff66ac | 2014-09-25 16:05:27 -0700 | [diff] [blame] | 546 | pr_err("inode %lu is not a directory\n", |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 547 | 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 Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 559 | path.dentry = dir; |
| 560 | ret = security_path_mknod(&path, next, S_IFREG, 0); |
| 561 | if (ret < 0) |
| 562 | goto create_error; |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 563 | start = jiffies; |
Al Viro | 312b63f | 2012-06-10 18:09:36 -0400 | [diff] [blame] | 564 | ret = vfs_create(dir->d_inode, next, S_IFREG, true); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 565 | 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 Frederick | 6ff66ac | 2014-09-25 16:05:27 -0700 | [diff] [blame] | 577 | pr_err("inode %lu is not a file or directory\n", |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 578 | 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 Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 609 | ret = cachefiles_bury_object(cache, dir, next, true); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 610 | 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 Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 622 | ret = cachefiles_mark_object_active(cache, object); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 623 | |
| 624 | mutex_unlock(&dir->d_inode->i_mutex); |
| 625 | dput(dir); |
| 626 | dir = NULL; |
| 627 | |
David Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 628 | if (ret == -ETIMEDOUT) |
| 629 | goto mark_active_timed_out; |
| 630 | |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 631 | _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 Viro | 68ac123 | 2012-03-15 08:21:57 -0400 | [diff] [blame] | 643 | path.dentry = next; |
| 644 | touch_atime(&path); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 645 | } |
| 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 | |
| 669 | create_error: |
| 670 | _debug("create error %d", ret); |
| 671 | if (ret == -EIO) |
| 672 | cachefiles_io_error(cache, "Create/mkdir failed"); |
| 673 | goto error; |
| 674 | |
David Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 675 | mark_active_timed_out: |
| 676 | _debug("mark active timed out"); |
| 677 | goto release_dentry; |
| 678 | |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 679 | check_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 Howells | fee096d | 2009-11-19 18:12:05 +0000 | [diff] [blame] | 686 | release_dentry: |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 687 | dput(object->dentry); |
| 688 | object->dentry = NULL; |
| 689 | goto error_out; |
| 690 | |
| 691 | delete_error: |
| 692 | _debug("delete error %d", ret); |
| 693 | goto error_out2; |
| 694 | |
| 695 | lookup_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; |
| 701 | error: |
| 702 | mutex_unlock(&dir->d_inode->i_mutex); |
| 703 | dput(next); |
| 704 | error_out2: |
| 705 | dput(dir); |
| 706 | error_out: |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 707 | _leave(" = error %d", -ret); |
| 708 | return ret; |
| 709 | } |
| 710 | |
| 711 | /* |
| 712 | * get a subdirectory |
| 713 | */ |
| 714 | struct 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 Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 720 | struct path path; |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 721 | 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 Howells | 8214044 | 2010-12-24 14:48:35 +0000 | [diff] [blame] | 748 | 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 Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 753 | 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 Frederick | 6ff66ac | 2014-09-25 16:05:27 -0700 | [diff] [blame] | 771 | pr_err("%s is not a directory\n", dirname); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 772 | ret = -EIO; |
| 773 | goto check_error; |
| 774 | } |
| 775 | |
| 776 | ret = -EPERM; |
Al Viro | 627bf81 | 2014-02-01 04:43:32 -0500 | [diff] [blame] | 777 | if (!subdir->d_inode->i_op->setxattr || |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 778 | !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 || |
David Howells | e2cf1f1 | 2014-09-17 23:28:38 +0100 | [diff] [blame] | 782 | (!subdir->d_inode->i_op->rename && |
| 783 | !subdir->d_inode->i_op->rename2) || |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 784 | !subdir->d_inode->i_op->rmdir || |
| 785 | !subdir->d_inode->i_op->unlink) |
| 786 | goto check_error; |
| 787 | |
| 788 | _leave(" = [%lu]", subdir->d_inode->i_ino); |
| 789 | return subdir; |
| 790 | |
| 791 | check_error: |
| 792 | dput(subdir); |
| 793 | _leave(" = %d [check]", ret); |
| 794 | return ERR_PTR(ret); |
| 795 | |
| 796 | mkdir_error: |
| 797 | mutex_unlock(&dir->d_inode->i_mutex); |
| 798 | dput(subdir); |
Fabian Frederick | 6ff66ac | 2014-09-25 16:05:27 -0700 | [diff] [blame] | 799 | pr_err("mkdir %s failed with error %d\n", dirname, ret); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 800 | return ERR_PTR(ret); |
| 801 | |
| 802 | lookup_error: |
| 803 | mutex_unlock(&dir->d_inode->i_mutex); |
| 804 | ret = PTR_ERR(subdir); |
Fabian Frederick | 6ff66ac | 2014-09-25 16:05:27 -0700 | [diff] [blame] | 805 | pr_err("Lookup %s failed with error %d\n", dirname, ret); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 806 | return ERR_PTR(ret); |
| 807 | |
| 808 | nomem_d_alloc: |
| 809 | mutex_unlock(&dir->d_inode->i_mutex); |
| 810 | _leave(" = -ENOMEM"); |
| 811 | return ERR_PTR(-ENOMEM); |
| 812 | } |
| 813 | |
| 814 | /* |
| 815 | * find out if an object is in use or not |
| 816 | * - if finds object and it's not in use: |
| 817 | * - returns a pointer to the object and a reference on it |
| 818 | * - returns with the directory locked |
| 819 | */ |
| 820 | static struct dentry *cachefiles_check_active(struct cachefiles_cache *cache, |
| 821 | struct dentry *dir, |
| 822 | char *filename) |
| 823 | { |
| 824 | struct cachefiles_object *object; |
| 825 | struct rb_node *_n; |
| 826 | struct dentry *victim; |
| 827 | unsigned long start; |
| 828 | int ret; |
| 829 | |
| 830 | //_enter(",%*.*s/,%s", |
| 831 | // dir->d_name.len, dir->d_name.len, dir->d_name.name, filename); |
| 832 | |
| 833 | /* look up the victim */ |
J. Bruce Fields | 6bd5e82 | 2013-05-10 19:50:25 +0100 | [diff] [blame] | 834 | mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 835 | |
| 836 | start = jiffies; |
| 837 | victim = lookup_one_len(filename, dir, strlen(filename)); |
| 838 | cachefiles_hist(cachefiles_lookup_histogram, start); |
| 839 | if (IS_ERR(victim)) |
| 840 | goto lookup_error; |
| 841 | |
| 842 | //_debug("victim -> %p %s", |
| 843 | // victim, victim->d_inode ? "positive" : "negative"); |
| 844 | |
| 845 | /* if the object is no longer there then we probably retired the object |
| 846 | * at the netfs's request whilst the cull was in progress |
| 847 | */ |
| 848 | if (!victim->d_inode) { |
| 849 | mutex_unlock(&dir->d_inode->i_mutex); |
| 850 | dput(victim); |
| 851 | _leave(" = -ENOENT [absent]"); |
| 852 | return ERR_PTR(-ENOENT); |
| 853 | } |
| 854 | |
| 855 | /* check to see if we're using this object */ |
| 856 | read_lock(&cache->active_lock); |
| 857 | |
| 858 | _n = cache->active_nodes.rb_node; |
| 859 | |
| 860 | while (_n) { |
| 861 | object = rb_entry(_n, struct cachefiles_object, active_node); |
| 862 | |
| 863 | if (object->dentry > victim) |
| 864 | _n = _n->rb_left; |
| 865 | else if (object->dentry < victim) |
| 866 | _n = _n->rb_right; |
| 867 | else |
| 868 | goto object_in_use; |
| 869 | } |
| 870 | |
| 871 | read_unlock(&cache->active_lock); |
| 872 | |
| 873 | //_leave(" = %p", victim); |
| 874 | return victim; |
| 875 | |
| 876 | object_in_use: |
| 877 | read_unlock(&cache->active_lock); |
| 878 | mutex_unlock(&dir->d_inode->i_mutex); |
| 879 | dput(victim); |
| 880 | //_leave(" = -EBUSY [in use]"); |
| 881 | return ERR_PTR(-EBUSY); |
| 882 | |
| 883 | lookup_error: |
| 884 | mutex_unlock(&dir->d_inode->i_mutex); |
| 885 | ret = PTR_ERR(victim); |
| 886 | if (ret == -ENOENT) { |
| 887 | /* file or dir now absent - probably retired by netfs */ |
| 888 | _leave(" = -ESTALE [absent]"); |
| 889 | return ERR_PTR(-ESTALE); |
| 890 | } |
| 891 | |
| 892 | if (ret == -EIO) { |
| 893 | cachefiles_io_error(cache, "Lookup failed"); |
| 894 | } else if (ret != -ENOMEM) { |
Fabian Frederick | 6ff66ac | 2014-09-25 16:05:27 -0700 | [diff] [blame] | 895 | pr_err("Internal error: %d\n", ret); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 896 | ret = -EIO; |
| 897 | } |
| 898 | |
| 899 | _leave(" = %d", ret); |
| 900 | return ERR_PTR(ret); |
| 901 | } |
| 902 | |
| 903 | /* |
| 904 | * cull an object if it's not in use |
| 905 | * - called only by cache manager daemon |
| 906 | */ |
| 907 | int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir, |
| 908 | char *filename) |
| 909 | { |
| 910 | struct dentry *victim; |
| 911 | int ret; |
| 912 | |
| 913 | _enter(",%*.*s/,%s", |
| 914 | dir->d_name.len, dir->d_name.len, dir->d_name.name, filename); |
| 915 | |
| 916 | victim = cachefiles_check_active(cache, dir, filename); |
| 917 | if (IS_ERR(victim)) |
| 918 | return PTR_ERR(victim); |
| 919 | |
| 920 | _debug("victim -> %p %s", |
| 921 | victim, victim->d_inode ? "positive" : "negative"); |
| 922 | |
| 923 | /* okay... the victim is not being used so we can cull it |
| 924 | * - start by marking it as stale |
| 925 | */ |
| 926 | _debug("victim is cullable"); |
| 927 | |
| 928 | ret = cachefiles_remove_object_xattr(cache, victim); |
| 929 | if (ret < 0) |
| 930 | goto error_unlock; |
| 931 | |
| 932 | /* actually remove the victim (drops the dir mutex) */ |
| 933 | _debug("bury"); |
| 934 | |
David Howells | c61ea31 | 2010-05-11 16:51:39 +0100 | [diff] [blame] | 935 | ret = cachefiles_bury_object(cache, dir, victim, false); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 936 | if (ret < 0) |
| 937 | goto error; |
| 938 | |
| 939 | dput(victim); |
| 940 | _leave(" = 0"); |
| 941 | return 0; |
| 942 | |
| 943 | error_unlock: |
| 944 | mutex_unlock(&dir->d_inode->i_mutex); |
| 945 | error: |
| 946 | dput(victim); |
| 947 | if (ret == -ENOENT) { |
| 948 | /* file or dir now absent - probably retired by netfs */ |
| 949 | _leave(" = -ESTALE [absent]"); |
| 950 | return -ESTALE; |
| 951 | } |
| 952 | |
| 953 | if (ret != -ENOMEM) { |
Fabian Frederick | 6ff66ac | 2014-09-25 16:05:27 -0700 | [diff] [blame] | 954 | pr_err("Internal error: %d\n", ret); |
David Howells | 9ae326a | 2009-04-03 16:42:41 +0100 | [diff] [blame] | 955 | ret = -EIO; |
| 956 | } |
| 957 | |
| 958 | _leave(" = %d", ret); |
| 959 | return ret; |
| 960 | } |
| 961 | |
| 962 | /* |
| 963 | * find out if an object is in use or not |
| 964 | * - called only by cache manager daemon |
| 965 | * - returns -EBUSY or 0 to indicate whether an object is in use or not |
| 966 | */ |
| 967 | int cachefiles_check_in_use(struct cachefiles_cache *cache, struct dentry *dir, |
| 968 | char *filename) |
| 969 | { |
| 970 | struct dentry *victim; |
| 971 | |
| 972 | //_enter(",%*.*s/,%s", |
| 973 | // dir->d_name.len, dir->d_name.len, dir->d_name.name, filename); |
| 974 | |
| 975 | victim = cachefiles_check_active(cache, dir, filename); |
| 976 | if (IS_ERR(victim)) |
| 977 | return PTR_ERR(victim); |
| 978 | |
| 979 | mutex_unlock(&dir->d_inode->i_mutex); |
| 980 | dput(victim); |
| 981 | //_leave(" = 0"); |
| 982 | return 0; |
| 983 | } |