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