kernfs_vnops.c revision 1.27
1 /* $NetBSD: kernfs_vnops.c,v 1.27 1994/06/29 06:34:29 cgd Exp $ */ 2 3 /* 4 * Copyright (c) 1992, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * This code is derived from software donated 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. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the University of 21 * California, Berkeley and its contributors. 22 * 4. Neither the name of the University nor the names of its contributors 23 * may be used to endorse or promote products derived from this software 24 * without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 36 * SUCH DAMAGE. 37 * 38 * @(#)kernfs_vnops.c 8.9 (Berkeley) 6/15/94 39 */ 40 41 /* 42 * Kernel parameter filesystem (/kern) 43 */ 44 45 #include <sys/param.h> 46 #include <sys/systm.h> 47 #include <sys/kernel.h> 48 #include <sys/vmmeter.h> 49 #include <sys/types.h> 50 #include <sys/time.h> 51 #include <sys/proc.h> 52 #include <sys/vnode.h> 53 #include <sys/malloc.h> 54 #include <sys/file.h> 55 #include <sys/stat.h> 56 #include <sys/mount.h> 57 #include <sys/namei.h> 58 #include <sys/buf.h> 59 #include <sys/dirent.h> 60 #include <miscfs/kernfs/kernfs.h> 61 62 #define KSTRING 256 /* Largest I/O available via this filesystem */ 63 #define UIO_MX 32 64 65 #define READ_MODE (S_IRUSR|S_IRGRP|S_IROTH) 66 #define WRITE_MODE (S_IWUSR|S_IRUSR|S_IRGRP|S_IROTH) 67 #define DIR_MODE (S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) 68 69 struct kern_target { 70 u_char kt_type; 71 u_char kt_namlen; 72 char *kt_name; 73 void *kt_data; 74 #define KTT_NULL 1 75 #define KTT_TIME 5 76 #define KTT_INT 17 77 #define KTT_STRING 31 78 #define KTT_HOSTNAME 47 79 #define KTT_AVENRUN 53 80 #define KTT_DEVICE 71 81 u_char kt_tag; 82 u_char kt_vtype; 83 mode_t kt_mode; 84 } kern_targets[] = { 85 /* NOTE: The name must be less than UIO_MX-16 chars in length */ 86 #define N(s) sizeof(s)-1, s 87 /* name data tag type ro/rw */ 88 { DT_DIR, N("."), 0, KTT_NULL, VDIR, DIR_MODE }, 89 { DT_DIR, N(".."), 0, KTT_NULL, VDIR, DIR_MODE }, 90 { DT_REG, N("boottime"), &boottime.tv_sec, KTT_INT, VREG, READ_MODE }, 91 { DT_REG, N("copyright"), copyright, KTT_STRING, VREG, READ_MODE }, 92 { DT_REG, N("hostname"), 0, KTT_HOSTNAME, VREG, WRITE_MODE }, 93 { DT_REG, N("hz"), &hz, KTT_INT, VREG, READ_MODE }, 94 { DT_REG, N("loadavg"), 0, KTT_AVENRUN, VREG, READ_MODE }, 95 { DT_REG, N("pagesize"), &cnt.v_page_size, KTT_INT, VREG, READ_MODE }, 96 { DT_REG, N("physmem"), &physmem, KTT_INT, VREG, READ_MODE }, 97 #if 0 98 { DT_DIR, N("root"), 0, KTT_NULL, VDIR, DIR_MODE }, 99 #endif 100 { DT_BLK, N("rootdev"), &rootdev, KTT_DEVICE, VBLK, READ_MODE }, 101 { DT_CHR, N("rrootdev"), &rrootdev, KTT_DEVICE, VCHR, READ_MODE }, 102 { DT_REG, N("time"), 0, KTT_TIME, VREG, READ_MODE }, 103 { DT_REG, N("version"), version, KTT_STRING, VREG, READ_MODE }, 104 #undef N 105 }; 106 static int nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]); 107 108 static int 109 kernfs_xread(kt, buf, len, lenp) 110 struct kern_target *kt; 111 char *buf; 112 int len; 113 int *lenp; 114 { 115 116 switch (kt->kt_tag) { 117 case KTT_TIME: { 118 struct timeval tv; 119 microtime(&tv); 120 sprintf(buf, "%d %d\n", tv.tv_sec, tv.tv_usec); 121 break; 122 } 123 124 case KTT_INT: { 125 int *ip = kt->kt_data; 126 sprintf(buf, "%d\n", *ip); 127 break; 128 } 129 130 case KTT_STRING: { 131 char *cp = kt->kt_data; 132 int xlen = strlen(cp) + 1; 133 134 if (xlen >= len) 135 return (EINVAL); 136 137 bcopy(cp, buf, xlen); 138 break; 139 } 140 141 case KTT_HOSTNAME: { 142 char *cp = hostname; 143 int xlen = hostnamelen; 144 145 if (xlen >= (len-2)) 146 return (EINVAL); 147 148 bcopy(cp, buf, xlen); 149 buf[xlen] = '\n'; 150 buf[xlen+1] = '\0'; 151 break; 152 } 153 154 case KTT_AVENRUN: 155 sprintf(buf, "%ld %ld %ld %ld\n", 156 averunnable.ldavg[0], averunnable.ldavg[1], 157 averunnable.ldavg[2], averunnable.fscale); 158 break; 159 160 default: 161 return (EIO); 162 } 163 164 *lenp = strlen(buf); 165 return (0); 166 } 167 168 static int 169 kernfs_xwrite(kt, buf, len) 170 struct kern_target *kt; 171 char *buf; 172 int len; 173 { 174 175 switch (kt->kt_tag) { 176 case KTT_HOSTNAME: 177 if (buf[len-1] == '\n') 178 --len; 179 bcopy(buf, hostname, len); 180 hostname[len] = '\0'; 181 hostnamelen = len; 182 return (0); 183 184 default: 185 return (EIO); 186 } 187 } 188 189 190 /* 191 * vp is the current namei directory 192 * ndp is the name to locate in that directory... 193 */ 194 kernfs_lookup(ap) 195 struct vop_lookup_args /* { 196 struct vnode * a_dvp; 197 struct vnode ** a_vpp; 198 struct componentname * a_cnp; 199 } */ *ap; 200 { 201 struct componentname *cnp = ap->a_cnp; 202 struct vnode **vpp = ap->a_vpp; 203 struct vnode *dvp = ap->a_dvp; 204 char *pname = cnp->cn_nameptr; 205 struct kern_target *kt; 206 struct vnode *fvp; 207 int error, i; 208 209 #ifdef KERNFS_DIAGNOSTIC 210 printf("kernfs_lookup(%x)\n", ap); 211 printf("kernfs_lookup(dp = %x, vpp = %x, cnp = %x)\n", dvp, vpp, ap->a_cnp); 212 printf("kernfs_lookup(%s)\n", pname); 213 #endif 214 215 if (cnp->cn_namelen == 1 && *pname == '.') { 216 *vpp = dvp; 217 VREF(dvp); 218 /*VOP_LOCK(dvp);*/ 219 return (0); 220 } 221 222 #if 0 223 if (cnp->cn_namelen == 4 && bcmp(pname, "root", 4) == 0) { 224 *vpp = rootdir; 225 VREF(rootdir); 226 VOP_LOCK(rootdir); 227 return (0); 228 } 229 #endif 230 231 *vpp = NULLVP; 232 233 for (error = ENOENT, kt = kern_targets, i = 0; i < nkern_targets; 234 kt++, i++) { 235 if (cnp->cn_namelen == kt->kt_namlen && 236 bcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) { 237 error = 0; 238 break; 239 } 240 } 241 242 #ifdef KERNFS_DIAGNOSTIC 243 printf("kernfs_lookup: i = %d, error = %d\n", i, error); 244 #endif 245 246 if (error) 247 return (error); 248 249 if (kt->kt_tag == KTT_DEVICE) { 250 dev_t *dp = kt->kt_data; 251 loop: 252 if (*dp == NODEV || !vfinddev(*dp, kt->kt_vtype, &fvp)) 253 return (ENOENT); 254 *vpp = fvp; 255 if (vget(fvp, 1)) 256 goto loop; 257 return (0); 258 } 259 260 #ifdef KERNFS_DIAGNOSTIC 261 printf("kernfs_lookup: allocate new vnode\n"); 262 #endif 263 if (error = getnewvnode(VT_KERNFS, dvp->v_mount, kernfs_vnodeop_p, 264 &fvp)) 265 return (error); 266 267 MALLOC(fvp->v_data, void *, sizeof(struct kernfs_node), M_TEMP, 268 M_WAITOK); 269 VTOKERN(fvp)->kf_kt = kt; 270 fvp->v_type = kt->kt_vtype; 271 *vpp = fvp; 272 273 #ifdef KERNFS_DIAGNOSTIC 274 printf("kernfs_lookup: newvp = %x\n", fvp); 275 #endif 276 return (0); 277 } 278 279 kernfs_open(ap) 280 struct vop_open_args /* { 281 struct vnode *a_vp; 282 int a_mode; 283 struct ucred *a_cred; 284 struct proc *a_p; 285 } */ *ap; 286 { 287 288 /* Only need to check access permissions. */ 289 return (0); 290 } 291 292 static int 293 kernfs_access(ap) 294 struct vop_access_args /* { 295 struct vnode *a_vp; 296 int a_mode; 297 struct ucred *a_cred; 298 struct proc *a_p; 299 } */ *ap; 300 { 301 struct vnode *vp = ap->a_vp; 302 struct ucred *cred = ap->a_cred; 303 mode_t amode = ap->a_mode; 304 mode_t fmode = 305 (vp->v_flag & VROOT) ? DIR_MODE : VTOKERN(vp)->kf_kt->kt_mode; 306 mode_t mask = 0; 307 gid_t *gp; 308 int i; 309 310 /* Some files are simply not modifiable. */ 311 if ((amode & VWRITE) && (fmode & (S_IWUSR|S_IWGRP|S_IWOTH)) == 0) 312 return (EPERM); 313 314 /* Root can do anything else. */ 315 if (cred->cr_uid == 0) 316 return (0); 317 318 /* Check for group 0 (wheel) permissions. */ 319 for (i = 0, gp = cred->cr_groups; i < cred->cr_ngroups; i++, gp++) 320 if (*gp == 0) { 321 if (amode & VEXEC) 322 mask |= S_IXGRP; 323 if (amode & VREAD) 324 mask |= S_IRGRP; 325 if (amode & VWRITE) 326 mask |= S_IWGRP; 327 return ((fmode & mask) == mask ? 0 : EACCES); 328 } 329 330 /* Otherwise, check everyone else. */ 331 if (amode & VEXEC) 332 mask |= S_IXOTH; 333 if (amode & VREAD) 334 mask |= S_IROTH; 335 if (amode & VWRITE) 336 mask |= S_IWOTH; 337 return ((fmode & mask) == mask ? 0 : EACCES); 338 } 339 340 kernfs_getattr(ap) 341 struct vop_getattr_args /* { 342 struct vnode *a_vp; 343 struct vattr *a_vap; 344 struct ucred *a_cred; 345 struct proc *a_p; 346 } */ *ap; 347 { 348 struct vnode *vp = ap->a_vp; 349 struct vattr *vap = ap->a_vap; 350 int error = 0; 351 char strbuf[KSTRING]; 352 353 bzero((caddr_t) vap, sizeof(*vap)); 354 vattr_null(vap); 355 vap->va_uid = 0; 356 vap->va_gid = 0; 357 vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0]; 358 vap->va_size = 0; 359 vap->va_blocksize = DEV_BSIZE; 360 microtime(&vap->va_atime); 361 vap->va_mtime = vap->va_atime; 362 vap->va_ctime = vap->va_ctime; 363 vap->va_gen = 0; 364 vap->va_flags = 0; 365 vap->va_rdev = 0; 366 vap->va_bytes = 0; 367 368 if (vp->v_flag & VROOT) { 369 #ifdef KERNFS_DIAGNOSTIC 370 printf("kernfs_getattr: stat rootdir\n"); 371 #endif 372 vap->va_type = VDIR; 373 vap->va_mode = DIR_MODE; 374 vap->va_nlink = 2; 375 vap->va_fileid = 2; 376 vap->va_size = DEV_BSIZE; 377 } else { 378 struct kern_target *kt = VTOKERN(vp)->kf_kt; 379 int nbytes; 380 #ifdef KERNFS_DIAGNOSTIC 381 printf("kernfs_getattr: stat target %s\n", kt->kt_name); 382 #endif 383 vap->va_type = kt->kt_vtype; 384 vap->va_mode = kt->kt_mode; 385 vap->va_nlink = 1; 386 vap->va_fileid = 1 + (kt - kern_targets) / sizeof(*kt); 387 error = kernfs_xread(kt, strbuf, sizeof(strbuf), &nbytes); 388 vap->va_size = nbytes; 389 } 390 391 #ifdef KERNFS_DIAGNOSTIC 392 printf("kernfs_getattr: return error %d\n", error); 393 #endif 394 return (error); 395 } 396 397 kernfs_setattr(ap) 398 struct vop_setattr_args /* { 399 struct vnode *a_vp; 400 struct vattr *a_vap; 401 struct ucred *a_cred; 402 struct proc *a_p; 403 } */ *ap; 404 { 405 406 /* 407 * Silently ignore attribute changes. 408 * This allows for open with truncate to have no 409 * effect until some data is written. I want to 410 * do it this way because all writes are atomic. 411 */ 412 return (0); 413 } 414 415 static int 416 kernfs_read(ap) 417 struct vop_read_args /* { 418 struct vnode *a_vp; 419 struct uio *a_uio; 420 int a_ioflag; 421 struct ucred *a_cred; 422 } */ *ap; 423 { 424 struct vnode *vp = ap->a_vp; 425 struct uio *uio = ap->a_uio; 426 struct kern_target *kt; 427 char strbuf[KSTRING]; 428 int off = uio->uio_offset; 429 int error, len; 430 char *cp; 431 432 if (vp->v_type == VDIR) 433 return (EOPNOTSUPP); 434 435 kt = VTOKERN(vp)->kf_kt; 436 437 #ifdef KERNFS_DIAGNOSTIC 438 printf("kern_read %s\n", kt->kt_name); 439 #endif 440 441 len = 0; 442 if (error = kernfs_xread(kt, strbuf, sizeof(strbuf), &len)) 443 return (error); 444 if (len <= off) 445 return (0); 446 return (uiomove(&strbuf[off], len - off, uio)); 447 } 448 449 static int 450 kernfs_write(ap) 451 struct vop_write_args /* { 452 struct vnode *a_vp; 453 struct uio *a_uio; 454 int a_ioflag; 455 struct ucred *a_cred; 456 } */ *ap; 457 { 458 struct vnode *vp = ap->a_vp; 459 struct uio *uio = ap->a_uio; 460 struct kern_target *kt; 461 int error, xlen; 462 char strbuf[KSTRING]; 463 464 if (vp->v_type == VDIR) 465 return (EOPNOTSUPP); 466 467 kt = VTOKERN(vp)->kf_kt; 468 469 if (uio->uio_offset != 0) 470 return (EINVAL); 471 472 xlen = min(uio->uio_resid, KSTRING-1); 473 if (error = uiomove(strbuf, xlen, uio)) 474 return (error); 475 476 if (uio->uio_resid != 0) 477 return (EIO); 478 479 strbuf[xlen] = '\0'; 480 xlen = strlen(strbuf); 481 return (kernfs_xwrite(kt, strbuf, xlen)); 482 } 483 484 kernfs_readdir(ap) 485 struct vop_readdir_args /* { 486 struct vnode *a_vp; 487 struct uio *a_uio; 488 struct ucred *a_cred; 489 int *a_eofflag; 490 u_long *a_cookies; 491 int a_ncookies; 492 } */ *ap; 493 { 494 struct uio *uio = ap->a_uio; 495 struct kern_target *kt; 496 struct dirent d; 497 int i; 498 int error; 499 500 if (ap->a_vp->v_type != VDIR) 501 return (ENOTDIR); 502 503 /* 504 * We don't allow exporting kernfs mounts, and currently local 505 * requests do not need cookies. 506 */ 507 if (ap->a_ncookies != NULL) 508 panic("kernfs_readdir: not hungry"); 509 510 i = uio->uio_offset / UIO_MX; 511 error = 0; 512 for (kt = &kern_targets[i]; 513 uio->uio_resid >= UIO_MX && i < nkern_targets; kt++, i++) { 514 struct dirent *dp = &d; 515 #ifdef KERNFS_DIAGNOSTIC 516 printf("kernfs_readdir: i = %d\n", i); 517 #endif 518 519 if (kt->kt_tag == KTT_DEVICE) { 520 dev_t *dp = kt->kt_data; 521 struct vnode *fvp; 522 523 if (*dp == NODEV || !vfinddev(*dp, kt->kt_vtype, &fvp)) 524 continue; 525 } 526 527 bzero((caddr_t)dp, UIO_MX); 528 dp->d_namlen = kt->kt_namlen; 529 bcopy(kt->kt_name, dp->d_name, kt->kt_namlen+1); 530 531 #ifdef KERNFS_DIAGNOSTIC 532 printf("kernfs_readdir: name = %s, len = %d\n", 533 dp->d_name, dp->d_namlen); 534 #endif 535 /* 536 * Fill in the remaining fields 537 */ 538 dp->d_reclen = UIO_MX; 539 dp->d_fileno = i + 3; 540 dp->d_type = kt->kt_type; 541 /* 542 * And ship to userland 543 */ 544 if (error = uiomove((caddr_t)dp, UIO_MX, uio)) 545 break; 546 } 547 548 uio->uio_offset = i * UIO_MX; 549 550 return (error); 551 } 552 553 kernfs_inactive(ap) 554 struct vop_inactive_args /* { 555 struct vnode *a_vp; 556 } */ *ap; 557 { 558 struct vnode *vp = ap->a_vp; 559 560 #ifdef KERNFS_DIAGNOSTIC 561 printf("kernfs_inactive(%x)\n", vp); 562 #endif 563 /* 564 * Clear out the v_type field to avoid 565 * nasty things happening in vgone(). 566 */ 567 vp->v_type = VNON; 568 return (0); 569 } 570 571 kernfs_reclaim(ap) 572 struct vop_reclaim_args /* { 573 struct vnode *a_vp; 574 } */ *ap; 575 { 576 struct vnode *vp = ap->a_vp; 577 578 #ifdef KERNFS_DIAGNOSTIC 579 printf("kernfs_reclaim(%x)\n", vp); 580 #endif 581 if (vp->v_data) { 582 FREE(vp->v_data, M_TEMP); 583 vp->v_data = 0; 584 } 585 return (0); 586 } 587 588 /* 589 * Return POSIX pathconf information applicable to special devices. 590 */ 591 kernfs_pathconf(ap) 592 struct vop_pathconf_args /* { 593 struct vnode *a_vp; 594 int a_name; 595 int *a_retval; 596 } */ *ap; 597 { 598 599 switch (ap->a_name) { 600 case _PC_LINK_MAX: 601 *ap->a_retval = LINK_MAX; 602 return (0); 603 case _PC_MAX_CANON: 604 *ap->a_retval = MAX_CANON; 605 return (0); 606 case _PC_MAX_INPUT: 607 *ap->a_retval = MAX_INPUT; 608 return (0); 609 case _PC_PIPE_BUF: 610 *ap->a_retval = PIPE_BUF; 611 return (0); 612 case _PC_CHOWN_RESTRICTED: 613 *ap->a_retval = 1; 614 return (0); 615 case _PC_VDISABLE: 616 *ap->a_retval = _POSIX_VDISABLE; 617 return (0); 618 default: 619 return (EINVAL); 620 } 621 /* NOTREACHED */ 622 } 623 624 /* 625 * Print out the contents of a /dev/fd vnode. 626 */ 627 /* ARGSUSED */ 628 kernfs_print(ap) 629 struct vop_print_args /* { 630 struct vnode *a_vp; 631 } */ *ap; 632 { 633 634 printf("tag VT_KERNFS, kernfs vnode\n"); 635 return (0); 636 } 637 638 /*void*/ 639 kernfs_vfree(ap) 640 struct vop_vfree_args /* { 641 struct vnode *a_pvp; 642 ino_t a_ino; 643 int a_mode; 644 } */ *ap; 645 { 646 647 return (0); 648 } 649 650 /* 651 * /dev/fd vnode unsupported operation 652 */ 653 kernfs_enotsupp() 654 { 655 656 return (EOPNOTSUPP); 657 } 658 659 /* 660 * /dev/fd "should never get here" operation 661 */ 662 kernfs_badop() 663 { 664 665 panic("kernfs: bad op"); 666 /* NOTREACHED */ 667 } 668 669 /* 670 * kernfs vnode null operation 671 */ 672 kernfs_nullop() 673 { 674 675 return (0); 676 } 677 678 #define kernfs_create ((int (*) __P((struct vop_create_args *)))kernfs_enotsupp) 679 #define kernfs_mknod ((int (*) __P((struct vop_mknod_args *)))kernfs_enotsupp) 680 #define kernfs_close ((int (*) __P((struct vop_close_args *)))nullop) 681 #define kernfs_ioctl ((int (*) __P((struct vop_ioctl_args *)))kernfs_enotsupp) 682 #define kernfs_select ((int (*) __P((struct vop_select_args *)))kernfs_enotsupp) 683 #define kernfs_mmap ((int (*) __P((struct vop_mmap_args *)))kernfs_enotsupp) 684 #define kernfs_fsync ((int (*) __P((struct vop_fsync_args *)))nullop) 685 #define kernfs_seek ((int (*) __P((struct vop_seek_args *)))nullop) 686 #define kernfs_remove ((int (*) __P((struct vop_remove_args *)))kernfs_enotsupp) 687 #define kernfs_link ((int (*) __P((struct vop_link_args *)))kernfs_enotsupp) 688 #define kernfs_rename ((int (*) __P((struct vop_rename_args *)))kernfs_enotsupp) 689 #define kernfs_mkdir ((int (*) __P((struct vop_mkdir_args *)))kernfs_enotsupp) 690 #define kernfs_rmdir ((int (*) __P((struct vop_rmdir_args *)))kernfs_enotsupp) 691 #define kernfs_symlink ((int (*) __P((struct vop_symlink_args *)))kernfs_enotsupp) 692 #define kernfs_readlink \ 693 ((int (*) __P((struct vop_readlink_args *)))kernfs_enotsupp) 694 #define kernfs_abortop ((int (*) __P((struct vop_abortop_args *)))nullop) 695 #define kernfs_lock ((int (*) __P((struct vop_lock_args *)))nullop) 696 #define kernfs_unlock ((int (*) __P((struct vop_unlock_args *)))nullop) 697 #define kernfs_bmap ((int (*) __P((struct vop_bmap_args *)))kernfs_badop) 698 #define kernfs_strategy ((int (*) __P((struct vop_strategy_args *)))kernfs_badop) 699 #define kernfs_islocked ((int (*) __P((struct vop_islocked_args *)))nullop) 700 #define kernfs_advlock ((int (*) __P((struct vop_advlock_args *)))kernfs_enotsupp) 701 #define kernfs_blkatoff \ 702 ((int (*) __P((struct vop_blkatoff_args *)))kernfs_enotsupp) 703 #define kernfs_valloc ((int(*) __P(( \ 704 struct vnode *pvp, \ 705 int mode, \ 706 struct ucred *cred, \ 707 struct vnode **vpp))) kernfs_enotsupp) 708 #define kernfs_truncate \ 709 ((int (*) __P((struct vop_truncate_args *)))kernfs_enotsupp) 710 #define kernfs_update ((int (*) __P((struct vop_update_args *)))kernfs_enotsupp) 711 #define kernfs_bwrite ((int (*) __P((struct vop_bwrite_args *)))kernfs_enotsupp) 712 713 int (**kernfs_vnodeop_p)(); 714 struct vnodeopv_entry_desc kernfs_vnodeop_entries[] = { 715 { &vop_default_desc, vn_default_error }, 716 { &vop_lookup_desc, kernfs_lookup }, /* lookup */ 717 { &vop_create_desc, kernfs_create }, /* create */ 718 { &vop_mknod_desc, kernfs_mknod }, /* mknod */ 719 { &vop_open_desc, kernfs_open }, /* open */ 720 { &vop_close_desc, kernfs_close }, /* close */ 721 { &vop_access_desc, kernfs_access }, /* access */ 722 { &vop_getattr_desc, kernfs_getattr }, /* getattr */ 723 { &vop_setattr_desc, kernfs_setattr }, /* setattr */ 724 { &vop_read_desc, kernfs_read }, /* read */ 725 { &vop_write_desc, kernfs_write }, /* write */ 726 { &vop_ioctl_desc, kernfs_ioctl }, /* ioctl */ 727 { &vop_select_desc, kernfs_select }, /* select */ 728 { &vop_mmap_desc, kernfs_mmap }, /* mmap */ 729 { &vop_fsync_desc, kernfs_fsync }, /* fsync */ 730 { &vop_seek_desc, kernfs_seek }, /* seek */ 731 { &vop_remove_desc, kernfs_remove }, /* remove */ 732 { &vop_link_desc, kernfs_link }, /* link */ 733 { &vop_rename_desc, kernfs_rename }, /* rename */ 734 { &vop_mkdir_desc, kernfs_mkdir }, /* mkdir */ 735 { &vop_rmdir_desc, kernfs_rmdir }, /* rmdir */ 736 { &vop_symlink_desc, kernfs_symlink }, /* symlink */ 737 { &vop_readdir_desc, kernfs_readdir }, /* readdir */ 738 { &vop_readlink_desc, kernfs_readlink },/* readlink */ 739 { &vop_abortop_desc, kernfs_abortop }, /* abortop */ 740 { &vop_inactive_desc, kernfs_inactive },/* inactive */ 741 { &vop_reclaim_desc, kernfs_reclaim }, /* reclaim */ 742 { &vop_lock_desc, kernfs_lock }, /* lock */ 743 { &vop_unlock_desc, kernfs_unlock }, /* unlock */ 744 { &vop_bmap_desc, kernfs_bmap }, /* bmap */ 745 { &vop_strategy_desc, kernfs_strategy },/* strategy */ 746 { &vop_print_desc, kernfs_print }, /* print */ 747 { &vop_islocked_desc, kernfs_islocked },/* islocked */ 748 { &vop_pathconf_desc, kernfs_pathconf },/* pathconf */ 749 { &vop_advlock_desc, kernfs_advlock }, /* advlock */ 750 { &vop_blkatoff_desc, kernfs_blkatoff },/* blkatoff */ 751 { &vop_valloc_desc, kernfs_valloc }, /* valloc */ 752 { &vop_vfree_desc, kernfs_vfree }, /* vfree */ 753 { &vop_truncate_desc, kernfs_truncate },/* truncate */ 754 { &vop_update_desc, kernfs_update }, /* update */ 755 { &vop_bwrite_desc, kernfs_bwrite }, /* bwrite */ 756 { (struct vnodeop_desc*)NULL, (int(*)())NULL } 757 }; 758 struct vnodeopv_desc kernfs_vnodeop_opv_desc = 759 { &kernfs_vnodeop_p, kernfs_vnodeop_entries }; 760
Indexes created Wed Oct 01 19:09:53 GMT 2025