kernfs_vnops.c revision 1.116.2.1
1 /* $NetBSD: kernfs_vnops.c,v 1.116.2.1 2006/02/05 13:20:21 yamt 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. 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 * @(#)kernfs_vnops.c 8.15 (Berkeley) 5/21/95 35 */ 36 37 /* 38 * Kernel parameter filesystem (/kern) 39 */ 40 41 #include <sys/cdefs.h> 42 __KERNEL_RCSID(0, "$NetBSD: kernfs_vnops.c,v 1.116.2.1 2006/02/05 13:20:21 yamt Exp $"); 43 44 #ifdef _KERNEL_OPT 45 #include "opt_ipsec.h" 46 #endif 47 48 #include <sys/param.h> 49 #include <sys/systm.h> 50 #include <sys/kernel.h> 51 #include <sys/vmmeter.h> 52 #include <sys/time.h> 53 #include <sys/proc.h> 54 #include <sys/vnode.h> 55 #include <sys/malloc.h> 56 #include <sys/file.h> 57 #include <sys/stat.h> 58 #include <sys/mount.h> 59 #include <sys/namei.h> 60 #include <sys/buf.h> 61 #include <sys/dirent.h> 62 #include <sys/msgbuf.h> 63 64 #include <miscfs/genfs/genfs.h> 65 #include <miscfs/kernfs/kernfs.h> 66 67 #ifdef IPSEC 68 #include <sys/mbuf.h> 69 #include <net/route.h> 70 #include <netinet/in.h> 71 #include <netinet6/ipsec.h> 72 #include <netkey/key.h> 73 #endif 74 75 #include <uvm/uvm_extern.h> 76 77 #define KSTRING 256 /* Largest I/O available via this filesystem */ 78 #define UIO_MX 32 79 80 #define READ_MODE (S_IRUSR|S_IRGRP|S_IROTH) 81 #define WRITE_MODE (S_IWUSR|S_IRUSR|S_IRGRP|S_IROTH) 82 #define UREAD_MODE (S_IRUSR) 83 #define DIR_MODE (S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) 84 #define UDIR_MODE (S_IRUSR|S_IXUSR) 85 86 #define N(s) sizeof(s)-1, s 87 const struct kern_target kern_targets[] = { 88 /* NOTE: The name must be less than UIO_MX-16 chars in length */ 89 /* name data tag type ro/rw */ 90 { DT_DIR, N("."), 0, KFSkern, VDIR, DIR_MODE }, 91 { DT_DIR, N(".."), 0, KFSroot, VDIR, DIR_MODE }, 92 { DT_REG, N("boottime"), &boottime.tv_sec, KFSint, VREG, READ_MODE }, 93 /* XXXUNCONST */ 94 { DT_REG, N("copyright"), __UNCONST(copyright), 95 KFSstring, VREG, READ_MODE }, 96 { DT_REG, N("hostname"), 0, KFShostname, VREG, WRITE_MODE }, 97 { DT_REG, N("hz"), &hz, KFSint, VREG, READ_MODE }, 98 #ifdef IPSEC 99 { DT_DIR, N("ipsecsa"), 0, KFSipsecsadir, VDIR, UDIR_MODE }, 100 { DT_DIR, N("ipsecsp"), 0, KFSipsecspdir, VDIR, UDIR_MODE }, 101 #endif 102 { DT_REG, N("loadavg"), 0, KFSavenrun, VREG, READ_MODE }, 103 { DT_REG, N("msgbuf"), 0, KFSmsgbuf, VREG, READ_MODE }, 104 { DT_REG, N("pagesize"), &uvmexp.pagesize, KFSint, VREG, READ_MODE }, 105 { DT_REG, N("physmem"), &physmem, KFSint, VREG, READ_MODE }, 106 #if 0 107 { DT_DIR, N("root"), 0, KFSnull, VDIR, DIR_MODE }, 108 #endif 109 { DT_BLK, N("rootdev"), &rootdev, KFSdevice, VBLK, READ_MODE }, 110 { DT_CHR, N("rrootdev"), &rrootdev, KFSdevice, VCHR, READ_MODE }, 111 { DT_REG, N("time"), 0, KFStime, VREG, READ_MODE }, 112 /* XXXUNCONST */ 113 { DT_REG, N("version"), __UNCONST(version), 114 KFSstring, VREG, READ_MODE }, 115 }; 116 const struct kern_target subdir_targets[] = { 117 /* NOTE: The name must be less than UIO_MX-16 chars in length */ 118 /* name data tag type ro/rw */ 119 { DT_DIR, N("."), 0, KFSsubdir, VDIR, DIR_MODE }, 120 { DT_DIR, N(".."), 0, KFSkern, VDIR, DIR_MODE }, 121 }; 122 #ifdef IPSEC 123 const struct kern_target ipsecsa_targets[] = { 124 /* NOTE: The name must be less than UIO_MX-16 chars in length */ 125 /* name data tag type ro/rw */ 126 { DT_DIR, N("."), 0, KFSipsecsadir, VDIR, DIR_MODE }, 127 { DT_DIR, N(".."), 0, KFSkern, VDIR, DIR_MODE }, 128 }; 129 const struct kern_target ipsecsp_targets[] = { 130 /* NOTE: The name must be less than UIO_MX-16 chars in length */ 131 /* name data tag type ro/rw */ 132 { DT_DIR, N("."), 0, KFSipsecspdir, VDIR, DIR_MODE }, 133 { DT_DIR, N(".."), 0, KFSkern, VDIR, DIR_MODE }, 134 }; 135 const struct kern_target ipsecsa_kt = 136 { DT_DIR, N(""), 0, KFSipsecsa, VREG, UREAD_MODE }; 137 const struct kern_target ipsecsp_kt = 138 { DT_DIR, N(""), 0, KFSipsecsp, VREG, UREAD_MODE }; 139 #endif 140 #undef N 141 SIMPLEQ_HEAD(,dyn_kern_target) dyn_kern_targets = 142 SIMPLEQ_HEAD_INITIALIZER(dyn_kern_targets); 143 int nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]); 144 const int static_nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]); 145 #ifdef IPSEC 146 int nipsecsa_targets = sizeof(ipsecsa_targets) / sizeof(ipsecsa_targets[0]); 147 int nipsecsp_targets = sizeof(ipsecsp_targets) / sizeof(ipsecsp_targets[0]); 148 int nkern_dirs = 4; /* 2 extra subdirs */ 149 #else 150 int nkern_dirs = 2; 151 #endif 152 153 int kernfs_try_fileop(kfstype, kfsfileop, void *, int); 154 int kernfs_try_xwrite(kfstype, const struct kernfs_node *, char *, 155 size_t, int); 156 157 static int kernfs_default_xwrite(void *v); 158 static int kernfs_default_fileop_getattr(void *); 159 160 /* must include all fileop's */ 161 const struct kernfs_fileop kernfs_default_fileops[] = { 162 { .kf_fileop = KERNFS_XWRITE }, 163 { .kf_fileop = KERNFS_FILEOP_OPEN }, 164 { .kf_fileop = KERNFS_FILEOP_GETATTR, 165 .kf_genop = {kernfs_default_fileop_getattr} }, 166 { .kf_fileop = KERNFS_FILEOP_IOCTL }, 167 { .kf_fileop = KERNFS_FILEOP_CLOSE }, 168 { .kf_fileop = KERNFS_FILEOP_WRITE, .kf_genop = {kernfs_default_xwrite} }, 169 }; 170 171 int kernfs_lookup(void *); 172 #define kernfs_create genfs_eopnotsupp 173 #define kernfs_mknod genfs_eopnotsupp 174 int kernfs_open(void *); 175 int kernfs_close(void *); 176 int kernfs_access(void *); 177 int kernfs_getattr(void *); 178 int kernfs_setattr(void *); 179 int kernfs_read(void *); 180 int kernfs_write(void *); 181 #define kernfs_fcntl genfs_fcntl 182 int kernfs_ioctl(void *); 183 #define kernfs_poll genfs_poll 184 #define kernfs_revoke genfs_revoke 185 #define kernfs_fsync genfs_nullop 186 #define kernfs_seek genfs_nullop 187 #define kernfs_remove genfs_eopnotsupp 188 int kernfs_link(void *); 189 #define kernfs_rename genfs_eopnotsupp 190 #define kernfs_mkdir genfs_eopnotsupp 191 #define kernfs_rmdir genfs_eopnotsupp 192 int kernfs_symlink(void *); 193 int kernfs_readdir(void *); 194 #define kernfs_readlink genfs_eopnotsupp 195 #define kernfs_abortop genfs_abortop 196 int kernfs_inactive(void *); 197 int kernfs_reclaim(void *); 198 #define kernfs_lock genfs_lock 199 #define kernfs_unlock genfs_unlock 200 #define kernfs_bmap genfs_badop 201 #define kernfs_strategy genfs_badop 202 int kernfs_print(void *); 203 #define kernfs_islocked genfs_islocked 204 int kernfs_pathconf(void *); 205 #define kernfs_advlock genfs_einval 206 #define kernfs_bwrite genfs_eopnotsupp 207 #define kernfs_putpages genfs_putpages 208 209 static int kernfs_xread(struct kernfs_node *, int, char **, 210 size_t, size_t *); 211 static int kernfs_xwrite(const struct kernfs_node *, char *, size_t); 212 213 int (**kernfs_vnodeop_p)(void *); 214 const struct vnodeopv_entry_desc kernfs_vnodeop_entries[] = { 215 { &vop_default_desc, vn_default_error }, 216 { &vop_lookup_desc, kernfs_lookup }, /* lookup */ 217 { &vop_create_desc, kernfs_create }, /* create */ 218 { &vop_mknod_desc, kernfs_mknod }, /* mknod */ 219 { &vop_open_desc, kernfs_open }, /* open */ 220 { &vop_close_desc, kernfs_close }, /* close */ 221 { &vop_access_desc, kernfs_access }, /* access */ 222 { &vop_getattr_desc, kernfs_getattr }, /* getattr */ 223 { &vop_setattr_desc, kernfs_setattr }, /* setattr */ 224 { &vop_read_desc, kernfs_read }, /* read */ 225 { &vop_write_desc, kernfs_write }, /* write */ 226 { &vop_fcntl_desc, kernfs_fcntl }, /* fcntl */ 227 { &vop_ioctl_desc, kernfs_ioctl }, /* ioctl */ 228 { &vop_poll_desc, kernfs_poll }, /* poll */ 229 { &vop_revoke_desc, kernfs_revoke }, /* revoke */ 230 { &vop_fsync_desc, kernfs_fsync }, /* fsync */ 231 { &vop_seek_desc, kernfs_seek }, /* seek */ 232 { &vop_remove_desc, kernfs_remove }, /* remove */ 233 { &vop_link_desc, kernfs_link }, /* link */ 234 { &vop_rename_desc, kernfs_rename }, /* rename */ 235 { &vop_mkdir_desc, kernfs_mkdir }, /* mkdir */ 236 { &vop_rmdir_desc, kernfs_rmdir }, /* rmdir */ 237 { &vop_symlink_desc, kernfs_symlink }, /* symlink */ 238 { &vop_readdir_desc, kernfs_readdir }, /* readdir */ 239 { &vop_readlink_desc, kernfs_readlink }, /* readlink */ 240 { &vop_abortop_desc, kernfs_abortop }, /* abortop */ 241 { &vop_inactive_desc, kernfs_inactive }, /* inactive */ 242 { &vop_reclaim_desc, kernfs_reclaim }, /* reclaim */ 243 { &vop_lock_desc, kernfs_lock }, /* lock */ 244 { &vop_unlock_desc, kernfs_unlock }, /* unlock */ 245 { &vop_bmap_desc, kernfs_bmap }, /* bmap */ 246 { &vop_strategy_desc, kernfs_strategy }, /* strategy */ 247 { &vop_print_desc, kernfs_print }, /* print */ 248 { &vop_islocked_desc, kernfs_islocked }, /* islocked */ 249 { &vop_pathconf_desc, kernfs_pathconf }, /* pathconf */ 250 { &vop_advlock_desc, kernfs_advlock }, /* advlock */ 251 { &vop_bwrite_desc, kernfs_bwrite }, /* bwrite */ 252 { &vop_putpages_desc, kernfs_putpages }, /* putpages */ 253 { NULL, NULL } 254 }; 255 const struct vnodeopv_desc kernfs_vnodeop_opv_desc = 256 { &kernfs_vnodeop_p, kernfs_vnodeop_entries }; 257 258 static inline int 259 kernfs_fileop_compare(struct kernfs_fileop *a, struct kernfs_fileop *b) 260 { 261 if (a->kf_type < b->kf_type) 262 return -1; 263 if (a->kf_type > b->kf_type) 264 return 1; 265 if (a->kf_fileop < b->kf_fileop) 266 return -1; 267 if (a->kf_fileop > b->kf_fileop) 268 return 1; 269 return (0); 270 } 271 272 SPLAY_HEAD(kfsfileoptree, kernfs_fileop) kfsfileoptree = 273 SPLAY_INITIALIZER(kfsfileoptree); 274 SPLAY_PROTOTYPE(kfsfileoptree, kernfs_fileop, kf_node, kernfs_fileop_compare); 275 SPLAY_GENERATE(kfsfileoptree, kernfs_fileop, kf_node, kernfs_fileop_compare); 276 277 kfstype 278 kernfs_alloctype(int nkf, const struct kernfs_fileop *kf) 279 { 280 static u_char nextfreetype = KFSlasttype; 281 struct kernfs_fileop *dkf, *fkf, skf; 282 int i; 283 284 /* XXX need to keep track of dkf's memory if we support 285 deallocating types */ 286 dkf = malloc(sizeof(kernfs_default_fileops), M_TEMP, M_WAITOK); 287 memcpy(dkf, kernfs_default_fileops, sizeof(kernfs_default_fileops)); 288 289 for (i = 0; i < sizeof(kernfs_default_fileops) / 290 sizeof(kernfs_default_fileops[0]); i++) { 291 dkf[i].kf_type = nextfreetype; 292 SPLAY_INSERT(kfsfileoptree, &kfsfileoptree, &dkf[i]); 293 } 294 295 for (i = 0; i < nkf; i++) { 296 skf.kf_type = nextfreetype; 297 skf.kf_fileop = kf[i].kf_fileop; 298 if ((fkf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf))) 299 fkf->kf_genop = kf[i].kf_genop; 300 } 301 302 return nextfreetype++; 303 } 304 305 int 306 kernfs_try_fileop(kfstype type, kfsfileop fileop, void *v, int error) 307 { 308 struct kernfs_fileop *kf, skf; 309 310 skf.kf_type = type; 311 skf.kf_fileop = fileop; 312 if ((kf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf))) 313 if (kf->kf_vop) 314 return kf->kf_vop(v); 315 return error; 316 } 317 318 int 319 kernfs_try_xwrite(kfstype type, const struct kernfs_node *kfs, char *bf, 320 size_t len, int error) 321 { 322 struct kernfs_fileop *kf, skf; 323 324 skf.kf_type = type; 325 skf.kf_fileop = KERNFS_XWRITE; 326 if ((kf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf))) 327 if (kf->kf_xwrite) 328 return kf->kf_xwrite(kfs, bf, len); 329 return error; 330 } 331 332 int 333 kernfs_addentry(kernfs_parentdir_t *pkt, kernfs_entry_t *dkt) 334 { 335 struct kernfs_subdir *ks, *parent; 336 337 if (pkt == NULL) { 338 SIMPLEQ_INSERT_TAIL(&dyn_kern_targets, dkt, dkt_queue); 339 nkern_targets++; 340 if (dkt->dkt_kt.kt_vtype == VDIR) 341 nkern_dirs++; 342 } else { 343 parent = (struct kernfs_subdir *)pkt->kt_data; 344 SIMPLEQ_INSERT_TAIL(&parent->ks_entries, dkt, dkt_queue); 345 parent->ks_nentries++; 346 if (dkt->dkt_kt.kt_vtype == VDIR) 347 parent->ks_dirs++; 348 } 349 if (dkt->dkt_kt.kt_vtype == VDIR && dkt->dkt_kt.kt_data == NULL) { 350 ks = malloc(sizeof(struct kernfs_subdir), 351 M_TEMP, M_WAITOK); 352 SIMPLEQ_INIT(&ks->ks_entries); 353 ks->ks_nentries = 2; /* . and .. */ 354 ks->ks_dirs = 2; 355 ks->ks_parent = pkt ? pkt : &kern_targets[0]; 356 dkt->dkt_kt.kt_data = ks; 357 } 358 return 0; 359 } 360 361 static int 362 kernfs_xread(kfs, off, bufp, len, wrlen) 363 struct kernfs_node *kfs; 364 int off; 365 char **bufp; 366 size_t len; 367 size_t *wrlen; 368 { 369 const struct kern_target *kt; 370 #ifdef IPSEC 371 struct mbuf *m; 372 #endif 373 374 kt = kfs->kfs_kt; 375 376 switch (kfs->kfs_type) { 377 case KFStime: { 378 struct timeval tv; 379 380 microtime(&tv); 381 snprintf(*bufp, len, "%ld %ld\n", tv.tv_sec, tv.tv_usec); 382 break; 383 } 384 385 case KFSint: { 386 int *ip = kt->kt_data; 387 388 snprintf(*bufp, len, "%d\n", *ip); 389 break; 390 } 391 392 case KFSstring: { 393 char *cp = kt->kt_data; 394 395 *bufp = cp; 396 break; 397 } 398 399 case KFSmsgbuf: { 400 long n; 401 402 /* 403 * deal with cases where the message buffer has 404 * become corrupted. 405 */ 406 if (!msgbufenabled || msgbufp->msg_magic != MSG_MAGIC) { 407 msgbufenabled = 0; 408 return (ENXIO); 409 } 410 411 /* 412 * Note that reads of /kern/msgbuf won't necessarily yield 413 * consistent results, if the message buffer is modified 414 * while the read is in progress. The worst that can happen 415 * is that incorrect data will be read. There's no way 416 * that this can crash the system unless the values in the 417 * message buffer header are corrupted, but that'll cause 418 * the system to die anyway. 419 */ 420 if (off >= msgbufp->msg_bufs) { 421 *wrlen = 0; 422 return (0); 423 } 424 n = msgbufp->msg_bufx + off; 425 if (n >= msgbufp->msg_bufs) 426 n -= msgbufp->msg_bufs; 427 len = min(msgbufp->msg_bufs - n, msgbufp->msg_bufs - off); 428 *bufp = msgbufp->msg_bufc + n; 429 *wrlen = len; 430 return (0); 431 } 432 433 case KFShostname: { 434 char *cp = hostname; 435 int xlen = hostnamelen; 436 437 if (xlen >= (len - 2)) 438 return (EINVAL); 439 440 memcpy(*bufp, cp, xlen); 441 (*bufp)[xlen] = '\n'; 442 (*bufp)[xlen+1] = '\0'; 443 len = strlen(*bufp); 444 break; 445 } 446 447 case KFSavenrun: 448 averunnable.fscale = FSCALE; 449 snprintf(*bufp, len, "%d %d %d %ld\n", 450 averunnable.ldavg[0], averunnable.ldavg[1], 451 averunnable.ldavg[2], averunnable.fscale); 452 break; 453 454 #ifdef IPSEC 455 case KFSipsecsa: 456 /* 457 * Note that SA configuration could be changed during the 458 * read operation, resulting in garbled output. 459 */ 460 m = key_setdumpsa_spi(htonl(kfs->kfs_value)); 461 if (!m) 462 return (ENOBUFS); 463 if (off >= m->m_pkthdr.len) { 464 *wrlen = 0; 465 m_freem(m); 466 return (0); 467 } 468 if (len > m->m_pkthdr.len - off) 469 len = m->m_pkthdr.len - off; 470 m_copydata(m, off, len, *bufp); 471 *wrlen = len; 472 m_freem(m); 473 return (0); 474 475 case KFSipsecsp: 476 /* 477 * Note that SP configuration could be changed during the 478 * read operation, resulting in garbled output. 479 */ 480 if (!kfs->kfs_v) { 481 struct secpolicy *sp; 482 483 sp = key_getspbyid(kfs->kfs_value); 484 if (sp) 485 kfs->kfs_v = sp; 486 else 487 return (ENOENT); 488 } 489 m = key_setdumpsp((struct secpolicy *)kfs->kfs_v, 490 SADB_X_SPDGET, 0, 0); 491 if (!m) 492 return (ENOBUFS); 493 if (off >= m->m_pkthdr.len) { 494 *wrlen = 0; 495 m_freem(m); 496 return (0); 497 } 498 if (len > m->m_pkthdr.len - off) 499 len = m->m_pkthdr.len - off; 500 m_copydata(m, off, len, *bufp); 501 *wrlen = len; 502 m_freem(m); 503 return (0); 504 #endif 505 506 default: 507 *wrlen = 0; 508 return (0); 509 } 510 511 len = strlen(*bufp); 512 if (len <= off) 513 *wrlen = 0; 514 else { 515 *bufp += off; 516 *wrlen = len - off; 517 } 518 return (0); 519 } 520 521 static int 522 kernfs_xwrite(kfs, bf, len) 523 const struct kernfs_node *kfs; 524 char *bf; 525 size_t len; 526 { 527 528 switch (kfs->kfs_type) { 529 case KFShostname: 530 if (bf[len-1] == '\n') 531 --len; 532 memcpy(hostname, bf, len); 533 hostname[len] = '\0'; 534 hostnamelen = (size_t) len; 535 return (0); 536 537 default: 538 return kernfs_try_xwrite(kfs->kfs_type, kfs, bf, len, EIO); 539 } 540 } 541 542 543 /* 544 * vp is the current namei directory 545 * ndp is the name to locate in that directory... 546 */ 547 int 548 kernfs_lookup(v) 549 void *v; 550 { 551 struct vop_lookup_args /* { 552 struct vnode * a_dvp; 553 struct vnode ** a_vpp; 554 struct componentname * a_cnp; 555 } */ *ap = v; 556 struct componentname *cnp = ap->a_cnp; 557 struct vnode **vpp = ap->a_vpp; 558 struct vnode *dvp = ap->a_dvp; 559 const char *pname = cnp->cn_nameptr; 560 const struct kernfs_node *kfs; 561 const struct kern_target *kt; 562 const struct dyn_kern_target *dkt; 563 const struct kernfs_subdir *ks; 564 int error, i, wantpunlock; 565 #ifdef IPSEC 566 char *ep; 567 u_int32_t id; 568 #endif 569 570 *vpp = NULLVP; 571 cnp->cn_flags &= ~PDIRUNLOCK; 572 573 if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME) 574 return (EROFS); 575 576 if (cnp->cn_namelen == 1 && *pname == '.') { 577 *vpp = dvp; 578 VREF(dvp); 579 return (0); 580 } 581 582 wantpunlock = (~cnp->cn_flags & (LOCKPARENT | ISLASTCN)); 583 kfs = VTOKERN(dvp); 584 switch (kfs->kfs_type) { 585 case KFSkern: 586 /* 587 * Shouldn't get here with .. in the root node. 588 */ 589 if (cnp->cn_flags & ISDOTDOT) 590 return (EIO); 591 592 for (i = 0; i < static_nkern_targets; i++) { 593 kt = &kern_targets[i]; 594 if (cnp->cn_namelen == kt->kt_namlen && 595 memcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) 596 goto found; 597 } 598 SIMPLEQ_FOREACH(dkt, &dyn_kern_targets, dkt_queue) { 599 if (cnp->cn_namelen == dkt->dkt_kt.kt_namlen && 600 memcmp(dkt->dkt_kt.kt_name, pname, cnp->cn_namelen) == 0) { 601 kt = &dkt->dkt_kt; 602 goto found; 603 } 604 } 605 break; 606 607 found: 608 error = kernfs_allocvp(dvp->v_mount, vpp, kt->kt_tag, kt, 0); 609 if ((error == 0) && wantpunlock) { 610 VOP_UNLOCK(dvp, 0); 611 cnp->cn_flags |= PDIRUNLOCK; 612 } 613 return (error); 614 615 case KFSsubdir: 616 ks = (struct kernfs_subdir *)kfs->kfs_kt->kt_data; 617 if (cnp->cn_flags & ISDOTDOT) { 618 kt = ks->ks_parent; 619 goto found; 620 } 621 622 SIMPLEQ_FOREACH(dkt, &ks->ks_entries, dkt_queue) { 623 if (cnp->cn_namelen == dkt->dkt_kt.kt_namlen && 624 memcmp(dkt->dkt_kt.kt_name, pname, cnp->cn_namelen) == 0) { 625 kt = &dkt->dkt_kt; 626 goto found; 627 } 628 } 629 break; 630 631 #ifdef IPSEC 632 case KFSipsecsadir: 633 if (cnp->cn_flags & ISDOTDOT) { 634 kt = &kern_targets[0]; 635 goto found; 636 } 637 638 for (i = 2; i < nipsecsa_targets; i++) { 639 kt = &ipsecsa_targets[i]; 640 if (cnp->cn_namelen == kt->kt_namlen && 641 memcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) 642 goto found; 643 } 644 645 ep = NULL; 646 id = strtoul(pname, &ep, 10); 647 if (!ep || *ep || ep == pname) 648 break; 649 650 error = kernfs_allocvp(dvp->v_mount, vpp, KFSipsecsa, &ipsecsa_kt, id); 651 if ((error == 0) && wantpunlock) { 652 VOP_UNLOCK(dvp, 0); 653 cnp->cn_flags |= PDIRUNLOCK; 654 } 655 return (error); 656 657 case KFSipsecspdir: 658 if (cnp->cn_flags & ISDOTDOT) { 659 kt = &kern_targets[0]; 660 goto found; 661 } 662 663 for (i = 2; i < nipsecsp_targets; i++) { 664 kt = &ipsecsp_targets[i]; 665 if (cnp->cn_namelen == kt->kt_namlen && 666 memcmp(kt->kt_name, pname, cnp->cn_namelen) == 0) 667 goto found; 668 } 669 670 ep = NULL; 671 id = strtoul(pname, &ep, 10); 672 if (!ep || *ep || ep == pname) 673 break; 674 675 error = kernfs_allocvp(dvp->v_mount, vpp, KFSipsecsp, &ipsecsp_kt, id); 676 if ((error == 0) && wantpunlock) { 677 VOP_UNLOCK(dvp, 0); 678 cnp->cn_flags |= PDIRUNLOCK; 679 } 680 return (error); 681 #endif 682 683 default: 684 return (ENOTDIR); 685 } 686 687 return (cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS); 688 } 689 690 int 691 kernfs_open(v) 692 void *v; 693 { 694 struct vop_open_args /* { 695 struct vnode *a_vp; 696 int a_mode; 697 struct ucred *a_cred; 698 struct lwp *a_l; 699 } */ *ap = v; 700 struct kernfs_node *kfs = VTOKERN(ap->a_vp); 701 #ifdef IPSEC 702 struct mbuf *m; 703 struct secpolicy *sp; 704 #endif 705 706 switch (kfs->kfs_type) { 707 #ifdef IPSEC 708 case KFSipsecsa: 709 m = key_setdumpsa_spi(htonl(kfs->kfs_value)); 710 if (m) { 711 m_freem(m); 712 return (0); 713 } else 714 return (ENOENT); 715 716 case KFSipsecsp: 717 sp = key_getspbyid(kfs->kfs_value); 718 if (sp) { 719 kfs->kfs_v = sp; 720 return (0); 721 } else 722 return (ENOENT); 723 #endif 724 725 default: 726 return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_OPEN, 727 v, 0); 728 } 729 } 730 731 int 732 kernfs_close(v) 733 void *v; 734 { 735 struct vop_close_args /* { 736 struct vnode *a_vp; 737 int a_fflag; 738 struct ucred *a_cred; 739 struct lwp *a_l; 740 } */ *ap = v; 741 struct kernfs_node *kfs = VTOKERN(ap->a_vp); 742 743 switch (kfs->kfs_type) { 744 #ifdef IPSEC 745 case KFSipsecsp: 746 key_freesp((struct secpolicy *)kfs->kfs_v); 747 break; 748 #endif 749 750 default: 751 return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_CLOSE, 752 v, 0); 753 } 754 755 return (0); 756 } 757 758 int 759 kernfs_access(v) 760 void *v; 761 { 762 struct vop_access_args /* { 763 struct vnode *a_vp; 764 int a_mode; 765 struct ucred *a_cred; 766 struct lwp *a_l; 767 } */ *ap = v; 768 struct vattr va; 769 int error; 770 771 if ((error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred, ap->a_l)) != 0) 772 return (error); 773 774 return (vaccess(va.va_type, va.va_mode, va.va_uid, va.va_gid, 775 ap->a_mode, ap->a_cred)); 776 } 777 778 static int 779 kernfs_default_fileop_getattr(v) 780 void *v; 781 { 782 struct vop_getattr_args /* { 783 struct vnode *a_vp; 784 struct vattr *a_vap; 785 struct ucred *a_cred; 786 struct lwp *a_l; 787 } */ *ap = v; 788 struct vattr *vap = ap->a_vap; 789 790 vap->va_nlink = 1; 791 vap->va_bytes = vap->va_size = 0; 792 793 return 0; 794 } 795 796 int 797 kernfs_getattr(v) 798 void *v; 799 { 800 struct vop_getattr_args /* { 801 struct vnode *a_vp; 802 struct vattr *a_vap; 803 struct ucred *a_cred; 804 struct lwp *a_l; 805 } */ *ap = v; 806 struct kernfs_node *kfs = VTOKERN(ap->a_vp); 807 struct kernfs_subdir *ks; 808 struct vattr *vap = ap->a_vap; 809 int error = 0; 810 char strbuf[KSTRING], *bf; 811 size_t nread, total; 812 813 VATTR_NULL(vap); 814 vap->va_type = ap->a_vp->v_type; 815 vap->va_uid = 0; 816 vap->va_gid = 0; 817 vap->va_mode = kfs->kfs_mode; 818 vap->va_fileid = kfs->kfs_fileno; 819 vap->va_flags = 0; 820 vap->va_size = 0; 821 vap->va_blocksize = DEV_BSIZE; 822 /* 823 * Make all times be current TOD, except for the "boottime" node. 824 * Avoid microtime(9), it's slow. 825 * We don't guard the read from time(9) with splclock(9) since we 826 * don't actually need to be THAT sure the access is atomic. 827 */ 828 if (kfs->kfs_kt && kfs->kfs_kt->kt_namlen == 8 && 829 !memcmp(kfs->kfs_kt->kt_name, "boottime", 8)) { 830 TIMEVAL_TO_TIMESPEC(&boottime, &vap->va_ctime); 831 } else { 832 TIMEVAL_TO_TIMESPEC(&time, &vap->va_ctime); 833 } 834 vap->va_atime = vap->va_mtime = vap->va_ctime; 835 vap->va_gen = 0; 836 vap->va_flags = 0; 837 vap->va_rdev = 0; 838 vap->va_bytes = 0; 839 840 switch (kfs->kfs_type) { 841 case KFSkern: 842 vap->va_nlink = nkern_dirs; 843 vap->va_bytes = vap->va_size = DEV_BSIZE; 844 break; 845 846 case KFSroot: 847 vap->va_nlink = 1; 848 vap->va_bytes = vap->va_size = DEV_BSIZE; 849 break; 850 851 case KFSsubdir: 852 ks = (struct kernfs_subdir *)kfs->kfs_kt->kt_data; 853 vap->va_nlink = ks->ks_dirs; 854 vap->va_bytes = vap->va_size = DEV_BSIZE; 855 break; 856 857 case KFSnull: 858 case KFStime: 859 case KFSint: 860 case KFSstring: 861 case KFShostname: 862 case KFSavenrun: 863 case KFSdevice: 864 case KFSmsgbuf: 865 #ifdef IPSEC 866 case KFSipsecsa: 867 case KFSipsecsp: 868 #endif 869 vap->va_nlink = 1; 870 total = 0; 871 do { 872 bf = strbuf; 873 error = kernfs_xread(kfs, total, &bf, 874 sizeof(strbuf), &nread); 875 total += nread; 876 } while (error == 0 && nread != 0); 877 vap->va_bytes = vap->va_size = total; 878 break; 879 880 #ifdef IPSEC 881 case KFSipsecsadir: 882 case KFSipsecspdir: 883 vap->va_nlink = 2; 884 vap->va_bytes = vap->va_size = DEV_BSIZE; 885 break; 886 #endif 887 888 default: 889 error = kernfs_try_fileop(kfs->kfs_type, 890 KERNFS_FILEOP_GETATTR, v, EINVAL); 891 break; 892 } 893 894 return (error); 895 } 896 897 /*ARGSUSED*/ 898 int 899 kernfs_setattr(v) 900 void *v; 901 { 902 903 /* 904 * Silently ignore attribute changes. 905 * This allows for open with truncate to have no 906 * effect until some data is written. I want to 907 * do it this way because all writes are atomic. 908 */ 909 return (0); 910 } 911 912 int 913 kernfs_read(v) 914 void *v; 915 { 916 struct vop_read_args /* { 917 struct vnode *a_vp; 918 struct uio *a_uio; 919 int a_ioflag; 920 struct ucred *a_cred; 921 } */ *ap = v; 922 struct uio *uio = ap->a_uio; 923 struct kernfs_node *kfs = VTOKERN(ap->a_vp); 924 char strbuf[KSTRING], *bf; 925 int off; 926 size_t len; 927 int error; 928 929 if (ap->a_vp->v_type == VDIR) 930 return (EOPNOTSUPP); 931 932 off = (int)uio->uio_offset; 933 /* Don't allow negative offsets */ 934 if (off < 0) 935 return EINVAL; 936 937 bf = strbuf; 938 if ((error = kernfs_xread(kfs, off, &bf, sizeof(strbuf), &len)) == 0) 939 error = uiomove(bf, len, uio); 940 return (error); 941 } 942 943 static int 944 kernfs_default_xwrite(v) 945 void *v; 946 { 947 struct vop_write_args /* { 948 struct vnode *a_vp; 949 struct uio *a_uio; 950 int a_ioflag; 951 struct ucred *a_cred; 952 } */ *ap = v; 953 struct kernfs_node *kfs = VTOKERN(ap->a_vp); 954 struct uio *uio = ap->a_uio; 955 int error, xlen; 956 char strbuf[KSTRING]; 957 958 if (uio->uio_offset != 0) 959 return (EINVAL); 960 961 xlen = min(uio->uio_resid, KSTRING-1); 962 if ((error = uiomove(strbuf, xlen, uio)) != 0) 963 return (error); 964 965 if (uio->uio_resid != 0) 966 return (EIO); 967 968 strbuf[xlen] = '\0'; 969 xlen = strlen(strbuf); 970 return (kernfs_xwrite(kfs, strbuf, xlen)); 971 } 972 973 int 974 kernfs_write(v) 975 void *v; 976 { 977 struct vop_write_args /* { 978 struct vnode *a_vp; 979 struct uio *a_uio; 980 int a_ioflag; 981 struct ucred *a_cred; 982 } */ *ap = v; 983 struct kernfs_node *kfs = VTOKERN(ap->a_vp); 984 985 return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_WRITE, v, 0); 986 } 987 988 int 989 kernfs_ioctl(v) 990 void *v; 991 { 992 struct vop_ioctl_args /* { 993 const struct vnodeop_desc *a_desc; 994 struct vnode *a_vp; 995 u_long a_command; 996 void *a_data; 997 int a_fflag; 998 struct ucred *a_cred; 999 struct lwp *a_l; 1000 } */ *ap = v; 1001 struct kernfs_node *kfs = VTOKERN(ap->a_vp); 1002 1003 return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_IOCTL, v, 1004 EPASSTHROUGH); 1005 } 1006 1007 static int 1008 kernfs_setdirentfileno_kt(struct dirent *d, const struct kern_target *kt, 1009 u_int32_t value, struct vop_readdir_args *ap) 1010 { 1011 struct kernfs_node *kfs; 1012 struct vnode *vp; 1013 int error; 1014 1015 if ((error = kernfs_allocvp(ap->a_vp->v_mount, &vp, kt->kt_tag, kt, 1016 value)) != 0) 1017 return error; 1018 if (kt->kt_tag == KFSdevice) { 1019 struct vattr va; 1020 1021 error = VOP_GETATTR(vp, &va, ap->a_cred, curlwp); 1022 if (error != 0) { 1023 return error; 1024 } 1025 d->d_fileno = va.va_fileid; 1026 } else { 1027 kfs = VTOKERN(vp); 1028 d->d_fileno = kfs->kfs_fileno; 1029 } 1030 vput(vp); 1031 return 0; 1032 } 1033 1034 static int 1035 kernfs_setdirentfileno(struct dirent *d, off_t entry, 1036 struct kernfs_node *thisdir_kfs, const struct kern_target *parent_kt, 1037 const struct kern_target *kt, struct vop_readdir_args *ap) 1038 { 1039 const struct kern_target *ikt; 1040 int error; 1041 1042 switch (entry) { 1043 case 0: 1044 d->d_fileno = thisdir_kfs->kfs_fileno; 1045 return 0; 1046 case 1: 1047 ikt = parent_kt; 1048 break; 1049 default: 1050 ikt = kt; 1051 break; 1052 } 1053 if (ikt != thisdir_kfs->kfs_kt) { 1054 if ((error = kernfs_setdirentfileno_kt(d, ikt, 0, ap)) != 0) 1055 return error; 1056 } else 1057 d->d_fileno = thisdir_kfs->kfs_fileno; 1058 return 0; 1059 } 1060 1061 int 1062 kernfs_readdir(v) 1063 void *v; 1064 { 1065 struct vop_readdir_args /* { 1066 struct vnode *a_vp; 1067 struct uio *a_uio; 1068 struct ucred *a_cred; 1069 int *a_eofflag; 1070 off_t **a_cookies; 1071 int a_*ncookies; 1072 } */ *ap = v; 1073 struct uio *uio = ap->a_uio; 1074 struct dirent d; 1075 struct kernfs_node *kfs = VTOKERN(ap->a_vp); 1076 const struct kern_target *kt; 1077 const struct dyn_kern_target *dkt = NULL; 1078 const struct kernfs_subdir *ks; 1079 off_t i, j; 1080 int error; 1081 off_t *cookies = NULL; 1082 int ncookies = 0, n; 1083 #ifdef IPSEC 1084 struct secasvar *sav, *sav2; 1085 struct secpolicy *sp; 1086 #endif 1087 1088 if (uio->uio_resid < UIO_MX) 1089 return (EINVAL); 1090 if (uio->uio_offset < 0) 1091 return (EINVAL); 1092 1093 error = 0; 1094 i = uio->uio_offset; 1095 memset(&d, 0, sizeof(d)); 1096 d.d_reclen = UIO_MX; 1097 ncookies = uio->uio_resid / UIO_MX; 1098 1099 switch (kfs->kfs_type) { 1100 case KFSkern: 1101 if (i >= nkern_targets) 1102 return (0); 1103 1104 if (ap->a_ncookies) { 1105 ncookies = min(ncookies, (nkern_targets - i)); 1106 cookies = malloc(ncookies * sizeof(off_t), M_TEMP, 1107 M_WAITOK); 1108 *ap->a_cookies = cookies; 1109 } 1110 1111 n = 0; 1112 for (; i < nkern_targets && uio->uio_resid >= UIO_MX; i++) { 1113 if (i < static_nkern_targets) 1114 kt = &kern_targets[i]; 1115 else { 1116 if (dkt == NULL) { 1117 dkt = SIMPLEQ_FIRST(&dyn_kern_targets); 1118 for (j = static_nkern_targets; j < i && 1119 dkt != NULL; j++) 1120 dkt = SIMPLEQ_NEXT(dkt, dkt_queue); 1121 if (j != i) 1122 break; 1123 } else { 1124 dkt = SIMPLEQ_NEXT(dkt, dkt_queue); 1125 if (dkt == NULL) 1126 break; 1127 } 1128 kt = &dkt->dkt_kt; 1129 } 1130 if (kt->kt_tag == KFSdevice) { 1131 dev_t *dp = kt->kt_data; 1132 struct vnode *fvp; 1133 1134 if (*dp == NODEV || 1135 !vfinddev(*dp, kt->kt_vtype, &fvp)) 1136 continue; 1137 } 1138 d.d_namlen = kt->kt_namlen; 1139 if ((error = kernfs_setdirentfileno(&d, i, kfs, 1140 &kern_targets[0], kt, ap)) != 0) 1141 break; 1142 memcpy(d.d_name, kt->kt_name, kt->kt_namlen + 1); 1143 d.d_type = kt->kt_type; 1144 if ((error = uiomove(&d, UIO_MX, uio)) != 0) 1145 break; 1146 if (cookies) 1147 *cookies++ = i + 1; 1148 n++; 1149 } 1150 ncookies = n; 1151 break; 1152 1153 case KFSroot: 1154 if (i >= 2) 1155 return 0; 1156 1157 if (ap->a_ncookies) { 1158 ncookies = min(ncookies, (2 - i)); 1159 cookies = malloc(ncookies * sizeof(off_t), M_TEMP, 1160 M_WAITOK); 1161 *ap->a_cookies = cookies; 1162 } 1163 1164 n = 0; 1165 for (; i < 2 && uio->uio_resid >= UIO_MX; i++) { 1166 kt = &kern_targets[i]; 1167 d.d_namlen = kt->kt_namlen; 1168 d.d_fileno = KERNFS_FILENO(kt, kt->kt_tag, 0); 1169 memcpy(d.d_name, kt->kt_name, kt->kt_namlen + 1); 1170 d.d_type = kt->kt_type; 1171 if ((error = uiomove(&d, UIO_MX, uio)) != 0) 1172 break; 1173 if (cookies) 1174 *cookies++ = i + 1; 1175 n++; 1176 } 1177 ncookies = n; 1178 break; 1179 1180 case KFSsubdir: 1181 ks = (struct kernfs_subdir *)kfs->kfs_kt->kt_data; 1182 if (i >= ks->ks_nentries) 1183 return (0); 1184 1185 if (ap->a_ncookies) { 1186 ncookies = min(ncookies, (ks->ks_nentries - i)); 1187 cookies = malloc(ncookies * sizeof(off_t), M_TEMP, 1188 M_WAITOK); 1189 *ap->a_cookies = cookies; 1190 } 1191 1192 dkt = SIMPLEQ_FIRST(&ks->ks_entries); 1193 for (j = 0; j < i && dkt != NULL; j++) 1194 dkt = SIMPLEQ_NEXT(dkt, dkt_queue); 1195 n = 0; 1196 for (; i < ks->ks_nentries && uio->uio_resid >= UIO_MX; i++) { 1197 if (i < 2) 1198 kt = &subdir_targets[i]; 1199 else { 1200 /* check if ks_nentries lied to us */ 1201 if (dkt == NULL) 1202 break; 1203 kt = &dkt->dkt_kt; 1204 dkt = SIMPLEQ_NEXT(dkt, dkt_queue); 1205 } 1206 if (kt->kt_tag == KFSdevice) { 1207 dev_t *dp = kt->kt_data; 1208 struct vnode *fvp; 1209 1210 if (*dp == NODEV || 1211 !vfinddev(*dp, kt->kt_vtype, &fvp)) 1212 continue; 1213 } 1214 d.d_namlen = kt->kt_namlen; 1215 if ((error = kernfs_setdirentfileno(&d, i, kfs, 1216 ks->ks_parent, kt, ap)) != 0) 1217 break; 1218 memcpy(d.d_name, kt->kt_name, kt->kt_namlen + 1); 1219 d.d_type = kt->kt_type; 1220 if ((error = uiomove(&d, UIO_MX, uio)) != 0) 1221 break; 1222 if (cookies) 1223 *cookies++ = i + 1; 1224 n++; 1225 } 1226 ncookies = n; 1227 break; 1228 1229 #ifdef IPSEC 1230 case KFSipsecsadir: 1231 /* count SA in the system */ 1232 n = 0; 1233 TAILQ_FOREACH(sav, &satailq, tailq) { 1234 for (sav2 = TAILQ_FIRST(&satailq); 1235 sav2 != sav; 1236 sav2 = TAILQ_NEXT(sav2, tailq)) { 1237 if (sav->spi == sav2->spi) { 1238 /* multiple SA with same SPI */ 1239 break; 1240 } 1241 } 1242 if (sav == sav2 || sav->spi != sav2->spi) 1243 n++; 1244 } 1245 1246 if (i >= nipsecsa_targets + n) 1247 return (0); 1248 1249 if (ap->a_ncookies) { 1250 ncookies = min(ncookies, (n - i)); 1251 cookies = malloc(ncookies * sizeof(off_t), M_TEMP, 1252 M_WAITOK); 1253 *ap->a_cookies = cookies; 1254 } 1255 1256 n = 0; 1257 for (; i < nipsecsa_targets && uio->uio_resid >= UIO_MX; i++) { 1258 kt = &ipsecsa_targets[i]; 1259 d.d_namlen = kt->kt_namlen; 1260 if ((error = kernfs_setdirentfileno(&d, i, kfs, 1261 &kern_targets[0], kt, ap)) != 0) 1262 break; 1263 memcpy(d.d_name, kt->kt_name, kt->kt_namlen + 1); 1264 d.d_type = kt->kt_type; 1265 if ((error = uiomove(&d, UIO_MX, uio)) != 0) 1266 break; 1267 if (cookies) 1268 *cookies++ = i + 1; 1269 n++; 1270 } 1271 if (error) { 1272 ncookies = n; 1273 break; 1274 } 1275 1276 TAILQ_FOREACH(sav, &satailq, tailq) { 1277 for (sav2 = TAILQ_FIRST(&satailq); 1278 sav2 != sav; 1279 sav2 = TAILQ_NEXT(sav2, tailq)) { 1280 if (sav->spi == sav2->spi) { 1281 /* multiple SA with same SPI */ 1282 break; 1283 } 1284 } 1285 if (sav != sav2 && sav->spi == sav2->spi) 1286 continue; 1287 if (uio->uio_resid < UIO_MX) 1288 break; 1289 if ((error = kernfs_setdirentfileno_kt(&d, &ipsecsa_kt, 1290 sav->spi, ap)) != 0) 1291 break; 1292 d.d_namlen = snprintf(d.d_name, sizeof(d.d_name), 1293 "%u", ntohl(sav->spi)); 1294 d.d_type = DT_REG; 1295 if ((error = uiomove(&d, UIO_MX, uio)) != 0) 1296 break; 1297 if (cookies) 1298 *cookies++ = i + 1; 1299 n++; 1300 i++; 1301 } 1302 ncookies = n; 1303 break; 1304 1305 case KFSipsecspdir: 1306 /* count SP in the system */ 1307 n = 0; 1308 TAILQ_FOREACH(sp, &sptailq, tailq) 1309 n++; 1310 1311 if (i >= nipsecsp_targets + n) 1312 return (0); 1313 1314 if (ap->a_ncookies) { 1315 ncookies = min(ncookies, (n - i)); 1316 cookies = malloc(ncookies * sizeof(off_t), M_TEMP, 1317 M_WAITOK); 1318 *ap->a_cookies = cookies; 1319 } 1320 1321 n = 0; 1322 for (; i < nipsecsp_targets && uio->uio_resid >= UIO_MX; i++) { 1323 kt = &ipsecsp_targets[i]; 1324 d.d_namlen = kt->kt_namlen; 1325 if ((error = kernfs_setdirentfileno(&d, i, kfs, 1326 &kern_targets[0], kt, ap)) != 0) 1327 break; 1328 memcpy(d.d_name, kt->kt_name, kt->kt_namlen + 1); 1329 d.d_type = kt->kt_type; 1330 if ((error = uiomove(&d, UIO_MX, uio)) != 0) 1331 break; 1332 if (cookies) 1333 *cookies++ = i + 1; 1334 n++; 1335 } 1336 if (error) { 1337 ncookies = n; 1338 break; 1339 } 1340 1341 TAILQ_FOREACH(sp, &sptailq, tailq) { 1342 if (uio->uio_resid < UIO_MX) 1343 break; 1344 if ((error = kernfs_setdirentfileno_kt(&d, &ipsecsp_kt, 1345 sp->id, ap)) != 0) 1346 break; 1347 d.d_namlen = snprintf(d.d_name, sizeof(d.d_name), 1348 "%u", sp->id); 1349 d.d_type = DT_REG; 1350 if ((error = uiomove(&d, UIO_MX, uio)) != 0) 1351 break; 1352 if (cookies) 1353 *cookies++ = i + 1; 1354 n++; 1355 i++; 1356 } 1357 ncookies = n; 1358 break; 1359 #endif 1360 1361 default: 1362 error = ENOTDIR; 1363 break; 1364 } 1365 1366 if (ap->a_ncookies) { 1367 if (error) { 1368 if (cookies) 1369 free(*ap->a_cookies, M_TEMP); 1370 *ap->a_ncookies = 0; 1371 *ap->a_cookies = NULL; 1372 } else 1373 *ap->a_ncookies = ncookies; 1374 } 1375 1376 uio->uio_offset = i; 1377 return (error); 1378 } 1379 1380 int 1381 kernfs_inactive(v) 1382 void *v; 1383 { 1384 struct vop_inactive_args /* { 1385 struct vnode *a_vp; 1386 struct lwp *a_l; 1387 } */ *ap = v; 1388 struct vnode *vp = ap->a_vp; 1389 const struct kernfs_node *kfs = VTOKERN(ap->a_vp); 1390 #ifdef IPSEC 1391 struct mbuf *m; 1392 struct secpolicy *sp; 1393 #endif 1394 1395 VOP_UNLOCK(vp, 0); 1396 switch (kfs->kfs_type) { 1397 #ifdef IPSEC 1398 case KFSipsecsa: 1399 m = key_setdumpsa_spi(htonl(kfs->kfs_value)); 1400 if (m) 1401 m_freem(m); 1402 else 1403 vgone(vp); 1404 break; 1405 case KFSipsecsp: 1406 sp = key_getspbyid(kfs->kfs_value); 1407 if (sp) 1408 key_freesp(sp); 1409 else { 1410 /* should never happen as we hold a refcnt */ 1411 vgone(vp); 1412 } 1413 break; 1414 #endif 1415 default: 1416 break; 1417 } 1418 return (0); 1419 } 1420 1421 int 1422 kernfs_reclaim(v) 1423 void *v; 1424 { 1425 struct vop_reclaim_args /* { 1426 struct vnode *a_vp; 1427 } */ *ap = v; 1428 1429 return (kernfs_freevp(ap->a_vp)); 1430 } 1431 1432 /* 1433 * Return POSIX pathconf information applicable to special devices. 1434 */ 1435 int 1436 kernfs_pathconf(v) 1437 void *v; 1438 { 1439 struct vop_pathconf_args /* { 1440 struct vnode *a_vp; 1441 int a_name; 1442 register_t *a_retval; 1443 } */ *ap = v; 1444 1445 switch (ap->a_name) { 1446 case _PC_LINK_MAX: 1447 *ap->a_retval = LINK_MAX; 1448 return (0); 1449 case _PC_MAX_CANON: 1450 *ap->a_retval = MAX_CANON; 1451 return (0); 1452 case _PC_MAX_INPUT: 1453 *ap->a_retval = MAX_INPUT; 1454 return (0); 1455 case _PC_PIPE_BUF: 1456 *ap->a_retval = PIPE_BUF; 1457 return (0); 1458 case _PC_CHOWN_RESTRICTED: 1459 *ap->a_retval = 1; 1460 return (0); 1461 case _PC_VDISABLE: 1462 *ap->a_retval = _POSIX_VDISABLE; 1463 return (0); 1464 case _PC_SYNC_IO: 1465 *ap->a_retval = 1; 1466 return (0); 1467 default: 1468 return (EINVAL); 1469 } 1470 /* NOTREACHED */ 1471 } 1472 1473 /* 1474 * Print out the contents of a /dev/fd vnode. 1475 */ 1476 /* ARGSUSED */ 1477 int 1478 kernfs_print(v) 1479 void *v; 1480 { 1481 1482 printf("tag VT_KERNFS, kernfs vnode\n"); 1483 return (0); 1484 } 1485 1486 int 1487 kernfs_link(v) 1488 void *v; 1489 { 1490 struct vop_link_args /* { 1491 struct vnode *a_dvp; 1492 struct vnode *a_vp; 1493 struct componentname *a_cnp; 1494 } */ *ap = v; 1495 1496 VOP_ABORTOP(ap->a_dvp, ap->a_cnp); 1497 vput(ap->a_dvp); 1498 return (EROFS); 1499 } 1500 1501 int 1502 kernfs_symlink(v) 1503 void *v; 1504 { 1505 struct vop_symlink_args /* { 1506 struct vnode *a_dvp; 1507 struct vnode **a_vpp; 1508 struct componentname *a_cnp; 1509 struct vattr *a_vap; 1510 char *a_target; 1511 } */ *ap = v; 1512 1513 VOP_ABORTOP(ap->a_dvp, ap->a_cnp); 1514 vput(ap->a_dvp); 1515 return (EROFS); 1516 } 1517
Indexes created Wed Oct 01 19:09:53 GMT 2025