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