Commit | Line | Data |
---|---|---|
457c8996 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
55a97593 TM |
2 | /* |
3 | * linux/fs/nfs/namespace.c | |
4 | * | |
5 | * Copyright (C) 2005 Trond Myklebust <Trond.Myklebust@netapp.com> | |
54ceac45 | 6 | * - Modified by David Howells <dhowells@redhat.com> |
55a97593 TM |
7 | * |
8 | * NFS namespace | |
9 | */ | |
10 | ||
ddda8e0a | 11 | #include <linux/module.h> |
55a97593 | 12 | #include <linux/dcache.h> |
5a0e3ad6 | 13 | #include <linux/gfp.h> |
55a97593 TM |
14 | #include <linux/mount.h> |
15 | #include <linux/namei.h> | |
16 | #include <linux/nfs_fs.h> | |
17 | #include <linux/string.h> | |
18 | #include <linux/sunrpc/clnt.h> | |
19 | #include <linux/vfs.h> | |
7ebb9315 | 20 | #include <linux/sunrpc/gss_api.h> |
f7b422b1 | 21 | #include "internal.h" |
250d69f6 | 22 | #include "nfs.h" |
55a97593 TM |
23 | |
24 | #define NFSDBG_FACILITY NFSDBG_VFS | |
25 | ||
65f27f38 | 26 | static void nfs_expire_automounts(struct work_struct *work); |
f7b422b1 | 27 | |
a3dab293 | 28 | static LIST_HEAD(nfs_automount_list); |
65f27f38 | 29 | static DECLARE_DELAYED_WORK(nfs_automount_task, nfs_expire_automounts); |
51d8fa6a TM |
30 | int nfs_mountpoint_expiry_timeout = 500 * HZ; |
31 | ||
f7b422b1 DH |
32 | /* |
33 | * nfs_path - reconstruct the path given an arbitrary dentry | |
b514f872 | 34 | * @base - used to return pointer to the end of devname part of path |
247db735 | 35 | * @dentry_in - pointer to dentry |
f7b422b1 | 36 | * @buffer - result buffer |
247db735 | 37 | * @buflen_in - length of buffer |
97a54868 | 38 | * @flags - options (see below) |
f7b422b1 | 39 | * |
b514f872 AV |
40 | * Helper function for constructing the server pathname |
41 | * by arbitrary hashed dentry. | |
f7b422b1 DH |
42 | * |
43 | * This is mainly for use in figuring out the path on the | |
b514f872 AV |
44 | * server side when automounting on top of an existing partition |
45 | * and in generating /proc/mounts and friends. | |
97a54868 BH |
46 | * |
47 | * Supported flags: | |
48 | * NFS_PATH_CANONICAL: ensure there is exactly one slash after | |
49 | * the original device (export) name | |
50 | * (if unset, the original name is returned verbatim) | |
f7b422b1 | 51 | */ |
247db735 AS |
52 | char *nfs_path(char **p, struct dentry *dentry_in, char *buffer, |
53 | ssize_t buflen_in, unsigned flags) | |
f7b422b1 | 54 | { |
949854d0 | 55 | char *end; |
f7b422b1 | 56 | int namelen; |
949854d0 | 57 | unsigned seq; |
b514f872 | 58 | const char *base; |
247db735 AS |
59 | struct dentry *dentry; |
60 | ssize_t buflen; | |
f7b422b1 | 61 | |
949854d0 | 62 | rename_retry: |
247db735 AS |
63 | buflen = buflen_in; |
64 | dentry = dentry_in; | |
949854d0 | 65 | end = buffer+buflen; |
f7b422b1 DH |
66 | *--end = '\0'; |
67 | buflen--; | |
949854d0 NP |
68 | |
69 | seq = read_seqbegin(&rename_lock); | |
70 | rcu_read_lock(); | |
b514f872 AV |
71 | while (1) { |
72 | spin_lock(&dentry->d_lock); | |
73 | if (IS_ROOT(dentry)) | |
74 | break; | |
f7b422b1 DH |
75 | namelen = dentry->d_name.len; |
76 | buflen -= namelen + 1; | |
77 | if (buflen < 0) | |
ce510193 | 78 | goto Elong_unlock; |
f7b422b1 DH |
79 | end -= namelen; |
80 | memcpy(end, dentry->d_name.name, namelen); | |
81 | *--end = '/'; | |
b514f872 | 82 | spin_unlock(&dentry->d_lock); |
f7b422b1 DH |
83 | dentry = dentry->d_parent; |
84 | } | |
b514f872 AV |
85 | if (read_seqretry(&rename_lock, seq)) { |
86 | spin_unlock(&dentry->d_lock); | |
87 | rcu_read_unlock(); | |
949854d0 | 88 | goto rename_retry; |
b514f872 | 89 | } |
97a54868 | 90 | if ((flags & NFS_PATH_CANONICAL) && *end != '/') { |
b514f872 AV |
91 | if (--buflen < 0) { |
92 | spin_unlock(&dentry->d_lock); | |
93 | rcu_read_unlock(); | |
0b75b35c | 94 | goto Elong; |
b514f872 | 95 | } |
0b75b35c TM |
96 | *--end = '/'; |
97 | } | |
b514f872 AV |
98 | *p = end; |
99 | base = dentry->d_fsdata; | |
100 | if (!base) { | |
101 | spin_unlock(&dentry->d_lock); | |
102 | rcu_read_unlock(); | |
103 | WARN_ON(1); | |
104 | return end; | |
105 | } | |
f7b422b1 | 106 | namelen = strlen(base); |
86a6c211 | 107 | if (*end == '/') { |
97a54868 BH |
108 | /* Strip off excess slashes in base string */ |
109 | while (namelen > 0 && base[namelen - 1] == '/') | |
110 | namelen--; | |
111 | } | |
f7b422b1 | 112 | buflen -= namelen; |
b514f872 | 113 | if (buflen < 0) { |
1c34092a | 114 | spin_unlock(&dentry->d_lock); |
b514f872 | 115 | rcu_read_unlock(); |
f7b422b1 | 116 | goto Elong; |
b514f872 | 117 | } |
f7b422b1 DH |
118 | end -= namelen; |
119 | memcpy(end, base, namelen); | |
b514f872 AV |
120 | spin_unlock(&dentry->d_lock); |
121 | rcu_read_unlock(); | |
f7b422b1 | 122 | return end; |
ce510193 | 123 | Elong_unlock: |
1c34092a | 124 | spin_unlock(&dentry->d_lock); |
949854d0 NP |
125 | rcu_read_unlock(); |
126 | if (read_seqretry(&rename_lock, seq)) | |
127 | goto rename_retry; | |
f7b422b1 DH |
128 | Elong: |
129 | return ERR_PTR(-ENAMETOOLONG); | |
130 | } | |
89d77c8f | 131 | EXPORT_SYMBOL_GPL(nfs_path); |
f7b422b1 | 132 | |
55a97593 | 133 | /* |
36d43a43 DH |
134 | * nfs_d_automount - Handle crossing a mountpoint on the server |
135 | * @path - The mountpoint | |
55a97593 TM |
136 | * |
137 | * When we encounter a mountpoint on the server, we want to set up | |
138 | * a mountpoint on the client too, to prevent inode numbers from | |
139 | * colliding, and to allow "df" to work properly. | |
140 | * On NFSv4, we also want to allow for the fact that different | |
141 | * filesystems may be migrated to different servers in a failover | |
142 | * situation, and that different filesystems may want to use | |
143 | * different security flavours. | |
144 | */ | |
36d43a43 | 145 | struct vfsmount *nfs_d_automount(struct path *path) |
55a97593 | 146 | { |
f2aedb71 DH |
147 | struct nfs_fs_context *ctx; |
148 | struct fs_context *fc; | |
149 | struct vfsmount *mnt = ERR_PTR(-ENOMEM); | |
2b0143b5 | 150 | struct nfs_server *server = NFS_SERVER(d_inode(path->dentry)); |
f2aedb71 | 151 | struct nfs_client *client = server->nfs_client; |
75da9858 | 152 | int timeout = READ_ONCE(nfs_mountpoint_expiry_timeout); |
f2aedb71 | 153 | int ret; |
55a97593 | 154 | |
36d43a43 | 155 | if (IS_ROOT(path->dentry)) |
e36d48e9 | 156 | return ERR_PTR(-ESTALE); |
44d5759d | 157 | |
f2aedb71 DH |
158 | /* Open a new filesystem context, transferring parameters from the |
159 | * parent superblock, including the network namespace. | |
160 | */ | |
1821b26a | 161 | fc = fs_context_for_submount(path->mnt->mnt_sb->s_type, path->dentry); |
f2aedb71 DH |
162 | if (IS_ERR(fc)) |
163 | return ERR_CAST(fc); | |
a4d7f168 | 164 | |
f2aedb71 DH |
165 | ctx = nfs_fc2context(fc); |
166 | ctx->clone_data.dentry = path->dentry; | |
167 | ctx->clone_data.sb = path->dentry->d_sb; | |
168 | ctx->clone_data.fattr = nfs_alloc_fattr(); | |
169 | if (!ctx->clone_data.fattr) | |
170 | goto out_fc; | |
171 | ||
172 | if (fc->net_ns != client->cl_net) { | |
173 | put_net(fc->net_ns); | |
174 | fc->net_ns = get_net(client->cl_net); | |
175 | } | |
176 | ||
177 | /* for submounts we want the same server; referrals will reassign */ | |
178 | memcpy(&ctx->nfs_server.address, &client->cl_addr, client->cl_addrlen); | |
179 | ctx->nfs_server.addrlen = client->cl_addrlen; | |
180 | ctx->nfs_server.port = server->port; | |
181 | ||
182 | ctx->version = client->rpc_ops->version; | |
183 | ctx->minorversion = client->cl_minorversion; | |
62a55d08 SM |
184 | ctx->nfs_mod = client->cl_nfs_mod; |
185 | __module_get(ctx->nfs_mod->owner); | |
f2aedb71 DH |
186 | |
187 | ret = client->rpc_ops->submount(fc, server); | |
188 | if (ret < 0) { | |
189 | mnt = ERR_PTR(ret); | |
190 | goto out_fc; | |
191 | } | |
192 | ||
193 | up_write(&fc->root->d_sb->s_umount); | |
194 | mnt = vfs_create_mount(fc); | |
55a97593 | 195 | if (IS_ERR(mnt)) |
f2aedb71 | 196 | goto out_fc; |
55a97593 | 197 | |
75da9858 TM |
198 | mntget(mnt); /* prevent immediate expiration */ |
199 | if (timeout <= 0) | |
f2aedb71 | 200 | goto out_fc; |
22a1ae9a | 201 | |
ea5b778a | 202 | mnt_set_expiry(mnt, &nfs_automount_list); |
75da9858 | 203 | schedule_delayed_work(&nfs_automount_task, timeout); |
36d43a43 | 204 | |
f2aedb71 DH |
205 | out_fc: |
206 | put_fs_context(fc); | |
36d43a43 | 207 | return mnt; |
55a97593 TM |
208 | } |
209 | ||
ab225417 | 210 | static int |
549c7297 CB |
211 | nfs_namespace_getattr(struct user_namespace *mnt_userns, |
212 | const struct path *path, struct kstat *stat, | |
213 | u32 request_mask, unsigned int query_flags) | |
ab225417 | 214 | { |
a528d35e | 215 | if (NFS_FH(d_inode(path->dentry))->size != 0) |
549c7297 CB |
216 | return nfs_getattr(mnt_userns, path, stat, request_mask, |
217 | query_flags); | |
0d56a451 | 218 | generic_fillattr(&init_user_ns, d_inode(path->dentry), stat); |
ab225417 TM |
219 | return 0; |
220 | } | |
221 | ||
222 | static int | |
549c7297 CB |
223 | nfs_namespace_setattr(struct user_namespace *mnt_userns, struct dentry *dentry, |
224 | struct iattr *attr) | |
ab225417 | 225 | { |
2b0143b5 | 226 | if (NFS_FH(d_inode(dentry))->size != 0) |
549c7297 | 227 | return nfs_setattr(mnt_userns, dentry, attr); |
ab225417 TM |
228 | return -EACCES; |
229 | } | |
230 | ||
92e1d5be | 231 | const struct inode_operations nfs_mountpoint_inode_operations = { |
55a97593 | 232 | .getattr = nfs_getattr, |
ab225417 | 233 | .setattr = nfs_setattr, |
55a97593 | 234 | }; |
51d8fa6a | 235 | |
92e1d5be | 236 | const struct inode_operations nfs_referral_inode_operations = { |
ab225417 TM |
237 | .getattr = nfs_namespace_getattr, |
238 | .setattr = nfs_namespace_setattr, | |
6b97fd3d MN |
239 | }; |
240 | ||
65f27f38 | 241 | static void nfs_expire_automounts(struct work_struct *work) |
51d8fa6a | 242 | { |
65f27f38 | 243 | struct list_head *list = &nfs_automount_list; |
75da9858 | 244 | int timeout = READ_ONCE(nfs_mountpoint_expiry_timeout); |
51d8fa6a TM |
245 | |
246 | mark_mounts_for_expiry(list); | |
75da9858 TM |
247 | if (!list_empty(list) && timeout > 0) |
248 | schedule_delayed_work(&nfs_automount_task, timeout); | |
51d8fa6a TM |
249 | } |
250 | ||
251 | void nfs_release_automount_timer(void) | |
252 | { | |
3d39c691 | 253 | if (list_empty(&nfs_automount_list)) |
560aef74 | 254 | cancel_delayed_work(&nfs_automount_task); |
51d8fa6a | 255 | } |
f7b422b1 | 256 | |
f7b422b1 DH |
257 | /** |
258 | * nfs_do_submount - set up mountpoint when crossing a filesystem boundary | |
3cab1854 | 259 | * @fc: pointer to struct nfs_fs_context |
f7b422b1 DH |
260 | * |
261 | */ | |
f2aedb71 | 262 | int nfs_do_submount(struct fs_context *fc) |
f7b422b1 | 263 | { |
f2aedb71 DH |
264 | struct nfs_fs_context *ctx = nfs_fc2context(fc); |
265 | struct dentry *dentry = ctx->clone_data.dentry; | |
250d69f6 | 266 | struct nfs_server *server; |
f2aedb71 DH |
267 | char *buffer, *p; |
268 | int ret; | |
f7b422b1 | 269 | |
f2aedb71 | 270 | /* create a new volume representation */ |
62a55d08 SM |
271 | server = ctx->nfs_mod->rpc_ops->clone_server(NFS_SB(ctx->clone_data.sb), |
272 | ctx->mntfh, | |
f2aedb71 DH |
273 | ctx->clone_data.fattr, |
274 | ctx->selected_flavor); | |
e36d48e9 | 275 | |
250d69f6 | 276 | if (IS_ERR(server)) |
f2aedb71 | 277 | return PTR_ERR(server); |
250d69f6 | 278 | |
62a55d08 | 279 | ctx->server = server; |
250d69f6 | 280 | |
f2aedb71 DH |
281 | buffer = kmalloc(4096, GFP_USER); |
282 | if (!buffer) | |
283 | return -ENOMEM; | |
54ceac45 | 284 | |
f2aedb71 | 285 | ctx->internal = true; |
62a55d08 | 286 | ctx->clone_data.inherited_bsize = ctx->clone_data.sb->s_blocksize_bits; |
f2aedb71 DH |
287 | |
288 | p = nfs_devname(dentry, buffer, 4096); | |
289 | if (IS_ERR(p)) { | |
ce8866f0 | 290 | nfs_errorf(fc, "NFS: Couldn't determine submount pathname"); |
f2aedb71 DH |
291 | ret = PTR_ERR(p); |
292 | } else { | |
293 | ret = vfs_parse_fs_string(fc, "source", p, buffer + 4096 - p); | |
294 | if (!ret) | |
295 | ret = vfs_get_tree(fc); | |
296 | } | |
297 | kfree(buffer); | |
298 | return ret; | |
f7b422b1 | 299 | } |
89d77c8f | 300 | EXPORT_SYMBOL_GPL(nfs_do_submount); |
281cad46 | 301 | |
f2aedb71 | 302 | int nfs_submount(struct fs_context *fc, struct nfs_server *server) |
281cad46 | 303 | { |
f2aedb71 DH |
304 | struct nfs_fs_context *ctx = nfs_fc2context(fc); |
305 | struct dentry *dentry = ctx->clone_data.dentry; | |
281cad46 | 306 | struct dentry *parent = dget_parent(dentry); |
f2aedb71 | 307 | int err; |
281cad46 BS |
308 | |
309 | /* Look it up again to get its attributes */ | |
f7b37b8b | 310 | err = server->nfs_client->rpc_ops->lookup(d_inode(parent), dentry, |
62a55d08 | 311 | ctx->mntfh, ctx->clone_data.fattr, |
f2aedb71 | 312 | NULL); |
281cad46 BS |
313 | dput(parent); |
314 | if (err != 0) | |
f2aedb71 | 315 | return err; |
281cad46 | 316 | |
f2aedb71 DH |
317 | ctx->selected_flavor = server->client->cl_auth->au_flavor; |
318 | return nfs_do_submount(fc); | |
281cad46 | 319 | } |
ddda8e0a | 320 | EXPORT_SYMBOL_GPL(nfs_submount); |
f30a6ea0 TM |
321 | |
322 | static int param_set_nfs_timeout(const char *val, const struct kernel_param *kp) | |
323 | { | |
324 | long num; | |
325 | int ret; | |
326 | ||
327 | if (!val) | |
328 | return -EINVAL; | |
329 | ret = kstrtol(val, 0, &num); | |
330 | if (ret) | |
331 | return -EINVAL; | |
332 | if (num > 0) { | |
333 | if (num >= INT_MAX / HZ) | |
334 | num = INT_MAX; | |
335 | else | |
336 | num *= HZ; | |
337 | *((int *)kp->arg) = num; | |
338 | if (!list_empty(&nfs_automount_list)) | |
339 | mod_delayed_work(system_wq, &nfs_automount_task, num); | |
340 | } else { | |
341 | *((int *)kp->arg) = -1*HZ; | |
342 | cancel_delayed_work(&nfs_automount_task); | |
343 | } | |
344 | return 0; | |
345 | } | |
346 | ||
347 | static int param_get_nfs_timeout(char *buffer, const struct kernel_param *kp) | |
348 | { | |
349 | long num = *((int *)kp->arg); | |
350 | ||
351 | if (num > 0) { | |
352 | if (num >= INT_MAX - (HZ - 1)) | |
353 | num = INT_MAX / HZ; | |
354 | else | |
355 | num = (num + (HZ - 1)) / HZ; | |
356 | } else | |
357 | num = -1; | |
358 | return scnprintf(buffer, PAGE_SIZE, "%li\n", num); | |
359 | } | |
360 | ||
361 | static const struct kernel_param_ops param_ops_nfs_timeout = { | |
362 | .set = param_set_nfs_timeout, | |
363 | .get = param_get_nfs_timeout, | |
364 | }; | |
a799b68a | 365 | #define param_check_nfs_timeout(name, p) __param_check(name, p, int) |
f30a6ea0 TM |
366 | |
367 | module_param(nfs_mountpoint_expiry_timeout, nfs_timeout, 0644); | |
368 | MODULE_PARM_DESC(nfs_mountpoint_expiry_timeout, | |
369 | "Set the NFS automounted mountpoint timeout value (seconds)." | |
370 | "Values <= 0 turn expiration off."); |