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 "internal.h" 24 25 #define CACHEFILES_KEYBUF_SIZE 512 26 27 /* 28 * dump debugging info about an object 29 */ 30 static noinline 31 void __cachefiles_printk_object(struct cachefiles_object *object, 32 const char *prefix, 33 u8 *keybuf) 34 { 35 struct fscache_cookie *cookie; 36 unsigned keylen, loop; 37 38 pr_err("%sobject: OBJ%x\n", prefix, object->fscache.debug_id); 39 pr_err("%sobjstate=%s fl=%lx wbusy=%x ev=%lx[%lx]\n", 40 prefix, object->fscache.state->name, 41 object->fscache.flags, work_busy(&object->fscache.work), 42 object->fscache.events, object->fscache.event_mask); 43 pr_err("%sops=%u inp=%u exc=%u\n", 44 prefix, object->fscache.n_ops, object->fscache.n_in_progress, 45 object->fscache.n_exclusive); 46 pr_err("%sparent=%p\n", 47 prefix, object->fscache.parent); 48 49 spin_lock(&object->fscache.lock); 50 cookie = object->fscache.cookie; 51 if (cookie) { 52 pr_err("%scookie=%p [pr=%p nd=%p fl=%lx]\n", 53 prefix, 54 object->fscache.cookie, 55 object->fscache.cookie->parent, 56 object->fscache.cookie->netfs_data, 57 object->fscache.cookie->flags); 58 if (keybuf && cookie->def) 59 keylen = cookie->def->get_key(cookie->netfs_data, keybuf, 60 CACHEFILES_KEYBUF_SIZE); 61 else 62 keylen = 0; 63 } else { 64 pr_err("%scookie=NULL\n", prefix); 65 keylen = 0; 66 } 67 spin_unlock(&object->fscache.lock); 68 69 if (keylen) { 70 pr_err("%skey=[%u] '", prefix, keylen); 71 for (loop = 0; loop < keylen; loop++) 72 pr_cont("%02x", keybuf[loop]); 73 pr_cont("'\n"); 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 93 /* 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 enum fscache_why_object_killed why) 102 { 103 struct cachefiles_object *object; 104 struct rb_node *p; 105 106 _enter(",'%pd'", dentry); 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, 129 object->fscache.state->name, 130 dentry); 131 132 if (fscache_object_is_live(&object->fscache)) { 133 pr_err("\n"); 134 pr_err("Error: Can't preemptively bury live object\n"); 135 cachefiles_printk_object(object, NULL); 136 } else { 137 if (why != FSCACHE_OBJECT_IS_STALE) 138 fscache_object_mark_killed(&object->fscache, why); 139 } 140 141 write_unlock(&cache->active_lock); 142 _leave(" [owner marked]"); 143 } 144 145 /* 146 * record the fact that an object is now active 147 */ 148 static int cachefiles_mark_object_active(struct cachefiles_cache *cache, 149 struct cachefiles_object *object) 150 { 151 struct cachefiles_object *xobject; 152 struct rb_node **_p, *_parent = NULL; 153 struct dentry *dentry; 154 155 _enter(",%p", object); 156 157 try_again: 158 write_lock(&cache->active_lock); 159 160 if (test_and_set_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags)) { 161 pr_err("Error: Object already active\n"); 162 cachefiles_printk_object(object, NULL); 163 BUG(); 164 } 165 166 dentry = object->dentry; 167 _p = &cache->active_nodes.rb_node; 168 while (*_p) { 169 _parent = *_p; 170 xobject = rb_entry(_parent, 171 struct cachefiles_object, active_node); 172 173 ASSERT(xobject != object); 174 175 if (xobject->dentry > dentry) 176 _p = &(*_p)->rb_left; 177 else if (xobject->dentry < dentry) 178 _p = &(*_p)->rb_right; 179 else 180 goto wait_for_old_object; 181 } 182 183 rb_link_node(&object->active_node, _parent, _p); 184 rb_insert_color(&object->active_node, &cache->active_nodes); 185 186 write_unlock(&cache->active_lock); 187 _leave(" = 0"); 188 return 0; 189 190 /* an old object from a previous incarnation is hogging the slot - we 191 * need to wait for it to be destroyed */ 192 wait_for_old_object: 193 if (fscache_object_is_live(&xobject->fscache)) { 194 pr_err("\n"); 195 pr_err("Error: Unexpected object collision\n"); 196 cachefiles_printk_object(object, xobject); 197 BUG(); 198 } 199 atomic_inc(&xobject->usage); 200 write_unlock(&cache->active_lock); 201 202 if (test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags)) { 203 wait_queue_head_t *wq; 204 205 signed long timeout = 60 * HZ; 206 wait_queue_t wait; 207 bool requeue; 208 209 /* if the object we're waiting for is queued for processing, 210 * then just put ourselves on the queue behind it */ 211 if (work_pending(&xobject->fscache.work)) { 212 _debug("queue OBJ%x behind OBJ%x immediately", 213 object->fscache.debug_id, 214 xobject->fscache.debug_id); 215 goto requeue; 216 } 217 218 /* otherwise we sleep until either the object we're waiting for 219 * is done, or the fscache_object is congested */ 220 wq = bit_waitqueue(&xobject->flags, CACHEFILES_OBJECT_ACTIVE); 221 init_wait(&wait); 222 requeue = false; 223 do { 224 prepare_to_wait(wq, &wait, TASK_UNINTERRUPTIBLE); 225 if (!test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags)) 226 break; 227 228 requeue = fscache_object_sleep_till_congested(&timeout); 229 } while (timeout > 0 && !requeue); 230 finish_wait(wq, &wait); 231 232 if (requeue && 233 test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags)) { 234 _debug("queue OBJ%x behind OBJ%x after wait", 235 object->fscache.debug_id, 236 xobject->fscache.debug_id); 237 goto requeue; 238 } 239 240 if (timeout <= 0) { 241 pr_err("\n"); 242 pr_err("Error: Overlong wait for old active object to go away\n"); 243 cachefiles_printk_object(object, xobject); 244 goto requeue; 245 } 246 } 247 248 ASSERT(!test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags)); 249 250 cache->cache.ops->put_object(&xobject->fscache); 251 goto try_again; 252 253 requeue: 254 clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags); 255 cache->cache.ops->put_object(&xobject->fscache); 256 _leave(" = -ETIMEDOUT"); 257 return -ETIMEDOUT; 258 } 259 260 /* 261 * delete an object representation from the cache 262 * - file backed objects are unlinked 263 * - directory backed objects are stuffed into the graveyard for userspace to 264 * delete 265 * - unlocks the directory mutex 266 */ 267 static int cachefiles_bury_object(struct cachefiles_cache *cache, 268 struct dentry *dir, 269 struct dentry *rep, 270 bool preemptive, 271 enum fscache_why_object_killed why) 272 { 273 struct dentry *grave, *trap; 274 struct path path, path_to_graveyard; 275 char nbuffer[8 + 8 + 1]; 276 int ret; 277 278 _enter(",'%pd','%pd'", dir, rep); 279 280 _debug("remove %p from %p", rep, dir); 281 282 /* non-directories can just be unlinked */ 283 if (!d_is_dir(rep)) { 284 _debug("unlink stale object"); 285 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 { 292 ret = vfs_unlink(d_inode(dir), rep, NULL); 293 294 if (preemptive) 295 cachefiles_mark_object_buried(cache, rep, why); 296 } 297 298 mutex_unlock(&d_inode(dir)->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(&d_inode(dir)->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 (!d_can_lookup(cache->graveyard)) { 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 (d_is_positive(grave)) { 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 */ 385 path.mnt = cache->mnt; 386 path.dentry = dir; 387 path_to_graveyard.mnt = cache->mnt; 388 path_to_graveyard.dentry = cache->graveyard; 389 ret = security_path_rename(&path, rep, &path_to_graveyard, grave, 0); 390 if (ret < 0) { 391 cachefiles_io_error(cache, "Rename security error %d", ret); 392 } else { 393 ret = vfs_rename(d_inode(dir), rep, 394 d_inode(cache->graveyard), grave, NULL, 0); 395 if (ret != 0 && ret != -ENOMEM) 396 cachefiles_io_error(cache, 397 "Rename failed with error %d", ret); 398 399 if (preemptive) 400 cachefiles_mark_object_buried(cache, rep, why); 401 } 402 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 418 _enter(",OBJ%x{%p}", object->fscache.debug_id, object->dentry); 419 420 ASSERT(object->dentry); 421 ASSERT(d_backing_inode(object->dentry)); 422 ASSERT(object->dentry->d_parent); 423 424 dir = dget_parent(object->dentry); 425 426 mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT); 427 428 if (test_bit(FSCACHE_OBJECT_KILLED_BY_CACHE, &object->fscache.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"); 432 mutex_unlock(&d_inode(dir)->i_mutex); 433 ret = 0; 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 FSCACHE_OBJECT_WAS_RETIRED); 441 } else { 442 /* it got moved, presumably by cachefilesd culling it, 443 * so it's no longer in the key path and we can ignore 444 * it */ 445 mutex_unlock(&d_inode(dir)->i_mutex); 446 ret = 0; 447 } 448 } 449 450 dput(dir); 451 _leave(" = %d", ret); 452 return ret; 453 } 454 455 /* 456 * walk from the parent object to the child object through the backing 457 * filesystem, creating directories as we go 458 */ 459 int cachefiles_walk_to_object(struct cachefiles_object *parent, 460 struct cachefiles_object *object, 461 const char *key, 462 struct cachefiles_xattr *auxdata) 463 { 464 struct cachefiles_cache *cache; 465 struct dentry *dir, *next = NULL; 466 struct path path; 467 unsigned long start; 468 const char *name; 469 int ret, nlen; 470 471 _enter("OBJ%x{%p},OBJ%x,%s,", 472 parent->fscache.debug_id, parent->dentry, 473 object->fscache.debug_id, key); 474 475 cache = container_of(parent->fscache.cache, 476 struct cachefiles_cache, cache); 477 path.mnt = cache->mnt; 478 479 ASSERT(parent->dentry); 480 ASSERT(d_backing_inode(parent->dentry)); 481 482 if (!(d_is_dir(parent->dentry))) { 483 // TODO: convert file to dir 484 _leave("looking up in none directory"); 485 return -ENOBUFS; 486 } 487 488 dir = dget(parent->dentry); 489 490 advance: 491 /* attempt to transit the first directory component */ 492 name = key; 493 nlen = strlen(key); 494 495 /* key ends in a double NUL */ 496 key = key + nlen + 1; 497 if (!*key) 498 key = NULL; 499 500 lookup_again: 501 /* search the current directory for the element name */ 502 _debug("lookup '%s'", name); 503 504 mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT); 505 506 start = jiffies; 507 next = lookup_one_len(name, dir, nlen); 508 cachefiles_hist(cachefiles_lookup_histogram, start); 509 if (IS_ERR(next)) 510 goto lookup_error; 511 512 _debug("next -> %p %s", next, d_backing_inode(next) ? "positive" : "negative"); 513 514 if (!key) 515 object->new = !d_backing_inode(next); 516 517 /* if this element of the path doesn't exist, then the lookup phase 518 * failed, and we can release any readers in the certain knowledge that 519 * there's nothing for them to actually read */ 520 if (d_is_negative(next)) 521 fscache_object_lookup_negative(&object->fscache); 522 523 /* we need to create the object if it's negative */ 524 if (key || object->type == FSCACHE_COOKIE_TYPE_INDEX) { 525 /* index objects and intervening tree levels must be subdirs */ 526 if (d_is_negative(next)) { 527 ret = cachefiles_has_space(cache, 1, 0); 528 if (ret < 0) 529 goto no_space_error; 530 531 path.dentry = dir; 532 ret = security_path_mkdir(&path, next, 0); 533 if (ret < 0) 534 goto create_error; 535 start = jiffies; 536 ret = vfs_mkdir(d_inode(dir), next, 0); 537 cachefiles_hist(cachefiles_mkdir_histogram, start); 538 if (ret < 0) 539 goto create_error; 540 541 ASSERT(d_backing_inode(next)); 542 543 _debug("mkdir -> %p{%p{ino=%lu}}", 544 next, d_backing_inode(next), d_backing_inode(next)->i_ino); 545 546 } else if (!d_can_lookup(next)) { 547 pr_err("inode %lu is not a directory\n", 548 d_backing_inode(next)->i_ino); 549 ret = -ENOBUFS; 550 goto error; 551 } 552 553 } else { 554 /* non-index objects start out life as files */ 555 if (d_is_negative(next)) { 556 ret = cachefiles_has_space(cache, 1, 0); 557 if (ret < 0) 558 goto no_space_error; 559 560 path.dentry = dir; 561 ret = security_path_mknod(&path, next, S_IFREG, 0); 562 if (ret < 0) 563 goto create_error; 564 start = jiffies; 565 ret = vfs_create(d_inode(dir), next, S_IFREG, true); 566 cachefiles_hist(cachefiles_create_histogram, start); 567 if (ret < 0) 568 goto create_error; 569 570 ASSERT(d_backing_inode(next)); 571 572 _debug("create -> %p{%p{ino=%lu}}", 573 next, d_backing_inode(next), d_backing_inode(next)->i_ino); 574 575 } else if (!d_can_lookup(next) && 576 !d_is_reg(next) 577 ) { 578 pr_err("inode %lu is not a file or directory\n", 579 d_backing_inode(next)->i_ino); 580 ret = -ENOBUFS; 581 goto error; 582 } 583 } 584 585 /* process the next component */ 586 if (key) { 587 _debug("advance"); 588 mutex_unlock(&d_inode(dir)->i_mutex); 589 dput(dir); 590 dir = next; 591 next = NULL; 592 goto advance; 593 } 594 595 /* we've found the object we were looking for */ 596 object->dentry = next; 597 598 /* if we've found that the terminal object exists, then we need to 599 * check its attributes and delete it if it's out of date */ 600 if (!object->new) { 601 _debug("validate '%pd'", next); 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 609 ret = cachefiles_bury_object(cache, dir, next, true, 610 FSCACHE_OBJECT_IS_STALE); 611 dput(next); 612 next = NULL; 613 614 if (ret < 0) 615 goto delete_error; 616 617 _debug("redo lookup"); 618 fscache_object_retrying_stale(&object->fscache); 619 goto lookup_again; 620 } 621 } 622 623 /* note that we're now using this object */ 624 ret = cachefiles_mark_object_active(cache, object); 625 626 mutex_unlock(&d_inode(dir)->i_mutex); 627 dput(dir); 628 dir = NULL; 629 630 if (ret == -ETIMEDOUT) 631 goto mark_active_timed_out; 632 633 _debug("=== OBTAINED_OBJECT ==="); 634 635 if (object->new) { 636 /* attach data to a newly constructed terminal object */ 637 ret = cachefiles_set_object_xattr(object, auxdata); 638 if (ret < 0) 639 goto check_error; 640 } else { 641 /* always update the atime on an object we've just looked up 642 * (this is used to keep track of culling, and atimes are only 643 * updated by read, write and readdir but not lookup or 644 * open) */ 645 path.dentry = next; 646 touch_atime(&path); 647 } 648 649 /* open a file interface onto a data file */ 650 if (object->type != FSCACHE_COOKIE_TYPE_INDEX) { 651 if (d_is_reg(object->dentry)) { 652 const struct address_space_operations *aops; 653 654 ret = -EPERM; 655 aops = d_backing_inode(object->dentry)->i_mapping->a_ops; 656 if (!aops->bmap) 657 goto check_error; 658 659 object->backer = object->dentry; 660 } else { 661 BUG(); // TODO: open file in data-class subdir 662 } 663 } 664 665 object->new = 0; 666 fscache_obtained_object(&object->fscache); 667 668 _leave(" = 0 [%lu]", d_backing_inode(object->dentry)->i_ino); 669 return 0; 670 671 no_space_error: 672 fscache_object_mark_killed(&object->fscache, FSCACHE_OBJECT_NO_SPACE); 673 create_error: 674 _debug("create error %d", ret); 675 if (ret == -EIO) 676 cachefiles_io_error(cache, "Create/mkdir failed"); 677 goto error; 678 679 mark_active_timed_out: 680 _debug("mark active timed out"); 681 goto release_dentry; 682 683 check_error: 684 _debug("check error %d", ret); 685 write_lock(&cache->active_lock); 686 rb_erase(&object->active_node, &cache->active_nodes); 687 clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags); 688 wake_up_bit(&object->flags, CACHEFILES_OBJECT_ACTIVE); 689 write_unlock(&cache->active_lock); 690 release_dentry: 691 dput(object->dentry); 692 object->dentry = NULL; 693 goto error_out; 694 695 delete_error: 696 _debug("delete error %d", ret); 697 goto error_out2; 698 699 lookup_error: 700 _debug("lookup error %ld", PTR_ERR(next)); 701 ret = PTR_ERR(next); 702 if (ret == -EIO) 703 cachefiles_io_error(cache, "Lookup failed"); 704 next = NULL; 705 error: 706 mutex_unlock(&d_inode(dir)->i_mutex); 707 dput(next); 708 error_out2: 709 dput(dir); 710 error_out: 711 _leave(" = error %d", -ret); 712 return ret; 713 } 714 715 /* 716 * get a subdirectory 717 */ 718 struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache, 719 struct dentry *dir, 720 const char *dirname) 721 { 722 struct dentry *subdir; 723 unsigned long start; 724 struct path path; 725 int ret; 726 727 _enter(",,%s", dirname); 728 729 /* search the current directory for the element name */ 730 mutex_lock(&d_inode(dir)->i_mutex); 731 732 start = jiffies; 733 subdir = lookup_one_len(dirname, dir, strlen(dirname)); 734 cachefiles_hist(cachefiles_lookup_histogram, start); 735 if (IS_ERR(subdir)) { 736 if (PTR_ERR(subdir) == -ENOMEM) 737 goto nomem_d_alloc; 738 goto lookup_error; 739 } 740 741 _debug("subdir -> %p %s", 742 subdir, d_backing_inode(subdir) ? "positive" : "negative"); 743 744 /* we need to create the subdir if it doesn't exist yet */ 745 if (d_is_negative(subdir)) { 746 ret = cachefiles_has_space(cache, 1, 0); 747 if (ret < 0) 748 goto mkdir_error; 749 750 _debug("attempt mkdir"); 751 752 path.mnt = cache->mnt; 753 path.dentry = dir; 754 ret = security_path_mkdir(&path, subdir, 0700); 755 if (ret < 0) 756 goto mkdir_error; 757 ret = vfs_mkdir(d_inode(dir), subdir, 0700); 758 if (ret < 0) 759 goto mkdir_error; 760 761 ASSERT(d_backing_inode(subdir)); 762 763 _debug("mkdir -> %p{%p{ino=%lu}}", 764 subdir, 765 d_backing_inode(subdir), 766 d_backing_inode(subdir)->i_ino); 767 } 768 769 mutex_unlock(&d_inode(dir)->i_mutex); 770 771 /* we need to make sure the subdir is a directory */ 772 ASSERT(d_backing_inode(subdir)); 773 774 if (!d_can_lookup(subdir)) { 775 pr_err("%s is not a directory\n", dirname); 776 ret = -EIO; 777 goto check_error; 778 } 779 780 ret = -EPERM; 781 if (!d_backing_inode(subdir)->i_op->setxattr || 782 !d_backing_inode(subdir)->i_op->getxattr || 783 !d_backing_inode(subdir)->i_op->lookup || 784 !d_backing_inode(subdir)->i_op->mkdir || 785 !d_backing_inode(subdir)->i_op->create || 786 (!d_backing_inode(subdir)->i_op->rename && 787 !d_backing_inode(subdir)->i_op->rename2) || 788 !d_backing_inode(subdir)->i_op->rmdir || 789 !d_backing_inode(subdir)->i_op->unlink) 790 goto check_error; 791 792 _leave(" = [%lu]", d_backing_inode(subdir)->i_ino); 793 return subdir; 794 795 check_error: 796 dput(subdir); 797 _leave(" = %d [check]", ret); 798 return ERR_PTR(ret); 799 800 mkdir_error: 801 mutex_unlock(&d_inode(dir)->i_mutex); 802 dput(subdir); 803 pr_err("mkdir %s failed with error %d\n", dirname, ret); 804 return ERR_PTR(ret); 805 806 lookup_error: 807 mutex_unlock(&d_inode(dir)->i_mutex); 808 ret = PTR_ERR(subdir); 809 pr_err("Lookup %s failed with error %d\n", dirname, ret); 810 return ERR_PTR(ret); 811 812 nomem_d_alloc: 813 mutex_unlock(&d_inode(dir)->i_mutex); 814 _leave(" = -ENOMEM"); 815 return ERR_PTR(-ENOMEM); 816 } 817 818 /* 819 * find out if an object is in use or not 820 * - if finds object and it's not in use: 821 * - returns a pointer to the object and a reference on it 822 * - returns with the directory locked 823 */ 824 static struct dentry *cachefiles_check_active(struct cachefiles_cache *cache, 825 struct dentry *dir, 826 char *filename) 827 { 828 struct cachefiles_object *object; 829 struct rb_node *_n; 830 struct dentry *victim; 831 unsigned long start; 832 int ret; 833 834 //_enter(",%pd/,%s", 835 // dir, filename); 836 837 /* look up the victim */ 838 mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT); 839 840 start = jiffies; 841 victim = lookup_one_len(filename, dir, strlen(filename)); 842 cachefiles_hist(cachefiles_lookup_histogram, start); 843 if (IS_ERR(victim)) 844 goto lookup_error; 845 846 //_debug("victim -> %p %s", 847 // victim, d_backing_inode(victim) ? "positive" : "negative"); 848 849 /* if the object is no longer there then we probably retired the object 850 * at the netfs's request whilst the cull was in progress 851 */ 852 if (d_is_negative(victim)) { 853 mutex_unlock(&d_inode(dir)->i_mutex); 854 dput(victim); 855 _leave(" = -ENOENT [absent]"); 856 return ERR_PTR(-ENOENT); 857 } 858 859 /* check to see if we're using this object */ 860 read_lock(&cache->active_lock); 861 862 _n = cache->active_nodes.rb_node; 863 864 while (_n) { 865 object = rb_entry(_n, struct cachefiles_object, active_node); 866 867 if (object->dentry > victim) 868 _n = _n->rb_left; 869 else if (object->dentry < victim) 870 _n = _n->rb_right; 871 else 872 goto object_in_use; 873 } 874 875 read_unlock(&cache->active_lock); 876 877 //_leave(" = %p", victim); 878 return victim; 879 880 object_in_use: 881 read_unlock(&cache->active_lock); 882 mutex_unlock(&d_inode(dir)->i_mutex); 883 dput(victim); 884 //_leave(" = -EBUSY [in use]"); 885 return ERR_PTR(-EBUSY); 886 887 lookup_error: 888 mutex_unlock(&d_inode(dir)->i_mutex); 889 ret = PTR_ERR(victim); 890 if (ret == -ENOENT) { 891 /* file or dir now absent - probably retired by netfs */ 892 _leave(" = -ESTALE [absent]"); 893 return ERR_PTR(-ESTALE); 894 } 895 896 if (ret == -EIO) { 897 cachefiles_io_error(cache, "Lookup failed"); 898 } else if (ret != -ENOMEM) { 899 pr_err("Internal error: %d\n", ret); 900 ret = -EIO; 901 } 902 903 _leave(" = %d", ret); 904 return ERR_PTR(ret); 905 } 906 907 /* 908 * cull an object if it's not in use 909 * - called only by cache manager daemon 910 */ 911 int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir, 912 char *filename) 913 { 914 struct dentry *victim; 915 int ret; 916 917 _enter(",%pd/,%s", dir, filename); 918 919 victim = cachefiles_check_active(cache, dir, filename); 920 if (IS_ERR(victim)) 921 return PTR_ERR(victim); 922 923 _debug("victim -> %p %s", 924 victim, d_backing_inode(victim) ? "positive" : "negative"); 925 926 /* okay... the victim is not being used so we can cull it 927 * - start by marking it as stale 928 */ 929 _debug("victim is cullable"); 930 931 ret = cachefiles_remove_object_xattr(cache, victim); 932 if (ret < 0) 933 goto error_unlock; 934 935 /* actually remove the victim (drops the dir mutex) */ 936 _debug("bury"); 937 938 ret = cachefiles_bury_object(cache, dir, victim, false, 939 FSCACHE_OBJECT_WAS_CULLED); 940 if (ret < 0) 941 goto error; 942 943 dput(victim); 944 _leave(" = 0"); 945 return 0; 946 947 error_unlock: 948 mutex_unlock(&d_inode(dir)->i_mutex); 949 error: 950 dput(victim); 951 if (ret == -ENOENT) { 952 /* file or dir now absent - probably retired by netfs */ 953 _leave(" = -ESTALE [absent]"); 954 return -ESTALE; 955 } 956 957 if (ret != -ENOMEM) { 958 pr_err("Internal error: %d\n", ret); 959 ret = -EIO; 960 } 961 962 _leave(" = %d", ret); 963 return ret; 964 } 965 966 /* 967 * find out if an object is in use or not 968 * - called only by cache manager daemon 969 * - returns -EBUSY or 0 to indicate whether an object is in use or not 970 */ 971 int cachefiles_check_in_use(struct cachefiles_cache *cache, struct dentry *dir, 972 char *filename) 973 { 974 struct dentry *victim; 975 976 //_enter(",%pd/,%s", 977 // dir, filename); 978 979 victim = cachefiles_check_active(cache, dir, filename); 980 if (IS_ERR(victim)) 981 return PTR_ERR(victim); 982 983 mutex_unlock(&d_inode(dir)->i_mutex); 984 dput(victim); 985 //_leave(" = 0"); 986 return 0; 987 } 988