diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 22:20:36 (GMT) |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 22:20:36 (GMT) |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /fs/afs/super.c | |
download | linux-1da177e4c3f41524e886b7f1b8a0c1fc7321cac2.tar.xz |
Linux-2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
Diffstat (limited to 'fs/afs/super.c')
-rw-r--r-- | fs/afs/super.c | 441 |
1 files changed, 441 insertions, 0 deletions
diff --git a/fs/afs/super.c b/fs/afs/super.c new file mode 100644 index 0000000..d6fa8e5 --- /dev/null +++ b/fs/afs/super.c @@ -0,0 +1,441 @@ +/* + * Copyright (c) 2002 Red Hat, Inc. All rights reserved. + * + * This software may be freely redistributed under the terms of the + * GNU General Public License. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * Authors: David Howells <dhowells@redhat.com> + * David Woodhouse <dwmw2@cambridge.redhat.com> + * + */ + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/slab.h> +#include <linux/fs.h> +#include <linux/pagemap.h> +#include "vnode.h" +#include "volume.h" +#include "cell.h" +#include "cmservice.h" +#include "fsclient.h" +#include "super.h" +#include "internal.h" + +#define AFS_FS_MAGIC 0x6B414653 /* 'kAFS' */ + +struct afs_mount_params { + int rwpath; + struct afs_cell *default_cell; + struct afs_volume *volume; +}; + +static void afs_i_init_once(void *foo, kmem_cache_t *cachep, + unsigned long flags); + +static struct super_block *afs_get_sb(struct file_system_type *fs_type, + int flags, const char *dev_name, + void *data); + +static struct inode *afs_alloc_inode(struct super_block *sb); + +static void afs_put_super(struct super_block *sb); + +static void afs_destroy_inode(struct inode *inode); + +static struct file_system_type afs_fs_type = { + .owner = THIS_MODULE, + .name = "afs", + .get_sb = afs_get_sb, + .kill_sb = kill_anon_super, + .fs_flags = FS_BINARY_MOUNTDATA, +}; + +static struct super_operations afs_super_ops = { + .statfs = simple_statfs, + .alloc_inode = afs_alloc_inode, + .drop_inode = generic_delete_inode, + .destroy_inode = afs_destroy_inode, + .clear_inode = afs_clear_inode, + .put_super = afs_put_super, +}; + +static kmem_cache_t *afs_inode_cachep; +static atomic_t afs_count_active_inodes; + +/*****************************************************************************/ +/* + * initialise the filesystem + */ +int __init afs_fs_init(void) +{ + int ret; + + _enter(""); + + afs_timer_init(&afs_mntpt_expiry_timer, &afs_mntpt_expiry_timer_ops); + + /* create ourselves an inode cache */ + atomic_set(&afs_count_active_inodes, 0); + + ret = -ENOMEM; + afs_inode_cachep = kmem_cache_create("afs_inode_cache", + sizeof(struct afs_vnode), + 0, + SLAB_HWCACHE_ALIGN, + afs_i_init_once, + NULL); + if (!afs_inode_cachep) { + printk(KERN_NOTICE "kAFS: Failed to allocate inode cache\n"); + return ret; + } + + /* now export our filesystem to lesser mortals */ + ret = register_filesystem(&afs_fs_type); + if (ret < 0) { + kmem_cache_destroy(afs_inode_cachep); + kleave(" = %d", ret); + return ret; + } + + kleave(" = 0"); + return 0; +} /* end afs_fs_init() */ + +/*****************************************************************************/ +/* + * clean up the filesystem + */ +void __exit afs_fs_exit(void) +{ + unregister_filesystem(&afs_fs_type); + + if (atomic_read(&afs_count_active_inodes) != 0) { + printk("kAFS: %d active inode objects still present\n", + atomic_read(&afs_count_active_inodes)); + BUG(); + } + + kmem_cache_destroy(afs_inode_cachep); + +} /* end afs_fs_exit() */ + +/*****************************************************************************/ +/* + * check that an argument has a value + */ +static int want_arg(char **_value, const char *option) +{ + if (!_value || !*_value || !**_value) { + printk(KERN_NOTICE "kAFS: %s: argument missing\n", option); + return 0; + } + return 1; +} /* end want_arg() */ + +/*****************************************************************************/ +/* + * check that there's no subsequent value + */ +static int want_no_value(char *const *_value, const char *option) +{ + if (*_value && **_value) { + printk(KERN_NOTICE "kAFS: %s: Invalid argument: %s\n", + option, *_value); + return 0; + } + return 1; +} /* end want_no_value() */ + +/*****************************************************************************/ +/* + * parse the mount options + * - this function has been shamelessly adapted from the ext3 fs which + * shamelessly adapted it from the msdos fs + */ +static int afs_super_parse_options(struct afs_mount_params *params, + char *options, + const char **devname) +{ + char *key, *value; + int ret; + + _enter("%s", options); + + options[PAGE_SIZE - 1] = 0; + + ret = 0; + while ((key = strsep(&options, ",")) != 0) + { + value = strchr(key, '='); + if (value) + *value++ = 0; + + printk("kAFS: KEY: %s, VAL:%s\n", key, value ?: "-"); + + if (strcmp(key, "rwpath") == 0) { + if (!want_no_value(&value, "rwpath")) + return -EINVAL; + params->rwpath = 1; + continue; + } + else if (strcmp(key, "vol") == 0) { + if (!want_arg(&value, "vol")) + return -EINVAL; + *devname = value; + continue; + } + else if (strcmp(key, "cell") == 0) { + if (!want_arg(&value, "cell")) + return -EINVAL; + afs_put_cell(params->default_cell); + ret = afs_cell_lookup(value, + strlen(value), + ¶ms->default_cell); + if (ret < 0) + return -EINVAL; + continue; + } + + printk("kAFS: Unknown mount option: '%s'\n", key); + ret = -EINVAL; + goto error; + } + + ret = 0; + + error: + _leave(" = %d", ret); + return ret; +} /* end afs_super_parse_options() */ + +/*****************************************************************************/ +/* + * check a superblock to see if it's the one we're looking for + */ +static int afs_test_super(struct super_block *sb, void *data) +{ + struct afs_mount_params *params = data; + struct afs_super_info *as = sb->s_fs_info; + + return as->volume == params->volume; +} /* end afs_test_super() */ + +/*****************************************************************************/ +/* + * fill in the superblock + */ +static int afs_fill_super(struct super_block *sb, void *data, int silent) +{ + struct afs_mount_params *params = data; + struct afs_super_info *as = NULL; + struct afs_fid fid; + struct dentry *root = NULL; + struct inode *inode = NULL; + int ret; + + kenter(""); + + /* allocate a superblock info record */ + as = kmalloc(sizeof(struct afs_super_info), GFP_KERNEL); + if (!as) { + _leave(" = -ENOMEM"); + return -ENOMEM; + } + + memset(as, 0, sizeof(struct afs_super_info)); + + afs_get_volume(params->volume); + as->volume = params->volume; + + /* fill in the superblock */ + sb->s_blocksize = PAGE_CACHE_SIZE; + sb->s_blocksize_bits = PAGE_CACHE_SHIFT; + sb->s_magic = AFS_FS_MAGIC; + sb->s_op = &afs_super_ops; + sb->s_fs_info = as; + + /* allocate the root inode and dentry */ + fid.vid = as->volume->vid; + fid.vnode = 1; + fid.unique = 1; + ret = afs_iget(sb, &fid, &inode); + if (ret < 0) + goto error; + + ret = -ENOMEM; + root = d_alloc_root(inode); + if (!root) + goto error; + + sb->s_root = root; + + kleave(" = 0"); + return 0; + + error: + iput(inode); + afs_put_volume(as->volume); + kfree(as); + + sb->s_fs_info = NULL; + + kleave(" = %d", ret); + return ret; +} /* end afs_fill_super() */ + +/*****************************************************************************/ +/* + * get an AFS superblock + * - TODO: don't use get_sb_nodev(), but rather call sget() directly + */ +static struct super_block *afs_get_sb(struct file_system_type *fs_type, + int flags, + const char *dev_name, + void *options) +{ + struct afs_mount_params params; + struct super_block *sb; + int ret; + + _enter(",,%s,%p", dev_name, options); + + memset(¶ms, 0, sizeof(params)); + + /* start the cache manager */ + ret = afscm_start(); + if (ret < 0) { + _leave(" = %d", ret); + return ERR_PTR(ret); + } + + /* parse the options */ + if (options) { + ret = afs_super_parse_options(¶ms, options, &dev_name); + if (ret < 0) + goto error; + if (!dev_name) { + printk("kAFS: no volume name specified\n"); + ret = -EINVAL; + goto error; + } + } + + /* parse the device name */ + ret = afs_volume_lookup(dev_name, + params.default_cell, + params.rwpath, + ¶ms.volume); + if (ret < 0) + goto error; + + /* allocate a deviceless superblock */ + sb = sget(fs_type, afs_test_super, set_anon_super, ¶ms); + if (IS_ERR(sb)) + goto error; + + sb->s_flags = flags; + + ret = afs_fill_super(sb, ¶ms, flags & MS_VERBOSE ? 1 : 0); + if (ret < 0) { + up_write(&sb->s_umount); + deactivate_super(sb); + goto error; + } + sb->s_flags |= MS_ACTIVE; + + afs_put_volume(params.volume); + afs_put_cell(params.default_cell); + _leave(" = %p", sb); + return sb; + + error: + afs_put_volume(params.volume); + afs_put_cell(params.default_cell); + afscm_stop(); + _leave(" = %d", ret); + return ERR_PTR(ret); +} /* end afs_get_sb() */ + +/*****************************************************************************/ +/* + * finish the unmounting process on the superblock + */ +static void afs_put_super(struct super_block *sb) +{ + struct afs_super_info *as = sb->s_fs_info; + + _enter(""); + + afs_put_volume(as->volume); + afscm_stop(); + + _leave(""); +} /* end afs_put_super() */ + +/*****************************************************************************/ +/* + * initialise an inode cache slab element prior to any use + */ +static void afs_i_init_once(void *_vnode, kmem_cache_t *cachep, + unsigned long flags) +{ + struct afs_vnode *vnode = (struct afs_vnode *) _vnode; + + if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) == + SLAB_CTOR_CONSTRUCTOR) { + memset(vnode, 0, sizeof(*vnode)); + inode_init_once(&vnode->vfs_inode); + init_waitqueue_head(&vnode->update_waitq); + spin_lock_init(&vnode->lock); + INIT_LIST_HEAD(&vnode->cb_link); + INIT_LIST_HEAD(&vnode->cb_hash_link); + afs_timer_init(&vnode->cb_timeout, + &afs_vnode_cb_timed_out_ops); + } + +} /* end afs_i_init_once() */ + +/*****************************************************************************/ +/* + * allocate an AFS inode struct from our slab cache + */ +static struct inode *afs_alloc_inode(struct super_block *sb) +{ + struct afs_vnode *vnode; + + vnode = (struct afs_vnode *) + kmem_cache_alloc(afs_inode_cachep, SLAB_KERNEL); + if (!vnode) + return NULL; + + atomic_inc(&afs_count_active_inodes); + + memset(&vnode->fid, 0, sizeof(vnode->fid)); + memset(&vnode->status, 0, sizeof(vnode->status)); + + vnode->volume = NULL; + vnode->update_cnt = 0; + vnode->flags = 0; + + return &vnode->vfs_inode; +} /* end afs_alloc_inode() */ + +/*****************************************************************************/ +/* + * destroy an AFS inode struct + */ +static void afs_destroy_inode(struct inode *inode) +{ + _enter("{%lu}", inode->i_ino); + + kmem_cache_free(afs_inode_cachep, AFS_FS_I(inode)); + + atomic_dec(&afs_count_active_inodes); + +} /* end afs_destroy_inode() */ |