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

fs/anon_inodes.c

+8 −10

Original line number	Diff line number	Diff line
		@@ -81,13 +81,10 @@ int anon_inode_getfd(int pfd, struct inode pinode, struct file *pfile,

		if (IS_ERR(anon_inode_inode))
		return -ENODEV;
		file = get_empty_filp();
		if (!file)
		return -ENFILE;

		error = get_unused_fd();
		if (error < 0)
		goto err_put_filp;
		return error;
		fd = error;

		/*
		@@ -114,14 +111,15 @@ int anon_inode_getfd(int pfd, struct inode pinode, struct file *pfile,
		dentry->d_flags &= ~DCACHE_UNHASHED;
		d_instantiate(dentry, anon_inode_inode);

		file->f_path.mnt = mntget(anon_inode_mnt);
		file->f_path.dentry = dentry;
		error = -ENFILE;
		file = alloc_file(anon_inode_mnt, dentry,
		FMODE_READ \| FMODE_WRITE, fops);
		if (!file)
		goto err_dput;
		file->f_mapping = anon_inode_inode->i_mapping;

		file->f_pos = 0;
		file->f_flags = O_RDWR;
		file->f_op = fops;
		file->f_mode = FMODE_READ \| FMODE_WRITE;
		file->f_version = 0;
		file->private_data = priv;

		@@ -132,10 +130,10 @@ int anon_inode_getfd(int pfd, struct inode pinode, struct file *pfile,
		*pfile = file;
		return 0;

		err_dput:
		dput(dentry);
		err_put_unused_fd:
		put_unused_fd(fd);
		err_put_filp:
		put_filp(file);
		return error;
		}
		EXPORT_SYMBOL_GPL(anon_inode_getfd);

fs/file_table.c

+6 −0

Original line number	Diff line number	Diff line
		@@ -83,6 +83,12 @@ int proc_nr_files(ctl_table table, int write, struct file filp,
		/* Find an unused file structure and return a pointer to it.
		* Returns NULL, if there are no more free file structures or
		* we run out of memory.
		*
		* Be very careful using this. You are responsible for
		* getting write access to any mount that you might assign
		* to this filp, if it is opened for write. If this is not
		* done, you will imbalance int the mount's writer count
		* and a warning at __fput() time.
		*/
		struct file *get_empty_filp(void)
		{

fs/hppfs/hppfs_kern.c

+201 −234

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
		* Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
		* Licensed under the GPL
		*/

		#include <linux/fs.h>
		#include <linux/ctype.h>
		#include <linux/dcache.h>
		#include <linux/file.h>
		#include <linux/module.h>
		#include <linux/fs.h>
		#include <linux/init.h>
		#include <linux/slab.h>
		#include <linux/list.h>
		#include <linux/kernel.h>
		#include <linux/ctype.h>
		#include <linux/dcache.h>
		#include <linux/list.h>
		#include <linux/module.h>
		#include <linux/mount.h>
		#include <linux/slab.h>
		#include <linux/statfs.h>
		#include <linux/types.h>
		#include <asm/uaccess.h>
		#include <asm/fcntl.h>
		#include "os.h"

		static int init_inode(struct inode inode, struct dentry dentry);
		static struct inode get_inode(struct super_block , struct dentry *);

		struct hppfs_data {
		struct list_head list;
		@@ -52,13 +53,13 @@ static int is_pid(struct dentry *dentry)

		sb = dentry->d_sb;
		if ((sb->s_op != &hppfs_sbops) \|\| (dentry->d_parent != sb->s_root))
		return(0);
		return 0;

		for (i = 0; i < dentry->d_name.len; i++) {
		if (!isdigit(dentry->d_name.name[i]))
		return(0);
		return 0;
		}
		return(1);
		return 1;
		}

		static char dentry_name(struct dentry dentry, int extra)
		@@ -80,7 +81,8 @@ static char dentry_name(struct dentry dentry, int extra)
		root = "proc";
		len += strlen(root);
		name = kmalloc(len + extra + 1, GFP_KERNEL);
		if(name == NULL) return(NULL);
		if (name == NULL)
		return NULL;

		name[len] = '\0';
		parent = dentry;
		@@ -100,24 +102,22 @@ static char dentry_name(struct dentry dentry, int extra)
		parent = parent->d_parent;
		}
		strncpy(name, root, strlen(root));
		return(name);
		return name;
		}

		struct dentry_operations hppfs_dentry_ops = {
		};

		static int file_removed(struct dentry dentry, const char file)
		{
		char *host_file;
		int extra, fd;

		extra = 0;
		if(file != NULL) extra += strlen(file) + 1;
		if (file != NULL)
		extra += strlen(file) + 1;

		host_file = dentry_name(dentry, extra + strlen("/remove"));
		if (host_file == NULL) {
		printk("file_removed : allocation failed\n");
		return(-ENOMEM);
		printk(KERN_ERR "file_removed : allocation failed\n");
		return -ENOMEM;
		}

		if (file != NULL) {
		@@ -130,43 +130,9 @@ static int file_removed(struct dentry dentry, const char file)
		kfree(host_file);
		if (fd > 0) {
		os_close_file(fd);
		return(1);
		}
		return(0);
		}

		static void hppfs_read_inode(struct inode *ino)
		{
		struct inode *proc_ino;

		if(HPPFS_I(ino)->proc_dentry == NULL)
		return;

		proc_ino = HPPFS_I(ino)->proc_dentry->d_inode;
		ino->i_uid = proc_ino->i_uid;
		ino->i_gid = proc_ino->i_gid;
		ino->i_atime = proc_ino->i_atime;
		ino->i_mtime = proc_ino->i_mtime;
		ino->i_ctime = proc_ino->i_ctime;
		ino->i_ino = proc_ino->i_ino;
		ino->i_mode = proc_ino->i_mode;
		ino->i_nlink = proc_ino->i_nlink;
		ino->i_size = proc_ino->i_size;
		ino->i_blocks = proc_ino->i_blocks;
		}

		static struct inode hppfs_iget(struct super_block sb)
		{
		struct inode *inode;

		inode = iget_locked(sb, 0);
		if (!inode)
		return ERR_PTR(-ENOMEM);
		if (inode->i_state & I_NEW) {
		hppfs_read_inode(inode);
		unlock_new_inode(inode);
		return 1;
		}
		return inode;
		return 0;
		}

		static struct dentry hppfs_lookup(struct inode ino, struct dentry *dentry,
		@@ -178,9 +144,9 @@ static struct dentry hppfs_lookup(struct inode ino, struct dentry *dentry,

		deleted = file_removed(dentry, NULL);
		if (deleted < 0)
		return(ERR_PTR(deleted));
		return ERR_PTR(deleted);
		else if (deleted)
		return(ERR_PTR(-ENOENT));
		return ERR_PTR(-ENOENT);

		err = -ENOMEM;
		parent = HPPFS_I(ino)->proc_dentry;
		@@ -202,30 +168,20 @@ static struct dentry hppfs_lookup(struct inode ino, struct dentry *dentry,
		mutex_unlock(&parent->d_inode->i_mutex);

		if (IS_ERR(proc_dentry))
		return(proc_dentry);
		return proc_dentry;

		inode = hppfs_iget(ino->i_sb);
		if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
		err = -ENOMEM;
		inode = get_inode(ino->i_sb, proc_dentry);
		if (!inode)
		goto out_dput;
		}

		err = init_inode(inode, proc_dentry);
		if(err)
		goto out_put;

		hppfs_read_inode(inode);

		d_add(dentry, inode);
		dentry->d_op = &hppfs_dentry_ops;
		return(NULL);
		return NULL;

		out_put:
		iput(inode);
		out_dput:
		dput(proc_dentry);
		out:
		return(ERR_PTR(err));
		return ERR_PTR(err);
		}

		static const struct inode_operations hppfs_file_iops = {
		@@ -247,7 +203,8 @@ static ssize_t read_proc(struct file file, char __user buf, ssize_t count,
		if (!is_user)
		set_fs(USER_DS);

		if(ppos) *ppos = file->f_pos;
		if (ppos)
		*ppos = file->f_pos;
		return n;
		}

		@@ -260,7 +217,7 @@ static ssize_t hppfs_read_file(int fd, char __user *buf, ssize_t count)
		n = -ENOMEM;
		new_buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
		if (new_buf == NULL) {
		printk("hppfs_read_file : kmalloc failed\n");
		printk(KERN_ERR "hppfs_read_file : kmalloc failed\n");
		goto out;
		}
		n = 0;
		@@ -268,12 +225,11 @@ static ssize_t hppfs_read_file(int fd, char __user *buf, ssize_t count)
		cur = min_t(ssize_t, count, PAGE_SIZE);
		err = os_read_file(fd, new_buf, cur);
		if (err < 0) {
		printk("hppfs_read : read failed, errno = %d\n",
		err);
		printk(KERN_ERR "hppfs_read : read failed, "
		"errno = %d\n", err);
		n = err;
		goto out_free;
		}
		else if(err == 0)
		} else if (err == 0)
		break;

		if (copy_to_user(buf, new_buf, err)) {
		@@ -298,7 +254,8 @@ static ssize_t hppfs_read(struct file file, char __user buf, size_t count,
		int err;

		if (hppfs->contents != NULL) {
		if(*ppos >= hppfs->len) return(0);
		if (*ppos >= hppfs->len)
		return 0;

		data = hppfs->contents;
		off = *ppos;
		@@ -312,12 +269,12 @@ static ssize_t hppfs_read(struct file file, char __user buf, size_t count,
		count = hppfs->len - off;
		copy_to_user(buf, &data->contents[off], count);
		*ppos += count;
		}
		else if(hppfs->host_fd != -1){
		} else if (hppfs->host_fd != -1) {
		err = os_seek_file(hppfs->host_fd, *ppos);
		if (err) {
		printk("hppfs_read : seek failed, errno = %d\n", err);
		return(err);
		printk(KERN_ERR "hppfs_read : seek failed, "
		"errno = %d\n", err);
		return err;
		}
		count = hppfs_read_file(hppfs->host_fd, buf, count);
		if (count > 0)
		@@ -325,7 +282,7 @@ static ssize_t hppfs_read(struct file file, char __user buf, size_t count,
		}
		else count = read_proc(hppfs->proc_file, buf, count, ppos, 1);

		return(count);
		return count;
		}

		static ssize_t hppfs_write(struct file file, const char __user buf, size_t len,
		@@ -342,7 +299,7 @@ static ssize_t hppfs_write(struct file file, const char __user buf, size_t len
		err = (*write)(proc_file, buf, len, &proc_file->f_pos);
		file->f_pos = proc_file->f_pos;

		return(err);
		return err;
		}

		static int open_host_sock(char host_file, int filter_out)
		@@ -355,12 +312,12 @@ static int open_host_sock(char host_file, int filter_out)
		*filter_out = 1;
		fd = os_connect_socket(host_file);
		if (fd > 0)
		return(fd);
		return fd;

		strcpy(end, "/r");
		*filter_out = 0;
		fd = os_connect_socket(host_file);
		return(fd);
		return fd;
		}

		static void free_contents(struct hppfs_data *head)
		@@ -368,7 +325,8 @@ static void free_contents(struct hppfs_data *head)
		struct hppfs_data *data;
		struct list_head ele, next;

		if(head == NULL) return;
		if (head == NULL)
		return;

		list_for_each_safe(ele, next, &head->list) {
		data = list_entry(ele, struct hppfs_data, list);
		@@ -388,7 +346,7 @@ static struct hppfs_data *hppfs_get_data(int fd, int filter,
		err = -ENOMEM;
		data = kmalloc(sizeof(*data), GFP_KERNEL);
		if (data == NULL) {
		printk("hppfs_get_data : head allocation failed\n");
		printk(KERN_ERR "hppfs_get_data : head allocation failed\n");
		goto failed;
		}

		@@ -403,7 +361,7 @@ static struct hppfs_data *hppfs_get_data(int fd, int filter,
		os_write_file(fd, data->contents, n);
		err = os_shutdown_socket(fd, 0, 1);
		if (err) {
		printk("hppfs_get_data : failed to shut down "
		printk(KERN_ERR "hppfs_get_data : failed to shut down "
		"socket\n");
		goto failed_free;
		}
		@@ -412,11 +370,10 @@ static struct hppfs_data *hppfs_get_data(int fd, int filter,
		n = os_read_file(fd, data->contents, sizeof(data->contents));
		if (n < 0) {
		err = n;
		printk("hppfs_get_data : read failed, errno = %d\n",
		err);
		printk(KERN_ERR "hppfs_get_data : read failed, "
		"errno = %d\n", err);
		goto failed_free;
		}
		else if(n == 0)
		} else if (n == 0)
		break;

		*size_out += n;
		@@ -426,7 +383,8 @@ static struct hppfs_data *hppfs_get_data(int fd, int filter,

		new = kmalloc(sizeof(*data), GFP_KERNEL);
		if (new == 0) {
		printk("hppfs_get_data : data allocation failed\n");
		printk(KERN_ERR "hppfs_get_data : data allocation "
		"failed\n");
		err = -ENOMEM;
		goto failed_free;
		}
		@@ -435,12 +393,12 @@ static struct hppfs_data *hppfs_get_data(int fd, int filter,
		list_add(&new->list, &data->list);
		data = new;
		}
		return(head);
		return head;

		failed_free:
		free_contents(head);
		failed:
		return(ERR_PTR(err));
		return ERR_PTR(err);
		}

		static struct hppfs_private *hppfs_data(void)
		@@ -449,29 +407,30 @@ static struct hppfs_private *hppfs_data(void)

		data = kmalloc(sizeof(*data), GFP_KERNEL);
		if (data == NULL)
		return(data);
		return data;

		*data = ((struct hppfs_private ) { .host_fd = -1,
		.len = -1,
		.contents = NULL } );
		return(data);
		return data;
		}

		static int file_mode(int fmode)
		{
		if (fmode == (FMODE_READ \| FMODE_WRITE))
		return(O_RDWR);
		return O_RDWR;
		if (fmode == FMODE_READ)
		return(O_RDONLY);
		return O_RDONLY;
		if (fmode == FMODE_WRITE)
		return(O_WRONLY);
		return(0);
		return O_WRONLY;
		return 0;
		}

		static int hppfs_open(struct inode inode, struct file file)
		{
		struct hppfs_private *data;
		struct dentry *proc_dentry;
		struct vfsmount *proc_mnt;
		char *host_file;
		int err, fd, type, filter;

		@@ -485,9 +444,10 @@ static int hppfs_open(struct inode inode, struct file file)
		goto out_free2;

		proc_dentry = HPPFS_I(inode)->proc_dentry;
		proc_mnt = inode->i_sb->s_fs_info;

		/* XXX This isn't closed anywhere */
		data->proc_file = dentry_open(dget(proc_dentry), NULL,
		data->proc_file = dentry_open(dget(proc_dentry), mntget(proc_mnt),
		file_mode(file->f_mode));
		err = PTR_ERR(data->proc_file);
		if (IS_ERR(data->proc_file))
		@@ -498,12 +458,12 @@ static int hppfs_open(struct inode inode, struct file file)
		fd = os_open_file(host_file, of_read(OPENFLAGS()), 0);
		if (fd >= 0)
		data->host_fd = fd;
		else printk("hppfs_open : failed to open '%s', errno = %d\n",
		host_file, -fd);
		else
		printk(KERN_ERR "hppfs_open : failed to open '%s', "
		"errno = %d\n", host_file, -fd);

		data->contents = NULL;
		}
		else if(type == OS_TYPE_DIR){
		} else if (type == OS_TYPE_DIR) {
		fd = open_host_sock(host_file, &filter);
		if (fd > 0) {
		data->contents = hppfs_get_data(fd, filter,
		@@ -511,14 +471,14 @@ static int hppfs_open(struct inode inode, struct file file)
		file, &data->len);
		if (!IS_ERR(data->contents))
		data->host_fd = fd;
		}
		else printk("hppfs_open : failed to open a socket in "
		"'%s', errno = %d\n", host_file, -fd);
		} else
		printk(KERN_ERR "hppfs_open : failed to open a socket "
		"in '%s', errno = %d\n", host_file, -fd);
		}
		kfree(host_file);

		file->private_data = data;
		return(0);
		return 0;

		out_free1:
		kfree(host_file);
		@@ -526,13 +486,14 @@ static int hppfs_open(struct inode inode, struct file file)
		free_contents(data->contents);
		kfree(data);
		out:
		return(err);
		return err;
		}

		static int hppfs_dir_open(struct inode inode, struct file file)
		{
		struct hppfs_private *data;
		struct dentry *proc_dentry;
		struct vfsmount *proc_mnt;
		int err;

		err = -ENOMEM;
		@@ -541,19 +502,20 @@ static int hppfs_dir_open(struct inode inode, struct file file)
		goto out;

		proc_dentry = HPPFS_I(inode)->proc_dentry;
		data->proc_file = dentry_open(dget(proc_dentry), NULL,
		proc_mnt = inode->i_sb->s_fs_info;
		data->proc_file = dentry_open(dget(proc_dentry), mntget(proc_mnt),
		file_mode(file->f_mode));
		err = PTR_ERR(data->proc_file);
		if (IS_ERR(data->proc_file))
		goto out_free;

		file->private_data = data;
		return(0);
		return 0;

		out_free:
		kfree(data);
		out:
		return(err);
		return err;
		}

		static loff_t hppfs_llseek(struct file *file, loff_t off, int where)
		@@ -567,10 +529,10 @@ static loff_t hppfs_llseek(struct file *file, loff_t off, int where)
		if (llseek != NULL) {
		ret = (*llseek)(proc_file, off, where);
		if (ret < 0)
		return(ret);
		return ret;
		}

		return(default_llseek(file, off, where));
		return default_llseek(file, off, where);
		}

		static const struct file_operations hppfs_file_fops = {
		@@ -593,10 +555,10 @@ static int hppfs_filldir(void d, const char name, int size,
		struct hppfs_dirent *dirent = d;

		if (file_removed(dirent->dentry, name))
		return(0);
		return 0;

		return((*dirent->filldir)(dirent->vfs_dirent, name, size, offset,
		inode, type));
		return (*dirent->filldir)(dirent->vfs_dirent, name, size, offset,
		inode, type);
		}

		static int hppfs_readdir(struct file file, void ent, filldir_t filldir)
		@@ -607,7 +569,8 @@ static int hppfs_readdir(struct file file, void ent, filldir_t filldir)
		struct hppfs_dirent dirent = ((struct hppfs_dirent)
		{ .vfs_dirent = ent,
		.filldir = filldir,
		.dentry = file->f_path.dentry } );
		.dentry = file->f_path.dentry
		});
		int err;

		readdir = proc_file->f_path.dentry->d_inode->i_fop->readdir;
		@@ -616,12 +579,12 @@ static int hppfs_readdir(struct file file, void ent, filldir_t filldir)
		err = (*readdir)(proc_file, &dirent, hppfs_filldir);
		file->f_pos = proc_file->f_pos;

		return(err);
		return err;
		}

		static int hppfs_fsync(struct file file, struct dentry dentry, int datasync)
		{
		return(0);
		return 0;
		}

		static const struct file_operations hppfs_dir_fops = {
		@@ -639,7 +602,7 @@ static int hppfs_statfs(struct dentry dentry, struct kstatfs sf)
		sf->f_files = 0;
		sf->f_ffree = 0;
		sf->f_type = HPPFS_SUPER_MAGIC;
		return(0);
		return 0;
		}

		static struct inode hppfs_alloc_inode(struct super_block sb)
		@@ -647,12 +610,12 @@ static struct inode hppfs_alloc_inode(struct super_block sb)
		struct hppfs_inode_info *hi;

		hi = kmalloc(sizeof(*hi), GFP_KERNEL);
		if(hi == NULL)
		return(NULL);
		if (!hi)
		return NULL;

		*hi = ((struct hppfs_inode_info) { .proc_dentry = NULL });
		hi->proc_dentry = NULL;
		inode_init_once(&hi->vfs_inode);
		return(&hi->vfs_inode);
		return &hi->vfs_inode;
		}

		void hppfs_delete_inode(struct inode *ino)
		@@ -665,21 +628,31 @@ static void hppfs_destroy_inode(struct inode *inode)
		kfree(HPPFS_I(inode));
		}

		static void hppfs_put_super(struct super_block *sb)
		{
		mntput(sb->s_fs_info);
		}

		static const struct super_operations hppfs_sbops = {
		.alloc_inode = hppfs_alloc_inode,
		.destroy_inode = hppfs_destroy_inode,
		.delete_inode = hppfs_delete_inode,
		.statfs = hppfs_statfs,
		.put_super = hppfs_put_super,
		};

		static int hppfs_readlink(struct dentry dentry, char __user buffer, int buflen)
		static int hppfs_readlink(struct dentry dentry, char __user buffer,
		int buflen)
		{
		struct file *proc_file;
		struct dentry *proc_dentry;
		struct vfsmount *proc_mnt;
		int ret;

		proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry;
		proc_file = dentry_open(dget(proc_dentry), NULL, O_RDONLY);
		proc_mnt = dentry->d_sb->s_fs_info;

		proc_file = dentry_open(dget(proc_dentry), mntget(proc_mnt), O_RDONLY);
		if (IS_ERR(proc_file))
		return PTR_ERR(proc_file);

		@@ -694,10 +667,13 @@ static void* hppfs_follow_link(struct dentry dentry, struct nameidata nd)
		{
		struct file *proc_file;
		struct dentry *proc_dentry;
		struct vfsmount *proc_mnt;
		void *ret;

		proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry;
		proc_file = dentry_open(dget(proc_dentry), NULL, O_RDONLY);
		proc_mnt = dentry->d_sb->s_fs_info;

		proc_file = dentry_open(dget(proc_dentry), mntget(proc_mnt), O_RDONLY);
		if (IS_ERR(proc_file))
		return proc_file;

		@@ -717,70 +693,72 @@ static const struct inode_operations hppfs_link_iops = {
		.follow_link = hppfs_follow_link,
		};

		static int init_inode(struct inode inode, struct dentry dentry)
		static struct inode get_inode(struct super_block sb, struct dentry *dentry)
		{
		struct inode *proc_ino = dentry->d_inode;
		struct inode *inode = new_inode(sb);

		if (!inode)
		return ERR_PTR(-ENOMEM);

		if (S_ISDIR(dentry->d_inode->i_mode)) {
		inode->i_op = &hppfs_dir_iops;
		inode->i_fop = &hppfs_dir_fops;
		}
		else if(S_ISLNK(dentry->d_inode->i_mode)){
		} else if (S_ISLNK(dentry->d_inode->i_mode)) {
		inode->i_op = &hppfs_link_iops;
		inode->i_fop = &hppfs_file_fops;
		}
		else {
		} else {
		inode->i_op = &hppfs_file_iops;
		inode->i_fop = &hppfs_file_fops;
		}

		HPPFS_I(inode)->proc_dentry = dentry;

		return(0);
		inode->i_uid = proc_ino->i_uid;
		inode->i_gid = proc_ino->i_gid;
		inode->i_atime = proc_ino->i_atime;
		inode->i_mtime = proc_ino->i_mtime;
		inode->i_ctime = proc_ino->i_ctime;
		inode->i_ino = proc_ino->i_ino;
		inode->i_mode = proc_ino->i_mode;
		inode->i_nlink = proc_ino->i_nlink;
		inode->i_size = proc_ino->i_size;
		inode->i_blocks = proc_ino->i_blocks;

		return 0;
		}

		static int hppfs_fill_super(struct super_block sb, void d, int silent)
		{
		struct inode *root_inode;
		struct file_system_type *procfs;
		struct super_block *proc_sb;
		int err;
		struct vfsmount *proc_mnt;
		int err = -ENOENT;

		err = -ENOENT;
		procfs = get_fs_type("proc");
		if(procfs == NULL)
		proc_mnt = do_kern_mount("proc", 0, "proc", NULL);
		if (IS_ERR(proc_mnt))
		goto out;

		if(list_empty(&procfs->fs_supers))
		goto out;

		proc_sb = list_entry(procfs->fs_supers.next, struct super_block,
		s_instances);

		sb->s_blocksize = 1024;
		sb->s_blocksize_bits = 10;
		sb->s_magic = HPPFS_SUPER_MAGIC;
		sb->s_op = &hppfs_sbops;

		root_inode = hppfs_iget(sb);
		if (IS_ERR(root_inode)) {
		err = PTR_ERR(root_inode);
		goto out;
		}

		err = init_inode(root_inode, proc_sb->s_root);
		if(err)
		goto out_put;
		sb->s_fs_info = proc_mnt;

		err = -ENOMEM;
		sb->s_root = d_alloc_root(root_inode);
		if(sb->s_root == NULL)
		goto out_put;
		root_inode = get_inode(sb, proc_mnt->mnt_sb->s_root);
		if (!root_inode)
		goto out_mntput;

		hppfs_read_inode(root_inode);
		sb->s_root = d_alloc_root(root_inode);
		if (!sb->s_root)
		goto out_iput;

		return(0);
		return 0;

		out_put:
		out_iput:
		iput(root_inode);
		out_mntput:
		mntput(proc_mnt);
		out:
		return(err);
		}
		@@ -802,7 +780,7 @@ static struct file_system_type hppfs_type = {

		static int __init init_hppfs(void)
		{
		return(register_filesystem(&hppfs_type));
		return register_filesystem(&hppfs_type);
		}

		static void __exit exit_hppfs(void)
		@@ -813,14 +791,3 @@ static void __exit exit_hppfs(void)
		module_init(init_hppfs)
		module_exit(exit_hppfs)
		MODULE_LICENSE("GPL");

		/*
		* Overrides for Emacs so that we follow Linus's tabbing style.
		* Emacs will notice this stuff at the end of the file and automatically
		* adjust the settings for this buffer only. This must remain at the end
		* of the file.
		* ---------------------------------------------------------------------------
		* Local variables:
		* c-file-style: "linux"
		* End:
		*/

fs/hugetlbfs/inode.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -954,7 +954,7 @@ struct file hugetlb_file_setup(const char name, size_t size)
		FMODE_WRITE \| FMODE_READ,
		&hugetlbfs_file_operations);
		if (!file)
		goto out_inode;
		goto out_dentry; /* inode is already attached */

		return file;

fs/namei.c

+32 −31

Original line number	Diff line number	Diff line
		@@ -106,7 +106,7 @@
		* any extra contention...
		*/

		static int link_path_walk(const char name, struct nameidata nd);
		static int __link_path_walk(const char name, struct nameidata nd);

		/* In order to reduce some races, while at the same time doing additional
		* checking and hopefully speeding things up, we copy filenames to the
		@@ -563,6 +563,37 @@ walk_init_root(const char name, struct nameidata nd)
		return 1;
		}

		/*
		* Wrapper to retry pathname resolution whenever the underlying
		* file system returns an ESTALE.
		*
		* Retry the whole path once, forcing real lookup requests
		* instead of relying on the dcache.
		*/
		static __always_inline int link_path_walk(const char name, struct nameidata nd)
		{
		struct path save = nd->path;
		int result;

		/* make sure the stuff we saved doesn't go away */
		dget(save.dentry);
		mntget(save.mnt);

		result = __link_path_walk(name, nd);
		if (result == -ESTALE) {
		/* nd->path had been dropped */
		nd->path = save;
		dget(nd->path.dentry);
		mntget(nd->path.mnt);
		nd->flags \|= LOOKUP_REVAL;
		result = __link_path_walk(name, nd);
		}

		path_put(&save);

		return result;
		}

		static __always_inline int __vfs_follow_link(struct nameidata nd, const char link)
		{
		int res = 0;
		@@ -1020,36 +1051,6 @@ return_err:
		return err;
		}

		/*
		* Wrapper to retry pathname resolution whenever the underlying
		* file system returns an ESTALE.
		*
		* Retry the whole path once, forcing real lookup requests
		* instead of relying on the dcache.
		*/
		static int link_path_walk(const char name, struct nameidata nd)
		{
		struct nameidata save = *nd;
		int result;

		/* make sure the stuff we saved doesn't go away */
		dget(save.path.dentry);
		mntget(save.path.mnt);

		result = __link_path_walk(name, nd);
		if (result == -ESTALE) {
		*nd = save;
		dget(nd->path.dentry);
		mntget(nd->path.mnt);
		nd->flags \|= LOOKUP_REVAL;
		result = __link_path_walk(name, nd);
		}

		path_put(&save.path);

		return result;
		}

		static int path_walk(const char name, struct nameidata nd)
		{
		current->total_link_count = 0;

Admin message