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         uid_t   uid;
 102         gid_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
 162         opts->setuid  = 0;
 163         opts->setgid  = 0;
 164         opts->uid     = 0;
 165         opts->gid     = 0;
 166         opts->mode    = DEVPTS_DEFAULT_MODE;
 167         opts->ptmxmode = DEVPTS_DEFAULT_PTMX_MODE;
 168         opts->max     = NR_UNIX98_PTY_MAX;
 169
 170         /* newinstance makes sense only on initial mount */
 171         if (op == PARSE_MOUNT)
 172                 opts->newinstance = 0;
 173
 174         while ((p = strsep(&data, ",")) != NULL) {
 175                 substring_t args[MAX_OPT_ARGS];
 176                 int token;
 177                 int option;
 178
 179                 if (!*p)
 180                         continue;
 181
 182                 token = match_token(p, tokens, args);
 183                 switch (token) {
 184                 case Opt_uid:
 185                         if (match_int(&args[0], &option))
 186                                 return -EINVAL;
 187                         opts->uid = option;
 188                         opts->setuid = 1;
 189                         break;
 190                 case Opt_gid:
 191                         if (match_int(&args[0], &option))
 192                                 return -EINVAL;
 193                         opts->gid = option;
 194                         opts->setgid = 1;
 195                         break;
 196                 case Opt_mode:
 197                         if (match_octal(&args[0], &option))
 198                                 return -EINVAL;
 199                         opts->mode = option & S_IALLUGO;
 200                         break;
 201 #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
 202                 case Opt_ptmxmode:
 203                         if (match_octal(&args[0], &option))
 204                                 return -EINVAL;
 205                         opts->ptmxmode = option & S_IALLUGO;
 206                         break;
 207                 case Opt_newinstance:
 208                         /* newinstance makes sense only on initial mount */
 209                         if (op == PARSE_MOUNT)
 210                                 opts->newinstance = 1;
 211                         break;
 212                 case Opt_max:
 213                         if (match_int(&args[0], &option) ||
 214                             option < 0 || option > NR_UNIX98_PTY_MAX)
 215                                 return -EINVAL;
 216                         opts->max = option;
 217                         break;
 218 #endif
 219                 default:
 220                         printk(KERN_ERR "devpts: called with bogus options\n");
 221                         return -EINVAL;
 222                 }
 223         }
 224
 225         return 0;
 226 }
 227
 228 #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
 229 static int mknod_ptmx(struct super_block *sb)
 230 {
 231         int mode;
 232         int rc = -ENOMEM;
 233         struct dentry *dentry;
 234         struct inode *inode;
 235         struct dentry *root = sb->s_root;
 236         struct pts_fs_info *fsi = DEVPTS_SB(sb);
 237         struct pts_mount_opts *opts = &fsi->mount_opts;
 238
 239         mutex_lock(&root->d_inode->i_mutex);
 240
 241         /* If we have already created ptmx node, return */
 242         if (fsi->ptmx_dentry) {
 243                 rc = 0;
 244                 goto out;
 245         }
 246
 247         dentry = d_alloc_name(root, "ptmx");
 248         if (!dentry) {
 249                 printk(KERN_NOTICE "Unable to alloc dentry for ptmx node\n");
 250                 goto out;
 251         }
 252
 253         /*
 254          * Create a new 'ptmx' node in this mount of devpts.
 255          */
 256         inode = new_inode(sb);
 257         if (!inode) {
 258                 printk(KERN_ERR "Unable to alloc inode for ptmx node\n");
 259                 dput(dentry);
 260                 goto out;
 261         }
 262
 263         inode->i_ino = 2;
 264         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
 265
 266         mode = S_IFCHR|opts->ptmxmode;
 267         init_special_inode(inode, mode, MKDEV(TTYAUX_MAJOR, 2));
 268
 269         d_add(dentry, inode);
 270
 271         fsi->ptmx_dentry = dentry;
 272         rc = 0;
 273 out:
 274         mutex_unlock(&root->d_inode->i_mutex);
 275         return rc;
 276 }
 277
 278 static void update_ptmx_mode(struct pts_fs_info *fsi)
 279 {
 280         struct inode *inode;
 281         if (fsi->ptmx_dentry) {
 282                 inode = fsi->ptmx_dentry->d_inode;
 283                 inode->i_mode = S_IFCHR|fsi->mount_opts.ptmxmode;
 284         }
 285 }
 286 #else
 287 static inline void update_ptmx_mode(struct pts_fs_info *fsi)
 288 {
 289        return;
 290 }
 291 #endif
 292
 293 static int devpts_remount(struct super_block *sb, int *flags, char *data)
 294 {
 295         int err;
 296         struct pts_fs_info *fsi = DEVPTS_SB(sb);
 297         struct pts_mount_opts *opts = &fsi->mount_opts;
 298
 299         err = parse_mount_options(data, PARSE_REMOUNT, opts);
 300
 301         /*
 302          * parse_mount_options() restores options to default values
 303          * before parsing and may have changed ptmxmode. So, update the
 304          * mode in the inode too. Bogus options don't fail the remount,
 305          * so do this even on error return.
 306          */
 307         update_ptmx_mode(fsi);
 308
 309         return err;
 310 }
 311
 312 static int devpts_show_options(struct seq_file *seq, struct dentry *root)
 313 {
 314         struct pts_fs_info *fsi = DEVPTS_SB(root->d_sb);
 315         struct pts_mount_opts *opts = &fsi->mount_opts;
 316
 317         if (opts->setuid)
 318                 seq_printf(seq, ",uid=%u", opts->uid);
 319         if (opts->setgid)
 320                 seq_printf(seq, ",gid=%u", opts->gid);
 321         seq_printf(seq, ",mode=%03o", opts->mode);
 322 #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
 323         seq_printf(seq, ",ptmxmode=%03o", opts->ptmxmode);
 324         if (opts->max < NR_UNIX98_PTY_MAX)
 325                 seq_printf(seq, ",max=%d", opts->max);
 326 #endif
 327
 328         return 0;
 329 }
 330
 331 static const struct super_operations devpts_sops = {
 332         .statfs         = simple_statfs,
 333         .remount_fs     = devpts_remount,
 334         .show_options   = devpts_show_options,
 335 };
 336
 337 static void *new_pts_fs_info(void)
 338 {
 339         struct pts_fs_info *fsi;
 340
 341         fsi = kzalloc(sizeof(struct pts_fs_info), GFP_KERNEL);
 342         if (!fsi)
 343                 return NULL;
 344
 345         ida_init(&fsi->allocated_ptys);
 346         fsi->mount_opts.mode = DEVPTS_DEFAULT_MODE;
 347         fsi->mount_opts.ptmxmode = DEVPTS_DEFAULT_PTMX_MODE;
 348
 349         return fsi;
 350 }
 351
 352 static int
 353 devpts_fill_super(struct super_block *s, void *data, int silent)
 354 {
 355         struct inode *inode;
 356
 357         s->s_blocksize = 1024;
 358         s->s_blocksize_bits = 10;
 359         s->s_magic = DEVPTS_SUPER_MAGIC;
 360         s->s_op = &devpts_sops;
 361         s->s_time_gran = 1;
 362
 363         s->s_fs_info = new_pts_fs_info();
 364         if (!s->s_fs_info)
 365                 goto fail;
 366
 367         inode = new_inode(s);
 368         if (!inode)
 369                 goto fail;
 370         inode->i_ino = 1;
 371         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
 372         inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO | S_IWUSR;
 373         inode->i_op = &simple_dir_inode_operations;
 374         inode->i_fop = &simple_dir_operations;
 375         set_nlink(inode, 2);
 376
 377         s->s_root = d_alloc_root(inode);
 378         if (s->s_root)
 379                 return 0;
 380
 381         printk(KERN_ERR "devpts: get root dentry failed\n");
 382         iput(inode);
 383
 384 fail:
 385         return -ENOMEM;
 386 }
 387
 388 #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
 389 static int compare_init_pts_sb(struct super_block *s, void *p)
 390 {
 391         if (devpts_mnt)
 392                 return devpts_mnt->mnt_sb == s;
 393         return 0;
 394 }
 395
 396 /*
 397  * devpts_mount()
 398  *
 399  *     If the '-o newinstance' mount option was specified, mount a new
 400  *     (private) instance of devpts.  PTYs created in this instance are
 401  *     independent of the PTYs in other devpts instances.
 402  *
 403  *     If the '-o newinstance' option was not specified, mount/remount the
 404  *     initial kernel mount of devpts.  This type of mount gives the
 405  *     legacy, single-instance semantics.
 406  *
 407  *     The 'newinstance' option is needed to support multiple namespace
 408  *     semantics in devpts while preserving backward compatibility of the
 409  *     current 'single-namespace' semantics. i.e all mounts of devpts
 410  *     without the 'newinstance' mount option should bind to the initial
 411  *     kernel mount, like mount_single().
 412  *
 413  *     Mounts with 'newinstance' option create a new, private namespace.
 414  *
 415  *     NOTE:
 416  *
 417  *     For single-mount semantics, devpts cannot use mount_single(),
 418  *     because mount_single()/sget() find and use the super-block from
 419  *     the most recent mount of devpts. But that recent mount may be a
 420  *     'newinstance' mount and mount_single() would pick the newinstance
 421  *     super-block instead of the initial super-block.
 422  */
 423 static struct dentry *devpts_mount(struct file_system_type *fs_type,
 424         int flags, const char *dev_name, void *data)
 425 {
 426         int error;
 427         struct pts_mount_opts opts;
 428         struct super_block *s;
 429
 430         error = parse_mount_options(data, PARSE_MOUNT, &opts);
 431         if (error)
 432                 return ERR_PTR(error);
 433
 434         if (opts.newinstance)
 435                 s = sget(fs_type, NULL, set_anon_super, NULL);
 436         else
 437                 s = sget(fs_type, compare_init_pts_sb, set_anon_super, NULL);
 438
 439         if (IS_ERR(s))
 440                 return ERR_CAST(s);
 441
 442         if (!s->s_root) {
 443                 s->s_flags = flags;
 444                 error = devpts_fill_super(s, data, flags & MS_SILENT ? 1 : 0);
 445                 if (error)
 446                         goto out_undo_sget;
 447                 s->s_flags |= MS_ACTIVE;
 448         }
 449
 450         memcpy(&(DEVPTS_SB(s))->mount_opts, &opts, sizeof(opts));
 451
 452         error = mknod_ptmx(s);
 453         if (error)
 454                 goto out_undo_sget;
 455
 456         return dget(s->s_root);
 457
 458 out_undo_sget:
 459         deactivate_locked_super(s);
 460         return ERR_PTR(error);
 461 }
 462
 463 #else
 464 /*
 465  * This supports only the legacy single-instance semantics (no
 466  * multiple-instance semantics)
 467  */
 468 static struct dentry *devpts_mount(struct file_system_type *fs_type, int flags,
 469                 const char *dev_name, void *data)
 470 {
 471         return mount_single(fs_type, flags, data, devpts_fill_super);
 472 }
 473 #endif
 474
 475 static void devpts_kill_sb(struct super_block *sb)
 476 {
 477         struct pts_fs_info *fsi = DEVPTS_SB(sb);
 478
 479         kfree(fsi);
 480         kill_litter_super(sb);
 481 }
 482
 483 static struct file_system_type devpts_fs_type = {
 484         .name           = "devpts",
 485         .mount          = devpts_mount,
 486         .kill_sb        = devpts_kill_sb,
 487 };
 488
 489 /*
 490  * The normal naming convention is simply /dev/pts/<number>; this conforms
 491  * to the System V naming convention
 492  */
 493
 494 int devpts_new_index(struct inode *ptmx_inode)
 495 {
 496         struct super_block *sb = pts_sb_from_inode(ptmx_inode);
 497         struct pts_fs_info *fsi = DEVPTS_SB(sb);
 498         int index;
 499         int ida_ret;
 500
 501 retry:
 502         if (!ida_pre_get(&fsi->allocated_ptys, GFP_KERNEL))
 503                 return -ENOMEM;
 504
 505         mutex_lock(&allocated_ptys_lock);
 506         if (pty_count >= pty_limit -
 507                         (fsi->mount_opts.newinstance ? pty_reserve : 0)) {
 508                 mutex_unlock(&allocated_ptys_lock);
 509                 return -ENOSPC;
 510         }
 511
 512         ida_ret = ida_get_new(&fsi->allocated_ptys, &index);
 513         if (ida_ret < 0) {
 514                 mutex_unlock(&allocated_ptys_lock);
 515                 if (ida_ret == -EAGAIN)
 516                         goto retry;
 517                 return -EIO;
 518         }
 519
 520         if (index >= fsi->mount_opts.max) {
 521                 ida_remove(&fsi->allocated_ptys, index);
 522                 mutex_unlock(&allocated_ptys_lock);
 523                 return -ENOSPC;
 524         }
 525         pty_count++;
 526         mutex_unlock(&allocated_ptys_lock);
 527         return index;
 528 }
 529
 530 void devpts_kill_index(struct inode *ptmx_inode, int idx)
 531 {
 532         struct super_block *sb = pts_sb_from_inode(ptmx_inode);
 533         struct pts_fs_info *fsi = DEVPTS_SB(sb);
 534
 535         mutex_lock(&allocated_ptys_lock);
 536         ida_remove(&fsi->allocated_ptys, idx);
 537         pty_count--;
 538         mutex_unlock(&allocated_ptys_lock);
 539 }
 540
 541 int devpts_pty_new(struct inode *ptmx_inode, struct tty_struct *tty)
 542 {
 543         /* tty layer puts index from devpts_new_index() in here */
 544         int number = tty->index;
 545         struct tty_driver *driver = tty->driver;
 546         dev_t device = MKDEV(driver->major, driver->minor_start+number);
 547         struct dentry *dentry;
 548         struct super_block *sb = pts_sb_from_inode(ptmx_inode);
 549         struct inode *inode = new_inode(sb);
 550         struct dentry *root = sb->s_root;
 551         struct pts_fs_info *fsi = DEVPTS_SB(sb);
 552         struct pts_mount_opts *opts = &fsi->mount_opts;
 553         int ret = 0;
 554         char s[12];
 555
 556         /* We're supposed to be given the slave end of a pty */
 557         BUG_ON(driver->type != TTY_DRIVER_TYPE_PTY);
 558         BUG_ON(driver->subtype != PTY_TYPE_SLAVE);
 559
 560         if (!inode)
 561                 return -ENOMEM;
 562
 563         inode->i_ino = number + 3;
 564         inode->i_uid = opts->setuid ? opts->uid : current_fsuid();
 565         inode->i_gid = opts->setgid ? opts->gid : current_fsgid();
 566         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
 567         init_special_inode(inode, S_IFCHR|opts->mode, device);
 568         inode->i_private = tty;
 569         tty->driver_data = inode;
 570
 571         sprintf(s, "%d", number);
 572
 573         mutex_lock(&root->d_inode->i_mutex);
 574
 575         dentry = d_alloc_name(root, s);
 576         if (dentry) {
 577                 d_add(dentry, inode);
 578                 fsnotify_create(root->d_inode, dentry);
 579         } else {
 580                 iput(inode);
 581                 ret = -ENOMEM;
 582         }
 583
 584         mutex_unlock(&root->d_inode->i_mutex);
 585
 586         return ret;
 587 }
 588
 589 struct tty_struct *devpts_get_tty(struct inode *pts_inode, int number)
 590 {
 591         struct dentry *dentry;
 592         struct tty_struct *tty;
 593
 594         BUG_ON(pts_inode->i_rdev == MKDEV(TTYAUX_MAJOR, PTMX_MINOR));
 595
 596         /* Ensure dentry has not been deleted by devpts_pty_kill() */
 597         dentry = d_find_alias(pts_inode);
 598         if (!dentry)
 599                 return NULL;
 600
 601         tty = NULL;
 602         if (pts_inode->i_sb->s_magic == DEVPTS_SUPER_MAGIC)
 603                 tty = (struct tty_struct *)pts_inode->i_private;
 604
 605         dput(dentry);
 606
 607         return tty;
 608 }
 609
 610 void devpts_pty_kill(struct tty_struct *tty)
 611 {
 612         struct inode *inode = tty->driver_data;
 613         struct super_block *sb = pts_sb_from_inode(inode);
 614         struct dentry *root = sb->s_root;
 615         struct dentry *dentry;
 616
 617         BUG_ON(inode->i_rdev == MKDEV(TTYAUX_MAJOR, PTMX_MINOR));
 618
 619         mutex_lock(&root->d_inode->i_mutex);
 620
 621         dentry = d_find_alias(inode);
 622
 623         drop_nlink(inode);
 624         d_delete(dentry);
 625         dput(dentry);   /* d_alloc_name() in devpts_pty_new() */
 626         dput(dentry);           /* d_find_alias above */
 627
 628         mutex_unlock(&root->d_inode->i_mutex);
 629 }
 630
 631 static int __init init_devpts_fs(void)
 632 {
 633         int err = register_filesystem(&devpts_fs_type);
 634         struct ctl_table_header *table;
 635
 636         if (!err) {
 637                 table = register_sysctl_table(pty_root_table);
 638                 devpts_mnt = kern_mount(&devpts_fs_type);
 639                 if (IS_ERR(devpts_mnt)) {
 640                         err = PTR_ERR(devpts_mnt);
 641                         unregister_filesystem(&devpts_fs_type);
 642                         unregister_sysctl_table(table);
 643                 }
 644         }
 645         return err;
 646 }
 647 module_init(init_devpts_fs)