xref: /openbmc/linux/fs/afs/dynroot.c (revision 3c305aa9)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* AFS dynamic root handling
3  *
4  * Copyright (C) 2018 Red Hat, Inc. All Rights Reserved.
5  * Written by David Howells (dhowells@redhat.com)
6  */
7 
8 #include <linux/fs.h>
9 #include <linux/namei.h>
10 #include <linux/dns_resolver.h>
11 #include "internal.h"
12 
13 static atomic_t afs_autocell_ino;
14 
15 /*
16  * iget5() comparator for inode created by autocell operations
17  *
18  * These pseudo inodes don't match anything.
19  */
afs_iget5_pseudo_test(struct inode * inode,void * opaque)20 static int afs_iget5_pseudo_test(struct inode *inode, void *opaque)
21 {
22 	return 0;
23 }
24 
25 /*
26  * iget5() inode initialiser
27  */
afs_iget5_pseudo_set(struct inode * inode,void * opaque)28 static int afs_iget5_pseudo_set(struct inode *inode, void *opaque)
29 {
30 	struct afs_super_info *as = AFS_FS_S(inode->i_sb);
31 	struct afs_vnode *vnode = AFS_FS_I(inode);
32 	struct afs_fid *fid = opaque;
33 
34 	vnode->volume		= as->volume;
35 	vnode->fid		= *fid;
36 	inode->i_ino		= fid->vnode;
37 	inode->i_generation	= fid->unique;
38 	return 0;
39 }
40 
41 /*
42  * Create an inode for a dynamic root directory or an autocell dynamic
43  * automount dir.
44  */
afs_iget_pseudo_dir(struct super_block * sb,bool root)45 struct inode *afs_iget_pseudo_dir(struct super_block *sb, bool root)
46 {
47 	struct afs_super_info *as = AFS_FS_S(sb);
48 	struct afs_vnode *vnode;
49 	struct inode *inode;
50 	struct afs_fid fid = {};
51 
52 	_enter("");
53 
54 	if (as->volume)
55 		fid.vid = as->volume->vid;
56 	if (root) {
57 		fid.vnode = 1;
58 		fid.unique = 1;
59 	} else {
60 		fid.vnode = atomic_inc_return(&afs_autocell_ino);
61 		fid.unique = 0;
62 	}
63 
64 	inode = iget5_locked(sb, fid.vnode,
65 			     afs_iget5_pseudo_test, afs_iget5_pseudo_set, &fid);
66 	if (!inode) {
67 		_leave(" = -ENOMEM");
68 		return ERR_PTR(-ENOMEM);
69 	}
70 
71 	_debug("GOT INODE %p { ino=%lu, vl=%llx, vn=%llx, u=%x }",
72 	       inode, inode->i_ino, fid.vid, fid.vnode, fid.unique);
73 
74 	vnode = AFS_FS_I(inode);
75 
76 	/* there shouldn't be an existing inode */
77 	BUG_ON(!(inode->i_state & I_NEW));
78 
79 	netfs_inode_init(&vnode->netfs, NULL);
80 	inode->i_size		= 0;
81 	inode->i_mode		= S_IFDIR | S_IRUGO | S_IXUGO;
82 	if (root) {
83 		inode->i_op	= &afs_dynroot_inode_operations;
84 		inode->i_fop	= &simple_dir_operations;
85 	} else {
86 		inode->i_op	= &afs_autocell_inode_operations;
87 	}
88 	set_nlink(inode, 2);
89 	inode->i_uid		= GLOBAL_ROOT_UID;
90 	inode->i_gid		= GLOBAL_ROOT_GID;
91 	inode->i_atime = inode->i_mtime = inode_set_ctime_current(inode);
92 	inode->i_blocks		= 0;
93 	inode->i_generation	= 0;
94 
95 	set_bit(AFS_VNODE_PSEUDODIR, &vnode->flags);
96 	if (!root) {
97 		set_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags);
98 		inode->i_flags |= S_AUTOMOUNT;
99 	}
100 
101 	inode->i_flags |= S_NOATIME;
102 	unlock_new_inode(inode);
103 	_leave(" = %p", inode);
104 	return inode;
105 }
106 
107 /*
108  * Probe to see if a cell may exist.  This prevents positive dentries from
109  * being created unnecessarily.
110  */
afs_probe_cell_name(struct dentry * dentry)111 static int afs_probe_cell_name(struct dentry *dentry)
112 {
113 	struct afs_cell *cell;
114 	struct afs_net *net = afs_d2net(dentry);
115 	const char *name = dentry->d_name.name;
116 	size_t len = dentry->d_name.len;
117 	char *result = NULL;
118 	int ret;
119 
120 	/* Names prefixed with a dot are R/W mounts. */
121 	if (name[0] == '.') {
122 		if (len == 1)
123 			return -EINVAL;
124 		name++;
125 		len--;
126 	}
127 
128 	cell = afs_find_cell(net, name, len, afs_cell_trace_use_probe);
129 	if (!IS_ERR(cell)) {
130 		afs_unuse_cell(net, cell, afs_cell_trace_unuse_probe);
131 		return 0;
132 	}
133 
134 	ret = dns_query(net->net, "afsdb", name, len, "srv=1",
135 			&result, NULL, false);
136 	if (ret == -ENODATA || ret == -ENOKEY || ret == 0)
137 		ret = -ENOENT;
138 	if (ret > 0 && ret >= sizeof(struct dns_server_list_v1_header)) {
139 		struct dns_server_list_v1_header *v1 = (void *)result;
140 
141 		if (v1->hdr.zero == 0 &&
142 		    v1->hdr.content == DNS_PAYLOAD_IS_SERVER_LIST &&
143 		    v1->hdr.version == 1 &&
144 		    (v1->status != DNS_LOOKUP_GOOD &&
145 		     v1->status != DNS_LOOKUP_GOOD_WITH_BAD))
146 			return -ENOENT;
147 
148 	}
149 
150 	kfree(result);
151 	return ret;
152 }
153 
154 /*
155  * Try to auto mount the mountpoint with pseudo directory, if the autocell
156  * operation is setted.
157  */
afs_try_auto_mntpt(struct dentry * dentry,struct inode * dir)158 struct inode *afs_try_auto_mntpt(struct dentry *dentry, struct inode *dir)
159 {
160 	struct afs_vnode *vnode = AFS_FS_I(dir);
161 	struct inode *inode;
162 	int ret = -ENOENT;
163 
164 	_enter("%p{%pd}, {%llx:%llu}",
165 	       dentry, dentry, vnode->fid.vid, vnode->fid.vnode);
166 
167 	if (!test_bit(AFS_VNODE_AUTOCELL, &vnode->flags))
168 		goto out;
169 
170 	ret = afs_probe_cell_name(dentry);
171 	if (ret < 0)
172 		goto out;
173 
174 	inode = afs_iget_pseudo_dir(dir->i_sb, false);
175 	if (IS_ERR(inode)) {
176 		ret = PTR_ERR(inode);
177 		goto out;
178 	}
179 
180 	_leave("= %p", inode);
181 	return inode;
182 
183 out:
184 	_leave("= %d", ret);
185 	return ret == -ENOENT ? NULL : ERR_PTR(ret);
186 }
187 
188 /*
189  * Look up @cell in a dynroot directory.  This is a substitution for the
190  * local cell name for the net namespace.
191  */
afs_lookup_atcell(struct dentry * dentry)192 static struct dentry *afs_lookup_atcell(struct dentry *dentry)
193 {
194 	struct afs_cell *cell;
195 	struct afs_net *net = afs_d2net(dentry);
196 	struct dentry *ret;
197 	char *name;
198 	int len;
199 
200 	if (!net->ws_cell)
201 		return ERR_PTR(-ENOENT);
202 
203 	ret = ERR_PTR(-ENOMEM);
204 	name = kmalloc(AFS_MAXCELLNAME + 1, GFP_KERNEL);
205 	if (!name)
206 		goto out_p;
207 
208 	down_read(&net->cells_lock);
209 	cell = net->ws_cell;
210 	if (cell) {
211 		len = cell->name_len;
212 		memcpy(name, cell->name, len + 1);
213 	}
214 	up_read(&net->cells_lock);
215 
216 	ret = ERR_PTR(-ENOENT);
217 	if (!cell)
218 		goto out_n;
219 
220 	ret = lookup_one_len(name, dentry->d_parent, len);
221 
222 	/* We don't want to d_add() the @cell dentry here as we don't want to
223 	 * the cached dentry to hide changes to the local cell name.
224 	 */
225 
226 out_n:
227 	kfree(name);
228 out_p:
229 	return ret;
230 }
231 
232 /*
233  * Look up an entry in a dynroot directory.
234  */
afs_dynroot_lookup(struct inode * dir,struct dentry * dentry,unsigned int flags)235 static struct dentry *afs_dynroot_lookup(struct inode *dir, struct dentry *dentry,
236 					 unsigned int flags)
237 {
238 	_enter("%pd", dentry);
239 
240 	ASSERTCMP(d_inode(dentry), ==, NULL);
241 
242 	if (flags & LOOKUP_CREATE)
243 		return ERR_PTR(-EOPNOTSUPP);
244 
245 	if (dentry->d_name.len >= AFSNAMEMAX) {
246 		_leave(" = -ENAMETOOLONG");
247 		return ERR_PTR(-ENAMETOOLONG);
248 	}
249 
250 	if (dentry->d_name.len == 5 &&
251 	    memcmp(dentry->d_name.name, "@cell", 5) == 0)
252 		return afs_lookup_atcell(dentry);
253 
254 	return d_splice_alias(afs_try_auto_mntpt(dentry, dir), dentry);
255 }
256 
257 const struct inode_operations afs_dynroot_inode_operations = {
258 	.lookup		= afs_dynroot_lookup,
259 };
260 
261 /*
262  * Dirs in the dynamic root don't need revalidation.
263  */
afs_dynroot_d_revalidate(struct dentry * dentry,unsigned int flags)264 static int afs_dynroot_d_revalidate(struct dentry *dentry, unsigned int flags)
265 {
266 	return 1;
267 }
268 
269 const struct dentry_operations afs_dynroot_dentry_operations = {
270 	.d_revalidate	= afs_dynroot_d_revalidate,
271 	.d_delete	= always_delete_dentry,
272 	.d_release	= afs_d_release,
273 	.d_automount	= afs_d_automount,
274 };
275 
276 /*
277  * Create a manually added cell mount directory.
278  * - The caller must hold net->proc_cells_lock
279  */
afs_dynroot_mkdir(struct afs_net * net,struct afs_cell * cell)280 int afs_dynroot_mkdir(struct afs_net *net, struct afs_cell *cell)
281 {
282 	struct super_block *sb = net->dynroot_sb;
283 	struct dentry *root, *subdir;
284 	int ret;
285 
286 	if (!sb || atomic_read(&sb->s_active) == 0)
287 		return 0;
288 
289 	/* Let the ->lookup op do the creation */
290 	root = sb->s_root;
291 	inode_lock(root->d_inode);
292 	subdir = lookup_one_len(cell->name, root, cell->name_len);
293 	if (IS_ERR(subdir)) {
294 		ret = PTR_ERR(subdir);
295 		goto unlock;
296 	}
297 
298 	/* Note that we're retaining an extra ref on the dentry */
299 	subdir->d_fsdata = (void *)1UL;
300 	ret = 0;
301 unlock:
302 	inode_unlock(root->d_inode);
303 	return ret;
304 }
305 
306 /*
307  * Remove a manually added cell mount directory.
308  * - The caller must hold net->proc_cells_lock
309  */
afs_dynroot_rmdir(struct afs_net * net,struct afs_cell * cell)310 void afs_dynroot_rmdir(struct afs_net *net, struct afs_cell *cell)
311 {
312 	struct super_block *sb = net->dynroot_sb;
313 	struct dentry *root, *subdir;
314 
315 	if (!sb || atomic_read(&sb->s_active) == 0)
316 		return;
317 
318 	root = sb->s_root;
319 	inode_lock(root->d_inode);
320 
321 	/* Don't want to trigger a lookup call, which will re-add the cell */
322 	subdir = try_lookup_one_len(cell->name, root, cell->name_len);
323 	if (IS_ERR_OR_NULL(subdir)) {
324 		_debug("lookup %ld", PTR_ERR(subdir));
325 		goto no_dentry;
326 	}
327 
328 	_debug("rmdir %pd %u", subdir, d_count(subdir));
329 
330 	if (subdir->d_fsdata) {
331 		_debug("unpin %u", d_count(subdir));
332 		subdir->d_fsdata = NULL;
333 		dput(subdir);
334 	}
335 	dput(subdir);
336 no_dentry:
337 	inode_unlock(root->d_inode);
338 	_leave("");
339 }
340 
341 /*
342  * Populate a newly created dynamic root with cell names.
343  */
afs_dynroot_populate(struct super_block * sb)344 int afs_dynroot_populate(struct super_block *sb)
345 {
346 	struct afs_cell *cell;
347 	struct afs_net *net = afs_sb2net(sb);
348 	int ret;
349 
350 	mutex_lock(&net->proc_cells_lock);
351 
352 	net->dynroot_sb = sb;
353 	hlist_for_each_entry(cell, &net->proc_cells, proc_link) {
354 		ret = afs_dynroot_mkdir(net, cell);
355 		if (ret < 0)
356 			goto error;
357 	}
358 
359 	ret = 0;
360 out:
361 	mutex_unlock(&net->proc_cells_lock);
362 	return ret;
363 
364 error:
365 	net->dynroot_sb = NULL;
366 	goto out;
367 }
368 
369 /*
370  * When a dynamic root that's in the process of being destroyed, depopulate it
371  * of pinned directories.
372  */
afs_dynroot_depopulate(struct super_block * sb)373 void afs_dynroot_depopulate(struct super_block *sb)
374 {
375 	struct afs_net *net = afs_sb2net(sb);
376 	struct dentry *root = sb->s_root, *subdir, *tmp;
377 
378 	/* Prevent more subdirs from being created */
379 	mutex_lock(&net->proc_cells_lock);
380 	if (net->dynroot_sb == sb)
381 		net->dynroot_sb = NULL;
382 	mutex_unlock(&net->proc_cells_lock);
383 
384 	if (root) {
385 		inode_lock(root->d_inode);
386 
387 		/* Remove all the pins for dirs created for manually added cells */
388 		list_for_each_entry_safe(subdir, tmp, &root->d_subdirs, d_child) {
389 			if (subdir->d_fsdata) {
390 				subdir->d_fsdata = NULL;
391 				dput(subdir);
392 			}
393 		}
394 
395 		inode_unlock(root->d_inode);
396 	}
397 }
398