kernfs_vnops.c revision 1.54
1 /* $NetBSD: kernfs_vnops.c,v 1.54 1998/02/05 08:00:12 mrg 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 <sys/msgbuf.h> 61 62 #include <miscfs/genfs/genfs.h> 63 #include <miscfs/kernfs/kernfs.h> 64 65 #if defined(UVM) 66 #include <vm/vm.h> 67 #include <uvm/uvm_extern.h> 68 #endif 69 70 #define KSTRING 256 /* Largest I/O available via this filesystem */ 71 #define UIO_MX 32 72 73 #define READ_MODE (S_IRUSR|S_IRGRP|S_IROTH) 74 #define WRITE_MODE (S_IWUSR|S_IRUSR|S_IRGRP|S_IROTH) 75 #define DIR_MODE (S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) 76 77 struct kern_target kern_targets[] = { 78 /* NOTE: The name must be less than UIO_MX-16 chars in length */ 79 #define N(s) sizeof(s)-1, s 80 /* name data tag type ro/rw */ 81 { DT_DIR, N("."), 0, KTT_NULL, VDIR, DIR_MODE }, 82 { DT_DIR, N(".."), 0, KTT_NULL, VDIR, DIR_MODE }, 83 { DT_REG, N("boottime"), &boottime.tv_sec, KTT_INT, VREG, READ_MODE }, 84 { DT_REG, N("copyright"), copyright, KTT_STRING, VREG, READ_MODE }, 85 { DT_REG, N("hostname"), 0, KTT_HOSTNAME, VREG, WRITE_MODE }, 86 { DT_REG, N("hz"), &hz, KTT_INT, VREG, READ_MODE }, 87 { DT_REG, N("loadavg"), 0, KTT_AVENRUN, VREG, READ_MODE }, 88 { DT_REG, N("msgbuf"), 0, KTT_MSGBUF, VREG, READ_MODE }, 89 #if defined(UVM) 90 { DT_REG, N("pagesize"), &uvmexp.pagesize, KTT_INT, VREG, READ_MODE }, 91 #else 92 { DT_REG, N("pagesize"), &cnt.v_page_size, KTT_INT, VREG, READ_MODE }, 93 #endif 94 { DT_REG, N("physmem"), &physmem, KTT_INT, VREG, READ_MODE }, 95 #if 0 96 { DT_DIR, N("root"), 0, KTT_NULL, VDIR, DIR_MODE }, 97 #endif 98 { DT_BLK, N("rootdev"), &rootdev, KTT_DEVICE, VBLK, READ_MODE }, 99 { DT_CHR, N("rrootdev"), &rrootdev, KTT_DEVICE, VCHR, READ_MODE }, 100 { DT_REG, N("time"), 0, KTT_TIME, VREG, READ_MODE }, 101 { DT_REG, N("version"), version, KTT_STRING, VREG, READ_MODE }, 102 #undef N 103 }; 104 static int nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]); 105 106 int kernfs_lookup __P((void *)); 107 #define kernfs_create genfs_eopnotsupp 108 #define kernfs_mknod genfs_eopnotsupp 109 #define kernfs_open genfs_nullop 110 #define kernfs_close genfs_nullop 111 int kernfs_access __P((void *)); 112 int kernfs_getattr __P((void *)); 113 int kernfs_setattr __P((void *)); 114 int kernfs_read __P((void *)); 115 int kernfs_write __P((void *)); 116 #define kernfs_ioctl genfs_eopnotsupp 117 #define kernfs_poll genfs_poll 118 #define kernfs_mmap genfs_eopnotsupp 119 #define kernfs_fsync genfs_nullop 120 #define kernfs_seek genfs_nullop 121 #define kernfs_remove genfs_eopnotsupp 122 int kernfs_link __P((void *)); 123 #define kernfs_rename genfs_eopnotsupp 124 #define kernfs_mkdir genfs_eopnotsupp 125 #define kernfs_rmdir genfs_eopnotsupp 126 int kernfs_symlink __P((void *)); 127 int kernfs_readdir __P((void *)); 128 #define kernfs_readlink genfs_eopnotsupp 129 #define kernfs_abortop genfs_abortop 130 int kernfs_inactive __P((void *)); 131 int kernfs_reclaim __P((void *)); 132 #define kernfs_lock genfs_nullop 133 #define kernfs_unlock genfs_nullop 134 #define kernfs_bmap genfs_badop 135 #define kernfs_strategy genfs_badop 136 int kernfs_print __P((void *)); 137 #define kernfs_islocked genfs_nullop 138 int kernfs_pathconf __P((void *)); 139 #define kernfs_advlock genfs_eopnotsupp 140 #define kernfs_blkatoff genfs_eopnotsupp 141 #define kernfs_valloc genfs_eopnotsupp 142 #define kernfs_vfree genfs_nullop 143 #define kernfs_truncate genfs_eopnotsupp 144 #define kernfs_update genfs_nullop 145 #define kernfs_bwrite genfs_eopnotsupp 146 147 int kernfs_xread __P((struct kern_target *, int, char **, int)); 148 int kernfs_xwrite __P((struct kern_target *, char *, int)); 149 150 int (**kernfs_vnodeop_p) __P((void *)); 151 struct vnodeopv_entry_desc kernfs_vnodeop_entries[] = { 152 { &vop_default_desc, vn_default_error }, 153 { &vop_lookup_desc, kernfs_lookup }, /* lookup */ 154 { &vop_create_desc, kernfs_create }, /* create */ 155 { &vop_mknod_desc, kernfs_mknod }, /* mknod */ 156 { &vop_open_desc, kernfs_open }, /* open */ 157 { &vop_close_desc, kernfs_close }, /* close */ 158 { &vop_access_desc, kernfs_access }, /* access */ 159 { &vop_getattr_desc, kernfs_getattr }, /* getattr */ 160 { &vop_setattr_desc, kernfs_setattr }, /* setattr */ 161 { &vop_read_desc, kernfs_read }, /* read */ 162 { &vop_write_desc, kernfs_write }, /* write */ 163 { &vop_ioctl_desc, kernfs_ioctl }, /* ioctl */ 164 { &vop_poll_desc, kernfs_poll }, /* poll */ 165 { &vop_mmap_desc, kernfs_mmap }, /* mmap */ 166 { &vop_fsync_desc, kernfs_fsync }, /* fsync */ 167 { &vop_seek_desc, kernfs_seek }, /* seek */ 168 { &vop_remove_desc, kernfs_remove }, /* remove */ 169 { &vop_link_desc, kernfs_link }, /* link */ 170 { &vop_rename_desc, kernfs_rename }, /* rename */ 171 { &vop_mkdir_desc, kernfs_mkdir }, /* mkdir */ 172 { &vop_rmdir_desc, kernfs_rmdir }, /* rmdir */ 173 { &vop_symlink_desc, kernfs_symlink }, /* symlink */ 174 { &vop_readdir_desc, kernfs_readdir }, /* readdir */ 175 { &vop_readlink_desc, kernfs_readlink }, /* readlink */ 176 { &vop_abortop_desc, kernfs_abortop }, /* abortop */ 177 { &vop_inactive_desc, kernfs_inactive }, /* inactive */ 178 { &vop_reclaim_desc, kernfs_reclaim }, /* reclaim */ 179 { &vop_lock_desc, kernfs_lock }, /* lock */ 180 { &vop_unlock_desc, kernfs_unlock }, /* unlock */ 181 { &vop_bmap_desc, kernfs_bmap }, /* bmap */ 182 { &vop_strategy_desc, kernfs_strategy }, /* strategy */ 183 { &vop_print_desc, kernfs_print }, /* print */ 184 { &vop_islocked_desc, kernfs_islocked }, /* islocked */ 185 { &vop_pathconf_desc, kernfs_pathconf }, /* pathconf */ 186 { &vop_advlock_desc, kernfs_advlock }, /* advlock */ 187 { &vop_blkatoff_desc, kernfs_blkatoff }, /* blkatoff */ 188 { &vop_valloc_desc, kernfs_valloc }, /* valloc */ 189 { &vop_vfree_desc, kernfs_vfree }, /* vfree */ 190 { &vop_truncate_desc, kernfs_truncate }, /* truncate */ 191 { &vop_update_desc, kernfs_update }, /* update */ 192 { &vop_bwrite_desc, kernfs_bwrite }, /* bwrite */ 193 { (struct vnodeop_desc*)NULL, (int(*) __P((void *)))NULL } 194 }; 195 struct vnodeopv_desc kernfs_vnodeop_opv_desc = 196 { &kernfs_vnodeop_p, kernfs_vnodeop_entries }; 197 198 int 199 kernfs_xread(kt, off, bufp, len) 200 struct kern_target *kt; 201 int off; 202 char **bufp; 203 int len; 204 { 205 206 switch (kt->kt_tag) { 207 case KTT_TIME: { 208 struct timeval tv; 209 210 microtime(&tv); 211 sprintf(*bufp, "%ld %ld\n", tv.tv_sec, tv.tv_usec); 212 break; 213 } 214 215 case KTT_INT: { 216 int *ip = kt->kt_data; 217 218 sprintf(*bufp, "%d\n", *ip); 219 break; 220 } 221 222 case KTT_STRING: { 223 char *cp = kt->kt_data; 224 225 *bufp = cp; 226 break; 227 } 228 229 case KTT_MSGBUF: { 230 long n; 231 232 /* 233 * deal with cases where the message buffer has 234 * become corrupted. 235 */ 236 if (!msgbufenabled || msgbufp->msg_magic != MSG_MAGIC) { 237 msgbufenabled = 0; 238 return (ENXIO); 239 } 240 241 /* 242 * Note that reads of /kern/msgbuf won't necessarily yield 243 * consistent results, if the message buffer is modified 244 * while the read is in progress. The worst that can happen 245 * is that incorrect data will be read. There's no way 246 * that this can crash the system unless the values in the 247 * message buffer header are corrupted, but that'll cause 248 * the system to die anyway. 249 */ 250 if (off >= msgbufp->msg_bufs) 251 return (0); 252 n = msgbufp->msg_bufx + off; 253 if (n >= msgbufp->msg_bufs) 254 n -= msgbufp->msg_bufs; 255 len = min(msgbufp->msg_bufs - n, msgbufp->msg_bufs - off); 256 *bufp = msgbufp->msg_bufc + n; 257 return (len); 258 } 259 260 case KTT_HOSTNAME: { 261 char *cp = hostname; 262 int xlen = hostnamelen; 263 264 if (xlen >= (len-2)) 265 return (EINVAL); 266 267 bcopy(cp, *bufp, xlen); 268 (*bufp)[xlen] = '\n'; 269 (*bufp)[xlen+1] = '\0'; 270 break; 271 } 272 273 case KTT_AVENRUN: 274 averunnable.fscale = FSCALE; 275 sprintf(*bufp, "%d %d %d %ld\n", 276 averunnable.ldavg[0], averunnable.ldavg[1], 277 averunnable.ldavg[2], averunnable.fscale); 278 break; 279 280 default: 281 return (0); 282 } 283 284 len = strlen(*bufp); 285 if (len <= off) 286 return (0); 287 *bufp += off; 288 return (len - off); 289 } 290 291 int 292 kernfs_xwrite(kt, buf, len) 293 struct kern_target *kt; 294 char *buf; 295 int len; 296 { 297 298 switch (kt->kt_tag) { 299 case KTT_HOSTNAME: 300 if (buf[len-1] == '\n') 301 --len; 302 bcopy(buf, hostname, len); 303 hostname[len] = '\0'; 304 hostnamelen = len; 305 return (0); 306 307 default: 308 return (EIO); 309 } 310 } 311 312 313 /* 314 * vp is the current namei directory 315 * ndp is the name to locate in that directory... 316 */ 317 int 318 kernfs_lookup(v) 319 void *v; 320 { 321 struct vop_lookup_args /* { 322 struct vnode * a_dvp; 323 struct vnode ** a_vpp; 324 struct componentname * a_cnp; 325 } */ *ap = v; 326 struct componentname *cnp = ap->a_cnp; 327 struct vnode **vpp = ap->a_vpp; 328 struct vnode *dvp = ap->a_dvp; 329 const char *pname = cnp->cn_nameptr; 330 struct kern_target *kt; 331 struct vnode *fvp; 332 int error, i; 333 334 #ifdef KERNFS_DIAGNOSTIC 335 printf("kernfs_lookup(%p)\n", ap); 336 printf("kernfs_lookup(dp = %p, vpp = %p, cnp = %p)\n", dvp, vpp, ap->a_cnp); 337 printf("kernfs_lookup(%s)\n", pname); 338 #endif 339 340 *vpp = NULLVP; 341 342 if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME) 343 return (EROFS); 344 345 if (cnp->cn_namelen == 1 && *pname == '.') { 346 *vpp = dvp; 347 VREF(dvp); 348 /*VOP_LOCK(dvp);*/ 349 return (0); 350 } 351 352 #if 0 353 if (cnp->cn_namelen == 4 && bcmp(pname, "root", 4) == 0) { 354 *vpp = rootdir; 355 VREF(rootdir); 356 VOP_LOCK(rootdir); 357 return (0); 358 } 359 #endif 360 361 for (kt = kern_targets, i = 0; i < nkern_targets; kt++, i++) { 362 if (cnp->cn_namelen == kt->kt_namlen && 363 bcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) 364 goto found; 365 } 366 367 #ifdef KERNFS_DIAGNOSTIC 368 printf("kernfs_lookup: i = %d, failed", i); 369 #endif 370 371 return (cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS); 372 373 found: 374 if (kt->kt_tag == KTT_DEVICE) { 375 dev_t *dp = kt->kt_data; 376 loop: 377 if (*dp == NODEV || !vfinddev(*dp, kt->kt_vtype, &fvp)) 378 return (ENOENT); 379 *vpp = fvp; 380 if (vget(fvp, 1)) 381 goto loop; 382 return (0); 383 } 384 385 #ifdef KERNFS_DIAGNOSTIC 386 printf("kernfs_lookup: allocate new vnode\n"); 387 #endif 388 error = getnewvnode(VT_KERNFS, dvp->v_mount, kernfs_vnodeop_p, &fvp); 389 if (error) 390 return (error); 391 392 MALLOC(fvp->v_data, void *, sizeof(struct kernfs_node), M_TEMP, 393 M_WAITOK); 394 VTOKERN(fvp)->kf_kt = kt; 395 fvp->v_type = kt->kt_vtype; 396 *vpp = fvp; 397 398 #ifdef KERNFS_DIAGNOSTIC 399 printf("kernfs_lookup: newvp = %p\n", fvp); 400 #endif 401 return (0); 402 } 403 404 int 405 kernfs_access(v) 406 void *v; 407 { 408 struct vop_access_args /* { 409 struct vnode *a_vp; 410 int a_mode; 411 struct ucred *a_cred; 412 struct proc *a_p; 413 } */ *ap = v; 414 struct vnode *vp = ap->a_vp; 415 mode_t mode; 416 417 if (vp->v_flag & VROOT) { 418 mode = DIR_MODE; 419 } else { 420 struct kern_target *kt = VTOKERN(vp)->kf_kt; 421 mode = kt->kt_mode; 422 } 423 424 return (vaccess(vp->v_type, mode, (uid_t)0, (gid_t)0, ap->a_mode, 425 ap->a_cred)); 426 } 427 428 int 429 kernfs_getattr(v) 430 void *v; 431 { 432 struct vop_getattr_args /* { 433 struct vnode *a_vp; 434 struct vattr *a_vap; 435 struct ucred *a_cred; 436 struct proc *a_p; 437 } */ *ap = v; 438 struct vnode *vp = ap->a_vp; 439 struct vattr *vap = ap->a_vap; 440 struct timeval tv; 441 int error = 0; 442 char strbuf[KSTRING], *buf; 443 444 bzero((caddr_t) vap, sizeof(*vap)); 445 vattr_null(vap); 446 vap->va_uid = 0; 447 vap->va_gid = 0; 448 vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0]; 449 vap->va_size = 0; 450 vap->va_blocksize = DEV_BSIZE; 451 microtime(&tv); 452 TIMEVAL_TO_TIMESPEC(&tv, &vap->va_atime); 453 vap->va_mtime = vap->va_atime; 454 vap->va_ctime = vap->va_ctime; 455 vap->va_gen = 0; 456 vap->va_flags = 0; 457 vap->va_rdev = 0; 458 vap->va_bytes = 0; 459 460 if (vp->v_flag & VROOT) { 461 #ifdef KERNFS_DIAGNOSTIC 462 printf("kernfs_getattr: stat rootdir\n"); 463 #endif 464 vap->va_type = VDIR; 465 vap->va_mode = DIR_MODE; 466 vap->va_nlink = 2; 467 vap->va_fileid = 2; 468 vap->va_size = DEV_BSIZE; 469 } else { 470 struct kern_target *kt = VTOKERN(vp)->kf_kt; 471 int nbytes, total; 472 #ifdef KERNFS_DIAGNOSTIC 473 printf("kernfs_getattr: stat target %s\n", kt->kt_name); 474 #endif 475 vap->va_type = kt->kt_vtype; 476 vap->va_mode = kt->kt_mode; 477 vap->va_nlink = 1; 478 vap->va_fileid = 3 + (kt - kern_targets); 479 total = 0; 480 while (buf = strbuf, 481 nbytes = kernfs_xread(kt, total, &buf, sizeof(strbuf))) 482 total += nbytes; 483 vap->va_size = total; 484 } 485 486 #ifdef KERNFS_DIAGNOSTIC 487 printf("kernfs_getattr: return error %d\n", error); 488 #endif 489 return (error); 490 } 491 492 /*ARGSUSED*/ 493 int 494 kernfs_setattr(v) 495 void *v; 496 { 497 /* 498 * Silently ignore attribute changes. 499 * This allows for open with truncate to have no 500 * effect until some data is written. I want to 501 * do it this way because all writes are atomic. 502 */ 503 return (0); 504 } 505 506 int 507 kernfs_read(v) 508 void *v; 509 { 510 struct vop_read_args /* { 511 struct vnode *a_vp; 512 struct uio *a_uio; 513 int a_ioflag; 514 struct ucred *a_cred; 515 } */ *ap = v; 516 struct vnode *vp = ap->a_vp; 517 struct uio *uio = ap->a_uio; 518 struct kern_target *kt; 519 char strbuf[KSTRING], *buf; 520 int off, len; 521 int error; 522 523 if (vp->v_type == VDIR) 524 return (EOPNOTSUPP); 525 526 kt = VTOKERN(vp)->kf_kt; 527 528 #ifdef KERNFS_DIAGNOSTIC 529 printf("kern_read %s\n", kt->kt_name); 530 #endif 531 532 off = uio->uio_offset; 533 #if 0 534 while (buf = strbuf, 535 #else 536 if (buf = strbuf, 537 #endif 538 len = kernfs_xread(kt, off, &buf, sizeof(strbuf))) { 539 if ((error = uiomove(buf, len, uio)) != 0) 540 return (error); 541 off += len; 542 } 543 return (0); 544 } 545 546 int 547 kernfs_write(v) 548 void *v; 549 { 550 struct vop_write_args /* { 551 struct vnode *a_vp; 552 struct uio *a_uio; 553 int a_ioflag; 554 struct ucred *a_cred; 555 } */ *ap = v; 556 struct vnode *vp = ap->a_vp; 557 struct uio *uio = ap->a_uio; 558 struct kern_target *kt; 559 int error, xlen; 560 char strbuf[KSTRING]; 561 562 if (vp->v_type == VDIR) 563 return (EOPNOTSUPP); 564 565 kt = VTOKERN(vp)->kf_kt; 566 567 if (uio->uio_offset != 0) 568 return (EINVAL); 569 570 xlen = min(uio->uio_resid, KSTRING-1); 571 if ((error = uiomove(strbuf, xlen, uio)) != 0) 572 return (error); 573 574 if (uio->uio_resid != 0) 575 return (EIO); 576 577 strbuf[xlen] = '\0'; 578 xlen = strlen(strbuf); 579 return (kernfs_xwrite(kt, strbuf, xlen)); 580 } 581 582 int 583 kernfs_readdir(v) 584 void *v; 585 { 586 struct vop_readdir_args /* { 587 struct vnode *a_vp; 588 struct uio *a_uio; 589 struct ucred *a_cred; 590 int *a_eofflag; 591 off_t *a_cookies; 592 int a_ncookies; 593 } */ *ap = v; 594 struct uio *uio = ap->a_uio; 595 struct dirent d; 596 struct kern_target *kt; 597 int i; 598 int error; 599 off_t *cookies = ap->a_cookies; 600 int ncookies = ap->a_ncookies; 601 602 if (ap->a_vp->v_type != VDIR) 603 return (ENOTDIR); 604 605 if (uio->uio_resid < UIO_MX) 606 return (EINVAL); 607 if (uio->uio_offset < 0) 608 return (EINVAL); 609 610 error = 0; 611 i = uio->uio_offset; 612 bzero((caddr_t)&d, UIO_MX); 613 d.d_reclen = UIO_MX; 614 615 for (kt = &kern_targets[i]; 616 uio->uio_resid >= UIO_MX && i < nkern_targets; kt++, i++) { 617 #ifdef KERNFS_DIAGNOSTIC 618 printf("kernfs_readdir: i = %d\n", i); 619 #endif 620 621 if (kt->kt_tag == KTT_DEVICE) { 622 dev_t *dp = kt->kt_data; 623 struct vnode *fvp; 624 625 if (*dp == NODEV || !vfinddev(*dp, kt->kt_vtype, &fvp)) 626 continue; 627 } 628 629 d.d_fileno = i + 3; 630 d.d_namlen = kt->kt_namlen; 631 bcopy(kt->kt_name, d.d_name, kt->kt_namlen + 1); 632 d.d_type = kt->kt_type; 633 634 if ((error = uiomove((caddr_t)&d, UIO_MX, uio)) != 0) 635 break; 636 if (ncookies-- > 0) 637 *cookies++ = i + 1; 638 } 639 640 uio->uio_offset = i; 641 return (error); 642 } 643 644 int 645 kernfs_inactive(v) 646 void *v; 647 { 648 struct vop_inactive_args /* { 649 struct vnode *a_vp; 650 } */ *ap = v; 651 struct vnode *vp = ap->a_vp; 652 653 #ifdef KERNFS_DIAGNOSTIC 654 printf("kernfs_inactive(%p)\n", vp); 655 #endif 656 /* 657 * Clear out the v_type field to avoid 658 * nasty things happening in vgone(). 659 */ 660 vp->v_type = VNON; 661 return (0); 662 } 663 664 int 665 kernfs_reclaim(v) 666 void *v; 667 { 668 struct vop_reclaim_args /* { 669 struct vnode *a_vp; 670 } */ *ap = v; 671 struct vnode *vp = ap->a_vp; 672 673 #ifdef KERNFS_DIAGNOSTIC 674 printf("kernfs_reclaim(%p)\n", vp); 675 #endif 676 if (vp->v_data) { 677 FREE(vp->v_data, M_TEMP); 678 vp->v_data = 0; 679 } 680 return (0); 681 } 682 683 /* 684 * Return POSIX pathconf information applicable to special devices. 685 */ 686 int 687 kernfs_pathconf(v) 688 void *v; 689 { 690 struct vop_pathconf_args /* { 691 struct vnode *a_vp; 692 int a_name; 693 register_t *a_retval; 694 } */ *ap = v; 695 696 switch (ap->a_name) { 697 case _PC_LINK_MAX: 698 *ap->a_retval = LINK_MAX; 699 return (0); 700 case _PC_MAX_CANON: 701 *ap->a_retval = MAX_CANON; 702 return (0); 703 case _PC_MAX_INPUT: 704 *ap->a_retval = MAX_INPUT; 705 return (0); 706 case _PC_PIPE_BUF: 707 *ap->a_retval = PIPE_BUF; 708 return (0); 709 case _PC_CHOWN_RESTRICTED: 710 *ap->a_retval = 1; 711 return (0); 712 case _PC_VDISABLE: 713 *ap->a_retval = _POSIX_VDISABLE; 714 return (0); 715 default: 716 return (EINVAL); 717 } 718 /* NOTREACHED */ 719 } 720 721 /* 722 * Print out the contents of a /dev/fd vnode. 723 */ 724 /* ARGSUSED */ 725 int 726 kernfs_print(v) 727 void *v; 728 { 729 730 printf("tag VT_KERNFS, kernfs vnode\n"); 731 return (0); 732 } 733 734 int 735 kernfs_link(v) 736 void *v; 737 { 738 struct vop_link_args /* { 739 struct vnode *a_dvp; 740 struct vnode *a_vp; 741 struct componentname *a_cnp; 742 } */ *ap = v; 743 744 VOP_ABORTOP(ap->a_dvp, ap->a_cnp); 745 vput(ap->a_dvp); 746 return (EROFS); 747 } 748 749 int 750 kernfs_symlink(v) 751 void *v; 752 { 753 struct vop_symlink_args /* { 754 struct vnode *a_dvp; 755 struct vnode **a_vpp; 756 struct componentname *a_cnp; 757 struct vattr *a_vap; 758 char *a_target; 759 } */ *ap = v; 760 761 VOP_ABORTOP(ap->a_dvp, ap->a_cnp); 762 vput(ap->a_dvp); 763 return (EROFS); 764 } 765
Indexes created Wed Oct 01 19:09:53 GMT 2025