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 DH |
147 | struct nfs_client *client = server->nfs_client; |
148 | int ret; | |
55a97593 | 149 | |
36d43a43 | 150 | if (IS_ROOT(path->dentry)) |
e36d48e9 | 151 | return ERR_PTR(-ESTALE); |
44d5759d | 152 | |
f2aedb71 DH |
153 | /* Open a new filesystem context, transferring parameters from the |
154 | * parent superblock, including the network namespace. | |
155 | */ | |
156 | fc = fs_context_for_submount(&nfs_fs_type, path->dentry); | |
157 | if (IS_ERR(fc)) | |
158 | return ERR_CAST(fc); | |
a4d7f168 | 159 | |
f2aedb71 DH |
160 | ctx = nfs_fc2context(fc); |
161 | ctx->clone_data.dentry = path->dentry; | |
162 | ctx->clone_data.sb = path->dentry->d_sb; | |
163 | ctx->clone_data.fattr = nfs_alloc_fattr(); | |
164 | if (!ctx->clone_data.fattr) | |
165 | goto out_fc; | |
166 | ||
167 | if (fc->net_ns != client->cl_net) { | |
168 | put_net(fc->net_ns); | |
169 | fc->net_ns = get_net(client->cl_net); | |
170 | } | |
171 | ||
172 | /* for submounts we want the same server; referrals will reassign */ | |
173 | memcpy(&ctx->nfs_server.address, &client->cl_addr, client->cl_addrlen); | |
174 | ctx->nfs_server.addrlen = client->cl_addrlen; | |
175 | ctx->nfs_server.port = server->port; | |
176 | ||
177 | ctx->version = client->rpc_ops->version; | |
178 | ctx->minorversion = client->cl_minorversion; | |
62a55d08 SM |
179 | ctx->nfs_mod = client->cl_nfs_mod; |
180 | __module_get(ctx->nfs_mod->owner); | |
f2aedb71 DH |
181 | |
182 | ret = client->rpc_ops->submount(fc, server); | |
183 | if (ret < 0) { | |
184 | mnt = ERR_PTR(ret); | |
185 | goto out_fc; | |
186 | } | |
187 | ||
188 | up_write(&fc->root->d_sb->s_umount); | |
189 | mnt = vfs_create_mount(fc); | |
55a97593 | 190 | if (IS_ERR(mnt)) |
f2aedb71 | 191 | goto out_fc; |
55a97593 | 192 | |
22a1ae9a | 193 | if (nfs_mountpoint_expiry_timeout < 0) |
f2aedb71 | 194 | goto out_fc; |
22a1ae9a | 195 | |
ea5b778a DH |
196 | mntget(mnt); /* prevent immediate expiration */ |
197 | mnt_set_expiry(mnt, &nfs_automount_list); | |
198 | schedule_delayed_work(&nfs_automount_task, nfs_mountpoint_expiry_timeout); | |
36d43a43 | 199 | |
f2aedb71 DH |
200 | out_fc: |
201 | put_fs_context(fc); | |
36d43a43 | 202 | return mnt; |
55a97593 TM |
203 | } |
204 | ||
ab225417 | 205 | static int |
a528d35e DH |
206 | nfs_namespace_getattr(const struct path *path, struct kstat *stat, |
207 | u32 request_mask, unsigned int query_flags) | |
ab225417 | 208 | { |
a528d35e DH |
209 | if (NFS_FH(d_inode(path->dentry))->size != 0) |
210 | return nfs_getattr(path, stat, request_mask, query_flags); | |
211 | generic_fillattr(d_inode(path->dentry), stat); | |
ab225417 TM |
212 | return 0; |
213 | } | |
214 | ||
215 | static int | |
216 | nfs_namespace_setattr(struct dentry *dentry, struct iattr *attr) | |
217 | { | |
2b0143b5 | 218 | if (NFS_FH(d_inode(dentry))->size != 0) |
ab225417 TM |
219 | return nfs_setattr(dentry, attr); |
220 | return -EACCES; | |
221 | } | |
222 | ||
92e1d5be | 223 | const struct inode_operations nfs_mountpoint_inode_operations = { |
55a97593 | 224 | .getattr = nfs_getattr, |
ab225417 | 225 | .setattr = nfs_setattr, |
55a97593 | 226 | }; |
51d8fa6a | 227 | |
92e1d5be | 228 | const struct inode_operations nfs_referral_inode_operations = { |
ab225417 TM |
229 | .getattr = nfs_namespace_getattr, |
230 | .setattr = nfs_namespace_setattr, | |
6b97fd3d MN |
231 | }; |
232 | ||
65f27f38 | 233 | static void nfs_expire_automounts(struct work_struct *work) |
51d8fa6a | 234 | { |
65f27f38 | 235 | struct list_head *list = &nfs_automount_list; |
51d8fa6a TM |
236 | |
237 | mark_mounts_for_expiry(list); | |
238 | if (!list_empty(list)) | |
239 | schedule_delayed_work(&nfs_automount_task, nfs_mountpoint_expiry_timeout); | |
240 | } | |
241 | ||
242 | void nfs_release_automount_timer(void) | |
243 | { | |
3d39c691 | 244 | if (list_empty(&nfs_automount_list)) |
560aef74 | 245 | cancel_delayed_work(&nfs_automount_task); |
51d8fa6a | 246 | } |
f7b422b1 | 247 | |
f7b422b1 DH |
248 | /** |
249 | * nfs_do_submount - set up mountpoint when crossing a filesystem boundary | |
302fad7b TM |
250 | * @dentry: parent directory |
251 | * @fh: filehandle for new root dentry | |
252 | * @fattr: attributes for new root inode | |
253 | * @authflavor: security flavor to use when performing the mount | |
f7b422b1 DH |
254 | * |
255 | */ | |
f2aedb71 | 256 | int nfs_do_submount(struct fs_context *fc) |
f7b422b1 | 257 | { |
f2aedb71 DH |
258 | struct nfs_fs_context *ctx = nfs_fc2context(fc); |
259 | struct dentry *dentry = ctx->clone_data.dentry; | |
250d69f6 | 260 | struct nfs_server *server; |
f2aedb71 DH |
261 | char *buffer, *p; |
262 | int ret; | |
f7b422b1 | 263 | |
f2aedb71 | 264 | /* create a new volume representation */ |
62a55d08 SM |
265 | server = ctx->nfs_mod->rpc_ops->clone_server(NFS_SB(ctx->clone_data.sb), |
266 | ctx->mntfh, | |
f2aedb71 DH |
267 | ctx->clone_data.fattr, |
268 | ctx->selected_flavor); | |
e36d48e9 | 269 | |
250d69f6 | 270 | if (IS_ERR(server)) |
f2aedb71 | 271 | return PTR_ERR(server); |
250d69f6 | 272 | |
62a55d08 | 273 | ctx->server = server; |
250d69f6 | 274 | |
f2aedb71 DH |
275 | buffer = kmalloc(4096, GFP_USER); |
276 | if (!buffer) | |
277 | return -ENOMEM; | |
54ceac45 | 278 | |
f2aedb71 | 279 | ctx->internal = true; |
62a55d08 | 280 | ctx->clone_data.inherited_bsize = ctx->clone_data.sb->s_blocksize_bits; |
f2aedb71 DH |
281 | |
282 | p = nfs_devname(dentry, buffer, 4096); | |
283 | if (IS_ERR(p)) { | |
ce8866f0 | 284 | nfs_errorf(fc, "NFS: Couldn't determine submount pathname"); |
f2aedb71 DH |
285 | ret = PTR_ERR(p); |
286 | } else { | |
287 | ret = vfs_parse_fs_string(fc, "source", p, buffer + 4096 - p); | |
288 | if (!ret) | |
289 | ret = vfs_get_tree(fc); | |
290 | } | |
291 | kfree(buffer); | |
292 | return ret; | |
f7b422b1 | 293 | } |
89d77c8f | 294 | EXPORT_SYMBOL_GPL(nfs_do_submount); |
281cad46 | 295 | |
f2aedb71 | 296 | int nfs_submount(struct fs_context *fc, struct nfs_server *server) |
281cad46 | 297 | { |
f2aedb71 DH |
298 | struct nfs_fs_context *ctx = nfs_fc2context(fc); |
299 | struct dentry *dentry = ctx->clone_data.dentry; | |
281cad46 | 300 | struct dentry *parent = dget_parent(dentry); |
f2aedb71 | 301 | int err; |
281cad46 BS |
302 | |
303 | /* Look it up again to get its attributes */ | |
f7b37b8b | 304 | err = server->nfs_client->rpc_ops->lookup(d_inode(parent), dentry, |
62a55d08 | 305 | ctx->mntfh, ctx->clone_data.fattr, |
f2aedb71 | 306 | NULL); |
281cad46 BS |
307 | dput(parent); |
308 | if (err != 0) | |
f2aedb71 | 309 | return err; |
281cad46 | 310 | |
f2aedb71 DH |
311 | ctx->selected_flavor = server->client->cl_auth->au_flavor; |
312 | return nfs_do_submount(fc); | |
281cad46 | 313 | } |
ddda8e0a | 314 | EXPORT_SYMBOL_GPL(nfs_submount); |