lkml.org 
[lkml]   [2012]   [Mar]   [15]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    Subject[patch 5/5] fs: Use seqlock in struct dentry
    Replace the open coded seqlock with a real seqlock. This reorders
    dentry members slightly to keep the structure size unchanged.

    Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

    ---
    arch/powerpc/platforms/cell/spufs/inode.c | 6
    drivers/infiniband/hw/ipath/ipath_fs.c | 6
    drivers/infiniband/hw/qib/qib_fs.c | 6
    drivers/usb/core/inode.c | 12 -
    fs/9p/vfs_dir.c | 4
    fs/afs/dir.c | 4
    fs/autofs4/autofs_i.h | 24 +-
    fs/autofs4/expire.c | 48 ++---
    fs/autofs4/root.c | 38 ++--
    fs/btrfs/export.c | 4
    fs/btrfs/inode.c | 4
    fs/ceph/caps.c | 8
    fs/ceph/debugfs.c | 8
    fs/ceph/dir.c | 30 +--
    fs/ceph/export.c | 4
    fs/ceph/inode.c | 20 +-
    fs/ceph/mds_client.c | 18 +-
    fs/cifs/dir.c | 6
    fs/coda/cache.c | 4
    fs/configfs/configfs_internal.h | 4
    fs/configfs/inode.c | 6
    fs/dcache.c | 253 ++++++++++++++----------------
    fs/dcookies.c | 8
    fs/exportfs/expfs.c | 12 -
    fs/fat/inode.c | 4
    fs/fat/namei_vfat.c | 4
    fs/fs-writeback.c | 4
    fs/fuse/inode.c | 4
    fs/gfs2/export.c | 4
    fs/isofs/export.c | 4
    fs/libfs.c | 36 ++--
    fs/namei.c | 42 ++--
    fs/namespace.c | 8
    fs/ncpfs/dir.c | 6
    fs/ncpfs/ncplib_kernel.h | 8
    fs/nfs/dir.c | 6
    fs/nfs/getroot.c | 12 -
    fs/nfs/namespace.c | 16 -
    fs/nfs/unlink.c | 20 +-
    fs/nilfs2/namei.c | 4
    fs/notify/fsnotify.c | 8
    fs/notify/vfsmount_mark.c | 24 +-
    fs/ocfs2/dcache.c | 6
    fs/ocfs2/export.c | 4
    fs/reiserfs/inode.c | 4
    fs/udf/namei.c | 4
    fs/xfs/xfs_export.c | 8
    include/linux/dcache.h | 17 --
    include/linux/fs.h | 4
    include/linux/fsnotify_backend.h | 6
    kernel/cgroup.c | 22 +-
    net/sunrpc/rpc_pipe.c | 6
    security/selinux/selinuxfs.c | 14 -
    53 files changed, 421 insertions(+), 425 deletions(-)

    Index: tip/arch/powerpc/platforms/cell/spufs/inode.c
    ===================================================================
    --- tip.orig/arch/powerpc/platforms/cell/spufs/inode.c
    +++ tip/arch/powerpc/platforms/cell/spufs/inode.c
    @@ -164,18 +164,18 @@ static void spufs_prune_dir(struct dentr

    mutex_lock(&dir->d_inode->i_mutex);
    list_for_each_entry_safe(dentry, tmp, &dir->d_subdirs, d_u.d_child) {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (!(d_unhashed(dentry)) && dentry->d_inode) {
    dget_dlock(dentry);
    __d_drop(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    simple_unlink(dir->d_inode, dentry);
    /* XXX: what was dcache_lock protecting here? Other
    * filesystems (IB, configfs) release dcache_lock
    * before unlink */
    dput(dentry);
    } else {
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }
    }
    shrink_dcache_parent(dir);
    Index: tip/drivers/infiniband/hw/ipath/ipath_fs.c
    ===================================================================
    --- tip.orig/drivers/infiniband/hw/ipath/ipath_fs.c
    +++ tip/drivers/infiniband/hw/ipath/ipath_fs.c
    @@ -277,14 +277,14 @@ static int remove_file(struct dentry *pa
    goto bail;
    }

    - spin_lock(&tmp->d_lock);
    + seq_spin_lock(&tmp->d_lock);
    if (!(d_unhashed(tmp) && tmp->d_inode)) {
    dget_dlock(tmp);
    __d_drop(tmp);
    - spin_unlock(&tmp->d_lock);
    + seq_spin_unlock(&tmp->d_lock);
    simple_unlink(parent->d_inode, tmp);
    } else
    - spin_unlock(&tmp->d_lock);
    + seq_spin_unlock(&tmp->d_lock);

    ret = 0;
    bail:
    Index: tip/drivers/infiniband/hw/qib/qib_fs.c
    ===================================================================
    --- tip.orig/drivers/infiniband/hw/qib/qib_fs.c
    +++ tip/drivers/infiniband/hw/qib/qib_fs.c
    @@ -453,14 +453,14 @@ static int remove_file(struct dentry *pa
    goto bail;
    }

    - spin_lock(&tmp->d_lock);
    + seq_spin_lock(&tmp->d_lock);
    if (!(d_unhashed(tmp) && tmp->d_inode)) {
    dget_dlock(tmp);
    __d_drop(tmp);
    - spin_unlock(&tmp->d_lock);
    + seq_spin_unlock(&tmp->d_lock);
    simple_unlink(parent->d_inode, tmp);
    } else {
    - spin_unlock(&tmp->d_lock);
    + seq_spin_unlock(&tmp->d_lock);
    }

    ret = 0;
    Index: tip/drivers/usb/core/inode.c
    ===================================================================
    --- tip.orig/drivers/usb/core/inode.c
    +++ tip/drivers/usb/core/inode.c
    @@ -341,19 +341,19 @@ static int usbfs_empty (struct dentry *d
    {
    struct list_head *list;

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    list_for_each(list, &dentry->d_subdirs) {
    struct dentry *de = list_entry(list, struct dentry, d_u.d_child);

    - spin_lock_nested(&de->d_lock, DENTRY_D_LOCK_NESTED);
    + seq_spin_lock_nested(&de->d_lock, DENTRY_D_LOCK_NESTED);
    if (usbfs_positive(de)) {
    - spin_unlock(&de->d_lock);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&de->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    return 0;
    }
    - spin_unlock(&de->d_lock);
    + seq_spin_unlock(&de->d_lock);
    }
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    return 1;
    }

    Index: tip/fs/9p/vfs_dir.c
    ===================================================================
    --- tip.orig/fs/9p/vfs_dir.c
    +++ tip/fs/9p/vfs_dir.c
    @@ -107,7 +107,7 @@ static int v9fs_alloc_rdir_buf(struct fi
    err = -ENOMEM;
    goto exit;
    }
    - spin_lock(&filp->f_dentry->d_lock);
    + seq_spin_lock(&filp->f_dentry->d_lock);
    if (!fid->rdir) {
    rdir->buf = (uint8_t *)rdir + sizeof(struct p9_rdir);
    mutex_init(&rdir->mutex);
    @@ -115,7 +115,7 @@ static int v9fs_alloc_rdir_buf(struct fi
    fid->rdir = (void *) rdir;
    rdir = NULL;
    }
    - spin_unlock(&filp->f_dentry->d_lock);
    + seq_spin_unlock(&filp->f_dentry->d_lock);
    kfree(rdir);
    }
    exit:
    Index: tip/fs/afs/dir.c
    ===================================================================
    --- tip.orig/fs/afs/dir.c
    +++ tip/fs/afs/dir.c
    @@ -705,9 +705,9 @@ out_skip:

    /* the dirent, if it exists, now points to a different vnode */
    not_found:
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    dentry->d_flags |= DCACHE_NFSFS_RENAMED;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);

    out_bad:
    if (dentry->d_inode) {
    Index: tip/fs/autofs4/autofs_i.h
    ===================================================================
    --- tip.orig/fs/autofs4/autofs_i.h
    +++ tip/fs/autofs4/autofs_i.h
    @@ -199,9 +199,9 @@ static inline void __managed_dentry_set_

    static inline void managed_dentry_set_automount(struct dentry *dentry)
    {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    __managed_dentry_set_automount(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }

    static inline void __managed_dentry_clear_automount(struct dentry *dentry)
    @@ -211,9 +211,9 @@ static inline void __managed_dentry_clea

    static inline void managed_dentry_clear_automount(struct dentry *dentry)
    {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    __managed_dentry_clear_automount(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }

    static inline void __managed_dentry_set_transit(struct dentry *dentry)
    @@ -223,9 +223,9 @@ static inline void __managed_dentry_set_

    static inline void managed_dentry_set_transit(struct dentry *dentry)
    {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    __managed_dentry_set_transit(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }

    static inline void __managed_dentry_clear_transit(struct dentry *dentry)
    @@ -235,9 +235,9 @@ static inline void __managed_dentry_clea

    static inline void managed_dentry_clear_transit(struct dentry *dentry)
    {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    __managed_dentry_clear_transit(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }

    static inline void __managed_dentry_set_managed(struct dentry *dentry)
    @@ -247,9 +247,9 @@ static inline void __managed_dentry_set_

    static inline void managed_dentry_set_managed(struct dentry *dentry)
    {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    __managed_dentry_set_managed(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }

    static inline void __managed_dentry_clear_managed(struct dentry *dentry)
    @@ -259,9 +259,9 @@ static inline void __managed_dentry_clea

    static inline void managed_dentry_clear_managed(struct dentry *dentry)
    {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    __managed_dentry_clear_managed(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }

    /* Initializing function */
    Index: tip/fs/autofs4/expire.c
    ===================================================================
    --- tip.orig/fs/autofs4/expire.c
    +++ tip/fs/autofs4/expire.c
    @@ -99,7 +99,7 @@ static struct dentry *get_next_positive_
    spin_lock(&sbi->lookup_lock);

    if (prev == NULL) {
    - spin_lock(&root->d_lock);
    + seq_spin_lock(&root->d_lock);
    prev = dget_dlock(root);
    next = prev->d_subdirs.next;
    p = prev;
    @@ -107,12 +107,12 @@ static struct dentry *get_next_positive_
    }

    p = prev;
    - spin_lock(&p->d_lock);
    + seq_spin_lock(&p->d_lock);
    again:
    next = p->d_u.d_child.next;
    start:
    if (next == &root->d_subdirs) {
    - spin_unlock(&p->d_lock);
    + seq_spin_unlock(&p->d_lock);
    spin_unlock(&sbi->lookup_lock);
    dput(prev);
    return NULL;
    @@ -120,17 +120,17 @@ start:

    q = list_entry(next, struct dentry, d_u.d_child);

    - spin_lock_nested(&q->d_lock, DENTRY_D_LOCK_NESTED);
    + seq_spin_lock_nested(&q->d_lock, DENTRY_D_LOCK_NESTED);
    /* Negative dentry - try next */
    if (!simple_positive(q)) {
    - spin_unlock(&p->d_lock);
    - lock_set_subclass(&q->d_lock.dep_map, 0, _RET_IP_);
    + seq_spin_unlock(&p->d_lock);
    + lock_set_subclass(&q->d_lock.lock.dep_map, 0, _RET_IP_);
    p = q;
    goto again;
    }
    dget_dlock(q);
    - spin_unlock(&q->d_lock);
    - spin_unlock(&p->d_lock);
    + seq_spin_unlock(&q->d_lock);
    + seq_spin_unlock(&p->d_lock);
    spin_unlock(&sbi->lookup_lock);

    dput(prev);
    @@ -154,7 +154,7 @@ static struct dentry *get_next_positive_
    spin_lock(&sbi->lookup_lock);
    relock:
    p = prev;
    - spin_lock(&p->d_lock);
    + seq_spin_lock(&p->d_lock);
    again:
    next = p->d_subdirs.next;
    if (next == &p->d_subdirs) {
    @@ -162,19 +162,19 @@ again:
    struct dentry *parent;

    if (p == root) {
    - spin_unlock(&p->d_lock);
    + seq_spin_unlock(&p->d_lock);
    spin_unlock(&sbi->lookup_lock);
    dput(prev);
    return NULL;
    }

    parent = p->d_parent;
    - if (!spin_trylock(&parent->d_lock)) {
    - spin_unlock(&p->d_lock);
    + if (!seq_spin_trylock(&parent->d_lock)) {
    + seq_spin_unlock(&p->d_lock);
    cpu_relax();
    goto relock;
    }
    - spin_unlock(&p->d_lock);
    + seq_spin_unlock(&p->d_lock);
    next = p->d_u.d_child.next;
    p = parent;
    if (next != &parent->d_subdirs)
    @@ -183,17 +183,17 @@ again:
    }
    ret = list_entry(next, struct dentry, d_u.d_child);

    - spin_lock_nested(&ret->d_lock, DENTRY_D_LOCK_NESTED);
    + seq_spin_lock_nested(&ret->d_lock, DENTRY_D_LOCK_NESTED);
    /* Negative dentry - try next */
    if (!simple_positive(ret)) {
    - spin_unlock(&p->d_lock);
    - lock_set_subclass(&ret->d_lock.dep_map, 0, _RET_IP_);
    + seq_spin_unlock(&p->d_lock);
    + lock_set_subclass(&ret->d_lock.lock.dep_map, 0, _RET_IP_);
    p = ret;
    goto again;
    }
    dget_dlock(ret);
    - spin_unlock(&ret->d_lock);
    - spin_unlock(&p->d_lock);
    + seq_spin_unlock(&ret->d_lock);
    + seq_spin_unlock(&p->d_lock);
    spin_unlock(&sbi->lookup_lock);

    dput(prev);
    @@ -464,11 +464,11 @@ found:
    init_completion(&ino->expire_complete);
    spin_unlock(&sbi->fs_lock);
    spin_lock(&sbi->lookup_lock);
    - spin_lock(&expired->d_parent->d_lock);
    - spin_lock_nested(&expired->d_lock, DENTRY_D_LOCK_NESTED);
    + seq_spin_lock(&expired->d_parent->d_lock);
    + seq_spin_lock_nested(&expired->d_lock, DENTRY_D_LOCK_NESTED);
    list_move(&expired->d_parent->d_subdirs, &expired->d_u.d_child);
    - spin_unlock(&expired->d_lock);
    - spin_unlock(&expired->d_parent->d_lock);
    + seq_spin_unlock(&expired->d_lock);
    + seq_spin_unlock(&expired->d_parent->d_lock);
    spin_unlock(&sbi->lookup_lock);
    return expired;
    }
    @@ -558,7 +558,7 @@ int autofs4_do_expire_multi(struct super

    spin_lock(&sbi->fs_lock);
    ino->flags &= ~AUTOFS_INF_EXPIRING;
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (!ret) {
    if ((IS_ROOT(dentry) ||
    (autofs_type_indirect(sbi->type) &&
    @@ -566,7 +566,7 @@ int autofs4_do_expire_multi(struct super
    !(dentry->d_flags & DCACHE_NEED_AUTOMOUNT))
    __managed_dentry_set_automount(dentry);
    }
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    complete_all(&ino->expire_complete);
    spin_unlock(&sbi->fs_lock);
    dput(dentry);
    Index: tip/fs/autofs4/root.c
    ===================================================================
    --- tip.orig/fs/autofs4/root.c
    +++ tip/fs/autofs4/root.c
    @@ -124,13 +124,13 @@ static int autofs4_dir_open(struct inode
    * it.
    */
    spin_lock(&sbi->lookup_lock);
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (!d_mountpoint(dentry) && list_empty(&dentry->d_subdirs)) {
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    spin_unlock(&sbi->lookup_lock);
    return -ENOENT;
    }
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    spin_unlock(&sbi->lookup_lock);

    out:
    @@ -179,7 +179,7 @@ static struct dentry *autofs4_lookup_act
    ino = list_entry(p, struct autofs_info, active);
    active = ino->dentry;

    - spin_lock(&active->d_lock);
    + seq_spin_lock(&active->d_lock);

    /* Already gone? */
    if (active->d_count == 0)
    @@ -199,12 +199,12 @@ static struct dentry *autofs4_lookup_act

    if (d_unhashed(active)) {
    dget_dlock(active);
    - spin_unlock(&active->d_lock);
    + seq_spin_unlock(&active->d_lock);
    spin_unlock(&sbi->lookup_lock);
    return active;
    }
    next:
    - spin_unlock(&active->d_lock);
    + seq_spin_unlock(&active->d_lock);
    }
    spin_unlock(&sbi->lookup_lock);

    @@ -231,7 +231,7 @@ static struct dentry *autofs4_lookup_exp
    ino = list_entry(p, struct autofs_info, expiring);
    expiring = ino->dentry;

    - spin_lock(&expiring->d_lock);
    + seq_spin_lock(&expiring->d_lock);

    /* Bad luck, we've already been dentry_iput */
    if (!expiring->d_inode)
    @@ -251,12 +251,12 @@ static struct dentry *autofs4_lookup_exp

    if (d_unhashed(expiring)) {
    dget_dlock(expiring);
    - spin_unlock(&expiring->d_lock);
    + seq_spin_unlock(&expiring->d_lock);
    spin_unlock(&sbi->lookup_lock);
    return expiring;
    }
    next:
    - spin_unlock(&expiring->d_lock);
    + seq_spin_unlock(&expiring->d_lock);
    }
    spin_unlock(&sbi->lookup_lock);

    @@ -382,12 +382,12 @@ static struct vfsmount *autofs4_d_automo
    if (have_submounts(dentry))
    goto done;
    } else {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (!list_empty(&dentry->d_subdirs)) {
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    goto done;
    }
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }
    ino->flags |= AUTOFS_INF_PENDING;
    spin_unlock(&sbi->fs_lock);
    @@ -410,12 +410,12 @@ done:
    * an actual mount so ->d_automount() won't be called during
    * the follow.
    */
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if ((!d_mountpoint(dentry) &&
    !list_empty(&dentry->d_subdirs)) ||
    (dentry->d_inode && S_ISLNK(dentry->d_inode->i_mode)))
    __managed_dentry_clear_automount(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }
    spin_unlock(&sbi->fs_lock);

    @@ -597,9 +597,9 @@ static int autofs4_dir_unlink(struct ino

    spin_lock(&sbi->lookup_lock);
    __autofs4_add_expiring(dentry);
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    __d_drop(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    spin_unlock(&sbi->lookup_lock);

    return 0;
    @@ -670,15 +670,15 @@ static int autofs4_dir_rmdir(struct inod
    return -EACCES;

    spin_lock(&sbi->lookup_lock);
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (!list_empty(&dentry->d_subdirs)) {
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    spin_unlock(&sbi->lookup_lock);
    return -ENOTEMPTY;
    }
    __autofs4_add_expiring(dentry);
    __d_drop(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    spin_unlock(&sbi->lookup_lock);

    if (sbi->version < 5)
    Index: tip/fs/btrfs/export.c
    ===================================================================
    --- tip.orig/fs/btrfs/export.c
    +++ tip/fs/btrfs/export.c
    @@ -40,14 +40,14 @@ static int btrfs_encode_fh(struct dentry
    struct inode *parent;
    u64 parent_root_id;

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);

    parent = dentry->d_parent->d_inode;
    fid->parent_objectid = BTRFS_I(parent)->location.objectid;
    fid->parent_gen = parent->i_generation;
    parent_root_id = BTRFS_I(parent)->root->objectid;

    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);

    if (parent_root_id != fid->root_objectid) {
    fid->parent_root_objectid = parent_root_id;
    Index: tip/fs/btrfs/inode.c
    ===================================================================
    --- tip.orig/fs/btrfs/inode.c
    +++ tip/fs/btrfs/inode.c
    @@ -4014,9 +4014,9 @@ static struct dentry *btrfs_lookup(struc

    ret = d_splice_alias(btrfs_lookup_dentry(dir, dentry), dentry);
    if (unlikely(d_need_lookup(dentry))) {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    dentry->d_flags &= ~DCACHE_NEED_LOOKUP;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }
    return ret;
    }
    Index: tip/fs/ceph/caps.c
    ===================================================================
    --- tip.orig/fs/ceph/caps.c
    +++ tip/fs/ceph/caps.c
    @@ -3066,14 +3066,14 @@ int ceph_encode_dentry_release(void **p,
    * doesn't have to be perfect; the mds will revoke anything we don't
    * release.
    */
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (di->lease_session && di->lease_session->s_mds == mds)
    force = 1;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);

    ret = ceph_encode_inode_release(p, dir, mds, drop, unless, force);

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (ret && di->lease_session && di->lease_session->s_mds == mds) {
    dout("encode_dentry_release %p mds%d seq %d\n",
    dentry, mds, (int)di->lease_seq);
    @@ -3083,6 +3083,6 @@ int ceph_encode_dentry_release(void **p,
    rel->dname_seq = cpu_to_le32(di->lease_seq);
    __ceph_mdsc_drop_dentry_lease(dentry);
    }
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    return ret;
    }
    Index: tip/fs/ceph/debugfs.c
    ===================================================================
    --- tip.orig/fs/ceph/debugfs.c
    +++ tip/fs/ceph/debugfs.c
    @@ -82,13 +82,13 @@ static int mdsc_show(struct seq_file *s,
    &pathbase, 0);
    if (IS_ERR(path))
    path = NULL;
    - spin_lock(&req->r_dentry->d_lock);
    + seq_spin_lock(&req->r_dentry->d_lock);
    seq_printf(s, " #%llx/%.*s (%s)",
    ceph_ino(req->r_dentry->d_parent->d_inode),
    req->r_dentry->d_name.len,
    req->r_dentry->d_name.name,
    path ? path : "");
    - spin_unlock(&req->r_dentry->d_lock);
    + seq_spin_unlock(&req->r_dentry->d_lock);
    kfree(path);
    } else if (req->r_path1) {
    seq_printf(s, " #%llx/%s", req->r_ino1.ino,
    @@ -100,13 +100,13 @@ static int mdsc_show(struct seq_file *s,
    &pathbase, 0);
    if (IS_ERR(path))
    path = NULL;
    - spin_lock(&req->r_old_dentry->d_lock);
    + seq_spin_lock(&req->r_old_dentry->d_lock);
    seq_printf(s, " #%llx/%.*s (%s)",
    ceph_ino(req->r_old_dentry_dir),
    req->r_old_dentry->d_name.len,
    req->r_old_dentry->d_name.name,
    path ? path : "");
    - spin_unlock(&req->r_old_dentry->d_lock);
    + seq_spin_unlock(&req->r_old_dentry->d_lock);
    kfree(path);
    } else if (req->r_path2) {
    if (req->r_ino2.ino)
    Index: tip/fs/ceph/dir.c
    ===================================================================
    --- tip.orig/fs/ceph/dir.c
    +++ tip/fs/ceph/dir.c
    @@ -44,7 +44,7 @@ int ceph_init_dentry(struct dentry *dent
    if (!di)
    return -ENOMEM; /* oh well */

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (dentry->d_fsdata) {
    /* lost a race */
    kmem_cache_free(ceph_dentry_cachep, di);
    @@ -67,7 +67,7 @@ int ceph_init_dentry(struct dentry *dent
    dentry->d_fsdata = di;
    ceph_dentry_lru_add(dentry);
    out_unlock:
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    return 0;
    }

    @@ -78,12 +78,12 @@ struct inode *ceph_get_dentry_parent_ino
    if (!dentry)
    return NULL;

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (dentry->d_parent) {
    inode = dentry->d_parent->d_inode;
    ihold(inode);
    }
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    return inode;
    }

    @@ -130,7 +130,7 @@ static int __dcache_readdir(struct file
    dout("__dcache_readdir %p at %llu (last %p)\n", dir, filp->f_pos,
    last);

    - spin_lock(&parent->d_lock);
    + seq_spin_lock(&parent->d_lock);

    /* start at beginning? */
    if (filp->f_pos == 2 || last == NULL ||
    @@ -154,7 +154,7 @@ more:
    fi->flags |= CEPH_F_ATEND;
    goto out_unlock;
    }
    - spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
    + seq_spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
    if (!d_unhashed(dentry) && dentry->d_inode &&
    ceph_snap(dentry->d_inode) != CEPH_SNAPDIR &&
    ceph_ino(dentry->d_inode) != CEPH_INO_CEPH &&
    @@ -164,15 +164,15 @@ more:
    dentry->d_name.len, dentry->d_name.name, di->offset,
    filp->f_pos, d_unhashed(dentry) ? " unhashed" : "",
    !dentry->d_inode ? " null" : "");
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    p = p->prev;
    dentry = list_entry(p, struct dentry, d_u.d_child);
    di = ceph_dentry(dentry);
    }

    dget_dlock(dentry);
    - spin_unlock(&dentry->d_lock);
    - spin_unlock(&parent->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&parent->d_lock);

    dout(" %llu (%llu) dentry %p %.*s %p\n", di->offset, filp->f_pos,
    dentry, dentry->d_name.len, dentry->d_name.name, dentry->d_inode);
    @@ -205,12 +205,12 @@ more:
    goto out;
    }

    - spin_lock(&parent->d_lock);
    + seq_spin_lock(&parent->d_lock);
    p = p->prev; /* advance to next dentry */
    goto more;

    out_unlock:
    - spin_unlock(&parent->d_lock);
    + seq_spin_unlock(&parent->d_lock);
    out:
    if (last)
    dput(last);
    @@ -950,10 +950,10 @@ static int ceph_rename(struct inode *old
    */
    void ceph_invalidate_dentry_lease(struct dentry *dentry)
    {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    dentry->d_time = jiffies;
    ceph_dentry(dentry)->lease_shared_gen = 0;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }

    /*
    @@ -971,7 +971,7 @@ static int dentry_lease_is_valid(struct
    struct inode *dir = NULL;
    u32 seq = 0;

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    di = ceph_dentry(dentry);
    if (di->lease_session) {
    s = di->lease_session;
    @@ -995,7 +995,7 @@ static int dentry_lease_is_valid(struct
    }
    }
    }
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);

    if (session) {
    ceph_mdsc_lease_send_msg(session, dir, dentry,
    Index: tip/fs/ceph/export.c
    ===================================================================
    --- tip.orig/fs/ceph/export.c
    +++ tip/fs/ceph/export.c
    @@ -55,7 +55,7 @@ static int ceph_encode_fh(struct dentry
    if (ceph_snap(inode) != CEPH_NOSNAP)
    return -EINVAL;

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    parent = dentry->d_parent;
    if (*max_len >= connected_handle_length) {
    dout("encode_fh %p connectable\n", dentry);
    @@ -79,7 +79,7 @@ static int ceph_encode_fh(struct dentry
    *max_len = handle_length;
    type = 255;
    }
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    return type;
    }

    Index: tip/fs/ceph/inode.c
    ===================================================================
    --- tip.orig/fs/ceph/inode.c
    +++ tip/fs/ceph/inode.c
    @@ -808,7 +808,7 @@ static void update_dentry_lease(struct d
    if (dentry->d_op != &ceph_dentry_ops)
    return;

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    dout("update_dentry_lease %p duration %lu ms ttl %lu\n",
    dentry, duration, ttl);

    @@ -836,7 +836,7 @@ static void update_dentry_lease(struct d
    di->lease_renew_from = 0;
    dentry->d_time = ttl;
    out_unlock:
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    return;
    }

    @@ -866,13 +866,13 @@ static void ceph_set_dentry_offset(struc
    di->offset = ceph_inode(inode)->i_max_offset++;
    spin_unlock(&ci->i_ceph_lock);

    - spin_lock(&dir->d_lock);
    - spin_lock_nested(&dn->d_lock, DENTRY_D_LOCK_NESTED);
    + seq_spin_lock(&dir->d_lock);
    + seq_spin_lock_nested(&dn->d_lock, DENTRY_D_LOCK_NESTED);
    list_move(&dn->d_u.d_child, &dir->d_subdirs);
    dout("set_dentry_offset %p %lld (%p %p)\n", dn, di->offset,
    dn->d_u.d_child.prev, dn->d_u.d_child.next);
    - spin_unlock(&dn->d_lock);
    - spin_unlock(&dir->d_lock);
    + seq_spin_unlock(&dn->d_lock);
    + seq_spin_unlock(&dir->d_lock);
    }

    /*
    @@ -1254,11 +1254,11 @@ retry_lookup:
    goto retry_lookup;
    } else {
    /* reorder parent's d_subdirs */
    - spin_lock(&parent->d_lock);
    - spin_lock_nested(&dn->d_lock, DENTRY_D_LOCK_NESTED);
    + seq_spin_lock(&parent->d_lock);
    + seq_spin_lock_nested(&dn->d_lock, DENTRY_D_LOCK_NESTED);
    list_move(&dn->d_u.d_child, &parent->d_subdirs);
    - spin_unlock(&dn->d_lock);
    - spin_unlock(&parent->d_lock);
    + seq_spin_unlock(&dn->d_lock);
    + seq_spin_unlock(&parent->d_lock);
    }

    di = dn->d_fsdata;
    Index: tip/fs/ceph/mds_client.c
    ===================================================================
    --- tip.orig/fs/ceph/mds_client.c
    +++ tip/fs/ceph/mds_client.c
    @@ -1492,25 +1492,25 @@ retry:
    for (temp = dentry; !IS_ROOT(temp) && pos != 0; ) {
    struct inode *inode;

    - spin_lock(&temp->d_lock);
    + seq_spin_lock(&temp->d_lock);
    inode = temp->d_inode;
    if (inode && ceph_snap(inode) == CEPH_SNAPDIR) {
    dout("build_path path+%d: %p SNAPDIR\n",
    pos, temp);
    } else if (stop_on_nosnap && inode &&
    ceph_snap(inode) == CEPH_NOSNAP) {
    - spin_unlock(&temp->d_lock);
    + seq_spin_unlock(&temp->d_lock);
    break;
    } else {
    pos -= temp->d_name.len;
    if (pos < 0) {
    - spin_unlock(&temp->d_lock);
    + seq_spin_unlock(&temp->d_lock);
    break;
    }
    strncpy(path + pos, temp->d_name.name,
    temp->d_name.len);
    }
    - spin_unlock(&temp->d_lock);
    + seq_spin_unlock(&temp->d_lock);
    if (pos)
    path[--pos] = '/';
    temp = temp->d_parent;
    @@ -2772,7 +2772,7 @@ static void handle_lease(struct ceph_mds
    if (!dentry)
    goto release;

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    di = ceph_dentry(dentry);
    switch (h->action) {
    case CEPH_MDS_LEASE_REVOKE:
    @@ -2800,7 +2800,7 @@ static void handle_lease(struct ceph_mds
    }
    break;
    }
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    dput(dentry);

    if (!release)
    @@ -2873,7 +2873,7 @@ void ceph_mdsc_lease_release(struct ceph
    BUG_ON(dentry == NULL);

    /* is dentry lease valid? */
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    di = ceph_dentry(dentry);
    if (!di || !di->lease_session ||
    di->lease_session->s_mds < 0 ||
    @@ -2882,7 +2882,7 @@ void ceph_mdsc_lease_release(struct ceph
    dout("lease_release inode %p dentry %p -- "
    "no lease\n",
    inode, dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    return;
    }

    @@ -2890,7 +2890,7 @@ void ceph_mdsc_lease_release(struct ceph
    session = ceph_get_mds_session(di->lease_session);
    seq = di->lease_seq;
    __ceph_mdsc_drop_dentry_lease(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);

    dout("lease_release inode %p dentry %p to mds%d\n",
    inode, dentry, session->s_mds);
    Index: tip/fs/cifs/dir.c
    ===================================================================
    --- tip.orig/fs/cifs/dir.c
    +++ tip/fs/cifs/dir.c
    @@ -83,10 +83,10 @@ cifs_bp_rename_retry:
    full_path[namelen] = 0; /* trailing null */
    rcu_read_lock();
    for (temp = direntry; !IS_ROOT(temp);) {
    - spin_lock(&temp->d_lock);
    + seq_spin_lock(&temp->d_lock);
    namelen -= 1 + temp->d_name.len;
    if (namelen < 0) {
    - spin_unlock(&temp->d_lock);
    + seq_spin_unlock(&temp->d_lock);
    break;
    } else {
    full_path[namelen] = dirsep;
    @@ -94,7 +94,7 @@ cifs_bp_rename_retry:
    temp->d_name.len);
    cFYI(0, "name: %s", full_path + namelen);
    }
    - spin_unlock(&temp->d_lock);
    + seq_spin_unlock(&temp->d_lock);
    temp = temp->d_parent;
    if (temp == NULL) {
    cERROR(1, "corrupt dentry");
    Index: tip/fs/coda/cache.c
    ===================================================================
    --- tip.orig/fs/coda/cache.c
    +++ tip/fs/coda/cache.c
    @@ -92,7 +92,7 @@ static void coda_flag_children(struct de
    struct list_head *child;
    struct dentry *de;

    - spin_lock(&parent->d_lock);
    + seq_spin_lock(&parent->d_lock);
    list_for_each(child, &parent->d_subdirs)
    {
    de = list_entry(child, struct dentry, d_u.d_child);
    @@ -101,7 +101,7 @@ static void coda_flag_children(struct de
    continue;
    coda_flag_inode(de->d_inode, flag);
    }
    - spin_unlock(&parent->d_lock);
    + seq_spin_unlock(&parent->d_lock);
    return;
    }

    Index: tip/fs/configfs/configfs_internal.h
    ===================================================================
    --- tip.orig/fs/configfs/configfs_internal.h
    +++ tip/fs/configfs/configfs_internal.h
    @@ -121,7 +121,7 @@ static inline struct config_item *config
    {
    struct config_item * item = NULL;

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (!d_unhashed(dentry)) {
    struct configfs_dirent * sd = dentry->d_fsdata;
    if (sd->s_type & CONFIGFS_ITEM_LINK) {
    @@ -130,7 +130,7 @@ static inline struct config_item *config
    } else
    item = config_item_get(sd->s_element);
    }
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);

    return item;
    }
    Index: tip/fs/configfs/inode.c
    ===================================================================
    --- tip.orig/fs/configfs/inode.c
    +++ tip/fs/configfs/inode.c
    @@ -251,14 +251,14 @@ void configfs_drop_dentry(struct configf
    struct dentry * dentry = sd->s_dentry;

    if (dentry) {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (!(d_unhashed(dentry) && dentry->d_inode)) {
    dget_dlock(dentry);
    __d_drop(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    simple_unlink(parent->d_inode, dentry);
    } else
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }
    }

    Index: tip/fs/dcache.c
    ===================================================================
    --- tip.orig/fs/dcache.c
    +++ tip/fs/dcache.c
    @@ -193,9 +193,9 @@ static void d_free(struct dentry *dentry
    */
    static inline void dentry_rcuwalk_barrier(struct dentry *dentry)
    {
    - assert_spin_locked(&dentry->d_lock);
    + assert_seq_spin_locked(&dentry->d_lock);
    /* Go through a barrier */
    - write_seqcount_barrier(&dentry->d_seq);
    + write_seqlock_barrier(&dentry->d_lock);
    }

    /*
    @@ -211,7 +211,7 @@ static void dentry_iput(struct dentry *
    if (inode) {
    dentry->d_inode = NULL;
    list_del_init(&dentry->d_alias);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    spin_unlock(&inode->i_lock);
    if (!inode->i_nlink)
    fsnotify_inoderemove(inode);
    @@ -220,7 +220,7 @@ static void dentry_iput(struct dentry *
    else
    iput(inode);
    } else {
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }
    }

    @@ -236,7 +236,7 @@ static void dentry_unlink_inode(struct d
    dentry->d_inode = NULL;
    list_del_init(&dentry->d_alias);
    dentry_rcuwalk_barrier(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    spin_unlock(&inode->i_lock);
    if (!inode->i_nlink)
    fsnotify_inoderemove(inode);
    @@ -334,7 +334,7 @@ static struct dentry *d_kill(struct dent
    */
    dentry->d_flags |= DCACHE_DISCONNECTED;
    if (parent)
    - spin_unlock(&parent->d_lock);
    + seq_spin_unlock(&parent->d_lock);
    dentry_iput(dentry);
    /*
    * dentry_iput drops the locks, at which point nobody (except
    @@ -391,9 +391,9 @@ EXPORT_SYMBOL(__d_drop);

    void d_drop(struct dentry *dentry)
    {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    __d_drop(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }
    EXPORT_SYMBOL(d_drop);

    @@ -408,10 +408,10 @@ EXPORT_SYMBOL(d_drop);
    */
    void d_clear_need_lookup(struct dentry *dentry)
    {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    __d_drop(dentry);
    dentry->d_flags &= ~DCACHE_NEED_LOOKUP;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }
    EXPORT_SYMBOL(d_clear_need_lookup);

    @@ -430,7 +430,7 @@ static inline struct dentry *dentry_kill
    inode = dentry->d_inode;
    if (inode && !spin_trylock(&inode->i_lock)) {
    relock:
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    cpu_relax();
    return dentry; /* try again with same dentry */
    }
    @@ -438,7 +438,7 @@ relock:
    parent = NULL;
    else
    parent = dentry->d_parent;
    - if (parent && !spin_trylock(&parent->d_lock)) {
    + if (parent && !seq_spin_trylock(&parent->d_lock)) {
    if (inode)
    spin_unlock(&inode->i_lock);
    goto relock;
    @@ -491,11 +491,11 @@ void dput(struct dentry *dentry)
    repeat:
    if (dentry->d_count == 1)
    might_sleep();
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    BUG_ON(!dentry->d_count);
    if (dentry->d_count > 1) {
    dentry->d_count--;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    return;
    }

    @@ -518,7 +518,7 @@ repeat:
    dentry_lru_add(dentry);

    dentry->d_count--;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    return;

    kill_it:
    @@ -545,9 +545,9 @@ int d_invalidate(struct dentry * dentry)
    /*
    * If it's already been dropped, return OK.
    */
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (d_unhashed(dentry)) {
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    return 0;
    }
    /*
    @@ -555,9 +555,9 @@ int d_invalidate(struct dentry * dentry)
    * to get rid of unused child entries.
    */
    if (!list_empty(&dentry->d_subdirs)) {
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    shrink_dcache_parent(dentry);
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    }

    /*
    @@ -574,13 +574,13 @@ int d_invalidate(struct dentry * dentry)
    */
    if (dentry->d_count > 1 && dentry->d_inode) {
    if (S_ISDIR(dentry->d_inode->i_mode) || d_mountpoint(dentry)) {
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    return -EBUSY;
    }
    }

    __d_drop(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    return 0;
    }
    EXPORT_SYMBOL(d_invalidate);
    @@ -593,9 +593,9 @@ static inline void __dget_dlock(struct d

    static inline void __dget(struct dentry *dentry)
    {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    __dget_dlock(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }

    struct dentry *dget_parent(struct dentry *dentry)
    @@ -609,16 +609,16 @@ repeat:
    */
    rcu_read_lock();
    ret = dentry->d_parent;
    - spin_lock(&ret->d_lock);
    + seq_spin_lock(&ret->d_lock);
    if (unlikely(ret != dentry->d_parent)) {
    - spin_unlock(&ret->d_lock);
    + seq_spin_unlock(&ret->d_lock);
    rcu_read_unlock();
    goto repeat;
    }
    rcu_read_unlock();
    BUG_ON(!ret->d_count);
    ret->d_count++;
    - spin_unlock(&ret->d_lock);
    + seq_spin_unlock(&ret->d_lock);
    return ret;
    }
    EXPORT_SYMBOL(dget_parent);
    @@ -646,31 +646,31 @@ static struct dentry *__d_find_alias(str
    again:
    discon_alias = NULL;
    list_for_each_entry(alias, &inode->i_dentry, d_alias) {
    - spin_lock(&alias->d_lock);
    + seq_spin_lock(&alias->d_lock);
    if (S_ISDIR(inode->i_mode) || !d_unhashed(alias)) {
    if (IS_ROOT(alias) &&
    (alias->d_flags & DCACHE_DISCONNECTED)) {
    discon_alias = alias;
    } else if (!want_discon) {
    __dget_dlock(alias);
    - spin_unlock(&alias->d_lock);
    + seq_spin_unlock(&alias->d_lock);
    return alias;
    }
    }
    - spin_unlock(&alias->d_lock);
    + seq_spin_unlock(&alias->d_lock);
    }
    if (discon_alias) {
    alias = discon_alias;
    - spin_lock(&alias->d_lock);
    + seq_spin_lock(&alias->d_lock);
    if (S_ISDIR(inode->i_mode) || !d_unhashed(alias)) {
    if (IS_ROOT(alias) &&
    (alias->d_flags & DCACHE_DISCONNECTED)) {
    __dget_dlock(alias);
    - spin_unlock(&alias->d_lock);
    + seq_spin_unlock(&alias->d_lock);
    return alias;
    }
    }
    - spin_unlock(&alias->d_lock);
    + seq_spin_unlock(&alias->d_lock);
    goto again;
    }
    return NULL;
    @@ -699,16 +699,16 @@ void d_prune_aliases(struct inode *inode
    restart:
    spin_lock(&inode->i_lock);
    list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (!dentry->d_count) {
    __dget_dlock(dentry);
    __d_drop(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    spin_unlock(&inode->i_lock);
    dput(dentry);
    goto restart;
    }
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }
    spin_unlock(&inode->i_lock);
    }
    @@ -745,10 +745,10 @@ static void try_prune_one_dentry(struct
    /* Prune ancestors. */
    dentry = parent;
    while (dentry) {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (dentry->d_count > 1) {
    dentry->d_count--;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    return;
    }
    dentry = dentry_kill(dentry, 1);
    @@ -764,9 +764,9 @@ static void shrink_dentry_list(struct li
    dentry = list_entry_rcu(list->prev, struct dentry, d_lru);
    if (&dentry->d_lru == list)
    break; /* empty */
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (dentry != list_entry(list->prev, struct dentry, d_lru)) {
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    continue;
    }

    @@ -777,7 +777,7 @@ static void shrink_dentry_list(struct li
    */
    if (dentry->d_count) {
    dentry_lru_del(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    continue;
    }

    @@ -815,7 +815,7 @@ relock:
    struct dentry, d_lru);
    BUG_ON(dentry->d_sb != sb);

    - if (!spin_trylock(&dentry->d_lock)) {
    + if (!seq_spin_trylock(&dentry->d_lock)) {
    spin_unlock(&dcache_lru_lock);
    cpu_relax();
    goto relock;
    @@ -824,11 +824,11 @@ relock:
    if (dentry->d_flags & DCACHE_REFERENCED) {
    dentry->d_flags &= ~DCACHE_REFERENCED;
    list_move(&dentry->d_lru, &referenced);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    } else {
    list_move_tail(&dentry->d_lru, &tmp);
    dentry->d_flags |= DCACHE_SHRINK_LIST;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    if (!--count)
    break;
    }
    @@ -981,8 +981,8 @@ static struct dentry *try_to_ascend(stru
    struct dentry *new = old->d_parent;

    rcu_read_lock();
    - spin_unlock(&old->d_lock);
    - spin_lock(&new->d_lock);
    + seq_spin_unlock(&old->d_lock);
    + seq_spin_lock(&new->d_lock);

    /*
    * might go back up the wrong parent if we have had a rename
    @@ -991,7 +991,7 @@ static struct dentry *try_to_ascend(stru
    if (new != old->d_parent ||
    (old->d_flags & DCACHE_DISCONNECTED) ||
    (!locked && read_seqretry(&rename_lock, seq))) {
    - spin_unlock(&new->d_lock);
    + seq_spin_unlock(&new->d_lock);
    new = NULL;
    }
    rcu_read_unlock();
    @@ -1025,7 +1025,7 @@ again:

    if (d_mountpoint(parent))
    goto positive;
    - spin_lock(&this_parent->d_lock);
    + seq_spin_lock(&this_parent->d_lock);
    repeat:
    next = this_parent->d_subdirs.next;
    resume:
    @@ -1034,21 +1034,21 @@ resume:
    struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
    next = tmp->next;

    - spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
    + seq_spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
    /* Have we found a mount point ? */
    if (d_mountpoint(dentry)) {
    - spin_unlock(&dentry->d_lock);
    - spin_unlock(&this_parent->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&this_parent->d_lock);
    goto positive;
    }
    if (!list_empty(&dentry->d_subdirs)) {
    - spin_unlock(&this_parent->d_lock);
    - spin_release(&dentry->d_lock.dep_map, 1, _RET_IP_);
    + seq_spin_unlock(&this_parent->d_lock);
    + spin_release(&dentry->d_lock.lock.dep_map, 1, _RET_IP_);
    this_parent = dentry;
    - spin_acquire(&this_parent->d_lock.dep_map, 0, 1, _RET_IP_);
    + spin_acquire(&this_parent->d_lock.lock.dep_map, 0, 1, _RET_IP_);
    goto repeat;
    }
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }
    /*
    * All done at this level ... ascend and resume the search.
    @@ -1061,7 +1061,7 @@ resume:
    next = child->d_u.d_child.next;
    goto resume;
    }
    - spin_unlock(&this_parent->d_lock);
    + seq_spin_unlock(&this_parent->d_lock);
    if (!locked && read_seqretry(&rename_lock, seq))
    goto rename_retry;
    if (locked)
    @@ -1106,7 +1106,7 @@ static int select_parent(struct dentry *
    seq = read_seqbegin(&rename_lock);
    again:
    this_parent = parent;
    - spin_lock(&this_parent->d_lock);
    + seq_spin_lock(&this_parent->d_lock);
    repeat:
    next = this_parent->d_subdirs.next;
    resume:
    @@ -1115,7 +1115,7 @@ resume:
    struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
    next = tmp->next;

    - spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
    + seq_spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);

    /*
    * move only zero ref count dentries to the dispose list.
    @@ -1138,7 +1138,7 @@ resume:
    * the rest.
    */
    if (found && need_resched()) {
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    goto out;
    }

    @@ -1146,14 +1146,14 @@ resume:
    * Descend a level if the d_subdirs list is non-empty.
    */
    if (!list_empty(&dentry->d_subdirs)) {
    - spin_unlock(&this_parent->d_lock);
    - spin_release(&dentry->d_lock.dep_map, 1, _RET_IP_);
    + seq_spin_unlock(&this_parent->d_lock);
    + spin_release(&dentry->d_lock.lock.dep_map, 1, _RET_IP_);
    this_parent = dentry;
    - spin_acquire(&this_parent->d_lock.dep_map, 0, 1, _RET_IP_);
    + spin_acquire(&this_parent->d_lock.lock.dep_map, 0, 1, _RET_IP_);
    goto repeat;
    }

    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }
    /*
    * All done at this level ... ascend and resume the search.
    @@ -1167,7 +1167,7 @@ resume:
    goto resume;
    }
    out:
    - spin_unlock(&this_parent->d_lock);
    + seq_spin_unlock(&this_parent->d_lock);
    if (!locked && read_seqretry(&rename_lock, seq))
    goto rename_retry;
    if (locked)
    @@ -1235,8 +1235,7 @@ struct dentry *__d_alloc(struct super_bl

    dentry->d_count = 1;
    dentry->d_flags = 0;
    - spin_lock_init(&dentry->d_lock);
    - seqcount_init(&dentry->d_seq);
    + seqlock_init(&dentry->d_lock);
    dentry->d_inode = NULL;
    dentry->d_parent = dentry;
    dentry->d_sb = sb;
    @@ -1269,7 +1268,7 @@ struct dentry *d_alloc(struct dentry * p
    if (!dentry)
    return NULL;

    - spin_lock(&parent->d_lock);
    + seq_spin_lock(&parent->d_lock);
    /*
    * don't need child lock because it is not subject
    * to concurrency here
    @@ -1277,7 +1276,7 @@ struct dentry *d_alloc(struct dentry * p
    __dget_dlock(parent);
    dentry->d_parent = parent;
    list_add(&dentry->d_u.d_child, &parent->d_subdirs);
    - spin_unlock(&parent->d_lock);
    + seq_spin_unlock(&parent->d_lock);

    return dentry;
    }
    @@ -1329,7 +1328,7 @@ EXPORT_SYMBOL(d_set_d_op);

    static void __d_instantiate(struct dentry *dentry, struct inode *inode)
    {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (inode) {
    if (unlikely(IS_AUTOMOUNT(inode)))
    dentry->d_flags |= DCACHE_NEED_AUTOMOUNT;
    @@ -1337,7 +1336,7 @@ static void __d_instantiate(struct dentr
    }
    dentry->d_inode = inode;
    dentry_rcuwalk_barrier(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    fsnotify_d_instantiate(dentry, inode);
    }

    @@ -1561,14 +1560,14 @@ struct dentry *d_obtain_alias(struct ino
    }

    /* attach a disconnected dentry */
    - spin_lock(&tmp->d_lock);
    + seq_spin_lock(&tmp->d_lock);
    tmp->d_inode = inode;
    tmp->d_flags |= DCACHE_DISCONNECTED;
    list_add(&tmp->d_alias, &inode->i_dentry);
    hlist_bl_lock(&tmp->d_sb->s_anon);
    hlist_bl_add_head(&tmp->d_hash, &tmp->d_sb->s_anon);
    hlist_bl_unlock(&tmp->d_sb->s_anon);
    - spin_unlock(&tmp->d_lock);
    + seq_spin_unlock(&tmp->d_lock);
    spin_unlock(&inode->i_lock);
    security_d_instantiate(tmp, inode);

    @@ -1778,7 +1777,7 @@ struct dentry *__d_lookup_rcu(const stru
    continue;

    seqretry:
    - seq = read_seqcount_begin(&dentry->d_seq);
    + seq = read_seqbegin(&dentry->d_lock);
    if (dentry->d_parent != parent)
    continue;
    if (d_unhashed(dentry))
    @@ -1793,7 +1792,7 @@ seqretry:
    * edge of memory when walking. If we could load this
    * atomically some other way, we could drop this check.
    */
    - if (read_seqcount_retry(&dentry->d_seq, seq))
    + if (read_seqretry(&dentry->d_lock, seq))
    goto seqretry;
    if (unlikely(parent->d_flags & DCACHE_OP_COMPARE)) {
    if (parent->d_op->d_compare(parent, *inode,
    @@ -1897,7 +1896,7 @@ struct dentry *__d_lookup(struct dentry
    if (dentry->d_name.hash != hash)
    continue;

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (dentry->d_parent != parent)
    goto next;
    if (d_unhashed(dentry))
    @@ -1921,10 +1920,10 @@ struct dentry *__d_lookup(struct dentry

    dentry->d_count++;
    found = dentry;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    break;
    next:
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }
    rcu_read_unlock();

    @@ -1972,17 +1971,17 @@ int d_validate(struct dentry *dentry, st
    {
    struct dentry *child;

    - spin_lock(&dparent->d_lock);
    + seq_spin_lock(&dparent->d_lock);
    list_for_each_entry(child, &dparent->d_subdirs, d_u.d_child) {
    if (dentry == child) {
    - spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
    + spin_lock_nested(&dentry->d_lock.lock, DENTRY_D_LOCK_NESTED);
    __dget_dlock(dentry);
    - spin_unlock(&dentry->d_lock);
    - spin_unlock(&dparent->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dparent->d_lock);
    return 1;
    }
    }
    - spin_unlock(&dparent->d_lock);
    + seq_spin_unlock(&dparent->d_lock);

    return 0;
    }
    @@ -2017,12 +2016,12 @@ void d_delete(struct dentry * dentry)
    * Are we the only user?
    */
    again:
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    inode = dentry->d_inode;
    isdir = S_ISDIR(inode->i_mode);
    if (dentry->d_count == 1) {
    if (inode && !spin_trylock(&inode->i_lock)) {
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    cpu_relax();
    goto again;
    }
    @@ -2035,7 +2034,7 @@ again:
    if (!d_unhashed(dentry))
    __d_drop(dentry);

    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);

    fsnotify_nameremove(dentry, isdir);
    }
    @@ -2064,9 +2063,9 @@ static void _d_rehash(struct dentry * en

    void d_rehash(struct dentry * entry)
    {
    - spin_lock(&entry->d_lock);
    + seq_spin_lock(&entry->d_lock);
    _d_rehash(entry);
    - spin_unlock(&entry->d_lock);
    + seq_spin_unlock(&entry->d_lock);
    }
    EXPORT_SYMBOL(d_rehash);

    @@ -2089,11 +2088,9 @@ void dentry_update_name_case(struct dent
    BUG_ON(!mutex_is_locked(&dentry->d_parent->d_inode->i_mutex));
    BUG_ON(dentry->d_name.len != name->len); /* d_lookup gives this */

    - spin_lock(&dentry->d_lock);
    - write_seqcount_begin(&dentry->d_seq);
    + write_seqlock(&dentry->d_lock);
    memcpy((unsigned char *)dentry->d_name.name, name->name, name->len);
    - write_seqcount_end(&dentry->d_seq);
    - spin_unlock(&dentry->d_lock);
    + write_sequnlock(&dentry->d_lock);
    }
    EXPORT_SYMBOL(dentry_update_name_case);

    @@ -2144,24 +2141,24 @@ static void dentry_lock_for_move(struct
    * XXXX: do we really need to take target->d_lock?
    */
    if (IS_ROOT(dentry) || dentry->d_parent == target->d_parent)
    - spin_lock(&target->d_parent->d_lock);
    + seq_spin_lock(&target->d_parent->d_lock);
    else {
    if (d_ancestor(dentry->d_parent, target->d_parent)) {
    - spin_lock(&dentry->d_parent->d_lock);
    - spin_lock_nested(&target->d_parent->d_lock,
    - DENTRY_D_LOCK_NESTED);
    + seq_spin_lock(&dentry->d_parent->d_lock);
    + seq_spin_lock_nested(&target->d_parent->d_lock,
    + DENTRY_D_LOCK_NESTED);
    } else {
    - spin_lock(&target->d_parent->d_lock);
    - spin_lock_nested(&dentry->d_parent->d_lock,
    - DENTRY_D_LOCK_NESTED);
    + seq_spin_lock(&target->d_parent->d_lock);
    + seq_spin_lock_nested(&dentry->d_parent->d_lock,
    + DENTRY_D_LOCK_NESTED);
    }
    }
    if (target < dentry) {
    - spin_lock_nested(&target->d_lock, 2);
    - spin_lock_nested(&dentry->d_lock, 3);
    + seq_spin_lock_nested(&target->d_lock, 2);
    + seq_spin_lock_nested(&dentry->d_lock, 3);
    } else {
    - spin_lock_nested(&dentry->d_lock, 2);
    - spin_lock_nested(&target->d_lock, 3);
    + seq_spin_lock_nested(&dentry->d_lock, 2);
    + seq_spin_lock_nested(&target->d_lock, 3);
    }
    }

    @@ -2169,9 +2166,9 @@ static void dentry_unlock_parents_for_mo
    struct dentry *target)
    {
    if (target->d_parent != dentry->d_parent)
    - spin_unlock(&dentry->d_parent->d_lock);
    + seq_spin_unlock(&dentry->d_parent->d_lock);
    if (target->d_parent != target)
    - spin_unlock(&target->d_parent->d_lock);
    + seq_spin_unlock(&target->d_parent->d_lock);
    }

    /*
    @@ -2205,8 +2202,8 @@ static void __d_move(struct dentry * den

    dentry_lock_for_move(dentry, target);

    - write_seqcount_begin(&dentry->d_seq);
    - write_seqcount_begin(&target->d_seq);
    + write_seqlock_begin(&dentry->d_lock);
    + write_seqlock_begin(&target->d_lock);

    /* __d_drop does write_seqcount_barrier, but they're OK to nest. */

    @@ -2241,13 +2238,13 @@ static void __d_move(struct dentry * den

    list_add(&dentry->d_u.d_child, &dentry->d_parent->d_subdirs);

    - write_seqcount_end(&target->d_seq);
    - write_seqcount_end(&dentry->d_seq);
    + write_seqlock_end(&target->d_lock);
    + write_seqlock_end(&dentry->d_lock);

    dentry_unlock_parents_for_move(dentry, target);
    - spin_unlock(&target->d_lock);
    + seq_spin_unlock(&target->d_lock);
    fsnotify_d_move(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }

    /*
    @@ -2336,8 +2333,8 @@ static void __d_materialise_dentry(struc

    dentry_lock_for_move(anon, dentry);

    - write_seqcount_begin(&dentry->d_seq);
    - write_seqcount_begin(&anon->d_seq);
    + write_seqlock_begin(&dentry->d_lock);
    + write_seqlock_begin(&anon->d_lock);

    dparent = dentry->d_parent;
    aparent = anon->d_parent;
    @@ -2359,11 +2356,11 @@ static void __d_materialise_dentry(struc
    else
    INIT_LIST_HEAD(&anon->d_u.d_child);

    - write_seqcount_end(&dentry->d_seq);
    - write_seqcount_end(&anon->d_seq);
    + write_seqlock_end(&dentry->d_lock);
    + write_seqlock_end(&anon->d_lock);

    dentry_unlock_parents_for_move(anon, dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);

    /* anon->d_lock still locked, returns locked */
    anon->d_flags &= ~DCACHE_DISCONNECTED;
    @@ -2439,10 +2436,10 @@ struct dentry *d_materialise_unique(stru
    else
    BUG_ON(!d_unhashed(actual));

    - spin_lock(&actual->d_lock);
    + seq_spin_lock(&actual->d_lock);
    found:
    _d_rehash(actual);
    - spin_unlock(&actual->d_lock);
    + seq_spin_unlock(&actual->d_lock);
    spin_unlock(&inode->i_lock);
    out_nolock:
    if (actual == dentry) {
    @@ -2504,9 +2501,9 @@ static int prepend_path(const struct pat
    }
    parent = dentry->d_parent;
    prefetch(parent);
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    error = prepend_name(buffer, buflen, &dentry->d_name);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    if (!error)
    error = prepend(buffer, buflen, "/", 1);
    if (error)
    @@ -2731,9 +2728,9 @@ static char *__dentry_path(struct dentry
    int error;

    prefetch(parent);
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    error = prepend_name(&end, &buflen, &dentry->d_name);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    if (error != 0 || prepend(&end, &buflen, "/", 1) != 0)
    goto Elong;

    @@ -2898,7 +2895,7 @@ void d_genocide(struct dentry *root)
    seq = read_seqbegin(&rename_lock);
    again:
    this_parent = root;
    - spin_lock(&this_parent->d_lock);
    + seq_spin_lock(&this_parent->d_lock);
    repeat:
    next = this_parent->d_subdirs.next;
    resume:
    @@ -2907,23 +2904,23 @@ resume:
    struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
    next = tmp->next;

    - spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
    + seq_spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
    if (d_unhashed(dentry) || !dentry->d_inode) {
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    continue;
    }
    if (!list_empty(&dentry->d_subdirs)) {
    - spin_unlock(&this_parent->d_lock);
    - spin_release(&dentry->d_lock.dep_map, 1, _RET_IP_);
    + seq_spin_unlock(&this_parent->d_lock);
    + spin_release(&dentry->d_lock.lock.dep_map, 1, _RET_IP_);
    this_parent = dentry;
    - spin_acquire(&this_parent->d_lock.dep_map, 0, 1, _RET_IP_);
    + spin_acquire(&this_parent->d_lock.lock.dep_map, 0, 1, _RET_IP_);
    goto repeat;
    }
    if (!(dentry->d_flags & DCACHE_GENOCIDE)) {
    dentry->d_flags |= DCACHE_GENOCIDE;
    dentry->d_count--;
    }
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }
    if (this_parent != root) {
    struct dentry *child = this_parent;
    @@ -2937,7 +2934,7 @@ resume:
    next = child->d_u.d_child.next;
    goto resume;
    }
    - spin_unlock(&this_parent->d_lock);
    + seq_spin_unlock(&this_parent->d_lock);
    if (!locked && read_seqretry(&rename_lock, seq))
    goto rename_retry;
    if (locked)
    Index: tip/fs/dcookies.c
    ===================================================================
    --- tip.orig/fs/dcookies.c
    +++ tip/fs/dcookies.c
    @@ -98,9 +98,9 @@ static struct dcookie_struct *alloc_dcoo
    return NULL;

    d = path->dentry;
    - spin_lock(&d->d_lock);
    + seq_spin_lock(&d->d_lock);
    d->d_flags |= DCACHE_COOKIE;
    - spin_unlock(&d->d_lock);
    + seq_spin_unlock(&d->d_lock);

    dcs->path = *path;
    path_get(path);
    @@ -267,9 +267,9 @@ static void free_dcookie(struct dcookie_
    {
    struct dentry *d = dcs->path.dentry;

    - spin_lock(&d->d_lock);
    + seq_spin_lock(&d->d_lock);
    d->d_flags &= ~DCACHE_COOKIE;
    - spin_unlock(&d->d_lock);
    + seq_spin_unlock(&d->d_lock);

    path_put(&dcs->path);
    kmem_cache_free(dcookie_cache, dcs);
    Index: tip/fs/exportfs/expfs.c
    ===================================================================
    --- tip.orig/fs/exportfs/expfs.c
    +++ tip/fs/exportfs/expfs.c
    @@ -114,15 +114,15 @@ reconnect_path(struct vfsmount *mnt, str

    if (!IS_ROOT(pd)) {
    /* must have found a connected parent - great */
    - spin_lock(&pd->d_lock);
    + seq_spin_lock(&pd->d_lock);
    pd->d_flags &= ~DCACHE_DISCONNECTED;
    - spin_unlock(&pd->d_lock);
    + seq_spin_unlock(&pd->d_lock);
    noprogress = 0;
    } else if (pd == mnt->mnt_sb->s_root) {
    printk(KERN_ERR "export: Eeek filesystem root is not connected, impossible\n");
    - spin_lock(&pd->d_lock);
    + seq_spin_lock(&pd->d_lock);
    pd->d_flags &= ~DCACHE_DISCONNECTED;
    - spin_unlock(&pd->d_lock);
    + seq_spin_unlock(&pd->d_lock);
    noprogress = 0;
    } else {
    /*
    @@ -335,11 +335,11 @@ static int export_encode_fh(struct dentr
    if (connectable && !S_ISDIR(inode->i_mode)) {
    struct inode *parent;

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    parent = dentry->d_parent->d_inode;
    fid->i32.parent_ino = parent->i_ino;
    fid->i32.parent_gen = parent->i_generation;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    len = 4;
    type = FILEID_INO32_GEN_PARENT;
    }
    Index: tip/fs/fat/inode.c
    ===================================================================
    --- tip.orig/fs/fat/inode.c
    +++ tip/fs/fat/inode.c
    @@ -771,9 +771,9 @@ fat_encode_fh(struct dentry *de, __u32 *
    fh[1] = inode->i_generation;
    fh[2] = ipos_h;
    fh[3] = ipos_m | MSDOS_I(inode)->i_logstart;
    - spin_lock(&de->d_lock);
    + seq_spin_lock(&de->d_lock);
    fh[4] = ipos_l | MSDOS_I(de->d_parent->d_inode)->i_logstart;
    - spin_unlock(&de->d_lock);
    + seq_spin_unlock(&de->d_lock);
    return 3;
    }

    Index: tip/fs/fat/namei_vfat.c
    ===================================================================
    --- tip.orig/fs/fat/namei_vfat.c
    +++ tip/fs/fat/namei_vfat.c
    @@ -34,10 +34,10 @@
    static int vfat_revalidate_shortname(struct dentry *dentry)
    {
    int ret = 1;
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (dentry->d_time != dentry->d_parent->d_inode->i_version)
    ret = 0;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    return ret;
    }

    Index: tip/fs/fs-writeback.c
    ===================================================================
    --- tip.orig/fs/fs-writeback.c
    +++ tip/fs/fs-writeback.c
    @@ -1019,7 +1019,7 @@ static noinline void block_dump___mark_i

    dentry = d_find_alias(inode);
    if (dentry) {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    name = (const char *) dentry->d_name.name;
    }
    printk(KERN_DEBUG
    @@ -1027,7 +1027,7 @@ static noinline void block_dump___mark_i
    current->comm, task_pid_nr(current), inode->i_ino,
    name, inode->i_sb->s_id);
    if (dentry) {
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    dput(dentry);
    }
    }
    Index: tip/fs/fuse/inode.c
    ===================================================================
    --- tip.orig/fs/fuse/inode.c
    +++ tip/fs/fuse/inode.c
    @@ -651,11 +651,11 @@ static int fuse_encode_fh(struct dentry
    if (encode_parent) {
    struct inode *parent;

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    parent = dentry->d_parent->d_inode;
    nodeid = get_fuse_inode(parent)->nodeid;
    generation = parent->i_generation;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);

    fh[3] = (u32)(nodeid >> 32);
    fh[4] = (u32)(nodeid & 0xffffffff);
    Index: tip/fs/gfs2/export.c
    ===================================================================
    --- tip.orig/fs/gfs2/export.c
    +++ tip/fs/gfs2/export.c
    @@ -53,11 +53,11 @@ static int gfs2_encode_fh(struct dentry
    if (!connectable || inode == sb->s_root->d_inode)
    return *len;

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    inode = dentry->d_parent->d_inode;
    ip = GFS2_I(inode);
    igrab(inode);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);

    fh[4] = cpu_to_be32(ip->i_no_formal_ino >> 32);
    fh[5] = cpu_to_be32(ip->i_no_formal_ino & 0xFFFFFFFF);
    Index: tip/fs/isofs/export.c
    ===================================================================
    --- tip.orig/fs/isofs/export.c
    +++ tip/fs/isofs/export.c
    @@ -139,13 +139,13 @@ isofs_export_encode_fh(struct dentry *de
    if (connectable && !S_ISDIR(inode->i_mode)) {
    struct inode *parent;
    struct iso_inode_info *eparent;
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    parent = dentry->d_parent->d_inode;
    eparent = ISOFS_I(parent);
    fh32[3] = eparent->i_iget5_block;
    fh16[3] = (__u16)eparent->i_iget5_offset; /* fh16 [sic] */
    fh32[4] = parent->i_generation;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    len = 5;
    type = 2;
    }
    Index: tip/fs/libfs.c
    ===================================================================
    --- tip.orig/fs/libfs.c
    +++ tip/fs/libfs.c
    @@ -102,21 +102,21 @@ loff_t dcache_dir_lseek(struct file *fil
    struct dentry *cursor = file->private_data;
    loff_t n = file->f_pos - 2;

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    /* d_lock not required for cursor */
    list_del(&cursor->d_u.d_child);
    p = dentry->d_subdirs.next;
    while (n && p != &dentry->d_subdirs) {
    struct dentry *next;
    next = list_entry(p, struct dentry, d_u.d_child);
    - spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
    + seq_spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
    if (simple_positive(next))
    n--;
    - spin_unlock(&next->d_lock);
    + seq_spin_unlock(&next->d_lock);
    p = p->next;
    }
    list_add_tail(&cursor->d_u.d_child, p);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }
    }
    mutex_unlock(&dentry->d_inode->i_mutex);
    @@ -159,35 +159,35 @@ int dcache_readdir(struct file * filp, v
    i++;
    /* fallthrough */
    default:
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (filp->f_pos == 2)
    list_move(q, &dentry->d_subdirs);

    for (p=q->next; p != &dentry->d_subdirs; p=p->next) {
    struct dentry *next;
    next = list_entry(p, struct dentry, d_u.d_child);
    - spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
    + seq_spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
    if (!simple_positive(next)) {
    - spin_unlock(&next->d_lock);
    + seq_spin_unlock(&next->d_lock);
    continue;
    }

    - spin_unlock(&next->d_lock);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&next->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    if (filldir(dirent, next->d_name.name,
    next->d_name.len, filp->f_pos,
    next->d_inode->i_ino,
    dt_type(next->d_inode)) < 0)
    return 0;
    - spin_lock(&dentry->d_lock);
    - spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
    + seq_spin_lock(&dentry->d_lock);
    + seq_spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
    /* next is still alive */
    list_move(q, p);
    - spin_unlock(&next->d_lock);
    + seq_spin_unlock(&next->d_lock);
    p = q;
    filp->f_pos++;
    }
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }
    return 0;
    }
    @@ -281,18 +281,18 @@ int simple_empty(struct dentry *dentry)
    struct dentry *child;
    int ret = 0;

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    list_for_each_entry(child, &dentry->d_subdirs, d_u.d_child) {
    - spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED);
    + seq_spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED);
    if (simple_positive(child)) {
    - spin_unlock(&child->d_lock);
    + seq_spin_unlock(&child->d_lock);
    goto out;
    }
    - spin_unlock(&child->d_lock);
    + seq_spin_unlock(&child->d_lock);
    }
    ret = 1;
    out:
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    return ret;
    }

    Index: tip/fs/namei.c
    ===================================================================
    --- tip.orig/fs/namei.c
    +++ tip/fs/namei.c
    @@ -432,7 +432,7 @@ static int unlazy_walk(struct nameidata
    nd->root.dentry != fs->root.dentry)
    goto err_root;
    }
    - spin_lock(&parent->d_lock);
    + seq_spin_lock(&parent->d_lock);
    if (!dentry) {
    if (!__d_rcu_to_refcount(parent, nd->seq))
    goto err_parent;
    @@ -440,7 +440,7 @@ static int unlazy_walk(struct nameidata
    } else {
    if (dentry->d_parent != parent)
    goto err_parent;
    - spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
    + seq_spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
    if (!__d_rcu_to_refcount(dentry, nd->seq))
    goto err_child;
    /*
    @@ -452,9 +452,9 @@ static int unlazy_walk(struct nameidata
    BUG_ON(!IS_ROOT(dentry) && dentry->d_parent != parent);
    BUG_ON(!parent->d_count);
    parent->d_count++;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }
    - spin_unlock(&parent->d_lock);
    + seq_spin_unlock(&parent->d_lock);
    if (want_root) {
    path_get(&nd->root);
    seq_spin_unlock(&fs->lock);
    @@ -467,9 +467,9 @@ static int unlazy_walk(struct nameidata
    return 0;

    err_child:
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    err_parent:
    - spin_unlock(&parent->d_lock);
    + seq_spin_unlock(&parent->d_lock);
    err_root:
    if (want_root)
    seq_spin_unlock(&fs->lock);
    @@ -516,15 +516,15 @@ static int complete_walk(struct nameidat
    nd->flags &= ~LOOKUP_RCU;
    if (!(nd->flags & LOOKUP_ROOT))
    nd->root.mnt = NULL;
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (unlikely(!__d_rcu_to_refcount(dentry, nd->seq))) {
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    rcu_read_unlock();
    br_read_unlock(vfsmount_lock);
    return -ECHILD;
    }
    BUG_ON(nd->inode != dentry->d_inode);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    mntget(nd->path.mnt);
    rcu_read_unlock();
    br_read_unlock(vfsmount_lock);
    @@ -568,7 +568,7 @@ static __always_inline void set_root_rcu
    do {
    seq = read_seqbegin(&fs->lock);
    nd->root = fs->root;
    - nd->seq = __read_seqcount_begin(&nd->root.dentry->d_seq);
    + nd->seq = __read_seqbegin(&nd->root.dentry->d_lock);
    } while (read_seqretry(&fs->lock, seq));
    }
    }
    @@ -902,7 +902,7 @@ static bool __follow_mount_rcu(struct na
    path->mnt = &mounted->mnt;
    path->dentry = mounted->mnt.mnt_root;
    nd->flags |= LOOKUP_JUMPED;
    - nd->seq = read_seqcount_begin(&path->dentry->d_seq);
    + nd->seq = read_seqbegin(&path->dentry->d_lock);
    /*
    * Update the inode too. We don't need to re-check the
    * dentry sequence number here after this d_inode read,
    @@ -922,7 +922,7 @@ static void follow_mount_rcu(struct name
    break;
    nd->path.mnt = &mounted->mnt;
    nd->path.dentry = mounted->mnt.mnt_root;
    - nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
    + nd->seq = read_seqbegin(&nd->path.dentry->d_lock);
    }
    }

    @@ -940,8 +940,8 @@ static int follow_dotdot_rcu(struct name
    struct dentry *parent = old->d_parent;
    unsigned seq;

    - seq = read_seqcount_begin(&parent->d_seq);
    - if (read_seqcount_retry(&old->d_seq, nd->seq))
    + seq = read_seqbegin(&parent->d_lock);
    + if (read_seqretry(&old->d_lock, nd->seq))
    goto failed;
    nd->path.dentry = parent;
    nd->seq = seq;
    @@ -949,7 +949,7 @@ static int follow_dotdot_rcu(struct name
    }
    if (!follow_up_rcu(&nd->path))
    break;
    - nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
    + nd->seq = read_seqbegin(&nd->path.dentry->d_lock);
    }
    follow_mount_rcu(nd);
    nd->inode = nd->path.dentry->d_inode;
    @@ -1135,7 +1135,7 @@ static int do_lookup(struct nameidata *n
    goto unlazy;

    /* Memory barrier in read_seqcount_begin of child is enough */
    - if (__read_seqcount_retry(&parent->d_seq, nd->seq))
    + if (__read_seqretry(&parent->d_lock, nd->seq))
    return -ECHILD;
    nd->seq = seq;

    @@ -1517,7 +1517,7 @@ static int path_init(int dfd, const char
    if (flags & LOOKUP_RCU) {
    br_read_lock(vfsmount_lock);
    rcu_read_lock();
    - nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
    + nd->seq = __read_seqbegin(&nd->path.dentry->d_lock);
    } else {
    path_get(&nd->path);
    }
    @@ -1547,7 +1547,7 @@ static int path_init(int dfd, const char
    do {
    seq = read_seqbegin(&fs->lock);
    nd->path = fs->pwd;
    - nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
    + nd->seq = __read_seqbegin(&nd->path.dentry->d_lock);
    } while (read_seqretry(&fs->lock, seq));
    } else {
    get_fs_pwd(current->fs, &nd->path);
    @@ -1576,7 +1576,7 @@ static int path_init(int dfd, const char
    if (flags & LOOKUP_RCU) {
    if (fput_needed)
    *fp = file;
    - nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
    + nd->seq = __read_seqbegin(&nd->path.dentry->d_lock);
    br_read_lock(vfsmount_lock);
    rcu_read_lock();
    } else {
    @@ -2638,10 +2638,10 @@ SYSCALL_DEFINE2(mkdir, const char __user
    void dentry_unhash(struct dentry *dentry)
    {
    shrink_dcache_parent(dentry);
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (dentry->d_count == 1)
    __d_drop(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }

    int vfs_rmdir(struct inode *dir, struct dentry *dentry)
    Index: tip/fs/namespace.c
    ===================================================================
    --- tip.orig/fs/namespace.c
    +++ tip/fs/namespace.c
    @@ -577,9 +577,9 @@ static void dentry_reset_mounted(struct
    return;
    }
    }
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    dentry->d_flags &= ~DCACHE_MOUNTED;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }

    /*
    @@ -605,9 +605,9 @@ void mnt_set_mountpoint(struct mount *mn
    mnt_add_count(mnt, 1); /* essentially, that's mntget */
    child_mnt->mnt_mountpoint = dget(dentry);
    child_mnt->mnt_parent = mnt;
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    dentry->d_flags |= DCACHE_MOUNTED;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }

    /*
    Index: tip/fs/ncpfs/dir.c
    ===================================================================
    --- tip.orig/fs/ncpfs/dir.c
    +++ tip/fs/ncpfs/dir.c
    @@ -388,7 +388,7 @@ ncp_dget_fpos(struct dentry *dentry, str
    }

    /* If a pointer is invalid, we search the dentry. */
    - spin_lock(&parent->d_lock);
    + seq_spin_lock(&parent->d_lock);
    next = parent->d_subdirs.next;
    while (next != &parent->d_subdirs) {
    dent = list_entry(next, struct dentry, d_u.d_child);
    @@ -397,12 +397,12 @@ ncp_dget_fpos(struct dentry *dentry, str
    dget(dent);
    else
    dent = NULL;
    - spin_unlock(&parent->d_lock);
    + seq_spin_unlock(&parent->d_lock);
    goto out;
    }
    next = next->next;
    }
    - spin_unlock(&parent->d_lock);
    + seq_spin_unlock(&parent->d_lock);
    return NULL;

    out:
    Index: tip/fs/ncpfs/ncplib_kernel.h
    ===================================================================
    --- tip.orig/fs/ncpfs/ncplib_kernel.h
    +++ tip/fs/ncpfs/ncplib_kernel.h
    @@ -191,7 +191,7 @@ ncp_renew_dentries(struct dentry *parent
    struct list_head *next;
    struct dentry *dentry;

    - spin_lock(&parent->d_lock);
    + seq_spin_lock(&parent->d_lock);
    next = parent->d_subdirs.next;
    while (next != &parent->d_subdirs) {
    dentry = list_entry(next, struct dentry, d_u.d_child);
    @@ -203,7 +203,7 @@ ncp_renew_dentries(struct dentry *parent

    next = next->next;
    }
    - spin_unlock(&parent->d_lock);
    + seq_spin_unlock(&parent->d_lock);
    }

    static inline void
    @@ -213,7 +213,7 @@ ncp_invalidate_dircache_entries(struct d
    struct list_head *next;
    struct dentry *dentry;

    - spin_lock(&parent->d_lock);
    + seq_spin_lock(&parent->d_lock);
    next = parent->d_subdirs.next;
    while (next != &parent->d_subdirs) {
    dentry = list_entry(next, struct dentry, d_u.d_child);
    @@ -221,7 +221,7 @@ ncp_invalidate_dircache_entries(struct d
    ncp_age_dentry(server, dentry);
    next = next->next;
    }
    - spin_unlock(&parent->d_lock);
    + seq_spin_unlock(&parent->d_lock);
    }

    struct ncp_cache_head {
    Index: tip/fs/nfs/dir.c
    ===================================================================
    --- tip.orig/fs/nfs/dir.c
    +++ tip/fs/nfs/dir.c
    @@ -1812,9 +1812,9 @@ static int nfs_unlink(struct inode *dir,
    dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id,
    dir->i_ino, dentry->d_name.name);

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (dentry->d_count > 1) {
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    /* Start asynchronous writeout of the inode */
    write_inode_now(dentry->d_inode, 0);
    error = nfs_sillyrename(dir, dentry);
    @@ -1824,7 +1824,7 @@ static int nfs_unlink(struct inode *dir,
    __d_drop(dentry);
    need_rehash = 1;
    }
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    error = nfs_safe_remove(dentry);
    if (!error || error == -ENOENT) {
    nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
    Index: tip/fs/nfs/getroot.c
    ===================================================================
    --- tip.orig/fs/nfs/getroot.c
    +++ tip/fs/nfs/getroot.c
    @@ -64,9 +64,9 @@ static int nfs_superblock_set_dummy_root
    * Oops, since the test for IS_ROOT() will fail.
    */
    spin_lock(&sb->s_root->d_inode->i_lock);
    - spin_lock(&sb->s_root->d_lock);
    + seq_spin_lock(&sb->s_root->d_lock);
    list_del_init(&sb->s_root->d_alias);
    - spin_unlock(&sb->s_root->d_lock);
    + seq_spin_unlock(&sb->s_root->d_lock);
    spin_unlock(&sb->s_root->d_inode->i_lock);
    }
    return 0;
    @@ -126,12 +126,12 @@ struct dentry *nfs_get_root(struct super
    }

    security_d_instantiate(ret, inode);
    - spin_lock(&ret->d_lock);
    + seq_spin_lock(&ret->d_lock);
    if (IS_ROOT(ret) && !(ret->d_flags & DCACHE_NFSFS_RENAMED)) {
    ret->d_fsdata = name;
    name = NULL;
    }
    - spin_unlock(&ret->d_lock);
    + seq_spin_unlock(&ret->d_lock);
    out:
    if (name)
    kfree(name);
    @@ -250,12 +250,12 @@ struct dentry *nfs4_get_root(struct supe
    }

    security_d_instantiate(ret, inode);
    - spin_lock(&ret->d_lock);
    + seq_spin_lock(&ret->d_lock);
    if (IS_ROOT(ret) && !(ret->d_flags & DCACHE_NFSFS_RENAMED)) {
    ret->d_fsdata = name;
    name = NULL;
    }
    - spin_unlock(&ret->d_lock);
    + seq_spin_unlock(&ret->d_lock);
    out:
    if (name)
    kfree(name);
    Index: tip/fs/nfs/namespace.c
    ===================================================================
    --- tip.orig/fs/nfs/namespace.c
    +++ tip/fs/nfs/namespace.c
    @@ -60,7 +60,7 @@ rename_retry:
    seq = read_seqbegin(&rename_lock);
    rcu_read_lock();
    while (1) {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (IS_ROOT(dentry))
    break;
    namelen = dentry->d_name.len;
    @@ -70,17 +70,17 @@ rename_retry:
    end -= namelen;
    memcpy(end, dentry->d_name.name, namelen);
    *--end = '/';
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    dentry = dentry->d_parent;
    }
    if (read_seqretry(&rename_lock, seq)) {
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    rcu_read_unlock();
    goto rename_retry;
    }
    if (*end != '/') {
    if (--buflen < 0) {
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    rcu_read_unlock();
    goto Elong;
    }
    @@ -89,7 +89,7 @@ rename_retry:
    *p = end;
    base = dentry->d_fsdata;
    if (!base) {
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    rcu_read_unlock();
    WARN_ON(1);
    return end;
    @@ -100,17 +100,17 @@ rename_retry:
    namelen--;
    buflen -= namelen;
    if (buflen < 0) {
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    rcu_read_unlock();
    goto Elong;
    }
    end -= namelen;
    memcpy(end, base, namelen);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    rcu_read_unlock();
    return end;
    Elong_unlock:
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    rcu_read_unlock();
    if (read_seqretry(&rename_lock, seq))
    goto rename_retry;
    Index: tip/fs/nfs/unlink.c
    ===================================================================
    --- tip.orig/fs/nfs/unlink.c
    +++ tip/fs/nfs/unlink.c
    @@ -156,7 +156,7 @@ static int nfs_do_call_unlink(struct den
    */
    nfs_free_dname(data);
    ret = nfs_copy_dname(alias, data);
    - spin_lock(&alias->d_lock);
    + seq_spin_lock(&alias->d_lock);
    if (ret == 0 && alias->d_inode != NULL &&
    !(alias->d_flags & DCACHE_NFSFS_RENAMED)) {
    devname_garbage = alias->d_fsdata;
    @@ -165,7 +165,7 @@ static int nfs_do_call_unlink(struct den
    ret = 1;
    } else
    ret = 0;
    - spin_unlock(&alias->d_lock);
    + seq_spin_unlock(&alias->d_lock);
    nfs_dec_sillycount(dir);
    dput(alias);
    /*
    @@ -274,13 +274,13 @@ nfs_async_unlink(struct inode *dir, stru
    data->res.dir_attr = &data->dir_attr;

    status = -EBUSY;
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
    goto out_unlock;
    dentry->d_flags |= DCACHE_NFSFS_RENAMED;
    devname_garbage = dentry->d_fsdata;
    dentry->d_fsdata = data;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    /*
    * If we'd displaced old cached devname, free it. At that
    * point dentry is definitely not a root, so we won't need
    @@ -290,7 +290,7 @@ nfs_async_unlink(struct inode *dir, stru
    kfree(devname_garbage);
    return 0;
    out_unlock:
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    put_rpccred(data->cred);
    out_free:
    kfree(data);
    @@ -312,13 +312,13 @@ nfs_complete_unlink(struct dentry *dentr
    {
    struct nfs_unlinkdata *data = NULL;

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
    dentry->d_flags &= ~DCACHE_NFSFS_RENAMED;
    data = dentry->d_fsdata;
    dentry->d_fsdata = NULL;
    }
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);

    if (data != NULL && (NFS_STALE(inode) || !nfs_call_unlink(dentry, data)))
    nfs_free_unlinkdata(data);
    @@ -328,17 +328,17 @@ nfs_complete_unlink(struct dentry *dentr
    static void
    nfs_cancel_async_unlink(struct dentry *dentry)
    {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
    struct nfs_unlinkdata *data = dentry->d_fsdata;

    dentry->d_flags &= ~DCACHE_NFSFS_RENAMED;
    dentry->d_fsdata = NULL;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    nfs_free_unlinkdata(data);
    return;
    }
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }

    struct nfs_renamedata {
    Index: tip/fs/nilfs2/namei.c
    ===================================================================
    --- tip.orig/fs/nilfs2/namei.c
    +++ tip/fs/nilfs2/namei.c
    @@ -538,11 +538,11 @@ static int nilfs_encode_fh(struct dentry
    if (connectable && !S_ISDIR(inode->i_mode)) {
    struct inode *parent;

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    parent = dentry->d_parent->d_inode;
    fid->parent_ino = parent->i_ino;
    fid->parent_gen = parent->i_generation;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);

    type = FILEID_NILFS_WITH_PARENT;
    *lenp = NILFS_FID_SIZE_CONNECTABLE;
    Index: tip/fs/notify/fsnotify.c
    ===================================================================
    --- tip.orig/fs/notify/fsnotify.c
    +++ tip/fs/notify/fsnotify.c
    @@ -69,19 +69,19 @@ void __fsnotify_update_child_dentry_flag
    /* run all of the children of the original inode and fix their
    * d_flags to indicate parental interest (their parent is the
    * original inode) */
    - spin_lock(&alias->d_lock);
    + seq_spin_lock(&alias->d_lock);
    list_for_each_entry(child, &alias->d_subdirs, d_u.d_child) {
    if (!child->d_inode)
    continue;

    - spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED);
    + seq_spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED);
    if (watched)
    child->d_flags |= DCACHE_FSNOTIFY_PARENT_WATCHED;
    else
    child->d_flags &= ~DCACHE_FSNOTIFY_PARENT_WATCHED;
    - spin_unlock(&child->d_lock);
    + seq_spin_unlock(&child->d_lock);
    }
    - spin_unlock(&alias->d_lock);
    + seq_spin_unlock(&alias->d_lock);
    }
    spin_unlock(&inode->i_lock);
    }
    Index: tip/fs/notify/vfsmount_mark.c
    ===================================================================
    --- tip.orig/fs/notify/vfsmount_mark.c
    +++ tip/fs/notify/vfsmount_mark.c
    @@ -37,13 +37,13 @@ void fsnotify_clear_marks_by_mount(struc
    struct mount *m = real_mount(mnt);
    LIST_HEAD(free_list);

    - spin_lock(&mnt->mnt_root->d_lock);
    + seq_spin_lock(&mnt->mnt_root->d_lock);
    hlist_for_each_entry_safe(mark, pos, n, &m->mnt_fsnotify_marks, m.m_list) {
    list_add(&mark->m.free_m_list, &free_list);
    hlist_del_init_rcu(&mark->m.m_list);
    fsnotify_get_mark(mark);
    }
    - spin_unlock(&mnt->mnt_root->d_lock);
    + seq_spin_unlock(&mnt->mnt_root->d_lock);

    list_for_each_entry_safe(mark, lmark, &free_list, m.free_m_list) {
    fsnotify_destroy_mark(mark);
    @@ -66,7 +66,7 @@ static void fsnotify_recalc_vfsmount_mas
    struct hlist_node *pos;
    __u32 new_mask = 0;

    - assert_spin_locked(&mnt->mnt_root->d_lock);
    + assert_seq_spin_locked(&mnt->mnt_root->d_lock);

    hlist_for_each_entry(mark, pos, &m->mnt_fsnotify_marks, m.m_list)
    new_mask |= mark->mask;
    @@ -79,9 +79,9 @@ static void fsnotify_recalc_vfsmount_mas
    */
    void fsnotify_recalc_vfsmount_mask(struct vfsmount *mnt)
    {
    - spin_lock(&mnt->mnt_root->d_lock);
    + seq_spin_lock(&mnt->mnt_root->d_lock);
    fsnotify_recalc_vfsmount_mask_locked(mnt);
    - spin_unlock(&mnt->mnt_root->d_lock);
    + seq_spin_unlock(&mnt->mnt_root->d_lock);
    }

    void fsnotify_destroy_vfsmount_mark(struct fsnotify_mark *mark)
    @@ -91,14 +91,14 @@ void fsnotify_destroy_vfsmount_mark(stru
    assert_spin_locked(&mark->lock);
    assert_spin_locked(&mark->group->mark_lock);

    - spin_lock(&mnt->mnt_root->d_lock);
    + seq_spin_lock(&mnt->mnt_root->d_lock);

    hlist_del_init_rcu(&mark->m.m_list);
    mark->m.mnt = NULL;

    fsnotify_recalc_vfsmount_mask_locked(mnt);

    - spin_unlock(&mnt->mnt_root->d_lock);
    + seq_spin_unlock(&mnt->mnt_root->d_lock);
    }

    static struct fsnotify_mark *fsnotify_find_vfsmount_mark_locked(struct fsnotify_group *group,
    @@ -108,7 +108,7 @@ static struct fsnotify_mark *fsnotify_fi
    struct fsnotify_mark *mark;
    struct hlist_node *pos;

    - assert_spin_locked(&mnt->mnt_root->d_lock);
    + assert_seq_spin_locked(&mnt->mnt_root->d_lock);

    hlist_for_each_entry(mark, pos, &m->mnt_fsnotify_marks, m.m_list) {
    if (mark->group == group) {
    @@ -128,9 +128,9 @@ struct fsnotify_mark *fsnotify_find_vfsm
    {
    struct fsnotify_mark *mark;

    - spin_lock(&mnt->mnt_root->d_lock);
    + seq_spin_lock(&mnt->mnt_root->d_lock);
    mark = fsnotify_find_vfsmount_mark_locked(group, mnt);
    - spin_unlock(&mnt->mnt_root->d_lock);
    + seq_spin_unlock(&mnt->mnt_root->d_lock);

    return mark;
    }
    @@ -154,7 +154,7 @@ int fsnotify_add_vfsmount_mark(struct fs
    assert_spin_locked(&mark->lock);
    assert_spin_locked(&group->mark_lock);

    - spin_lock(&mnt->mnt_root->d_lock);
    + seq_spin_lock(&mnt->mnt_root->d_lock);

    mark->m.mnt = mnt;

    @@ -189,7 +189,7 @@ int fsnotify_add_vfsmount_mark(struct fs
    hlist_add_after_rcu(last, &mark->m.m_list);
    out:
    fsnotify_recalc_vfsmount_mask_locked(mnt);
    - spin_unlock(&mnt->mnt_root->d_lock);
    + seq_spin_unlock(&mnt->mnt_root->d_lock);

    return ret;
    }
    Index: tip/fs/ocfs2/dcache.c
    ===================================================================
    --- tip.orig/fs/ocfs2/dcache.c
    +++ tip/fs/ocfs2/dcache.c
    @@ -177,16 +177,16 @@ struct dentry *ocfs2_find_local_alias(st
    list_for_each(p, &inode->i_dentry) {
    dentry = list_entry(p, struct dentry, d_alias);

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    if (ocfs2_match_dentry(dentry, parent_blkno, skip_unhashed)) {
    trace_ocfs2_find_local_alias(dentry->d_name.len,
    dentry->d_name.name);

    dget_dlock(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    break;
    }
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);

    dentry = NULL;
    }
    Index: tip/fs/ocfs2/export.c
    ===================================================================
    --- tip.orig/fs/ocfs2/export.c
    +++ tip/fs/ocfs2/export.c
    @@ -214,7 +214,7 @@ static int ocfs2_encode_fh(struct dentry
    if (connectable && !S_ISDIR(inode->i_mode)) {
    struct inode *parent;

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);

    parent = dentry->d_parent->d_inode;
    blkno = OCFS2_I(parent)->ip_blkno;
    @@ -224,7 +224,7 @@ static int ocfs2_encode_fh(struct dentry
    fh[4] = cpu_to_le32((u32)(blkno & 0xffffffff));
    fh[5] = cpu_to_le32(generation);

    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);

    len = 6;
    type = 2;
    Index: tip/fs/reiserfs/inode.c
    ===================================================================
    --- tip.orig/fs/reiserfs/inode.c
    +++ tip/fs/reiserfs/inode.c
    @@ -1614,7 +1614,7 @@ int reiserfs_encode_fh(struct dentry *de
    if (maxlen < 5 || !need_parent)
    return 3;

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    inode = dentry->d_parent->d_inode;
    data[3] = inode->i_ino;
    data[4] = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
    @@ -1623,7 +1623,7 @@ int reiserfs_encode_fh(struct dentry *de
    data[5] = inode->i_generation;
    *lenp = 6;
    }
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    return *lenp;
    }

    Index: tip/fs/udf/namei.c
    ===================================================================
    --- tip.orig/fs/udf/namei.c
    +++ tip/fs/udf/namei.c
    @@ -1296,13 +1296,13 @@ static int udf_encode_fh(struct dentry *
    fid->udf.generation = inode->i_generation;

    if (connectable && !S_ISDIR(inode->i_mode)) {
    - spin_lock(&de->d_lock);
    + seq_spin_lock(&de->d_lock);
    inode = de->d_parent->d_inode;
    location = UDF_I(inode)->i_location;
    fid->udf.parent_block = location.logicalBlockNum;
    fid->udf.parent_partref = location.partitionReferenceNum;
    fid->udf.parent_generation = inode->i_generation;
    - spin_unlock(&de->d_lock);
    + seq_spin_unlock(&de->d_lock);
    *lenp = 5;
    type = FILEID_UDF_WITH_PARENT;
    }
    Index: tip/fs/xfs/xfs_export.c
    ===================================================================
    --- tip.orig/fs/xfs/xfs_export.c
    +++ tip/fs/xfs/xfs_export.c
    @@ -97,20 +97,20 @@ xfs_fs_encode_fh(

    switch (fileid_type) {
    case FILEID_INO32_GEN_PARENT:
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    fid->i32.parent_ino = XFS_I(dentry->d_parent->d_inode)->i_ino;
    fid->i32.parent_gen = dentry->d_parent->d_inode->i_generation;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    /*FALLTHRU*/
    case FILEID_INO32_GEN:
    fid->i32.ino = XFS_I(inode)->i_ino;
    fid->i32.gen = inode->i_generation;
    break;
    case FILEID_INO32_GEN_PARENT | XFS_FILEID_TYPE_64FLAG:
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    fid64->parent_ino = XFS_I(dentry->d_parent->d_inode)->i_ino;
    fid64->parent_gen = dentry->d_parent->d_inode->i_generation;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    /*FALLTHRU*/
    case FILEID_INO32_GEN | XFS_FILEID_TYPE_64FLAG:
    fid64->ino = XFS_I(inode)->i_ino;
    Index: tip/include/linux/dcache.h
    ===================================================================
    --- tip.orig/include/linux/dcache.h
    +++ tip/include/linux/dcache.h
    @@ -88,7 +88,8 @@ extern unsigned int full_name_hash(const
    struct dentry {
    /* RCU lookup touched fields */
    unsigned int d_flags; /* protected by d_lock */
    - seqcount_t d_seq; /* per dentry seqlock */
    + unsigned int d_count; /* (Ref lookup) protected by d_lock */
    + seqlock_t d_lock; /* per dentry seqlock */
    struct hlist_bl_node d_hash; /* lookup hash list */
    struct dentry *d_parent; /* parent directory */
    struct qstr d_name;
    @@ -97,8 +98,6 @@ struct dentry {
    unsigned char d_iname[DNAME_INLINE_LEN]; /* small names */

    /* Ref lookup also touches following */
    - unsigned int d_count; /* protected by d_lock */
    - spinlock_t d_lock; /* per dentry lock */
    const struct dentry_operations *d_op;
    struct super_block *d_sb; /* The root of the dentry tree */
    unsigned long d_time; /* used by d_revalidate */
    @@ -298,8 +297,8 @@ static inline int __d_rcu_to_refcount(st
    {
    int ret = 0;

    - assert_spin_locked(&dentry->d_lock);
    - if (!read_seqcount_retry(&dentry->d_seq, seq)) {
    + assert_seq_spin_locked(&dentry->d_lock);
    + if (!read_seqretry(&dentry->d_lock, seq)) {
    ret = 1;
    dentry->d_count++;
    }
    @@ -342,9 +341,9 @@ static inline struct dentry *dget_dlock(
    static inline struct dentry *dget(struct dentry *dentry)
    {
    if (dentry) {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    dget_dlock(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }
    return dentry;
    }
    @@ -375,9 +374,9 @@ static inline int cant_mount(struct dent

    static inline void dont_mount(struct dentry *dentry)
    {
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    dentry->d_flags |= DCACHE_CANT_MOUNT;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }

    extern void dput(struct dentry *);
    Index: tip/include/linux/fs.h
    ===================================================================
    --- tip.orig/include/linux/fs.h
    +++ tip/include/linux/fs.h
    @@ -2569,9 +2569,9 @@ static inline ino_t parent_ino(struct de
    * Don't strictly need d_lock here? If the parent ino could change
    * then surely we'd have a deeper race in the caller?
    */
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    res = dentry->d_parent->d_inode->i_ino;
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    return res;
    }

    Index: tip/include/linux/fsnotify_backend.h
    ===================================================================
    --- tip.orig/include/linux/fsnotify_backend.h
    +++ tip/include/linux/fsnotify_backend.h
    @@ -329,7 +329,7 @@ static inline void __fsnotify_update_dca
    {
    struct dentry *parent;

    - assert_spin_locked(&dentry->d_lock);
    + assert_seq_spin_locked(&dentry->d_lock);

    /*
    * Serialisation of setting PARENT_WATCHED on the dentries is provided
    @@ -353,9 +353,9 @@ static inline void __fsnotify_d_instanti
    if (!inode)
    return;

    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    __fsnotify_update_dcache_flags(dentry);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }

    /* called from fsnotify listeners, such as fanotify or dnotify */
    Index: tip/kernel/cgroup.c
    ===================================================================
    --- tip.orig/kernel/cgroup.c
    +++ tip/kernel/cgroup.c
    @@ -887,29 +887,29 @@ static void cgroup_clear_directory(struc
    struct list_head *node;

    BUG_ON(!mutex_is_locked(&dentry->d_inode->i_mutex));
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    node = dentry->d_subdirs.next;
    while (node != &dentry->d_subdirs) {
    struct dentry *d = list_entry(node, struct dentry, d_u.d_child);

    - spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED);
    + seq_spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED);
    list_del_init(node);
    if (d->d_inode) {
    /* This should never be called on a cgroup
    * directory with child cgroups */
    BUG_ON(d->d_inode->i_mode & S_IFDIR);
    dget_dlock(d);
    - spin_unlock(&d->d_lock);
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&d->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    d_delete(d);
    simple_unlink(dentry->d_inode, d);
    dput(d);
    - spin_lock(&dentry->d_lock);
    + seq_spin_lock(&dentry->d_lock);
    } else
    - spin_unlock(&d->d_lock);
    + seq_spin_unlock(&d->d_lock);
    node = dentry->d_subdirs.next;
    }
    - spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    }

    /*
    @@ -922,11 +922,11 @@ static void cgroup_d_remove_dir(struct d
    cgroup_clear_directory(dentry);

    parent = dentry->d_parent;
    - spin_lock(&parent->d_lock);
    - spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
    + seq_spin_lock(&parent->d_lock);
    + seq_spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
    list_del_init(&dentry->d_u.d_child);
    - spin_unlock(&dentry->d_lock);
    - spin_unlock(&parent->d_lock);
    + seq_spin_unlock(&dentry->d_lock);
    + seq_spin_unlock(&parent->d_lock);
    remove_dir(dentry);
    }

    Index: tip/net/sunrpc/rpc_pipe.c
    ===================================================================
    --- tip.orig/net/sunrpc/rpc_pipe.c
    +++ tip/net/sunrpc/rpc_pipe.c
    @@ -396,14 +396,14 @@ rpc_info_open(struct inode *inode, struc
    if (!ret) {
    struct seq_file *m = file->private_data;

    - spin_lock(&file->f_path.dentry->d_lock);
    + seq_spin_lock(&file->f_path.dentry->d_lock);
    if (!d_unhashed(file->f_path.dentry))
    clnt = RPC_I(inode)->private;
    if (clnt != NULL && atomic_inc_not_zero(&clnt->cl_count)) {
    - spin_unlock(&file->f_path.dentry->d_lock);
    + seq_spin_unlock(&file->f_path.dentry->d_lock);
    m->private = clnt;
    } else {
    - spin_unlock(&file->f_path.dentry->d_lock);
    + seq_spin_unlock(&file->f_path.dentry->d_lock);
    single_release(inode, file);
    ret = -EINVAL;
    }
    Index: tip/security/selinux/selinuxfs.c
    ===================================================================
    --- tip.orig/security/selinux/selinuxfs.c
    +++ tip/security/selinux/selinuxfs.c
    @@ -1188,28 +1188,28 @@ static void sel_remove_entries(struct de
    {
    struct list_head *node;

    - spin_lock(&de->d_lock);
    + seq_spin_lock(&de->d_lock);
    node = de->d_subdirs.next;
    while (node != &de->d_subdirs) {
    struct dentry *d = list_entry(node, struct dentry, d_u.d_child);

    - spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED);
    + seq_spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED);
    list_del_init(node);

    if (d->d_inode) {
    dget_dlock(d);
    - spin_unlock(&de->d_lock);
    - spin_unlock(&d->d_lock);
    + seq_spin_unlock(&de->d_lock);
    + seq_spin_unlock(&d->d_lock);
    d_delete(d);
    simple_unlink(de->d_inode, d);
    dput(d);
    - spin_lock(&de->d_lock);
    + seq_spin_lock(&de->d_lock);
    } else
    - spin_unlock(&d->d_lock);
    + seq_spin_unlock(&d->d_lock);
    node = de->d_subdirs.next;
    }

    - spin_unlock(&de->d_lock);
    + seq_spin_unlock(&de->d_lock);
    }

    #define BOOL_DIR_NAME "booleans"



    \
     
     \ /
      Last update: 2012-03-15 12:47    [W:0.221 / U:118.420 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site