xref: /kernel/linux/linux-5.10/fs/afs/super.c (revision 8c2ecf20) 
1/* AFS superblock handling
2 *
3 * Copyright (c) 2002, 2007, 2018 Red Hat, Inc. All rights reserved.
4 *
5 * This software may be freely redistributed under the terms of the
6 * GNU General Public License.
7 *
8 * You should have received a copy of the GNU General Public License
9 * along with this program; if not, write to the Free Software
10 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
11 *
12 * Authors: David Howells <dhowells@redhat.com>
13 *          David Woodhouse <dwmw2@infradead.org>
14 *
15 */
16
17#include <linux/kernel.h>
18#include <linux/module.h>
19#include <linux/mount.h>
20#include <linux/init.h>
21#include <linux/slab.h>
22#include <linux/fs.h>
23#include <linux/pagemap.h>
24#include <linux/fs_parser.h>
25#include <linux/statfs.h>
26#include <linux/sched.h>
27#include <linux/nsproxy.h>
28#include <linux/magic.h>
29#include <net/net_namespace.h>
30#include "internal.h"
31
32static void afs_i_init_once(void *foo);
33static void afs_kill_super(struct super_block *sb);
34static struct inode *afs_alloc_inode(struct super_block *sb);
35static void afs_destroy_inode(struct inode *inode);
36static void afs_free_inode(struct inode *inode);
37static int afs_statfs(struct dentry *dentry, struct kstatfs *buf);
38static int afs_show_devname(struct seq_file *m, struct dentry *root);
39static int afs_show_options(struct seq_file *m, struct dentry *root);
40static int afs_init_fs_context(struct fs_context *fc);
41static const struct fs_parameter_spec afs_fs_parameters[];
42
43struct file_system_type afs_fs_type = {
44	.owner			= THIS_MODULE,
45	.name			= "afs",
46	.init_fs_context	= afs_init_fs_context,
47	.parameters		= afs_fs_parameters,
48	.kill_sb		= afs_kill_super,
49	.fs_flags		= FS_RENAME_DOES_D_MOVE,
50};
51MODULE_ALIAS_FS("afs");
52
53int afs_net_id;
54
55static const struct super_operations afs_super_ops = {
56	.statfs		= afs_statfs,
57	.alloc_inode	= afs_alloc_inode,
58	.drop_inode	= afs_drop_inode,
59	.destroy_inode	= afs_destroy_inode,
60	.free_inode	= afs_free_inode,
61	.evict_inode	= afs_evict_inode,
62	.show_devname	= afs_show_devname,
63	.show_options	= afs_show_options,
64};
65
66static struct kmem_cache *afs_inode_cachep;
67static atomic_t afs_count_active_inodes;
68
69enum afs_param {
70	Opt_autocell,
71	Opt_dyn,
72	Opt_flock,
73	Opt_source,
74};
75
76static const struct constant_table afs_param_flock[] = {
77	{"local",	afs_flock_mode_local },
78	{"openafs",	afs_flock_mode_openafs },
79	{"strict",	afs_flock_mode_strict },
80	{"write",	afs_flock_mode_write },
81	{}
82};
83
84static const struct fs_parameter_spec afs_fs_parameters[] = {
85	fsparam_flag  ("autocell",	Opt_autocell),
86	fsparam_flag  ("dyn",		Opt_dyn),
87	fsparam_enum  ("flock",		Opt_flock, afs_param_flock),
88	fsparam_string("source",	Opt_source),
89	{}
90};
91
92/*
93 * initialise the filesystem
94 */
95int __init afs_fs_init(void)
96{
97	int ret;
98
99	_enter("");
100
101	/* create ourselves an inode cache */
102	atomic_set(&afs_count_active_inodes, 0);
103
104	ret = -ENOMEM;
105	afs_inode_cachep = kmem_cache_create("afs_inode_cache",
106					     sizeof(struct afs_vnode),
107					     0,
108					     SLAB_HWCACHE_ALIGN|SLAB_ACCOUNT,
109					     afs_i_init_once);
110	if (!afs_inode_cachep) {
111		printk(KERN_NOTICE "kAFS: Failed to allocate inode cache\n");
112		return ret;
113	}
114
115	/* now export our filesystem to lesser mortals */
116	ret = register_filesystem(&afs_fs_type);
117	if (ret < 0) {
118		kmem_cache_destroy(afs_inode_cachep);
119		_leave(" = %d", ret);
120		return ret;
121	}
122
123	_leave(" = 0");
124	return 0;
125}
126
127/*
128 * clean up the filesystem
129 */
130void afs_fs_exit(void)
131{
132	_enter("");
133
134	afs_mntpt_kill_timer();
135	unregister_filesystem(&afs_fs_type);
136
137	if (atomic_read(&afs_count_active_inodes) != 0) {
138		printk("kAFS: %d active inode objects still present\n",
139		       atomic_read(&afs_count_active_inodes));
140		BUG();
141	}
142
143	/*
144	 * Make sure all delayed rcu free inodes are flushed before we
145	 * destroy cache.
146	 */
147	rcu_barrier();
148	kmem_cache_destroy(afs_inode_cachep);
149	_leave("");
150}
151
152/*
153 * Display the mount device name in /proc/mounts.
154 */
155static int afs_show_devname(struct seq_file *m, struct dentry *root)
156{
157	struct afs_super_info *as = AFS_FS_S(root->d_sb);
158	struct afs_volume *volume = as->volume;
159	struct afs_cell *cell = as->cell;
160	const char *suf = "";
161	char pref = '%';
162
163	if (as->dyn_root) {
164		seq_puts(m, "none");
165		return 0;
166	}
167
168	switch (volume->type) {
169	case AFSVL_RWVOL:
170		break;
171	case AFSVL_ROVOL:
172		pref = '#';
173		if (volume->type_force)
174			suf = ".readonly";
175		break;
176	case AFSVL_BACKVOL:
177		pref = '#';
178		suf = ".backup";
179		break;
180	}
181
182	seq_printf(m, "%c%s:%s%s", pref, cell->name, volume->name, suf);
183	return 0;
184}
185
186/*
187 * Display the mount options in /proc/mounts.
188 */
189static int afs_show_options(struct seq_file *m, struct dentry *root)
190{
191	struct afs_super_info *as = AFS_FS_S(root->d_sb);
192	const char *p = NULL;
193
194	if (as->dyn_root)
195		seq_puts(m, ",dyn");
196	if (test_bit(AFS_VNODE_AUTOCELL, &AFS_FS_I(d_inode(root))->flags))
197		seq_puts(m, ",autocell");
198	switch (as->flock_mode) {
199	case afs_flock_mode_unset:	break;
200	case afs_flock_mode_local:	p = "local";	break;
201	case afs_flock_mode_openafs:	p = "openafs";	break;
202	case afs_flock_mode_strict:	p = "strict";	break;
203	case afs_flock_mode_write:	p = "write";	break;
204	}
205	if (p)
206		seq_printf(m, ",flock=%s", p);
207
208	return 0;
209}
210
211/*
212 * Parse the source name to get cell name, volume name, volume type and R/W
213 * selector.
214 *
215 * This can be one of the following:
216 *	"%[cell:]volume[.]"		R/W volume
217 *	"#[cell:]volume[.]"		R/O or R/W volume (R/O parent),
218 *					 or R/W (R/W parent) volume
219 *	"%[cell:]volume.readonly"	R/O volume
220 *	"#[cell:]volume.readonly"	R/O volume
221 *	"%[cell:]volume.backup"		Backup volume
222 *	"#[cell:]volume.backup"		Backup volume
223 */
224static int afs_parse_source(struct fs_context *fc, struct fs_parameter *param)
225{
226	struct afs_fs_context *ctx = fc->fs_private;
227	struct afs_cell *cell;
228	const char *cellname, *suffix, *name = param->string;
229	int cellnamesz;
230
231	_enter(",%s", name);
232
233	if (fc->source)
234		return invalf(fc, "kAFS: Multiple sources not supported");
235
236	if (!name) {
237		printk(KERN_ERR "kAFS: no volume name specified\n");
238		return -EINVAL;
239	}
240
241	if ((name[0] != '%' && name[0] != '#') || !name[1]) {
242		/* To use dynroot, we don't want to have to provide a source */
243		if (strcmp(name, "none") == 0) {
244			ctx->no_cell = true;
245			return 0;
246		}
247		printk(KERN_ERR "kAFS: unparsable volume name\n");
248		return -EINVAL;
249	}
250
251	/* determine the type of volume we're looking for */
252	if (name[0] == '%') {
253		ctx->type = AFSVL_RWVOL;
254		ctx->force = true;
255	}
256	name++;
257
258	/* split the cell name out if there is one */
259	ctx->volname = strchr(name, ':');
260	if (ctx->volname) {
261		cellname = name;
262		cellnamesz = ctx->volname - name;
263		ctx->volname++;
264	} else {
265		ctx->volname = name;
266		cellname = NULL;
267		cellnamesz = 0;
268	}
269
270	/* the volume type is further affected by a possible suffix */
271	suffix = strrchr(ctx->volname, '.');
272	if (suffix) {
273		if (strcmp(suffix, ".readonly") == 0) {
274			ctx->type = AFSVL_ROVOL;
275			ctx->force = true;
276		} else if (strcmp(suffix, ".backup") == 0) {
277			ctx->type = AFSVL_BACKVOL;
278			ctx->force = true;
279		} else if (suffix[1] == 0) {
280		} else {
281			suffix = NULL;
282		}
283	}
284
285	ctx->volnamesz = suffix ?
286		suffix - ctx->volname : strlen(ctx->volname);
287
288	_debug("cell %*.*s [%p]",
289	       cellnamesz, cellnamesz, cellname ?: "", ctx->cell);
290
291	/* lookup the cell record */
292	if (cellname) {
293		cell = afs_lookup_cell(ctx->net, cellname, cellnamesz,
294				       NULL, false);
295		if (IS_ERR(cell)) {
296			pr_err("kAFS: unable to lookup cell '%*.*s'\n",
297			       cellnamesz, cellnamesz, cellname ?: "");
298			return PTR_ERR(cell);
299		}
300		afs_unuse_cell(ctx->net, ctx->cell, afs_cell_trace_unuse_parse);
301		afs_see_cell(cell, afs_cell_trace_see_source);
302		ctx->cell = cell;
303	}
304
305	_debug("CELL:%s [%p] VOLUME:%*.*s SUFFIX:%s TYPE:%d%s",
306	       ctx->cell->name, ctx->cell,
307	       ctx->volnamesz, ctx->volnamesz, ctx->volname,
308	       suffix ?: "-", ctx->type, ctx->force ? " FORCE" : "");
309
310	fc->source = param->string;
311	param->string = NULL;
312	return 0;
313}
314
315/*
316 * Parse a single mount parameter.
317 */
318static int afs_parse_param(struct fs_context *fc, struct fs_parameter *param)
319{
320	struct fs_parse_result result;
321	struct afs_fs_context *ctx = fc->fs_private;
322	int opt;
323
324	opt = fs_parse(fc, afs_fs_parameters, param, &result);
325	if (opt < 0)
326		return opt;
327
328	switch (opt) {
329	case Opt_source:
330		return afs_parse_source(fc, param);
331
332	case Opt_autocell:
333		ctx->autocell = true;
334		break;
335
336	case Opt_dyn:
337		ctx->dyn_root = true;
338		break;
339
340	case Opt_flock:
341		ctx->flock_mode = result.uint_32;
342		break;
343
344	default:
345		return -EINVAL;
346	}
347
348	_leave(" = 0");
349	return 0;
350}
351
352/*
353 * Validate the options, get the cell key and look up the volume.
354 */
355static int afs_validate_fc(struct fs_context *fc)
356{
357	struct afs_fs_context *ctx = fc->fs_private;
358	struct afs_volume *volume;
359	struct afs_cell *cell;
360	struct key *key;
361	int ret;
362
363	if (!ctx->dyn_root) {
364		if (ctx->no_cell) {
365			pr_warn("kAFS: Can only specify source 'none' with -o dyn\n");
366			return -EINVAL;
367		}
368
369		if (!ctx->cell) {
370			pr_warn("kAFS: No cell specified\n");
371			return -EDESTADDRREQ;
372		}
373
374	reget_key:
375		/* We try to do the mount securely. */
376		key = afs_request_key(ctx->cell);
377		if (IS_ERR(key))
378			return PTR_ERR(key);
379
380		ctx->key = key;
381
382		if (ctx->volume) {
383			afs_put_volume(ctx->net, ctx->volume,
384				       afs_volume_trace_put_validate_fc);
385			ctx->volume = NULL;
386		}
387
388		if (test_bit(AFS_CELL_FL_CHECK_ALIAS, &ctx->cell->flags)) {
389			ret = afs_cell_detect_alias(ctx->cell, key);
390			if (ret < 0)
391				return ret;
392			if (ret == 1) {
393				_debug("switch to alias");
394				key_put(ctx->key);
395				ctx->key = NULL;
396				cell = afs_use_cell(ctx->cell->alias_of,
397						    afs_cell_trace_use_fc_alias);
398				afs_unuse_cell(ctx->net, ctx->cell, afs_cell_trace_unuse_fc);
399				ctx->cell = cell;
400				goto reget_key;
401			}
402		}
403
404		volume = afs_create_volume(ctx);
405		if (IS_ERR(volume))
406			return PTR_ERR(volume);
407
408		ctx->volume = volume;
409		if (volume->type != AFSVL_RWVOL)
410			ctx->flock_mode = afs_flock_mode_local;
411	}
412
413	return 0;
414}
415
416/*
417 * check a superblock to see if it's the one we're looking for
418 */
419static int afs_test_super(struct super_block *sb, struct fs_context *fc)
420{
421	struct afs_fs_context *ctx = fc->fs_private;
422	struct afs_super_info *as = AFS_FS_S(sb);
423
424	return (as->net_ns == fc->net_ns &&
425		as->volume &&
426		as->volume->vid == ctx->volume->vid &&
427		as->cell == ctx->cell &&
428		!as->dyn_root);
429}
430
431static int afs_dynroot_test_super(struct super_block *sb, struct fs_context *fc)
432{
433	struct afs_super_info *as = AFS_FS_S(sb);
434
435	return (as->net_ns == fc->net_ns &&
436		as->dyn_root);
437}
438
439static int afs_set_super(struct super_block *sb, struct fs_context *fc)
440{
441	return set_anon_super(sb, NULL);
442}
443
444/*
445 * fill in the superblock
446 */
447static int afs_fill_super(struct super_block *sb, struct afs_fs_context *ctx)
448{
449	struct afs_super_info *as = AFS_FS_S(sb);
450	struct inode *inode = NULL;
451	int ret;
452
453	_enter("");
454
455	/* fill in the superblock */
456	sb->s_blocksize		= PAGE_SIZE;
457	sb->s_blocksize_bits	= PAGE_SHIFT;
458	sb->s_maxbytes		= MAX_LFS_FILESIZE;
459	sb->s_magic		= AFS_FS_MAGIC;
460	sb->s_op		= &afs_super_ops;
461	if (!as->dyn_root)
462		sb->s_xattr	= afs_xattr_handlers;
463	ret = super_setup_bdi(sb);
464	if (ret)
465		return ret;
466
467	/* allocate the root inode and dentry */
468	if (as->dyn_root) {
469		inode = afs_iget_pseudo_dir(sb, true);
470	} else {
471		sprintf(sb->s_id, "%llu", as->volume->vid);
472		afs_activate_volume(as->volume);
473		inode = afs_root_iget(sb, ctx->key);
474	}
475
476	if (IS_ERR(inode))
477		return PTR_ERR(inode);
478
479	if (ctx->autocell || as->dyn_root)
480		set_bit(AFS_VNODE_AUTOCELL, &AFS_FS_I(inode)->flags);
481
482	ret = -ENOMEM;
483	sb->s_root = d_make_root(inode);
484	if (!sb->s_root)
485		goto error;
486
487	if (as->dyn_root) {
488		sb->s_d_op = &afs_dynroot_dentry_operations;
489		ret = afs_dynroot_populate(sb);
490		if (ret < 0)
491			goto error;
492	} else {
493		sb->s_d_op = &afs_fs_dentry_operations;
494		rcu_assign_pointer(as->volume->sb, sb);
495	}
496
497	_leave(" = 0");
498	return 0;
499
500error:
501	_leave(" = %d", ret);
502	return ret;
503}
504
505static struct afs_super_info *afs_alloc_sbi(struct fs_context *fc)
506{
507	struct afs_fs_context *ctx = fc->fs_private;
508	struct afs_super_info *as;
509
510	as = kzalloc(sizeof(struct afs_super_info), GFP_KERNEL);
511	if (as) {
512		as->net_ns = get_net(fc->net_ns);
513		as->flock_mode = ctx->flock_mode;
514		if (ctx->dyn_root) {
515			as->dyn_root = true;
516		} else {
517			as->cell = afs_use_cell(ctx->cell, afs_cell_trace_use_sbi);
518			as->volume = afs_get_volume(ctx->volume,
519						    afs_volume_trace_get_alloc_sbi);
520		}
521	}
522	return as;
523}
524
525static void afs_destroy_sbi(struct afs_super_info *as)
526{
527	if (as) {
528		struct afs_net *net = afs_net(as->net_ns);
529		afs_put_volume(net, as->volume, afs_volume_trace_put_destroy_sbi);
530		afs_unuse_cell(net, as->cell, afs_cell_trace_unuse_sbi);
531		put_net(as->net_ns);
532		kfree(as);
533	}
534}
535
536static void afs_kill_super(struct super_block *sb)
537{
538	struct afs_super_info *as = AFS_FS_S(sb);
539
540	if (as->dyn_root)
541		afs_dynroot_depopulate(sb);
542
543	/* Clear the callback interests (which will do ilookup5) before
544	 * deactivating the superblock.
545	 */
546	if (as->volume)
547		rcu_assign_pointer(as->volume->sb, NULL);
548	kill_anon_super(sb);
549	if (as->volume)
550		afs_deactivate_volume(as->volume);
551	afs_destroy_sbi(as);
552}
553
554/*
555 * Get an AFS superblock and root directory.
556 */
557static int afs_get_tree(struct fs_context *fc)
558{
559	struct afs_fs_context *ctx = fc->fs_private;
560	struct super_block *sb;
561	struct afs_super_info *as;
562	int ret;
563
564	ret = afs_validate_fc(fc);
565	if (ret)
566		goto error;
567
568	_enter("");
569
570	/* allocate a superblock info record */
571	ret = -ENOMEM;
572	as = afs_alloc_sbi(fc);
573	if (!as)
574		goto error;
575	fc->s_fs_info = as;
576
577	/* allocate a deviceless superblock */
578	sb = sget_fc(fc,
579		     as->dyn_root ? afs_dynroot_test_super : afs_test_super,
580		     afs_set_super);
581	if (IS_ERR(sb)) {
582		ret = PTR_ERR(sb);
583		goto error;
584	}
585
586	if (!sb->s_root) {
587		/* initial superblock/root creation */
588		_debug("create");
589		ret = afs_fill_super(sb, ctx);
590		if (ret < 0)
591			goto error_sb;
592		sb->s_flags |= SB_ACTIVE;
593	} else {
594		_debug("reuse");
595		ASSERTCMP(sb->s_flags, &, SB_ACTIVE);
596	}
597
598	fc->root = dget(sb->s_root);
599	trace_afs_get_tree(as->cell, as->volume);
600	_leave(" = 0 [%p]", sb);
601	return 0;
602
603error_sb:
604	deactivate_locked_super(sb);
605error:
606	_leave(" = %d", ret);
607	return ret;
608}
609
610static void afs_free_fc(struct fs_context *fc)
611{
612	struct afs_fs_context *ctx = fc->fs_private;
613
614	afs_destroy_sbi(fc->s_fs_info);
615	afs_put_volume(ctx->net, ctx->volume, afs_volume_trace_put_free_fc);
616	afs_unuse_cell(ctx->net, ctx->cell, afs_cell_trace_unuse_fc);
617	key_put(ctx->key);
618	kfree(ctx);
619}
620
621static const struct fs_context_operations afs_context_ops = {
622	.free		= afs_free_fc,
623	.parse_param	= afs_parse_param,
624	.get_tree	= afs_get_tree,
625};
626
627/*
628 * Set up the filesystem mount context.
629 */
630static int afs_init_fs_context(struct fs_context *fc)
631{
632	struct afs_fs_context *ctx;
633	struct afs_cell *cell;
634
635	ctx = kzalloc(sizeof(struct afs_fs_context), GFP_KERNEL);
636	if (!ctx)
637		return -ENOMEM;
638
639	ctx->type = AFSVL_ROVOL;
640	ctx->net = afs_net(fc->net_ns);
641
642	/* Default to the workstation cell. */
643	cell = afs_find_cell(ctx->net, NULL, 0, afs_cell_trace_use_fc);
644	if (IS_ERR(cell))
645		cell = NULL;
646	ctx->cell = cell;
647
648	fc->fs_private = ctx;
649	fc->ops = &afs_context_ops;
650	return 0;
651}
652
653/*
654 * Initialise an inode cache slab element prior to any use.  Note that
655 * afs_alloc_inode() *must* reset anything that could incorrectly leak from one
656 * inode to another.
657 */
658static void afs_i_init_once(void *_vnode)
659{
660	struct afs_vnode *vnode = _vnode;
661
662	memset(vnode, 0, sizeof(*vnode));
663	inode_init_once(&vnode->vfs_inode);
664	mutex_init(&vnode->io_lock);
665	init_rwsem(&vnode->validate_lock);
666	spin_lock_init(&vnode->wb_lock);
667	spin_lock_init(&vnode->lock);
668	INIT_LIST_HEAD(&vnode->wb_keys);
669	INIT_LIST_HEAD(&vnode->pending_locks);
670	INIT_LIST_HEAD(&vnode->granted_locks);
671	INIT_DELAYED_WORK(&vnode->lock_work, afs_lock_work);
672	seqlock_init(&vnode->cb_lock);
673}
674
675/*
676 * allocate an AFS inode struct from our slab cache
677 */
678static struct inode *afs_alloc_inode(struct super_block *sb)
679{
680	struct afs_vnode *vnode;
681
682	vnode = kmem_cache_alloc(afs_inode_cachep, GFP_KERNEL);
683	if (!vnode)
684		return NULL;
685
686	atomic_inc(&afs_count_active_inodes);
687
688	/* Reset anything that shouldn't leak from one inode to the next. */
689	memset(&vnode->fid, 0, sizeof(vnode->fid));
690	memset(&vnode->status, 0, sizeof(vnode->status));
691
692	vnode->volume		= NULL;
693	vnode->lock_key		= NULL;
694	vnode->permit_cache	= NULL;
695#ifdef CONFIG_AFS_FSCACHE
696	vnode->cache		= NULL;
697#endif
698
699	vnode->flags		= 1 << AFS_VNODE_UNSET;
700	vnode->lock_state	= AFS_VNODE_LOCK_NONE;
701
702	init_rwsem(&vnode->rmdir_lock);
703
704	_leave(" = %p", &vnode->vfs_inode);
705	return &vnode->vfs_inode;
706}
707
708static void afs_free_inode(struct inode *inode)
709{
710	kmem_cache_free(afs_inode_cachep, AFS_FS_I(inode));
711}
712
713/*
714 * destroy an AFS inode struct
715 */
716static void afs_destroy_inode(struct inode *inode)
717{
718	struct afs_vnode *vnode = AFS_FS_I(inode);
719
720	_enter("%p{%llx:%llu}", inode, vnode->fid.vid, vnode->fid.vnode);
721
722	_debug("DESTROY INODE %p", inode);
723
724	atomic_dec(&afs_count_active_inodes);
725}
726
727static void afs_get_volume_status_success(struct afs_operation *op)
728{
729	struct afs_volume_status *vs = &op->volstatus.vs;
730	struct kstatfs *buf = op->volstatus.buf;
731
732	if (vs->max_quota == 0)
733		buf->f_blocks = vs->part_max_blocks;
734	else
735		buf->f_blocks = vs->max_quota;
736
737	if (buf->f_blocks > vs->blocks_in_use)
738		buf->f_bavail = buf->f_bfree =
739			buf->f_blocks - vs->blocks_in_use;
740}
741
742static const struct afs_operation_ops afs_get_volume_status_operation = {
743	.issue_afs_rpc	= afs_fs_get_volume_status,
744	.issue_yfs_rpc	= yfs_fs_get_volume_status,
745	.success	= afs_get_volume_status_success,
746};
747
748/*
749 * return information about an AFS volume
750 */
751static int afs_statfs(struct dentry *dentry, struct kstatfs *buf)
752{
753	struct afs_super_info *as = AFS_FS_S(dentry->d_sb);
754	struct afs_operation *op;
755	struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));
756
757	buf->f_type	= dentry->d_sb->s_magic;
758	buf->f_bsize	= AFS_BLOCK_SIZE;
759	buf->f_namelen	= AFSNAMEMAX - 1;
760
761	if (as->dyn_root) {
762		buf->f_blocks	= 1;
763		buf->f_bavail	= 0;
764		buf->f_bfree	= 0;
765		return 0;
766	}
767
768	op = afs_alloc_operation(NULL, as->volume);
769	if (IS_ERR(op))
770		return PTR_ERR(op);
771
772	afs_op_set_vnode(op, 0, vnode);
773	op->nr_files		= 1;
774	op->volstatus.buf	= buf;
775	op->ops			= &afs_get_volume_status_operation;
776	return afs_do_sync_operation(op);
777}
778