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