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

Commit 3e93cd67 authored by Al Viro's avatar Al Viro
Browse files

Take fs_struct handling to new file (fs/fs_struct.c) 



Pure code move; two new helper functions for nfsd and daemonize
(unshare_fs_struct() and daemonize_fs_struct() resp.; for now -
the same code as used to be in callers).  unshare_fs_struct()
exported (for nfsd, as copy_fs_struct()/exit_fs() used to be),
copy_fs_struct() and exit_fs() don't need exports anymore.

Signed-off-by: default avatarAl Viro <viro@zeniv.linux.org.uk>
parent f8ef3ed2

fs/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -11,7 +11,7 @@ obj-y := open.o read_write.o file_table.o super.o \ 
		attr.o bad_inode.o file.o filesystems.o namespace.o \

		seq_file.o xattr.o libfs.o fs-writeback.o \

		pnode.o drop_caches.o splice.o sync.o utimes.o \

		stack.o

		stack.o fs_struct.o



ifeq ($(CONFIG_BLOCK),y)

obj-y +=	buffer.o bio.o block_dev.o direct-io.o mpage.o ioprio.o

fs/fs_struct.c

0 → 100644
+141 −0
Original line number Diff line number Diff line 
#include <linux/module.h>

#include <linux/sched.h>

#include <linux/fs.h>

#include <linux/path.h>

#include <linux/slab.h>



/*

 * Replace the fs->{rootmnt,root} with {mnt,dentry}. Put the old values.

 * It can block.

 */

void set_fs_root(struct fs_struct *fs, struct path *path)

{

	struct path old_root;



	write_lock(&fs->lock);

	old_root = fs->root;

	fs->root = *path;

	path_get(path);

	write_unlock(&fs->lock);

	if (old_root.dentry)

		path_put(&old_root);

}



/*

 * Replace the fs->{pwdmnt,pwd} with {mnt,dentry}. Put the old values.

 * It can block.

 */

void set_fs_pwd(struct fs_struct *fs, struct path *path)

{

	struct path old_pwd;



	write_lock(&fs->lock);

	old_pwd = fs->pwd;

	fs->pwd = *path;

	path_get(path);

	write_unlock(&fs->lock);



	if (old_pwd.dentry)

		path_put(&old_pwd);

}



void chroot_fs_refs(struct path *old_root, struct path *new_root)

{

	struct task_struct *g, *p;

	struct fs_struct *fs;

	int count = 0;



	read_lock(&tasklist_lock);

	do_each_thread(g, p) {

		task_lock(p);

		fs = p->fs;

		if (fs) {

			write_lock(&fs->lock);

			if (fs->root.dentry == old_root->dentry

			    && fs->root.mnt == old_root->mnt) {

				path_get(new_root);

				fs->root = *new_root;

				count++;

			}

			if (fs->pwd.dentry == old_root->dentry

			    && fs->pwd.mnt == old_root->mnt) {

				path_get(new_root);

				fs->pwd = *new_root;

				count++;

			}

			write_unlock(&fs->lock);

		}

		task_unlock(p);

	} while_each_thread(g, p);

	read_unlock(&tasklist_lock);

	while (count--)

		path_put(old_root);

}



void put_fs_struct(struct fs_struct *fs)

{

	/* No need to hold fs->lock if we are killing it */

	if (atomic_dec_and_test(&fs->count)) {

		path_put(&fs->root);

		path_put(&fs->pwd);

		kmem_cache_free(fs_cachep, fs);

	}

}



void exit_fs(struct task_struct *tsk)

{

	struct fs_struct * fs = tsk->fs;



	if (fs) {

		task_lock(tsk);

		tsk->fs = NULL;

		task_unlock(tsk);

		put_fs_struct(fs);

	}

}



struct fs_struct *copy_fs_struct(struct fs_struct *old)

{

	struct fs_struct *fs = kmem_cache_alloc(fs_cachep, GFP_KERNEL);

	/* We don't need to lock fs - think why ;-) */

	if (fs) {

		atomic_set(&fs->count, 1);

		rwlock_init(&fs->lock);

		fs->umask = old->umask;

		read_lock(&old->lock);

		fs->root = old->root;

		path_get(&old->root);

		fs->pwd = old->pwd;

		path_get(&old->pwd);

		read_unlock(&old->lock);

	}

	return fs;

}



int unshare_fs_struct(void)

{

	struct fs_struct *fsp = copy_fs_struct(current->fs);

	if (!fsp)

		return -ENOMEM;

	exit_fs(current);

	current->fs = fsp;

	return 0;

}

EXPORT_SYMBOL_GPL(unshare_fs_struct);



/* to be mentioned only in INIT_TASK */

struct fs_struct init_fs = {

	.count		= ATOMIC_INIT(1),

	.lock		= __RW_LOCK_UNLOCKED(init_fs.lock),

	.umask		= 0022,

};



void daemonize_fs_struct(void)

{

	struct fs_struct *fs;



	exit_fs(current);	/* current->fs->count--; */

	fs = &init_fs;

	current->fs = fs;

	atomic_inc(&fs->count);

}

fs/internal.h

+6 −0
Original line number Diff line number Diff line
@@ -11,6 +11,7 @@ 


struct super_block;

struct linux_binprm;

struct path;



/*

 * block_dev.c
@@ -60,3 +61,8 @@ extern void umount_tree(struct vfsmount *, int, struct list_head *); 
extern struct vfsmount *copy_tree(struct vfsmount *, struct dentry *, int);



extern void __init mnt_init(void);



/*

 * fs_struct.c

 */

extern void chroot_fs_refs(struct path *, struct path *);

fs/namei.c

+0 −7
Original line number Diff line number Diff line
@@ -2897,10 +2897,3 @@ EXPORT_SYMBOL(vfs_symlink); 
EXPORT_SYMBOL(vfs_unlink);

EXPORT_SYMBOL(dentry_unhash);

EXPORT_SYMBOL(generic_readlink);
 


/* to be mentioned only in INIT_TASK */

struct fs_struct init_fs = {

	.count		= ATOMIC_INIT(1),

	.lock		= __RW_LOCK_UNLOCKED(init_fs.lock),

	.umask		= 0022,

};

fs/namespace.c

+0 −68
Original line number Diff line number Diff line
@@ -2092,74 +2092,6 @@ SYSCALL_DEFINE5(mount, char __user *, dev_name, char __user *, dir_name, 
	return retval;

}



/*

 * Replace the fs->{rootmnt,root} with {mnt,dentry}. Put the old values.

 * It can block. Requires the big lock held.

 */

void set_fs_root(struct fs_struct *fs, struct path *path)

{

	struct path old_root;



	write_lock(&fs->lock);

	old_root = fs->root;

	fs->root = *path;

	path_get(path);

	write_unlock(&fs->lock);

	if (old_root.dentry)

		path_put(&old_root);

}



/*

 * Replace the fs->{pwdmnt,pwd} with {mnt,dentry}. Put the old values.

 * It can block. Requires the big lock held.

 */

void set_fs_pwd(struct fs_struct *fs, struct path *path)

{

	struct path old_pwd;



	write_lock(&fs->lock);

	old_pwd = fs->pwd;

	fs->pwd = *path;

	path_get(path);

	write_unlock(&fs->lock);



	if (old_pwd.dentry)

		path_put(&old_pwd);

}



static void chroot_fs_refs(struct path *old_root, struct path *new_root)

{

	struct task_struct *g, *p;

	struct fs_struct *fs;

	int count = 0;



	read_lock(&tasklist_lock);

	do_each_thread(g, p) {

		task_lock(p);

		fs = p->fs;

		if (fs) {

			write_lock(&fs->lock);

			if (fs->root.dentry == old_root->dentry

			    && fs->root.mnt == old_root->mnt) {

				path_get(new_root);

				fs->root = *new_root;

				count++;

			}

			if (fs->pwd.dentry == old_root->dentry

			    && fs->pwd.mnt == old_root->mnt) {

				path_get(new_root);

				fs->pwd = *new_root;

				count++;

			}

			write_unlock(&fs->lock);

		}

		task_unlock(p);

	} while_each_thread(g, p);

	read_unlock(&tasklist_lock);

	while (count--)

		path_put(old_root);

}



/*

 * pivot_root Semantics:

 * Moves the root file system of the current process to the directory put_old,