ptyfs_vnops.c revision 1.15
1 /* $NetBSD: ptyfs_vnops.c,v 1.15 2006/06/07 22:33:38 kardel 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.15 2006/06/07 22:33:38 kardel 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 /* 110 * Vnode Operations. 111 * 112 */ 113 114 int ptyfs_lookup (void *); 115 #define ptyfs_create genfs_eopnotsupp 116 #define ptyfs_mknod genfs_eopnotsupp 117 int ptyfs_open (void *); 118 int ptyfs_close (void *); 119 int ptyfs_access (void *); 120 int ptyfs_getattr (void *); 121 int ptyfs_setattr (void *); 122 int ptyfs_read (void *); 123 int ptyfs_write (void *); 124 #define ptyfs_fcntl genfs_fcntl 125 int ptyfs_ioctl (void *); 126 int ptyfs_poll (void *); 127 int ptyfs_kqfilter (void *); 128 #define ptyfs_revoke genfs_revoke 129 #define ptyfs_mmap genfs_eopnotsupp 130 #define ptyfs_fsync genfs_nullop 131 #define ptyfs_seek genfs_nullop 132 #define ptyfs_remove genfs_eopnotsupp 133 #define ptyfs_link genfs_abortop 134 #define ptyfs_rename genfs_eopnotsupp 135 #define ptyfs_mkdir genfs_eopnotsupp 136 #define ptyfs_rmdir genfs_eopnotsupp 137 #define ptyfs_symlink genfs_abortop 138 int ptyfs_readdir (void *); 139 #define ptyfs_readlink genfs_eopnotsupp 140 #define ptyfs_abortop genfs_abortop 141 int ptyfs_reclaim (void *); 142 #define ptyfs_lock genfs_lock 143 #define ptyfs_unlock genfs_unlock 144 #define ptyfs_bmap genfs_badop 145 #define ptyfs_strategy genfs_badop 146 int ptyfs_print (void *); 147 int ptyfs_pathconf (void *); 148 #define ptyfs_islocked genfs_islocked 149 #define ptyfs_advlock genfs_einval 150 #define ptyfs_bwrite genfs_eopnotsupp 151 #define ptyfs_putpages genfs_null_putpages 152 153 static int ptyfs_update(struct vnode *, const struct timespec *, 154 const struct timespec *, int); 155 static int ptyfs_chown(struct vnode *, uid_t, gid_t, kauth_cred_t, 156 struct proc *); 157 static int ptyfs_chmod(struct vnode *, mode_t, kauth_cred_t, struct proc *); 158 static int atoi(const char *, size_t); 159 160 extern const struct cdevsw pts_cdevsw, ptc_cdevsw; 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 * Invent attributes for ptyfsnode (vp) and store 287 * them in (vap). 288 * Directories lengths are returned as zero since 289 * any real length would require the genuine size 290 * to be computed, and nothing cares anyway. 291 * 292 * this is relatively minimal for ptyfs. 293 */ 294 int 295 ptyfs_getattr(void *v) 296 { 297 struct vop_getattr_args /* { 298 struct vnode *a_vp; 299 struct vattr *a_vap; 300 kauth_cred_t a_cred; 301 struct lwp *a_l; 302 } */ *ap = v; 303 struct ptyfsnode *ptyfs = VTOPTYFS(ap->a_vp); 304 struct vattr *vap = ap->a_vap; 305 306 PTYFS_ITIMES(ptyfs, NULL, NULL, NULL); 307 308 /* start by zeroing out the attributes */ 309 VATTR_NULL(vap); 310 311 /* next do all the common fields */ 312 vap->va_type = ap->a_vp->v_type; 313 vap->va_fsid = ap->a_vp->v_mount->mnt_stat.f_fsidx.__fsid_val[0]; 314 vap->va_fileid = ptyfs->ptyfs_fileno; 315 vap->va_gen = 0; 316 vap->va_flags = 0; 317 vap->va_nlink = 1; 318 vap->va_blocksize = PAGE_SIZE; 319 320 vap->va_atime = ptyfs->ptyfs_atime; 321 vap->va_mtime = ptyfs->ptyfs_mtime; 322 vap->va_ctime = ptyfs->ptyfs_ctime; 323 vap->va_birthtime = ptyfs->ptyfs_birthtime; 324 vap->va_mode = ptyfs->ptyfs_mode; 325 vap->va_flags = ptyfs->ptyfs_flags; 326 vap->va_uid = ptyfs->ptyfs_uid; 327 vap->va_gid = ptyfs->ptyfs_gid; 328 329 switch (ptyfs->ptyfs_type) { 330 case PTYFSpts: 331 case PTYFSptc: 332 if (pty_isfree(ptyfs->ptyfs_pty, 1)) 333 return ENOENT; 334 vap->va_bytes = vap->va_size = 0; 335 vap->va_rdev = ap->a_vp->v_rdev; 336 break; 337 case PTYFSroot: 338 vap->va_rdev = 0; 339 vap->va_bytes = vap->va_size = DEV_BSIZE; 340 break; 341 342 default: 343 return EOPNOTSUPP; 344 } 345 346 return 0; 347 } 348 349 /*ARGSUSED*/ 350 int 351 ptyfs_setattr(void *v) 352 { 353 struct vop_setattr_args /* { 354 struct vnodeop_desc *a_desc; 355 struct vnode *a_vp; 356 struct vattr *a_vap; 357 kauth_cred_t a_cred; 358 struct lwp *a_l; 359 } */ *ap = v; 360 struct vnode *vp = ap->a_vp; 361 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 362 struct vattr *vap = ap->a_vap; 363 kauth_cred_t cred = ap->a_cred; 364 struct lwp *l = ap->a_l; 365 struct proc *p = l->l_proc; 366 int error; 367 368 if (vap->va_size != VNOVAL) { 369 switch (ptyfs->ptyfs_type) { 370 case PTYFSroot: 371 return EISDIR; 372 case PTYFSpts: 373 case PTYFSptc: 374 break; 375 default: 376 return EINVAL; 377 } 378 } 379 380 if (vap->va_flags != VNOVAL) { 381 if (vp->v_mount->mnt_flag & MNT_RDONLY) 382 return EROFS; 383 if (kauth_cred_geteuid(cred) != ptyfs->ptyfs_uid && 384 (error = kauth_authorize_generic(cred, KAUTH_GENERIC_ISSUSER, 385 &p->p_acflag)) != 0) 386 return error; 387 if (kauth_authorize_generic(cred, KAUTH_GENERIC_ISSUSER, NULL) == 0) { 388 if ((ptyfs->ptyfs_flags & (SF_IMMUTABLE | SF_APPEND)) && 389 securelevel > 0) 390 return EPERM; 391 /* Snapshot flag cannot be set or cleared */ 392 if ((vap->va_flags & SF_SNAPSHOT) != 393 (ptyfs->ptyfs_flags & SF_SNAPSHOT)) 394 return EPERM; 395 ptyfs->ptyfs_flags = vap->va_flags; 396 } else { 397 if ((ptyfs->ptyfs_flags & (SF_IMMUTABLE | SF_APPEND)) || 398 (vap->va_flags & UF_SETTABLE) != vap->va_flags) 399 return EPERM; 400 if ((ptyfs->ptyfs_flags & SF_SETTABLE) != 401 (vap->va_flags & SF_SETTABLE)) 402 return EPERM; 403 ptyfs->ptyfs_flags &= SF_SETTABLE; 404 ptyfs->ptyfs_flags |= (vap->va_flags & UF_SETTABLE); 405 } 406 ptyfs->ptyfs_flag |= PTYFS_CHANGE; 407 if (vap->va_flags & (IMMUTABLE | APPEND)) 408 return 0; 409 } 410 if (ptyfs->ptyfs_flags & (IMMUTABLE | APPEND)) 411 return EPERM; 412 /* 413 * Go through the fields and update iff not VNOVAL. 414 */ 415 if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) { 416 if (vp->v_mount->mnt_flag & MNT_RDONLY) 417 return EROFS; 418 if (ptyfs->ptyfs_type == PTYFSroot) 419 return EPERM; 420 error = ptyfs_chown(vp, vap->va_uid, vap->va_gid, cred, p); 421 if (error) 422 return error; 423 } 424 425 if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL || 426 vap->va_birthtime.tv_sec != VNOVAL) { 427 if (vp->v_mount->mnt_flag & MNT_RDONLY) 428 return EROFS; 429 if ((ptyfs->ptyfs_flags & SF_SNAPSHOT) != 0) 430 return EPERM; 431 if (kauth_cred_geteuid(cred) != ptyfs->ptyfs_uid && 432 (error = kauth_authorize_generic(cred, KAUTH_GENERIC_ISSUSER, 433 &p->p_acflag)) && 434 ((vap->va_vaflags & VA_UTIMES_NULL) == 0 || 435 (error = VOP_ACCESS(vp, VWRITE, cred, l)) != 0)) 436 return (error); 437 if (vap->va_atime.tv_sec != VNOVAL) 438 if (!(vp->v_mount->mnt_flag & MNT_NOATIME)) 439 ptyfs->ptyfs_flag |= PTYFS_ACCESS; 440 if (vap->va_mtime.tv_sec != VNOVAL) 441 ptyfs->ptyfs_flag |= PTYFS_CHANGE | PTYFS_MODIFY; 442 if (vap->va_birthtime.tv_sec != VNOVAL) 443 ptyfs->ptyfs_birthtime = vap->va_birthtime; 444 ptyfs->ptyfs_flag |= PTYFS_CHANGE; 445 error = ptyfs_update(vp, &vap->va_atime, &vap->va_mtime, 0); 446 if (error) 447 return error; 448 } 449 if (vap->va_mode != (mode_t)VNOVAL) { 450 if (vp->v_mount->mnt_flag & MNT_RDONLY) 451 return EROFS; 452 if (ptyfs->ptyfs_type == PTYFSroot) 453 return EPERM; 454 if ((ptyfs->ptyfs_flags & SF_SNAPSHOT) != 0 && 455 (vap->va_mode & 456 (S_IXUSR|S_IWUSR|S_IXGRP|S_IWGRP|S_IXOTH|S_IWOTH))) 457 return EPERM; 458 error = ptyfs_chmod(vp, vap->va_mode, cred, p); 459 if (error) 460 return error; 461 } 462 VN_KNOTE(vp, NOTE_ATTRIB); 463 return 0; 464 } 465 466 /* 467 * Change the mode on a file. 468 * Inode must be locked before calling. 469 */ 470 static int 471 ptyfs_chmod(struct vnode *vp, mode_t mode, kauth_cred_t cred, struct proc *p) 472 { 473 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 474 int error; 475 476 if (kauth_cred_geteuid(cred) != ptyfs->ptyfs_uid && 477 (error = kauth_authorize_generic(cred, KAUTH_GENERIC_ISSUSER, 478 &p->p_acflag)) != 0) 479 return error; 480 ptyfs->ptyfs_mode &= ~ALLPERMS; 481 ptyfs->ptyfs_mode |= (mode & ALLPERMS); 482 return 0; 483 } 484 485 /* 486 * Perform chown operation on inode ip; 487 * inode must be locked prior to call. 488 */ 489 static int 490 ptyfs_chown(struct vnode *vp, uid_t uid, gid_t gid, kauth_cred_t cred, 491 struct proc *p) 492 { 493 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 494 int error, ismember = 0; 495 496 if (uid == (uid_t)VNOVAL) 497 uid = ptyfs->ptyfs_uid; 498 if (gid == (gid_t)VNOVAL) 499 gid = ptyfs->ptyfs_gid; 500 /* 501 * If we don't own the file, are trying to change the owner 502 * of the file, or are not a member of the target group, 503 * the caller's credentials must imply super-user privilege 504 * or the call fails. 505 */ 506 if ((kauth_cred_geteuid(cred) != ptyfs->ptyfs_uid || uid != ptyfs->ptyfs_uid || 507 (gid != ptyfs->ptyfs_gid && 508 !(kauth_cred_getegid(cred) == gid || 509 (kauth_cred_ismember_gid(cred, gid, &ismember) == 0 && ismember)))) && 510 ((error = kauth_authorize_generic(cred, KAUTH_GENERIC_ISSUSER, 511 &p->p_acflag)) != 0)) 512 return error; 513 514 ptyfs->ptyfs_gid = gid; 515 ptyfs->ptyfs_uid = uid; 516 return 0; 517 } 518 519 /* 520 * implement access checking. 521 * 522 * actually, the check for super-user is slightly 523 * broken since it will allow read access to write-only 524 * objects. this doesn't cause any particular trouble 525 * but does mean that the i/o entry points need to check 526 * that the operation really does make sense. 527 */ 528 int 529 ptyfs_access(void *v) 530 { 531 struct vop_access_args /* { 532 struct vnode *a_vp; 533 int a_mode; 534 kauth_cred_t a_cred; 535 struct lwp *a_l; 536 } */ *ap = v; 537 struct vattr va; 538 int error; 539 540 if ((error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred, ap->a_l)) != 0) 541 return error; 542 543 return vaccess(va.va_type, va.va_mode, 544 va.va_uid, va.va_gid, ap->a_mode, ap->a_cred); 545 } 546 547 /* 548 * lookup. this is incredibly complicated in the 549 * general case, however for most pseudo-filesystems 550 * very little needs to be done. 551 * 552 * Locking isn't hard here, just poorly documented. 553 * 554 * If we're looking up ".", just vref the parent & return it. 555 * 556 * If we're looking up "..", unlock the parent, and lock "..". If everything 557 * went ok, and we're on the last component and the caller requested the 558 * parent locked, try to re-lock the parent. We do this to prevent lock 559 * races. 560 * 561 * For anything else, get the needed node. Then unlock the parent if not 562 * the last component or not LOCKPARENT (i.e. if we wouldn't re-lock the 563 * parent in the .. case). 564 * 565 * We try to exit with the parent locked in error cases. 566 */ 567 int 568 ptyfs_lookup(void *v) 569 { 570 struct vop_lookup_args /* { 571 struct vnode * a_dvp; 572 struct vnode ** a_vpp; 573 struct componentname * a_cnp; 574 } */ *ap = v; 575 struct componentname *cnp = ap->a_cnp; 576 struct vnode **vpp = ap->a_vpp; 577 struct vnode *dvp = ap->a_dvp; 578 const char *pname = cnp->cn_nameptr; 579 struct ptyfsnode *ptyfs; 580 int pty, error, wantpunlock; 581 582 *vpp = NULL; 583 cnp->cn_flags &= ~PDIRUNLOCK; 584 585 if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME) 586 return EROFS; 587 588 if (cnp->cn_namelen == 1 && *pname == '.') { 589 *vpp = dvp; 590 VREF(dvp); 591 return 0; 592 } 593 594 wantpunlock = ~cnp->cn_flags & (LOCKPARENT | ISLASTCN); 595 ptyfs = VTOPTYFS(dvp); 596 switch (ptyfs->ptyfs_type) { 597 case PTYFSroot: 598 /* 599 * Shouldn't get here with .. in the root node. 600 */ 601 if (cnp->cn_flags & ISDOTDOT) 602 return EIO; 603 604 pty = atoi(pname, cnp->cn_namelen); 605 606 if (pty < 0 || pty >= npty || pty_isfree(pty, 1)) 607 break; 608 609 error = ptyfs_allocvp(dvp->v_mount, vpp, PTYFSpts, pty, 610 curlwp); 611 if (error == 0 && wantpunlock) { 612 VOP_UNLOCK(dvp, 0); 613 cnp->cn_flags |= PDIRUNLOCK; 614 } 615 return error; 616 617 default: 618 return ENOTDIR; 619 } 620 621 return cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS; 622 } 623 624 /* 625 * readdir returns directory entries from ptyfsnode (vp). 626 * 627 * the strategy here with ptyfs is to generate a single 628 * directory entry at a time (struct dirent) and then 629 * copy that out to userland using uiomove. a more efficent 630 * though more complex implementation, would try to minimize 631 * the number of calls to uiomove(). for ptyfs, this is 632 * hardly worth the added code complexity. 633 * 634 * this should just be done through read() 635 */ 636 int 637 ptyfs_readdir(void *v) 638 { 639 struct vop_readdir_args /* { 640 struct vnode *a_vp; 641 struct uio *a_uio; 642 kauth_cred_t a_cred; 643 int *a_eofflag; 644 off_t **a_cookies; 645 int *a_ncookies; 646 } */ *ap = v; 647 struct uio *uio = ap->a_uio; 648 struct dirent d; 649 struct ptyfsnode *ptyfs; 650 off_t i; 651 int error; 652 off_t *cookies = NULL; 653 int ncookies; 654 struct vnode *vp; 655 int nc = 0; 656 657 vp = ap->a_vp; 658 ptyfs = VTOPTYFS(vp); 659 660 if (uio->uio_resid < UIO_MX) 661 return EINVAL; 662 if (uio->uio_offset < 0) 663 return EINVAL; 664 665 error = 0; 666 i = uio->uio_offset; 667 (void)memset(&d, 0, sizeof(d)); 668 d.d_reclen = UIO_MX; 669 ncookies = uio->uio_resid / UIO_MX; 670 671 switch (ptyfs->ptyfs_type) { 672 case PTYFSroot: /* root */ 673 674 if (i >= npty) 675 return 0; 676 677 if (ap->a_ncookies) { 678 ncookies = min(ncookies, (npty + 2 - i)); 679 cookies = malloc(ncookies * sizeof (off_t), 680 M_TEMP, M_WAITOK); 681 *ap->a_cookies = cookies; 682 } 683 684 for (; i < 2; i++) { 685 switch (i) { 686 case 0: /* `.' */ 687 case 1: /* `..' */ 688 d.d_fileno = PTYFS_FILENO(0, PTYFSroot); 689 d.d_namlen = i + 1; 690 (void)memcpy(d.d_name, "..", d.d_namlen); 691 d.d_name[i + 1] = '\0'; 692 d.d_type = DT_DIR; 693 break; 694 } 695 if ((error = uiomove(&d, UIO_MX, uio)) != 0) 696 break; 697 if (cookies) 698 *cookies++ = i + 1; 699 nc++; 700 } 701 if (error) { 702 ncookies = nc; 703 break; 704 } 705 for (; uio->uio_resid >= UIO_MX && i < npty; i++) { 706 /* check for used ptys */ 707 if (pty_isfree(i - 2, 1)) 708 continue; 709 710 d.d_fileno = PTYFS_FILENO(i - 2, PTYFSpts); 711 d.d_namlen = snprintf(d.d_name, sizeof(d.d_name), 712 "%lld", (long long)(i - 2)); 713 d.d_type = DT_CHR; 714 if ((error = uiomove(&d, UIO_MX, uio)) != 0) 715 break; 716 if (cookies) 717 *cookies++ = i + 1; 718 nc++; 719 } 720 ncookies = nc; 721 break; 722 723 default: 724 error = ENOTDIR; 725 break; 726 } 727 728 if (ap->a_ncookies) { 729 if (error) { 730 if (cookies) 731 free(*ap->a_cookies, M_TEMP); 732 *ap->a_ncookies = 0; 733 *ap->a_cookies = NULL; 734 } else 735 *ap->a_ncookies = ncookies; 736 } 737 uio->uio_offset = i; 738 return error; 739 } 740 741 int 742 ptyfs_open(void *v) 743 { 744 struct vop_open_args /* { 745 struct vnode *a_vp; 746 int a_mode; 747 kauth_cred_t a_cred; 748 struct lwp *a_l; 749 } */ *ap = v; 750 struct vnode *vp = ap->a_vp; 751 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 752 753 ptyfs->ptyfs_flag |= PTYFS_CHANGE|PTYFS_ACCESS; 754 switch (ptyfs->ptyfs_type) { 755 case PTYFSpts: 756 case PTYFSptc: 757 return spec_open(v); 758 case PTYFSroot: 759 return 0; 760 default: 761 return EINVAL; 762 } 763 } 764 765 int 766 ptyfs_close(void *v) 767 { 768 struct vop_close_args /* { 769 struct vnode *a_vp; 770 int a_fflag; 771 kauth_cred_t a_cred; 772 struct lwp *a_l; 773 } */ *ap = v; 774 struct vnode *vp = ap->a_vp; 775 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 776 777 simple_lock(&vp->v_interlock); 778 if (vp->v_usecount > 1) 779 PTYFS_ITIMES(ptyfs, NULL, NULL, NULL); 780 simple_unlock(&vp->v_interlock); 781 782 switch (ptyfs->ptyfs_type) { 783 case PTYFSpts: 784 case PTYFSptc: 785 return spec_close(v); 786 case PTYFSroot: 787 return 0; 788 default: 789 return EINVAL; 790 } 791 } 792 793 int 794 ptyfs_read(void *v) 795 { 796 struct vop_read_args /* { 797 struct vnode *a_vp; 798 struct uio *a_uio; 799 int a_ioflag; 800 kauth_cred_t a_cred; 801 } */ *ap = v; 802 struct timespec ts; 803 struct vnode *vp = ap->a_vp; 804 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 805 int error; 806 807 ptyfs->ptyfs_flag |= PTYFS_ACCESS; 808 /* hardclock() resolution is good enough for ptyfs */ 809 getnanotime(&ts); 810 (void)ptyfs_update(vp, &ts, &ts, 0); 811 812 switch (ptyfs->ptyfs_type) { 813 case PTYFSpts: 814 VOP_UNLOCK(vp, 0); 815 error = (*pts_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 case PTYFSptc: 820 VOP_UNLOCK(vp, 0); 821 error = (*ptc_cdevsw.d_read)(vp->v_rdev, ap->a_uio, 822 ap->a_ioflag); 823 vn_lock(vp, LK_RETRY|LK_EXCLUSIVE); 824 return error; 825 default: 826 return EOPNOTSUPP; 827 } 828 } 829 830 int 831 ptyfs_write(void *v) 832 { 833 struct vop_write_args /* { 834 struct vnode *a_vp; 835 struct uio *a_uio; 836 int a_ioflag; 837 kauth_cred_t a_cred; 838 } */ *ap = v; 839 struct timespec ts; 840 struct vnode *vp = ap->a_vp; 841 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 842 int error; 843 844 ptyfs->ptyfs_flag |= PTYFS_MODIFY; 845 getnanotime(&ts); 846 (void)ptyfs_update(vp, &ts, &ts, 0); 847 848 switch (ptyfs->ptyfs_type) { 849 case PTYFSpts: 850 VOP_UNLOCK(vp, 0); 851 error = (*pts_cdevsw.d_write)(vp->v_rdev, ap->a_uio, 852 ap->a_ioflag); 853 vn_lock(vp, LK_RETRY|LK_EXCLUSIVE); 854 return error; 855 case PTYFSptc: 856 VOP_UNLOCK(vp, 0); 857 error = (*ptc_cdevsw.d_write)(vp->v_rdev, ap->a_uio, 858 ap->a_ioflag); 859 vn_lock(vp, LK_RETRY|LK_EXCLUSIVE); 860 return error; 861 default: 862 return EOPNOTSUPP; 863 } 864 } 865 866 int 867 ptyfs_ioctl(void *v) 868 { 869 struct vop_ioctl_args /* { 870 struct vnode *a_vp; 871 u_long a_command; 872 void *a_data; 873 int a_fflag; 874 kauth_cred_t a_cred; 875 struct lwp *a_l; 876 } */ *ap = v; 877 struct vnode *vp = ap->a_vp; 878 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 879 880 switch (ptyfs->ptyfs_type) { 881 case PTYFSpts: 882 return (*pts_cdevsw.d_ioctl)(vp->v_rdev, ap->a_command, 883 ap->a_data, ap->a_fflag, ap->a_l); 884 case PTYFSptc: 885 return (*ptc_cdevsw.d_ioctl)(vp->v_rdev, ap->a_command, 886 ap->a_data, ap->a_fflag, ap->a_l); 887 default: 888 return EOPNOTSUPP; 889 } 890 } 891 892 int 893 ptyfs_poll(void *v) 894 { 895 struct vop_poll_args /* { 896 struct vnode *a_vp; 897 int a_events; 898 struct lwp *a_l; 899 } */ *ap = v; 900 struct vnode *vp = ap->a_vp; 901 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 902 903 switch (ptyfs->ptyfs_type) { 904 case PTYFSpts: 905 return (*pts_cdevsw.d_poll)(vp->v_rdev, ap->a_events, ap->a_l); 906 case PTYFSptc: 907 return (*ptc_cdevsw.d_poll)(vp->v_rdev, ap->a_events, ap->a_l); 908 default: 909 return genfs_poll(v); 910 } 911 } 912 913 int 914 ptyfs_kqfilter(void *v) 915 { 916 struct vop_kqfilter_args /* { 917 struct vnode *a_vp; 918 struct knote *a_kn; 919 } */ *ap = v; 920 struct vnode *vp = ap->a_vp; 921 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 922 923 switch (ptyfs->ptyfs_type) { 924 case PTYFSpts: 925 return (*pts_cdevsw.d_kqfilter)(vp->v_rdev, ap->a_kn); 926 case PTYFSptc: 927 return (*ptc_cdevsw.d_kqfilter)(vp->v_rdev, ap->a_kn); 928 default: 929 return genfs_kqfilter(v); 930 } 931 } 932 933 static int 934 ptyfs_update(struct vnode *vp, const struct timespec *acc, 935 const struct timespec *mod, int flags) 936 { 937 struct ptyfsnode *ptyfs = VTOPTYFS(vp); 938 939 if (vp->v_mount->mnt_flag & MNT_RDONLY) 940 return 0; 941 942 PTYFS_ITIMES(ptyfs, acc, mod, NULL); 943 return 0; 944 } 945 946 void 947 ptyfs_itimes(struct ptyfsnode *ptyfs, const struct timespec *acc, 948 const struct timespec *mod, const struct timespec *cre) 949 { 950 struct timespec now; 951 952 KASSERT(ptyfs->ptyfs_flag & (PTYFS_ACCESS|PTYFS_CHANGE|PTYFS_MODIFY)); 953 954 getnanotime(&now); 955 if (ptyfs->ptyfs_flag & (PTYFS_ACCESS|PTYFS_MODIFY)) { 956 if (acc == NULL) 957 acc = &now; 958 ptyfs->ptyfs_atime = *acc; 959 } 960 if (ptyfs->ptyfs_flag & PTYFS_MODIFY) { 961 if (mod == NULL) 962 mod = &now; 963 ptyfs->ptyfs_mtime = *mod; 964 } 965 if (ptyfs->ptyfs_flag & PTYFS_CHANGE) { 966 if (cre == NULL) 967 cre = &now; 968 ptyfs->ptyfs_ctime = *cre; 969 } 970 ptyfs->ptyfs_flag &= ~(PTYFS_ACCESS|PTYFS_CHANGE|PTYFS_MODIFY); 971 } 972 973 /* 974 * convert decimal ascii to int 975 */ 976 static int 977 atoi(const char *b, size_t len) 978 { 979 int p = 0; 980 981 while (len--) { 982 char c = *b++; 983 if (c < '0' || c > '9') 984 return -1; 985 p = 10 * p + (c - '0'); 986 } 987 988 return p; 989 } 990
Indexes created Mon Sep 29 18:09:42 GMT 2025