1
2
3
4
5
6
7
8
9
10
11
12
13#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14
15#include <linux/module.h>
16#include <linux/init.h>
17#include <linux/fs.h>
18#include <linux/sched.h>
19#include <linux/namei.h>
20#include <linux/slab.h>
21#include <linux/mount.h>
22#include <linux/tty.h>
23#include <linux/mutex.h>
24#include <linux/magic.h>
25#include <linux/idr.h>
26#include <linux/devpts_fs.h>
27#include <linux/parser.h>
28#include <linux/fsnotify.h>
29#include <linux/seq_file.h>
30
31#define DEVPTS_DEFAULT_MODE 0600
32
33
34
35
36
37
38#define DEVPTS_DEFAULT_PTMX_MODE 0000
39#define PTMX_MINOR 2
40
41
42
43
44
45static int pty_limit = NR_UNIX98_PTY_DEFAULT;
46static int pty_reserve = NR_UNIX98_PTY_RESERVE;
47static int pty_limit_min;
48static int pty_limit_max = INT_MAX;
49static int pty_count;
50
51static struct ctl_table pty_table[] = {
52 {
53 .procname = "max",
54 .maxlen = sizeof(int),
55 .mode = 0644,
56 .data = &pty_limit,
57 .proc_handler = proc_dointvec_minmax,
58 .extra1 = &pty_limit_min,
59 .extra2 = &pty_limit_max,
60 }, {
61 .procname = "reserve",
62 .maxlen = sizeof(int),
63 .mode = 0644,
64 .data = &pty_reserve,
65 .proc_handler = proc_dointvec_minmax,
66 .extra1 = &pty_limit_min,
67 .extra2 = &pty_limit_max,
68 }, {
69 .procname = "nr",
70 .maxlen = sizeof(int),
71 .mode = 0444,
72 .data = &pty_count,
73 .proc_handler = proc_dointvec,
74 },
75 {}
76};
77
78static struct ctl_table pty_kern_table[] = {
79 {
80 .procname = "pty",
81 .mode = 0555,
82 .child = pty_table,
83 },
84 {}
85};
86
87static struct ctl_table pty_root_table[] = {
88 {
89 .procname = "kernel",
90 .mode = 0555,
91 .child = pty_kern_table,
92 },
93 {}
94};
95
96static DEFINE_MUTEX(allocated_ptys_lock);
97
98struct 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 reserve;
106 int max;
107};
108
109enum {
110 Opt_uid, Opt_gid, Opt_mode, Opt_ptmxmode, Opt_newinstance, Opt_max,
111 Opt_err
112};
113
114static const match_table_t tokens = {
115 {Opt_uid, "uid=%u"},
116 {Opt_gid, "gid=%u"},
117 {Opt_mode, "mode=%o"},
118 {Opt_ptmxmode, "ptmxmode=%o"},
119 {Opt_newinstance, "newinstance"},
120 {Opt_max, "max=%d"},
121 {Opt_err, NULL}
122};
123
124struct pts_fs_info {
125 struct ida allocated_ptys;
126 struct pts_mount_opts mount_opts;
127 struct super_block *sb;
128 struct dentry *ptmx_dentry;
129};
130
131static inline struct pts_fs_info *DEVPTS_SB(struct super_block *sb)
132{
133 return sb->s_fs_info;
134}
135
136struct pts_fs_info *devpts_acquire(struct file *filp)
137{
138 struct pts_fs_info *result;
139 struct path path;
140 struct super_block *sb;
141 int err;
142
143 path = filp->f_path;
144 path_get(&path);
145
146
147 sb = path.mnt->mnt_sb;
148 if (sb->s_magic != DEVPTS_SUPER_MAGIC) {
149
150 err = path_pts(&path);
151 if (err) {
152 result = ERR_PTR(err);
153 goto out;
154 }
155
156
157 result = ERR_PTR(-ENODEV);
158 sb = path.mnt->mnt_sb;
159 if ((sb->s_magic != DEVPTS_SUPER_MAGIC) ||
160 (path.mnt->mnt_root != sb->s_root))
161 goto out;
162 }
163
164
165
166
167 atomic_inc(&sb->s_active);
168 result = DEVPTS_SB(sb);
169
170out:
171 path_put(&path);
172 return result;
173}
174
175void devpts_release(struct pts_fs_info *fsi)
176{
177 deactivate_super(fsi->sb);
178}
179
180#define PARSE_MOUNT 0
181#define PARSE_REMOUNT 1
182
183
184
185
186
187
188
189
190static int parse_mount_options(char *data, int op, struct pts_mount_opts *opts)
191{
192 char *p;
193 kuid_t uid;
194 kgid_t gid;
195
196 opts->setuid = 0;
197 opts->setgid = 0;
198 opts->uid = GLOBAL_ROOT_UID;
199 opts->gid = GLOBAL_ROOT_GID;
200 opts->mode = DEVPTS_DEFAULT_MODE;
201 opts->ptmxmode = DEVPTS_DEFAULT_PTMX_MODE;
202 opts->max = NR_UNIX98_PTY_MAX;
203
204
205
206
207 if (op == PARSE_MOUNT)
208 opts->reserve =
209 (current->nsproxy->mnt_ns == init_task.nsproxy->mnt_ns);
210
211 while ((p = strsep(&data, ",")) != NULL) {
212 substring_t args[MAX_OPT_ARGS];
213 int token;
214 int option;
215
216 if (!*p)
217 continue;
218
219 token = match_token(p, tokens, args);
220 switch (token) {
221 case Opt_uid:
222 if (match_int(&args[0], &option))
223 return -EINVAL;
224 uid = make_kuid(current_user_ns(), option);
225 if (!uid_valid(uid))
226 return -EINVAL;
227 opts->uid = uid;
228 opts->setuid = 1;
229 break;
230 case Opt_gid:
231 if (match_int(&args[0], &option))
232 return -EINVAL;
233 gid = make_kgid(current_user_ns(), option);
234 if (!gid_valid(gid))
235 return -EINVAL;
236 opts->gid = gid;
237 opts->setgid = 1;
238 break;
239 case Opt_mode:
240 if (match_octal(&args[0], &option))
241 return -EINVAL;
242 opts->mode = option & S_IALLUGO;
243 break;
244 case Opt_ptmxmode:
245 if (match_octal(&args[0], &option))
246 return -EINVAL;
247 opts->ptmxmode = option & S_IALLUGO;
248 break;
249 case Opt_newinstance:
250 break;
251 case Opt_max:
252 if (match_int(&args[0], &option) ||
253 option < 0 || option > NR_UNIX98_PTY_MAX)
254 return -EINVAL;
255 opts->max = option;
256 break;
257 default:
258 pr_err("called with bogus options\n");
259 return -EINVAL;
260 }
261 }
262
263 return 0;
264}
265
266static int mknod_ptmx(struct super_block *sb)
267{
268 int mode;
269 int rc = -ENOMEM;
270 struct dentry *dentry;
271 struct inode *inode;
272 struct dentry *root = sb->s_root;
273 struct pts_fs_info *fsi = DEVPTS_SB(sb);
274 struct pts_mount_opts *opts = &fsi->mount_opts;
275 kuid_t root_uid;
276 kgid_t root_gid;
277
278 root_uid = make_kuid(current_user_ns(), 0);
279 root_gid = make_kgid(current_user_ns(), 0);
280 if (!uid_valid(root_uid) || !gid_valid(root_gid))
281 return -EINVAL;
282
283 inode_lock(d_inode(root));
284
285
286 if (fsi->ptmx_dentry) {
287 rc = 0;
288 goto out;
289 }
290
291 dentry = d_alloc_name(root, "ptmx");
292 if (!dentry) {
293 pr_err("Unable to alloc dentry for ptmx node\n");
294 goto out;
295 }
296
297
298
299
300 inode = new_inode(sb);
301 if (!inode) {
302 pr_err("Unable to alloc inode for ptmx node\n");
303 dput(dentry);
304 goto out;
305 }
306
307 inode->i_ino = 2;
308 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
309
310 mode = S_IFCHR|opts->ptmxmode;
311 init_special_inode(inode, mode, MKDEV(TTYAUX_MAJOR, 2));
312 inode->i_uid = root_uid;
313 inode->i_gid = root_gid;
314
315 d_add(dentry, inode);
316
317 fsi->ptmx_dentry = dentry;
318 rc = 0;
319out:
320 inode_unlock(d_inode(root));
321 return rc;
322}
323
324static void update_ptmx_mode(struct pts_fs_info *fsi)
325{
326 struct inode *inode;
327 if (fsi->ptmx_dentry) {
328 inode = d_inode(fsi->ptmx_dentry);
329 inode->i_mode = S_IFCHR|fsi->mount_opts.ptmxmode;
330 }
331}
332
333static int devpts_remount(struct super_block *sb, int *flags, char *data)
334{
335 int err;
336 struct pts_fs_info *fsi = DEVPTS_SB(sb);
337 struct pts_mount_opts *opts = &fsi->mount_opts;
338
339 sync_filesystem(sb);
340 err = parse_mount_options(data, PARSE_REMOUNT, opts);
341
342
343
344
345
346
347
348 update_ptmx_mode(fsi);
349
350 return err;
351}
352
353static int devpts_show_options(struct seq_file *seq, struct dentry *root)
354{
355 struct pts_fs_info *fsi = DEVPTS_SB(root->d_sb);
356 struct pts_mount_opts *opts = &fsi->mount_opts;
357
358 if (opts->setuid)
359 seq_printf(seq, ",uid=%u",
360 from_kuid_munged(&init_user_ns, opts->uid));
361 if (opts->setgid)
362 seq_printf(seq, ",gid=%u",
363 from_kgid_munged(&init_user_ns, opts->gid));
364 seq_printf(seq, ",mode=%03o", opts->mode);
365 seq_printf(seq, ",ptmxmode=%03o", opts->ptmxmode);
366 if (opts->max < NR_UNIX98_PTY_MAX)
367 seq_printf(seq, ",max=%d", opts->max);
368
369 return 0;
370}
371
372static const struct super_operations devpts_sops = {
373 .statfs = simple_statfs,
374 .remount_fs = devpts_remount,
375 .show_options = devpts_show_options,
376};
377
378static void *new_pts_fs_info(struct super_block *sb)
379{
380 struct pts_fs_info *fsi;
381
382 fsi = kzalloc(sizeof(struct pts_fs_info), GFP_KERNEL);
383 if (!fsi)
384 return NULL;
385
386 ida_init(&fsi->allocated_ptys);
387 fsi->mount_opts.mode = DEVPTS_DEFAULT_MODE;
388 fsi->mount_opts.ptmxmode = DEVPTS_DEFAULT_PTMX_MODE;
389 fsi->sb = sb;
390
391 return fsi;
392}
393
394static int
395devpts_fill_super(struct super_block *s, void *data, int silent)
396{
397 struct inode *inode;
398
399 s->s_iflags &= ~SB_I_NODEV;
400 s->s_blocksize = 1024;
401 s->s_blocksize_bits = 10;
402 s->s_magic = DEVPTS_SUPER_MAGIC;
403 s->s_op = &devpts_sops;
404 s->s_time_gran = 1;
405
406 s->s_fs_info = new_pts_fs_info(s);
407 if (!s->s_fs_info)
408 goto fail;
409
410 inode = new_inode(s);
411 if (!inode)
412 goto fail;
413 inode->i_ino = 1;
414 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
415 inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO | S_IWUSR;
416 inode->i_op = &simple_dir_inode_operations;
417 inode->i_fop = &simple_dir_operations;
418 set_nlink(inode, 2);
419
420 s->s_root = d_make_root(inode);
421 if (s->s_root)
422 return 0;
423
424 pr_err("get root dentry failed\n");
425
426fail:
427 return -ENOMEM;
428}
429
430
431
432
433
434
435
436static struct dentry *devpts_mount(struct file_system_type *fs_type,
437 int flags, const char *dev_name, void *data)
438{
439 int error;
440 struct pts_mount_opts opts;
441 struct super_block *s;
442
443 error = parse_mount_options(data, PARSE_MOUNT, &opts);
444 if (error)
445 return ERR_PTR(error);
446
447 s = sget(fs_type, NULL, set_anon_super, flags, NULL);
448 if (IS_ERR(s))
449 return ERR_CAST(s);
450
451 if (!s->s_root) {
452 error = devpts_fill_super(s, data, flags & MS_SILENT ? 1 : 0);
453 if (error)
454 goto out_undo_sget;
455 s->s_flags |= MS_ACTIVE;
456 }
457
458 memcpy(&(DEVPTS_SB(s))->mount_opts, &opts, sizeof(opts));
459
460 error = mknod_ptmx(s);
461 if (error)
462 goto out_undo_sget;
463
464 return dget(s->s_root);
465
466out_undo_sget:
467 deactivate_locked_super(s);
468 return ERR_PTR(error);
469}
470
471static void devpts_kill_sb(struct super_block *sb)
472{
473 struct pts_fs_info *fsi = DEVPTS_SB(sb);
474
475 ida_destroy(&fsi->allocated_ptys);
476 kfree(fsi);
477 kill_litter_super(sb);
478}
479
480static struct file_system_type devpts_fs_type = {
481 .name = "devpts",
482 .mount = devpts_mount,
483 .kill_sb = devpts_kill_sb,
484 .fs_flags = FS_USERNS_MOUNT,
485};
486
487
488
489
490
491
492int devpts_new_index(struct pts_fs_info *fsi)
493{
494 int index;
495 int ida_ret;
496
497retry:
498 if (!ida_pre_get(&fsi->allocated_ptys, GFP_KERNEL))
499 return -ENOMEM;
500
501 mutex_lock(&allocated_ptys_lock);
502 if (pty_count >= (pty_limit -
503 (fsi->mount_opts.reserve ? 0 : pty_reserve))) {
504 mutex_unlock(&allocated_ptys_lock);
505 return -ENOSPC;
506 }
507
508 ida_ret = ida_get_new(&fsi->allocated_ptys, &index);
509 if (ida_ret < 0) {
510 mutex_unlock(&allocated_ptys_lock);
511 if (ida_ret == -EAGAIN)
512 goto retry;
513 return -EIO;
514 }
515
516 if (index >= fsi->mount_opts.max) {
517 ida_remove(&fsi->allocated_ptys, index);
518 mutex_unlock(&allocated_ptys_lock);
519 return -ENOSPC;
520 }
521 pty_count++;
522 mutex_unlock(&allocated_ptys_lock);
523 return index;
524}
525
526void devpts_kill_index(struct pts_fs_info *fsi, int idx)
527{
528 mutex_lock(&allocated_ptys_lock);
529 ida_remove(&fsi->allocated_ptys, idx);
530 pty_count--;
531 mutex_unlock(&allocated_ptys_lock);
532}
533
534
535
536
537
538
539
540
541
542
543struct dentry *devpts_pty_new(struct pts_fs_info *fsi, int index, void *priv)
544{
545 struct dentry *dentry;
546 struct super_block *sb = fsi->sb;
547 struct inode *inode;
548 struct dentry *root;
549 struct pts_mount_opts *opts;
550 char s[12];
551
552 root = sb->s_root;
553 opts = &fsi->mount_opts;
554
555 inode = new_inode(sb);
556 if (!inode)
557 return ERR_PTR(-ENOMEM);
558
559 inode->i_ino = index + 3;
560 inode->i_uid = opts->setuid ? opts->uid : current_fsuid();
561 inode->i_gid = opts->setgid ? opts->gid : current_fsgid();
562 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
563 init_special_inode(inode, S_IFCHR|opts->mode, MKDEV(UNIX98_PTY_SLAVE_MAJOR, index));
564
565 sprintf(s, "%d", index);
566
567 dentry = d_alloc_name(root, s);
568 if (dentry) {
569 dentry->d_fsdata = priv;
570 d_add(dentry, inode);
571 fsnotify_create(d_inode(root), dentry);
572 } else {
573 iput(inode);
574 dentry = ERR_PTR(-ENOMEM);
575 }
576
577 return dentry;
578}
579
580
581
582
583
584
585
586void *devpts_get_priv(struct dentry *dentry)
587{
588 if (dentry->d_sb->s_magic != DEVPTS_SUPER_MAGIC)
589 return NULL;
590 return dentry->d_fsdata;
591}
592
593
594
595
596
597
598
599void devpts_pty_kill(struct dentry *dentry)
600{
601 WARN_ON_ONCE(dentry->d_sb->s_magic != DEVPTS_SUPER_MAGIC);
602
603 dentry->d_fsdata = NULL;
604 drop_nlink(dentry->d_inode);
605 d_delete(dentry);
606 dput(dentry);
607}
608
609static int __init init_devpts_fs(void)
610{
611 int err = register_filesystem(&devpts_fs_type);
612 if (!err) {
613 register_sysctl_table(pty_root_table);
614 }
615 return err;
616}
617module_init(init_devpts_fs)
618