uipc_domain.c revision 1.87.12.2
1 /* $NetBSD: uipc_domain.c,v 1.87.12.2 2014/08/20 00:04:29 tls Exp $ */ 2 3 /* 4 * Copyright (c) 1982, 1986, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 * 31 * @(#)uipc_domain.c 8.3 (Berkeley) 2/14/95 32 */ 33 34 #include <sys/cdefs.h> 35 __KERNEL_RCSID(0, "$NetBSD: uipc_domain.c,v 1.87.12.2 2014/08/20 00:04:29 tls Exp $"); 36 37 #include <sys/param.h> 38 #include <sys/socket.h> 39 #include <sys/socketvar.h> 40 #include <sys/protosw.h> 41 #include <sys/domain.h> 42 #include <sys/mbuf.h> 43 #include <sys/time.h> 44 #include <sys/kernel.h> 45 #include <sys/systm.h> 46 #include <sys/callout.h> 47 #include <sys/queue.h> 48 #include <sys/proc.h> 49 #include <sys/sysctl.h> 50 #include <sys/un.h> 51 #include <sys/unpcb.h> 52 #include <sys/file.h> 53 #include <sys/filedesc.h> 54 #include <sys/kauth.h> 55 #include <netinet/in.h> 56 57 MALLOC_DECLARE(M_SOCKADDR); 58 59 MALLOC_DEFINE(M_SOCKADDR, "sockaddr", "socket endpoints"); 60 61 void pffasttimo(void *); 62 void pfslowtimo(void *); 63 64 struct domainhead domains = STAILQ_HEAD_INITIALIZER(domains); 65 static struct domain *domain_array[AF_MAX]; 66 67 callout_t pffasttimo_ch, pfslowtimo_ch; 68 69 /* 70 * Current time values for fast and slow timeouts. We can use u_int 71 * relatively safely. The fast timer will roll over in 27 years and 72 * the slow timer in 68 years. 73 */ 74 u_int pfslowtimo_now; 75 u_int pffasttimo_now; 76 77 static struct sysctllog *domain_sysctllog; 78 static void sysctl_net_setup(void); 79 80 /* ensure successful linkage even without any domains in link sets */ 81 static struct domain domain_dummy; 82 __link_set_add_rodata(domains,domain_dummy); 83 84 void 85 domaininit(bool addroute) 86 { 87 __link_set_decl(domains, struct domain); 88 struct domain * const * dpp; 89 struct domain *rt_domain = NULL; 90 91 sysctl_net_setup(); 92 93 /* 94 * Add all of the domains. Make sure the PF_ROUTE 95 * domain is added last. 96 */ 97 __link_set_foreach(dpp, domains) { 98 if (*dpp == &domain_dummy) 99 continue; 100 if ((*dpp)->dom_family == PF_ROUTE) 101 rt_domain = *dpp; 102 else 103 domain_attach(*dpp); 104 } 105 if (rt_domain && addroute) 106 domain_attach(rt_domain); 107 108 callout_init(&pffasttimo_ch, CALLOUT_MPSAFE); 109 callout_init(&pfslowtimo_ch, CALLOUT_MPSAFE); 110 111 callout_reset(&pffasttimo_ch, 1, pffasttimo, NULL); 112 callout_reset(&pfslowtimo_ch, 1, pfslowtimo, NULL); 113 } 114 115 void 116 domain_attach(struct domain *dp) 117 { 118 const struct protosw *pr; 119 120 STAILQ_INSERT_TAIL(&domains, dp, dom_link); 121 if (dp->dom_family < __arraycount(domain_array)) 122 domain_array[dp->dom_family] = dp; 123 124 if (dp->dom_init) 125 (*dp->dom_init)(); 126 127 #ifdef MBUFTRACE 128 if (dp->dom_mowner.mo_name[0] == '\0') { 129 strncpy(dp->dom_mowner.mo_name, dp->dom_name, 130 sizeof(dp->dom_mowner.mo_name)); 131 MOWNER_ATTACH(&dp->dom_mowner); 132 } 133 #endif 134 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) { 135 if (pr->pr_init) 136 (*pr->pr_init)(); 137 } 138 139 if (max_linkhdr < 16) /* XXX */ 140 max_linkhdr = 16; 141 max_hdr = max_linkhdr + max_protohdr; 142 max_datalen = MHLEN - max_hdr; 143 } 144 145 struct domain * 146 pffinddomain(int family) 147 { 148 struct domain *dp; 149 150 if (family < __arraycount(domain_array) && domain_array[family] != NULL) 151 return domain_array[family]; 152 153 DOMAIN_FOREACH(dp) 154 if (dp->dom_family == family) 155 return dp; 156 return NULL; 157 } 158 159 const struct protosw * 160 pffindtype(int family, int type) 161 { 162 struct domain *dp; 163 const struct protosw *pr; 164 165 dp = pffinddomain(family); 166 if (dp == NULL) 167 return NULL; 168 169 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) 170 if (pr->pr_type && pr->pr_type == type) 171 return pr; 172 173 return NULL; 174 } 175 176 const struct protosw * 177 pffindproto(int family, int protocol, int type) 178 { 179 struct domain *dp; 180 const struct protosw *pr; 181 const struct protosw *maybe = NULL; 182 183 if (family == 0) 184 return NULL; 185 186 dp = pffinddomain(family); 187 if (dp == NULL) 188 return NULL; 189 190 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) { 191 if ((pr->pr_protocol == protocol) && (pr->pr_type == type)) 192 return pr; 193 194 if (type == SOCK_RAW && pr->pr_type == SOCK_RAW && 195 pr->pr_protocol == 0 && maybe == NULL) 196 maybe = pr; 197 } 198 return maybe; 199 } 200 201 void * 202 sockaddr_addr(struct sockaddr *sa, socklen_t *slenp) 203 { 204 const struct domain *dom; 205 206 if ((dom = pffinddomain(sa->sa_family)) == NULL || 207 dom->dom_sockaddr_addr == NULL) 208 return NULL; 209 210 return (*dom->dom_sockaddr_addr)(sa, slenp); 211 } 212 213 const void * 214 sockaddr_const_addr(const struct sockaddr *sa, socklen_t *slenp) 215 { 216 const struct domain *dom; 217 218 if ((dom = pffinddomain(sa->sa_family)) == NULL || 219 dom->dom_sockaddr_const_addr == NULL) 220 return NULL; 221 222 return (*dom->dom_sockaddr_const_addr)(sa, slenp); 223 } 224 225 const struct sockaddr * 226 sockaddr_any_by_family(int family) 227 { 228 const struct domain *dom; 229 230 if ((dom = pffinddomain(family)) == NULL) 231 return NULL; 232 233 return dom->dom_sa_any; 234 } 235 236 const struct sockaddr * 237 sockaddr_any(const struct sockaddr *sa) 238 { 239 return sockaddr_any_by_family(sa->sa_family); 240 } 241 242 const void * 243 sockaddr_anyaddr(const struct sockaddr *sa, socklen_t *slenp) 244 { 245 const struct sockaddr *any; 246 247 if ((any = sockaddr_any(sa)) == NULL) 248 return NULL; 249 250 return sockaddr_const_addr(any, slenp); 251 } 252 253 struct sockaddr * 254 sockaddr_alloc(sa_family_t af, socklen_t socklen, int flags) 255 { 256 struct sockaddr *sa; 257 socklen_t reallen = MAX(socklen, offsetof(struct sockaddr, sa_data[0])); 258 259 if ((sa = malloc(reallen, M_SOCKADDR, flags)) == NULL) 260 return NULL; 261 262 sa->sa_family = af; 263 sa->sa_len = reallen; 264 return sa; 265 } 266 267 struct sockaddr * 268 sockaddr_copy(struct sockaddr *dst, socklen_t socklen, 269 const struct sockaddr *src) 270 { 271 if (__predict_false(socklen < src->sa_len)) { 272 panic("%s: source too long, %d < %d bytes", __func__, socklen, 273 src->sa_len); 274 } 275 return memcpy(dst, src, src->sa_len); 276 } 277 278 struct sockaddr * 279 sockaddr_externalize(struct sockaddr *dst, socklen_t socklen, 280 const struct sockaddr *src) 281 { 282 struct domain *dom; 283 284 dom = pffinddomain(src->sa_family); 285 286 if (dom != NULL && dom->dom_sockaddr_externalize != NULL) 287 return (*dom->dom_sockaddr_externalize)(dst, socklen, src); 288 289 return sockaddr_copy(dst, socklen, src); 290 } 291 292 int 293 sockaddr_cmp(const struct sockaddr *sa1, const struct sockaddr *sa2) 294 { 295 int len, rc; 296 struct domain *dom; 297 298 if (sa1->sa_family != sa2->sa_family) 299 return sa1->sa_family - sa2->sa_family; 300 301 dom = pffinddomain(sa1->sa_family); 302 303 if (dom != NULL && dom->dom_sockaddr_cmp != NULL) 304 return (*dom->dom_sockaddr_cmp)(sa1, sa2); 305 306 len = MIN(sa1->sa_len, sa2->sa_len); 307 308 if (dom == NULL || dom->dom_sa_cmplen == 0) { 309 if ((rc = memcmp(sa1, sa2, len)) != 0) 310 return rc; 311 return sa1->sa_len - sa2->sa_len; 312 } 313 314 if ((rc = memcmp((const char *)sa1 + dom->dom_sa_cmpofs, 315 (const char *)sa2 + dom->dom_sa_cmpofs, 316 MIN(dom->dom_sa_cmplen, 317 len - MIN(len, dom->dom_sa_cmpofs)))) != 0) 318 return rc; 319 320 return MIN(dom->dom_sa_cmplen + dom->dom_sa_cmpofs, sa1->sa_len) - 321 MIN(dom->dom_sa_cmplen + dom->dom_sa_cmpofs, sa2->sa_len); 322 } 323 324 struct sockaddr * 325 sockaddr_dup(const struct sockaddr *src, int flags) 326 { 327 struct sockaddr *dst; 328 329 if ((dst = sockaddr_alloc(src->sa_family, src->sa_len, flags)) == NULL) 330 return NULL; 331 332 return sockaddr_copy(dst, dst->sa_len, src); 333 } 334 335 void 336 sockaddr_free(struct sockaddr *sa) 337 { 338 free(sa, M_SOCKADDR); 339 } 340 341 void 342 sockaddr_format(const struct sockaddr *sa, char *buf, size_t len) 343 { 344 const struct sockaddr_un *sun = (const struct sockaddr_un *)sa; 345 const struct sockaddr_in *sin = (const struct sockaddr_in *)sa; 346 const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)sa; 347 const uint8_t *data; 348 size_t data_len; 349 350 if (sa == NULL) { 351 strlcpy(buf, "(null)", len); 352 return; 353 } 354 355 switch (sa->sa_family) { 356 default: 357 snprintf(buf, len, "(unknown socket family %d)", 358 (int)sa->sa_family); 359 return; 360 case AF_LOCAL: 361 strlcpy(buf, "unix:", len); 362 strlcat(buf, sun->sun_path, len); 363 return; 364 case AF_INET: 365 strlcpy(buf, "inet:", len); 366 if (len < 6) 367 return; 368 buf += 5; 369 len -= 5; 370 data = (const uint8_t *)&sin->sin_addr; 371 data_len = sizeof(sin->sin_addr); 372 break; 373 case AF_INET6: 374 strlcpy(buf, "inet6:", len); 375 if (len < 7) 376 return; 377 buf += 6; 378 len -= 6; 379 data = (const uint8_t *)&sin6->sin6_addr; 380 data_len = sizeof(sin6->sin6_addr); 381 break; 382 } 383 for (;;) { 384 if (--len == 0) 385 break; 386 387 uint8_t hi = *data >> 4; 388 uint8_t lo = *data & 15; 389 --data_len; 390 ++data; 391 *buf++ = hi + (hi >= 10 ? 'a' - 10 : '0'); 392 if (--len == 0) 393 break; 394 *buf++ = lo + (lo >= 10 ? 'a' - 10 : '0'); 395 if (data_len == 0) 396 break; 397 } 398 *buf = 0; 399 } 400 401 /* 402 * sysctl helper to stuff PF_LOCAL pcbs into sysctl structures 403 */ 404 static void 405 sysctl_dounpcb(struct kinfo_pcb *pcb, const struct socket *so) 406 { 407 struct unpcb *unp = sotounpcb(so); 408 struct sockaddr_un *un = unp->unp_addr; 409 410 memset(pcb, 0, sizeof(*pcb)); 411 412 pcb->ki_family = so->so_proto->pr_domain->dom_family; 413 pcb->ki_type = so->so_proto->pr_type; 414 pcb->ki_protocol = so->so_proto->pr_protocol; 415 pcb->ki_pflags = unp->unp_flags; 416 417 pcb->ki_pcbaddr = PTRTOUINT64(unp); 418 /* pcb->ki_ppcbaddr = unp has no ppcb... */ 419 pcb->ki_sockaddr = PTRTOUINT64(so); 420 421 pcb->ki_sostate = so->so_state; 422 /* pcb->ki_prstate = unp has no state... */ 423 424 pcb->ki_rcvq = so->so_rcv.sb_cc; 425 pcb->ki_sndq = so->so_snd.sb_cc; 426 427 un = (struct sockaddr_un *)pcb->ki_spad; 428 /* 429 * local domain sockets may bind without having a local 430 * endpoint. bleah! 431 */ 432 if (unp->unp_addr != NULL) { 433 /* 434 * We've added one to sun_len when allocating to 435 * hold terminating NUL which we want here. See 436 * makeun(). 437 */ 438 memcpy(un, unp->unp_addr, 439 min(sizeof(pcb->ki_spad), unp->unp_addr->sun_len + 1)); 440 } 441 else { 442 un->sun_len = offsetof(struct sockaddr_un, sun_path); 443 un->sun_family = pcb->ki_family; 444 } 445 if (unp->unp_conn != NULL) { 446 un = (struct sockaddr_un *)pcb->ki_dpad; 447 if (unp->unp_conn->unp_addr != NULL) { 448 memcpy(un, unp->unp_conn->unp_addr, 449 min(sizeof(pcb->ki_dpad), unp->unp_conn->unp_addr->sun_len + 1)); 450 } 451 else { 452 un->sun_len = offsetof(struct sockaddr_un, sun_path); 453 un->sun_family = pcb->ki_family; 454 } 455 } 456 457 pcb->ki_inode = unp->unp_ino; 458 pcb->ki_vnode = PTRTOUINT64(unp->unp_vnode); 459 pcb->ki_conn = PTRTOUINT64(unp->unp_conn); 460 pcb->ki_refs = PTRTOUINT64(unp->unp_refs); 461 pcb->ki_nextref = PTRTOUINT64(unp->unp_nextref); 462 } 463 464 static int 465 sysctl_unpcblist(SYSCTLFN_ARGS) 466 { 467 struct file *fp, *dfp; 468 struct socket *so; 469 struct kinfo_pcb pcb; 470 char *dp; 471 size_t len, needed, elem_size, out_size; 472 int error, elem_count, pf, type; 473 474 if (namelen == 1 && name[0] == CTL_QUERY) 475 return sysctl_query(SYSCTLFN_CALL(rnode)); 476 477 if (namelen != 4) 478 return EINVAL; 479 480 if (oldp != NULL) { 481 len = *oldlenp; 482 elem_size = name[2]; 483 elem_count = name[3]; 484 if (elem_size != sizeof(pcb)) 485 return EINVAL; 486 } else { 487 len = 0; 488 elem_size = sizeof(pcb); 489 elem_count = INT_MAX; 490 } 491 error = 0; 492 dp = oldp; 493 out_size = elem_size; 494 needed = 0; 495 496 if (name - oname != 4) 497 return EINVAL; 498 499 pf = oname[1]; 500 type = oname[2]; 501 502 /* 503 * allocate dummy file descriptor to make position in list. 504 */ 505 sysctl_unlock(); 506 if ((dfp = fgetdummy()) == NULL) { 507 sysctl_relock(); 508 return ENOMEM; 509 } 510 511 /* 512 * there's no "list" of local domain sockets, so we have 513 * to walk the file list looking for them. :-/ 514 */ 515 mutex_enter(&filelist_lock); 516 LIST_FOREACH(fp, &filehead, f_list) { 517 if (fp->f_count == 0 || fp->f_type != DTYPE_SOCKET || 518 fp->f_data == NULL) 519 continue; 520 so = (struct socket *)fp->f_data; 521 if (so->so_type != type) 522 continue; 523 if (so->so_proto->pr_domain->dom_family != pf) 524 continue; 525 if (kauth_authorize_network(l->l_cred, KAUTH_NETWORK_SOCKET, 526 KAUTH_REQ_NETWORK_SOCKET_CANSEE, so, NULL, NULL) != 0) 527 continue; 528 if (len >= elem_size && elem_count > 0) { 529 mutex_enter(&fp->f_lock); 530 fp->f_count++; 531 mutex_exit(&fp->f_lock); 532 LIST_INSERT_AFTER(fp, dfp, f_list); 533 mutex_exit(&filelist_lock); 534 sysctl_dounpcb(&pcb, so); 535 error = copyout(&pcb, dp, out_size); 536 closef(fp); 537 mutex_enter(&filelist_lock); 538 LIST_REMOVE(dfp, f_list); 539 if (error) 540 break; 541 dp += elem_size; 542 len -= elem_size; 543 } 544 needed += elem_size; 545 if (elem_count > 0 && elem_count != INT_MAX) 546 elem_count--; 547 } 548 mutex_exit(&filelist_lock); 549 fputdummy(dfp); 550 *oldlenp = needed; 551 if (oldp == NULL) 552 *oldlenp += PCB_SLOP * sizeof(struct kinfo_pcb); 553 sysctl_relock(); 554 555 return error; 556 } 557 558 static void 559 sysctl_net_setup(void) 560 { 561 562 KASSERT(domain_sysctllog == NULL); 563 sysctl_createv(&domain_sysctllog, 0, NULL, NULL, 564 CTLFLAG_PERMANENT, 565 CTLTYPE_NODE, "local", 566 SYSCTL_DESCR("PF_LOCAL related settings"), 567 NULL, 0, NULL, 0, 568 CTL_NET, PF_LOCAL, CTL_EOL); 569 sysctl_createv(&domain_sysctllog, 0, NULL, NULL, 570 CTLFLAG_PERMANENT, 571 CTLTYPE_NODE, "stream", 572 SYSCTL_DESCR("SOCK_STREAM settings"), 573 NULL, 0, NULL, 0, 574 CTL_NET, PF_LOCAL, SOCK_STREAM, CTL_EOL); 575 sysctl_createv(&domain_sysctllog, 0, NULL, NULL, 576 CTLFLAG_PERMANENT, 577 CTLTYPE_NODE, "seqpacket", 578 SYSCTL_DESCR("SOCK_SEQPACKET settings"), 579 NULL, 0, NULL, 0, 580 CTL_NET, PF_LOCAL, SOCK_SEQPACKET, CTL_EOL); 581 sysctl_createv(&domain_sysctllog, 0, NULL, NULL, 582 CTLFLAG_PERMANENT, 583 CTLTYPE_NODE, "dgram", 584 SYSCTL_DESCR("SOCK_DGRAM settings"), 585 NULL, 0, NULL, 0, 586 CTL_NET, PF_LOCAL, SOCK_DGRAM, CTL_EOL); 587 588 sysctl_createv(&domain_sysctllog, 0, NULL, NULL, 589 CTLFLAG_PERMANENT, 590 CTLTYPE_STRUCT, "pcblist", 591 SYSCTL_DESCR("SOCK_STREAM protocol control block list"), 592 sysctl_unpcblist, 0, NULL, 0, 593 CTL_NET, PF_LOCAL, SOCK_STREAM, CTL_CREATE, CTL_EOL); 594 sysctl_createv(&domain_sysctllog, 0, NULL, NULL, 595 CTLFLAG_PERMANENT, 596 CTLTYPE_STRUCT, "pcblist", 597 SYSCTL_DESCR("SOCK_SEQPACKET protocol control " 598 "block list"), 599 sysctl_unpcblist, 0, NULL, 0, 600 CTL_NET, PF_LOCAL, SOCK_SEQPACKET, CTL_CREATE, CTL_EOL); 601 sysctl_createv(&domain_sysctllog, 0, NULL, NULL, 602 CTLFLAG_PERMANENT, 603 CTLTYPE_STRUCT, "pcblist", 604 SYSCTL_DESCR("SOCK_DGRAM protocol control block list"), 605 sysctl_unpcblist, 0, NULL, 0, 606 CTL_NET, PF_LOCAL, SOCK_DGRAM, CTL_CREATE, CTL_EOL); 607 } 608 609 void 610 pfctlinput(int cmd, const struct sockaddr *sa) 611 { 612 struct domain *dp; 613 const struct protosw *pr; 614 615 DOMAIN_FOREACH(dp) { 616 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) { 617 if (pr->pr_ctlinput != NULL) 618 (*pr->pr_ctlinput)(cmd, sa, NULL); 619 } 620 } 621 } 622 623 void 624 pfctlinput2(int cmd, const struct sockaddr *sa, void *ctlparam) 625 { 626 struct domain *dp; 627 const struct protosw *pr; 628 629 if (sa == NULL) 630 return; 631 632 DOMAIN_FOREACH(dp) { 633 /* 634 * the check must be made by xx_ctlinput() anyways, to 635 * make sure we use data item pointed to by ctlparam in 636 * correct way. the following check is made just for safety. 637 */ 638 if (dp->dom_family != sa->sa_family) 639 continue; 640 641 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) { 642 if (pr->pr_ctlinput != NULL) 643 (*pr->pr_ctlinput)(cmd, sa, ctlparam); 644 } 645 } 646 } 647 648 void 649 pfslowtimo(void *arg) 650 { 651 struct domain *dp; 652 const struct protosw *pr; 653 654 pfslowtimo_now++; 655 656 DOMAIN_FOREACH(dp) { 657 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) 658 if (pr->pr_slowtimo) 659 (*pr->pr_slowtimo)(); 660 } 661 callout_schedule(&pfslowtimo_ch, hz / PR_SLOWHZ); 662 } 663 664 void 665 pffasttimo(void *arg) 666 { 667 struct domain *dp; 668 const struct protosw *pr; 669 670 pffasttimo_now++; 671 672 DOMAIN_FOREACH(dp) { 673 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) 674 if (pr->pr_fasttimo) 675 (*pr->pr_fasttimo)(); 676 } 677 callout_schedule(&pffasttimo_ch, hz / PR_FASTHZ); 678 } 679
Indexes created Sat Oct 11 19:10:01 GMT 2025