1/* AFS superblock handling
2 *
3 * Copyright (c) 2002, 2007 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/smp_lock.h>
23#include <linux/fs.h>
24#include <linux/pagemap.h>
25#include <linux/parser.h>
26#include <linux/statfs.h>
27#include <linux/sched.h>
28#include "internal.h"
29
30#define AFS_FS_MAGIC 0x6B414653 /* 'kAFS' */
31
32static void afs_i_init_once(void *foo);
33static int afs_get_sb(struct file_system_type *fs_type,
34		      int flags, const char *dev_name,
35		      void *data, struct vfsmount *mnt);
36static struct inode *afs_alloc_inode(struct super_block *sb);
37static void afs_put_super(struct super_block *sb);
38static void afs_destroy_inode(struct inode *inode);
39static int afs_statfs(struct dentry *dentry, struct kstatfs *buf);
40
41struct file_system_type afs_fs_type = {
42	.owner		= THIS_MODULE,
43	.name		= "afs",
44	.get_sb		= afs_get_sb,
45	.kill_sb	= kill_anon_super,
46	.fs_flags	= 0,
47};
48
49static const struct super_operations afs_super_ops = {
50	.statfs		= afs_statfs,
51	.alloc_inode	= afs_alloc_inode,
52	.drop_inode	= afs_drop_inode,
53	.destroy_inode	= afs_destroy_inode,
54	.evict_inode	= afs_evict_inode,
55	.put_super	= afs_put_super,
56	.show_options	= generic_show_options,
57};
58
59static struct kmem_cache *afs_inode_cachep;
60static atomic_t afs_count_active_inodes;
61
62enum {
63	afs_no_opt,
64	afs_opt_cell,
65	afs_opt_rwpath,
66	afs_opt_vol,
67	afs_opt_autocell,
68};
69
70static const match_table_t afs_options_list = {
71	{ afs_opt_cell,		"cell=%s"	},
72	{ afs_opt_rwpath,	"rwpath"	},
73	{ afs_opt_vol,		"vol=%s"	},
74	{ afs_opt_autocell,	"autocell"	},
75	{ afs_no_opt,		NULL		},
76};
77
78/*
79 * initialise the filesystem
80 */
81int __init afs_fs_init(void)
82{
83	int ret;
84
85	_enter("");
86
87	/* create ourselves an inode cache */
88	atomic_set(&afs_count_active_inodes, 0);
89
90	ret = -ENOMEM;
91	afs_inode_cachep = kmem_cache_create("afs_inode_cache",
92					     sizeof(struct afs_vnode),
93					     0,
94					     SLAB_HWCACHE_ALIGN,
95					     afs_i_init_once);
96	if (!afs_inode_cachep) {
97		printk(KERN_NOTICE "kAFS: Failed to allocate inode cache\n");
98		return ret;
99	}
100
101	/* now export our filesystem to lesser mortals */
102	ret = register_filesystem(&afs_fs_type);
103	if (ret < 0) {
104		kmem_cache_destroy(afs_inode_cachep);
105		_leave(" = %d", ret);
106		return ret;
107	}
108
109	_leave(" = 0");
110	return 0;
111}
112
113/*
114 * clean up the filesystem
115 */
116void __exit afs_fs_exit(void)
117{
118	_enter("");
119
120	afs_mntpt_kill_timer();
121	unregister_filesystem(&afs_fs_type);
122
123	if (atomic_read(&afs_count_active_inodes) != 0) {
124		printk("kAFS: %d active inode objects still present\n",
125		       atomic_read(&afs_count_active_inodes));
126		BUG();
127	}
128
129	kmem_cache_destroy(afs_inode_cachep);
130	_leave("");
131}
132
133/*
134 * parse the mount options
135 * - this function has been shamelessly adapted from the ext3 fs which
136 *   shamelessly adapted it from the msdos fs
137 */
138static int afs_parse_options(struct afs_mount_params *params,
139			     char *options, const char **devname)
140{
141	struct afs_cell *cell;
142	substring_t args[MAX_OPT_ARGS];
143	char *p;
144	int token;
145
146	_enter("%s", options);
147
148	options[PAGE_SIZE - 1] = 0;
149
150	while ((p = strsep(&options, ","))) {
151		if (!*p)
152			continue;
153
154		token = match_token(p, afs_options_list, args);
155		switch (token) {
156		case afs_opt_cell:
157			cell = afs_cell_lookup(args[0].from,
158					       args[0].to - args[0].from,
159					       false);
160			if (IS_ERR(cell))
161				return PTR_ERR(cell);
162			afs_put_cell(params->cell);
163			params->cell = cell;
164			break;
165
166		case afs_opt_rwpath:
167			params->rwpath = 1;
168			break;
169
170		case afs_opt_vol:
171			*devname = args[0].from;
172			break;
173
174		case afs_opt_autocell:
175			params->autocell = 1;
176			break;
177
178		default:
179			printk(KERN_ERR "kAFS:"
180			       " Unknown or invalid mount option: '%s'\n", p);
181			return -EINVAL;
182		}
183	}
184
185	_leave(" = 0");
186	return 0;
187}
188
189/*
190 * parse a device name to get cell name, volume name, volume type and R/W
191 * selector
192 * - this can be one of the following:
193 *	"%[cell:]volume[.]"		R/W volume
194 *	"#[cell:]volume[.]"		R/O or R/W volume (rwpath=0),
195 *					 or R/W (rwpath=1) volume
196 *	"%[cell:]volume.readonly"	R/O volume
197 *	"#[cell:]volume.readonly"	R/O volume
198 *	"%[cell:]volume.backup"		Backup volume
199 *	"#[cell:]volume.backup"		Backup volume
200 */
201static int afs_parse_device_name(struct afs_mount_params *params,
202				 const char *name)
203{
204	struct afs_cell *cell;
205	const char *cellname, *suffix;
206	int cellnamesz;
207
208	_enter(",%s", name);
209
210	if (!name) {
211		printk(KERN_ERR "kAFS: no volume name specified\n");
212		return -EINVAL;
213	}
214
215	if ((name[0] != '%' && name[0] != '#') || !name[1]) {
216		printk(KERN_ERR "kAFS: unparsable volume name\n");
217		return -EINVAL;
218	}
219
220	/* determine the type of volume we're looking for */
221	params->type = AFSVL_ROVOL;
222	params->force = false;
223	if (params->rwpath || name[0] == '%') {
224		params->type = AFSVL_RWVOL;
225		params->force = true;
226	}
227	name++;
228
229	/* split the cell name out if there is one */
230	params->volname = strchr(name, ':');
231	if (params->volname) {
232		cellname = name;
233		cellnamesz = params->volname - name;
234		params->volname++;
235	} else {
236		params->volname = name;
237		cellname = NULL;
238		cellnamesz = 0;
239	}
240
241	/* the volume type is further affected by a possible suffix */
242	suffix = strrchr(params->volname, '.');
243	if (suffix) {
244		if (strcmp(suffix, ".readonly") == 0) {
245			params->type = AFSVL_ROVOL;
246			params->force = true;
247		} else if (strcmp(suffix, ".backup") == 0) {
248			params->type = AFSVL_BACKVOL;
249			params->force = true;
250		} else if (suffix[1] == 0) {
251		} else {
252			suffix = NULL;
253		}
254	}
255
256	params->volnamesz = suffix ?
257		suffix - params->volname : strlen(params->volname);
258
259	_debug("cell %*.*s [%p]",
260	       cellnamesz, cellnamesz, cellname ?: "", params->cell);
261
262	/* lookup the cell record */
263	if (cellname || !params->cell) {
264		cell = afs_cell_lookup(cellname, cellnamesz, true);
265		if (IS_ERR(cell)) {
266			printk(KERN_ERR "kAFS: unable to lookup cell '%*.*s'\n",
267			       cellnamesz, cellnamesz, cellname ?: "");
268			return PTR_ERR(cell);
269		}
270		afs_put_cell(params->cell);
271		params->cell = cell;
272	}
273
274	_debug("CELL:%s [%p] VOLUME:%*.*s SUFFIX:%s TYPE:%d%s",
275	       params->cell->name, params->cell,
276	       params->volnamesz, params->volnamesz, params->volname,
277	       suffix ?: "-", params->type, params->force ? " FORCE" : "");
278
279	return 0;
280}
281
282/*
283 * check a superblock to see if it's the one we're looking for
284 */
285static int afs_test_super(struct super_block *sb, void *data)
286{
287	struct afs_mount_params *params = data;
288	struct afs_super_info *as = sb->s_fs_info;
289
290	return as->volume == params->volume;
291}
292
293/*
294 * fill in the superblock
295 */
296static int afs_fill_super(struct super_block *sb, void *data)
297{
298	struct afs_mount_params *params = data;
299	struct afs_super_info *as = NULL;
300	struct afs_fid fid;
301	struct dentry *root = NULL;
302	struct inode *inode = NULL;
303	int ret;
304
305	_enter("");
306
307	/* allocate a superblock info record */
308	as = kzalloc(sizeof(struct afs_super_info), GFP_KERNEL);
309	if (!as) {
310		_leave(" = -ENOMEM");
311		return -ENOMEM;
312	}
313
314	afs_get_volume(params->volume);
315	as->volume = params->volume;
316
317	/* fill in the superblock */
318	sb->s_blocksize		= PAGE_CACHE_SIZE;
319	sb->s_blocksize_bits	= PAGE_CACHE_SHIFT;
320	sb->s_magic		= AFS_FS_MAGIC;
321	sb->s_op		= &afs_super_ops;
322	sb->s_fs_info		= as;
323	sb->s_bdi		= &as->volume->bdi;
324
325	/* allocate the root inode and dentry */
326	fid.vid		= as->volume->vid;
327	fid.vnode	= 1;
328	fid.unique	= 1;
329	inode = afs_iget(sb, params->key, &fid, NULL, NULL);
330	if (IS_ERR(inode))
331		goto error_inode;
332
333	if (params->autocell)
334		set_bit(AFS_VNODE_AUTOCELL, &AFS_FS_I(inode)->flags);
335
336	ret = -ENOMEM;
337	root = d_alloc_root(inode);
338	if (!root)
339		goto error;
340
341	sb->s_root = root;
342
343	_leave(" = 0");
344	return 0;
345
346error_inode:
347	ret = PTR_ERR(inode);
348	inode = NULL;
349error:
350	iput(inode);
351	afs_put_volume(as->volume);
352	kfree(as);
353
354	sb->s_fs_info = NULL;
355
356	_leave(" = %d", ret);
357	return ret;
358}
359
360/*
361 * get an AFS superblock
362 */
363static int afs_get_sb(struct file_system_type *fs_type,
364		      int flags,
365		      const char *dev_name,
366		      void *options,
367		      struct vfsmount *mnt)
368{
369	struct afs_mount_params params;
370	struct super_block *sb;
371	struct afs_volume *vol;
372	struct key *key;
373	char *new_opts = kstrdup(options, GFP_KERNEL);
374	int ret;
375
376	_enter(",,%s,%p", dev_name, options);
377
378	memset(&params, 0, sizeof(params));
379
380	/* parse the options and device name */
381	if (options) {
382		ret = afs_parse_options(&params, options, &dev_name);
383		if (ret < 0)
384			goto error;
385	}
386
387	ret = afs_parse_device_name(&params, dev_name);
388	if (ret < 0)
389		goto error;
390
391	/* try and do the mount securely */
392	key = afs_request_key(params.cell);
393	if (IS_ERR(key)) {
394		_leave(" = %ld [key]", PTR_ERR(key));
395		ret = PTR_ERR(key);
396		goto error;
397	}
398	params.key = key;
399
400	/* parse the device name */
401	vol = afs_volume_lookup(&params);
402	if (IS_ERR(vol)) {
403		ret = PTR_ERR(vol);
404		goto error;
405	}
406	params.volume = vol;
407
408	/* allocate a deviceless superblock */
409	sb = sget(fs_type, afs_test_super, set_anon_super, &params);
410	if (IS_ERR(sb)) {
411		ret = PTR_ERR(sb);
412		goto error;
413	}
414
415	if (!sb->s_root) {
416		/* initial superblock/root creation */
417		_debug("create");
418		sb->s_flags = flags;
419		ret = afs_fill_super(sb, &params);
420		if (ret < 0) {
421			deactivate_locked_super(sb);
422			goto error;
423		}
424		save_mount_options(sb, new_opts);
425		sb->s_flags |= MS_ACTIVE;
426	} else {
427		_debug("reuse");
428		ASSERTCMP(sb->s_flags, &, MS_ACTIVE);
429	}
430
431	simple_set_mnt(mnt, sb);
432	afs_put_volume(params.volume);
433	afs_put_cell(params.cell);
434	kfree(new_opts);
435	_leave(" = 0 [%p]", sb);
436	return 0;
437
438error:
439	afs_put_volume(params.volume);
440	afs_put_cell(params.cell);
441	key_put(params.key);
442	kfree(new_opts);
443	_leave(" = %d", ret);
444	return ret;
445}
446
447/*
448 * finish the unmounting process on the superblock
449 */
450static void afs_put_super(struct super_block *sb)
451{
452	struct afs_super_info *as = sb->s_fs_info;
453
454	_enter("");
455
456	lock_kernel();
457
458	afs_put_volume(as->volume);
459
460	unlock_kernel();
461
462	_leave("");
463}
464
465/*
466 * initialise an inode cache slab element prior to any use
467 */
468static void afs_i_init_once(void *_vnode)
469{
470	struct afs_vnode *vnode = _vnode;
471
472	memset(vnode, 0, sizeof(*vnode));
473	inode_init_once(&vnode->vfs_inode);
474	init_waitqueue_head(&vnode->update_waitq);
475	mutex_init(&vnode->permits_lock);
476	mutex_init(&vnode->validate_lock);
477	spin_lock_init(&vnode->writeback_lock);
478	spin_lock_init(&vnode->lock);
479	INIT_LIST_HEAD(&vnode->writebacks);
480	INIT_LIST_HEAD(&vnode->pending_locks);
481	INIT_LIST_HEAD(&vnode->granted_locks);
482	INIT_DELAYED_WORK(&vnode->lock_work, afs_lock_work);
483	INIT_WORK(&vnode->cb_broken_work, afs_broken_callback_work);
484}
485
486/*
487 * allocate an AFS inode struct from our slab cache
488 */
489static struct inode *afs_alloc_inode(struct super_block *sb)
490{
491	struct afs_vnode *vnode;
492
493	vnode = kmem_cache_alloc(afs_inode_cachep, GFP_KERNEL);
494	if (!vnode)
495		return NULL;
496
497	atomic_inc(&afs_count_active_inodes);
498
499	memset(&vnode->fid, 0, sizeof(vnode->fid));
500	memset(&vnode->status, 0, sizeof(vnode->status));
501
502	vnode->volume		= NULL;
503	vnode->update_cnt	= 0;
504	vnode->flags		= 1 << AFS_VNODE_UNSET;
505	vnode->cb_promised	= false;
506
507	_leave(" = %p", &vnode->vfs_inode);
508	return &vnode->vfs_inode;
509}
510
511/*
512 * destroy an AFS inode struct
513 */
514static void afs_destroy_inode(struct inode *inode)
515{
516	struct afs_vnode *vnode = AFS_FS_I(inode);
517
518	_enter("%p{%x:%u}", inode, vnode->fid.vid, vnode->fid.vnode);
519
520	_debug("DESTROY INODE %p", inode);
521
522	ASSERTCMP(vnode->server, ==, NULL);
523
524	kmem_cache_free(afs_inode_cachep, vnode);
525	atomic_dec(&afs_count_active_inodes);
526}
527
528/*
529 * return information about an AFS volume
530 */
531static int afs_statfs(struct dentry *dentry, struct kstatfs *buf)
532{
533	struct afs_volume_status vs;
534	struct afs_vnode *vnode = AFS_FS_I(dentry->d_inode);
535	struct key *key;
536	int ret;
537
538	key = afs_request_key(vnode->volume->cell);
539	if (IS_ERR(key))
540		return PTR_ERR(key);
541
542	ret = afs_vnode_get_volume_status(vnode, key, &vs);
543	key_put(key);
544	if (ret < 0) {
545		_leave(" = %d", ret);
546		return ret;
547	}
548
549	buf->f_type	= dentry->d_sb->s_magic;
550	buf->f_bsize	= AFS_BLOCK_SIZE;
551	buf->f_namelen	= AFSNAMEMAX - 1;
552
553	if (vs.max_quota == 0)
554		buf->f_blocks = vs.part_max_blocks;
555	else
556		buf->f_blocks = vs.max_quota;
557	buf->f_bavail = buf->f_bfree = buf->f_blocks - vs.blocks_in_use;
558	return 0;
559}
560