The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/uipc_domain.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1982, 1986, 1993
    3  *      The Regents of the University of California.  All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  * 4. Neither the name of the University nor the names of its contributors
   14  *    may be used to endorse or promote products derived from this software
   15  *    without specific prior written permission.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   27  * SUCH DAMAGE.
   28  *
   29  *      @(#)uipc_domain.c       8.2 (Berkeley) 10/18/93
   30  */
   31 
   32 #include <sys/cdefs.h>
   33 __FBSDID("$FreeBSD: releng/6.0/sys/kern/uipc_domain.c 150368 2005-09-20 09:16:10Z glebius $");
   34 
   35 #include <sys/param.h>
   36 #include <sys/socket.h>
   37 #include <sys/protosw.h>
   38 #include <sys/domain.h>
   39 #include <sys/mbuf.h>
   40 #include <sys/kernel.h>
   41 #include <sys/lock.h>
   42 #include <sys/mutex.h>
   43 #include <sys/socketvar.h>
   44 #include <sys/systm.h>
   45 #include <vm/uma.h>
   46 
   47 /*
   48  * System initialization
   49  *
   50  * Note: domain initialization takes place on a per domain basis
   51  * as a result of traversing a SYSINIT linker set.  Most likely,
   52  * each domain would want to call DOMAIN_SET(9) itself, which
   53  * would cause the domain to be added just after domaininit()
   54  * is called during startup.
   55  *
   56  * See DOMAIN_SET(9) for details on its use.
   57  */
   58 
   59 static void domaininit(void *);
   60 SYSINIT(domain, SI_SUB_PROTO_DOMAIN, SI_ORDER_FIRST, domaininit, NULL)
   61 
   62 static void domainfinalize(void *);
   63 SYSINIT(domainfin, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_FIRST, domainfinalize,
   64     NULL)
   65 
   66 static struct callout pffast_callout;
   67 static struct callout pfslow_callout;
   68 
   69 static void     pffasttimo(void *);
   70 static void     pfslowtimo(void *);
   71 
   72 struct domain *domains;         /* registered protocol domains */
   73 int domain_init_status = 0;
   74 struct mtx dom_mtx;             /* domain list lock */
   75 MTX_SYSINIT(domain, &dom_mtx, "domain list", MTX_DEF);
   76 
   77 /*
   78  * Dummy protocol specific user requests function pointer array.
   79  * All functions return EOPNOTSUPP.
   80  */
   81 struct pr_usrreqs nousrreqs = {
   82         .pru_abort =            pru_abort_notsupp,
   83         .pru_accept =           pru_accept_notsupp,
   84         .pru_attach =           pru_attach_notsupp,
   85         .pru_bind =             pru_bind_notsupp,
   86         .pru_connect =          pru_connect_notsupp,
   87         .pru_connect2 =         pru_connect2_notsupp,
   88         .pru_control =          pru_control_notsupp,
   89         .pru_detach =           pru_detach_notsupp,
   90         .pru_disconnect =       pru_disconnect_notsupp,
   91         .pru_listen =           pru_listen_notsupp,
   92         .pru_peeraddr =         pru_peeraddr_notsupp,
   93         .pru_rcvd =             pru_rcvd_notsupp,
   94         .pru_rcvoob =           pru_rcvoob_notsupp,
   95         .pru_send =             pru_send_notsupp,
   96         .pru_sense =            pru_sense_null,
   97         .pru_shutdown =         pru_shutdown_notsupp,
   98         .pru_sockaddr =         pru_sockaddr_notsupp,
   99         .pru_sosend =           pru_sosend_notsupp,
  100         .pru_soreceive =        pru_soreceive_notsupp,
  101         .pru_sopoll =           pru_sopoll_notsupp,
  102         .pru_sosetlabel =       pru_sosetlabel_null
  103 };
  104 
  105 static void
  106 protosw_init(struct protosw *pr)
  107 {
  108         struct pr_usrreqs *pu;
  109 
  110         pu = pr->pr_usrreqs;
  111         KASSERT(pu != NULL, ("protosw_init: %ssw[%d] has no usrreqs!",
  112             pr->pr_domain->dom_name,
  113             (int)(pr - pr->pr_domain->dom_protosw)));
  114 
  115 #define DEFAULT(foo, bar)       if ((foo) == NULL)  (foo) = (bar)
  116         DEFAULT(pu->pru_accept, pru_accept_notsupp);
  117         DEFAULT(pu->pru_connect, pru_connect_notsupp);
  118         DEFAULT(pu->pru_connect2, pru_connect2_notsupp);
  119         DEFAULT(pu->pru_control, pru_control_notsupp);
  120         DEFAULT(pu->pru_listen, pru_listen_notsupp);
  121         DEFAULT(pu->pru_rcvd, pru_rcvd_notsupp);
  122         DEFAULT(pu->pru_rcvoob, pru_rcvoob_notsupp);
  123         DEFAULT(pu->pru_sense, pru_sense_null);
  124         DEFAULT(pu->pru_sosend, sosend);
  125         DEFAULT(pu->pru_soreceive, soreceive);
  126         DEFAULT(pu->pru_sopoll, sopoll);
  127         DEFAULT(pu->pru_sosetlabel, pru_sosetlabel_null);
  128 #undef DEFAULT
  129         if (pr->pr_init)
  130                 (*pr->pr_init)();
  131 }
  132 
  133 /*
  134  * Add a new protocol domain to the list of supported domains
  135  * Note: you cant unload it again because a socket may be using it.
  136  * XXX can't fail at this time.
  137  */
  138 static void
  139 net_init_domain(struct domain *dp)
  140 {
  141         struct protosw *pr;
  142 
  143         if (dp->dom_init)
  144                 (*dp->dom_init)();
  145         for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
  146                 protosw_init(pr);
  147         /*
  148          * update global information about maximums
  149          */
  150         max_hdr = max_linkhdr + max_protohdr;
  151         max_datalen = MHLEN - max_hdr;
  152 }
  153 
  154 /*
  155  * Add a new protocol domain to the list of supported domains
  156  * Note: you cant unload it again because a socket may be using it.
  157  * XXX can't fail at this time.
  158  */
  159 void
  160 net_add_domain(void *data)
  161 {
  162         struct domain *dp;
  163 
  164         dp = (struct domain *)data;
  165         mtx_lock(&dom_mtx);
  166         dp->dom_next = domains;
  167         domains = dp;
  168 
  169         KASSERT(domain_init_status >= 1,
  170             ("attempt to net_add_domain(%s) before domaininit()",
  171             dp->dom_name));
  172 #ifndef INVARIANTS
  173         if (domain_init_status < 1)
  174                 printf("WARNING: attempt to net_add_domain(%s) before "
  175                     "domaininit()\n", dp->dom_name);
  176 #endif
  177 #ifdef notyet
  178         KASSERT(domain_init_status < 2,
  179             ("attempt to net_add_domain(%s) after domainfinalize()",
  180             dp->dom_name));
  181 #else
  182 #ifdef DIAGNOSTIC
  183         if (domain_init_status >= 2)
  184                 printf("WARNING: attempt to net_add_domain(%s) after "
  185                     "domainfinalize()\n", dp->dom_name);
  186 #endif
  187 #endif
  188         mtx_unlock(&dom_mtx);
  189         net_init_domain(dp);
  190 }
  191 
  192 /* ARGSUSED*/
  193 static void
  194 domaininit(void *dummy)
  195 {
  196         /*
  197          * Before we do any setup, make sure to initialize the
  198          * zone allocator we get struct sockets from.
  199          */
  200 
  201         socket_zone = uma_zcreate("socket", sizeof(struct socket), NULL, NULL,
  202             NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
  203         uma_zone_set_max(socket_zone, maxsockets);
  204 
  205         if (max_linkhdr < 16)           /* XXX */
  206                 max_linkhdr = 16;
  207 
  208         if (debug_mpsafenet) {
  209                 callout_init(&pffast_callout, CALLOUT_MPSAFE);
  210                 callout_init(&pfslow_callout, CALLOUT_MPSAFE);
  211         } else {
  212                 callout_init(&pffast_callout, 0);
  213                 callout_init(&pfslow_callout, 0);
  214         }
  215 
  216         mtx_lock(&dom_mtx);
  217         KASSERT(domain_init_status == 0, ("domaininit called too late!"));
  218         domain_init_status = 1;
  219         mtx_unlock(&dom_mtx);
  220 }
  221 
  222 /* ARGSUSED*/
  223 static void
  224 domainfinalize(void *dummy)
  225 {
  226         mtx_lock(&dom_mtx);
  227         KASSERT(domain_init_status == 1, ("domainfinalize called too late!"));
  228         domain_init_status = 2;
  229         mtx_unlock(&dom_mtx);   
  230 
  231         callout_reset(&pffast_callout, 1, pffasttimo, NULL);
  232         callout_reset(&pfslow_callout, 1, pfslowtimo, NULL);
  233 }
  234 
  235 struct protosw *
  236 pffindtype(family, type)
  237         int family;
  238         int type;
  239 {
  240         register struct domain *dp;
  241         register struct protosw *pr;
  242 
  243         for (dp = domains; dp; dp = dp->dom_next)
  244                 if (dp->dom_family == family)
  245                         goto found;
  246         return (0);
  247 found:
  248         for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
  249                 if (pr->pr_type && pr->pr_type == type)
  250                         return (pr);
  251         return (0);
  252 }
  253 
  254 struct protosw *
  255 pffindproto(family, protocol, type)
  256         int family;
  257         int protocol;
  258         int type;
  259 {
  260         register struct domain *dp;
  261         register struct protosw *pr;
  262         struct protosw *maybe = 0;
  263 
  264         if (family == 0)
  265                 return (0);
  266         for (dp = domains; dp; dp = dp->dom_next)
  267                 if (dp->dom_family == family)
  268                         goto found;
  269         return (0);
  270 found:
  271         for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) {
  272                 if ((pr->pr_protocol == protocol) && (pr->pr_type == type))
  273                         return (pr);
  274 
  275                 if (type == SOCK_RAW && pr->pr_type == SOCK_RAW &&
  276                     pr->pr_protocol == 0 && maybe == (struct protosw *)0)
  277                         maybe = pr;
  278         }
  279         return (maybe);
  280 }
  281 
  282 /*
  283  * The caller must make sure that the new protocol is fully set up and ready to
  284  * accept requests before it is registered.
  285  */
  286 int
  287 pf_proto_register(family, npr)
  288         int family;
  289         struct protosw *npr;
  290 {
  291         struct domain *dp;
  292         struct protosw *pr, *fpr;
  293 
  294         /* Sanity checks. */
  295         if (family == 0)
  296                 return (EPFNOSUPPORT);
  297         if (npr->pr_type == 0)
  298                 return (EPROTOTYPE);
  299         if (npr->pr_protocol == 0)
  300                 return (EPROTONOSUPPORT);
  301         if (npr->pr_usrreqs == NULL)
  302                 return (ENXIO);
  303 
  304         /* Try to find the specified domain based on the family. */
  305         for (dp = domains; dp; dp = dp->dom_next)
  306                 if (dp->dom_family == family)
  307                         goto found;
  308         return (EPFNOSUPPORT);
  309 
  310 found:
  311         /* Initialize backpointer to struct domain. */
  312         npr->pr_domain = dp;
  313         fpr = NULL;
  314 
  315         /*
  316          * Protect us against races when two protocol registrations for
  317          * the same protocol happen at the same time.
  318          */
  319         mtx_lock(&Giant);
  320 
  321         /* The new protocol must not yet exist. */
  322         for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) {
  323                 if ((pr->pr_type == npr->pr_type) &&
  324                     (pr->pr_protocol == npr->pr_protocol)) {
  325                         mtx_unlock(&Giant);
  326                         return (EEXIST);        /* XXX: Check only protocol? */
  327                 }
  328                 /* While here, remember the first free spacer. */
  329                 if ((fpr == NULL) && (pr->pr_protocol == PROTO_SPACER))
  330                         fpr = pr;
  331         }
  332 
  333         /* If no free spacer is found we can't add the new protocol. */
  334         if (fpr == NULL) {
  335                 mtx_unlock(&Giant);
  336                 return (ENOMEM);
  337         }
  338 
  339         /* Copy the new struct protosw over the spacer. */
  340         bcopy(npr, fpr, sizeof(*fpr));
  341 
  342         /* Job is done, no more protection required. */
  343         mtx_unlock(&Giant);
  344 
  345         /* Initialize and activate the protocol. */
  346         protosw_init(fpr);
  347 
  348         return (0);
  349 }
  350 
  351 /*
  352  * The caller must make sure the protocol and its functions correctly shut down
  353  * all sockets and release all locks and memory references.
  354  */
  355 int
  356 pf_proto_unregister(family, protocol, type)
  357         int family;
  358         int protocol;
  359         int type;
  360 {
  361         struct domain *dp;
  362         struct protosw *pr, *dpr;
  363 
  364         /* Sanity checks. */
  365         if (family == 0)
  366                 return (EPFNOSUPPORT);
  367         if (protocol == 0)
  368                 return (EPROTONOSUPPORT);
  369         if (type == 0)
  370                 return (EPROTOTYPE);
  371 
  372         /* Try to find the specified domain based on the family type. */
  373         for (dp = domains; dp; dp = dp->dom_next)
  374                 if (dp->dom_family == family)
  375                         goto found;
  376         return (EPFNOSUPPORT);
  377 
  378 found:
  379         dpr = NULL;
  380 
  381         /* Lock out everyone else while we are manipulating the protosw. */
  382         mtx_lock(&Giant);
  383 
  384         /* The protocol must exist and only once. */
  385         for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) {
  386                 if ((pr->pr_type == type) && (pr->pr_protocol == protocol)) {
  387                         if (dpr != NULL) {
  388                                 mtx_unlock(&Giant);
  389                                 return (EMLINK);   /* Should not happen! */
  390                         } else
  391                                 dpr = pr;
  392                 }
  393         }
  394 
  395         /* Protocol does not exist. */
  396         if (dpr == NULL) {
  397                 mtx_unlock(&Giant);
  398                 return (EPROTONOSUPPORT);
  399         }
  400 
  401         /* De-orbit the protocol and make the slot available again. */
  402         dpr->pr_type = 0;
  403         dpr->pr_domain = dp;
  404         dpr->pr_protocol = PROTO_SPACER;
  405         dpr->pr_flags = 0;
  406         dpr->pr_input = NULL;
  407         dpr->pr_output = NULL;
  408         dpr->pr_ctlinput = NULL;
  409         dpr->pr_ctloutput = NULL;
  410         dpr->pr_ousrreq = NULL;
  411         dpr->pr_init = NULL;
  412         dpr->pr_fasttimo = NULL;
  413         dpr->pr_slowtimo = NULL;
  414         dpr->pr_drain = NULL;
  415         dpr->pr_usrreqs = &nousrreqs;
  416 
  417         /* Job is done, not more protection required. */
  418         mtx_unlock(&Giant);
  419 
  420         return (0);
  421 }
  422 
  423 void
  424 pfctlinput(cmd, sa)
  425         int cmd;
  426         struct sockaddr *sa;
  427 {
  428         register struct domain *dp;
  429         register struct protosw *pr;
  430 
  431         for (dp = domains; dp; dp = dp->dom_next)
  432                 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
  433                         if (pr->pr_ctlinput)
  434                                 (*pr->pr_ctlinput)(cmd, sa, (void *)0);
  435 }
  436 
  437 void
  438 pfctlinput2(cmd, sa, ctlparam)
  439         int cmd;
  440         struct sockaddr *sa;
  441         void *ctlparam;
  442 {
  443         struct domain *dp;
  444         struct protosw *pr;
  445 
  446         if (!sa)
  447                 return;
  448         for (dp = domains; dp; dp = dp->dom_next) {
  449                 /*
  450                  * the check must be made by xx_ctlinput() anyways, to
  451                  * make sure we use data item pointed to by ctlparam in
  452                  * correct way.  the following check is made just for safety.
  453                  */
  454                 if (dp->dom_family != sa->sa_family)
  455                         continue;
  456 
  457                 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
  458                         if (pr->pr_ctlinput)
  459                                 (*pr->pr_ctlinput)(cmd, sa, ctlparam);
  460         }
  461 }
  462 
  463 static void
  464 pfslowtimo(arg)
  465         void *arg;
  466 {
  467         register struct domain *dp;
  468         register struct protosw *pr;
  469 
  470         NET_ASSERT_GIANT();
  471 
  472         for (dp = domains; dp; dp = dp->dom_next)
  473                 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
  474                         if (pr->pr_slowtimo)
  475                                 (*pr->pr_slowtimo)();
  476         callout_reset(&pfslow_callout, hz/2, pfslowtimo, NULL);
  477 }
  478 
  479 static void
  480 pffasttimo(arg)
  481         void *arg;
  482 {
  483         register struct domain *dp;
  484         register struct protosw *pr;
  485 
  486         NET_ASSERT_GIANT();
  487 
  488         for (dp = domains; dp; dp = dp->dom_next)
  489                 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
  490                         if (pr->pr_fasttimo)
  491                                 (*pr->pr_fasttimo)();
  492         callout_reset(&pffast_callout, hz/5, pffasttimo, NULL);
  493 }

Cache object: fd14354b313c379670e15db61bedd4a2


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.