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