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