[linux-2.6-block.git] / fs / devpts / inode.c

/* -*- linux-c -*- --------------------------------------------------------- *
 *
 * linux/fs/devpts/inode.c
 *
 *  Copyright 1998-2004 H. Peter Anvin -- All Rights Reserved
 *
 * This file is part of the Linux kernel and is made available under
 * the terms of the GNU General Public License, version 2, or at your
 * option, any later version, incorporated herein by reference.
 *
 * ------------------------------------------------------------------------- */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/namei.h>
#include <linux/mount.h>
#include <linux/tty.h>
#include <linux/mutex.h>
#include <linux/idr.h>
#include <linux/devpts_fs.h>
#include <linux/parser.h>
#include <linux/fsnotify.h>
#include <linux/seq_file.h>

#define DEVPTS_SUPER_MAGIC 0x1cd1

#define DEVPTS_DEFAULT_MODE 0600
/*
 * ptmx is a new node in /dev/pts and will be unused in legacy (single-
 * instance) mode. To prevent surprises in user space, set permissions of
 * ptmx to 0. Use 'chmod' or remount with '-o ptmxmode' to set meaningful
 * permissions.
 */
#define DEVPTS_DEFAULT_PTMX_MODE 0000
#define PTMX_MINOR	2

extern int pty_limit;			/* Config limit on Unix98 ptys */
static DEFINE_MUTEX(allocated_ptys_lock);

static struct vfsmount *devpts_mnt;

struct pts_mount_opts {
	int setuid;
	int setgid;
	uid_t   uid;
	gid_t   gid;
	umode_t mode;
	umode_t ptmxmode;
	int newinstance;
};

enum {
	Opt_uid, Opt_gid, Opt_mode, Opt_ptmxmode, Opt_newinstance,
	Opt_err
};

static const match_table_t tokens = {
	{Opt_uid, "uid=%u"},
	{Opt_gid, "gid=%u"},
	{Opt_mode, "mode=%o"},
#ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
	{Opt_ptmxmode, "ptmxmode=%o"},
	{Opt_newinstance, "newinstance"},
#endif
	{Opt_err, NULL}
};

struct pts_fs_info {
	struct ida allocated_ptys;
	struct pts_mount_opts mount_opts;
	struct dentry *ptmx_dentry;
};

static inline struct pts_fs_info *DEVPTS_SB(struct super_block *sb)
{
	return sb->s_fs_info;
}

static inline struct super_block *pts_sb_from_inode(struct inode *inode)
{
#ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
	if (inode->i_sb->s_magic == DEVPTS_SUPER_MAGIC)
		return inode->i_sb;
#endif
	return devpts_mnt->mnt_sb;
}

#define PARSE_MOUNT	0
#define PARSE_REMOUNT	1

static int parse_mount_options(char *data, int op, struct pts_mount_opts *opts)
{
	char *p;

	opts->setuid  = 0;
	opts->setgid  = 0;
	opts->uid     = 0;
	opts->gid     = 0;
	opts->mode    = DEVPTS_DEFAULT_MODE;
	opts->ptmxmode = DEVPTS_DEFAULT_PTMX_MODE;

	/* newinstance makes sense only on initial mount */
	if (op == PARSE_MOUNT)
		opts->newinstance = 0;

	while ((p = strsep(&data, ",")) != NULL) {
		substring_t args[MAX_OPT_ARGS];
		int token;
		int option;

		if (!*p)
			continue;

		token = match_token(p, tokens, args);
		switch (token) {
		case Opt_uid:
			if (match_int(&args[0], &option))
				return -EINVAL;
			opts->uid = option;
			opts->setuid = 1;
			break;
		case Opt_gid:
			if (match_int(&args[0], &option))
				return -EINVAL;
			opts->gid = option;
			opts->setgid = 1;
			break;
		case Opt_mode:
			if (match_octal(&args[0], &option))
				return -EINVAL;
			opts->mode = option & S_IALLUGO;
			break;
#ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
		case Opt_ptmxmode:
			if (match_octal(&args[0], &option))
				return -EINVAL;
			opts->ptmxmode = option & S_IALLUGO;
			break;
		case Opt_newinstance:
			/* newinstance makes sense only on initial mount */
			if (op == PARSE_MOUNT)
				opts->newinstance = 1;
			break;
#endif
		default:
			printk(KERN_ERR "devpts: called with bogus options\n");
			return -EINVAL;
		}
	}

	return 0;
}

#ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
static int mknod_ptmx(struct super_block *sb)
{
	int mode;
	int rc = -ENOMEM;
	struct dentry *dentry;
	struct inode *inode;
	struct dentry *root = sb->s_root;
	struct pts_fs_info *fsi = DEVPTS_SB(sb);
	struct pts_mount_opts *opts = &fsi->mount_opts;

	mutex_lock(&root->d_inode->i_mutex);

	/* If we have already created ptmx node, return */
	if (fsi->ptmx_dentry) {
		rc = 0;
		goto out;
	}

	dentry = d_alloc_name(root, "ptmx");
	if (!dentry) {
		printk(KERN_NOTICE "Unable to alloc dentry for ptmx node\n");
		goto out;
	}

	/*
	 * Create a new 'ptmx' node in this mount of devpts.
	 */
	inode = new_inode(sb);
	if (!inode) {
		printk(KERN_ERR "Unable to alloc inode for ptmx node\n");
		dput(dentry);
		goto out;
	}

	inode->i_ino = 2;
	inode->i_uid = inode->i_gid = 0;
	inode->i_blocks = 0;
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;

	mode = S_IFCHR|opts->ptmxmode;
	init_special_inode(inode, mode, MKDEV(TTYAUX_MAJOR, 2));

	d_add(dentry, inode);

	fsi->ptmx_dentry = dentry;
	rc = 0;

	printk(KERN_DEBUG "Created ptmx node in devpts ino %lu\n",
			inode->i_ino);
out:
	mutex_unlock(&root->d_inode->i_mutex);
	return rc;
}

static void update_ptmx_mode(struct pts_fs_info *fsi)
{
	struct inode *inode;
	if (fsi->ptmx_dentry) {
		inode = fsi->ptmx_dentry->d_inode;
		inode->i_mode = S_IFCHR|fsi->mount_opts.ptmxmode;
	}
}
#else
static inline void update_ptmx_mode(struct pts_fs_info *fsi)
{
       return;
}
#endif

static int devpts_remount(struct super_block *sb, int *flags, char *data)
{
	int err;
	struct pts_fs_info *fsi = DEVPTS_SB(sb);
	struct pts_mount_opts *opts = &fsi->mount_opts;

	err = parse_mount_options(data, PARSE_REMOUNT, opts);

	/*
	 * parse_mount_options() restores options to default values
	 * before parsing and may have changed ptmxmode. So, update the
	 * mode in the inode too. Bogus options don't fail the remount,
	 * so do this even on error return.
	 */
	update_ptmx_mode(fsi);

	return err;
}

static int devpts_show_options(struct seq_file *seq, struct vfsmount *vfs)
{
	struct pts_fs_info *fsi = DEVPTS_SB(vfs->mnt_sb);
	struct pts_mount_opts *opts = &fsi->mount_opts;

	if (opts->setuid)
		seq_printf(seq, ",uid=%u", opts->uid);
	if (opts->setgid)
		seq_printf(seq, ",gid=%u", opts->gid);
	seq_printf(seq, ",mode=%03o", opts->mode);
#ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
	seq_printf(seq, ",ptmxmode=%03o", opts->ptmxmode);
#endif

	return 0;
}

static const struct super_operations devpts_sops = {
	.statfs		= simple_statfs,
	.remount_fs	= devpts_remount,
	.show_options	= devpts_show_options,
};

static void *new_pts_fs_info(void)
{
	struct pts_fs_info *fsi;

	fsi = kzalloc(sizeof(struct pts_fs_info), GFP_KERNEL);
	if (!fsi)
		return NULL;

	ida_init(&fsi->allocated_ptys);
	fsi->mount_opts.mode = DEVPTS_DEFAULT_MODE;
	fsi->mount_opts.ptmxmode = DEVPTS_DEFAULT_PTMX_MODE;

	return fsi;
}

static int
devpts_fill_super(struct super_block *s, void *data, int silent)
{
	struct inode *inode;

	s->s_blocksize = 1024;
	s->s_blocksize_bits = 10;
	s->s_magic = DEVPTS_SUPER_MAGIC;
	s->s_op = &devpts_sops;
	s->s_time_gran = 1;

	s->s_fs_info = new_pts_fs_info();
	if (!s->s_fs_info)
		goto fail;

	inode = new_inode(s);
	if (!inode)
		goto free_fsi;
	inode->i_ino = 1;
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
	inode->i_blocks = 0;
	inode->i_uid = inode->i_gid = 0;
	inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO | S_IWUSR;
	inode->i_op = &simple_dir_inode_operations;
	inode->i_fop = &simple_dir_operations;
	inode->i_nlink = 2;

	s->s_root = d_alloc_root(inode);
	if (s->s_root)
		return 0;

	printk("devpts: get root dentry failed\n");
	iput(inode);

free_fsi:
	kfree(s->s_fs_info);
fail:
	return -ENOMEM;
}

static int compare_init_pts_sb(struct super_block *s, void *p)
{
	if (devpts_mnt)
		return devpts_mnt->mnt_sb == s;
	return 0;
}

#ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
/*
 * Safely parse the mount options in @data and update @opts.
 *
 * devpts ends up parsing options two times during mount, due to the
 * two modes of operation it supports. The first parse occurs in
 * devpts_get_sb() when determining the mode (single-instance or
 * multi-instance mode). The second parse happens in devpts_remount()
 * or new_pts_mount() depending on the mode.
 *
 * Parsing of options modifies the @data making subsequent parsing
 * incorrect. So make a local copy of @data and parse it.
 *
 * Return: 0 On success, -errno on error
 */
static int safe_parse_mount_options(void *data, struct pts_mount_opts *opts)
{
	int rc;
	void *datacp;

	if (!data)
		return 0;

	/* Use kstrdup() ?  */
	datacp = kmalloc(PAGE_SIZE, GFP_KERNEL);
	if (!datacp)
		return -ENOMEM;

	memcpy(datacp, data, PAGE_SIZE);
	rc = parse_mount_options((char *)datacp, PARSE_MOUNT, opts);
	kfree(datacp);

	return rc;
}

/*
 * Mount a new (private) instance of devpts.  PTYs created in this
 * instance are independent of the PTYs in other devpts instances.
 */
static int new_pts_mount(struct file_system_type *fs_type, int flags,
		void *data, struct vfsmount *mnt)
{
	int err;
	struct pts_fs_info *fsi;
	struct pts_mount_opts *opts;

	printk(KERN_NOTICE "devpts: newinstance mount\n");

	err = get_sb_nodev(fs_type, flags, data, devpts_fill_super, mnt);
	if (err)
		return err;

	fsi = DEVPTS_SB(mnt->mnt_sb);
	opts = &fsi->mount_opts;

	err = parse_mount_options(data, PARSE_MOUNT, opts);
	if (err)
		goto fail;

	err = mknod_ptmx(mnt->mnt_sb);
	if (err)
		goto fail;

	return 0;

fail:
	dput(mnt->mnt_sb->s_root);
	deactivate_super(mnt->mnt_sb);
	return err;
}

/*
 * Check if 'newinstance' mount option was specified in @data.
 *
 * Return: -errno  	on error (eg: invalid mount options specified)
 * 	 : 1 		if 'newinstance' mount option was specified
 * 	 : 0 		if 'newinstance' mount option was NOT specified
 */
static int is_new_instance_mount(void *data)
{
	int rc;
	struct pts_mount_opts opts;

	if (!data)
		return 0;

	rc = safe_parse_mount_options(data, &opts);
	if (!rc)
		rc = opts.newinstance;

	return rc;
}

/*
 * get_init_pts_sb()
 *
 *     This interface is needed to support multiple namespace semantics in
 *     devpts while preserving backward compatibility of the current 'single-
 *     namespace' semantics. i.e all mounts of devpts without the 'newinstance'
 *     mount option should bind to the initial kernel mount, like
 *     get_sb_single().
 *
 *     Mounts with 'newinstance' option create a new private namespace.
 *
 *     But for single-mount semantics, devpts cannot use get_sb_single(),
 *     because get_sb_single()/sget() find and use the super-block from
 *     the most recent mount of devpts. But that recent mount may be a
 *     'newinstance' mount and get_sb_single() would pick the newinstance
 *     super-block instead of the initial super-block.
 *
 *     This interface is identical to get_sb_single() except that it
 *     consistently selects the 'single-namespace' superblock even in the
 *     presence of the private namespace (i.e 'newinstance') super-blocks.
 */
static int get_init_pts_sb(struct file_system_type *fs_type, int flags,
		void *data, struct vfsmount *mnt)
{
        struct super_block *s;
        int error;

        s = sget(fs_type, compare_init_pts_sb, set_anon_super, NULL);
        if (IS_ERR(s))
                return PTR_ERR(s);

        if (!s->s_root) {
                s->s_flags = flags;
                error = devpts_fill_super(s, data, flags & MS_SILENT ? 1 : 0);
                if (error) {
                        up_write(&s->s_umount);
                        deactivate_super(s);
                        return error;
                }
                s->s_flags |= MS_ACTIVE;
        }
        do_remount_sb(s, flags, data, 0);
        return simple_set_mnt(mnt, s);
}

/*
 * Mount or remount the initial kernel mount of devpts. This type of
 * mount maintains the legacy, single-instance semantics, while the
 * kernel still allows multiple-instances.
 */
static int init_pts_mount(struct file_system_type *fs_type, int flags,
		void *data, struct vfsmount *mnt)
{
	int err;

	err = get_init_pts_sb(fs_type, flags, data, mnt);
	if (err)
		 return err;

	err = mknod_ptmx(mnt->mnt_sb);
	if (err) {
		dput(mnt->mnt_sb->s_root);
		deactivate_super(mnt->mnt_sb);
	}

	return err;
}

static int devpts_get_sb(struct file_system_type *fs_type,
	int flags, const char *dev_name, void *data, struct vfsmount *mnt)
{
	int new;

	new = is_new_instance_mount(data);
	if (new < 0)
		return new;

	if (new)
		return new_pts_mount(fs_type, flags, data, mnt);

	return init_pts_mount(fs_type, flags, data, mnt);
}
#else
/*
 * This supports only the legacy single-instance semantics (no
 * multiple-instance semantics)
 */
static int devpts_get_sb(struct file_system_type *fs_type, int flags,
		const char *dev_name, void *data, struct vfsmount *mnt)
{
	return get_sb_single(fs_type, flags, data, devpts_fill_super, mnt);
}
#endif

static void devpts_kill_sb(struct super_block *sb)
{
	struct pts_fs_info *fsi = DEVPTS_SB(sb);

	kfree(fsi);
	kill_litter_super(sb);
}

static struct file_system_type devpts_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "devpts",
	.get_sb		= devpts_get_sb,
	.kill_sb	= devpts_kill_sb,
};

/*
 * The normal naming convention is simply /dev/pts/<number>; this conforms
 * to the System V naming convention
 */

int devpts_new_index(struct inode *ptmx_inode)
{
	struct super_block *sb = pts_sb_from_inode(ptmx_inode);
	struct pts_fs_info *fsi = DEVPTS_SB(sb);
	int index;
	int ida_ret;

retry:
	if (!ida_pre_get(&fsi->allocated_ptys, GFP_KERNEL)) {
		return -ENOMEM;
	}

	mutex_lock(&allocated_ptys_lock);
	ida_ret = ida_get_new(&fsi->allocated_ptys, &index);
	if (ida_ret < 0) {
		mutex_unlock(&allocated_ptys_lock);
		if (ida_ret == -EAGAIN)
			goto retry;
		return -EIO;
	}

	if (index >= pty_limit) {
		ida_remove(&fsi->allocated_ptys, index);
		mutex_unlock(&allocated_ptys_lock);
		return -EIO;
	}
	mutex_unlock(&allocated_ptys_lock);
	return index;
}

void devpts_kill_index(struct inode *ptmx_inode, int idx)
{
	struct super_block *sb = pts_sb_from_inode(ptmx_inode);
	struct pts_fs_info *fsi = DEVPTS_SB(sb);

	mutex_lock(&allocated_ptys_lock);
	ida_remove(&fsi->allocated_ptys, idx);
	mutex_unlock(&allocated_ptys_lock);
}

int devpts_pty_new(struct inode *ptmx_inode, struct tty_struct *tty)
{
	int number = tty->index; /* tty layer puts index from devpts_new_index() in here */
	struct tty_driver *driver = tty->driver;
	dev_t device = MKDEV(driver->major, driver->minor_start+number);
	struct dentry *dentry;
	struct super_block *sb = pts_sb_from_inode(ptmx_inode);
	struct inode *inode = new_inode(sb);
	struct dentry *root = sb->s_root;
	struct pts_fs_info *fsi = DEVPTS_SB(sb);
	struct pts_mount_opts *opts = &fsi->mount_opts;
	char s[12];

	/* We're supposed to be given the slave end of a pty */
	BUG_ON(driver->type != TTY_DRIVER_TYPE_PTY);
	BUG_ON(driver->subtype != PTY_TYPE_SLAVE);

	if (!inode)
		return -ENOMEM;

	inode->i_ino = number+2;
	inode->i_uid = config.setuid ? config.uid : current_fsuid();
	inode->i_gid = config.setgid ? config.gid : current_fsgid();
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
	init_special_inode(inode, S_IFCHR|opts->mode, device);
	inode->i_private = tty;
	tty->driver_data = inode;

	sprintf(s, "%d", number);

	mutex_lock(&root->d_inode->i_mutex);

	dentry = d_alloc_name(root, s);
	if (!IS_ERR(dentry)) {
		d_add(dentry, inode);
		fsnotify_create(root->d_inode, dentry);
	}

	mutex_unlock(&root->d_inode->i_mutex);

	return 0;
}

struct tty_struct *devpts_get_tty(struct inode *pts_inode, int number)
{
	BUG_ON(pts_inode->i_rdev == MKDEV(TTYAUX_MAJOR, PTMX_MINOR));

	if (pts_inode->i_sb->s_magic == DEVPTS_SUPER_MAGIC)
		return (struct tty_struct *)pts_inode->i_private;
	return NULL;
}

void devpts_pty_kill(struct tty_struct *tty)
{
	struct inode *inode = tty->driver_data;
	struct super_block *sb = pts_sb_from_inode(inode);
	struct dentry *root = sb->s_root;
	struct dentry *dentry;

	BUG_ON(inode->i_rdev == MKDEV(TTYAUX_MAJOR, PTMX_MINOR));

	mutex_lock(&root->d_inode->i_mutex);

	dentry = d_find_alias(inode);
	if (IS_ERR(dentry))
		goto out;

	if (dentry) {
		inode->i_nlink--;
		d_delete(dentry);
		dput(dentry);	// d_alloc_name() in devpts_pty_new()
	}

	dput(dentry);		// d_find_alias above

out:
	mutex_unlock(&root->d_inode->i_mutex);
}

static int __init init_devpts_fs(void)
{
	int err = register_filesystem(&devpts_fs_type);
	if (!err) {
		devpts_mnt = kern_mount(&devpts_fs_type);
		if (IS_ERR(devpts_mnt))
			err = PTR_ERR(devpts_mnt);
	}
	return err;
}

static void __exit exit_devpts_fs(void)
{
	unregister_filesystem(&devpts_fs_type);
	mntput(devpts_mnt);
}

module_init(init_devpts_fs)
module_exit(exit_devpts_fs)
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/* -- linux-c -- --------------------------------------------------------- *
	2	*
	3	* linux/fs/devpts/inode.c
	4	*
	5	* Copyright 1998-2004 H. Peter Anvin -- All Rights Reserved
	6	*
	7	* This file is part of the Linux kernel and is made available under
	8	* the terms of the GNU General Public License, version 2, or at your
	9	* option, any later version, incorporated herein by reference.
	10	*
	11	* ------------------------------------------------------------------------- */
	12
	13	#include <linux/module.h>
	14	#include <linux/init.h>
	15	#include <linux/fs.h>
	16	#include <linux/sched.h>
	17	#include <linux/namei.h>
	18	#include <linux/mount.h>
	19	#include <linux/tty.h>
718a9163 SB	20	#include <linux/mutex.h>
718a9163 SB	21	#include <linux/idr.h>
1da177e4	22	#include <linux/devpts_fs.h>
7a673c6b	23	#include <linux/parser.h>
3972b7f6	24	#include <linux/fsnotify.h>
b87a267e	25	#include <linux/seq_file.h>
1da177e4 LT	26
	27	#define DEVPTS_SUPER_MAGIC 0x1cd1
	28
b87a267e	29	#define DEVPTS_DEFAULT_MODE 0600
1f8f1e29 SB	30	/*
	31	* ptmx is a new node in /dev/pts and will be unused in legacy (single-
	32	* instance) mode. To prevent surprises in user space, set permissions of
	33	* ptmx to 0. Use 'chmod' or remount with '-o ptmxmode' to set meaningful
	34	* permissions.
	35	*/
	36	#define DEVPTS_DEFAULT_PTMX_MODE 0000
527b3e47	37	#define PTMX_MINOR 2
b87a267e	38
718a9163	39	extern int pty_limit; /* Config limit on Unix98 ptys */
718a9163 SB	40	static DEFINE_MUTEX(allocated_ptys_lock);
718a9163 SB	41
1da177e4	42	static struct vfsmount *devpts_mnt;
1da177e4	43
31af0abb	44	struct pts_mount_opts {
1da177e4 LT	45	int setuid;
	46	int setgid;
	47	uid_t uid;
	48	gid_t gid;
	49	umode_t mode;
1f8f1e29	50	umode_t ptmxmode;
2a1b2dc0	51	int newinstance;
31af0abb	52	};
1da177e4	53
7a673c6b	54	enum {
2a1b2dc0	55	Opt_uid, Opt_gid, Opt_mode, Opt_ptmxmode, Opt_newinstance,
7a673c6b DP	56	Opt_err
	57	};
	58
a447c093	59	static const match_table_t tokens = {
7a673c6b DP	60	{Opt_uid, "uid=%u"},
	61	{Opt_gid, "gid=%u"},
	62	{Opt_mode, "mode=%o"},
1f8f1e29 SB	63	#ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
1f8f1e29 SB	64	{Opt_ptmxmode, "ptmxmode=%o"},
2a1b2dc0	65	{Opt_newinstance, "newinstance"},
1f8f1e29	66	#endif
7a673c6b DP	67	{Opt_err, NULL}
	68	};
	69
e76b7c01 SB	70	struct pts_fs_info {
e76b7c01 SB	71	struct ida allocated_ptys;
31af0abb	72	struct pts_mount_opts mount_opts;
1f8f1e29	73	struct dentry *ptmx_dentry;
e76b7c01 SB	74	};
	75
	76	static inline struct pts_fs_info DEVPTS_SB(struct super_block sb)
	77	{
	78	return sb->s_fs_info;
	79	}
	80
59e55e6c SB	81	static inline struct super_block pts_sb_from_inode(struct inode inode)
59e55e6c SB	82	{
2a1b2dc0	83	#ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
59e55e6c SB	84	if (inode->i_sb->s_magic == DEVPTS_SUPER_MAGIC)
59e55e6c SB	85	return inode->i_sb;
2a1b2dc0	86	#endif
59e55e6c SB	87	return devpts_mnt->mnt_sb;
	88	}
	89
2a1b2dc0 SB	90	#define PARSE_MOUNT 0
	91	#define PARSE_REMOUNT 1
	92
	93	static int parse_mount_options(char data, int op, struct pts_mount_opts opts)
1da177e4	94	{
7a673c6b DP	95	char *p;
7a673c6b DP	96
31af0abb SB	97	opts->setuid = 0;
	98	opts->setgid = 0;
	99	opts->uid = 0;
	100	opts->gid = 0;
	101	opts->mode = DEVPTS_DEFAULT_MODE;
1f8f1e29	102	opts->ptmxmode = DEVPTS_DEFAULT_PTMX_MODE;
7a673c6b	103
2a1b2dc0 SB	104	/* newinstance makes sense only on initial mount */
	105	if (op == PARSE_MOUNT)
	106	opts->newinstance = 0;
	107
7a673c6b DP	108	while ((p = strsep(&data, ",")) != NULL) {
	109	substring_t args[MAX_OPT_ARGS];
	110	int token;
	111	int option;
	112
	113	if (!*p)
1da177e4	114	continue;
7a673c6b DP	115
	116	token = match_token(p, tokens, args);
	117	switch (token) {
	118	case Opt_uid:
	119	if (match_int(&args[0], &option))
	120	return -EINVAL;
31af0abb SB	121	opts->uid = option;
31af0abb SB	122	opts->setuid = 1;
7a673c6b DP	123	break;
	124	case Opt_gid:
	125	if (match_int(&args[0], &option))
	126	return -EINVAL;
31af0abb SB	127	opts->gid = option;
31af0abb SB	128	opts->setgid = 1;
7a673c6b DP	129	break;
	130	case Opt_mode:
	131	if (match_octal(&args[0], &option))
	132	return -EINVAL;
31af0abb	133	opts->mode = option & S_IALLUGO;
7a673c6b	134	break;
1f8f1e29 SB	135	#ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
	136	case Opt_ptmxmode:
	137	if (match_octal(&args[0], &option))
	138	return -EINVAL;
	139	opts->ptmxmode = option & S_IALLUGO;
	140	break;
2a1b2dc0 SB	141	case Opt_newinstance:
	142	/* newinstance makes sense only on initial mount */
	143	if (op == PARSE_MOUNT)
	144	opts->newinstance = 1;
	145	break;
1f8f1e29	146	#endif
7a673c6b DP	147	default:
7a673c6b DP	148	printk(KERN_ERR "devpts: called with bogus options\n");
1da177e4 LT	149	return -EINVAL;
	150	}
	151	}
1da177e4 LT	152
	153	return 0;
	154	}
	155
1f8f1e29 SB	156	#ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
	157	static int mknod_ptmx(struct super_block *sb)
	158	{
	159	int mode;
	160	int rc = -ENOMEM;
	161	struct dentry *dentry;
	162	struct inode *inode;
	163	struct dentry *root = sb->s_root;
	164	struct pts_fs_info *fsi = DEVPTS_SB(sb);
	165	struct pts_mount_opts *opts = &fsi->mount_opts;
	166
	167	mutex_lock(&root->d_inode->i_mutex);
	168
	169	/* If we have already created ptmx node, return */
	170	if (fsi->ptmx_dentry) {
	171	rc = 0;
	172	goto out;
	173	}
	174
	175	dentry = d_alloc_name(root, "ptmx");
	176	if (!dentry) {
	177	printk(KERN_NOTICE "Unable to alloc dentry for ptmx node\n");
	178	goto out;
	179	}
	180
	181	/*
	182	* Create a new 'ptmx' node in this mount of devpts.
	183	*/
	184	inode = new_inode(sb);
	185	if (!inode) {
	186	printk(KERN_ERR "Unable to alloc inode for ptmx node\n");
	187	dput(dentry);
	188	goto out;
	189	}
	190
	191	inode->i_ino = 2;
	192	inode->i_uid = inode->i_gid = 0;
	193	inode->i_blocks = 0;
	194	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
	195
	196	mode = S_IFCHR\|opts->ptmxmode;
	197	init_special_inode(inode, mode, MKDEV(TTYAUX_MAJOR, 2));
	198
	199	d_add(dentry, inode);
	200
	201	fsi->ptmx_dentry = dentry;
	202	rc = 0;
	203
	204	printk(KERN_DEBUG "Created ptmx node in devpts ino %lu\n",
	205	inode->i_ino);
	206	out:
	207	mutex_unlock(&root->d_inode->i_mutex);
	208	return rc;
	209	}
	210
	211	static void update_ptmx_mode(struct pts_fs_info *fsi)
	212	{
	213	struct inode *inode;
	214	if (fsi->ptmx_dentry) {
	215	inode = fsi->ptmx_dentry->d_inode;
	216	inode->i_mode = S_IFCHR\|fsi->mount_opts.ptmxmode;
	217	}
	218	}
	219	#else
220	static inline void update_ptmx_mode(struct pts_fs_info *fsi)
221	{
222	return;
223	}
224	#endif
225
53af8ee4 SB	226	static int devpts_remount(struct super_block sb, int flags, char *data)
53af8ee4 SB	227	{
1f8f1e29	228	int err;
53af8ee4 SB	229	struct pts_fs_info *fsi = DEVPTS_SB(sb);
	230	struct pts_mount_opts *opts = &fsi->mount_opts;
	231
2a1b2dc0	232	err = parse_mount_options(data, PARSE_REMOUNT, opts);
1f8f1e29 SB	233
	234	/*
	235	* parse_mount_options() restores options to default values
	236	* before parsing and may have changed ptmxmode. So, update the
	237	* mode in the inode too. Bogus options don't fail the remount,
	238	* so do this even on error return.
	239	*/
	240	update_ptmx_mode(fsi);
	241
	242	return err;
53af8ee4 SB	243	}
53af8ee4 SB	244
b87a267e MS	245	static int devpts_show_options(struct seq_file seq, struct vfsmount vfs)
b87a267e MS	246	{
31af0abb SB	247	struct pts_fs_info *fsi = DEVPTS_SB(vfs->mnt_sb);
	248	struct pts_mount_opts *opts = &fsi->mount_opts;
	249
	250	if (opts->setuid)
	251	seq_printf(seq, ",uid=%u", opts->uid);
	252	if (opts->setgid)
	253	seq_printf(seq, ",gid=%u", opts->gid);
	254	seq_printf(seq, ",mode=%03o", opts->mode);
1f8f1e29 SB	255	#ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
	256	seq_printf(seq, ",ptmxmode=%03o", opts->ptmxmode);
	257	#endif
b87a267e MS	258
	259	return 0;
	260	}
	261
ee9b6d61	262	static const struct super_operations devpts_sops = {
1da177e4 LT	263	.statfs = simple_statfs,
1da177e4 LT	264	.remount_fs = devpts_remount,
b87a267e	265	.show_options = devpts_show_options,
1da177e4 LT	266	};
1da177e4 LT	267
e76b7c01 SB	268	static void *new_pts_fs_info(void)
	269	{
	270	struct pts_fs_info *fsi;
	271
	272	fsi = kzalloc(sizeof(struct pts_fs_info), GFP_KERNEL);
	273	if (!fsi)
	274	return NULL;
	275
	276	ida_init(&fsi->allocated_ptys);
31af0abb	277	fsi->mount_opts.mode = DEVPTS_DEFAULT_MODE;
1f8f1e29	278	fsi->mount_opts.ptmxmode = DEVPTS_DEFAULT_PTMX_MODE;
e76b7c01 SB	279
	280	return fsi;
	281	}
	282
1da177e4 LT	283	static int
	284	devpts_fill_super(struct super_block s, void data, int silent)
	285	{
1f8f1e29	286	struct inode *inode;
1da177e4 LT	287
	288	s->s_blocksize = 1024;
	289	s->s_blocksize_bits = 10;
	290	s->s_magic = DEVPTS_SUPER_MAGIC;
	291	s->s_op = &devpts_sops;
1da177e4 LT	292	s->s_time_gran = 1;
1da177e4 LT	293
e76b7c01 SB	294	s->s_fs_info = new_pts_fs_info();
	295	if (!s->s_fs_info)
	296	goto fail;
	297
1da177e4 LT	298	inode = new_inode(s);
1da177e4 LT	299	if (!inode)
e76b7c01	300	goto free_fsi;
1da177e4 LT	301	inode->i_ino = 1;
	302	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
	303	inode->i_blocks = 0;
1da177e4 LT	304	inode->i_uid = inode->i_gid = 0;
	305	inode->i_mode = S_IFDIR \| S_IRUGO \| S_IXUGO \| S_IWUSR;
	306	inode->i_op = &simple_dir_inode_operations;
	307	inode->i_fop = &simple_dir_operations;
	308	inode->i_nlink = 2;
	309
59e55e6c	310	s->s_root = d_alloc_root(inode);
1da177e4 LT	311	if (s->s_root)
1da177e4 LT	312	return 0;
1f8f1e29	313
1da177e4 LT	314	printk("devpts: get root dentry failed\n");
1da177e4 LT	315	iput(inode);
e76b7c01 SB	316
	317	free_fsi:
	318	kfree(s->s_fs_info);
1da177e4 LT	319	fail:
	320	return -ENOMEM;
	321	}
	322
d4076ac5 SB	323	static int compare_init_pts_sb(struct super_block s, void p)
	324	{
	325	if (devpts_mnt)
	326	return devpts_mnt->mnt_sb == s;
2a1b2dc0 SB	327	return 0;
	328	}
	329
	330	#ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
	331	/*
	332	* Safely parse the mount options in @data and update @opts.
	333	*
	334	* devpts ends up parsing options two times during mount, due to the
	335	* two modes of operation it supports. The first parse occurs in
	336	* devpts_get_sb() when determining the mode (single-instance or
	337	* multi-instance mode). The second parse happens in devpts_remount()
	338	* or new_pts_mount() depending on the mode.
	339	*
	340	* Parsing of options modifies the @data making subsequent parsing
	341	* incorrect. So make a local copy of @data and parse it.
	342	*
	343	* Return: 0 On success, -errno on error
	344	*/
	345	static int safe_parse_mount_options(void data, struct pts_mount_opts opts)
	346	{
	347	int rc;
	348	void *datacp;
	349
	350	if (!data)
	351	return 0;
	352
	353	/* Use kstrdup() ? */
	354	datacp = kmalloc(PAGE_SIZE, GFP_KERNEL);
	355	if (!datacp)
	356	return -ENOMEM;
	357
	358	memcpy(datacp, data, PAGE_SIZE);
	359	rc = parse_mount_options((char *)datacp, PARSE_MOUNT, opts);
	360	kfree(datacp);
	361
	362	return rc;
	363	}
	364
	365	/*
	366	* Mount a new (private) instance of devpts. PTYs created in this
	367	* instance are independent of the PTYs in other devpts instances.
	368	*/
	369	static int new_pts_mount(struct file_system_type *fs_type, int flags,
	370	void data, struct vfsmount mnt)
	371	{
	372	int err;
	373	struct pts_fs_info *fsi;
	374	struct pts_mount_opts *opts;
	375
	376	printk(KERN_NOTICE "devpts: newinstance mount\n");
	377
	378	err = get_sb_nodev(fs_type, flags, data, devpts_fill_super, mnt);
	379	if (err)
	380	return err;
	381
	382	fsi = DEVPTS_SB(mnt->mnt_sb);
	383	opts = &fsi->mount_opts;
	384
	385	err = parse_mount_options(data, PARSE_MOUNT, opts);
	386	if (err)
	387	goto fail;
	388
	389	err = mknod_ptmx(mnt->mnt_sb);
	390	if (err)
391	goto fail;
d4076ac5 SB	392
d4076ac5 SB	393	return 0;
2a1b2dc0 SB	394
	395	fail:
	396	dput(mnt->mnt_sb->s_root);
	397	deactivate_super(mnt->mnt_sb);
	398	return err;
	399	}
	400
	401	/*
	402	* Check if 'newinstance' mount option was specified in @data.
	403	*
	404	* Return: -errno on error (eg: invalid mount options specified)
	405	* : 1 if 'newinstance' mount option was specified
	406	* : 0 if 'newinstance' mount option was NOT specified
	407	*/
	408	static int is_new_instance_mount(void *data)
	409	{
	410	int rc;
	411	struct pts_mount_opts opts;
	412
	413	if (!data)
	414	return 0;
	415
	416	rc = safe_parse_mount_options(data, &opts);
	417	if (!rc)
	418	rc = opts.newinstance;
	419
	420	return rc;
d4076ac5 SB	421	}
	422
	423	/*
	424	* get_init_pts_sb()
	425	*
	426	* This interface is needed to support multiple namespace semantics in
	427	* devpts while preserving backward compatibility of the current 'single-
	428	* namespace' semantics. i.e all mounts of devpts without the 'newinstance'
	429	* mount option should bind to the initial kernel mount, like
	430	* get_sb_single().
	431	*
	432	* Mounts with 'newinstance' option create a new private namespace.
	433	*
	434	* But for single-mount semantics, devpts cannot use get_sb_single(),
	435	* because get_sb_single()/sget() find and use the super-block from
	436	* the most recent mount of devpts. But that recent mount may be a
	437	* 'newinstance' mount and get_sb_single() would pick the newinstance
	438	* super-block instead of the initial super-block.
	439	*
	440	* This interface is identical to get_sb_single() except that it
	441	* consistently selects the 'single-namespace' superblock even in the
	442	* presence of the private namespace (i.e 'newinstance') super-blocks.
	443	*/
	444	static int get_init_pts_sb(struct file_system_type *fs_type, int flags,
	445	void data, struct vfsmount mnt)
	446	{
	447	struct super_block *s;
	448	int error;
	449
	450	s = sget(fs_type, compare_init_pts_sb, set_anon_super, NULL);
	451	if (IS_ERR(s))
	452	return PTR_ERR(s);
	453
	454	if (!s->s_root) {
	455	s->s_flags = flags;
	456	error = devpts_fill_super(s, data, flags & MS_SILENT ? 1 : 0);
	457	if (error) {
	458	up_write(&s->s_umount);
	459	deactivate_super(s);
	460	return error;
	461	}
	462	s->s_flags \|= MS_ACTIVE;
	463	}
	464	do_remount_sb(s, flags, data, 0);
	465	return simple_set_mnt(mnt, s);
	466	}
	467
2a1b2dc0 SB	468	/*
	469	* Mount or remount the initial kernel mount of devpts. This type of
	470	* mount maintains the legacy, single-instance semantics, while the
	471	* kernel still allows multiple-instances.
	472	*/
	473	static int init_pts_mount(struct file_system_type *fs_type, int flags,
	474	void data, struct vfsmount mnt)
	475	{
	476	int err;
	477
	478	err = get_init_pts_sb(fs_type, flags, data, mnt);
	479	if (err)
	480	return err;
	481
	482	err = mknod_ptmx(mnt->mnt_sb);
	483	if (err) {
	484	dput(mnt->mnt_sb->s_root);
	485	deactivate_super(mnt->mnt_sb);
	486	}
	487
	488	return err;
	489	}
	490
454e2398 DH	491	static int devpts_get_sb(struct file_system_type *fs_type,
454e2398 DH	492	int flags, const char dev_name, void data, struct vfsmount *mnt)
1da177e4	493	{
2a1b2dc0 SB	494	int new;
	495
	496	new = is_new_instance_mount(data);
	497	if (new < 0)
	498	return new;
	499
	500	if (new)
	501	return new_pts_mount(fs_type, flags, data, mnt);
	502
	503	return init_pts_mount(fs_type, flags, data, mnt);
1da177e4	504	}
2a1b2dc0 SB	505	#else
	506	/*
	507	* This supports only the legacy single-instance semantics (no
	508	* multiple-instance semantics)
	509	*/
	510	static int devpts_get_sb(struct file_system_type *fs_type, int flags,
	511	const char dev_name, void data, struct vfsmount *mnt)
	512	{
	513	return get_sb_single(fs_type, flags, data, devpts_fill_super, mnt);
	514	}
	515	#endif
1da177e4	516
e76b7c01 SB	517	static void devpts_kill_sb(struct super_block *sb)
	518	{
	519	struct pts_fs_info *fsi = DEVPTS_SB(sb);
	520
	521	kfree(fsi);
1f8f1e29	522	kill_litter_super(sb);
e76b7c01 SB	523	}
e76b7c01 SB	524
1da177e4 LT	525	static struct file_system_type devpts_fs_type = {
	526	.owner = THIS_MODULE,
	527	.name = "devpts",
	528	.get_sb = devpts_get_sb,
e76b7c01	529	.kill_sb = devpts_kill_sb,
1da177e4 LT	530	};
	531
	532	/*
	533	* The normal naming convention is simply /dev/pts/<number>; this conforms
	534	* to the System V naming convention
	535	*/
	536
15f1a633	537	int devpts_new_index(struct inode *ptmx_inode)
718a9163	538	{
e76b7c01 SB	539	struct super_block *sb = pts_sb_from_inode(ptmx_inode);
e76b7c01 SB	540	struct pts_fs_info *fsi = DEVPTS_SB(sb);
718a9163	541	int index;
7ee7c12b	542	int ida_ret;
718a9163 SB	543
718a9163 SB	544	retry:
e76b7c01	545	if (!ida_pre_get(&fsi->allocated_ptys, GFP_KERNEL)) {
718a9163 SB	546	return -ENOMEM;
	547	}
	548
	549	mutex_lock(&allocated_ptys_lock);
e76b7c01	550	ida_ret = ida_get_new(&fsi->allocated_ptys, &index);
7ee7c12b	551	if (ida_ret < 0) {
718a9163	552	mutex_unlock(&allocated_ptys_lock);
7ee7c12b	553	if (ida_ret == -EAGAIN)
718a9163 SB	554	goto retry;
	555	return -EIO;
	556	}
	557
	558	if (index >= pty_limit) {
e76b7c01	559	ida_remove(&fsi->allocated_ptys, index);
718a9163 SB	560	mutex_unlock(&allocated_ptys_lock);
	561	return -EIO;
	562	}
	563	mutex_unlock(&allocated_ptys_lock);
	564	return index;
	565	}
	566
15f1a633	567	void devpts_kill_index(struct inode *ptmx_inode, int idx)
718a9163	568	{
e76b7c01 SB	569	struct super_block *sb = pts_sb_from_inode(ptmx_inode);
	570	struct pts_fs_info *fsi = DEVPTS_SB(sb);
	571
718a9163	572	mutex_lock(&allocated_ptys_lock);
e76b7c01	573	ida_remove(&fsi->allocated_ptys, idx);
718a9163 SB	574	mutex_unlock(&allocated_ptys_lock);
	575	}
	576
15f1a633	577	int devpts_pty_new(struct inode ptmx_inode, struct tty_struct tty)
1da177e4	578	{
718a9163	579	int number = tty->index; /* tty layer puts index from devpts_new_index() in here */
1da177e4 LT	580	struct tty_driver *driver = tty->driver;
	581	dev_t device = MKDEV(driver->major, driver->minor_start+number);
	582	struct dentry *dentry;
59e55e6c SB	583	struct super_block *sb = pts_sb_from_inode(ptmx_inode);
	584	struct inode *inode = new_inode(sb);
	585	struct dentry *root = sb->s_root;
31af0abb SB	586	struct pts_fs_info *fsi = DEVPTS_SB(sb);
31af0abb SB	587	struct pts_mount_opts *opts = &fsi->mount_opts;
89a52e10	588	char s[12];
1da177e4 LT	589
	590	/* We're supposed to be given the slave end of a pty */
	591	BUG_ON(driver->type != TTY_DRIVER_TYPE_PTY);
	592	BUG_ON(driver->subtype != PTY_TYPE_SLAVE);
	593
	594	if (!inode)
	595	return -ENOMEM;
	596
	597	inode->i_ino = number+2;
ec4c2aac DH	598	inode->i_uid = config.setuid ? config.uid : current_fsuid();
ec4c2aac DH	599	inode->i_gid = config.setgid ? config.gid : current_fsgid();
1da177e4	600	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
31af0abb	601	init_special_inode(inode, S_IFCHR\|opts->mode, device);
8e18e294	602	inode->i_private = tty;
a6f37daa	603	tty->driver_data = inode;
1da177e4	604
89a52e10 SB	605	sprintf(s, "%d", number);
89a52e10 SB	606
59e55e6c	607	mutex_lock(&root->d_inode->i_mutex);
89a52e10	608
59e55e6c	609	dentry = d_alloc_name(root, s);
89a52e10 SB	610	if (!IS_ERR(dentry)) {
89a52e10 SB	611	d_add(dentry, inode);
59e55e6c	612	fsnotify_create(root->d_inode, dentry);
3972b7f6	613	}
1da177e4	614
59e55e6c	615	mutex_unlock(&root->d_inode->i_mutex);
1da177e4 LT	616
	617	return 0;
	618	}
	619
15f1a633	620	struct tty_struct devpts_get_tty(struct inode pts_inode, int number)
1da177e4	621	{
527b3e47	622	BUG_ON(pts_inode->i_rdev == MKDEV(TTYAUX_MAJOR, PTMX_MINOR));
1da177e4	623
527b3e47 SB	624	if (pts_inode->i_sb->s_magic == DEVPTS_SUPER_MAGIC)
	625	return (struct tty_struct *)pts_inode->i_private;
	626	return NULL;
1da177e4 LT	627	}
1da177e4 LT	628
15f1a633	629	void devpts_pty_kill(struct tty_struct *tty)
1da177e4	630	{
a6f37daa	631	struct inode *inode = tty->driver_data;
59e55e6c SB	632	struct super_block *sb = pts_sb_from_inode(inode);
59e55e6c SB	633	struct dentry *root = sb->s_root;
a6f37daa	634	struct dentry *dentry;
1da177e4	635
a6f37daa SB	636	BUG_ON(inode->i_rdev == MKDEV(TTYAUX_MAJOR, PTMX_MINOR));
a6f37daa SB	637
59e55e6c	638	mutex_lock(&root->d_inode->i_mutex);
a6f37daa SB	639
a6f37daa SB	640	dentry = d_find_alias(inode);
2a1b2dc0 SB	641	if (IS_ERR(dentry))
	642	goto out;
	643
	644	if (dentry) {
a6f37daa SB	645	inode->i_nlink--;
a6f37daa SB	646	d_delete(dentry);
2a1b2dc0	647	dput(dentry); // d_alloc_name() in devpts_pty_new()
1da177e4	648	}
a6f37daa	649
2a1b2dc0 SB	650	dput(dentry); // d_find_alias above
	651
	652	out:
59e55e6c	653	mutex_unlock(&root->d_inode->i_mutex);
1da177e4 LT	654	}
	655
	656	static int __init init_devpts_fs(void)
	657	{
	658	int err = register_filesystem(&devpts_fs_type);
	659	if (!err) {
	660	devpts_mnt = kern_mount(&devpts_fs_type);
	661	if (IS_ERR(devpts_mnt))
	662	err = PTR_ERR(devpts_mnt);
	663	}
	664	return err;
	665	}
	666
	667	static void __exit exit_devpts_fs(void)
	668	{
	669	unregister_filesystem(&devpts_fs_type);
	670	mntput(devpts_mnt);
	671	}
	672
	673	module_init(init_devpts_fs)
	674	module_exit(exit_devpts_fs)
	675	MODULE_LICENSE("GPL");