Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 18 | #include <linux/slab.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | #include <linux/mount.h> |
| 20 | #include <linux/tty.h> |
Sukadev Bhattiprolu | 718a916 | 2008-04-30 00:54:21 -0700 | [diff] [blame] | 21 | #include <linux/mutex.h> |
Nick Black | 1fd7317 | 2009-09-22 16:43:33 -0700 | [diff] [blame] | 22 | #include <linux/magic.h> |
Sukadev Bhattiprolu | 718a916 | 2008-04-30 00:54:21 -0700 | [diff] [blame] | 23 | #include <linux/idr.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 24 | #include <linux/devpts_fs.h> |
Domen Puncer | 7a673c6 | 2006-03-23 03:00:59 -0800 | [diff] [blame] | 25 | #include <linux/parser.h> |
Florin Malita | 3972b7f | 2007-05-08 00:24:18 -0700 | [diff] [blame] | 26 | #include <linux/fsnotify.h> |
Miklos Szeredi | b87a267 | 2008-02-08 04:21:41 -0800 | [diff] [blame] | 27 | #include <linux/seq_file.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 28 | |
Miklos Szeredi | b87a267 | 2008-02-08 04:21:41 -0800 | [diff] [blame] | 29 | #define DEVPTS_DEFAULT_MODE 0600 |
Sukadev Bhattiprolu | 1f8f1e2 | 2009-01-02 13:42:02 +0000 | [diff] [blame] | 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 |
Sukadev Bhattiprolu | 527b3e4 | 2008-10-13 10:43:08 +0100 | [diff] [blame] | 37 | #define PTMX_MINOR 2 |
Miklos Szeredi | b87a267 | 2008-02-08 04:21:41 -0800 | [diff] [blame] | 38 | |
Konstantin Khlebnikov | a4834c1 | 2012-01-05 13:06:02 +0400 | [diff] [blame] | 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; |
Konstantin Khlebnikov | e9aba51 | 2012-01-05 13:06:11 +0400 | [diff] [blame] | 44 | static int pty_reserve = NR_UNIX98_PTY_RESERVE; |
Konstantin Khlebnikov | a4834c1 | 2012-01-05 13:06:02 +0400 | [diff] [blame] | 45 | static int pty_limit_min; |
Konstantin Khlebnikov | e9aba51 | 2012-01-05 13:06:11 +0400 | [diff] [blame] | 46 | static int pty_limit_max = INT_MAX; |
Konstantin Khlebnikov | a4834c1 | 2012-01-05 13:06:02 +0400 | [diff] [blame] | 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 | }, { |
Konstantin Khlebnikov | e9aba51 | 2012-01-05 13:06:11 +0400 | [diff] [blame] | 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 | }, { |
Konstantin Khlebnikov | a4834c1 | 2012-01-05 13:06:02 +0400 | [diff] [blame] | 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 | |
Sukadev Bhattiprolu | 718a916 | 2008-04-30 00:54:21 -0700 | [diff] [blame] | 94 | static DEFINE_MUTEX(allocated_ptys_lock); |
| 95 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 96 | static struct vfsmount *devpts_mnt; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 97 | |
Sukadev Bhattiprolu | 31af0ab | 2009-01-02 13:41:33 +0000 | [diff] [blame] | 98 | struct pts_mount_opts { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 99 | int setuid; |
| 100 | int setgid; |
| 101 | uid_t uid; |
| 102 | gid_t gid; |
| 103 | umode_t mode; |
Sukadev Bhattiprolu | 1f8f1e2 | 2009-01-02 13:42:02 +0000 | [diff] [blame] | 104 | umode_t ptmxmode; |
Sukadev Bhattiprolu | 2a1b2dc | 2009-01-02 13:42:27 +0000 | [diff] [blame] | 105 | int newinstance; |
Konstantin Khlebnikov | e9aba51 | 2012-01-05 13:06:11 +0400 | [diff] [blame] | 106 | int max; |
Sukadev Bhattiprolu | 31af0ab | 2009-01-02 13:41:33 +0000 | [diff] [blame] | 107 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 108 | |
Domen Puncer | 7a673c6 | 2006-03-23 03:00:59 -0800 | [diff] [blame] | 109 | enum { |
Konstantin Khlebnikov | e9aba51 | 2012-01-05 13:06:11 +0400 | [diff] [blame] | 110 | Opt_uid, Opt_gid, Opt_mode, Opt_ptmxmode, Opt_newinstance, Opt_max, |
Domen Puncer | 7a673c6 | 2006-03-23 03:00:59 -0800 | [diff] [blame] | 111 | Opt_err |
| 112 | }; |
| 113 | |
Steven Whitehouse | a447c09 | 2008-10-13 10:46:57 +0100 | [diff] [blame] | 114 | static const match_table_t tokens = { |
Domen Puncer | 7a673c6 | 2006-03-23 03:00:59 -0800 | [diff] [blame] | 115 | {Opt_uid, "uid=%u"}, |
| 116 | {Opt_gid, "gid=%u"}, |
| 117 | {Opt_mode, "mode=%o"}, |
Sukadev Bhattiprolu | 1f8f1e2 | 2009-01-02 13:42:02 +0000 | [diff] [blame] | 118 | #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES |
| 119 | {Opt_ptmxmode, "ptmxmode=%o"}, |
Sukadev Bhattiprolu | 2a1b2dc | 2009-01-02 13:42:27 +0000 | [diff] [blame] | 120 | {Opt_newinstance, "newinstance"}, |
Konstantin Khlebnikov | e9aba51 | 2012-01-05 13:06:11 +0400 | [diff] [blame] | 121 | {Opt_max, "max=%d"}, |
Sukadev Bhattiprolu | 1f8f1e2 | 2009-01-02 13:42:02 +0000 | [diff] [blame] | 122 | #endif |
Domen Puncer | 7a673c6 | 2006-03-23 03:00:59 -0800 | [diff] [blame] | 123 | {Opt_err, NULL} |
| 124 | }; |
| 125 | |
Sukadev Bhattiprolu | e76b7c0 | 2009-01-02 13:41:21 +0000 | [diff] [blame] | 126 | struct pts_fs_info { |
| 127 | struct ida allocated_ptys; |
Sukadev Bhattiprolu | 31af0ab | 2009-01-02 13:41:33 +0000 | [diff] [blame] | 128 | struct pts_mount_opts mount_opts; |
Sukadev Bhattiprolu | 1f8f1e2 | 2009-01-02 13:42:02 +0000 | [diff] [blame] | 129 | struct dentry *ptmx_dentry; |
Sukadev Bhattiprolu | e76b7c0 | 2009-01-02 13:41:21 +0000 | [diff] [blame] | 130 | }; |
| 131 | |
| 132 | static inline struct pts_fs_info *DEVPTS_SB(struct super_block *sb) |
| 133 | { |
| 134 | return sb->s_fs_info; |
| 135 | } |
| 136 | |
Sukadev Bhattiprolu | 59e55e6 | 2009-01-02 13:41:11 +0000 | [diff] [blame] | 137 | static inline struct super_block *pts_sb_from_inode(struct inode *inode) |
| 138 | { |
Sukadev Bhattiprolu | 2a1b2dc | 2009-01-02 13:42:27 +0000 | [diff] [blame] | 139 | #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES |
Sukadev Bhattiprolu | 59e55e6 | 2009-01-02 13:41:11 +0000 | [diff] [blame] | 140 | if (inode->i_sb->s_magic == DEVPTS_SUPER_MAGIC) |
| 141 | return inode->i_sb; |
Sukadev Bhattiprolu | 2a1b2dc | 2009-01-02 13:42:27 +0000 | [diff] [blame] | 142 | #endif |
Sukadev Bhattiprolu | 59e55e6 | 2009-01-02 13:41:11 +0000 | [diff] [blame] | 143 | return devpts_mnt->mnt_sb; |
| 144 | } |
| 145 | |
Sukadev Bhattiprolu | 2a1b2dc | 2009-01-02 13:42:27 +0000 | [diff] [blame] | 146 | #define PARSE_MOUNT 0 |
| 147 | #define PARSE_REMOUNT 1 |
| 148 | |
Sukadev Bhattiprolu | 1f71ebe | 2009-05-14 19:38:24 -0700 | [diff] [blame] | 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 | */ |
Sukadev Bhattiprolu | 2a1b2dc | 2009-01-02 13:42:27 +0000 | [diff] [blame] | 158 | static int parse_mount_options(char *data, int op, struct pts_mount_opts *opts) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | { |
Domen Puncer | 7a673c6 | 2006-03-23 03:00:59 -0800 | [diff] [blame] | 160 | char *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 161 | |
Sukadev Bhattiprolu | 31af0ab | 2009-01-02 13:41:33 +0000 | [diff] [blame] | 162 | opts->setuid = 0; |
| 163 | opts->setgid = 0; |
| 164 | opts->uid = 0; |
| 165 | opts->gid = 0; |
| 166 | opts->mode = DEVPTS_DEFAULT_MODE; |
Sukadev Bhattiprolu | 1f8f1e2 | 2009-01-02 13:42:02 +0000 | [diff] [blame] | 167 | opts->ptmxmode = DEVPTS_DEFAULT_PTMX_MODE; |
Konstantin Khlebnikov | e9aba51 | 2012-01-05 13:06:11 +0400 | [diff] [blame] | 168 | opts->max = NR_UNIX98_PTY_MAX; |
Domen Puncer | 7a673c6 | 2006-03-23 03:00:59 -0800 | [diff] [blame] | 169 | |
Sukadev Bhattiprolu | 2a1b2dc | 2009-01-02 13:42:27 +0000 | [diff] [blame] | 170 | /* newinstance makes sense only on initial mount */ |
| 171 | if (op == PARSE_MOUNT) |
| 172 | opts->newinstance = 0; |
| 173 | |
Domen Puncer | 7a673c6 | 2006-03-23 03:00:59 -0800 | [diff] [blame] | 174 | while ((p = strsep(&data, ",")) != NULL) { |
| 175 | substring_t args[MAX_OPT_ARGS]; |
| 176 | int token; |
| 177 | int option; |
| 178 | |
| 179 | if (!*p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 180 | continue; |
Domen Puncer | 7a673c6 | 2006-03-23 03:00:59 -0800 | [diff] [blame] | 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; |
Sukadev Bhattiprolu | 31af0ab | 2009-01-02 13:41:33 +0000 | [diff] [blame] | 187 | opts->uid = option; |
| 188 | opts->setuid = 1; |
Domen Puncer | 7a673c6 | 2006-03-23 03:00:59 -0800 | [diff] [blame] | 189 | break; |
| 190 | case Opt_gid: |
| 191 | if (match_int(&args[0], &option)) |
| 192 | return -EINVAL; |
Sukadev Bhattiprolu | 31af0ab | 2009-01-02 13:41:33 +0000 | [diff] [blame] | 193 | opts->gid = option; |
| 194 | opts->setgid = 1; |
Domen Puncer | 7a673c6 | 2006-03-23 03:00:59 -0800 | [diff] [blame] | 195 | break; |
| 196 | case Opt_mode: |
| 197 | if (match_octal(&args[0], &option)) |
| 198 | return -EINVAL; |
Sukadev Bhattiprolu | 31af0ab | 2009-01-02 13:41:33 +0000 | [diff] [blame] | 199 | opts->mode = option & S_IALLUGO; |
Domen Puncer | 7a673c6 | 2006-03-23 03:00:59 -0800 | [diff] [blame] | 200 | break; |
Sukadev Bhattiprolu | 1f8f1e2 | 2009-01-02 13:42:02 +0000 | [diff] [blame] | 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; |
Sukadev Bhattiprolu | 2a1b2dc | 2009-01-02 13:42:27 +0000 | [diff] [blame] | 207 | case Opt_newinstance: |
| 208 | /* newinstance makes sense only on initial mount */ |
| 209 | if (op == PARSE_MOUNT) |
| 210 | opts->newinstance = 1; |
| 211 | break; |
Konstantin Khlebnikov | e9aba51 | 2012-01-05 13:06:11 +0400 | [diff] [blame] | 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; |
Sukadev Bhattiprolu | 1f8f1e2 | 2009-01-02 13:42:02 +0000 | [diff] [blame] | 218 | #endif |
Domen Puncer | 7a673c6 | 2006-03-23 03:00:59 -0800 | [diff] [blame] | 219 | default: |
| 220 | printk(KERN_ERR "devpts: called with bogus options\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 221 | return -EINVAL; |
| 222 | } |
| 223 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 224 | |
| 225 | return 0; |
| 226 | } |
| 227 | |
Sukadev Bhattiprolu | 1f8f1e2 | 2009-01-02 13:42:02 +0000 | [diff] [blame] | 228 | #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES |
| 229 | static int mknod_ptmx(struct super_block *sb) |
Sukadev Bhattiprolu | 53af8ee | 2009-01-02 13:41:47 +0000 | [diff] [blame] | 230 | { |
Sukadev Bhattiprolu | 1f8f1e2 | 2009-01-02 13:42:02 +0000 | [diff] [blame] | 231 | int mode; |
| 232 | int rc = -ENOMEM; |
| 233 | struct dentry *dentry; |
| 234 | struct inode *inode; |
| 235 | struct dentry *root = sb->s_root; |
Sukadev Bhattiprolu | 53af8ee | 2009-01-02 13:41:47 +0000 | [diff] [blame] | 236 | struct pts_fs_info *fsi = DEVPTS_SB(sb); |
| 237 | struct pts_mount_opts *opts = &fsi->mount_opts; |
| 238 | |
Sukadev Bhattiprolu | 1f8f1e2 | 2009-01-02 13:42:02 +0000 | [diff] [blame] | 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; |
Sukadev Bhattiprolu | 1f8f1e2 | 2009-01-02 13:42:02 +0000 | [diff] [blame] | 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; |
Sukadev Bhattiprolu | 1f8f1e2 | 2009-01-02 13:42:02 +0000 | [diff] [blame] | 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 | |
Sukadev Bhattiprolu | 2a1b2dc | 2009-01-02 13:42:27 +0000 | [diff] [blame] | 299 | err = parse_mount_options(data, PARSE_REMOUNT, opts); |
Sukadev Bhattiprolu | 1f8f1e2 | 2009-01-02 13:42:02 +0000 | [diff] [blame] | 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; |
Sukadev Bhattiprolu | 53af8ee | 2009-01-02 13:41:47 +0000 | [diff] [blame] | 310 | } |
| 311 | |
Al Viro | 34c80b1 | 2011-12-08 21:32:45 -0500 | [diff] [blame] | 312 | static int devpts_show_options(struct seq_file *seq, struct dentry *root) |
Miklos Szeredi | b87a267 | 2008-02-08 04:21:41 -0800 | [diff] [blame] | 313 | { |
Al Viro | 34c80b1 | 2011-12-08 21:32:45 -0500 | [diff] [blame] | 314 | struct pts_fs_info *fsi = DEVPTS_SB(root->d_sb); |
Sukadev Bhattiprolu | 31af0ab | 2009-01-02 13:41:33 +0000 | [diff] [blame] | 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); |
Sukadev Bhattiprolu | 1f8f1e2 | 2009-01-02 13:42:02 +0000 | [diff] [blame] | 322 | #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES |
| 323 | seq_printf(seq, ",ptmxmode=%03o", opts->ptmxmode); |
Konstantin Khlebnikov | e9aba51 | 2012-01-05 13:06:11 +0400 | [diff] [blame] | 324 | if (opts->max < NR_UNIX98_PTY_MAX) |
| 325 | seq_printf(seq, ",max=%d", opts->max); |
Sukadev Bhattiprolu | 1f8f1e2 | 2009-01-02 13:42:02 +0000 | [diff] [blame] | 326 | #endif |
Miklos Szeredi | b87a267 | 2008-02-08 04:21:41 -0800 | [diff] [blame] | 327 | |
| 328 | return 0; |
| 329 | } |
| 330 | |
Josef 'Jeff' Sipek | ee9b6d6 | 2007-02-12 00:55:41 -0800 | [diff] [blame] | 331 | static const struct super_operations devpts_sops = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 332 | .statfs = simple_statfs, |
| 333 | .remount_fs = devpts_remount, |
Miklos Szeredi | b87a267 | 2008-02-08 04:21:41 -0800 | [diff] [blame] | 334 | .show_options = devpts_show_options, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 335 | }; |
| 336 | |
Sukadev Bhattiprolu | e76b7c0 | 2009-01-02 13:41:21 +0000 | [diff] [blame] | 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); |
Sukadev Bhattiprolu | 31af0ab | 2009-01-02 13:41:33 +0000 | [diff] [blame] | 346 | fsi->mount_opts.mode = DEVPTS_DEFAULT_MODE; |
Sukadev Bhattiprolu | 1f8f1e2 | 2009-01-02 13:42:02 +0000 | [diff] [blame] | 347 | fsi->mount_opts.ptmxmode = DEVPTS_DEFAULT_PTMX_MODE; |
Sukadev Bhattiprolu | e76b7c0 | 2009-01-02 13:41:21 +0000 | [diff] [blame] | 348 | |
| 349 | return fsi; |
| 350 | } |
| 351 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 352 | static int |
| 353 | devpts_fill_super(struct super_block *s, void *data, int silent) |
| 354 | { |
Sukadev Bhattiprolu | 1f8f1e2 | 2009-01-02 13:42:02 +0000 | [diff] [blame] | 355 | struct inode *inode; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 361 | s->s_time_gran = 1; |
| 362 | |
Sukadev Bhattiprolu | e76b7c0 | 2009-01-02 13:41:21 +0000 | [diff] [blame] | 363 | s->s_fs_info = new_pts_fs_info(); |
| 364 | if (!s->s_fs_info) |
| 365 | goto fail; |
| 366 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 367 | inode = new_inode(s); |
| 368 | if (!inode) |
Al Viro | 3850aba | 2012-01-08 19:40:27 -0500 | [diff] [blame] | 369 | goto fail; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 370 | inode->i_ino = 1; |
| 371 | inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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; |
Miklos Szeredi | bfe8684 | 2011-10-28 14:13:29 +0200 | [diff] [blame] | 375 | set_nlink(inode, 2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 376 | |
Al Viro | 48fde70 | 2012-01-08 22:15:13 -0500 | [diff] [blame] | 377 | s->s_root = d_make_root(inode); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 378 | if (s->s_root) |
| 379 | return 0; |
Sukadev Bhattiprolu | 1f8f1e2 | 2009-01-02 13:42:02 +0000 | [diff] [blame] | 380 | |
Alan Cox | 835aa44 | 2009-01-02 13:42:48 +0000 | [diff] [blame] | 381 | printk(KERN_ERR "devpts: get root dentry failed\n"); |
Sukadev Bhattiprolu | e76b7c0 | 2009-01-02 13:41:21 +0000 | [diff] [blame] | 382 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 383 | fail: |
| 384 | return -ENOMEM; |
| 385 | } |
| 386 | |
Andrew Morton | 8c056e5 | 2009-01-02 13:44:12 +0000 | [diff] [blame] | 387 | #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES |
Sukadev Bhattiprolu | d4076ac | 2009-01-02 13:42:19 +0000 | [diff] [blame] | 388 | static int compare_init_pts_sb(struct super_block *s, void *p) |
| 389 | { |
| 390 | if (devpts_mnt) |
| 391 | return devpts_mnt->mnt_sb == s; |
Sukadev Bhattiprolu | 2a1b2dc | 2009-01-02 13:42:27 +0000 | [diff] [blame] | 392 | return 0; |
| 393 | } |
| 394 | |
Sukadev Bhattiprolu | 2a1b2dc | 2009-01-02 13:42:27 +0000 | [diff] [blame] | 395 | /* |
Al Viro | fc14f2f | 2010-07-25 01:48:30 +0400 | [diff] [blame] | 396 | * devpts_mount() |
Sukadev Bhattiprolu | 289f00e | 2009-03-07 10:12:06 -0800 | [diff] [blame] | 397 | * |
Sukadev Bhattiprolu | 1bd7903 | 2009-03-07 10:12:32 -0800 | [diff] [blame] | 398 | * If the '-o newinstance' mount option was specified, mount a new |
| 399 | * (private) instance of devpts. PTYs created in this instance are |
| 400 | * independent of the PTYs in other devpts instances. |
Sukadev Bhattiprolu | d4076ac | 2009-01-02 13:42:19 +0000 | [diff] [blame] | 401 | * |
Sukadev Bhattiprolu | 1bd7903 | 2009-03-07 10:12:32 -0800 | [diff] [blame] | 402 | * If the '-o newinstance' option was not specified, mount/remount the |
| 403 | * initial kernel mount of devpts. This type of mount gives the |
| 404 | * legacy, single-instance semantics. |
Sukadev Bhattiprolu | d4076ac | 2009-01-02 13:42:19 +0000 | [diff] [blame] | 405 | * |
Sukadev Bhattiprolu | 1bd7903 | 2009-03-07 10:12:32 -0800 | [diff] [blame] | 406 | * The 'newinstance' option is needed to support multiple namespace |
| 407 | * semantics in devpts while preserving backward compatibility of the |
| 408 | * current 'single-namespace' semantics. i.e all mounts of devpts |
| 409 | * without the 'newinstance' mount option should bind to the initial |
Al Viro | fc14f2f | 2010-07-25 01:48:30 +0400 | [diff] [blame] | 410 | * kernel mount, like mount_single(). |
Sukadev Bhattiprolu | d4076ac | 2009-01-02 13:42:19 +0000 | [diff] [blame] | 411 | * |
Sukadev Bhattiprolu | 1bd7903 | 2009-03-07 10:12:32 -0800 | [diff] [blame] | 412 | * Mounts with 'newinstance' option create a new, private namespace. |
| 413 | * |
| 414 | * NOTE: |
| 415 | * |
Al Viro | fc14f2f | 2010-07-25 01:48:30 +0400 | [diff] [blame] | 416 | * For single-mount semantics, devpts cannot use mount_single(), |
| 417 | * because mount_single()/sget() find and use the super-block from |
Sukadev Bhattiprolu | d4076ac | 2009-01-02 13:42:19 +0000 | [diff] [blame] | 418 | * the most recent mount of devpts. But that recent mount may be a |
Al Viro | fc14f2f | 2010-07-25 01:48:30 +0400 | [diff] [blame] | 419 | * 'newinstance' mount and mount_single() would pick the newinstance |
Sukadev Bhattiprolu | d4076ac | 2009-01-02 13:42:19 +0000 | [diff] [blame] | 420 | * super-block instead of the initial super-block. |
Sukadev Bhattiprolu | d4076ac | 2009-01-02 13:42:19 +0000 | [diff] [blame] | 421 | */ |
Al Viro | fc14f2f | 2010-07-25 01:48:30 +0400 | [diff] [blame] | 422 | static struct dentry *devpts_mount(struct file_system_type *fs_type, |
| 423 | int flags, const char *dev_name, void *data) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 424 | { |
Sukadev Bhattiprolu | 482984f | 2009-03-07 10:14:41 -0800 | [diff] [blame] | 425 | int error; |
| 426 | struct pts_mount_opts opts; |
Sukadev Bhattiprolu | 1bd7903 | 2009-03-07 10:12:32 -0800 | [diff] [blame] | 427 | struct super_block *s; |
Sukadev Bhattiprolu | 2a1b2dc | 2009-01-02 13:42:27 +0000 | [diff] [blame] | 428 | |
Sukadev Bhattiprolu | 1f71ebe | 2009-05-14 19:38:24 -0700 | [diff] [blame] | 429 | error = parse_mount_options(data, PARSE_MOUNT, &opts); |
| 430 | if (error) |
Al Viro | fc14f2f | 2010-07-25 01:48:30 +0400 | [diff] [blame] | 431 | return ERR_PTR(error); |
Sukadev Bhattiprolu | 2a1b2dc | 2009-01-02 13:42:27 +0000 | [diff] [blame] | 432 | |
Sukadev Bhattiprolu | 482984f | 2009-03-07 10:14:41 -0800 | [diff] [blame] | 433 | if (opts.newinstance) |
Sukadev Bhattiprolu | 1bd7903 | 2009-03-07 10:12:32 -0800 | [diff] [blame] | 434 | s = sget(fs_type, NULL, set_anon_super, NULL); |
Sukadev Bhattiprolu | 482984f | 2009-03-07 10:14:41 -0800 | [diff] [blame] | 435 | else |
Sukadev Bhattiprolu | 1bd7903 | 2009-03-07 10:12:32 -0800 | [diff] [blame] | 436 | s = sget(fs_type, compare_init_pts_sb, set_anon_super, NULL); |
Sukadev Bhattiprolu | 945cf2c | 2009-03-07 10:11:41 -0800 | [diff] [blame] | 437 | |
Sukadev Bhattiprolu | 1bd7903 | 2009-03-07 10:12:32 -0800 | [diff] [blame] | 438 | if (IS_ERR(s)) |
Al Viro | fc14f2f | 2010-07-25 01:48:30 +0400 | [diff] [blame] | 439 | return ERR_CAST(s); |
Sukadev Bhattiprolu | 945cf2c | 2009-03-07 10:11:41 -0800 | [diff] [blame] | 440 | |
Sukadev Bhattiprolu | 1bd7903 | 2009-03-07 10:12:32 -0800 | [diff] [blame] | 441 | if (!s->s_root) { |
| 442 | s->s_flags = flags; |
| 443 | error = devpts_fill_super(s, data, flags & MS_SILENT ? 1 : 0); |
| 444 | if (error) |
| 445 | goto out_undo_sget; |
| 446 | s->s_flags |= MS_ACTIVE; |
| 447 | } |
| 448 | |
Sukadev Bhattiprolu | 1bd7903 | 2009-03-07 10:12:32 -0800 | [diff] [blame] | 449 | memcpy(&(DEVPTS_SB(s))->mount_opts, &opts, sizeof(opts)); |
| 450 | |
| 451 | error = mknod_ptmx(s); |
Sukadev Bhattiprolu | 945cf2c | 2009-03-07 10:11:41 -0800 | [diff] [blame] | 452 | if (error) |
Al Viro | 8946807 | 2010-03-20 21:57:43 -0400 | [diff] [blame] | 453 | goto out_undo_sget; |
| 454 | |
Al Viro | fc14f2f | 2010-07-25 01:48:30 +0400 | [diff] [blame] | 455 | return dget(s->s_root); |
Sukadev Bhattiprolu | 945cf2c | 2009-03-07 10:11:41 -0800 | [diff] [blame] | 456 | |
Sukadev Bhattiprolu | 1bd7903 | 2009-03-07 10:12:32 -0800 | [diff] [blame] | 457 | out_undo_sget: |
Al Viro | 6f5bbff | 2009-05-06 01:34:22 -0400 | [diff] [blame] | 458 | deactivate_locked_super(s); |
Al Viro | fc14f2f | 2010-07-25 01:48:30 +0400 | [diff] [blame] | 459 | return ERR_PTR(error); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 460 | } |
Sukadev Bhattiprolu | 482984f | 2009-03-07 10:14:41 -0800 | [diff] [blame] | 461 | |
Sukadev Bhattiprolu | 2a1b2dc | 2009-01-02 13:42:27 +0000 | [diff] [blame] | 462 | #else |
| 463 | /* |
| 464 | * This supports only the legacy single-instance semantics (no |
| 465 | * multiple-instance semantics) |
| 466 | */ |
Al Viro | fc14f2f | 2010-07-25 01:48:30 +0400 | [diff] [blame] | 467 | static struct dentry *devpts_mount(struct file_system_type *fs_type, int flags, |
| 468 | const char *dev_name, void *data) |
Sukadev Bhattiprolu | 2a1b2dc | 2009-01-02 13:42:27 +0000 | [diff] [blame] | 469 | { |
Al Viro | fc14f2f | 2010-07-25 01:48:30 +0400 | [diff] [blame] | 470 | return mount_single(fs_type, flags, data, devpts_fill_super); |
Sukadev Bhattiprolu | 2a1b2dc | 2009-01-02 13:42:27 +0000 | [diff] [blame] | 471 | } |
| 472 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 473 | |
Sukadev Bhattiprolu | e76b7c0 | 2009-01-02 13:41:21 +0000 | [diff] [blame] | 474 | static void devpts_kill_sb(struct super_block *sb) |
| 475 | { |
| 476 | struct pts_fs_info *fsi = DEVPTS_SB(sb); |
| 477 | |
| 478 | kfree(fsi); |
Sukadev Bhattiprolu | 1f8f1e2 | 2009-01-02 13:42:02 +0000 | [diff] [blame] | 479 | kill_litter_super(sb); |
Sukadev Bhattiprolu | e76b7c0 | 2009-01-02 13:41:21 +0000 | [diff] [blame] | 480 | } |
| 481 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 482 | static struct file_system_type devpts_fs_type = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 483 | .name = "devpts", |
Al Viro | fc14f2f | 2010-07-25 01:48:30 +0400 | [diff] [blame] | 484 | .mount = devpts_mount, |
Sukadev Bhattiprolu | e76b7c0 | 2009-01-02 13:41:21 +0000 | [diff] [blame] | 485 | .kill_sb = devpts_kill_sb, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 486 | }; |
| 487 | |
| 488 | /* |
| 489 | * The normal naming convention is simply /dev/pts/<number>; this conforms |
| 490 | * to the System V naming convention |
| 491 | */ |
| 492 | |
Sukadev Bhattiprolu | 15f1a63 | 2008-10-13 10:42:59 +0100 | [diff] [blame] | 493 | int devpts_new_index(struct inode *ptmx_inode) |
Sukadev Bhattiprolu | 718a916 | 2008-04-30 00:54:21 -0700 | [diff] [blame] | 494 | { |
Sukadev Bhattiprolu | e76b7c0 | 2009-01-02 13:41:21 +0000 | [diff] [blame] | 495 | struct super_block *sb = pts_sb_from_inode(ptmx_inode); |
| 496 | struct pts_fs_info *fsi = DEVPTS_SB(sb); |
Sukadev Bhattiprolu | 718a916 | 2008-04-30 00:54:21 -0700 | [diff] [blame] | 497 | int index; |
Alexey Dobriyan | 7ee7c12 | 2008-07-26 11:42:16 +0400 | [diff] [blame] | 498 | int ida_ret; |
Sukadev Bhattiprolu | 718a916 | 2008-04-30 00:54:21 -0700 | [diff] [blame] | 499 | |
| 500 | retry: |
Alan Cox | 835aa44 | 2009-01-02 13:42:48 +0000 | [diff] [blame] | 501 | if (!ida_pre_get(&fsi->allocated_ptys, GFP_KERNEL)) |
Sukadev Bhattiprolu | 718a916 | 2008-04-30 00:54:21 -0700 | [diff] [blame] | 502 | return -ENOMEM; |
Sukadev Bhattiprolu | 718a916 | 2008-04-30 00:54:21 -0700 | [diff] [blame] | 503 | |
| 504 | mutex_lock(&allocated_ptys_lock); |
Konstantin Khlebnikov | e9aba51 | 2012-01-05 13:06:11 +0400 | [diff] [blame] | 505 | if (pty_count >= pty_limit - |
| 506 | (fsi->mount_opts.newinstance ? pty_reserve : 0)) { |
| 507 | mutex_unlock(&allocated_ptys_lock); |
| 508 | return -ENOSPC; |
| 509 | } |
| 510 | |
Sukadev Bhattiprolu | e76b7c0 | 2009-01-02 13:41:21 +0000 | [diff] [blame] | 511 | ida_ret = ida_get_new(&fsi->allocated_ptys, &index); |
Alexey Dobriyan | 7ee7c12 | 2008-07-26 11:42:16 +0400 | [diff] [blame] | 512 | if (ida_ret < 0) { |
Sukadev Bhattiprolu | 718a916 | 2008-04-30 00:54:21 -0700 | [diff] [blame] | 513 | mutex_unlock(&allocated_ptys_lock); |
Alexey Dobriyan | 7ee7c12 | 2008-07-26 11:42:16 +0400 | [diff] [blame] | 514 | if (ida_ret == -EAGAIN) |
Sukadev Bhattiprolu | 718a916 | 2008-04-30 00:54:21 -0700 | [diff] [blame] | 515 | goto retry; |
| 516 | return -EIO; |
| 517 | } |
| 518 | |
Konstantin Khlebnikov | e9aba51 | 2012-01-05 13:06:11 +0400 | [diff] [blame] | 519 | if (index >= fsi->mount_opts.max) { |
Sukadev Bhattiprolu | e76b7c0 | 2009-01-02 13:41:21 +0000 | [diff] [blame] | 520 | ida_remove(&fsi->allocated_ptys, index); |
Sukadev Bhattiprolu | 718a916 | 2008-04-30 00:54:21 -0700 | [diff] [blame] | 521 | mutex_unlock(&allocated_ptys_lock); |
Konstantin Khlebnikov | e9aba51 | 2012-01-05 13:06:11 +0400 | [diff] [blame] | 522 | return -ENOSPC; |
Sukadev Bhattiprolu | 718a916 | 2008-04-30 00:54:21 -0700 | [diff] [blame] | 523 | } |
Konstantin Khlebnikov | a4834c1 | 2012-01-05 13:06:02 +0400 | [diff] [blame] | 524 | pty_count++; |
Sukadev Bhattiprolu | 718a916 | 2008-04-30 00:54:21 -0700 | [diff] [blame] | 525 | mutex_unlock(&allocated_ptys_lock); |
| 526 | return index; |
| 527 | } |
| 528 | |
Sukadev Bhattiprolu | 15f1a63 | 2008-10-13 10:42:59 +0100 | [diff] [blame] | 529 | void devpts_kill_index(struct inode *ptmx_inode, int idx) |
Sukadev Bhattiprolu | 718a916 | 2008-04-30 00:54:21 -0700 | [diff] [blame] | 530 | { |
Sukadev Bhattiprolu | e76b7c0 | 2009-01-02 13:41:21 +0000 | [diff] [blame] | 531 | struct super_block *sb = pts_sb_from_inode(ptmx_inode); |
| 532 | struct pts_fs_info *fsi = DEVPTS_SB(sb); |
| 533 | |
Sukadev Bhattiprolu | 718a916 | 2008-04-30 00:54:21 -0700 | [diff] [blame] | 534 | mutex_lock(&allocated_ptys_lock); |
Sukadev Bhattiprolu | e76b7c0 | 2009-01-02 13:41:21 +0000 | [diff] [blame] | 535 | ida_remove(&fsi->allocated_ptys, idx); |
Konstantin Khlebnikov | a4834c1 | 2012-01-05 13:06:02 +0400 | [diff] [blame] | 536 | pty_count--; |
Sukadev Bhattiprolu | 718a916 | 2008-04-30 00:54:21 -0700 | [diff] [blame] | 537 | mutex_unlock(&allocated_ptys_lock); |
| 538 | } |
| 539 | |
Sukadev Bhattiprolu | 15f1a63 | 2008-10-13 10:42:59 +0100 | [diff] [blame] | 540 | int devpts_pty_new(struct inode *ptmx_inode, struct tty_struct *tty) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 541 | { |
Alan Cox | 835aa44 | 2009-01-02 13:42:48 +0000 | [diff] [blame] | 542 | /* tty layer puts index from devpts_new_index() in here */ |
| 543 | int number = tty->index; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 544 | struct tty_driver *driver = tty->driver; |
| 545 | dev_t device = MKDEV(driver->major, driver->minor_start+number); |
| 546 | struct dentry *dentry; |
Sukadev Bhattiprolu | 59e55e6 | 2009-01-02 13:41:11 +0000 | [diff] [blame] | 547 | struct super_block *sb = pts_sb_from_inode(ptmx_inode); |
| 548 | struct inode *inode = new_inode(sb); |
| 549 | struct dentry *root = sb->s_root; |
Sukadev Bhattiprolu | 31af0ab | 2009-01-02 13:41:33 +0000 | [diff] [blame] | 550 | struct pts_fs_info *fsi = DEVPTS_SB(sb); |
| 551 | struct pts_mount_opts *opts = &fsi->mount_opts; |
Andrey Vagin | aa597bc | 2011-02-08 00:14:52 +0300 | [diff] [blame] | 552 | int ret = 0; |
Sukadev Bhattiprolu | 89a52e1 | 2008-10-13 10:43:18 +0100 | [diff] [blame] | 553 | char s[12]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 554 | |
| 555 | /* We're supposed to be given the slave end of a pty */ |
| 556 | BUG_ON(driver->type != TTY_DRIVER_TYPE_PTY); |
| 557 | BUG_ON(driver->subtype != PTY_TYPE_SLAVE); |
| 558 | |
| 559 | if (!inode) |
| 560 | return -ENOMEM; |
| 561 | |
David Howells | d0eafc7 | 2009-01-02 13:44:49 +0000 | [diff] [blame] | 562 | inode->i_ino = number + 3; |
| 563 | inode->i_uid = opts->setuid ? opts->uid : current_fsuid(); |
| 564 | inode->i_gid = opts->setgid ? opts->gid : current_fsgid(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 565 | inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; |
Sukadev Bhattiprolu | 31af0ab | 2009-01-02 13:41:33 +0000 | [diff] [blame] | 566 | init_special_inode(inode, S_IFCHR|opts->mode, device); |
Theodore Ts'o | 8e18e29 | 2006-09-27 01:50:46 -0700 | [diff] [blame] | 567 | inode->i_private = tty; |
Sukadev Bhattiprolu | a6f37da | 2008-10-13 10:43:27 +0100 | [diff] [blame] | 568 | tty->driver_data = inode; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 569 | |
Sukadev Bhattiprolu | 89a52e1 | 2008-10-13 10:43:18 +0100 | [diff] [blame] | 570 | sprintf(s, "%d", number); |
| 571 | |
Sukadev Bhattiprolu | 59e55e6 | 2009-01-02 13:41:11 +0000 | [diff] [blame] | 572 | mutex_lock(&root->d_inode->i_mutex); |
Sukadev Bhattiprolu | 89a52e1 | 2008-10-13 10:43:18 +0100 | [diff] [blame] | 573 | |
Sukadev Bhattiprolu | 59e55e6 | 2009-01-02 13:41:11 +0000 | [diff] [blame] | 574 | dentry = d_alloc_name(root, s); |
Andrey Vagin | b12d125 | 2011-03-22 16:35:11 -0700 | [diff] [blame] | 575 | if (dentry) { |
Sukadev Bhattiprolu | 89a52e1 | 2008-10-13 10:43:18 +0100 | [diff] [blame] | 576 | d_add(dentry, inode); |
Sukadev Bhattiprolu | 59e55e6 | 2009-01-02 13:41:11 +0000 | [diff] [blame] | 577 | fsnotify_create(root->d_inode, dentry); |
Andrey Vagin | aa597bc | 2011-02-08 00:14:52 +0300 | [diff] [blame] | 578 | } else { |
| 579 | iput(inode); |
| 580 | ret = -ENOMEM; |
Florin Malita | 3972b7f | 2007-05-08 00:24:18 -0700 | [diff] [blame] | 581 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 582 | |
Sukadev Bhattiprolu | 59e55e6 | 2009-01-02 13:41:11 +0000 | [diff] [blame] | 583 | mutex_unlock(&root->d_inode->i_mutex); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 584 | |
Andrey Vagin | aa597bc | 2011-02-08 00:14:52 +0300 | [diff] [blame] | 585 | return ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 586 | } |
| 587 | |
Sukadev Bhattiprolu | 15f1a63 | 2008-10-13 10:42:59 +0100 | [diff] [blame] | 588 | struct tty_struct *devpts_get_tty(struct inode *pts_inode, int number) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 589 | { |
Sukadev Bhattiprolu | edfacdd | 2009-11-17 18:35:43 -0800 | [diff] [blame] | 590 | struct dentry *dentry; |
| 591 | struct tty_struct *tty; |
| 592 | |
Sukadev Bhattiprolu | 527b3e4 | 2008-10-13 10:43:08 +0100 | [diff] [blame] | 593 | BUG_ON(pts_inode->i_rdev == MKDEV(TTYAUX_MAJOR, PTMX_MINOR)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 594 | |
Sukadev Bhattiprolu | edfacdd | 2009-11-17 18:35:43 -0800 | [diff] [blame] | 595 | /* Ensure dentry has not been deleted by devpts_pty_kill() */ |
| 596 | dentry = d_find_alias(pts_inode); |
| 597 | if (!dentry) |
| 598 | return NULL; |
| 599 | |
| 600 | tty = NULL; |
Sukadev Bhattiprolu | 527b3e4 | 2008-10-13 10:43:08 +0100 | [diff] [blame] | 601 | if (pts_inode->i_sb->s_magic == DEVPTS_SUPER_MAGIC) |
Sukadev Bhattiprolu | edfacdd | 2009-11-17 18:35:43 -0800 | [diff] [blame] | 602 | tty = (struct tty_struct *)pts_inode->i_private; |
| 603 | |
| 604 | dput(dentry); |
| 605 | |
| 606 | return tty; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 607 | } |
| 608 | |
Sukadev Bhattiprolu | 15f1a63 | 2008-10-13 10:42:59 +0100 | [diff] [blame] | 609 | void devpts_pty_kill(struct tty_struct *tty) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 610 | { |
Sukadev Bhattiprolu | a6f37da | 2008-10-13 10:43:27 +0100 | [diff] [blame] | 611 | struct inode *inode = tty->driver_data; |
Sukadev Bhattiprolu | 59e55e6 | 2009-01-02 13:41:11 +0000 | [diff] [blame] | 612 | struct super_block *sb = pts_sb_from_inode(inode); |
| 613 | struct dentry *root = sb->s_root; |
Sukadev Bhattiprolu | a6f37da | 2008-10-13 10:43:27 +0100 | [diff] [blame] | 614 | struct dentry *dentry; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 615 | |
Sukadev Bhattiprolu | a6f37da | 2008-10-13 10:43:27 +0100 | [diff] [blame] | 616 | BUG_ON(inode->i_rdev == MKDEV(TTYAUX_MAJOR, PTMX_MINOR)); |
| 617 | |
Sukadev Bhattiprolu | 59e55e6 | 2009-01-02 13:41:11 +0000 | [diff] [blame] | 618 | mutex_lock(&root->d_inode->i_mutex); |
Sukadev Bhattiprolu | a6f37da | 2008-10-13 10:43:27 +0100 | [diff] [blame] | 619 | |
| 620 | dentry = d_find_alias(inode); |
Sukadev Bhattiprolu | 2a1b2dc | 2009-01-02 13:42:27 +0000 | [diff] [blame] | 621 | |
Miklos Szeredi | 6d6b77f | 2011-10-28 14:13:28 +0200 | [diff] [blame] | 622 | drop_nlink(inode); |
Andrey Vagin | aa597bc | 2011-02-08 00:14:52 +0300 | [diff] [blame] | 623 | d_delete(dentry); |
| 624 | dput(dentry); /* d_alloc_name() in devpts_pty_new() */ |
Alan Cox | 835aa44 | 2009-01-02 13:42:48 +0000 | [diff] [blame] | 625 | dput(dentry); /* d_find_alias above */ |
Andrey Vagin | aa597bc | 2011-02-08 00:14:52 +0300 | [diff] [blame] | 626 | |
Sukadev Bhattiprolu | 59e55e6 | 2009-01-02 13:41:11 +0000 | [diff] [blame] | 627 | mutex_unlock(&root->d_inode->i_mutex); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 628 | } |
| 629 | |
| 630 | static int __init init_devpts_fs(void) |
| 631 | { |
| 632 | int err = register_filesystem(&devpts_fs_type); |
Konstantin Khlebnikov | a4834c1 | 2012-01-05 13:06:02 +0400 | [diff] [blame] | 633 | struct ctl_table_header *table; |
| 634 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 635 | if (!err) { |
Konstantin Khlebnikov | a4834c1 | 2012-01-05 13:06:02 +0400 | [diff] [blame] | 636 | table = register_sysctl_table(pty_root_table); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 637 | devpts_mnt = kern_mount(&devpts_fs_type); |
Alan Cox | 93d5581 | 2009-06-11 14:03:55 +0100 | [diff] [blame] | 638 | if (IS_ERR(devpts_mnt)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 639 | err = PTR_ERR(devpts_mnt); |
Alan Cox | 93d5581 | 2009-06-11 14:03:55 +0100 | [diff] [blame] | 640 | unregister_filesystem(&devpts_fs_type); |
Konstantin Khlebnikov | a4834c1 | 2012-01-05 13:06:02 +0400 | [diff] [blame] | 641 | unregister_sysctl_table(table); |
Alan Cox | 93d5581 | 2009-06-11 14:03:55 +0100 | [diff] [blame] | 642 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 643 | } |
| 644 | return err; |
| 645 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 646 | module_init(init_devpts_fs) |