774f90e2603825edd483f6ed71585428e3459ef1
[dragonfly.git] / sys / kern / uipc_domain.c
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  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by the University of
16  *      California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  *      @(#)uipc_domain.c       8.2 (Berkeley) 10/18/93
34  * $FreeBSD: src/sys/kern/uipc_domain.c,v 1.22.2.1 2001/07/03 11:01:37 ume Exp $
35  * $DragonFly: src/sys/kern/uipc_domain.c,v 1.13 2008/10/27 02:56:30 sephe Exp $
36  */
37
38 #include <sys/param.h>
39 #include <sys/socket.h>
40 #include <sys/protosw.h>
41 #include <sys/domain.h>
42 #include <sys/mbuf.h>
43 #include <sys/kernel.h>
44 #include <sys/socketvar.h>
45 #include <sys/socketops.h>
46 #include <sys/systm.h>
47 #include <vm/vm_zone.h>
48
49 #include <sys/thread2.h>
50
51 /*
52  * System initialization
53  *
54  * Note: domain initialization wants to take place on a per domain basis
55  * as a result of traversing a linker set.  Most likely, each domain
56  * want to call a registration function rather than being handled here
57  * in domaininit().  Probably this will look like:
58  *
59  * SYSINIT(unique, SI_SUB_PROTO_DOMAIN, SI_ORDER_ANY, domain_add, xxx)
60  *
61  * Where 'xxx' is replaced by the address of a parameter struct to be
62  * passed to the doamin_add() function.
63  */
64
65 static void domaininit (void *);
66 SYSINIT(domain, SI_SUB_PROTO_DOMAIN, SI_ORDER_FIRST, domaininit, NULL)
67
68 static void     pffasttimo (void *);
69 static void     pfslowtimo (void *);
70
71 struct domainlist domains;
72
73 static struct callout pffasttimo_ch;
74 static struct callout pfslowtimo_ch;
75
76 /*
77  * Add a new protocol domain to the list of supported domains
78  * Note: you cant unload it again because a socket may be using it.
79  * XXX can't fail at this time.
80  */
81 #define PRU_NOTSUPP(pu, label)          \
82         if (pu->pru_ ## label == NULL)  \
83                 pu->pru_ ## label = pru_ ## label ## _notsupp;
84 #define PRU_NULL(pu, label)             \
85         if (pu->pru_ ## label == NULL)  \
86                 pu->pru_ ## label = pru_ ## label ## _null;
87
88 static void
89 net_init_domain(struct domain *dp)
90 {
91         struct protosw *pr;
92         struct pr_usrreqs *pu;
93
94         crit_enter();
95         if (dp->dom_init)
96                 (*dp->dom_init)();
97         for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) {
98                 pu = pr->pr_usrreqs;
99                 if (pu == NULL)
100                         panic("domaininit: %ssw[%d] has no usrreqs!",
101                               dp->dom_name, pr - dp->dom_protosw);
102                 PRU_NOTSUPP(pu, accept);
103                 PRU_NOTSUPP(pu, bind);
104                 PRU_NOTSUPP(pu, connect);
105                 PRU_NOTSUPP(pu, connect2);
106                 PRU_NOTSUPP(pu, control);
107                 PRU_NOTSUPP(pu, disconnect);
108                 PRU_NOTSUPP(pu, listen);
109                 PRU_NOTSUPP(pu, peeraddr);
110                 PRU_NOTSUPP(pu, rcvd);
111                 PRU_NOTSUPP(pu, rcvoob);
112                 PRU_NULL(pu, sense);
113                 PRU_NOTSUPP(pu, shutdown);
114                 PRU_NOTSUPP(pu, sockaddr);
115                 PRU_NOTSUPP(pu, sosend);
116                 PRU_NOTSUPP(pu, soreceive);
117                 PRU_NOTSUPP(pu, sopoll);
118                 PRU_NOTSUPP(pu, ctloutput);
119
120                 if (pr->pr_init)
121                         (*pr->pr_init)();
122         }
123         /*
124          * update global information about maximums
125          */
126         max_hdr = max_linkhdr + max_protohdr;
127         max_datalen = MHLEN - max_hdr;
128         crit_exit();
129 }
130
131 /*
132  * Add a new protocol domain to the list of supported domains
133  * Note: you cant unload it again because a socket may be using it.
134  * XXX can't fail at this time.
135  */
136 void
137 net_add_domain(void *data)
138 {
139         struct domain *dp = data;
140
141         crit_enter();
142         SLIST_INSERT_HEAD(&domains, dp, dom_next);
143         crit_exit();
144         net_init_domain(dp);
145 }
146
147 /* ARGSUSED*/
148 static void
149 domaininit(void *dummy)
150 {
151         if (max_linkhdr < 16)           /* XXX */
152                 max_linkhdr = 16;
153
154         callout_init(&pffasttimo_ch);
155         callout_init(&pfslowtimo_ch);
156         callout_reset(&pffasttimo_ch, 1, pffasttimo, NULL);
157         callout_reset(&pfslowtimo_ch, 1, pfslowtimo, NULL);
158 }
159
160
161 struct protosw *
162 pffindtype(int family, int type)
163 {
164         struct domain *dp;
165         struct protosw *pr;
166
167         SLIST_FOREACH(dp, &domains, dom_next)
168                 if (dp->dom_family == family)
169                         goto found;
170         return (NULL);
171
172 found:
173         for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
174                 if (pr->pr_type && pr->pr_type == type)
175                         return (pr);
176         return (NULL);
177 }
178
179 struct protosw *
180 pffindproto(int family, int protocol, int type)
181 {
182         struct domain *dp;
183         struct protosw *pr;
184         struct protosw *maybe = NULL;
185
186         if (family == 0)
187                 return (NULL);
188         SLIST_FOREACH(dp, &domains, dom_next)
189                 if (dp->dom_family == family)
190                         goto found;
191         return (NULL);
192
193 found:
194         for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) {
195                 if ((pr->pr_protocol == protocol) && (pr->pr_type == type))
196                         return (pr);
197
198                 if (type == SOCK_RAW && pr->pr_type == SOCK_RAW &&
199                     pr->pr_protocol == 0 && maybe == NULL)
200                         maybe = pr;
201         }
202         return (maybe);
203 }
204
205 void
206 kpfctlinput(int cmd, struct sockaddr *sa)
207 {
208         struct domain *dp;
209         struct protosw *pr;
210
211         SLIST_FOREACH(dp, &domains, dom_next) {
212                 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
213                         so_pru_ctlinput(pr, cmd, sa, NULL);
214         }
215 }
216
217 void
218 kpfctlinput2(int cmd, struct sockaddr *sa, void *ctlparam)
219 {
220         struct domain *dp;
221         struct protosw *pr;
222
223         if (!sa)
224                 return;
225         SLIST_FOREACH(dp, &domains, dom_next) {
226                 /*
227                  * the check must be made by xx_ctlinput() anyways, to
228                  * make sure we use data item pointed to by ctlparam in
229                  * correct way.  the following check is made just for safety.
230                  */
231                 if (dp->dom_family != sa->sa_family)
232                         continue;
233
234                 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
235                         so_pru_ctlinput(pr, cmd, sa, ctlparam);
236         }
237 }
238
239 static void
240 pfslowtimo(void *arg)
241 {
242         struct domain *dp;
243         struct protosw *pr;
244
245         SLIST_FOREACH(dp, &domains, dom_next)
246                 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
247                         if (pr->pr_slowtimo)
248                                 (*pr->pr_slowtimo)();
249         callout_reset(&pfslowtimo_ch, hz / 2, pfslowtimo, NULL);
250 }
251
252 static void
253 pffasttimo(void *arg)
254 {
255         struct domain *dp;
256         struct protosw *pr;
257
258         SLIST_FOREACH(dp, &domains, dom_next)
259                 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
260                         if (pr->pr_fasttimo)
261                                 (*pr->pr_fasttimo)();
262         callout_reset(&pffasttimo_ch, hz / 5, pffasttimo, NULL);
263 }