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