1 /* -*- linux-c -*- --------------------------------------------------------- *
3 * linux/fs/devpts/inode.c
5 * Copyright 1998-2004 H. Peter Anvin -- All Rights Reserved
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.
11 * ------------------------------------------------------------------------- */
13 #include <linux/module.h>
14 #include <linux/init.h>
16 #include <linux/sched.h>
17 #include <linux/namei.h>
18 #include <linux/mount.h>
19 #include <linux/tty.h>
20 #include <linux/mutex.h>
21 #include <linux/idr.h>
22 #include <linux/devpts_fs.h>
23 #include <linux/parser.h>
24 #include <linux/fsnotify.h>
25 #include <linux/seq_file.h>
27 #define DEVPTS_SUPER_MAGIC 0x1cd1
29 #define DEVPTS_DEFAULT_MODE 0600
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
36 #define DEVPTS_DEFAULT_PTMX_MODE 0000
39 extern int pty_limit
; /* Config limit on Unix98 ptys */
40 static DEFINE_MUTEX(allocated_ptys_lock
);
42 static struct vfsmount
*devpts_mnt
;
44 struct pts_mount_opts
{
55 Opt_uid
, Opt_gid
, Opt_mode
, Opt_ptmxmode
, Opt_newinstance
,
59 static const match_table_t tokens
= {
62 {Opt_mode
, "mode=%o"},
63 #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
64 {Opt_ptmxmode
, "ptmxmode=%o"},
65 {Opt_newinstance
, "newinstance"},
71 struct ida allocated_ptys
;
72 struct pts_mount_opts mount_opts
;
73 struct dentry
*ptmx_dentry
;
76 static inline struct pts_fs_info
*DEVPTS_SB(struct super_block
*sb
)
81 static inline struct super_block
*pts_sb_from_inode(struct inode
*inode
)
83 #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
84 if (inode
->i_sb
->s_magic
== DEVPTS_SUPER_MAGIC
)
87 return devpts_mnt
->mnt_sb
;
91 #define PARSE_REMOUNT 1
93 static int parse_mount_options(char *data
, int op
, struct pts_mount_opts
*opts
)
101 opts
->mode
= DEVPTS_DEFAULT_MODE
;
102 opts
->ptmxmode
= DEVPTS_DEFAULT_PTMX_MODE
;
104 /* newinstance makes sense only on initial mount */
105 if (op
== PARSE_MOUNT
)
106 opts
->newinstance
= 0;
108 while ((p
= strsep(&data
, ",")) != NULL
) {
109 substring_t args
[MAX_OPT_ARGS
];
116 token
= match_token(p
, tokens
, args
);
119 if (match_int(&args
[0], &option
))
125 if (match_int(&args
[0], &option
))
131 if (match_octal(&args
[0], &option
))
133 opts
->mode
= option
& S_IALLUGO
;
135 #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
137 if (match_octal(&args
[0], &option
))
139 opts
->ptmxmode
= option
& S_IALLUGO
;
141 case Opt_newinstance
:
142 /* newinstance makes sense only on initial mount */
143 if (op
== PARSE_MOUNT
)
144 opts
->newinstance
= 1;
148 printk(KERN_ERR
"devpts: called with bogus options\n");
156 #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
157 static int mknod_ptmx(struct super_block
*sb
)
161 struct dentry
*dentry
;
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
;
167 mutex_lock(&root
->d_inode
->i_mutex
);
169 /* If we have already created ptmx node, return */
170 if (fsi
->ptmx_dentry
) {
175 dentry
= d_alloc_name(root
, "ptmx");
177 printk(KERN_NOTICE
"Unable to alloc dentry for ptmx node\n");
182 * Create a new 'ptmx' node in this mount of devpts.
184 inode
= new_inode(sb
);
186 printk(KERN_ERR
"Unable to alloc inode for ptmx node\n");
192 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
194 mode
= S_IFCHR
|opts
->ptmxmode
;
195 init_special_inode(inode
, mode
, MKDEV(TTYAUX_MAJOR
, 2));
197 d_add(dentry
, inode
);
199 fsi
->ptmx_dentry
= dentry
;
202 mutex_unlock(&root
->d_inode
->i_mutex
);
206 static void update_ptmx_mode(struct pts_fs_info
*fsi
)
209 if (fsi
->ptmx_dentry
) {
210 inode
= fsi
->ptmx_dentry
->d_inode
;
211 inode
->i_mode
= S_IFCHR
|fsi
->mount_opts
.ptmxmode
;
215 static inline void update_ptmx_mode(struct pts_fs_info
*fsi
)
221 static int devpts_remount(struct super_block
*sb
, int *flags
, char *data
)
224 struct pts_fs_info
*fsi
= DEVPTS_SB(sb
);
225 struct pts_mount_opts
*opts
= &fsi
->mount_opts
;
227 err
= parse_mount_options(data
, PARSE_REMOUNT
, opts
);
230 * parse_mount_options() restores options to default values
231 * before parsing and may have changed ptmxmode. So, update the
232 * mode in the inode too. Bogus options don't fail the remount,
233 * so do this even on error return.
235 update_ptmx_mode(fsi
);
240 static int devpts_show_options(struct seq_file
*seq
, struct vfsmount
*vfs
)
242 struct pts_fs_info
*fsi
= DEVPTS_SB(vfs
->mnt_sb
);
243 struct pts_mount_opts
*opts
= &fsi
->mount_opts
;
246 seq_printf(seq
, ",uid=%u", opts
->uid
);
248 seq_printf(seq
, ",gid=%u", opts
->gid
);
249 seq_printf(seq
, ",mode=%03o", opts
->mode
);
250 #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
251 seq_printf(seq
, ",ptmxmode=%03o", opts
->ptmxmode
);
257 static const struct super_operations devpts_sops
= {
258 .statfs
= simple_statfs
,
259 .remount_fs
= devpts_remount
,
260 .show_options
= devpts_show_options
,
263 static void *new_pts_fs_info(void)
265 struct pts_fs_info
*fsi
;
267 fsi
= kzalloc(sizeof(struct pts_fs_info
), GFP_KERNEL
);
271 ida_init(&fsi
->allocated_ptys
);
272 fsi
->mount_opts
.mode
= DEVPTS_DEFAULT_MODE
;
273 fsi
->mount_opts
.ptmxmode
= DEVPTS_DEFAULT_PTMX_MODE
;
279 devpts_fill_super(struct super_block
*s
, void *data
, int silent
)
283 s
->s_blocksize
= 1024;
284 s
->s_blocksize_bits
= 10;
285 s
->s_magic
= DEVPTS_SUPER_MAGIC
;
286 s
->s_op
= &devpts_sops
;
289 s
->s_fs_info
= new_pts_fs_info();
293 inode
= new_inode(s
);
297 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
298 inode
->i_mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
| S_IWUSR
;
299 inode
->i_op
= &simple_dir_inode_operations
;
300 inode
->i_fop
= &simple_dir_operations
;
303 s
->s_root
= d_alloc_root(inode
);
307 printk(KERN_ERR
"devpts: get root dentry failed\n");
316 #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
317 static int compare_init_pts_sb(struct super_block
*s
, void *p
)
320 return devpts_mnt
->mnt_sb
== s
;
325 * Mount a new (private) instance of devpts. PTYs created in this
326 * instance are independent of the PTYs in other devpts instances.
328 static int new_pts_mount(struct file_system_type
*fs_type
, int flags
,
329 void *data
, struct pts_mount_opts
*opts
, struct vfsmount
*mnt
)
332 struct pts_fs_info
*fsi
;
334 err
= get_sb_nodev(fs_type
, flags
, data
, devpts_fill_super
, mnt
);
338 fsi
= DEVPTS_SB(mnt
->mnt_sb
);
339 memcpy(&fsi
->mount_opts
, opts
, sizeof(opts
));
347 * Mount or remount the initial kernel mount of devpts. This type of
348 * mount maintains the legacy, single-instance semantics, while the
349 * kernel still allows multiple-instances.
351 * This interface is needed to support multiple namespace semantics in
352 * devpts while preserving backward compatibility of the current 'single-
353 * namespace' semantics. i.e all mounts of devpts without the 'newinstance'
354 * mount option should bind to the initial kernel mount, like
357 * Mounts with 'newinstance' option create a new private namespace.
359 * But for single-mount semantics, devpts cannot use get_sb_single(),
360 * because get_sb_single()/sget() find and use the super-block from
361 * the most recent mount of devpts. But that recent mount may be a
362 * 'newinstance' mount and get_sb_single() would pick the newinstance
363 * super-block instead of the initial super-block.
365 * This interface is identical to get_sb_single() except that it
366 * consistently selects the 'single-namespace' superblock even in the
367 * presence of the private namespace (i.e 'newinstance') super-blocks.
369 static int init_pts_mount(struct file_system_type
*fs_type
, int flags
,
370 void *data
, struct pts_mount_opts
*opts
, struct vfsmount
*mnt
)
372 struct super_block
*s
;
373 struct pts_fs_info
*fsi
;
376 s
= sget(fs_type
, compare_init_pts_sb
, set_anon_super
, NULL
);
382 error
= devpts_fill_super(s
, data
, flags
& MS_SILENT
? 1 : 0);
384 up_write(&s
->s_umount
);
388 s
->s_flags
|= MS_ACTIVE
;
391 simple_set_mnt(mnt
, s
);
393 fsi
= DEVPTS_SB(mnt
->mnt_sb
);
394 memcpy(&fsi
->mount_opts
, opts
, sizeof(opts
));
399 static int devpts_get_sb(struct file_system_type
*fs_type
,
400 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
403 struct pts_mount_opts opts
;
405 memset(&opts
, 0, sizeof(opts
));
407 error
= parse_mount_options(data
, PARSE_MOUNT
, &opts
);
412 if (opts
.newinstance
)
413 error
= new_pts_mount(fs_type
, flags
, data
, &opts
, mnt
);
415 error
= init_pts_mount(fs_type
, flags
, data
, &opts
, mnt
);
420 error
= mknod_ptmx(mnt
->mnt_sb
);
427 dput(mnt
->mnt_sb
->s_root
);
428 up_write(&mnt
->mnt_sb
->s_umount
);
429 deactivate_super(mnt
->mnt_sb
);
435 * This supports only the legacy single-instance semantics (no
436 * multiple-instance semantics)
438 static int devpts_get_sb(struct file_system_type
*fs_type
, int flags
,
439 const char *dev_name
, void *data
, struct vfsmount
*mnt
)
441 return get_sb_single(fs_type
, flags
, data
, devpts_fill_super
, mnt
);
445 static void devpts_kill_sb(struct super_block
*sb
)
447 struct pts_fs_info
*fsi
= DEVPTS_SB(sb
);
450 kill_litter_super(sb
);
453 static struct file_system_type devpts_fs_type
= {
454 .owner
= THIS_MODULE
,
456 .get_sb
= devpts_get_sb
,
457 .kill_sb
= devpts_kill_sb
,
461 * The normal naming convention is simply /dev/pts/<number>; this conforms
462 * to the System V naming convention
465 int devpts_new_index(struct inode
*ptmx_inode
)
467 struct super_block
*sb
= pts_sb_from_inode(ptmx_inode
);
468 struct pts_fs_info
*fsi
= DEVPTS_SB(sb
);
473 if (!ida_pre_get(&fsi
->allocated_ptys
, GFP_KERNEL
))
476 mutex_lock(&allocated_ptys_lock
);
477 ida_ret
= ida_get_new(&fsi
->allocated_ptys
, &index
);
479 mutex_unlock(&allocated_ptys_lock
);
480 if (ida_ret
== -EAGAIN
)
485 if (index
>= pty_limit
) {
486 ida_remove(&fsi
->allocated_ptys
, index
);
487 mutex_unlock(&allocated_ptys_lock
);
490 mutex_unlock(&allocated_ptys_lock
);
494 void devpts_kill_index(struct inode
*ptmx_inode
, int idx
)
496 struct super_block
*sb
= pts_sb_from_inode(ptmx_inode
);
497 struct pts_fs_info
*fsi
= DEVPTS_SB(sb
);
499 mutex_lock(&allocated_ptys_lock
);
500 ida_remove(&fsi
->allocated_ptys
, idx
);
501 mutex_unlock(&allocated_ptys_lock
);
504 int devpts_pty_new(struct inode
*ptmx_inode
, struct tty_struct
*tty
)
506 /* tty layer puts index from devpts_new_index() in here */
507 int number
= tty
->index
;
508 struct tty_driver
*driver
= tty
->driver
;
509 dev_t device
= MKDEV(driver
->major
, driver
->minor_start
+number
);
510 struct dentry
*dentry
;
511 struct super_block
*sb
= pts_sb_from_inode(ptmx_inode
);
512 struct inode
*inode
= new_inode(sb
);
513 struct dentry
*root
= sb
->s_root
;
514 struct pts_fs_info
*fsi
= DEVPTS_SB(sb
);
515 struct pts_mount_opts
*opts
= &fsi
->mount_opts
;
518 /* We're supposed to be given the slave end of a pty */
519 BUG_ON(driver
->type
!= TTY_DRIVER_TYPE_PTY
);
520 BUG_ON(driver
->subtype
!= PTY_TYPE_SLAVE
);
525 inode
->i_ino
= number
+ 3;
526 inode
->i_uid
= opts
->setuid
? opts
->uid
: current_fsuid();
527 inode
->i_gid
= opts
->setgid
? opts
->gid
: current_fsgid();
528 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
529 init_special_inode(inode
, S_IFCHR
|opts
->mode
, device
);
530 inode
->i_private
= tty
;
531 tty
->driver_data
= inode
;
533 sprintf(s
, "%d", number
);
535 mutex_lock(&root
->d_inode
->i_mutex
);
537 dentry
= d_alloc_name(root
, s
);
538 if (!IS_ERR(dentry
)) {
539 d_add(dentry
, inode
);
540 fsnotify_create(root
->d_inode
, dentry
);
543 mutex_unlock(&root
->d_inode
->i_mutex
);
548 struct tty_struct
*devpts_get_tty(struct inode
*pts_inode
, int number
)
550 BUG_ON(pts_inode
->i_rdev
== MKDEV(TTYAUX_MAJOR
, PTMX_MINOR
));
552 if (pts_inode
->i_sb
->s_magic
== DEVPTS_SUPER_MAGIC
)
553 return (struct tty_struct
*)pts_inode
->i_private
;
557 void devpts_pty_kill(struct tty_struct
*tty
)
559 struct inode
*inode
= tty
->driver_data
;
560 struct super_block
*sb
= pts_sb_from_inode(inode
);
561 struct dentry
*root
= sb
->s_root
;
562 struct dentry
*dentry
;
564 BUG_ON(inode
->i_rdev
== MKDEV(TTYAUX_MAJOR
, PTMX_MINOR
));
566 mutex_lock(&root
->d_inode
->i_mutex
);
568 dentry
= d_find_alias(inode
);
575 dput(dentry
); /* d_alloc_name() in devpts_pty_new() */
578 dput(dentry
); /* d_find_alias above */
580 mutex_unlock(&root
->d_inode
->i_mutex
);
583 static int __init
init_devpts_fs(void)
585 int err
= register_filesystem(&devpts_fs_type
);
587 devpts_mnt
= kern_mount(&devpts_fs_type
);
588 if (IS_ERR(devpts_mnt
))
589 err
= PTR_ERR(devpts_mnt
);
594 static void __exit
exit_devpts_fs(void)
596 unregister_filesystem(&devpts_fs_type
);
600 module_init(init_devpts_fs
)
601 module_exit(exit_devpts_fs
)
602 MODULE_LICENSE("GPL");