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