Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/fs/devpts/inode.c

  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/slab.h>
 19 #include <linux/mount.h>
 20 #include <linux/tty.h>
 21 #include <linux/mutex.h>
 22 #include <linux/magic.h>
 23 #include <linux/idr.h>
 24 #include <linux/devpts_fs.h>
 25 #include <linux/parser.h>
 26 #include <linux/fsnotify.h>
 27 #include <linux/seq_file.h>
 28 
 29 #define DEVPTS_DEFAULT_MODE 0600
 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
 37 #define PTMX_MINOR      2
 38 
 39 /*
 40  * sysctl support for setting limits on the number of Unix98 ptys allocated.
 41  * Otherwise one can eat up all kernel memory by opening /dev/ptmx repeatedly.
 42  */
 43 static int pty_limit = NR_UNIX98_PTY_DEFAULT;
 44 static int pty_reserve = NR_UNIX98_PTY_RESERVE;
 45 static int pty_limit_min;
 46 static int pty_limit_max = INT_MAX;
 47 static int pty_count;
 48 
 49 static struct ctl_table pty_table[] = {
 50         {
 51                 .procname       = "max",
 52                 .maxlen         = sizeof(int),
 53                 .mode           = 0644,
 54                 .data           = &pty_limit,
 55                 .proc_handler   = proc_dointvec_minmax,
 56                 .extra1         = &pty_limit_min,
 57                 .extra2         = &pty_limit_max,
 58         }, {
 59                 .procname       = "reserve",
 60                 .maxlen         = sizeof(int),
 61                 .mode           = 0644,
 62                 .data           = &pty_reserve,
 63                 .proc_handler   = proc_dointvec_minmax,
 64                 .extra1         = &pty_limit_min,
 65                 .extra2         = &pty_limit_max,
 66         }, {
 67                 .procname       = "nr",
 68                 .maxlen         = sizeof(int),
 69                 .mode           = 0444,
 70                 .data           = &pty_count,
 71                 .proc_handler   = proc_dointvec,
 72         },
 73         {}
 74 };
 75 
 76 static struct ctl_table pty_kern_table[] = {
 77         {
 78                 .procname       = "pty",
 79                 .mode           = 0555,
 80                 .child          = pty_table,
 81         },
 82         {}
 83 };
 84 
 85 static struct ctl_table pty_root_table[] = {
 86         {
 87                 .procname       = "kernel",
 88                 .mode           = 0555,
 89                 .child          = pty_kern_table,
 90         },
 91         {}
 92 };
 93 
 94 static DEFINE_MUTEX(allocated_ptys_lock);
 95 
 96 static struct vfsmount *devpts_mnt;
 97 
 98 struct pts_mount_opts {
 99         int setuid;
100         int setgid;
101         kuid_t   uid;
102         kgid_t   gid;
103         umode_t mode;
104         umode_t ptmxmode;
105         int newinstance;
106         int max;
107 };
108 
109 enum {
110         Opt_uid, Opt_gid, Opt_mode, Opt_ptmxmode, Opt_newinstance,  Opt_max,
111         Opt_err
112 };
113 
114 static const match_table_t tokens = {
115         {Opt_uid, "uid=%u"},
116         {Opt_gid, "gid=%u"},
117         {Opt_mode, "mode=%o"},
118 #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
119         {Opt_ptmxmode, "ptmxmode=%o"},
120         {Opt_newinstance, "newinstance"},
121         {Opt_max, "max=%d"},
122 #endif
123         {Opt_err, NULL}
124 };
125 
126 struct pts_fs_info {
127         struct ida allocated_ptys;
128         struct pts_mount_opts mount_opts;
129         struct dentry *ptmx_dentry;
130 };
131 
132 static inline struct pts_fs_info *DEVPTS_SB(struct super_block *sb)
133 {
134         return sb->s_fs_info;
135 }
136 
137 static inline struct super_block *pts_sb_from_inode(struct inode *inode)
138 {
139 #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
140         if (inode->i_sb->s_magic == DEVPTS_SUPER_MAGIC)
141                 return inode->i_sb;
142 #endif
143         return devpts_mnt->mnt_sb;
144 }
145 
146 #define PARSE_MOUNT     0
147 #define PARSE_REMOUNT   1
148 
149 /*
150  * parse_mount_options():
151  *      Set @opts to mount options specified in @data. If an option is not
152  *      specified in @data, set it to its default value. The exception is
153  *      'newinstance' option which can only be set/cleared on a mount (i.e.
154  *      cannot be changed during remount).
155  *
156  * Note: @data may be NULL (in which case all options are set to default).
157  */
158 static int parse_mount_options(char *data, int op, struct pts_mount_opts *opts)
159 {
160         char *p;
161         kuid_t uid;
162         kgid_t gid;
163 
164         opts->setuid  = 0;
165         opts->setgid  = 0;
166         opts->uid     = GLOBAL_ROOT_UID;
167         opts->gid     = GLOBAL_ROOT_GID;
168         opts->mode    = DEVPTS_DEFAULT_MODE;
169         opts->ptmxmode = DEVPTS_DEFAULT_PTMX_MODE;
170         opts->max     = NR_UNIX98_PTY_MAX;
171 
172         /* newinstance makes sense only on initial mount */
173         if (op == PARSE_MOUNT)
174                 opts->newinstance = 0;
175 
176         while ((p = strsep(&data, ",")) != NULL) {
177                 substring_t args[MAX_OPT_ARGS];
178                 int token;
179                 int option;
180 
181                 if (!*p)
182                         continue;
183 
184                 token = match_token(p, tokens, args);
185                 switch (token) {
186                 case Opt_uid:
187                         if (match_int(&args[0], &option))
188                                 return -EINVAL;
189                         uid = make_kuid(current_user_ns(), option);
190                         if (!uid_valid(uid))
191                                 return -EINVAL;
192                         opts->uid = uid;
193                         opts->setuid = 1;
194                         break;
195                 case Opt_gid:
196                         if (match_int(&args[0], &option))
197                                 return -EINVAL;
198                         gid = make_kgid(current_user_ns(), option);
199                         if (!gid_valid(gid))
200                                 return -EINVAL;
201                         opts->gid = gid;
202                         opts->setgid = 1;
203                         break;
204                 case Opt_mode:
205                         if (match_octal(&args[0], &option))
206                                 return -EINVAL;
207                         opts->mode = option & S_IALLUGO;
208                         break;
209 #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
210                 case Opt_ptmxmode:
211                         if (match_octal(&args[0], &option))
212                                 return -EINVAL;
213                         opts->ptmxmode = option & S_IALLUGO;
214                         break;
215                 case Opt_newinstance:
216                         /* newinstance makes sense only on initial mount */
217                         if (op == PARSE_MOUNT)
218                                 opts->newinstance = 1;
219                         break;
220                 case Opt_max:
221                         if (match_int(&args[0], &option) ||
222                             option < 0 || option > NR_UNIX98_PTY_MAX)
223                                 return -EINVAL;
224                         opts->max = option;
225                         break;
226 #endif
227                 default:
228                         printk(KERN_ERR "devpts: called with bogus options\n");
229                         return -EINVAL;
230                 }
231         }
232 
233         return 0;
234 }
235 
236 #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
237 static int mknod_ptmx(struct super_block *sb)
238 {
239         int mode;
240         int rc = -ENOMEM;
241         struct dentry *dentry;
242         struct inode *inode;
243         struct dentry *root = sb->s_root;
244         struct pts_fs_info *fsi = DEVPTS_SB(sb);
245         struct pts_mount_opts *opts = &fsi->mount_opts;
246         kuid_t root_uid;
247         kgid_t root_gid;
248 
249         root_uid = make_kuid(current_user_ns(), 0);
250         root_gid = make_kgid(current_user_ns(), 0);
251         if (!uid_valid(root_uid) || !gid_valid(root_gid))
252                 return -EINVAL;
253 
254         mutex_lock(&root->d_inode->i_mutex);
255 
256         /* If we have already created ptmx node, return */
257         if (fsi->ptmx_dentry) {
258                 rc = 0;
259                 goto out;
260         }
261 
262         dentry = d_alloc_name(root, "ptmx");
263         if (!dentry) {
264                 printk(KERN_NOTICE "Unable to alloc dentry for ptmx node\n");
265                 goto out;
266         }
267 
268         /*
269          * Create a new 'ptmx' node in this mount of devpts.
270          */
271         inode = new_inode(sb);
272         if (!inode) {
273                 printk(KERN_ERR "Unable to alloc inode for ptmx node\n");
274                 dput(dentry);
275                 goto out;
276         }
277 
278         inode->i_ino = 2;
279         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
280 
281         mode = S_IFCHR|opts->ptmxmode;
282         init_special_inode(inode, mode, MKDEV(TTYAUX_MAJOR, 2));
283         inode->i_uid = root_uid;
284         inode->i_gid = root_gid;
285 
286         d_add(dentry, inode);
287 
288         fsi->ptmx_dentry = dentry;
289         rc = 0;
290 out:
291         mutex_unlock(&root->d_inode->i_mutex);
292         return rc;
293 }
294 
295 static void update_ptmx_mode(struct pts_fs_info *fsi)
296 {
297         struct inode *inode;
298         if (fsi->ptmx_dentry) {
299                 inode = fsi->ptmx_dentry->d_inode;
300                 inode->i_mode = S_IFCHR|fsi->mount_opts.ptmxmode;
301         }
302 }
303 #else
304 static inline void update_ptmx_mode(struct pts_fs_info *fsi)
305 {
306        return;
307 }
308 #endif
309 
310 static int devpts_remount(struct super_block *sb, int *flags, char *data)
311 {
312         int err;
313         struct pts_fs_info *fsi = DEVPTS_SB(sb);
314         struct pts_mount_opts *opts = &fsi->mount_opts;
315 
316         sync_filesystem(sb);
317         err = parse_mount_options(data, PARSE_REMOUNT, opts);
318 
319         /*
320          * parse_mount_options() restores options to default values
321          * before parsing and may have changed ptmxmode. So, update the
322          * mode in the inode too. Bogus options don't fail the remount,
323          * so do this even on error return.
324          */
325         update_ptmx_mode(fsi);
326 
327         return err;
328 }
329 
330 static int devpts_show_options(struct seq_file *seq, struct dentry *root)
331 {
332         struct pts_fs_info *fsi = DEVPTS_SB(root->d_sb);
333         struct pts_mount_opts *opts = &fsi->mount_opts;
334 
335         if (opts->setuid)
336                 seq_printf(seq, ",uid=%u", from_kuid_munged(&init_user_ns, opts->uid));
337         if (opts->setgid)
338                 seq_printf(seq, ",gid=%u", from_kgid_munged(&init_user_ns, opts->gid));
339         seq_printf(seq, ",mode=%03o", opts->mode);
340 #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
341         seq_printf(seq, ",ptmxmode=%03o", opts->ptmxmode);
342         if (opts->max < NR_UNIX98_PTY_MAX)
343                 seq_printf(seq, ",max=%d", opts->max);
344 #endif
345 
346         return 0;
347 }
348 
349 static const struct super_operations devpts_sops = {
350         .statfs         = simple_statfs,
351         .remount_fs     = devpts_remount,
352         .show_options   = devpts_show_options,
353 };
354 
355 static void *new_pts_fs_info(void)
356 {
357         struct pts_fs_info *fsi;
358 
359         fsi = kzalloc(sizeof(struct pts_fs_info), GFP_KERNEL);
360         if (!fsi)
361                 return NULL;
362 
363         ida_init(&fsi->allocated_ptys);
364         fsi->mount_opts.mode = DEVPTS_DEFAULT_MODE;
365         fsi->mount_opts.ptmxmode = DEVPTS_DEFAULT_PTMX_MODE;
366 
367         return fsi;
368 }
369 
370 static int
371 devpts_fill_super(struct super_block *s, void *data, int silent)
372 {
373         struct inode *inode;
374 
375         s->s_blocksize = 1024;
376         s->s_blocksize_bits = 10;
377         s->s_magic = DEVPTS_SUPER_MAGIC;
378         s->s_op = &devpts_sops;
379         s->s_time_gran = 1;
380 
381         s->s_fs_info = new_pts_fs_info();
382         if (!s->s_fs_info)
383                 goto fail;
384 
385         inode = new_inode(s);
386         if (!inode)
387                 goto fail;
388         inode->i_ino = 1;
389         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
390         inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO | S_IWUSR;
391         inode->i_op = &simple_dir_inode_operations;
392         inode->i_fop = &simple_dir_operations;
393         set_nlink(inode, 2);
394 
395         s->s_root = d_make_root(inode);
396         if (s->s_root)
397                 return 0;
398 
399         printk(KERN_ERR "devpts: get root dentry failed\n");
400 
401 fail:
402         return -ENOMEM;
403 }
404 
405 #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
406 static int compare_init_pts_sb(struct super_block *s, void *p)
407 {
408         if (devpts_mnt)
409                 return devpts_mnt->mnt_sb == s;
410         return 0;
411 }
412 
413 /*
414  * devpts_mount()
415  *
416  *     If the '-o newinstance' mount option was specified, mount a new
417  *     (private) instance of devpts.  PTYs created in this instance are
418  *     independent of the PTYs in other devpts instances.
419  *
420  *     If the '-o newinstance' option was not specified, mount/remount the
421  *     initial kernel mount of devpts.  This type of mount gives the
422  *     legacy, single-instance semantics.
423  *
424  *     The 'newinstance' option is needed to support multiple namespace
425  *     semantics in devpts while preserving backward compatibility of the
426  *     current 'single-namespace' semantics. i.e all mounts of devpts
427  *     without the 'newinstance' mount option should bind to the initial
428  *     kernel mount, like mount_single().
429  *
430  *     Mounts with 'newinstance' option create a new, private namespace.
431  *
432  *     NOTE:
433  *
434  *     For single-mount semantics, devpts cannot use mount_single(),
435  *     because mount_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 mount_single() would pick the newinstance
438  *     super-block instead of the initial super-block.
439  */
440 static struct dentry *devpts_mount(struct file_system_type *fs_type,
441         int flags, const char *dev_name, void *data)
442 {
443         int error;
444         struct pts_mount_opts opts;
445         struct super_block *s;
446 
447         error = parse_mount_options(data, PARSE_MOUNT, &opts);
448         if (error)
449                 return ERR_PTR(error);
450 
451         /* Require newinstance for all user namespace mounts to ensure
452          * the mount options are not changed.
453          */
454         if ((current_user_ns() != &init_user_ns) && !opts.newinstance)
455                 return ERR_PTR(-EINVAL);
456 
457         if (opts.newinstance)
458                 s = sget(fs_type, NULL, set_anon_super, flags, NULL);
459         else
460                 s = sget(fs_type, compare_init_pts_sb, set_anon_super, flags,
461                          NULL);
462 
463         if (IS_ERR(s))
464                 return ERR_CAST(s);
465 
466         if (!s->s_root) {
467                 error = devpts_fill_super(s, data, flags & MS_SILENT ? 1 : 0);
468                 if (error)
469                         goto out_undo_sget;
470                 s->s_flags |= MS_ACTIVE;
471         }
472 
473         memcpy(&(DEVPTS_SB(s))->mount_opts, &opts, sizeof(opts));
474 
475         error = mknod_ptmx(s);
476         if (error)
477                 goto out_undo_sget;
478 
479         return dget(s->s_root);
480 
481 out_undo_sget:
482         deactivate_locked_super(s);
483         return ERR_PTR(error);
484 }
485 
486 #else
487 /*
488  * This supports only the legacy single-instance semantics (no
489  * multiple-instance semantics)
490  */
491 static struct dentry *devpts_mount(struct file_system_type *fs_type, int flags,
492                 const char *dev_name, void *data)
493 {
494         return mount_single(fs_type, flags, data, devpts_fill_super);
495 }
496 #endif
497 
498 static void devpts_kill_sb(struct super_block *sb)
499 {
500         struct pts_fs_info *fsi = DEVPTS_SB(sb);
501 
502         ida_destroy(&fsi->allocated_ptys);
503         kfree(fsi);
504         kill_litter_super(sb);
505 }
506 
507 static struct file_system_type devpts_fs_type = {
508         .name           = "devpts",
509         .mount          = devpts_mount,
510         .kill_sb        = devpts_kill_sb,
511 #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
512         .fs_flags       = FS_USERNS_MOUNT | FS_USERNS_DEV_MOUNT,
513 #endif
514 };
515 
516 /*
517  * The normal naming convention is simply /dev/pts/<number>; this conforms
518  * to the System V naming convention
519  */
520 
521 int devpts_new_index(struct inode *ptmx_inode)
522 {
523         struct super_block *sb = pts_sb_from_inode(ptmx_inode);
524         struct pts_fs_info *fsi = DEVPTS_SB(sb);
525         int index;
526         int ida_ret;
527 
528 retry:
529         if (!ida_pre_get(&fsi->allocated_ptys, GFP_KERNEL))
530                 return -ENOMEM;
531 
532         mutex_lock(&allocated_ptys_lock);
533         if (pty_count >= pty_limit -
534                         (fsi->mount_opts.newinstance ? pty_reserve : 0)) {
535                 mutex_unlock(&allocated_ptys_lock);
536                 return -ENOSPC;
537         }
538 
539         ida_ret = ida_get_new(&fsi->allocated_ptys, &index);
540         if (ida_ret < 0) {
541                 mutex_unlock(&allocated_ptys_lock);
542                 if (ida_ret == -EAGAIN)
543                         goto retry;
544                 return -EIO;
545         }
546 
547         if (index >= fsi->mount_opts.max) {
548                 ida_remove(&fsi->allocated_ptys, index);
549                 mutex_unlock(&allocated_ptys_lock);
550                 return -ENOSPC;
551         }
552         pty_count++;
553         mutex_unlock(&allocated_ptys_lock);
554         return index;
555 }
556 
557 void devpts_kill_index(struct inode *ptmx_inode, int idx)
558 {
559         struct super_block *sb = pts_sb_from_inode(ptmx_inode);
560         struct pts_fs_info *fsi = DEVPTS_SB(sb);
561 
562         mutex_lock(&allocated_ptys_lock);
563         ida_remove(&fsi->allocated_ptys, idx);
564         pty_count--;
565         mutex_unlock(&allocated_ptys_lock);
566 }
567 
568 /**
569  * devpts_pty_new -- create a new inode in /dev/pts/
570  * @ptmx_inode: inode of the master
571  * @device: major+minor of the node to be created
572  * @index: used as a name of the node
573  * @priv: what's given back by devpts_get_priv
574  *
575  * The created inode is returned. Remove it from /dev/pts/ by devpts_pty_kill.
576  */
577 struct inode *devpts_pty_new(struct inode *ptmx_inode, dev_t device, int index,
578                 void *priv)
579 {
580         struct dentry *dentry;
581         struct super_block *sb = pts_sb_from_inode(ptmx_inode);
582         struct inode *inode;
583         struct dentry *root = sb->s_root;
584         struct pts_fs_info *fsi = DEVPTS_SB(sb);
585         struct pts_mount_opts *opts = &fsi->mount_opts;
586         char s[12];
587 
588         inode = new_inode(sb);
589         if (!inode)
590                 return ERR_PTR(-ENOMEM);
591 
592         inode->i_ino = index + 3;
593         inode->i_uid = opts->setuid ? opts->uid : current_fsuid();
594         inode->i_gid = opts->setgid ? opts->gid : current_fsgid();
595         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
596         init_special_inode(inode, S_IFCHR|opts->mode, device);
597         inode->i_private = priv;
598 
599         sprintf(s, "%d", index);
600 
601         mutex_lock(&root->d_inode->i_mutex);
602 
603         dentry = d_alloc_name(root, s);
604         if (dentry) {
605                 d_add(dentry, inode);
606                 fsnotify_create(root->d_inode, dentry);
607         } else {
608                 iput(inode);
609                 inode = ERR_PTR(-ENOMEM);
610         }
611 
612         mutex_unlock(&root->d_inode->i_mutex);
613 
614         return inode;
615 }
616 
617 /**
618  * devpts_get_priv -- get private data for a slave
619  * @pts_inode: inode of the slave
620  *
621  * Returns whatever was passed as priv in devpts_pty_new for a given inode.
622  */
623 void *devpts_get_priv(struct inode *pts_inode)
624 {
625         struct dentry *dentry;
626         void *priv = NULL;
627 
628         BUG_ON(pts_inode->i_rdev == MKDEV(TTYAUX_MAJOR, PTMX_MINOR));
629 
630         /* Ensure dentry has not been deleted by devpts_pty_kill() */
631         dentry = d_find_alias(pts_inode);
632         if (!dentry)
633                 return NULL;
634 
635         if (pts_inode->i_sb->s_magic == DEVPTS_SUPER_MAGIC)
636                 priv = pts_inode->i_private;
637 
638         dput(dentry);
639 
640         return priv;
641 }
642 
643 /**
644  * devpts_pty_kill -- remove inode form /dev/pts/
645  * @inode: inode of the slave to be removed
646  *
647  * This is an inverse operation of devpts_pty_new.
648  */
649 void devpts_pty_kill(struct inode *inode)
650 {
651         struct super_block *sb = pts_sb_from_inode(inode);
652         struct dentry *root = sb->s_root;
653         struct dentry *dentry;
654 
655         BUG_ON(inode->i_rdev == MKDEV(TTYAUX_MAJOR, PTMX_MINOR));
656 
657         mutex_lock(&root->d_inode->i_mutex);
658 
659         dentry = d_find_alias(inode);
660 
661         drop_nlink(inode);
662         d_delete(dentry);
663         dput(dentry);   /* d_alloc_name() in devpts_pty_new() */
664         dput(dentry);           /* d_find_alias above */
665 
666         mutex_unlock(&root->d_inode->i_mutex);
667 }
668 
669 static int __init init_devpts_fs(void)
670 {
671         int err = register_filesystem(&devpts_fs_type);
672         struct ctl_table_header *table;
673 
674         if (!err) {
675                 table = register_sysctl_table(pty_root_table);
676                 devpts_mnt = kern_mount(&devpts_fs_type);
677                 if (IS_ERR(devpts_mnt)) {
678                         err = PTR_ERR(devpts_mnt);
679                         unregister_filesystem(&devpts_fs_type);
680                         unregister_sysctl_table(table);
681                 }
682         }
683         return err;
684 }
685 module_init(init_devpts_fs)
686 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us