kernfs_vnops.c revision 1.1.1.1
1 /* 2 * Copyright (c) 1992, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * This code is derived from software donated to Berkeley by 6 * Jan-Simon Pendry. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed by the University of 19 * California, Berkeley and its contributors. 20 * 4. Neither the name of the University nor the names of its contributors 21 * may be used to endorse or promote products derived from this software 22 * without specific prior written permission. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 * 36 * @(#)kernfs_vnops.c 8.6 (Berkeley) 2/10/94 37 */ 38 39 /* 40 * Kernel parameter filesystem (/kern) 41 */ 42 43 #include <sys/param.h> 44 #include <sys/systm.h> 45 #include <sys/kernel.h> 46 #include <sys/vmmeter.h> 47 #include <sys/types.h> 48 #include <sys/time.h> 49 #include <sys/proc.h> 50 #include <sys/vnode.h> 51 #include <sys/malloc.h> 52 #include <sys/file.h> 53 #include <sys/stat.h> 54 #include <sys/mount.h> 55 #include <sys/namei.h> 56 #include <sys/buf.h> 57 #include <sys/dirent.h> 58 #include <miscfs/kernfs/kernfs.h> 59 60 #define KSTRING 256 /* Largest I/O available via this filesystem */ 61 #define UIO_MX 32 62 63 #define READ_MODE (S_IRUSR|S_IRGRP|S_IROTH) 64 #define WRITE_MODE (S_IWUSR|S_IRUSR|S_IRGRP|S_IROTH) 65 #define DIR_MODE (S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) 66 67 struct kern_target { 68 char *kt_name; 69 void *kt_data; 70 #define KTT_NULL 1 71 #define KTT_TIME 5 72 #define KTT_INT 17 73 #define KTT_STRING 31 74 #define KTT_HOSTNAME 47 75 #define KTT_AVENRUN 53 76 int kt_tag; 77 int kt_rw; 78 int kt_vtype; 79 } kern_targets[] = { 80 /* NOTE: The name must be less than UIO_MX-16 chars in length */ 81 /* name data tag ro/rw */ 82 { ".", 0, KTT_NULL, VREAD, VDIR }, 83 { "..", 0, KTT_NULL, VREAD, VDIR }, 84 { "boottime", &boottime.tv_sec, KTT_INT, VREAD, VREG }, 85 { "copyright", copyright, KTT_STRING, VREAD, VREG }, 86 { "hostname", 0, KTT_HOSTNAME, VREAD|VWRITE, VREG }, 87 { "hz", &hz, KTT_INT, VREAD, VREG }, 88 { "loadavg", 0, KTT_AVENRUN, VREAD, VREG }, 89 { "pagesize", &cnt.v_page_size, KTT_INT, VREAD, VREG }, 90 { "physmem", &physmem, KTT_INT, VREAD, VREG }, 91 #if 0 92 { "root", 0, KTT_NULL, VREAD, VDIR }, 93 #endif 94 { "rootdev", 0, KTT_NULL, VREAD, VBLK }, 95 { "rrootdev", 0, KTT_NULL, VREAD, VCHR }, 96 { "time", 0, KTT_TIME, VREAD, VREG }, 97 { "version", version, KTT_STRING, VREAD, VREG }, 98 }; 99 100 static int nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]); 101 102 static int 103 kernfs_xread(kt, buf, len, lenp) 104 struct kern_target *kt; 105 char *buf; 106 int len; 107 int *lenp; 108 { 109 switch (kt->kt_tag) { 110 case KTT_TIME: { 111 struct timeval tv; 112 microtime(&tv); 113 sprintf(buf, "%d %d\n", tv.tv_sec, tv.tv_usec); 114 break; 115 } 116 117 case KTT_INT: { 118 int *ip = kt->kt_data; 119 sprintf(buf, "%d\n", *ip); 120 break; 121 } 122 123 case KTT_STRING: { 124 char *cp = kt->kt_data; 125 int xlen = strlen(cp) + 1; 126 127 if (xlen >= len) 128 return (EINVAL); 129 130 bcopy(cp, buf, xlen); 131 break; 132 } 133 134 case KTT_HOSTNAME: { 135 char *cp = hostname; 136 int xlen = hostnamelen; 137 138 if (xlen >= (len-2)) 139 return (EINVAL); 140 141 bcopy(cp, buf, xlen); 142 buf[xlen] = '\n'; 143 buf[xlen+1] = '\0'; 144 break; 145 } 146 147 case KTT_AVENRUN: 148 sprintf(buf, "%ld %ld %ld %ld\n", 149 averunnable.ldavg[0], 150 averunnable.ldavg[1], 151 averunnable.ldavg[2], 152 averunnable.fscale); 153 break; 154 155 default: 156 return (EINVAL); 157 } 158 159 *lenp = strlen(buf); 160 return (0); 161 } 162 163 static int 164 kernfs_xwrite(kt, buf, len) 165 struct kern_target *kt; 166 char *buf; 167 int len; 168 { 169 switch (kt->kt_tag) { 170 case KTT_HOSTNAME: { 171 if (buf[len-1] == '\n') 172 --len; 173 bcopy(buf, hostname, len); 174 hostname[len] = '\0'; 175 hostnamelen = len; 176 return (0); 177 } 178 179 default: 180 return (EIO); 181 } 182 } 183 184 185 /* 186 * vp is the current namei directory 187 * ndp is the name to locate in that directory... 188 */ 189 kernfs_lookup(ap) 190 struct vop_lookup_args /* { 191 struct vnode * a_dvp; 192 struct vnode ** a_vpp; 193 struct componentname * a_cnp; 194 } */ *ap; 195 { 196 struct vnode **vpp = ap->a_vpp; 197 struct vnode *dvp = ap->a_dvp; 198 struct componentname *cnp = ap->a_cnp; 199 struct vnode *fvp; 200 int error, i; 201 char *pname; 202 203 #ifdef KERNFS_DIAGNOSTIC 204 printf("kernfs_lookup(%x)\n", ap); 205 printf("kernfs_lookup(dp = %x, vpp = %x, cnp = %x)\n", dvp, vpp, ap->a_cnp); 206 #endif 207 pname = cnp->cn_nameptr; 208 #ifdef KERNFS_DIAGNOSTIC 209 printf("kernfs_lookup(%s)\n", pname); 210 #endif 211 if (cnp->cn_namelen == 1 && *pname == '.') { 212 *vpp = dvp; 213 VREF(dvp); 214 /*VOP_LOCK(dvp);*/ 215 return (0); 216 } 217 218 #if 0 219 if (cnp->cn_namelen == 4 && bcmp(pname, "root", 4) == 0) { 220 *vpp = rootdir; 221 VREF(rootdir); 222 VOP_LOCK(rootdir); 223 return (0); 224 } 225 #endif 226 227 /* 228 * /kern/rootdev is the root device 229 */ 230 if (cnp->cn_namelen == 7 && bcmp(pname, "rootdev", 7) == 0) { 231 *vpp = rootvp; 232 VREF(rootvp); 233 VOP_LOCK(rootvp); 234 return (0); 235 } 236 237 /* 238 * /kern/rrootdev is the raw root device 239 */ 240 if (cnp->cn_namelen == 8 && bcmp(pname, "rrootdev", 8) == 0) { 241 if (rrootvp) { 242 *vpp = rrootvp; 243 VREF(rrootvp); 244 VOP_LOCK(rrootvp); 245 return (0); 246 } 247 error = ENXIO; 248 goto bad; 249 } 250 251 error = ENOENT; 252 253 for (i = 0; i < nkern_targets; i++) { 254 struct kern_target *kt = &kern_targets[i]; 255 if (cnp->cn_namelen == strlen(kt->kt_name) && 256 bcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) { 257 error = 0; 258 break; 259 } 260 } 261 262 #ifdef KERNFS_DIAGNOSTIC 263 printf("kernfs_lookup: i = %d, error = %d\n", i, error); 264 #endif 265 266 if (error) 267 goto bad; 268 269 #ifdef KERNFS_DIAGNOSTIC 270 printf("kernfs_lookup: allocate new vnode\n"); 271 #endif 272 error = getnewvnode(VT_KERNFS, dvp->v_mount, kernfs_vnodeop_p, &fvp); 273 if (error) 274 goto bad; 275 MALLOC(fvp->v_data, void *, sizeof(struct kernfs_node), M_TEMP, M_WAITOK); 276 VTOKERN(fvp)->kf_kt = &kern_targets[i]; 277 fvp->v_type = VTOKERN(fvp)->kf_kt->kt_vtype; 278 *vpp = fvp; 279 #ifdef KERNFS_DIAGNOSTIC 280 printf("kernfs_lookup: newvp = %x\n", fvp); 281 #endif 282 return (0); 283 284 bad:; 285 *vpp = NULL; 286 #ifdef KERNFS_DIAGNOSTIC 287 printf("kernfs_lookup: error = %d\n", error); 288 #endif 289 return (error); 290 } 291 292 kernfs_open(ap) 293 struct vop_open_args /* { 294 struct vnode *a_vp; 295 int a_mode; 296 struct ucred *a_cred; 297 struct proc *a_p; 298 } */ *ap; 299 { 300 struct vnode *vp = ap->a_vp; 301 302 /* 303 * Can always open the root (modulo perms) 304 */ 305 if (vp->v_flag & VROOT) 306 return (0); 307 308 #ifdef KERNFS_DIAGNOSTIC 309 printf("kernfs_open, mode = %x, file = %s\n", 310 ap->a_mode, VTOKERN(vp)->kf_kt->kt_name); 311 #endif 312 313 if ((ap->a_mode & FWRITE) && !(VTOKERN(vp)->kf_kt->kt_rw & VWRITE)) 314 return (EOPNOTSUPP); 315 316 return (0); 317 } 318 319 static int 320 kernfs_access(ap) 321 struct vop_access_args /* { 322 struct vnode *a_vp; 323 int a_mode; 324 struct ucred *a_cred; 325 struct proc *a_p; 326 } */ *ap; 327 { 328 struct vnode *vp = ap->a_vp; 329 struct ucred *cred = ap->a_cred; 330 mode_t mode = ap->a_mode; 331 332 if (mode & VEXEC) { 333 if (vp->v_flag & VROOT) 334 return (0); 335 return (EACCES); 336 } 337 338 if (cred->cr_uid == 0) { 339 if ((vp->v_flag & VROOT) == 0) { 340 struct kern_target *kt = VTOKERN(vp)->kf_kt; 341 342 if ((mode & VWRITE) && !(kt->kt_rw & VWRITE)) 343 return (EROFS); 344 } 345 return (0); 346 } 347 348 if (mode & VWRITE) 349 return (EACCES); 350 351 return (0); 352 } 353 354 355 kernfs_getattr(ap) 356 struct vop_getattr_args /* { 357 struct vnode *a_vp; 358 struct vattr *a_vap; 359 struct ucred *a_cred; 360 struct proc *a_p; 361 } */ *ap; 362 { 363 struct vnode *vp = ap->a_vp; 364 struct vattr *vap = ap->a_vap; 365 int error = 0; 366 char strbuf[KSTRING]; 367 368 bzero((caddr_t) vap, sizeof(*vap)); 369 vattr_null(vap); 370 vap->va_uid = 0; 371 vap->va_gid = 0; 372 vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0]; 373 /* vap->va_qsize = 0; */ 374 vap->va_blocksize = DEV_BSIZE; 375 microtime(&vap->va_atime); 376 vap->va_mtime = vap->va_atime; 377 vap->va_ctime = vap->va_ctime; 378 vap->va_gen = 0; 379 vap->va_flags = 0; 380 vap->va_rdev = 0; 381 /* vap->va_qbytes = 0; */ 382 vap->va_bytes = 0; 383 384 if (vp->v_flag & VROOT) { 385 #ifdef KERNFS_DIAGNOSTIC 386 printf("kernfs_getattr: stat rootdir\n"); 387 #endif 388 vap->va_type = VDIR; 389 vap->va_mode = DIR_MODE; 390 vap->va_nlink = 2; 391 vap->va_fileid = 2; 392 vap->va_size = DEV_BSIZE; 393 } else { 394 struct kern_target *kt = VTOKERN(vp)->kf_kt; 395 int nbytes; 396 #ifdef KERNFS_DIAGNOSTIC 397 printf("kernfs_getattr: stat target %s\n", kt->kt_name); 398 #endif 399 vap->va_type = kt->kt_vtype; 400 vap->va_mode = (kt->kt_rw & VWRITE ? WRITE_MODE : READ_MODE); 401 vap->va_nlink = 1; 402 vap->va_fileid = 3 + (kt - kern_targets) / sizeof(*kt); 403 error = kernfs_xread(kt, strbuf, sizeof(strbuf), &nbytes); 404 vap->va_size = nbytes; 405 } 406 407 vp->v_type = vap->va_type; 408 #ifdef KERNFS_DIAGNOSTIC 409 printf("kernfs_getattr: return error %d\n", error); 410 #endif 411 return (error); 412 } 413 414 kernfs_setattr(ap) 415 struct vop_setattr_args /* { 416 struct vnode *a_vp; 417 struct vattr *a_vap; 418 struct ucred *a_cred; 419 struct proc *a_p; 420 } */ *ap; 421 { 422 423 /* 424 * Silently ignore attribute changes. 425 * This allows for open with truncate to have no 426 * effect until some data is written. I want to 427 * do it this way because all writes are atomic. 428 */ 429 return (0); 430 } 431 432 static int 433 kernfs_read(ap) 434 struct vop_read_args /* { 435 struct vnode *a_vp; 436 struct uio *a_uio; 437 int a_ioflag; 438 struct ucred *a_cred; 439 } */ *ap; 440 { 441 struct vnode *vp = ap->a_vp; 442 struct uio *uio = ap->a_uio; 443 struct kern_target *kt; 444 char strbuf[KSTRING]; 445 int off = uio->uio_offset; 446 int error, len; 447 char *cp; 448 449 if (vp->v_flag & VROOT) 450 return (EOPNOTSUPP); 451 452 kt = VTOKERN(vp)->kf_kt; 453 454 #ifdef KERNFS_DIAGNOSTIC 455 printf("kern_read %s\n", kt->kt_name); 456 #endif 457 458 len = 0; 459 error = kernfs_xread(kt, strbuf, sizeof(strbuf), &len); 460 if (error) 461 return (error); 462 cp = strbuf + off; 463 len -= off; 464 return (uiomove(cp, len, uio)); 465 } 466 467 static int 468 kernfs_write(ap) 469 struct vop_write_args /* { 470 struct vnode *a_vp; 471 struct uio *a_uio; 472 int a_ioflag; 473 struct ucred *a_cred; 474 } */ *ap; 475 { 476 struct vnode *vp = ap->a_vp; 477 struct uio *uio = ap->a_uio; 478 struct kern_target *kt; 479 int error, xlen; 480 char strbuf[KSTRING]; 481 482 if (vp->v_flag & VROOT) 483 return (0); 484 485 kt = VTOKERN(vp)->kf_kt; 486 487 if (uio->uio_offset != 0) 488 return (EINVAL); 489 490 xlen = min(uio->uio_resid, KSTRING-1); 491 error = uiomove(strbuf, xlen, uio); 492 if (error) 493 return (error); 494 495 if (uio->uio_resid != 0) 496 return (EIO); 497 498 strbuf[xlen] = '\0'; 499 xlen = strlen(strbuf); 500 return (kernfs_xwrite(kt, strbuf, xlen)); 501 } 502 503 504 kernfs_readdir(ap) 505 struct vop_readdir_args /* { 506 struct vnode *a_vp; 507 struct uio *a_uio; 508 struct ucred *a_cred; 509 } */ *ap; 510 { 511 struct uio *uio = ap->a_uio; 512 int i; 513 int error; 514 515 i = uio->uio_offset / UIO_MX; 516 error = 0; 517 while (uio->uio_resid > 0 && i < nkern_targets) { 518 struct dirent d; 519 struct dirent *dp = &d; 520 struct kern_target *kt = &kern_targets[i]; 521 #ifdef KERNFS_DIAGNOSTIC 522 printf("kernfs_readdir: i = %d\n", i); 523 #endif 524 525 bzero((caddr_t) dp, UIO_MX); 526 527 dp->d_namlen = strlen(kt->kt_name); 528 bcopy(kt->kt_name, dp->d_name, dp->d_namlen+1); 529 530 #ifdef KERNFS_DIAGNOSTIC 531 printf("kernfs_readdir: name = %s, len = %d\n", 532 dp->d_name, dp->d_namlen); 533 #endif 534 /* 535 * Fill in the remaining fields 536 */ 537 dp->d_reclen = UIO_MX; 538 dp->d_fileno = i + 3; 539 dp->d_type = DT_UNKNOWN; /* XXX */ 540 /* 541 * And ship to userland 542 */ 543 error = uiomove((caddr_t) dp, UIO_MX, uio); 544 if (error) 545 break; 546 i++; 547 } 548 549 uio->uio_offset = i * UIO_MX; 550 551 return (error); 552 } 553 554 kernfs_inactive(ap) 555 struct vop_inactive_args /* { 556 struct vnode *a_vp; 557 } */ *ap; 558 { 559 struct vnode *vp = ap->a_vp; 560 561 /* 562 * Clear out the v_type field to avoid 563 * nasty things happening in vgone(). 564 */ 565 vp->v_type = VNON; 566 #ifdef KERNFS_DIAGNOSTIC 567 printf("kernfs_inactive(%x)\n", vp); 568 #endif 569 return (0); 570 } 571 572 kernfs_reclaim(ap) 573 struct vop_reclaim_args /* { 574 struct vnode *a_vp; 575 } */ *ap; 576 { 577 struct vnode *vp = ap->a_vp; 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