ptyfs_vnops.c revision 1.12
1 /* $NetBSD: ptyfs_vnops.c,v 1.12 2005/12/11 12:24:29 christos Exp $ */ 2 3 /* 4 * Copyright (c) 1993, 1995 5 * The Regents of the University of California. All rights reserved. 6 * 7 * This code is derived from software contributed to Berkeley by 8 * Jan-Simon Pendry. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 * @(#)procfs_vnops.c 8.18 (Berkeley) 5/21/95 35 */ 36 37 /* 38 * Copyright (c) 1993 Jan-Simon Pendry 39 * 40 * This code is derived from software contributed to Berkeley by 41 * Jan-Simon Pendry. 42 * 43 * Redistribution and use in source and binary forms, with or without 44 * modification, are permitted provided that the following conditions 45 * are met: 46 * 1. Redistributions of source code must retain the above copyright 47 * notice, this list of conditions and the following disclaimer. 48 * 2. Redistributions in binary form must reproduce the above copyright 49 * notice, this list of conditions and the following disclaimer in the 50 * documentation and/or other materials provided with the distribution. 51 * 3. All advertising materials mentioning features or use of this software 52 * must display the following acknowledgement: 53 * This product includes software developed by the University of 54 * California, Berkeley and its contributors. 55 * 4. Neither the name of the University nor the names of its contributors 56 * may be used to endorse or promote products derived from this software 57 * without specific prior written permission. 58 * 59 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 60 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 61 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 62 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 63 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 64 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 65 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 66 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 67 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 68 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 69 * SUCH DAMAGE. 70 * 71 * @(#)procfs_vnops.c 8.18 (Berkeley) 5/21/95 72 */ 73 74 /* 75 * ptyfs vnode interface 76 */ 77 78 #include <sys/cdefs.h> 79 __KERNEL_RCSID(0, "$NetBSD: ptyfs_vnops.c,v 1.12 2005/12/11 12:24:29 christos Exp $"); 80 81 #include <sys/param.h> 82 #include <sys/systm.h> 83 #include <sys/time.h> 84 #include <sys/kernel.h> 85 #include <sys/file.h> 86 #include <sys/filedesc.h> 87 #include <sys/proc.h> 88 #include <sys/vnode.h> 89 #include <sys/namei.h> 90 #include <sys/malloc.h> 91 #include <sys/mount.h> 92 #include <sys/select.h> 93 #include <sys/dirent.h> 94 #include <sys/resourcevar.h> 95 #include <sys/stat.h> 96 #include <sys/conf.h> 97 #include <sys/tty.h> 98 #include <sys/pty.h> 99 100 #include <uvm/uvm_extern.h> /* for PAGE_SIZE */ 101 102 #include <machine/reg.h> 103 104 #include <fs/ptyfs/ptyfs.h> 105 #include <miscfs/genfs/genfs.h> 106 #include <miscfs/specfs/specdev.h> 107 108 /* 109 * Vnode Operations. 110 * 111 */ 112 113 int ptyfs_lookup (void *); 114 #define ptyfs_create genfs_eopnotsupp 115 #define ptyfs_mknod genfs_eopnotsupp 116 int ptyfs_open (void *); 117 int ptyfs_close (void *); 118 int ptyfs_access (void *); 119 int ptyfs_getattr (void *); 120 int ptyfs_setattr (void *); 121 int ptyfs_read (void *); 122 int ptyfs_write (void *); 123 #define ptyfs_fcntl genfs_fcntl 124 int ptyfs_ioctl (void *); 125 int ptyfs_poll (void *); 126 int ptyfs_kqfilter (void *); 127 #define ptyfs_revoke genfs_revoke 128 #define ptyfs_mmap genfs_eopnotsupp 129 #define ptyfs_fsync genfs_nullop 130 #define ptyfs_seek genfs_nullop 131 #define ptyfs_remove genfs_eopnotsupp 132 #define ptyfs_link genfs_abortop 133 #define ptyfs_rename genfs_eopnotsupp 134 #define ptyfs_mkdir genfs_eopnotsupp 135 #define ptyfs_rmdir genfs_eopnotsupp 136 #define ptyfs_symlink genfs_abortop 137 int ptyfs_readdir (void *); 138 #define ptyfs_readlink genfs_eopnotsupp 139 #define ptyfs_abortop genfs_abortop 140 int ptyfs_reclaim (void *); 141 #define ptyfs_lock genfs_lock 142 #define ptyfs_unlock genfs_unlock 143 #define ptyfs_bmap genfs_badop 144 #define ptyfs_strategy genfs_badop 145 int ptyfs_print (void *); 146 int ptyfs_pathconf (void *); 147 #define ptyfs_islocked genfs_islocked 148 #define ptyfs_advlock genfs_einval 149 #define ptyfs_bwrite genfs_eopnotsupp 150 #define ptyfs_putpages genfs_null_putpages 151 152 static int ptyfs_update(struct vnode *, const struct timespec *, 153 const struct timespec *, int); 154 static int ptyfs_chown(struct vnode *, uid_t, gid_t, struct ucred *, 155 struct proc *); 156 static int ptyfs_chmod(struct vnode *, mode_t, struct ucred *, struct proc *); 157 static int atoi(const char *, size_t); 158 159 extern const struct cdevsw pts_cdevsw, ptc_cdevsw; 160 161 /* 162 * ptyfs vnode operations. 163 */ 164 int (**ptyfs_vnodeop_p)(void *); 165 const struct vnodeopv_entry_desc ptyfs_vnodeop_entries[] = { 166 { &vop_default_desc, vn_default_error }, 167 { &vop_lookup_desc, ptyfs_lookup }, /* lookup */ 168 { &vop_create_desc, ptyfs_create }, /* create */ 169 { &vop_mknod_desc, ptyfs_mknod }, /* mknod */ 170 { &vop_open_desc, ptyfs_open }, /* open */ 171 { &vop_close_desc, ptyfs_close }, /* close */ 172 { &vop_access_desc, ptyfs_access }, /* access */ 173 { &vop_getattr_desc, ptyfs_getattr }, /* getattr */ 174 { &vop_setattr_desc, ptyfs_setattr }, /* setattr */ 175 { &vop_read_desc, ptyfs_read }, /* read */ 176 { &vop_write_desc, ptyfs_write }, /* write */ 177 { &vop_ioctl_desc, ptyfs_ioctl }, /* ioctl */ 178 { &vop_fcntl_desc, ptyfs_fcntl }, /* fcntl */ 179 { &vop_poll_desc, ptyfs_poll }, /* poll */ 180 { &vop_kqfilter_desc, ptyfs_kqfilter }, /* kqfilter */ 181 { &vop_revoke_desc, ptyfs_revoke }, /* revoke */ 182 { &vop_mmap_desc, ptyfs_mmap }, /* mmap */ 183 { &vop_fsync_desc, ptyfs_fsync }, /* fsync */ 184 { &vop_seek_desc, ptyfs_seek }, /* seek */ 185 { &vop_remove_desc, ptyfs_remove }, /* remove */ 186 { &vop_link_desc, ptyfs_link }, /* link */ 187 { &vop_rename_desc, ptyfs_rename }, /* rename */ 188 { &vop_mkdir_desc, ptyfs_mkdir }, /* mkdir */ 189 { &vop_rmdir_desc, ptyfs_rmdir }, /* rmdir */ 190 { &vop_symlink_desc, ptyfs_symlink }, /* symlink */ 191 { &vop_readdir_desc, ptyfs_readdir }, /* readdir */ 192 { &vop_readlink_desc, ptyfs_readlink }, /* readlink */ 193 { &vop_abortop_desc, ptyfs_abortop }, /* abortop */ 194 { &vop_inactive_desc, spec_inactive }, /* inactive */ 195 { &vop_reclaim_desc, ptyfs_reclaim }, /* reclaim */ 196 { &vop_lock_desc, ptyfs_lock }, /* lock */ 197 { &vop_unlock_desc, ptyfs_unlock }, /* unlock */ 198 { &vop_bmap_desc, ptyfs_bmap }, /* bmap */ 199 { &vop_strategy_desc, ptyfs_strategy }, /* strategy */ 200 { &vop_print_desc, ptyfs_print }, /* print */ 201 { &vop_islocked_desc, ptyfs_islocked }, /* islocked */ 202 { &vop_pathconf_desc, ptyfs_pathconf }, /* pathconf */ 203 { &vop_advlock_desc, ptyfs_advlock }, /* advlock */ 204 { &vop_bwrite_desc, ptyfs_bwrite }, /* bwrite */ 205 { &vop_putpages_desc, ptyfs_putpages }, /* putpages */ 206 { NULL, NULL } 207 }; 208 const struct vnodeopv_desc ptyfs_vnodeop_opv_desc = 209 { &ptyfs_vnodeop_p, ptyfs_vnodeop_entries }; 210 211 /* 212 * _reclaim is called when getnewvnode() 213 * wants to make use of an entry on the vnode 214 * free list. at this time the filesystem needs 215 * to free any private data and remove the node 216 * from any private lists. 217 */ 218 int 219 ptyfs_reclaim(void *v) 220 { 221 struct vop_reclaim_args /* { 222 struct vnode *a_vp; 223 } */ *ap = v; 224 return ptyfs_freevp(ap->a_vp); 225 } 226 227 /* 228 * Return POSIX pathconf information applicable to special devices. 229 */ 230 int 231 ptyfs_pathconf(void *v) 232 { 233 struct vop_pathconf_args /* { 234 struct vnode *a_vp; 235 int a_name; 236 register_t *a_retval; 237 } */ *ap = v; 238 239 switch (ap->a_name) { 240 case _PC_LINK_MAX: 241 *ap->a_retval = LINK_MAX; 242 return 0; 243 case _PC_MAX_CANON: 244 *ap->a_retval = MAX_CANON; 245 return 0; 246 case _PC_MAX_INPUT: 247 *ap->a_retval = MAX_INPUT; 248 return 0; 249 case _PC_PIPE_BUF: 250 *ap->a_retval = PIPE_BUF; 251 return 0; 252 case _PC_CHOWN_RESTRICTED: 253 *ap->a_retval = 1; 254 return 0; 255 case _PC_VDISABLE: 256 *ap->a_retval = _POSIX_VDISABLE; 257 return 0; 258 case _PC_SYNC_IO: 259 *ap->a_retval = 1; 260 return 0; 261 default: 262 return EINVAL; 263 } 264 } 265 266 /* 267 * _print is used for debugging. 268 * just print a readable description 269 * of (vp). 270 */ 271 int 272 ptyfs_print(void *v) 273 { 274 struct vop_print_args /* { 275 struct vnode *a_vp; 276 } */ *ap = v; 277 struct ptyfsnode *ptyfs = VTOPTYFS(ap->a_vp); 278 279 printf("tag VT_PTYFS, type %d, pty %d\n", 280 ptyfs->ptyfs_type, ptyfs->ptyfs_pty); 281 return 0; 282 } 283 284 /* 285 * Invent attributes for ptyfsnode (vp) and store 286 * them in (vap). 287 * Directories lengths are returned as zero since 288 * any real length would require the genuine size 289 * to be computed, and nothing cares anyway. 290 * 291 * this is relatively minimal for ptyfs. 292 */ 293 int 294 ptyfs_getattr(void *v) 295 { 296 struct vop_getattr_args /* { 297 struct vnode *a_vp; 298 struct vattr *a_vap; 299 struct ucred *a_cred; 300 struct lwp *a_l; 301 } */ *ap = v; 302 struct ptyfsnode *ptyfs = VTOPTYFS(ap->a_vp); 303 struct vattr *vap = ap->a_vap; 304 305 PTYFS_ITIMES(ptyfs, NULL, NULL, NULL); 306 307 /* start by zeroing out the attributes */ 308 VATTR_NULL(vap); 309 310 /* next do all the common fields */ 311 vap->va_type = ap->a_vp->v_type; 312 vap->va_fsid = ap->a_vp->v_mount->mnt_stat.f_fsidx.__fsid_val[0]; 313 vap->va_fileid = ptyfs->ptyfs_fileno; 314 vap->va_gen = 0; 315 vap->va_flags = 0; 316 vap->va_nlink = 1; 317 vap->va_blocksize = PAGE_SIZE; 318 319 vap->va_atime = ptyfs->ptyfs_atime; 320 vap->va_mtime = ptyfs->ptyfs_mtime; 321 vap->va_ctime = ptyfs->ptyfs_ctime; 322 vap->va_birthtime = ptyfs->ptyfs_birthtime; 323 vap->va_mode = ptyfs->ptyfs_mode; 324 vap->va_flags = ptyfs->ptyfs_flags; 325 vap->va_uid = ptyfs->ptyfs_uid; 326 vap->va_gid = ptyfs->ptyfs_gid; 327 328 switch (ptyfs->ptyfs_type) { 329 case PTYFSpts: 330 case PTYFSptc: 331 if (pty_isfree(ptyfs->ptyfs_pty, 1)) 332 return ENOENT; 333 vap->va_bytes = vap->va_size = 0; 334 vap->va_rdev = ap->a_vp->v_rdev; 335 break; 336 case PTYFSroot: 337 vap->va_rdev = 0; 338 vap->va_bytes = vap->va_size = DEV_BSIZE; 339 break; 340 341 default: 342 return EOPNOTSUPP; 343 } 344 345 return 0; 346 } 347 348 /*ARGSUSED*/ 349 int 350 ptyfs_setattr(void *v) 351 { 352 struct vop_setattr_args /* { 353 struct vnodeop_desc *a_desc; 354 struct vnode *a_vp; 355 struct vattr *a_vap; 356 struct ucred *a_cred; 357 struct lwp *a_l; 358 } */ *ap = v; 359 struct vnode *vp = ap->a_vp; 360 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 361 struct vattr *vap = ap->a_vap; 362 struct ucred *cred = ap->a_cred; 363 struct lwp *l = ap->a_l; 364 struct proc *p = l->l_proc; 365 int error; 366 367 if (vap->va_size != VNOVAL) { 368 switch (ptyfs->ptyfs_type) { 369 case PTYFSroot: 370 return EISDIR; 371 case PTYFSpts: 372 case PTYFSptc: 373 break; 374 default: 375 return EINVAL; 376 } 377 } 378 379 if (vap->va_flags != VNOVAL) { 380 if (vp->v_mount->mnt_flag & MNT_RDONLY) 381 return EROFS; 382 if (cred->cr_uid != ptyfs->ptyfs_uid && 383 (error = suser(cred, &p->p_acflag)) != 0) 384 return error; 385 if (cred->cr_uid == 0) { 386 if ((ptyfs->ptyfs_flags & (SF_IMMUTABLE | SF_APPEND)) && 387 securelevel > 0) 388 return EPERM; 389 /* Snapshot flag cannot be set or cleared */ 390 if ((vap->va_flags & SF_SNAPSHOT) != 391 (ptyfs->ptyfs_flags & SF_SNAPSHOT)) 392 return EPERM; 393 ptyfs->ptyfs_flags = vap->va_flags; 394 } else { 395 if ((ptyfs->ptyfs_flags & (SF_IMMUTABLE | SF_APPEND)) || 396 (vap->va_flags & UF_SETTABLE) != vap->va_flags) 397 return EPERM; 398 if ((ptyfs->ptyfs_flags & SF_SETTABLE) != 399 (vap->va_flags & SF_SETTABLE)) 400 return EPERM; 401 ptyfs->ptyfs_flags &= SF_SETTABLE; 402 ptyfs->ptyfs_flags |= (vap->va_flags & UF_SETTABLE); 403 } 404 ptyfs->ptyfs_flag |= PTYFS_CHANGE; 405 if (vap->va_flags & (IMMUTABLE | APPEND)) 406 return 0; 407 } 408 if (ptyfs->ptyfs_flags & (IMMUTABLE | APPEND)) 409 return EPERM; 410 /* 411 * Go through the fields and update iff not VNOVAL. 412 */ 413 if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) { 414 if (vp->v_mount->mnt_flag & MNT_RDONLY) 415 return EROFS; 416 if (ptyfs->ptyfs_type == PTYFSroot) 417 return EPERM; 418 error = ptyfs_chown(vp, vap->va_uid, vap->va_gid, cred, p); 419 if (error) 420 return error; 421 } 422 423 if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL || 424 vap->va_birthtime.tv_sec != VNOVAL) { 425 if (vp->v_mount->mnt_flag & MNT_RDONLY) 426 return EROFS; 427 if ((ptyfs->ptyfs_flags & SF_SNAPSHOT) != 0) 428 return EPERM; 429 if (cred->cr_uid != ptyfs->ptyfs_uid && 430 (error = suser(cred, &p->p_acflag)) && 431 ((vap->va_vaflags & VA_UTIMES_NULL) == 0 || 432 (error = VOP_ACCESS(vp, VWRITE, cred, l)) != 0)) 433 return (error); 434 if (vap->va_atime.tv_sec != VNOVAL) 435 if (!(vp->v_mount->mnt_flag & MNT_NOATIME)) 436 ptyfs->ptyfs_flag |= PTYFS_ACCESS; 437 if (vap->va_mtime.tv_sec != VNOVAL) 438 ptyfs->ptyfs_flag |= PTYFS_CHANGE | PTYFS_MODIFY; 439 if (vap->va_birthtime.tv_sec != VNOVAL) 440 ptyfs->ptyfs_birthtime = vap->va_birthtime; 441 ptyfs->ptyfs_flag |= PTYFS_CHANGE; 442 error = ptyfs_update(vp, &vap->va_atime, &vap->va_mtime, 0); 443 if (error) 444 return error; 445 } 446 if (vap->va_mode != (mode_t)VNOVAL) { 447 if (vp->v_mount->mnt_flag & MNT_RDONLY) 448 return EROFS; 449 if (ptyfs->ptyfs_type == PTYFSroot) 450 return EPERM; 451 if ((ptyfs->ptyfs_flags & SF_SNAPSHOT) != 0 && 452 (vap->va_mode & 453 (S_IXUSR|S_IWUSR|S_IXGRP|S_IWGRP|S_IXOTH|S_IWOTH))) 454 return EPERM; 455 error = ptyfs_chmod(vp, vap->va_mode, cred, p); 456 if (error) 457 return error; 458 } 459 VN_KNOTE(vp, NOTE_ATTRIB); 460 return 0; 461 } 462 463 /* 464 * Change the mode on a file. 465 * Inode must be locked before calling. 466 */ 467 static int 468 ptyfs_chmod(struct vnode *vp, mode_t mode, struct ucred *cred, struct proc *p) 469 { 470 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 471 int error; 472 473 if (cred->cr_uid != ptyfs->ptyfs_uid && 474 (error = suser(cred, &p->p_acflag)) != 0) 475 return error; 476 ptyfs->ptyfs_mode &= ~ALLPERMS; 477 ptyfs->ptyfs_mode |= (mode & ALLPERMS); 478 return 0; 479 } 480 481 /* 482 * Perform chown operation on inode ip; 483 * inode must be locked prior to call. 484 */ 485 static int 486 ptyfs_chown(struct vnode *vp, uid_t uid, gid_t gid, struct ucred *cred, 487 struct proc *p) 488 { 489 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 490 int error; 491 492 if (uid == (uid_t)VNOVAL) 493 uid = ptyfs->ptyfs_uid; 494 if (gid == (gid_t)VNOVAL) 495 gid = ptyfs->ptyfs_gid; 496 /* 497 * If we don't own the file, are trying to change the owner 498 * of the file, or are not a member of the target group, 499 * the caller's credentials must imply super-user privilege 500 * or the call fails. 501 */ 502 if ((cred->cr_uid != ptyfs->ptyfs_uid || uid != ptyfs->ptyfs_uid || 503 (gid != ptyfs->ptyfs_gid && 504 !(cred->cr_gid == gid || groupmember((gid_t)gid, cred)))) && 505 ((error = suser(cred, &p->p_acflag)) != 0)) 506 return error; 507 508 ptyfs->ptyfs_gid = gid; 509 ptyfs->ptyfs_uid = uid; 510 return 0; 511 } 512 513 /* 514 * implement access checking. 515 * 516 * actually, the check for super-user is slightly 517 * broken since it will allow read access to write-only 518 * objects. this doesn't cause any particular trouble 519 * but does mean that the i/o entry points need to check 520 * that the operation really does make sense. 521 */ 522 int 523 ptyfs_access(void *v) 524 { 525 struct vop_access_args /* { 526 struct vnode *a_vp; 527 int a_mode; 528 struct ucred *a_cred; 529 struct lwp *a_l; 530 } */ *ap = v; 531 struct vattr va; 532 int error; 533 534 if ((error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred, ap->a_l)) != 0) 535 return error; 536 537 return vaccess(va.va_type, va.va_mode, 538 va.va_uid, va.va_gid, ap->a_mode, ap->a_cred); 539 } 540 541 /* 542 * lookup. this is incredibly complicated in the 543 * general case, however for most pseudo-filesystems 544 * very little needs to be done. 545 * 546 * Locking isn't hard here, just poorly documented. 547 * 548 * If we're looking up ".", just vref the parent & return it. 549 * 550 * If we're looking up "..", unlock the parent, and lock "..". If everything 551 * went ok, and we're on the last component and the caller requested the 552 * parent locked, try to re-lock the parent. We do this to prevent lock 553 * races. 554 * 555 * For anything else, get the needed node. Then unlock the parent if not 556 * the last component or not LOCKPARENT (i.e. if we wouldn't re-lock the 557 * parent in the .. case). 558 * 559 * We try to exit with the parent locked in error cases. 560 */ 561 int 562 ptyfs_lookup(void *v) 563 { 564 struct vop_lookup_args /* { 565 struct vnode * a_dvp; 566 struct vnode ** a_vpp; 567 struct componentname * a_cnp; 568 } */ *ap = v; 569 struct componentname *cnp = ap->a_cnp; 570 struct vnode **vpp = ap->a_vpp; 571 struct vnode *dvp = ap->a_dvp; 572 const char *pname = cnp->cn_nameptr; 573 struct ptyfsnode *ptyfs; 574 int pty, error, wantpunlock; 575 576 *vpp = NULL; 577 cnp->cn_flags &= ~PDIRUNLOCK; 578 579 if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME) 580 return EROFS; 581 582 if (cnp->cn_namelen == 1 && *pname == '.') { 583 *vpp = dvp; 584 VREF(dvp); 585 return 0; 586 } 587 588 wantpunlock = ~cnp->cn_flags & (LOCKPARENT | ISLASTCN); 589 ptyfs = VTOPTYFS(dvp); 590 switch (ptyfs->ptyfs_type) { 591 case PTYFSroot: 592 /* 593 * Shouldn't get here with .. in the root node. 594 */ 595 if (cnp->cn_flags & ISDOTDOT) 596 return EIO; 597 598 pty = atoi(pname, cnp->cn_namelen); 599 600 if (pty < 0 || pty >= npty || pty_isfree(pty, 1)) 601 break; 602 603 error = ptyfs_allocvp(dvp->v_mount, vpp, PTYFSpts, pty, 604 curlwp); 605 if (error == 0 && wantpunlock) { 606 VOP_UNLOCK(dvp, 0); 607 cnp->cn_flags |= PDIRUNLOCK; 608 } 609 return error; 610 611 default: 612 return ENOTDIR; 613 } 614 615 return cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS; 616 } 617 618 /* 619 * readdir returns directory entries from ptyfsnode (vp). 620 * 621 * the strategy here with ptyfs is to generate a single 622 * directory entry at a time (struct dirent) and then 623 * copy that out to userland using uiomove. a more efficent 624 * though more complex implementation, would try to minimize 625 * the number of calls to uiomove(). for ptyfs, this is 626 * hardly worth the added code complexity. 627 * 628 * this should just be done through read() 629 */ 630 int 631 ptyfs_readdir(void *v) 632 { 633 struct vop_readdir_args /* { 634 struct vnode *a_vp; 635 struct uio *a_uio; 636 struct ucred *a_cred; 637 int *a_eofflag; 638 off_t **a_cookies; 639 int *a_ncookies; 640 } */ *ap = v; 641 struct uio *uio = ap->a_uio; 642 struct dirent d; 643 struct ptyfsnode *ptyfs; 644 off_t i; 645 int error; 646 off_t *cookies = NULL; 647 int ncookies; 648 struct vnode *vp; 649 int nc = 0; 650 651 vp = ap->a_vp; 652 ptyfs = VTOPTYFS(vp); 653 654 if (uio->uio_resid < UIO_MX) 655 return EINVAL; 656 if (uio->uio_offset < 0) 657 return EINVAL; 658 659 error = 0; 660 i = uio->uio_offset; 661 (void)memset(&d, 0, sizeof(d)); 662 d.d_reclen = UIO_MX; 663 ncookies = uio->uio_resid / UIO_MX; 664 665 switch (ptyfs->ptyfs_type) { 666 case PTYFSroot: /* root */ 667 668 if (i >= npty) 669 return 0; 670 671 if (ap->a_ncookies) { 672 ncookies = min(ncookies, (npty + 2 - i)); 673 cookies = malloc(ncookies * sizeof (off_t), 674 M_TEMP, M_WAITOK); 675 *ap->a_cookies = cookies; 676 } 677 678 for (; i < 2; i++) { 679 switch (i) { 680 case 0: /* `.' */ 681 case 1: /* `..' */ 682 d.d_fileno = PTYFS_FILENO(0, PTYFSroot); 683 d.d_namlen = i + 1; 684 (void)memcpy(d.d_name, "..", d.d_namlen); 685 d.d_name[i + 1] = '\0'; 686 d.d_type = DT_DIR; 687 break; 688 } 689 if ((error = uiomove(&d, UIO_MX, uio)) != 0) 690 break; 691 if (cookies) 692 *cookies++ = i + 1; 693 nc++; 694 } 695 if (error) { 696 ncookies = nc; 697 break; 698 } 699 for (; uio->uio_resid >= UIO_MX && i < npty; i++) { 700 /* check for used ptys */ 701 if (pty_isfree(i - 2, 1)) 702 continue; 703 704 d.d_fileno = PTYFS_FILENO(i - 2, PTYFSpts); 705 d.d_namlen = snprintf(d.d_name, sizeof(d.d_name), 706 "%lld", (long long)(i - 2)); 707 d.d_type = DT_CHR; 708 if ((error = uiomove(&d, UIO_MX, uio)) != 0) 709 break; 710 if (cookies) 711 *cookies++ = i + 1; 712 nc++; 713 } 714 ncookies = nc; 715 break; 716 717 default: 718 error = ENOTDIR; 719 break; 720 } 721 722 if (ap->a_ncookies) { 723 if (error) { 724 if (cookies) 725 free(*ap->a_cookies, M_TEMP); 726 *ap->a_ncookies = 0; 727 *ap->a_cookies = NULL; 728 } else 729 *ap->a_ncookies = ncookies; 730 } 731 uio->uio_offset = i; 732 return error; 733 } 734 735 int 736 ptyfs_open(void *v) 737 { 738 struct vop_open_args /* { 739 struct vnode *a_vp; 740 int a_mode; 741 struct ucred *a_cred; 742 struct lwp *a_l; 743 } */ *ap = v; 744 struct vnode *vp = ap->a_vp; 745 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 746 747 ptyfs->ptyfs_flag |= PTYFS_CHANGE|PTYFS_ACCESS; 748 switch (ptyfs->ptyfs_type) { 749 case PTYFSpts: 750 case PTYFSptc: 751 return spec_open(v); 752 case PTYFSroot: 753 return 0; 754 default: 755 return EINVAL; 756 } 757 } 758 759 int 760 ptyfs_close(void *v) 761 { 762 struct vop_close_args /* { 763 struct vnode *a_vp; 764 int a_fflag; 765 struct ucred *a_cred; 766 struct lwp *a_l; 767 } */ *ap = v; 768 struct vnode *vp = ap->a_vp; 769 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 770 771 simple_lock(&vp->v_interlock); 772 if (vp->v_usecount > 1) 773 PTYFS_ITIMES(ptyfs, NULL, NULL, NULL); 774 simple_unlock(&vp->v_interlock); 775 776 switch (ptyfs->ptyfs_type) { 777 case PTYFSpts: 778 case PTYFSptc: 779 return spec_close(v); 780 case PTYFSroot: 781 return 0; 782 default: 783 return EINVAL; 784 } 785 } 786 787 int 788 ptyfs_read(void *v) 789 { 790 struct vop_read_args /* { 791 struct vnode *a_vp; 792 struct uio *a_uio; 793 int a_ioflag; 794 struct ucred *a_cred; 795 } */ *ap = v; 796 struct timespec ts; 797 struct vnode *vp = ap->a_vp; 798 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 799 int error; 800 801 ptyfs->ptyfs_flag |= PTYFS_ACCESS; 802 /* hardclock() resolution is good enough for ptyfs */ 803 TIMEVAL_TO_TIMESPEC(&time, &ts); 804 (void)ptyfs_update(vp, &ts, &ts, 0); 805 806 switch (ptyfs->ptyfs_type) { 807 case PTYFSpts: 808 VOP_UNLOCK(vp, 0); 809 error = (*pts_cdevsw.d_read)(vp->v_rdev, ap->a_uio, 810 ap->a_ioflag); 811 vn_lock(vp, LK_RETRY|LK_EXCLUSIVE); 812 return error; 813 case PTYFSptc: 814 VOP_UNLOCK(vp, 0); 815 error = (*ptc_cdevsw.d_read)(vp->v_rdev, ap->a_uio, 816 ap->a_ioflag); 817 vn_lock(vp, LK_RETRY|LK_EXCLUSIVE); 818 return error; 819 default: 820 return EOPNOTSUPP; 821 } 822 } 823 824 int 825 ptyfs_write(void *v) 826 { 827 struct vop_write_args /* { 828 struct vnode *a_vp; 829 struct uio *a_uio; 830 int a_ioflag; 831 struct ucred *a_cred; 832 } */ *ap = v; 833 struct timespec ts; 834 struct vnode *vp = ap->a_vp; 835 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 836 int error; 837 838 ptyfs->ptyfs_flag |= PTYFS_MODIFY; 839 /* hardclock() resolution is good enough for ptyfs */ 840 TIMEVAL_TO_TIMESPEC(&time, &ts); 841 (void)ptyfs_update(vp, &ts, &ts, 0); 842 843 switch (ptyfs->ptyfs_type) { 844 case PTYFSpts: 845 VOP_UNLOCK(vp, 0); 846 error = (*pts_cdevsw.d_write)(vp->v_rdev, ap->a_uio, 847 ap->a_ioflag); 848 vn_lock(vp, LK_RETRY|LK_EXCLUSIVE); 849 return error; 850 case PTYFSptc: 851 VOP_UNLOCK(vp, 0); 852 error = (*ptc_cdevsw.d_write)(vp->v_rdev, ap->a_uio, 853 ap->a_ioflag); 854 vn_lock(vp, LK_RETRY|LK_EXCLUSIVE); 855 return error; 856 default: 857 return EOPNOTSUPP; 858 } 859 } 860 861 int 862 ptyfs_ioctl(void *v) 863 { 864 struct vop_ioctl_args /* { 865 struct vnode *a_vp; 866 u_long a_command; 867 void *a_data; 868 int a_fflag; 869 struct ucred *a_cred; 870 struct lwp *a_l; 871 } */ *ap = v; 872 struct vnode *vp = ap->a_vp; 873 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 874 875 switch (ptyfs->ptyfs_type) { 876 case PTYFSpts: 877 return (*pts_cdevsw.d_ioctl)(vp->v_rdev, ap->a_command, 878 ap->a_data, ap->a_fflag, ap->a_l); 879 case PTYFSptc: 880 return (*ptc_cdevsw.d_ioctl)(vp->v_rdev, ap->a_command, 881 ap->a_data, ap->a_fflag, ap->a_l); 882 default: 883 return EOPNOTSUPP; 884 } 885 } 886 887 int 888 ptyfs_poll(void *v) 889 { 890 struct vop_poll_args /* { 891 struct vnode *a_vp; 892 int a_events; 893 struct lwp *a_l; 894 } */ *ap = v; 895 struct vnode *vp = ap->a_vp; 896 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 897 898 switch (ptyfs->ptyfs_type) { 899 case PTYFSpts: 900 return (*pts_cdevsw.d_poll)(vp->v_rdev, ap->a_events, ap->a_l); 901 case PTYFSptc: 902 return (*ptc_cdevsw.d_poll)(vp->v_rdev, ap->a_events, ap->a_l); 903 default: 904 return genfs_poll(v); 905 } 906 } 907 908 int 909 ptyfs_kqfilter(void *v) 910 { 911 struct vop_kqfilter_args /* { 912 struct vnode *a_vp; 913 struct knote *a_kn; 914 } */ *ap = v; 915 struct vnode *vp = ap->a_vp; 916 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 917 918 switch (ptyfs->ptyfs_type) { 919 case PTYFSpts: 920 return (*pts_cdevsw.d_kqfilter)(vp->v_rdev, ap->a_kn); 921 case PTYFSptc: 922 return (*ptc_cdevsw.d_kqfilter)(vp->v_rdev, ap->a_kn); 923 default: 924 return genfs_kqfilter(v); 925 } 926 } 927 928 static int 929 ptyfs_update(struct vnode *vp, const struct timespec *acc, 930 const struct timespec *mod, int flags) 931 { 932 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 933 934 if (vp->v_mount->mnt_flag & MNT_RDONLY) 935 return 0; 936 937 PTYFS_ITIMES(ptyfs, acc, mod, NULL); 938 return 0; 939 } 940 941 void 942 ptyfs_itimes(struct ptyfsnode *ptyfs, const struct timespec *acc, 943 const struct timespec *mod, const struct timespec *cre) 944 { 945 struct timespec *ts = NULL, tsb; 946 947 KASSERT(ptyfs->ptyfs_flag & (PTYFS_ACCESS|PTYFS_CHANGE|PTYFS_MODIFY)); 948 if (ptyfs->ptyfs_flag & (PTYFS_ACCESS|PTYFS_MODIFY)) { 949 if (acc == NULL) 950 acc = ts == NULL ? (ts = nanotime(&tsb)) : ts; 951 ptyfs->ptyfs_atime = *acc; 952 } 953 if (ptyfs->ptyfs_flag & PTYFS_MODIFY) { 954 if (mod == NULL) 955 mod = ts == NULL ? (ts = nanotime(&tsb)) : ts; 956 ptyfs->ptyfs_mtime = *mod; 957 } 958 if (ptyfs->ptyfs_flag & PTYFS_CHANGE) { 959 if (cre == NULL) 960 cre = ts == NULL ? (ts = nanotime(&tsb)) : ts; 961 ptyfs->ptyfs_ctime = *cre; 962 } 963 ptyfs->ptyfs_flag &= ~(PTYFS_ACCESS|PTYFS_CHANGE|PTYFS_MODIFY); 964 } 965 966 /* 967 * convert decimal ascii to int 968 */ 969 static int 970 atoi(const char *b, size_t len) 971 { 972 int p = 0; 973 974 while (len--) { 975 char c = *b++; 976 if (c < '0' || c > '9') 977 return -1; 978 p = 10 * p + (c - '0'); 979 } 980 981 return p; 982 } 983
Indexes created Fri Sep 26 08:10:20 GMT 2025