Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7ed7fe5e authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs-2.6 

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs-2.6:
  [PATCH] get stack footprint of pathname resolution back to relative sanity
  [PATCH] double iput() on failure exit in hugetlb
  [PATCH] double dput() on failure exit in tiny-shmem
  [PATCH] fix up new filp allocators
  [PATCH] check for null vfsmount in dentry_open()
  [PATCH] reiserfs: eliminate private use of struct file in xattr
  [PATCH] sanitize hppfs
  hppfs pass vfsmount to dentry_open()
  [PATCH] restore export of do_kern_mount()
parents a4083c92 a02f76c3

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;