FreeBSD/Linux Kernel Cross Reference
sys/kern/tty_ptm.c
1 /* $NetBSD: tty_ptm.c,v 1.45 2022/09/29 12:18:27 christos Exp $ */
2
3 /*-
4 * Copyright (c) 2004, 2020 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include <sys/cdefs.h>
30 __KERNEL_RCSID(0, "$NetBSD: tty_ptm.c,v 1.45 2022/09/29 12:18:27 christos Exp $");
31
32 #ifdef _KERNEL_OPT
33 #include "opt_compat_netbsd.h"
34 #include "opt_ptm.h"
35 #endif
36
37 /* pty multiplexor driver /dev/ptm{,x} */
38
39 #include <sys/param.h>
40 #include <sys/systm.h>
41 #include <sys/ioctl.h>
42 #include <sys/proc.h>
43 #include <sys/tty.h>
44 #include <sys/stat.h>
45 #include <sys/file.h>
46 #include <sys/uio.h>
47 #include <sys/kernel.h>
48 #include <sys/vnode.h>
49 #include <sys/namei.h>
50 #include <sys/signalvar.h>
51 #include <sys/filedesc.h>
52 #include <sys/conf.h>
53 #include <sys/poll.h>
54 #include <sys/pty.h>
55 #include <sys/kauth.h>
56 #include <sys/compat_stub.h>
57
58 #include <miscfs/specfs/specdev.h>
59
60 #include <compat/sys/ttycom.h>
61
62 #include "ioconf.h"
63
64 #ifdef DEBUG_PTM
65 #define DPRINTF(a) printf a
66 #else
67 #define DPRINTF(a)
68 #endif
69
70 #ifdef NO_DEV_PTM
71 const struct cdevsw ptm_cdevsw = {
72 .d_open = noopen,
73 .d_close = noclose,
74 .d_read = noread,
75 .d_write = nowrite,
76 .d_ioctl = noioctl,
77 .d_stop = nostop,
78 .d_tty = notty,
79 .d_poll = nopoll,
80 .d_mmap = nommap,
81 .d_kqfilter = nokqfilter,
82 .d_discard = nodiscard,
83 .d_flag = D_TTY
84 };
85 #else
86
87 int pts_major, ptc_major;
88
89 static dev_t pty_getfree(void);
90 static int pty_alloc_master(struct lwp *, int *, dev_t *, struct mount *, int);
91 static int pty_alloc_slave(struct lwp *, int *, dev_t, struct mount *);
92 static int pty_vn_open(struct vnode *, struct lwp *);
93
94 int
95 pty_getmp(struct lwp *l, struct mount **mpp)
96 {
97 if (ptm == NULL)
98 return EOPNOTSUPP;
99
100 return (*ptm->getmp)(l, mpp);
101 }
102
103 dev_t
104 pty_makedev(char ms, int minor)
105 {
106 return makedev(ms == 't' ? pts_major : ptc_major, minor);
107 }
108
109
110 static dev_t
111 pty_getfree(void)
112 {
113 extern kmutex_t pt_softc_mutex;
114 int i;
115
116 mutex_enter(&pt_softc_mutex);
117 for (i = 0; i < npty; i++) {
118 if (pty_isfree(i, 0))
119 break;
120 }
121 mutex_exit(&pt_softc_mutex);
122 return pty_makedev('t', i);
123 }
124
125 /*
126 * Hacked up version of vn_open. We _only_ handle ptys and only open
127 * them with FREAD|FWRITE and never deal with creat or stuff like that.
128 *
129 * We need it because we have to fake up root credentials to open the pty.
130 */
131 int
132 pty_vn_open(struct vnode *vp, struct lwp *l)
133 {
134 int error;
135
136 if (vp->v_type != VCHR) {
137 vput(vp);
138 return EINVAL;
139 }
140
141 error = VOP_OPEN(vp, FREAD|FWRITE, lwp0.l_cred);
142
143 if (error) {
144 /* only ptys mean we can't get these */
145 KASSERT(error != EDUPFD && error != EMOVEFD);
146 vput(vp);
147 return error;
148 }
149
150 mutex_enter(vp->v_interlock);
151 vp->v_writecount++;
152 mutex_exit(vp->v_interlock);
153
154 return 0;
155 }
156
157 static int
158 pty_alloc_master(struct lwp *l, int *fd, dev_t *dev, struct mount *mp,
159 int flags)
160 {
161 int error;
162 struct file *fp;
163 struct vnode *vp;
164 int md;
165
166 if ((error = fd_allocfile(&fp, fd)) != 0) {
167 DPRINTF(("fd_allocfile %d\n", error));
168 return error;
169 }
170 retry:
171 /* Find and open a free master pty. */
172 *dev = pty_getfree();
173 md = minor(*dev);
174 if ((error = pty_check(md)) != 0) {
175 DPRINTF(("pty_check %d\n", error));
176 goto bad;
177 }
178 if (ptm == NULL) {
179 DPRINTF(("no ptm\n"));
180 error = EOPNOTSUPP;
181 goto bad;
182 }
183 if ((error = (*ptm->allocvp)(mp, l, &vp, *dev, 'p')) != 0) {
184 DPRINTF(("pty_allocvp %d\n", error));
185 goto bad;
186 }
187
188 if ((error = pty_vn_open(vp, l)) != 0) {
189 DPRINTF(("pty_vn_open %d\n", error));
190 /*
191 * Check if the master open failed because we lost
192 * the race to grab it.
193 */
194 if (error != EIO)
195 goto bad;
196 error = !pty_isfree(md, 1);
197 DPRINTF(("pty_isfree %d\n", error));
198 if (error)
199 goto retry;
200 else
201 goto bad;
202 }
203 fp->f_flag = FREAD|FWRITE|(flags&FMASK);
204 fp->f_type = DTYPE_VNODE;
205 fp->f_ops = &vnops;
206 fp->f_vnode = vp;
207
208 VOP_UNLOCK(vp);
209 fd_set_exclose(l, *fd, (flags & O_CLOEXEC) != 0);
210 fd_affix(curproc, fp, *fd);
211 return 0;
212 bad:
213 fd_abort(curproc, fp, *fd);
214 return error;
215 }
216
217 int
218 pty_grant_slave(struct lwp *l, dev_t dev, struct mount *mp)
219 {
220 int error;
221 struct vnode *vp;
222
223 /*
224 * Open the slave.
225 * namei -> setattr -> unlock -> revoke -> vrele ->
226 * namei -> open -> unlock
227 * Three stage rocket:
228 * 1. Change the owner and permissions on the slave.
229 * 2. Revoke all the users of the slave.
230 * 3. open the slave.
231 */
232 if (ptm == NULL)
233 return EOPNOTSUPP;
234 if ((error = (*ptm->allocvp)(mp, l, &vp, dev, 't')) != 0)
235 return error;
236
237 if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
238 struct vattr vattr;
239 (*ptm->getvattr)(mp, l, &vattr);
240 /* Do the VOP_SETATTR() as root. */
241 error = VOP_SETATTR(vp, &vattr, lwp0.l_cred);
242 if (error) {
243 DPRINTF(("setattr %d\n", error));
244 vput(vp);
245 return error;
246 }
247 }
248 VOP_UNLOCK(vp);
249 VOP_REVOKE(vp, REVOKEALL);
250
251 /*
252 * The vnode is useless after the revoke, we need to get it again.
253 */
254 vrele(vp);
255 return 0;
256 }
257
258 static int
259 pty_alloc_slave(struct lwp *l, int *fd, dev_t dev, struct mount *mp)
260 {
261 int error;
262 struct file *fp;
263 struct vnode *vp;
264
265 /* Grab a filedescriptor for the slave */
266 if ((error = fd_allocfile(&fp, fd)) != 0) {
267 DPRINTF(("fd_allocfile %d\n", error));
268 return error;
269 }
270
271 if (ptm == NULL) {
272 error = EOPNOTSUPP;
273 goto bad;
274 }
275
276 if ((error = (*ptm->allocvp)(mp, l, &vp, dev, 't')) != 0)
277 goto bad;
278 if ((error = pty_vn_open(vp, l)) != 0)
279 goto bad;
280
281 fp->f_flag = FREAD|FWRITE;
282 fp->f_type = DTYPE_VNODE;
283 fp->f_ops = &vnops;
284 fp->f_vnode = vp;
285 VOP_UNLOCK(vp);
286 fd_affix(curproc, fp, *fd);
287 return 0;
288 bad:
289 fd_abort(curproc, fp, *fd);
290 return error;
291 }
292
293 struct ptm_pty *
294 pty_sethandler(struct ptm_pty *nptm)
295 {
296 struct ptm_pty *optm = ptm;
297 ptm = nptm;
298 return optm;
299 }
300
301 int
302 pty_fill_ptmget(struct lwp *l, dev_t dev, int cfd, int sfd, void *data, struct mount *mp)
303 {
304 struct ptmget *ptmg = data;
305 int error;
306
307 if (ptm == NULL)
308 return EOPNOTSUPP;
309
310 ptmg->cfd = cfd == -1 ? minor(dev) : cfd;
311 ptmg->sfd = sfd == -1 ? minor(dev) : sfd;
312
313 error = (*ptm->makename)(mp, l, ptmg->cn, sizeof(ptmg->cn), dev, 'p');
314 if (error)
315 return error;
316
317 return (*ptm->makename)(mp, l, ptmg->sn, sizeof(ptmg->sn), dev, 't');
318 }
319
320 void
321 /*ARGSUSED*/
322 ptmattach(int n)
323 {
324 extern const struct cdevsw pts_cdevsw, ptc_cdevsw;
325 /* find the major and minor of the pty devices */
326 if ((pts_major = cdevsw_lookup_major(&pts_cdevsw)) == -1)
327 panic("%s: Can't find pty slave in cdevsw", __func__);
328 if ((ptc_major = cdevsw_lookup_major(&ptc_cdevsw)) == -1)
329 panic("%s: Can't find pty master in cdevsw", __func__);
330 #ifdef COMPAT_BSDPTY
331 ptm = &ptm_bsdpty;
332 #endif
333 }
334
335 static int
336 /*ARGSUSED*/
337 ptmopen(dev_t dev, int flag, int mode, struct lwp *l)
338 {
339 int error;
340 int fd;
341 dev_t ttydev;
342 struct mount *mp;
343
344 switch(minor(dev)) {
345 case 0: /* /dev/ptmx */
346 case 2: /* /emul/linux/dev/ptmx */
347 if ((error = pty_getmp(l, &mp)) != 0)
348 return error;
349 if ((error = pty_alloc_master(l, &fd, &ttydev, mp, flag)) != 0)
350 return error;
351 if (minor(dev) == 2) {
352 /*
353 * Linux ptyfs grants the pty right here.
354 * Handle this case here, instead of writing
355 * a new linux module.
356 */
357 if ((error = pty_grant_slave(l, ttydev, mp)) != 0) {
358 file_t *fp = fd_getfile(fd);
359 if (fp != NULL) {
360 fd_close(fd);
361 }
362 return error;
363 }
364 }
365 curlwp->l_dupfd = fd;
366 return EMOVEFD;
367 case 1: /* /dev/ptm */
368 return 0;
369 default:
370 return ENODEV;
371 }
372 }
373
374 static int
375 /*ARGSUSED*/
376 ptmclose(dev_t dev, int flag, int mode, struct lwp *l)
377 {
378
379 return (0);
380 }
381
382 static int
383 /*ARGSUSED*/
384 ptmioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
385 {
386 int error;
387 dev_t newdev;
388 int cfd, sfd;
389 file_t *fp;
390 struct mount *mp;
391
392 error = 0;
393 switch (cmd) {
394 case TIOCPTMGET:
395 if ((error = pty_getmp(l, &mp)) != 0)
396 return error;
397
398 if ((error = pty_alloc_master(l, &cfd, &newdev, mp, 0)) != 0)
399 return error;
400
401 if ((error = pty_grant_slave(l, newdev, mp)) != 0)
402 goto bad;
403
404 if ((error = pty_alloc_slave(l, &sfd, newdev, mp)) != 0)
405 goto bad;
406
407 /* now, put the indices and names into struct ptmget */
408 if ((error = pty_fill_ptmget(l, newdev, cfd, sfd, data, mp)) != 0)
409 goto bad2;
410 return 0;
411 default:
412 MODULE_HOOK_CALL(tty_ptmioctl_60_hook,
413 (dev, cmd, data, flag, l), EPASSTHROUGH, error);
414 if (error != EPASSTHROUGH)
415 return error;
416 DPRINTF(("ptmioctl EINVAL\n"));
417 return EINVAL;
418 }
419 bad2:
420 fp = fd_getfile(sfd);
421 if (fp != NULL) {
422 fd_close(sfd);
423 }
424 bad:
425 fp = fd_getfile(cfd);
426 if (fp != NULL) {
427 fd_close(cfd);
428 }
429 return error;
430 }
431
432 const struct cdevsw ptm_cdevsw = {
433 .d_open = ptmopen,
434 .d_close = ptmclose,
435 .d_read = noread,
436 .d_write = nowrite,
437 .d_ioctl = ptmioctl,
438 .d_stop = nullstop,
439 .d_tty = notty,
440 .d_poll = nopoll,
441 .d_mmap = nommap,
442 .d_kqfilter = nokqfilter,
443 .d_discard = nodiscard,
444 .d_flag = D_TTY
445 };
446 #endif
Cache object: a0b7f68d76d5351920d6871f7f2147c4
|