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