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