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 { 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, 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 if (test_and_set_bit(CACHEFILES_OBJECT_BURIED, &object->flags)) { 137 pr_err("Error: Object already preemptively buried\n"); 138 } 139 140 write_unlock(&cache->active_lock); 141 _leave(" [owner marked]"); 142 } 143 144 /* 145 * record the fact that an object is now active 146 */ 147 static int cachefiles_mark_object_active(struct cachefiles_cache *cache, 148 struct cachefiles_object *object) 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 159 if (test_and_set_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags)) { 160 pr_err("Error: Object already active\n"); 161 cachefiles_printk_object(object, NULL); 162 BUG(); 163 } 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); 186 _leave(" = 0"); 187 return 0; 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: 192 if (fscache_object_is_live(&xobject->fscache)) { 193 pr_err("\n"); 194 pr_err("Error: Unexpected object collision\n"); 195 cachefiles_printk_object(object, xobject); 196 BUG(); 197 } 198 atomic_inc(&xobject->usage); 199 write_unlock(&cache->active_lock); 200 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 */ 210 if (work_pending(&xobject->fscache.work)) { 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 218 * is done, or the fscache_object is congested */ 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; 226 227 requeue = fscache_object_sleep_till_congested(&timeout); 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) { 240 pr_err("\n"); 241 pr_err("Error: Overlong wait for old active object to go away\n"); 242 cachefiles_printk_object(object, xobject); 243 goto requeue; 244 } 245 } 246 247 ASSERT(!test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags)); 248 249 cache->cache.ops->put_object(&xobject->fscache); 250 goto try_again; 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; 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, 268 struct dentry *rep, 269 bool preemptive) 270 { 271 struct dentry *grave, *trap; 272 struct path path, path_to_graveyard; 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 280 _debug("remove %p from %p", rep, dir); 281 282 /* non-directories can just be unlinked */ 283 if (!S_ISDIR(rep->d_inode->i_mode)) { 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(dir->d_inode, rep, NULL); 293 294 if (preemptive) 295 cachefiles_mark_object_buried(cache, rep); 296 } 297 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 */ 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(dir->d_inode, rep, 394 cache->graveyard->d_inode, 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); 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(object->dentry->d_inode); 422 ASSERT(object->dentry->d_parent); 423 424 dir = dget_parent(object->dentry); 425 426 mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT); 427 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"); 432 mutex_unlock(&dir->d_inode->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 } 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 } 447 } 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; 465 struct path path; 466 unsigned long start; 467 const char *name; 468 int ret, nlen; 469 470 _enter("OBJ%x{%p},OBJ%x,%s,", 471 parent->fscache.debug_id, parent->dentry, 472 object->fscache.debug_id, key); 473 474 cache = container_of(parent->fscache.cache, 475 struct cachefiles_cache, cache); 476 path.mnt = cache->mnt; 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 503 mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT); 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 530 path.dentry = dir; 531 ret = security_path_mkdir(&path, next, 0); 532 if (ret < 0) 533 goto create_error; 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)) { 546 pr_err("inode %lu is not a directory\n", 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 559 path.dentry = dir; 560 ret = security_path_mknod(&path, next, S_IFREG, 0); 561 if (ret < 0) 562 goto create_error; 563 start = jiffies; 564 ret = vfs_create(dir->d_inode, next, S_IFREG, true); 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 ) { 577 pr_err("inode %lu is not a file or directory\n", 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 609 ret = cachefiles_bury_object(cache, dir, next, true); 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 */ 622 ret = cachefiles_mark_object_active(cache, object); 623 624 mutex_unlock(&dir->d_inode->i_mutex); 625 dput(dir); 626 dir = NULL; 627 628 if (ret == -ETIMEDOUT) 629 goto mark_active_timed_out; 630 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) */ 643 path.dentry = next; 644 touch_atime(&path); 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 675 mark_active_timed_out: 676 _debug("mark active timed out"); 677 goto release_dentry; 678 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); 686 release_dentry: 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: 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; 720 struct path path; 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 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; 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)) { 771 pr_err("%s is not a directory\n", dirname); 772 ret = -EIO; 773 goto check_error; 774 } 775 776 ret = -EPERM; 777 if (!subdir->d_inode->i_op->setxattr || 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 || 782 (!subdir->d_inode->i_op->rename && 783 !subdir->d_inode->i_op->rename2) || 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); 799 pr_err("mkdir %s failed with error %d\n", dirname, ret); 800 return ERR_PTR(ret); 801 802 lookup_error: 803 mutex_unlock(&dir->d_inode->i_mutex); 804 ret = PTR_ERR(subdir); 805 pr_err("Lookup %s failed with error %d\n", dirname, ret); 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 */ 834 mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT); 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) { 895 pr_err("Internal error: %d\n", ret); 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 935 ret = cachefiles_bury_object(cache, dir, victim, false); 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) { 954 pr_err("Internal error: %d\n", ret); 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 } 984