自学教程：C++ DEVPTS_SB函数代码示例

/* * Try to find a suitable devpts filesystem. We support the following * scenarios: * - The ptmx device node is located in the same directory as the devpts *   mount where the pts device nodes are located. *   This is e.g. the case when calling open on the /dev/pts/ptmx device *   node when the devpts filesystem is mounted at /dev/pts. * - The ptmx device node is located outside the devpts filesystem mount *   where the pts device nodes are located. For example, the ptmx device *   is a symlink, separate device node, or bind-mount. *   A supported scenario is bind-mounting /dev/pts/ptmx to /dev/ptmx and *   then calling open on /dev/ptmx. In this case a suitable pts *   subdirectory can be found in the common parent directory /dev of the *   devpts mount and the ptmx bind-mount, after resolving the /dev/ptmx *   bind-mount. *   If no suitable pts subdirectory can be found this function will fail. *   This is e.g. the case when bind-mounting /dev/pts/ptmx to /ptmx. */struct vfsmount *devpts_mntget(struct file *filp, struct pts_fs_info *fsi){	struct path path;	int err = 0;	path = filp->f_path;	path_get(&path);	/* Walk upward while the start point is a bind mount of	 * a single file.	 */	while (path.mnt->mnt_root == path.dentry)		if (follow_up(&path) == 0)			break;	/* devpts_ptmx_path() finds a devpts fs or returns an error. */	if ((path.mnt->mnt_sb->s_magic != DEVPTS_SUPER_MAGIC) ||	    (DEVPTS_SB(path.mnt->mnt_sb) != fsi))		err = devpts_ptmx_path(&path);	dput(path.dentry);	if (!err) {		if (DEVPTS_SB(path.mnt->mnt_sb) == fsi)			return path.mnt;		err = -ENODEV;	}	mntput(path.mnt);	return ERR_PTR(err);}

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;}

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

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;	kuid_t root_uid;	kgid_t root_gid;	root_uid = make_kuid(current_user_ns(), 0);	root_gid = make_kgid(current_user_ns(), 0);	if (!uid_valid(root_uid) || !gid_valid(root_gid))		return -EINVAL;	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_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;	mode = S_IFCHR|opts->ptmxmode;	init_special_inode(inode, mode, MKDEV(TTYAUX_MAJOR, 2));	inode->i_uid = root_uid;	inode->i_gid = root_gid;	d_add(dentry, inode);	fsi->ptmx_dentry = dentry;	rc = 0;out:	mutex_unlock(&root->d_inode->i_mutex);	return rc;}

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);}

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;	kuid_t ptmx_uid = current_fsuid();	kgid_t ptmx_gid = current_fsgid();	inode_lock(d_inode(root));	/* If we have already created ptmx node, return */	if (fsi->ptmx_dentry) {		rc = 0;		goto out;	}	dentry = d_alloc_name(root, "ptmx");	if (!dentry) {		pr_err("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) {		pr_err("Unable to alloc inode for ptmx node/n");		dput(dentry);		goto out;	}	inode->i_ino = 2;	inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);	mode = S_IFCHR|opts->ptmxmode;	init_special_inode(inode, mode, MKDEV(TTYAUX_MAJOR, 2));	inode->i_uid = ptmx_uid;	inode->i_gid = ptmx_gid;	d_add(dentry, inode);	fsi->ptmx_dentry = dentry;	rc = 0;out:	inode_unlock(d_inode(root));	return rc;}

static intdevpts_fill_super(struct super_block *s, void *data, int silent){	struct inode *inode;	int error;	s->s_iflags &= ~SB_I_NODEV;	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;	error = -ENOMEM;	s->s_fs_info = new_pts_fs_info(s);	if (!s->s_fs_info)		goto fail;	error = parse_mount_options(data, PARSE_MOUNT, &DEVPTS_SB(s)->mount_opts);	if (error)		goto fail;	error = -ENOMEM;	inode = new_inode(s);	if (!inode)		goto fail;	inode->i_ino = 1;	inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);	inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO | S_IWUSR;	inode->i_op = &simple_dir_inode_operations;	inode->i_fop = &simple_dir_operations;	set_nlink(inode, 2);	s->s_root = d_make_root(inode);	if (!s->s_root) {		pr_err("get root dentry failed/n");		goto fail;	}	error = mknod_ptmx(s);	if (error)		goto fail_dput;	return 0;fail_dput:	dput(s->s_root);	s->s_root = NULL;fail:	return error;}

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;}

/* * devpts_mount() * *     If the '-o newinstance' mount option was specified, mount a new *     (private) instance of devpts.  PTYs created in this instance are *     independent of the PTYs in other devpts instances. * *     If the '-o newinstance' option was not specified, mount/remount the *     initial kernel mount of devpts.  This type of mount gives the *     legacy, single-instance semantics. * *     The 'newinstance' option 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 mount_single(). * *     Mounts with 'newinstance' option create a new, private namespace. * *     NOTE: * *     For single-mount semantics, devpts cannot use mount_single(), *     because mount_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 mount_single() would pick the newinstance *     super-block instead of the initial super-block. */static struct dentry *devpts_mount(struct file_system_type *fs_type,	int flags, const char *dev_name, void *data){	int error;	struct pts_mount_opts opts;	struct super_block *s;	error = parse_mount_options(data, PARSE_MOUNT, &opts);	if (error)		return ERR_PTR(error);	/* Require newinstance for all user namespace mounts to ensure	 * the mount options are not changed.	 */	if ((current_user_ns() != &init_user_ns) && !opts.newinstance)		return ERR_PTR(-EINVAL);	if (opts.newinstance)		s = sget(fs_type, NULL, set_anon_super, flags, NULL);	else		s = sget(fs_type, compare_init_pts_sb, set_anon_super, flags,			 NULL);	if (IS_ERR(s))		return ERR_CAST(s);	if (!s->s_root) {		error = devpts_fill_super(s, data, flags & MS_SILENT ? 1 : 0);		if (error)			goto out_undo_sget;		s->s_flags |= MS_ACTIVE;	}	memcpy(&(DEVPTS_SB(s))->mount_opts, &opts, sizeof(opts));	error = mknod_ptmx(s);	if (error)		goto out_undo_sget;	return dget(s->s_root);out_undo_sget:	deactivate_locked_super(s);	return ERR_PTR(error);}

static int devpts_show_options(struct seq_file *seq, struct dentry *root){	struct pts_fs_info *fsi = DEVPTS_SB(root->d_sb);	struct pts_mount_opts *opts = &fsi->mount_opts;	if (opts->setuid)		seq_printf(seq, ",uid=%u",			   from_kuid_munged(&init_user_ns, opts->uid));	if (opts->setgid)		seq_printf(seq, ",gid=%u",			   from_kgid_munged(&init_user_ns, opts->gid));	seq_printf(seq, ",mode=%03o", opts->mode);	seq_printf(seq, ",ptmxmode=%03o", opts->ptmxmode);	if (opts->max < NR_UNIX98_PTY_MAX)		seq_printf(seq, ",max=%d", opts->max);	return 0;}

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;}

/* * devpts_get_sb() * *     If the '-o newinstance' mount option was specified, mount a new *     (private) instance of devpts.  PTYs created in this instance are *     independent of the PTYs in other devpts instances. * *     If the '-o newinstance' option was not specified, mount/remount the *     initial kernel mount of devpts.  This type of mount gives the *     legacy, single-instance semantics. * *     The 'newinstance' option 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. * *     NOTE: * *     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. */static int devpts_get_sb(struct file_system_type *fs_type,	int flags, const char *dev_name, void *data, struct vfsmount *mnt){	int error;	struct pts_mount_opts opts;	struct super_block *s;	error = parse_mount_options(data, PARSE_MOUNT, &opts);	if (error)		return error;	if (opts.newinstance)		s = sget(fs_type, NULL, set_anon_super, NULL);	else		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)			goto out_undo_sget;		s->s_flags |= MS_ACTIVE;	}	simple_set_mnt(mnt, s);	memcpy(&(DEVPTS_SB(s))->mount_opts, &opts, sizeof(opts));	error = mknod_ptmx(s);	if (error)		goto out_dput;	return 0;out_dput:	dput(s->s_root); /* undo dget() in simple_set_mnt() */out_undo_sget:	deactivate_locked_super(s);	return error;}

/** * devpts_pty_new -- create a new inode in /dev/pts/ * @ptmx_inode: inode of the master * @device: major+minor of the node to be created * @index: used as a name of the node * @priv: what's given back by devpts_get_priv * * The created inode is returned. Remove it from /dev/pts/ by devpts_pty_kill. */struct inode *devpts_pty_new(struct inode *ptmx_inode, dev_t device, int index,		void *priv){	struct dentry *dentry;	struct super_block *sb = pts_sb_from_inode(ptmx_inode);	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;	char s[12];	inode = new_inode(sb);	if (!inode)		return ERR_PTR(-ENOMEM);	inode->i_ino = index + 3;	inode->i_uid = opts->setuid ? opts->uid : current_fsuid();	inode->i_gid = opts->setgid ? opts->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 = priv;	sprintf(s, "%d", index);	mutex_lock(&root->d_inode->i_mutex);	dentry = d_alloc_name(root, s);	if (dentry) {		d_add(dentry, inode);		fsnotify_create(root->d_inode, dentry);	} else {		iput(inode);		inode = ERR_PTR(-ENOMEM);	}	mutex_unlock(&root->d_inode->i_mutex);	return inode;}