fs/nfs/nfs4super.c

   1 /*
   2  * Copyright (c) 2012 Bryan Schumaker <bjschuma@netapp.com>
   3  */
   4 #include <linux/init.h>
   5 #include <linux/module.h>
   6 #include <linux/nfs_idmap.h>
   7 #include <linux/nfs4_mount.h>
   8 #include <linux/nfs_fs.h>
   9 #include "delegation.h"
  10 #include "internal.h"
  11 #include "nfs4_fs.h"
  12 #include "pnfs.h"
  13 #include "nfs.h"
  14
  15 #define NFSDBG_FACILITY         NFSDBG_VFS
  16
  17 static int nfs4_write_inode(struct inode *inode, struct writeback_control *wbc);
  18 static void nfs4_evict_inode(struct inode *inode);
  19 static struct dentry *nfs4_remote_mount(struct file_system_type *fs_type,
  20         int flags, const char *dev_name, void *raw_data);
  21 static struct dentry *nfs4_referral_mount(struct file_system_type *fs_type,
  22         int flags, const char *dev_name, void *raw_data);
  23 static struct dentry *nfs4_remote_referral_mount(struct file_system_type *fs_type,
  24         int flags, const char *dev_name, void *raw_data);
  25
  26 static struct file_system_type nfs4_fs_type = {
  27         .owner          = THIS_MODULE,
  28         .name           = "nfs4",
  29         .mount          = nfs_fs_mount,
  30         .kill_sb        = nfs_kill_super,
  31         .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
  32 };
  33
  34 static struct file_system_type nfs4_remote_fs_type = {
  35         .owner          = THIS_MODULE,
  36         .name           = "nfs4",
  37         .mount          = nfs4_remote_mount,
  38         .kill_sb        = nfs_kill_super,
  39         .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
  40 };
  41
  42 static struct file_system_type nfs4_remote_referral_fs_type = {
  43         .owner          = THIS_MODULE,
  44         .name           = "nfs4",
  45         .mount          = nfs4_remote_referral_mount,
  46         .kill_sb        = nfs_kill_super,
  47         .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
  48 };
  49
  50 struct file_system_type nfs4_referral_fs_type = {
  51         .owner          = THIS_MODULE,
  52         .name           = "nfs4",
  53         .mount          = nfs4_referral_mount,
  54         .kill_sb        = nfs_kill_super,
  55         .fs_flags       = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
  56 };
  57
  58 static const struct super_operations nfs4_sops = {
  59         .alloc_inode    = nfs_alloc_inode,
  60         .destroy_inode  = nfs_destroy_inode,
  61         .write_inode    = nfs4_write_inode,
  62         .put_super      = nfs_put_super,
  63         .statfs         = nfs_statfs,
  64         .evict_inode    = nfs4_evict_inode,
  65         .umount_begin   = nfs_umount_begin,
  66         .show_options   = nfs_show_options,
  67         .show_devname   = nfs_show_devname,
  68         .show_path      = nfs_show_path,
  69         .show_stats     = nfs_show_stats,
  70         .remount_fs     = nfs_remount,
  71 };
  72
  73 struct nfs_subversion nfs_v4 = {
  74         .owner = THIS_MODULE,
  75         .nfs_fs   = &nfs4_fs_type,
  76         .rpc_vers = &nfs_version4,
  77         .rpc_ops  = &nfs_v4_clientops,
  78         .sops     = &nfs4_sops,
  79         .xattr    = nfs4_xattr_handlers,
  80 };
  81
  82 static int nfs4_write_inode(struct inode *inode, struct writeback_control *wbc)
  83 {
  84         int ret = nfs_write_inode(inode, wbc);
  85
  86         if (ret >= 0 && test_bit(NFS_INO_LAYOUTCOMMIT, &NFS_I(inode)->flags)) {
  87                 int status;
  88                 bool sync = true;
  89
  90                 if (wbc->sync_mode == WB_SYNC_NONE)
  91                         sync = false;
  92
  93                 status = pnfs_layoutcommit_inode(inode, sync);
  94                 if (status < 0)
  95                         return status;
  96         }
  97         return ret;
  98 }
  99
 100 /*
 101  * Clean out any remaining NFSv4 state that might be left over due
 102  * to open() calls that passed nfs_atomic_lookup, but failed to call
 103  * nfs_open().
 104  */
 105 static void nfs4_evict_inode(struct inode *inode)
 106 {
 107         truncate_inode_pages(&inode->i_data, 0);
 108         clear_inode(inode);
 109         pnfs_return_layout(inode);
 110         pnfs_destroy_layout(NFS_I(inode));
 111         /* If we are holding a delegation, return it! */
 112         nfs_inode_return_delegation_noreclaim(inode);
 113         /* First call standard NFS clear_inode() code */
 114         nfs_clear_inode(inode);
 115 }
 116
 117 /*
 118  * Get the superblock for the NFS4 root partition
 119  */
 120 static struct dentry *
 121 nfs4_remote_mount(struct file_system_type *fs_type, int flags,
 122                   const char *dev_name, void *info)
 123 {
 124         struct nfs_mount_info *mount_info = info;
 125         struct nfs_server *server;
 126         struct dentry *mntroot = ERR_PTR(-ENOMEM);
 127
 128         mount_info->set_security = nfs_set_sb_security;
 129
 130         /* Get a volume representation */
 131         server = nfs4_create_server(mount_info, &nfs_v4);
 132         if (IS_ERR(server)) {
 133                 mntroot = ERR_CAST(server);
 134                 goto out;
 135         }
 136
 137         mntroot = nfs_fs_mount_common(server, flags, dev_name, mount_info, &nfs_v4);
 138
 139 out:
 140         return mntroot;
 141 }
 142
 143 static struct vfsmount *nfs_do_root_mount(struct file_system_type *fs_type,
 144                 int flags, void *data, const char *hostname)
 145 {
 146         struct vfsmount *root_mnt;
 147         char *root_devname;
 148         size_t len;
 149
 150         len = strlen(hostname) + 5;
 151         root_devname = kmalloc(len, GFP_KERNEL);
 152         if (root_devname == NULL)
 153                 return ERR_PTR(-ENOMEM);
 154         /* Does hostname needs to be enclosed in brackets? */
 155         if (strchr(hostname, ':'))
 156                 snprintf(root_devname, len, "[%s]:/", hostname);
 157         else
 158                 snprintf(root_devname, len, "%s:/", hostname);
 159         root_mnt = vfs_kern_mount(fs_type, flags, root_devname, data);
 160         kfree(root_devname);
 161         return root_mnt;
 162 }
 163
 164 struct nfs_referral_count {
 165         struct list_head list;
 166         const struct task_struct *task;
 167         unsigned int referral_count;
 168 };
 169
 170 static LIST_HEAD(nfs_referral_count_list);
 171 static DEFINE_SPINLOCK(nfs_referral_count_list_lock);
 172
 173 static struct nfs_referral_count *nfs_find_referral_count(void)
 174 {
 175         struct nfs_referral_count *p;
 176
 177         list_for_each_entry(p, &nfs_referral_count_list, list) {
 178                 if (p->task == current)
 179                         return p;
 180         }
 181         return NULL;
 182 }
 183
 184 #define NFS_MAX_NESTED_REFERRALS 2
 185
 186 static int nfs_referral_loop_protect(void)
 187 {
 188         struct nfs_referral_count *p, *new;
 189         int ret = -ENOMEM;
 190
 191         new = kmalloc(sizeof(*new), GFP_KERNEL);
 192         if (!new)
 193                 goto out;
 194         new->task = current;
 195         new->referral_count = 1;
 196
 197         ret = 0;
 198         spin_lock(&nfs_referral_count_list_lock);
 199         p = nfs_find_referral_count();
 200         if (p != NULL) {
 201                 if (p->referral_count >= NFS_MAX_NESTED_REFERRALS)
 202                         ret = -ELOOP;
 203                 else
 204                         p->referral_count++;
 205         } else {
 206                 list_add(&new->list, &nfs_referral_count_list);
 207                 new = NULL;
 208         }
 209         spin_unlock(&nfs_referral_count_list_lock);
 210         kfree(new);
 211 out:
 212         return ret;
 213 }
 214
 215 static void nfs_referral_loop_unprotect(void)
 216 {
 217         struct nfs_referral_count *p;
 218
 219         spin_lock(&nfs_referral_count_list_lock);
 220         p = nfs_find_referral_count();
 221         p->referral_count--;
 222         if (p->referral_count == 0)
 223                 list_del(&p->list);
 224         else
 225                 p = NULL;
 226         spin_unlock(&nfs_referral_count_list_lock);
 227         kfree(p);
 228 }
 229
 230 static struct dentry *nfs_follow_remote_path(struct vfsmount *root_mnt,
 231                 const char *export_path)
 232 {
 233         struct dentry *dentry;
 234         int err;
 235
 236         if (IS_ERR(root_mnt))
 237                 return ERR_CAST(root_mnt);
 238
 239         err = nfs_referral_loop_protect();
 240         if (err) {
 241                 mntput(root_mnt);
 242                 return ERR_PTR(err);
 243         }
 244
 245         dentry = mount_subtree(root_mnt, export_path);
 246         nfs_referral_loop_unprotect();
 247
 248         return dentry;
 249 }
 250
 251 struct dentry *nfs4_try_mount(int flags, const char *dev_name,
 252                               struct nfs_mount_info *mount_info,
 253                               struct nfs_subversion *nfs_mod)
 254 {
 255         char *export_path;
 256         struct vfsmount *root_mnt;
 257         struct dentry *res;
 258         struct nfs_parsed_mount_data *data = mount_info->parsed;
 259
 260         dfprintk(MOUNT, "--> nfs4_try_mount()\n");
 261
 262         export_path = data->nfs_server.export_path;
 263         data->nfs_server.export_path = "/";
 264         root_mnt = nfs_do_root_mount(&nfs4_remote_fs_type, flags, mount_info,
 265                         data->nfs_server.hostname);
 266         data->nfs_server.export_path = export_path;
 267
 268         res = nfs_follow_remote_path(root_mnt, export_path);
 269
 270         dfprintk(MOUNT, "<-- nfs4_try_mount() = %ld%s\n",
 271                         IS_ERR(res) ? PTR_ERR(res) : 0,
 272                         IS_ERR(res) ? " [error]" : "");
 273         return res;
 274 }
 275
 276 static struct dentry *
 277 nfs4_remote_referral_mount(struct file_system_type *fs_type, int flags,
 278                            const char *dev_name, void *raw_data)
 279 {
 280         struct nfs_mount_info mount_info = {
 281                 .fill_super = nfs_fill_super,
 282                 .set_security = nfs_clone_sb_security,
 283                 .cloned = raw_data,
 284         };
 285         struct nfs_server *server;
 286         struct dentry *mntroot = ERR_PTR(-ENOMEM);
 287
 288         dprintk("--> nfs4_referral_get_sb()\n");
 289
 290         mount_info.mntfh = nfs_alloc_fhandle();
 291         if (mount_info.cloned == NULL || mount_info.mntfh == NULL)
 292                 goto out;
 293
 294         /* create a new volume representation */
 295         server = nfs4_create_referral_server(mount_info.cloned, mount_info.mntfh);
 296         if (IS_ERR(server)) {
 297                 mntroot = ERR_CAST(server);
 298                 goto out;
 299         }
 300
 301         mntroot = nfs_fs_mount_common(server, flags, dev_name, &mount_info, &nfs_v4);
 302 out:
 303         nfs_free_fhandle(mount_info.mntfh);
 304         return mntroot;
 305 }
 306
 307 /*
 308  * Create an NFS4 server record on referral traversal
 309  */
 310 static struct dentry *nfs4_referral_mount(struct file_system_type *fs_type,
 311                 int flags, const char *dev_name, void *raw_data)
 312 {
 313         struct nfs_clone_mount *data = raw_data;
 314         char *export_path;
 315         struct vfsmount *root_mnt;
 316         struct dentry *res;
 317
 318         dprintk("--> nfs4_referral_mount()\n");
 319
 320         export_path = data->mnt_path;
 321         data->mnt_path = "/";
 322
 323         root_mnt = nfs_do_root_mount(&nfs4_remote_referral_fs_type,
 324                         flags, data, data->hostname);
 325         data->mnt_path = export_path;
 326
 327         res = nfs_follow_remote_path(root_mnt, export_path);
 328         dprintk("<-- nfs4_referral_mount() = %ld%s\n",
 329                         IS_ERR(res) ? PTR_ERR(res) : 0,
 330                         IS_ERR(res) ? " [error]" : "");
 331         return res;
 332 }
 333
 334
 335 static int __init init_nfs_v4(void)
 336 {
 337         int err;
 338
 339         err = nfs_idmap_init();
 340         if (err)
 341                 goto out;
 342
 343         err = nfs4_register_sysctl();
 344         if (err)
 345                 goto out1;
 346
 347         err = register_filesystem(&nfs4_fs_type);
 348         if (err < 0)
 349                 goto out2;
 350
 351         register_nfs_version(&nfs_v4);
 352         return 0;
 353 out2:
 354         nfs4_unregister_sysctl();
 355 out1:
 356         nfs_idmap_quit();
 357 out:
 358         return err;
 359 }
 360
 361 static void __exit exit_nfs_v4(void)
 362 {
 363         unregister_nfs_version(&nfs_v4);
 364         unregister_filesystem(&nfs4_fs_type);
 365         nfs4_unregister_sysctl();
 366         nfs_idmap_quit();
 367 }
 368
 369 MODULE_LICENSE("GPL");
 370
 371 module_init(init_nfs_v4);
 372 module_exit(exit_nfs_v4);