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 dentry *dentry;
 173
 174        spin_lock(&inode->i_lock);
 175        hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
 176                spin_lock(&dentry->d_lock);
 177                if (ocfs2_match_dentry(dentry, parent_blkno, skip_unhashed)) {
 178                        trace_ocfs2_find_local_alias(dentry->d_name.len,
 179                                                     dentry->d_name.name);
 180
 181                        dget_dlock(dentry);
 182                        spin_unlock(&dentry->d_lock);
 183                        spin_unlock(&inode->i_lock);
 184                        return dentry;
 185                }
 186                spin_unlock(&dentry->d_lock);
 187        }
 188        spin_unlock(&inode->i_lock);
 189        return NULL;
 190}
 191
 192DEFINE_SPINLOCK(dentry_attach_lock);
 193
 194/*
 195 * Attach this dentry to a cluster lock.
 196 *
 197 * Dentry locks cover all links in a given directory to a particular
 198 * inode. We do this so that ocfs2 can build a lock name which all
 199 * nodes in the cluster can agree on at all times. Shoving full names
 200 * in the cluster lock won't work due to size restrictions. Covering
 201 * links inside of a directory is a good compromise because it still
 202 * allows us to use the parent directory lock to synchronize
 203 * operations.
 204 *
 205 * Call this function with the parent dir semaphore and the parent dir
 206 * cluster lock held.
 207 *
 208 * The dir semaphore will protect us from having to worry about
 209 * concurrent processes on our node trying to attach a lock at the
 210 * same time.
 211 *
 212 * The dir cluster lock (held at either PR or EX mode) protects us
 213 * from unlink and rename on other nodes.
 214 *
 215 * A dput() can happen asynchronously due to pruning, so we cover
 216 * attaching and detaching the dentry lock with a
 217 * dentry_attach_lock.
 218 *
 219 * A node which has done lookup on a name retains a protected read
 220 * lock until final dput. If the user requests and unlink or rename,
 221 * the protected read is upgraded to an exclusive lock. Other nodes
 222 * who have seen the dentry will then be informed that they need to
 223 * downgrade their lock, which will involve d_delete on the
 224 * dentry. This happens in ocfs2_dentry_convert_worker().
 225 */
 226int ocfs2_dentry_attach_lock(struct dentry *dentry,
 227                             struct inode *inode,
 228                             u64 parent_blkno)
 229{
 230        int ret;
 231        struct dentry *alias;
 232        struct ocfs2_dentry_lock *dl = dentry->d_fsdata;
 233
 234        trace_ocfs2_dentry_attach_lock(dentry->d_name.len, dentry->d_name.name,
 235                                       (unsigned long long)parent_blkno, dl);
 236
 237        /*
 238         * Negative dentry. We ignore these for now.
 239         *
 240         * XXX: Could we can improve ocfs2_dentry_revalidate() by
 241         * tracking these?
 242         */
 243        if (!inode)
 244                return 0;
 245
 246        if (!dentry->d_inode && dentry->d_fsdata) {
 247                /* Converting a negative dentry to positive
 248                   Clear dentry->d_fsdata */
 249                dentry->d_fsdata = dl = NULL;
 250        }
 251
 252        if (dl) {
 253                mlog_bug_on_msg(dl->dl_parent_blkno != parent_blkno,
 254                                " \"%.*s\": old parent: %llu, new: %llu\n",
 255                                dentry->d_name.len, dentry->d_name.name,
 256                                (unsigned long long)parent_blkno,
 257                                (unsigned long long)dl->dl_parent_blkno);
 258                return 0;
 259        }
 260
 261        alias = ocfs2_find_local_alias(inode, parent_blkno, 0);
 262        if (alias) {
 263                /*
 264                 * Great, an alias exists, which means we must have a
 265                 * dentry lock already. We can just grab the lock off
 266                 * the alias and add it to the list.
 267                 *
 268                 * We're depending here on the fact that this dentry
 269                 * was found and exists in the dcache and so must have
 270                 * a reference to the dentry_lock because we can't
 271                 * race creates. Final dput() cannot happen on it
 272                 * since we have it pinned, so our reference is safe.
 273                 */
 274                dl = alias->d_fsdata;
 275                mlog_bug_on_msg(!dl, "parent %llu, ino %llu\n",
 276                                (unsigned long long)parent_blkno,
 277                                (unsigned long long)OCFS2_I(inode)->ip_blkno);
 278
 279                mlog_bug_on_msg(dl->dl_parent_blkno != parent_blkno,
 280                                " \"%.*s\": old parent: %llu, new: %llu\n",
 281                                dentry->d_name.len, dentry->d_name.name,
 282                                (unsigned long long)parent_blkno,
 283                                (unsigned long long)dl->dl_parent_blkno);
 284
 285                trace_ocfs2_dentry_attach_lock_found(dl->dl_lockres.l_name,
 286                                (unsigned long long)parent_blkno,
 287                                (unsigned long long)OCFS2_I(inode)->ip_blkno);
 288
 289                goto out_attach;
 290        }
 291
 292        /*
 293         * There are no other aliases
 294         */
 295        dl = kmalloc(sizeof(*dl), GFP_NOFS);
 296        if (!dl) {
 297                ret = -ENOMEM;
 298                mlog_errno(ret);
 299                return ret;
 300        }
 301
 302        dl->dl_count = 0;
 303        /*
 304         * Does this have to happen below, for all attaches, in case
 305         * the struct inode gets blown away by the downconvert thread?
 306         */
 307        dl->dl_inode = igrab(inode);
 308        dl->dl_parent_blkno = parent_blkno;
 309        ocfs2_dentry_lock_res_init(dl, parent_blkno, inode);
 310
 311out_attach:
 312        spin_lock(&dentry_attach_lock);
 313        dentry->d_fsdata = dl;
 314        dl->dl_count++;
 315        spin_unlock(&dentry_attach_lock);
 316
 317        /*
 318         * This actually gets us our PRMODE level lock. From now on,
 319         * we'll have a notification if one of these names is
 320         * destroyed on another node.
 321         */
 322        ret = ocfs2_dentry_lock(dentry, 0);
 323        if (!ret)
 324                ocfs2_dentry_unlock(dentry, 0);
 325        else
 326                mlog_errno(ret);
 327
 328        /*
 329         * In case of error, manually free the allocation and do the iput().
 330         * We need to do this because error here means no d_instantiate(),
 331         * which means iput() will not be called during dput(dentry).
 332         */
 333        if (ret < 0 && !alias) {
 334                ocfs2_lock_res_free(&dl->dl_lockres);
 335                BUG_ON(dl->dl_count != 1);
 336                spin_lock(&dentry_attach_lock);
 337                dentry->d_fsdata = NULL;
 338                spin_unlock(&dentry_attach_lock);
 339                kfree(dl);
 340                iput(inode);
 341        }
 342
 343        dput(alias);
 344
 345        return ret;
 346}
 347
 348DEFINE_SPINLOCK(dentry_list_lock);
 349
 350/* We limit the number of dentry locks to drop in one go. We have
 351 * this limit so that we don't starve other users of ocfs2_wq. */
 352#define DL_INODE_DROP_COUNT 64
 353
 354/* Drop inode references from dentry locks */
 355static void __ocfs2_drop_dl_inodes(struct ocfs2_super *osb, int drop_count)
 356{
 357        struct ocfs2_dentry_lock *dl;
 358
 359        spin_lock(&dentry_list_lock);
 360        while (osb->dentry_lock_list && (drop_count < 0 || drop_count--)) {
 361                dl = osb->dentry_lock_list;
 362                osb->dentry_lock_list = dl->dl_next;
 363                spin_unlock(&dentry_list_lock);
 364                iput(dl->dl_inode);
 365                kfree(dl);
 366                spin_lock(&dentry_list_lock);
 367        }
 368        spin_unlock(&dentry_list_lock);
 369}
 370
 371void ocfs2_drop_dl_inodes(struct work_struct *work)
 372{
 373        struct ocfs2_super *osb = container_of(work, struct ocfs2_super,
 374                                               dentry_lock_work);
 375
 376        __ocfs2_drop_dl_inodes(osb, DL_INODE_DROP_COUNT);
 377        /*
 378         * Don't queue dropping if umount is in progress. We flush the
 379         * list in ocfs2_dismount_volume
 380         */
 381        spin_lock(&dentry_list_lock);
 382        if (osb->dentry_lock_list &&
 383            !ocfs2_test_osb_flag(osb, OCFS2_OSB_DROP_DENTRY_LOCK_IMMED))
 384                queue_work(ocfs2_wq, &osb->dentry_lock_work);
 385        spin_unlock(&dentry_list_lock);
 386}
 387
 388/* Flush the whole work queue */
 389void ocfs2_drop_all_dl_inodes(struct ocfs2_super *osb)
 390{
 391        __ocfs2_drop_dl_inodes(osb, -1);
 392}
 393
 394/*
 395 * ocfs2_dentry_iput() and friends.
 396 *
 397 * At this point, our particular dentry is detached from the inodes
 398 * alias list, so there's no way that the locking code can find it.
 399 *
 400 * The interesting stuff happens when we determine that our lock needs
 401 * to go away because this is the last subdir alias in the
 402 * system. This function needs to handle a couple things:
 403 *
 404 * 1) Synchronizing lock shutdown with the downconvert threads. This
 405 *    is already handled for us via the lockres release drop function
 406 *    called in ocfs2_release_dentry_lock()
 407 *
 408 * 2) A race may occur when we're doing our lock shutdown and
 409 *    another process wants to create a new dentry lock. Right now we
 410 *    let them race, which means that for a very short while, this
 411 *    node might have two locks on a lock resource. This should be a
 412 *    problem though because one of them is in the process of being
 413 *    thrown out.
 414 */
 415static void ocfs2_drop_dentry_lock(struct ocfs2_super *osb,
 416                                   struct ocfs2_dentry_lock *dl)
 417{
 418        ocfs2_simple_drop_lockres(osb, &dl->dl_lockres);
 419        ocfs2_lock_res_free(&dl->dl_lockres);
 420
 421        /* We leave dropping of inode reference to ocfs2_wq as that can
 422         * possibly lead to inode deletion which gets tricky */
 423        spin_lock(&dentry_list_lock);
 424        if (!osb->dentry_lock_list &&
 425            !ocfs2_test_osb_flag(osb, OCFS2_OSB_DROP_DENTRY_LOCK_IMMED))
 426                queue_work(ocfs2_wq, &osb->dentry_lock_work);
 427        dl->dl_next = osb->dentry_lock_list;
 428        osb->dentry_lock_list = dl;
 429        spin_unlock(&dentry_list_lock);
 430}
 431
 432void ocfs2_dentry_lock_put(struct ocfs2_super *osb,
 433                           struct ocfs2_dentry_lock *dl)
 434{
 435        int unlock;
 436
 437        BUG_ON(dl->dl_count == 0);
 438
 439        spin_lock(&dentry_attach_lock);
 440        dl->dl_count--;
 441        unlock = !dl->dl_count;
 442        spin_unlock(&dentry_attach_lock);
 443
 444        if (unlock)
 445                ocfs2_drop_dentry_lock(osb, dl);
 446}
 447
 448static void ocfs2_dentry_iput(struct dentry *dentry, struct inode *inode)
 449{
 450        struct ocfs2_dentry_lock *dl = dentry->d_fsdata;
 451
 452        if (!dl) {
 453                /*
 454                 * No dentry lock is ok if we're disconnected or
 455                 * unhashed.
 456                 */
 457                if (!(dentry->d_flags & DCACHE_DISCONNECTED) &&
 458                    !d_unhashed(dentry)) {
 459                        unsigned long long ino = 0ULL;
 460                        if (inode)
 461                                ino = (unsigned long long)OCFS2_I(inode)->ip_blkno;
 462                        mlog(ML_ERROR, "Dentry is missing cluster lock. "
 463                             "inode: %llu, d_flags: 0x%x, d_name: %.*s\n",
 464                             ino, dentry->d_flags, dentry->d_name.len,
 465                             dentry->d_name.name);
 466                }
 467
 468                goto out;
 469        }
 470
 471        mlog_bug_on_msg(dl->dl_count == 0, "dentry: %.*s, count: %u\n",
 472                        dentry->d_name.len, dentry->d_name.name,
 473                        dl->dl_count);
 474
 475        ocfs2_dentry_lock_put(OCFS2_SB(dentry->d_sb), dl);
 476
 477out:
 478        iput(inode);
 479}
 480
 481/*
 482 * d_move(), but keep the locks in sync.
 483 *
 484 * When we are done, "dentry" will have the parent dir and name of
 485 * "target", which will be thrown away.
 486 *
 487 * We manually update the lock of "dentry" if need be.
 488 *
 489 * "target" doesn't have it's dentry lock touched - we allow the later
 490 * dput() to handle this for us.
 491 *
 492 * This is called during ocfs2_rename(), while holding parent
 493 * directory locks. The dentries have already been deleted on other
 494 * nodes via ocfs2_remote_dentry_delete().
 495 *
 496 * Normally, the VFS handles the d_move() for the file system, after
 497 * the ->rename() callback. OCFS2 wants to handle this internally, so
 498 * the new lock can be created atomically with respect to the cluster.
 499 */
 500void ocfs2_dentry_move(struct dentry *dentry, struct dentry *target,
 501                       struct inode *old_dir, struct inode *new_dir)
 502{
 503        int ret;
 504        struct ocfs2_super *osb = OCFS2_SB(old_dir->i_sb);
 505        struct inode *inode = dentry->d_inode;
 506
 507        /*
 508         * Move within the same directory, so the actual lock info won't
 509         * change.
 510         *
 511         * XXX: Is there any advantage to dropping the lock here?
 512         */
 513        if (old_dir == new_dir)
 514                goto out_move;
 515
 516        ocfs2_dentry_lock_put(osb, dentry->d_fsdata);
 517
 518        dentry->d_fsdata = NULL;
 519        ret = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(new_dir)->ip_blkno);
 520        if (ret)
 521                mlog_errno(ret);
 522
 523out_move:
 524        d_move(dentry, target);
 525}
 526
 527const struct dentry_operations ocfs2_dentry_ops = {
 528        .d_revalidate           = ocfs2_dentry_revalidate,
 529        .d_iput                 = ocfs2_dentry_iput,
 530};
 531
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.