linux/fs/ocfs2/dcache.c
<<
>>
Prefs
   1/* -*- mode: c; c-basic-offset: 8; -*-
   2 * vim: noexpandtab sw=8 ts=8 sts=0:
   3 *
   4 * dcache.c
   5 *
   6 * dentry cache handling code
   7 *
   8 * Copyright (C) 2002, 2004 Oracle.  All rights reserved.
   9 *
  10 * This program is free software; you can redistribute it and/or
  11 * modify it under the terms of the GNU General Public
  12 * License as published by the Free Software Foundation; either
  13 * version 2 of the License, or (at your option) any later version.
  14 *
  15 * This program is distributed in the hope that it will be useful,
  16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18 * General Public License for more details.
  19 *
  20 * You should have received a copy of the GNU General Public
  21 * License along with this program; if not, write to the
  22 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23 * Boston, MA 021110-1307, USA.
  24 */
  25
  26#include <linux/fs.h>
  27#include <linux/types.h>
  28#include <linux/slab.h>
  29#include <linux/namei.h>
  30
  31#include <cluster/masklog.h>
  32
  33#include "ocfs2.h"
  34
  35#include "alloc.h"
  36#include "dcache.h"
  37#include "dlmglue.h"
  38#include "file.h"
  39#include "inode.h"
  40#include "super.h"
  41#include "ocfs2_trace.h"
  42
  43void ocfs2_dentry_attach_gen(struct dentry *dentry)
  44{
  45        unsigned long gen =
  46                OCFS2_I(dentry->d_parent->d_inode)->ip_dir_lock_gen;
  47        BUG_ON(dentry->d_inode);
  48        dentry->d_fsdata = (void *)gen;
  49}
  50
  51
  52static int ocfs2_dentry_revalidate(struct dentry *dentry, unsigned int flags)
  53{
  54        struct inode *inode;
  55        int ret = 0;    /* if all else fails, just return false */
  56        struct ocfs2_super *osb;
  57
  58        if (flags & LOOKUP_RCU)
  59                return -ECHILD;
  60
  61        inode = dentry->d_inode;
  62        osb = OCFS2_SB(dentry->d_sb);
  63
  64        trace_ocfs2_dentry_revalidate(dentry, dentry->d_name.len,
  65                                      dentry->d_name.name);
  66
  67        /* For a negative dentry -
  68         * check the generation number of the parent and compare with the
  69         * one stored in the inode.
  70         */
  71        if (inode == NULL) {
  72                unsigned long gen = (unsigned long) dentry->d_fsdata;
  73                unsigned long pgen =
  74                        OCFS2_I(dentry->d_parent->d_inode)->ip_dir_lock_gen;
  75
  76                trace_ocfs2_dentry_revalidate_negative(dentry->d_name.len,
  77                                                       dentry->d_name.name,
  78                                                       pgen, gen);
  79                if (gen != pgen)
  80                        goto bail;
  81                goto valid;
  82        }
  83
  84        BUG_ON(!osb);
  85
  86        if (inode == osb->root_inode || is_bad_inode(inode))
  87                goto bail;
  88
  89        spin_lock(&OCFS2_I(inode)->ip_lock);
  90        /* did we or someone else delete this inode? */
  91        if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_DELETED) {
  92                spin_unlock(&OCFS2_I(inode)->ip_lock);
  93                trace_ocfs2_dentry_revalidate_delete(
  94                                (unsigned long long)OCFS2_I(inode)->ip_blkno);
  95                goto bail;
  96        }
  97        spin_unlock(&OCFS2_I(inode)->ip_lock);
  98
  99        /*
 100         * We don't need a cluster lock to test this because once an
 101         * inode nlink hits zero, it never goes back.
 102         */
 103        if (inode->i_nlink == 0) {
 104                trace_ocfs2_dentry_revalidate_orphaned(
 105                        (unsigned long long)OCFS2_I(inode)->ip_blkno,
 106                        S_ISDIR(inode->i_mode));
 107                goto bail;
 108        }
 109
 110        /*
 111         * If the last lookup failed to create dentry lock, let us
 112         * redo it.
 113         */
 114        if (!dentry->d_fsdata) {
 115                trace_ocfs2_dentry_revalidate_nofsdata(
 116                                (unsigned long long)OCFS2_I(inode)->ip_blkno);
 117                goto bail;
 118        }
 119
 120valid:
 121        ret = 1;
 122
 123bail:
 124        trace_ocfs2_dentry_revalidate_ret(ret);
 125        return ret;
 126}
 127
 128static int ocfs2_match_dentry(struct dentry *dentry,
 129                              u64 parent_blkno,
 130                              int skip_unhashed)
 131{
 132        struct inode *parent;
 133
 134        /*
 135         * ocfs2_lookup() does a d_splice_alias() _before_ attaching
 136         * to the lock data, so we skip those here, otherwise
 137         * ocfs2_dentry_attach_lock() will get its original dentry
 138         * back.
 139         */
 140        if (!dentry->d_fsdata)
 141                return 0;
 142
 143        if (!dentry->d_parent)
 144                return 0;
 145
 146        if (skip_unhashed && d_unhashed(dentry))
 147                return 0;
 148
 149        parent = dentry->d_parent->d_inode;
 150        /* Negative parent dentry? */
 151        if (!parent)
 152                return 0;
 153
 154        /* Name is in a different directory. */
 155        if (OCFS2_I(parent)->ip_blkno != parent_blkno)
 156                return 0;
 157
 158        return 1;
 159}
 160
 161/*
 162 * Walk the inode alias list, and find a dentry which has a given
 163 * parent. ocfs2_dentry_attach_lock() wants to find _any_ alias as it
 164 * is looking for a dentry_lock reference. The downconvert thread is
 165 * looking to unhash aliases, so we allow it to skip any that already
 166 * have that property.
 167 */
 168struct dentry *ocfs2_find_local_alias(struct inode *inode,
 169                                      u64 parent_blkno,
 170                                      int skip_unhashed)
 171{
 172        struct hlist_node *p;
 173        struct dentry *dentry;
 174
 175        spin_lock(&inode->i_lock);
 176        hlist_for_each_entry(dentry, p, &inode->i_dentry, d_alias) {
 177                spin_lock(&dentry->d_lock);
 178                if (ocfs2_match_dentry(dentry, parent_blkno, skip_unhashed)) {
 179                        trace_ocfs2_find_local_alias(dentry->d_name.len,
 180                                                     dentry->d_name.name);
 181
 182                        dget_dlock(dentry);
 183                        spin_unlock(&dentry->d_lock);
 184                        spin_unlock(&inode->i_lock);
 185                        return dentry;
 186                }
 187                spin_unlock(&dentry->d_lock);
 188        }
 189        spin_unlock(&inode->i_lock);
 190        return NULL;
 191}
 192
 193DEFINE_SPINLOCK(dentry_attach_lock);
 194
 195/*
 196 * Attach this dentry to a cluster lock.
 197 *
 198 * Dentry locks cover all links in a given directory to a particular
 199 * inode. We do this so that ocfs2 can build a lock name which all
 200 * nodes in the cluster can agree on at all times. Shoving full names
 201 * in the cluster lock won't work due to size restrictions. Covering
 202 * links inside of a directory is a good compromise because it still
 203 * allows us to use the parent directory lock to synchronize
 204 * operations.
 205 *
 206 * Call this function with the parent dir semaphore and the parent dir
 207 * cluster lock held.
 208 *
 209 * The dir semaphore will protect us from having to worry about
 210 * concurrent processes on our node trying to attach a lock at the
 211 * same time.
 212 *
 213 * The dir cluster lock (held at either PR or EX mode) protects us
 214 * from unlink and rename on other nodes.
 215 *
 216 * A dput() can happen asynchronously due to pruning, so we cover
 217 * attaching and detaching the dentry lock with a
 218 * dentry_attach_lock.
 219 *
 220 * A node which has done lookup on a name retains a protected read
 221 * lock until final dput. If the user requests and unlink or rename,
 222 * the protected read is upgraded to an exclusive lock. Other nodes
 223 * who have seen the dentry will then be informed that they need to
 224 * downgrade their lock, which will involve d_delete on the
 225 * dentry. This happens in ocfs2_dentry_convert_worker().
 226 */
 227int ocfs2_dentry_attach_lock(struct dentry *dentry,
 228                             struct inode *inode,
 229                             u64 parent_blkno)
 230{
 231        int ret;
 232        struct dentry *alias;
 233        struct ocfs2_dentry_lock *dl = dentry->d_fsdata;
 234
 235        trace_ocfs2_dentry_attach_lock(dentry->d_name.len, dentry->d_name.name,
 236                                       (unsigned long long)parent_blkno, dl);
 237
 238        /*
 239         * Negative dentry. We ignore these for now.
 240         *
 241         * XXX: Could we can improve ocfs2_dentry_revalidate() by
 242         * tracking these?
 243         */
 244        if (!inode)
 245                return 0;
 246
 247        if (!dentry->d_inode && dentry->d_fsdata) {
 248                /* Converting a negative dentry to positive
 249                   Clear dentry->d_fsdata */
 250                dentry->d_fsdata = dl = NULL;
 251        }
 252
 253        if (dl) {
 254                mlog_bug_on_msg(dl->dl_parent_blkno != parent_blkno,
 255                                " \"%.*s\": old parent: %llu, new: %llu\n",
 256                                dentry->d_name.len, dentry->d_name.name,
 257                                (unsigned long long)parent_blkno,
 258                                (unsigned long long)dl->dl_parent_blkno);
 259                return 0;
 260        }
 261
 262        alias = ocfs2_find_local_alias(inode, parent_blkno, 0);
 263        if (alias) {
 264                /*
 265                 * Great, an alias exists, which means we must have a
 266                 * dentry lock already. We can just grab the lock off
 267                 * the alias and add it to the list.
 268                 *
 269                 * We're depending here on the fact that this dentry
 270                 * was found and exists in the dcache and so must have
 271                 * a reference to the dentry_lock because we can't
 272                 * race creates. Final dput() cannot happen on it
 273                 * since we have it pinned, so our reference is safe.
 274                 */
 275                dl = alias->d_fsdata;
 276                mlog_bug_on_msg(!dl, "parent %llu, ino %llu\n",
 277                                (unsigned long long)parent_blkno,
 278                                (unsigned long long)OCFS2_I(inode)->ip_blkno);
 279
 280                mlog_bug_on_msg(dl->dl_parent_blkno != parent_blkno,
 281                                " \"%.*s\": old parent: %llu, new: %llu\n",
 282                                dentry->d_name.len, dentry->d_name.name,
 283                                (unsigned long long)parent_blkno,
 284                                (unsigned long long)dl->dl_parent_blkno);
 285
 286                trace_ocfs2_dentry_attach_lock_found(dl->dl_lockres.l_name,
 287                                (unsigned long long)parent_blkno,
 288                                (unsigned long long)OCFS2_I(inode)->ip_blkno);
 289
 290                goto out_attach;
 291        }
 292
 293        /*
 294         * There are no other aliases
 295         */
 296        dl = kmalloc(sizeof(*dl), GFP_NOFS);
 297        if (!dl) {
 298                ret = -ENOMEM;
 299                mlog_errno(ret);
 300                return ret;
 301        }
 302
 303        dl->dl_count = 0;
 304        /*
 305         * Does this have to happen below, for all attaches, in case
 306         * the struct inode gets blown away by the downconvert thread?
 307         */
 308        dl->dl_inode = igrab(inode);
 309        dl->dl_parent_blkno = parent_blkno;
 310        ocfs2_dentry_lock_res_init(dl, parent_blkno, inode);
 311
 312out_attach:
 313        spin_lock(&dentry_attach_lock);
 314        dentry->d_fsdata = dl;
 315        dl->dl_count++;
 316        spin_unlock(&dentry_attach_lock);
 317
 318        /*
 319         * This actually gets us our PRMODE level lock. From now on,
 320         * we'll have a notification if one of these names is
 321         * destroyed on another node.
 322         */
 323        ret = ocfs2_dentry_lock(dentry, 0);
 324        if (!ret)
 325                ocfs2_dentry_unlock(dentry, 0);
 326        else
 327                mlog_errno(ret);
 328
 329        /*
 330         * In case of error, manually free the allocation and do the iput().
 331         * We need to do this because error here means no d_instantiate(),
 332         * which means iput() will not be called during dput(dentry).
 333         */
 334        if (ret < 0 && !alias) {
 335                ocfs2_lock_res_free(&dl->dl_lockres);
 336                BUG_ON(dl->dl_count != 1);
 337                spin_lock(&dentry_attach_lock);
 338                dentry->d_fsdata = NULL;
 339                spin_unlock(&dentry_attach_lock);
 340                kfree(dl);
 341                iput(inode);
 342        }
 343
 344        dput(alias);
 345
 346        return ret;
 347}
 348
 349DEFINE_SPINLOCK(dentry_list_lock);
 350
 351/* We limit the number of dentry locks to drop in one go. We have
 352 * this limit so that we don't starve other users of ocfs2_wq. */
 353#define DL_INODE_DROP_COUNT 64
 354
 355/* Drop inode references from dentry locks */
 356static void __ocfs2_drop_dl_inodes(struct ocfs2_super *osb, int drop_count)
 357{
 358        struct ocfs2_dentry_lock *dl;
 359
 360        spin_lock(&dentry_list_lock);
 361        while (osb->dentry_lock_list && (drop_count < 0 || drop_count--)) {
 362                dl = osb->dentry_lock_list;
 363                osb->dentry_lock_list = dl->dl_next;
 364                spin_unlock(&dentry_list_lock);
 365                iput(dl->dl_inode);
 366                kfree(dl);
 367                spin_lock(&dentry_list_lock);
 368        }
 369        spin_unlock(&dentry_list_lock);
 370}
 371
 372void ocfs2_drop_dl_inodes(struct work_struct *work)
 373{
 374        struct ocfs2_super *osb = container_of(work, struct ocfs2_super,
 375                                               dentry_lock_work);
 376
 377        __ocfs2_drop_dl_inodes(osb, DL_INODE_DROP_COUNT);
 378        /*
 379         * Don't queue dropping if umount is in progress. We flush the
 380         * list in ocfs2_dismount_volume
 381         */
 382        spin_lock(&dentry_list_lock);
 383        if (osb->dentry_lock_list &&
 384            !ocfs2_test_osb_flag(osb, OCFS2_OSB_DROP_DENTRY_LOCK_IMMED))
 385                queue_work(ocfs2_wq, &osb->dentry_lock_work);
 386        spin_unlock(&dentry_list_lock);
 387}
 388
 389/* Flush the whole work queue */
 390void ocfs2_drop_all_dl_inodes(struct ocfs2_super *osb)
 391{
 392        __ocfs2_drop_dl_inodes(osb, -1);
 393}
 394
 395/*
 396 * ocfs2_dentry_iput() and friends.
 397 *
 398 * At this point, our particular dentry is detached from the inodes
 399 * alias list, so there's no way that the locking code can find it.
 400 *
 401 * The interesting stuff happens when we determine that our lock needs
 402 * to go away because this is the last subdir alias in the
 403 * system. This function needs to handle a couple things:
 404 *
 405 * 1) Synchronizing lock shutdown with the downconvert threads. This
 406 *    is already handled for us via the lockres release drop function
 407 *    called in ocfs2_release_dentry_lock()
 408 *
 409 * 2) A race may occur when we're doing our lock shutdown and
 410 *    another process wants to create a new dentry lock. Right now we
 411 *    let them race, which means that for a very short while, this
 412 *    node might have two locks on a lock resource. This should be a
 413 *    problem though because one of them is in the process of being
 414 *    thrown out.
 415 */
 416static void ocfs2_drop_dentry_lock(struct ocfs2_super *osb,
 417                                   struct ocfs2_dentry_lock *dl)
 418{
 419        ocfs2_simple_drop_lockres(osb, &dl->dl_lockres);
 420        ocfs2_lock_res_free(&dl->dl_lockres);
 421
 422        /* We leave dropping of inode reference to ocfs2_wq as that can
 423         * possibly lead to inode deletion which gets tricky */
 424        spin_lock(&dentry_list_lock);
 425        if (!osb->dentry_lock_list &&
 426            !ocfs2_test_osb_flag(osb, OCFS2_OSB_DROP_DENTRY_LOCK_IMMED))
 427                queue_work(ocfs2_wq, &osb->dentry_lock_work);
 428        dl->dl_next = osb->dentry_lock_list;
 429        osb->dentry_lock_list = dl;
 430        spin_unlock(&dentry_list_lock);
 431}
 432
 433void ocfs2_dentry_lock_put(struct ocfs2_super *osb,
 434                           struct ocfs2_dentry_lock *dl)
 435{
 436        int unlock;
 437
 438        BUG_ON(dl->dl_count == 0);
 439
 440        spin_lock(&dentry_attach_lock);
 441        dl->dl_count--;
 442        unlock = !dl->dl_count;
 443        spin_unlock(&dentry_attach_lock);
 444
 445        if (unlock)
 446                ocfs2_drop_dentry_lock(osb, dl);
 447}
 448
 449static void ocfs2_dentry_iput(struct dentry *dentry, struct inode *inode)
 450{
 451        struct ocfs2_dentry_lock *dl = dentry->d_fsdata;
 452
 453        if (!dl) {
 454                /*
 455                 * No dentry lock is ok if we're disconnected or
 456                 * unhashed.
 457                 */
 458                if (!(dentry->d_flags & DCACHE_DISCONNECTED) &&
 459                    !d_unhashed(dentry)) {
 460                        unsigned long long ino = 0ULL;
 461                        if (inode)
 462                                ino = (unsigned long long)OCFS2_I(inode)->ip_blkno;
 463                        mlog(ML_ERROR, "Dentry is missing cluster lock. "
 464                             "inode: %llu, d_flags: 0x%x, d_name: %.*s\n",
 465                             ino, dentry->d_flags, dentry->d_name.len,
 466                             dentry->d_name.name);
 467                }
 468
 469                goto out;
 470        }
 471
 472        mlog_bug_on_msg(dl->dl_count == 0, "dentry: %.*s, count: %u\n",
 473                        dentry->d_name.len, dentry->d_name.name,
 474                        dl->dl_count);
 475
 476        ocfs2_dentry_lock_put(OCFS2_SB(dentry->d_sb), dl);
 477
 478out:
 479        iput(inode);
 480}
 481
 482/*
 483 * d_move(), but keep the locks in sync.
 484 *
 485 * When we are done, "dentry" will have the parent dir and name of
 486 * "target", which will be thrown away.
 487 *
 488 * We manually update the lock of "dentry" if need be.
 489 *
 490 * "target" doesn't have it's dentry lock touched - we allow the later
 491 * dput() to handle this for us.
 492 *
 493 * This is called during ocfs2_rename(), while holding parent
 494 * directory locks. The dentries have already been deleted on other
 495 * nodes via ocfs2_remote_dentry_delete().
 496 *
 497 * Normally, the VFS handles the d_move() for the file system, after
 498 * the ->rename() callback. OCFS2 wants to handle this internally, so
 499 * the new lock can be created atomically with respect to the cluster.
 500 */
 501void ocfs2_dentry_move(struct dentry *dentry, struct dentry *target,
 502                       struct inode *old_dir, struct inode *new_dir)
 503{
 504        int ret;
 505        struct ocfs2_super *osb = OCFS2_SB(old_dir->i_sb);
 506        struct inode *inode = dentry->d_inode;
 507
 508        /*
 509         * Move within the same directory, so the actual lock info won't
 510         * change.
 511         *
 512         * XXX: Is there any advantage to dropping the lock here?
 513         */
 514        if (old_dir == new_dir)
 515                goto out_move;
 516
 517        ocfs2_dentry_lock_put(osb, dentry->d_fsdata);
 518
 519        dentry->d_fsdata = NULL;
 520        ret = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(new_dir)->ip_blkno);
 521        if (ret)
 522                mlog_errno(ret);
 523
 524out_move:
 525        d_move(dentry, target);
 526}
 527
 528const struct dentry_operations ocfs2_dentry_ops = {
 529        .d_revalidate           = ocfs2_dentry_revalidate,
 530        .d_iput                 = ocfs2_dentry_iput,
 531};
 532
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.