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