Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * linux/fs/nfs/namespace.c
4 : : *
5 : : * Copyright (C) 2005 Trond Myklebust <Trond.Myklebust@netapp.com>
6 : : * - Modified by David Howells <dhowells@redhat.com>
7 : : *
8 : : * NFS namespace
9 : : */
10 : :
11 : : #include <linux/module.h>
12 : : #include <linux/dcache.h>
13 : : #include <linux/gfp.h>
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>
20 : : #include <linux/sunrpc/gss_api.h>
21 : : #include "internal.h"
22 : : #include "nfs.h"
23 : :
24 : : #define NFSDBG_FACILITY NFSDBG_VFS
25 : :
26 : : static void nfs_expire_automounts(struct work_struct *work);
27 : :
28 : : static LIST_HEAD(nfs_automount_list);
29 : : static DECLARE_DELAYED_WORK(nfs_automount_task, nfs_expire_automounts);
30 : : int nfs_mountpoint_expiry_timeout = 500 * HZ;
31 : :
32 : : /*
33 : : * nfs_path - reconstruct the path given an arbitrary dentry
34 : : * @base - used to return pointer to the end of devname part of path
35 : : * @dentry - pointer to dentry
36 : : * @buffer - result buffer
37 : : * @buflen - length of buffer
38 : : * @flags - options (see below)
39 : : *
40 : : * Helper function for constructing the server pathname
41 : : * by arbitrary hashed dentry.
42 : : *
43 : : * This is mainly for use in figuring out the path on the
44 : : * server side when automounting on top of an existing partition
45 : : * and in generating /proc/mounts and friends.
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)
51 : : */
52 : 0 : char *nfs_path(char **p, struct dentry *dentry, char *buffer, ssize_t buflen,
53 : : unsigned flags)
54 : : {
55 : 0 : char *end;
56 : 0 : int namelen;
57 : 0 : unsigned seq;
58 : 0 : const char *base;
59 : :
60 : : rename_retry:
61 : 0 : end = buffer+buflen;
62 : 0 : *--end = '\0';
63 : 0 : buflen--;
64 : :
65 : 0 : seq = read_seqbegin(&rename_lock);
66 : 0 : rcu_read_lock();
67 : 0 : while (1) {
68 : 0 : spin_lock(&dentry->d_lock);
69 [ # # ]: 0 : if (IS_ROOT(dentry))
70 : : break;
71 : 0 : namelen = dentry->d_name.len;
72 : 0 : buflen -= namelen + 1;
73 [ # # ]: 0 : if (buflen < 0)
74 : 0 : goto Elong_unlock;
75 : 0 : end -= namelen;
76 : 0 : memcpy(end, dentry->d_name.name, namelen);
77 : 0 : *--end = '/';
78 : 0 : spin_unlock(&dentry->d_lock);
79 : 0 : dentry = dentry->d_parent;
80 : : }
81 [ # # ]: 0 : if (read_seqretry(&rename_lock, seq)) {
82 : 0 : spin_unlock(&dentry->d_lock);
83 : 0 : rcu_read_unlock();
84 : 0 : goto rename_retry;
85 : : }
86 [ # # # # ]: 0 : if ((flags & NFS_PATH_CANONICAL) && *end != '/') {
87 [ # # ]: 0 : if (--buflen < 0) {
88 : 0 : spin_unlock(&dentry->d_lock);
89 : 0 : rcu_read_unlock();
90 : 0 : goto Elong;
91 : : }
92 : 0 : *--end = '/';
93 : : }
94 : 0 : *p = end;
95 : 0 : base = dentry->d_fsdata;
96 [ # # ]: 0 : if (!base) {
97 : 0 : spin_unlock(&dentry->d_lock);
98 : 0 : rcu_read_unlock();
99 : 0 : WARN_ON(1);
100 : 0 : return end;
101 : : }
102 : 0 : namelen = strlen(base);
103 [ # # ]: 0 : if (*end == '/') {
104 : : /* Strip off excess slashes in base string */
105 [ # # # # ]: 0 : while (namelen > 0 && base[namelen - 1] == '/')
106 : : namelen--;
107 : : }
108 : 0 : buflen -= namelen;
109 [ # # ]: 0 : if (buflen < 0) {
110 : 0 : spin_unlock(&dentry->d_lock);
111 : 0 : rcu_read_unlock();
112 : 0 : goto Elong;
113 : : }
114 : 0 : end -= namelen;
115 : 0 : memcpy(end, base, namelen);
116 : 0 : spin_unlock(&dentry->d_lock);
117 : 0 : rcu_read_unlock();
118 : 0 : return end;
119 : : Elong_unlock:
120 : 0 : spin_unlock(&dentry->d_lock);
121 : 0 : rcu_read_unlock();
122 [ # # ]: 0 : if (read_seqretry(&rename_lock, seq))
123 : 0 : goto rename_retry;
124 : 0 : Elong:
125 : : return ERR_PTR(-ENAMETOOLONG);
126 : : }
127 : : EXPORT_SYMBOL_GPL(nfs_path);
128 : :
129 : : /*
130 : : * nfs_d_automount - Handle crossing a mountpoint on the server
131 : : * @path - The mountpoint
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 : : */
141 : 0 : struct vfsmount *nfs_d_automount(struct path *path)
142 : : {
143 : 0 : struct nfs_fs_context *ctx;
144 : 0 : struct fs_context *fc;
145 [ # # ]: 0 : struct vfsmount *mnt = ERR_PTR(-ENOMEM);
146 [ # # ]: 0 : struct nfs_server *server = NFS_SERVER(d_inode(path->dentry));
147 : 0 : struct nfs_client *client = server->nfs_client;
148 : 0 : int ret;
149 : :
150 [ # # ]: 0 : if (IS_ROOT(path->dentry))
151 : : return ERR_PTR(-ESTALE);
152 : :
153 : : /* Open a new filesystem context, transferring parameters from the
154 : : * parent superblock, including the network namespace.
155 : : */
156 : 0 : fc = fs_context_for_submount(path->mnt->mnt_sb->s_type, path->dentry);
157 [ # # ]: 0 : if (IS_ERR(fc))
158 : : return ERR_CAST(fc);
159 : :
160 : 0 : ctx = nfs_fc2context(fc);
161 : 0 : ctx->clone_data.dentry = path->dentry;
162 : 0 : ctx->clone_data.sb = path->dentry->d_sb;
163 : 0 : ctx->clone_data.fattr = nfs_alloc_fattr();
164 [ # # ]: 0 : if (!ctx->clone_data.fattr)
165 : 0 : goto out_fc;
166 : :
167 [ # # ]: 0 : if (fc->net_ns != client->cl_net) {
168 : 0 : put_net(fc->net_ns);
169 : 0 : fc->net_ns = get_net(client->cl_net);
170 : : }
171 : :
172 : : /* for submounts we want the same server; referrals will reassign */
173 : 0 : memcpy(&ctx->nfs_server.address, &client->cl_addr, client->cl_addrlen);
174 : 0 : ctx->nfs_server.addrlen = client->cl_addrlen;
175 : 0 : ctx->nfs_server.port = server->port;
176 : :
177 : 0 : ctx->version = client->rpc_ops->version;
178 : 0 : ctx->minorversion = client->cl_minorversion;
179 : 0 : ctx->nfs_mod = client->cl_nfs_mod;
180 : 0 : __module_get(ctx->nfs_mod->owner);
181 : :
182 : 0 : ret = client->rpc_ops->submount(fc, server);
183 [ # # ]: 0 : if (ret < 0) {
184 : 0 : mnt = ERR_PTR(ret);
185 : 0 : goto out_fc;
186 : : }
187 : :
188 : 0 : up_write(&fc->root->d_sb->s_umount);
189 : 0 : mnt = vfs_create_mount(fc);
190 [ # # ]: 0 : if (IS_ERR(mnt))
191 : 0 : goto out_fc;
192 : :
193 [ # # ]: 0 : if (nfs_mountpoint_expiry_timeout < 0)
194 : 0 : goto out_fc;
195 : :
196 : 0 : mntget(mnt); /* prevent immediate expiration */
197 : 0 : mnt_set_expiry(mnt, &nfs_automount_list);
198 : 0 : schedule_delayed_work(&nfs_automount_task, nfs_mountpoint_expiry_timeout);
199 : :
200 : 0 : out_fc:
201 : 0 : put_fs_context(fc);
202 : 0 : return mnt;
203 : : }
204 : :
205 : : static int
206 : 0 : nfs_namespace_getattr(const struct path *path, struct kstat *stat,
207 : : u32 request_mask, unsigned int query_flags)
208 : : {
209 [ # # ]: 0 : if (NFS_FH(d_inode(path->dentry))->size != 0)
210 : 0 : return nfs_getattr(path, stat, request_mask, query_flags);
211 : 0 : generic_fillattr(d_inode(path->dentry), stat);
212 : 0 : return 0;
213 : : }
214 : :
215 : : static int
216 : 0 : nfs_namespace_setattr(struct dentry *dentry, struct iattr *attr)
217 : : {
218 [ # # ]: 0 : if (NFS_FH(d_inode(dentry))->size != 0)
219 : 0 : return nfs_setattr(dentry, attr);
220 : : return -EACCES;
221 : : }
222 : :
223 : : const struct inode_operations nfs_mountpoint_inode_operations = {
224 : : .getattr = nfs_getattr,
225 : : .setattr = nfs_setattr,
226 : : };
227 : :
228 : : const struct inode_operations nfs_referral_inode_operations = {
229 : : .getattr = nfs_namespace_getattr,
230 : : .setattr = nfs_namespace_setattr,
231 : : };
232 : :
233 : 0 : static void nfs_expire_automounts(struct work_struct *work)
234 : : {
235 : 0 : struct list_head *list = &nfs_automount_list;
236 : :
237 : 0 : mark_mounts_for_expiry(list);
238 [ # # ]: 0 : if (!list_empty(list))
239 : 0 : schedule_delayed_work(&nfs_automount_task, nfs_mountpoint_expiry_timeout);
240 : 0 : }
241 : :
242 : 0 : void nfs_release_automount_timer(void)
243 : : {
244 [ # # ]: 0 : if (list_empty(&nfs_automount_list))
245 : 0 : cancel_delayed_work(&nfs_automount_task);
246 : 0 : }
247 : :
248 : : /**
249 : : * nfs_do_submount - set up mountpoint when crossing a filesystem boundary
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
254 : : *
255 : : */
256 : 0 : int nfs_do_submount(struct fs_context *fc)
257 : : {
258 : 0 : struct nfs_fs_context *ctx = nfs_fc2context(fc);
259 : 0 : struct dentry *dentry = ctx->clone_data.dentry;
260 : 0 : struct nfs_server *server;
261 : 0 : char *buffer, *p;
262 : 0 : int ret;
263 : :
264 : : /* create a new volume representation */
265 : 0 : server = ctx->nfs_mod->rpc_ops->clone_server(NFS_SB(ctx->clone_data.sb),
266 : : ctx->mntfh,
267 : : ctx->clone_data.fattr,
268 : : ctx->selected_flavor);
269 : :
270 [ # # ]: 0 : if (IS_ERR(server))
271 : 0 : return PTR_ERR(server);
272 : :
273 : 0 : ctx->server = server;
274 : :
275 : 0 : buffer = kmalloc(4096, GFP_USER);
276 [ # # ]: 0 : if (!buffer)
277 : : return -ENOMEM;
278 : :
279 : 0 : ctx->internal = true;
280 : 0 : ctx->clone_data.inherited_bsize = ctx->clone_data.sb->s_blocksize_bits;
281 : :
282 : 0 : p = nfs_devname(dentry, buffer, 4096);
283 [ # # ]: 0 : if (IS_ERR(p)) {
284 : 0 : nfs_errorf(fc, "NFS: Couldn't determine submount pathname");
285 : 0 : ret = PTR_ERR(p);
286 : : } else {
287 : 0 : ret = vfs_parse_fs_string(fc, "source", p, buffer + 4096 - p);
288 [ # # ]: 0 : if (!ret)
289 : 0 : ret = vfs_get_tree(fc);
290 : : }
291 : 0 : kfree(buffer);
292 : 0 : return ret;
293 : : }
294 : : EXPORT_SYMBOL_GPL(nfs_do_submount);
295 : :
296 : 0 : int nfs_submount(struct fs_context *fc, struct nfs_server *server)
297 : : {
298 : 0 : struct nfs_fs_context *ctx = nfs_fc2context(fc);
299 : 0 : struct dentry *dentry = ctx->clone_data.dentry;
300 : 0 : struct dentry *parent = dget_parent(dentry);
301 : 0 : int err;
302 : :
303 : : /* Look it up again to get its attributes */
304 : 0 : err = server->nfs_client->rpc_ops->lookup(d_inode(parent), dentry,
305 : : ctx->mntfh, ctx->clone_data.fattr,
306 : : NULL);
307 : 0 : dput(parent);
308 [ # # ]: 0 : if (err != 0)
309 : : return err;
310 : :
311 : 0 : ctx->selected_flavor = server->client->cl_auth->au_flavor;
312 : 0 : return nfs_do_submount(fc);
313 : : }
314 : : EXPORT_SYMBOL_GPL(nfs_submount);
|
