Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs-2.6 (8dac6bee) · Commits · 戴 / test

fs/afs/dir.c

+4 −4

Original line number	Diff line number	Diff line
		@@ -584,11 +584,11 @@ static struct dentry afs_lookup(struct inode dir, struct dentry *dentry,

		success:
		d_add(dentry, inode);
		_leave(" = 0 { vn=%u u=%u } -> { ino=%lu v=%llu }",
		_leave(" = 0 { vn=%u u=%u } -> { ino=%lu v=%u }",
		fid.vnode,
		fid.unique,
		dentry->d_inode->i_ino,
		(unsigned long long)dentry->d_inode->i_version);
		dentry->d_inode->i_generation);

		return NULL;
		}
		@@ -671,10 +671,10 @@ static int afs_d_revalidate(struct dentry dentry, struct nameidata nd)
		* been deleted and replaced, and the original vnode ID has
		* been reused */
		if (fid.unique != vnode->fid.unique) {
		_debug("%s: file deleted (uq %u -> %u I:%llu)",
		_debug("%s: file deleted (uq %u -> %u I:%u)",
		dentry->d_name.name, fid.unique,
		vnode->fid.unique,
		(unsigned long long)dentry->d_inode->i_version);
		dentry->d_inode->i_generation);
		spin_lock(&vnode->lock);
		set_bit(AFS_VNODE_DELETED, &vnode->flags);
		spin_unlock(&vnode->lock);

fs/afs/fsclient.c

+2 −1

Original line number	Diff line number	Diff line
		@@ -89,7 +89,7 @@ static void xdr_decode_AFSFetchStatus(const __be32 **_bp,
		i_size_write(&vnode->vfs_inode, size);
		vnode->vfs_inode.i_uid = status->owner;
		vnode->vfs_inode.i_gid = status->group;
		vnode->vfs_inode.i_version = vnode->fid.unique;
		vnode->vfs_inode.i_generation = vnode->fid.unique;
		vnode->vfs_inode.i_nlink = status->nlink;

		mode = vnode->vfs_inode.i_mode;
		@@ -102,6 +102,7 @@ static void xdr_decode_AFSFetchStatus(const __be32 **_bp,
		vnode->vfs_inode.i_ctime.tv_sec = status->mtime_server;
		vnode->vfs_inode.i_mtime = vnode->vfs_inode.i_ctime;
		vnode->vfs_inode.i_atime = vnode->vfs_inode.i_ctime;
		vnode->vfs_inode.i_version = data_version;
		}

		expected_version = status->data_version;

fs/afs/inode.c

+5 −5

Original line number	Diff line number	Diff line
		@@ -75,7 +75,8 @@ static int afs_inode_map_status(struct afs_vnode vnode, struct key key)
		inode->i_ctime.tv_nsec = 0;
		inode->i_atime = inode->i_mtime = inode->i_ctime;
		inode->i_blocks = 0;
		inode->i_version = vnode->fid.unique;
		inode->i_generation = vnode->fid.unique;
		inode->i_version = vnode->status.data_version;
		inode->i_mapping->a_ops = &afs_fs_aops;

		/* check to see whether a symbolic link is really a mountpoint */
		@@ -100,7 +101,7 @@ static int afs_iget5_test(struct inode inode, void opaque)
		struct afs_iget_data *data = opaque;

		return inode->i_ino == data->fid.vnode &&
		inode->i_version == data->fid.unique;
		inode->i_generation == data->fid.unique;
		}

		/*
		@@ -122,7 +123,7 @@ static int afs_iget5_set(struct inode inode, void opaque)
		struct afs_vnode *vnode = AFS_FS_I(inode);

		inode->i_ino = data->fid.vnode;
		inode->i_version = data->fid.unique;
		inode->i_generation = data->fid.unique;
		vnode->fid = data->fid;
		vnode->volume = data->volume;

		@@ -380,8 +381,7 @@ int afs_getattr(struct vfsmount mnt, struct dentry dentry,

		inode = dentry->d_inode;

		_enter("{ ino=%lu v=%llu }", inode->i_ino,
		(unsigned long long)inode->i_version);
		_enter("{ ino=%lu v=%u }", inode->i_ino, inode->i_generation);

		generic_fillattr(inode, stat);
		return 0;

fs/afs/super.c

+33 −41

Original line number	Diff line number	Diff line
		@@ -31,8 +31,8 @@
		static void afs_i_init_once(void *foo);
		static struct dentry afs_mount(struct file_system_type fs_type,
		int flags, const char dev_name, void data);
		static void afs_kill_super(struct super_block *sb);
		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 int afs_statfs(struct dentry dentry, struct kstatfs buf);

		@@ -40,7 +40,7 @@ struct file_system_type afs_fs_type = {
		.owner = THIS_MODULE,
		.name = "afs",
		.mount = afs_mount,
		.kill_sb = kill_anon_super,
		.kill_sb = afs_kill_super,
		.fs_flags = 0,
		};

		@@ -50,7 +50,6 @@ static const struct super_operations afs_super_ops = {
		.drop_inode = afs_drop_inode,
		.destroy_inode = afs_destroy_inode,
		.evict_inode = afs_evict_inode,
		.put_super = afs_put_super,
		.show_options = generic_show_options,
		};

		@@ -282,19 +281,25 @@ static int afs_parse_device_name(struct afs_mount_params *params,
		*/
		static int afs_test_super(struct super_block sb, void data)
		{
		struct afs_mount_params *params = data;
		struct afs_super_info *as1 = data;
		struct afs_super_info *as = sb->s_fs_info;

		return as->volume == params->volume;
		return as->volume == as1->volume;
		}

		static int afs_set_super(struct super_block sb, void data)
		{
		sb->s_fs_info = data;
		return set_anon_super(sb, NULL);
		}

		/*
		* fill in the superblock
		*/
		static int afs_fill_super(struct super_block sb, void data)
		static int afs_fill_super(struct super_block *sb,
		struct afs_mount_params *params)
		{
		struct afs_mount_params *params = data;
		struct afs_super_info *as = NULL;
		struct afs_super_info *as = sb->s_fs_info;
		struct afs_fid fid;
		struct dentry *root = NULL;
		struct inode *inode = NULL;
		@@ -302,23 +307,13 @@ static int afs_fill_super(struct super_block sb, void data)

		_enter("");

		/* allocate a superblock info record */
		as = kzalloc(sizeof(struct afs_super_info), GFP_KERNEL);
		if (!as) {
		_leave(" = -ENOMEM");
		return -ENOMEM;
		}

		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;
		sb->s_bdi = &as->volume->bdi;
		strlcpy(sb->s_id, as->volume->vlocation->vldb.name, sizeof(sb->s_id));

		/* allocate the root inode and dentry */
		fid.vid = as->volume->vid;
		@@ -326,7 +321,7 @@ static int afs_fill_super(struct super_block sb, void data)
		fid.unique = 1;
		inode = afs_iget(sb, params->key, &fid, NULL, NULL);
		if (IS_ERR(inode))
		goto error_inode;
		return PTR_ERR(inode);

		if (params->autocell)
		set_bit(AFS_VNODE_AUTOCELL, &AFS_FS_I(inode)->flags);
		@@ -342,16 +337,8 @@ static int afs_fill_super(struct super_block sb, void data)
		_leave(" = 0");
		return 0;

		error_inode:
		ret = PTR_ERR(inode);
		inode = NULL;
		error:
		iput(inode);
		afs_put_volume(as->volume);
		kfree(as);

		sb->s_fs_info = NULL;

		_leave(" = %d", ret);
		return ret;
		}
		@@ -367,6 +354,7 @@ static struct dentry afs_mount(struct file_system_type fs_type,
		struct afs_volume *vol;
		struct key *key;
		char *new_opts = kstrdup(options, GFP_KERNEL);
		struct afs_super_info *as;
		int ret;

		_enter(",,%s,%p", dev_name, options);
		@@ -399,12 +387,22 @@ static struct dentry afs_mount(struct file_system_type fs_type,
		ret = PTR_ERR(vol);
		goto error;
		}
		params.volume = vol;

		/* allocate a superblock info record */
		as = kzalloc(sizeof(struct afs_super_info), GFP_KERNEL);
		if (!as) {
		ret = -ENOMEM;
		afs_put_volume(vol);
		goto error;
		}
		as->volume = vol;

		/* allocate a deviceless superblock */
		sb = sget(fs_type, afs_test_super, set_anon_super, &params);
		sb = sget(fs_type, afs_test_super, afs_set_super, as);
		if (IS_ERR(sb)) {
		ret = PTR_ERR(sb);
		afs_put_volume(vol);
		kfree(as);
		goto error;
		}

		@@ -422,16 +420,16 @@ static struct dentry afs_mount(struct file_system_type fs_type,
		} else {
		_debug("reuse");
		ASSERTCMP(sb->s_flags, &, MS_ACTIVE);
		afs_put_volume(vol);
		kfree(as);
		}

		afs_put_volume(params.volume);
		afs_put_cell(params.cell);
		kfree(new_opts);
		_leave(" = 0 [%p]", sb);
		return dget(sb->s_root);

		error:
		afs_put_volume(params.volume);
		afs_put_cell(params.cell);
		key_put(params.key);
		kfree(new_opts);
		@@ -439,18 +437,12 @@ error:
		return ERR_PTR(ret);
		}

		/*
		* finish the unmounting process on the superblock
		*/
		static void afs_put_super(struct super_block *sb)
		static void afs_kill_super(struct super_block *sb)
		{
		struct afs_super_info *as = sb->s_fs_info;

		_enter("");

		kill_anon_super(sb);
		afs_put_volume(as->volume);

		_leave("");
		kfree(as);
		}

		/*

fs/afs/write.c

+9 −12

Original line number	Diff line number	Diff line
		@@ -84,23 +84,21 @@ void afs_put_writeback(struct afs_writeback *wb)
		* partly or wholly fill a page that's under preparation for writing
		*/
		static int afs_fill_page(struct afs_vnode vnode, struct key key,
		loff_t pos, unsigned len, struct page *page)
		loff_t pos, struct page *page)
		{
		loff_t i_size;
		unsigned eof;
		int ret;
		int len;

		_enter(",,%llu,%u", (unsigned long long)pos, len);

		ASSERTCMP(len, <=, PAGE_CACHE_SIZE);
		_enter(",,%llu", (unsigned long long)pos);

		i_size = i_size_read(&vnode->vfs_inode);
		if (pos + len > i_size)
		eof = i_size;
		if (pos + PAGE_CACHE_SIZE > i_size)
		len = i_size - pos;
		else
		eof = PAGE_CACHE_SIZE;
		len = PAGE_CACHE_SIZE;

		ret = afs_vnode_fetch_data(vnode, key, 0, eof, page);
		ret = afs_vnode_fetch_data(vnode, key, pos, len, page);
		if (ret < 0) {
		if (ret == -ENOENT) {
		_debug("got NOENT from server"
		@@ -153,9 +151,8 @@ int afs_write_begin(struct file file, struct address_space mapping,
		*pagep = page;
		/* page won't leak in error case: it eventually gets cleaned off LRU */

		if (!PageUptodate(page)) {
		_debug("not up to date");
		ret = afs_fill_page(vnode, key, pos, len, page);
		if (!PageUptodate(page) && len != PAGE_CACHE_SIZE) {
		ret = afs_fill_page(vnode, key, index << PAGE_CACHE_SHIFT, page);
		if (ret < 0) {
		kfree(candidate);
		_leave(" = %d [prep]", ret);

Admin message