new helper: set_default_d_op()

... to be used instead of manually assigning to ->s_d_op.
All in-tree filesystem converted (and field itself is renamed,
so any out-of-tree ones in need of conversion will be caught
by compiler).

Reviewed-by: Christian Brauner <brauner@kernel.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

diff --git a/Documentation/filesystems/porting.rst b/Documentation/filesystems/porting.rst
index 3616d7161dabd4cc1b8f447934c6e056e7e77a83..b16139e9194220cabcea3c9b7800aa8cfaa3b2ab 100644 (file)
--- a/Documentation/filesystems/porting.rst
+++ b/Documentation/filesystems/porting.rst
@@ -1249,3 +1249,10 @@ Using try_lookup_noperm() will require linux/namei.h to be included.
 
 Calling conventions for ->d_automount() have changed; we should *not* grab
 an extra reference to new mount - it should be returned with refcount 1.
+
+---
+
+**mandatory**
+
+If your filesystem sets the default dentry_operations, use set_default_d_op()
+rather than manually setting sb->s_d_op.

diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c
index 489db161abc9831b23148396bdf49ebf34525542..5c3dc3efb90930e0fc05ee2b95d4fe8942025057 100644 (file)
--- a/fs/9p/vfs_super.c
+++ b/fs/9p/vfs_super.c
@@ -135,9 +135,9 @@ static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
                goto release_sb;
 
        if (v9ses->cache & (CACHE_META|CACHE_LOOSE))
-               sb->s_d_op = &v9fs_cached_dentry_operations;
+               set_default_d_op(sb, &v9fs_cached_dentry_operations);
        else
-               sb->s_d_op = &v9fs_dentry_operations;
+               set_default_d_op(sb, &v9fs_dentry_operations);
 
        inode = v9fs_get_new_inode_from_fid(v9ses, fid, sb);
        if (IS_ERR(inode)) {

diff --git a/fs/adfs/super.c b/fs/adfs/super.c
index 017c48a80203d771ec7c1f66772ea5fac49ab505..fdccdbbfc213062b3cd25c71f2117e96a28c3949 100644 (file)
--- a/fs/adfs/super.c
+++ b/fs/adfs/super.c
@@ -397,7 +397,7 @@ static int adfs_fill_super(struct super_block *sb, struct fs_context *fc)
        if (asb->s_ftsuffix)
                asb->s_namelen += 4;
 
-       sb->s_d_op = &adfs_dentry_operations;
+       set_default_d_op(sb, &adfs_dentry_operations);
        root = adfs_iget(sb, &root_obj);
        sb->s_root = d_make_root(root);
        if (!sb->s_root) {

diff --git a/fs/affs/super.c b/fs/affs/super.c
index 2fa40337776da3f4de02adefb3ad820e4a15000c..44f8aa883100e129f8279c0ed1be4a3842c50c89 100644 (file)
--- a/fs/affs/super.c
+++ b/fs/affs/super.c
@@ -500,9 +500,9 @@ got_root:
                return PTR_ERR(root_inode);
 
        if (affs_test_opt(AFFS_SB(sb)->s_flags, SF_INTL))
-               sb->s_d_op = &affs_intl_dentry_operations;
+               set_default_d_op(sb, &affs_intl_dentry_operations);
        else
-               sb->s_d_op = &affs_dentry_operations;
+               set_default_d_op(sb, &affs_dentry_operations);
 
        sb->s_root = d_make_root(root_inode);
        if (!sb->s_root) {

diff --git a/fs/afs/super.c b/fs/afs/super.c
index 25b306db69926e164c2ed76262d46a77729003af..da407f2d6f0d1dff8892dfc0a2d991a5e5795a07 100644 (file)
--- a/fs/afs/super.c
+++ b/fs/afs/super.c
@@ -483,9 +483,9 @@ static int afs_fill_super(struct super_block *sb, struct afs_fs_context *ctx)
                goto error;
 
        if (as->dyn_root) {
-               sb->s_d_op = &afs_dynroot_dentry_operations;
+               set_default_d_op(sb, &afs_dynroot_dentry_operations);
        } else {
-               sb->s_d_op = &afs_fs_dentry_operations;
+               set_default_d_op(sb, &afs_fs_dentry_operations);
                rcu_assign_pointer(as->volume->sb, sb);
        }
 

diff --git a/fs/autofs/inode.c b/fs/autofs/inode.c
index ee2edccaef70c7159adb9a2cdf3486f93e57192d..f5c16ffba01340e95ea843fc15dcc957ef337d5f 100644 (file)
--- a/fs/autofs/inode.c
+++ b/fs/autofs/inode.c
@@ -311,7 +311,7 @@ static int autofs_fill_super(struct super_block *s, struct fs_context *fc)
        s->s_blocksize_bits = 10;
        s->s_magic = AUTOFS_SUPER_MAGIC;
        s->s_op = &autofs_sops;
-       s->s_d_op = &autofs_dentry_operations;
+       set_default_d_op(s, &autofs_dentry_operations);
        s->s_time_gran = 1;
 
        /*

diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index a0c65adce1abd23c02cdb46fa95920bfa14dd091..ad75d9f8f40401516f9efc2cc989f82adebcccae 100644 (file)
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -950,7 +950,7 @@ static int btrfs_fill_super(struct super_block *sb,
        sb->s_maxbytes = MAX_LFS_FILESIZE;
        sb->s_magic = BTRFS_SUPER_MAGIC;
        sb->s_op = &btrfs_super_ops;
-       sb->s_d_op = &btrfs_dentry_operations;
+       set_default_d_op(sb, &btrfs_dentry_operations);
        sb->s_export_op = &btrfs_export_ops;
 #ifdef CONFIG_FS_VERITY
        sb->s_vop = &btrfs_verityops;

diff --git a/fs/ceph/super.c b/fs/ceph/super.c
index 2b8438d8a32412126d70690fb5d1457bf5e810da..c3eb651862c555254fb3b4818db4c3f7355bfbb4 100644 (file)
--- a/fs/ceph/super.c
+++ b/fs/ceph/super.c
@@ -1219,7 +1219,7 @@ static int ceph_set_super(struct super_block *s, struct fs_context *fc)
        fsc->max_file_size = 1ULL << 40; /* temp value until we get mdsmap */
 
        s->s_op = &ceph_super_ops;
-       s->s_d_op = &ceph_dentry_ops;
+       set_default_d_op(s, &ceph_dentry_ops);
        s->s_export_op = &ceph_export_ops;
 
        s->s_time_gran = 1;

diff --git a/fs/coda/inode.c b/fs/coda/inode.c
index 6896fce122e1865f15455abeac33c904766c2984..08450d00601666342dfc847765a4d0f920b67159 100644 (file)
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -230,7 +230,7 @@ static int coda_fill_super(struct super_block *sb, struct fs_context *fc)
        sb->s_blocksize_bits = 12;
        sb->s_magic = CODA_SUPER_MAGIC;
        sb->s_op = &coda_super_operations;
-       sb->s_d_op = &coda_dentry_operations;
+       set_default_d_op(sb, &coda_dentry_operations);
        sb->s_time_gran = 1;
        sb->s_time_min = S64_MIN;
        sb->s_time_max = S64_MAX;

diff --git a/fs/configfs/mount.c b/fs/configfs/mount.c
index c2d820063ec49a5def2050678e65c7c8ad7279fd..20412eaca972e093604b639372515c86b103d9c1 100644 (file)
--- a/fs/configfs/mount.c
+++ b/fs/configfs/mount.c
@@ -92,7 +92,7 @@ static int configfs_fill_super(struct super_block *sb, struct fs_context *fc)
        configfs_root_group.cg_item.ci_dentry = root;
        root->d_fsdata = &configfs_root;
        sb->s_root = root;
-       sb->s_d_op = &configfs_dentry_ops; /* the rest get that */
+       set_default_d_op(sb, &configfs_dentry_ops); /* the rest get that */
        return 0;
 }
 

diff --git a/fs/dcache.c b/fs/dcache.c
index bf550d438e40ce51067c7389cf2e08a32a8ad03a..2ed875558ccc9b058986fe04ae55450a22e97f85 100644 (file)
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -1738,7 +1738,7 @@ static struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
        INIT_HLIST_HEAD(&dentry->d_children);
        INIT_HLIST_NODE(&dentry->d_u.d_alias);
        INIT_HLIST_NODE(&dentry->d_sib);
-       d_set_d_op(dentry, dentry->d_sb->s_d_op);
+       d_set_d_op(dentry, dentry->d_sb->__s_d_op);
 
        if (dentry->d_op && dentry->d_op->d_init) {
                err = dentry->d_op->d_init(dentry);
@@ -1821,7 +1821,7 @@ struct dentry *d_alloc_pseudo(struct super_block *sb, const struct qstr *name)
        struct dentry *dentry = __d_alloc(sb, name);
        if (likely(dentry)) {
                dentry->d_flags |= DCACHE_NORCU;
-               if (!sb->s_d_op)
+               if (!dentry->d_op)
                        d_set_d_op(dentry, &anon_ops);
        }
        return dentry;
@@ -1867,6 +1867,12 @@ void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
 }
 EXPORT_SYMBOL(d_set_d_op);
 
+void set_default_d_op(struct super_block *s, const struct dentry_operations *ops)
+{
+       s->__s_d_op = ops;
+}
+EXPORT_SYMBOL(set_default_d_op);
+
 static unsigned d_flags_for_inode(struct inode *inode)
 {
        unsigned add_flags = DCACHE_REGULAR_TYPE;

diff --git a/fs/debugfs/inode.c b/fs/debugfs/inode.c
index 30c4944e18622dcccee5c4dbc845ddcaecae5012..29c5ec3823427680c3ac07339e8ca7aec979a7f8 100644 (file)
--- a/fs/debugfs/inode.c
+++ b/fs/debugfs/inode.c
@@ -273,7 +273,7 @@ static int debugfs_fill_super(struct super_block *sb, struct fs_context *fc)
                return err;
 
        sb->s_op = &debugfs_super_operations;
-       sb->s_d_op = &debugfs_dops;
+       set_default_d_op(sb, &debugfs_dops);
 
        debugfs_apply_options(sb);
 

diff --git a/fs/devpts/inode.c b/fs/devpts/inode.c
index 9c20d78e41f6b438c9d63a429ab47250294804c4..fd17992ee2981b6473565089b15dac9c7b0b00c0 100644 (file)
--- a/fs/devpts/inode.c
+++ b/fs/devpts/inode.c
@@ -381,7 +381,7 @@ static int devpts_fill_super(struct super_block *s, struct fs_context *fc)
        s->s_blocksize_bits = 10;
        s->s_magic = DEVPTS_SUPER_MAGIC;
        s->s_op = &devpts_sops;
-       s->s_d_op = &simple_dentry_operations;
+       set_default_d_op(s, &simple_dentry_operations);
        s->s_time_gran = 1;
        fsi->sb = s;
 

diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c
index 8dd1d7189c3b2e7876b1fe86897a7773f6e8733f..45f9ca4465da82494b2052c5f43df216ac168d52 100644 (file)
--- a/fs/ecryptfs/main.c
+++ b/fs/ecryptfs/main.c
@@ -471,7 +471,7 @@ static int ecryptfs_get_tree(struct fs_context *fc)
        sbi = NULL;
        s->s_op = &ecryptfs_sops;
        s->s_xattr = ecryptfs_xattr_handlers;
-       s->s_d_op = &ecryptfs_dops;
+       set_default_d_op(s, &ecryptfs_dops);
 
        err = "Reading sb failed";
        rc = kern_path(fc->source, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &path);

diff --git a/fs/efivarfs/super.c b/fs/efivarfs/super.c
index c900d98bf49459cf37bfdf1374e6002a7544b521..f76d8dfa646bbb5b1417b90476bb4039f86c0fc5 100644 (file)
--- a/fs/efivarfs/super.c
+++ b/fs/efivarfs/super.c
@@ -350,7 +350,7 @@ static int efivarfs_fill_super(struct super_block *sb, struct fs_context *fc)
        sb->s_blocksize_bits    = PAGE_SHIFT;
        sb->s_magic             = EFIVARFS_MAGIC;
        sb->s_op                = &efivarfs_ops;
-       sb->s_d_op              = &efivarfs_d_ops;
+       set_default_d_op(sb, &efivarfs_d_ops);
        sb->s_time_gran         = 1;
 
        if (!efivar_supports_writes())

diff --git a/fs/exfat/super.c b/fs/exfat/super.c
index 7ed858937d45d2d4db8f842d5a4b08b0a3cdb70e..ea5c1334a2143496c80a02a04c12851f45888182 100644 (file)
--- a/fs/exfat/super.c
+++ b/fs/exfat/super.c
@@ -667,9 +667,9 @@ static int exfat_fill_super(struct super_block *sb, struct fs_context *fc)
        }
 
        if (sbi->options.utf8)
-               sb->s_d_op = &exfat_utf8_dentry_ops;
+               set_default_d_op(sb, &exfat_utf8_dentry_ops);
        else
-               sb->s_d_op = &exfat_dentry_ops;
+               set_default_d_op(sb, &exfat_dentry_ops);
 
        root_inode = new_inode(sb);
        if (!root_inode) {

diff --git a/fs/fat/namei_msdos.c b/fs/fat/namei_msdos.c
index 23e9b9371ec38ec54045d67ceb1d9056768126bb..0b920ee40a7f9fe3c57af5d939d3efedf001a3d9 100644 (file)
--- a/fs/fat/namei_msdos.c
+++ b/fs/fat/namei_msdos.c
@@ -646,7 +646,7 @@ static const struct inode_operations msdos_dir_inode_operations = {
 static void setup(struct super_block *sb)
 {
        MSDOS_SB(sb)->dir_ops = &msdos_dir_inode_operations;
-       sb->s_d_op = &msdos_dentry_operations;
+       set_default_d_op(sb, &msdos_dentry_operations);
        sb->s_flags |= SB_NOATIME;
 }
 

diff --git a/fs/fat/namei_vfat.c b/fs/fat/namei_vfat.c
index dd910edd2404db0be909ed702fd1292e1cc8deaf..5dbc4cbb8fce3d9b891cbc597f876c2c7b8d6aa0 100644 (file)
--- a/fs/fat/namei_vfat.c
+++ b/fs/fat/namei_vfat.c
@@ -1187,9 +1187,9 @@ static void setup(struct super_block *sb)
 {
        MSDOS_SB(sb)->dir_ops = &vfat_dir_inode_operations;
        if (MSDOS_SB(sb)->options.name_check != 's')
-               sb->s_d_op = &vfat_ci_dentry_ops;
+               set_default_d_op(sb, &vfat_ci_dentry_ops);
        else
-               sb->s_d_op = &vfat_dentry_ops;
+               set_default_d_op(sb, &vfat_dentry_ops);
 }
 
 static int vfat_fill_super(struct super_block *sb, struct fs_context *fc)

diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index eb61775085982aca5588b02e8d4bdc0b0f17fd4c..0dd65c0e9e299c8489986f652c76871fb76dab9d 100644 (file)
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -1715,7 +1715,7 @@ static int fuse_fill_super_submount(struct super_block *sb,
        fi = get_fuse_inode(root);
        fi->nlookup--;
 
-       sb->s_d_op = &fuse_dentry_operations;
+       set_default_d_op(sb, &fuse_dentry_operations);
        sb->s_root = d_make_root(root);
        if (!sb->s_root)
                return -ENOMEM;
@@ -1850,7 +1850,7 @@ int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx)
 
        err = -ENOMEM;
        root = fuse_get_root_inode(sb, ctx->rootmode);
-       sb->s_d_op = &fuse_dentry_operations;
+       set_default_d_op(sb, &fuse_dentry_operations);
        root_dentry = d_make_root(root);
        if (!root_dentry)
                goto err_dev_free;

diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index 85c491fcf1a3669d71d71837e2f38cbeca033f91..b568767dba46eac032f00bd49bb7b98fb7b56fc9 100644 (file)
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -1145,7 +1145,7 @@ static int gfs2_fill_super(struct super_block *sb, struct fs_context *fc)
        sb->s_magic = GFS2_MAGIC;
        sb->s_op = &gfs2_super_ops;
 
-       sb->s_d_op = &gfs2_dops;
+       set_default_d_op(sb, &gfs2_dops);
        sb->s_export_op = &gfs2_export_ops;
        sb->s_qcop = &gfs2_quotactl_ops;
        sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP;

diff --git a/fs/hfs/super.c b/fs/hfs/super.c
index fe09c2093a93d981c8d1341e14079b29c4d18137..388a318297ece2cff84fde9a0f5021a5b8c7b81a 100644 (file)
--- a/fs/hfs/super.c
+++ b/fs/hfs/super.c
@@ -365,7 +365,7 @@ static int hfs_fill_super(struct super_block *sb, struct fs_context *fc)
        if (!root_inode)
                goto bail_no_root;
 
-       sb->s_d_op = &hfs_dentry_operations;
+       set_default_d_op(sb, &hfs_dentry_operations);
        res = -ENOMEM;
        sb->s_root = d_make_root(root_inode);
        if (!sb->s_root)

diff --git a/fs/hfsplus/super.c b/fs/hfsplus/super.c
index 948b8aaee33e3aa5822f3bf8adc9f0764405a445..0caf7aa1c2490c155f6c770be9efe859ba0dda4e 100644 (file)
--- a/fs/hfsplus/super.c
+++ b/fs/hfsplus/super.c
@@ -508,7 +508,7 @@ static int hfsplus_fill_super(struct super_block *sb, struct fs_context *fc)
                goto out_put_alloc_file;
        }
 
-       sb->s_d_op = &hfsplus_dentry_operations;
+       set_default_d_op(sb, &hfsplus_dentry_operations);
        sb->s_root = d_make_root(root);
        if (!sb->s_root) {
                err = -ENOMEM;

diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index 702c41317589a82c2e03ff474b4303c6dd336f52..1c0f5038e19cf32ec0996e44e539f8a714e2dbc3 100644 (file)
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -933,7 +933,7 @@ static int hostfs_fill_super(struct super_block *sb, struct fs_context *fc)
        sb->s_blocksize_bits = 10;
        sb->s_magic = HOSTFS_SUPER_MAGIC;
        sb->s_op = &hostfs_sbops;
-       sb->s_d_op = &simple_dentry_operations;
+       set_default_d_op(sb, &simple_dentry_operations);
        sb->s_maxbytes = MAX_LFS_FILESIZE;
        err = super_setup_bdi(sb);
        if (err)

diff --git a/fs/hpfs/super.c b/fs/hpfs/super.c
index 27567920abe42143decd13d14f8bdbc671dc64f1..42b779b4d87f870bf44bcb0e13268c4411a5ed01 100644 (file)
--- a/fs/hpfs/super.c
+++ b/fs/hpfs/super.c
@@ -554,7 +554,7 @@ static int hpfs_fill_super(struct super_block *s, struct fs_context *fc)
        /* Fill superblock stuff */
        s->s_magic = HPFS_SUPER_MAGIC;
        s->s_op = &hpfs_sops;
-       s->s_d_op = &hpfs_dentry_operations;
+       set_default_d_op(s, &hpfs_dentry_operations);
        s->s_time_min =  local_to_gmt(s, 0);
        s->s_time_max =  local_to_gmt(s, U32_MAX);
 

diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c
index d5da9817df9b36a56482ff9279d463ed125e9da6..8624393c0d8c1c65ca23bd1f38b0ee891b40b5fb 100644 (file)
--- a/fs/isofs/inode.c
+++ b/fs/isofs/inode.c
@@ -939,7 +939,7 @@ root_found:
        sbi->s_check = opt->check;
 
        if (table)
-               s->s_d_op = &isofs_dentry_ops[table - 1];
+               set_default_d_op(s, &isofs_dentry_ops[table - 1]);
 
        /* get the root dentry */
        s->s_root = d_make_root(inode);

diff --git a/fs/jfs/super.c b/fs/jfs/super.c
index 10368c188c5eef0a2e15910b90e214aef697d3f9..3cfb86c5a36e8f0c46a2734a24fba6ffd36c7ad9 100644 (file)
--- a/fs/jfs/super.c
+++ b/fs/jfs/super.c
@@ -542,7 +542,7 @@ static int jfs_fill_super(struct super_block *sb, struct fs_context *fc)
        sb->s_magic = JFS_SUPER_MAGIC;
 
        if (sbi->mntflag & JFS_OS2)
-               sb->s_d_op = &jfs_ci_dentry_operations;
+               set_default_d_op(sb, &jfs_ci_dentry_operations);
 
        inode = jfs_iget(sb, ROOT_I);
        if (IS_ERR(inode)) {

diff --git a/fs/kernfs/mount.c b/fs/kernfs/mount.c
index c1719b5778a11b19b77ffa842317e8ad66e9a3ac..e384a69fbece7bbd1397f508927c062ef2fbac1c 100644 (file)
--- a/fs/kernfs/mount.c
+++ b/fs/kernfs/mount.c
@@ -318,7 +318,7 @@ static int kernfs_fill_super(struct super_block *sb, struct kernfs_fs_context *k
                return -ENOMEM;
        }
        sb->s_root = root;
-       sb->s_d_op = &kernfs_dops;
+       set_default_d_op(sb, &kernfs_dops);
        return 0;
 }
 

diff --git a/fs/libfs.c b/fs/libfs.c
index 9ea0ecc325a81c93a55e584824417789e8d1aea0..ab82de070310b0c5ae16ad3ca8852f804af60fa2 100644 (file)
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -75,7 +75,7 @@ struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, unsigned
 {
        if (dentry->d_name.len > NAME_MAX)
                return ERR_PTR(-ENAMETOOLONG);
-       if (!dentry->d_sb->s_d_op)
+       if (!dentry->d_op)
                d_set_d_op(dentry, &simple_dentry_operations);
 
        if (IS_ENABLED(CONFIG_UNICODE) && IS_CASEFOLDED(dir))
@@ -684,7 +684,7 @@ static int pseudo_fs_fill_super(struct super_block *s, struct fs_context *fc)
        s->s_root = d_make_root(root);
        if (!s->s_root)
                return -ENOMEM;
-       s->s_d_op = ctx->dops;
+       set_default_d_op(s, ctx->dops);
        return 0;
 }
 
@@ -1950,22 +1950,22 @@ static const struct dentry_operations generic_encrypted_dentry_ops = {
  * @sb: superblock to be configured
  *
  * Filesystems supporting casefolding and/or fscrypt can call this
- * helper at mount-time to configure sb->s_d_op to best set of dentry
- * operations required for the enabled features. The helper must be
- * called after these have been configured, but before the root dentry
- * is created.
+ * helper at mount-time to configure default dentry_operations to the
+ * best set of dentry operations required for the enabled features.
+ * The helper must be called after these have been configured, but
+ * before the root dentry is created.
  */
 void generic_set_sb_d_ops(struct super_block *sb)
 {
 #if IS_ENABLED(CONFIG_UNICODE)
        if (sb->s_encoding) {
-               sb->s_d_op = &generic_ci_dentry_ops;
+               set_default_d_op(sb, &generic_ci_dentry_ops);
                return;
        }
 #endif
 #ifdef CONFIG_FS_ENCRYPTION
        if (sb->s_cop) {
-               sb->s_d_op = &generic_encrypted_dentry_ops;
+               set_default_d_op(sb, &generic_encrypted_dentry_ops);
                return;
        }
 #endif

diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index 91b5503b6f74d75950ab85bd0cb907bba2be94f8..72dee6f3050e67820bb35dbf00074bcbcd27bd7a 100644 (file)
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -1183,7 +1183,7 @@ static int nfs_set_super(struct super_block *s, struct fs_context *fc)
        struct nfs_server *server = fc->s_fs_info;
        int ret;
 
-       s->s_d_op = server->nfs_client->rpc_ops->dentry_ops;
+       set_default_d_op(s, server->nfs_client->rpc_ops->dentry_ops);
        ret = set_anon_super(s, server);
        if (ret == 0)
                server->s_dev = s->s_dev;

diff --git a/fs/ntfs3/super.c b/fs/ntfs3/super.c
index 920a1ab47b631dc0a80366769d875da1af6cfb9e..ddff94c091b8c69b24fb9a385e0e88673c9f8617 100644 (file)
--- a/fs/ntfs3/super.c
+++ b/fs/ntfs3/super.c
@@ -1223,7 +1223,8 @@ static int ntfs_fill_super(struct super_block *sb, struct fs_context *fc)
        sb->s_export_op = &ntfs_export_ops;
        sb->s_time_gran = NTFS_TIME_GRAN; // 100 nsec
        sb->s_xattr = ntfs_xattr_handlers;
-       sb->s_d_op = options->nocase ? &ntfs_dentry_ops : NULL;
+       if (options->nocase)
+               set_default_d_op(sb, &ntfs_dentry_ops);
 
        options->nls = ntfs_load_nls(options->nls_name);
        if (IS_ERR(options->nls)) {

diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c
index 3d2533950bae20900f218dc3d25f1b2acb90687a..53daa448240638f37ce8c3aceb053be5aa6bf545 100644 (file)
--- a/fs/ocfs2/super.c
+++ b/fs/ocfs2/super.c
@@ -1962,7 +1962,7 @@ static int ocfs2_initialize_super(struct super_block *sb,
 
        sb->s_fs_info = osb;
        sb->s_op = &ocfs2_sops;
-       sb->s_d_op = &ocfs2_dentry_ops;
+       set_default_d_op(sb, &ocfs2_dentry_ops);
        sb->s_export_op = &ocfs2_export_ops;
        sb->s_qcop = &dquot_quotactl_sysfile_ops;
        sb->dq_op = &ocfs2_quota_operations;

diff --git a/fs/orangefs/super.c b/fs/orangefs/super.c
index 64ca9498f5505353665384c7671ab2f47a32b406..f3da840758e74224e08a6c81c5e085673f955e1f 100644 (file)
--- a/fs/orangefs/super.c
+++ b/fs/orangefs/super.c
@@ -416,7 +416,7 @@ static int orangefs_fill_sb(struct super_block *sb,
        sb->s_xattr = orangefs_xattr_handlers;
        sb->s_magic = ORANGEFS_SUPER_MAGIC;
        sb->s_op = &orangefs_s_ops;
-       sb->s_d_op = &orangefs_dentry_operations;
+       set_default_d_op(sb, &orangefs_dentry_operations);
 
        sb->s_blocksize = PAGE_SIZE;
        sb->s_blocksize_bits = PAGE_SHIFT;

diff --git a/fs/overlayfs/super.c b/fs/overlayfs/super.c
index e19940d649ca3a9d9c89a3061359ddba0b62c622..efbf0b2915516897b4d0dd8ba0b2f037b35dfa35 100644 (file)
--- a/fs/overlayfs/super.c
+++ b/fs/overlayfs/super.c
@@ -1322,7 +1322,7 @@ int ovl_fill_super(struct super_block *sb, struct fs_context *fc)
        if (WARN_ON(fc->user_ns != current_user_ns()))
                goto out_err;
 
-       sb->s_d_op = &ovl_dentry_operations;
+       set_default_d_op(sb, &ovl_dentry_operations);
 
        err = -ENOMEM;
        if (!ofs->creator_cred)

diff --git a/fs/smb/client/cifsfs.c b/fs/smb/client/cifsfs.c
index 0a5266ecfd157141b27d029f47af8acd0325c0c7..d4ec73359922c8d4b66623411e95036c22cadb4a 100644 (file)
--- a/fs/smb/client/cifsfs.c
+++ b/fs/smb/client/cifsfs.c
@@ -260,9 +260,9 @@ cifs_read_super(struct super_block *sb)
        }
 
        if (tcon->nocase)
-               sb->s_d_op = &cifs_ci_dentry_ops;
+               set_default_d_op(sb, &cifs_ci_dentry_ops);
        else
-               sb->s_d_op = &cifs_dentry_ops;
+               set_default_d_op(sb, &cifs_dentry_ops);
 
        sb->s_root = d_make_root(inode);
        if (!sb->s_root) {

diff --git a/fs/tracefs/inode.c b/fs/tracefs/inode.c
index a3fd3cc591bd8884de4c05e6cd569331dc69df5b..c8ca61777323473b584a7364aa6d2ceda888d625 100644 (file)
--- a/fs/tracefs/inode.c
+++ b/fs/tracefs/inode.c
@@ -480,7 +480,7 @@ static int tracefs_fill_super(struct super_block *sb, struct fs_context *fc)
                return err;
 
        sb->s_op = &tracefs_super_operations;
-       sb->s_d_op = &tracefs_dentry_operations;
+       set_default_d_op(sb, &tracefs_dentry_operations);
 
        return 0;
 }

diff --git a/fs/vboxsf/super.c b/fs/vboxsf/super.c
index 0bc96ab6580b36c8a7708b19abee36c028e7497d..241647b060ee6784b3e9ba73e1bbc2bad93a069f 100644 (file)
--- a/fs/vboxsf/super.c
+++ b/fs/vboxsf/super.c
@@ -189,7 +189,7 @@ static int vboxsf_fill_super(struct super_block *sb, struct fs_context *fc)
        sb->s_blocksize = 1024;
        sb->s_maxbytes = MAX_LFS_FILESIZE;
        sb->s_op = &vboxsf_super_ops;
-       sb->s_d_op = &vboxsf_dentry_ops;
+       set_default_d_op(sb, &vboxsf_dentry_ops);
 
        iroot = iget_locked(sb, 0);
        if (!iroot) {

diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 1993e670455268a615c15c0b159c56de89e76db1..be7ae058fa90a1fd95134f4702fad835487fbe68 100644 (file)
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -607,4 +607,6 @@ static inline struct dentry *d_next_sibling(const struct dentry *dentry)
        return hlist_entry_safe(dentry->d_sib.next, struct dentry, d_sib);
 }
 
+void set_default_d_op(struct super_block *, const struct dentry_operations *);
+
 #endif /* __LINUX_DCACHE_H */

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 96c7925a655199ebdfefafa587ea5ae3e3665867..7cd8eaab4d4e2e713ecb087e5118c76f6f255321 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1413,7 +1413,7 @@ struct super_block {
         */
        const char *s_subtype;
 
-       const struct dentry_operations *s_d_op; /* default d_op for dentries */
+       const struct dentry_operations *__s_d_op; /* default d_op for dentries */
 
        struct shrinker *s_shrink;      /* per-sb shrinker handle */
 

diff --git a/mm/shmem.c b/mm/shmem.c
index 0c5fb4ffa03aadf8397002f0a55f2e96b8eec5c7..3583508800fc06deaac1075049fc4d7e8c69e084 100644 (file)
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -5028,7 +5028,7 @@ static int shmem_fill_super(struct super_block *sb, struct fs_context *fc)
 
        if (ctx->encoding) {
                sb->s_encoding = ctx->encoding;
-               sb->s_d_op = &shmem_ci_dentry_ops;
+               set_default_d_op(sb, &shmem_ci_dentry_ops);
                if (ctx->strict_encoding)
                        sb->s_encoding_flags = SB_ENC_STRICT_MODE_FL;
        }

diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index 98f78cd559055b232d33981ccc54c9326df90db3..f4e880383f67706ec6d4210bdc87c560c138ea65 100644 (file)
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -1363,7 +1363,7 @@ rpc_fill_super(struct super_block *sb, struct fs_context *fc)
        sb->s_blocksize_bits = PAGE_SHIFT;
        sb->s_magic = RPCAUTH_GSSMAGIC;
        sb->s_op = &s_ops;
-       sb->s_d_op = &simple_dentry_operations;
+       set_default_d_op(sb, &simple_dentry_operations);
        sb->s_time_gran = 1;
 
        inode = rpc_get_inode(sb, S_IFDIR | 0555);