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