c117e38e6b822ec115b82baae0601f784c663600
[dragonfly.git] / sys / kern / uipc_msg.c
1 /*
2  * Copyright (c) 2003, 2004 Jeffrey M. Hsu.  All rights reserved.
3  * Copyright (c) 2003, 2004 The DragonFly Project.  All rights reserved.
4  * 
5  * This code is derived from software contributed to The DragonFly Project
6  * by Jeffrey M. Hsu.
7  * 
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. Neither the name of The DragonFly Project nor the names of its
17  *    contributors may be used to endorse or promote products derived
18  *    from this software without specific, prior written permission.
19  * 
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
24  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
26  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
27  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
28  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
30  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  * $DragonFly: src/sys/kern/uipc_msg.c,v 1.26 2008/10/27 02:56:30 sephe Exp $
34  */
35
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/kernel.h>
39 #include <sys/msgport.h>
40 #include <sys/protosw.h>
41 #include <sys/socket.h>
42 #include <sys/socketvar.h>
43 #include <sys/socketops.h>
44 #include <sys/thread.h>
45 #include <sys/thread2.h>
46 #include <sys/msgport2.h>
47 #include <vm/pmap.h>
48 #include <net/netmsg2.h>
49
50 #include <net/netisr.h>
51 #include <net/netmsg.h>
52
53 /*
54  * Abort a socket and free it.  Called from soabort() only.
55  *
56  * The SS_ABORTING flag must already be set.
57  */
58 void
59 so_pru_abort(struct socket *so)
60 {
61         struct netmsg_pru_abort msg;
62         lwkt_port_t port;
63
64         KKASSERT(so->so_state & SS_ABORTING);
65         port = so->so_proto->pr_mport(so, NULL, NULL, PRU_ABORT);
66         netmsg_init(&msg.nm_netmsg, &curthread->td_msgport,
67                     0, netmsg_pru_abort);
68         msg.nm_prufn = so->so_proto->pr_usrreqs->pru_abort;
69         msg.nm_so = so;
70         (void)lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0);
71 }
72
73 /*
74  * Abort a socket and free it, asynchronously.  Called from
75  * soaborta() only.
76  *
77  * The SS_ABORTING flag must already be set.
78  */
79 void
80 so_pru_aborta(struct socket *so)
81 {
82         struct netmsg_pru_abort *msg;
83         lwkt_port_t port;
84
85         KKASSERT(so->so_state & SS_ABORTING);
86         msg = kmalloc(sizeof(*msg), M_LWKTMSG, M_WAITOK | M_ZERO);
87         port = so->so_proto->pr_mport(so, NULL, NULL, PRU_ABORT);
88         netmsg_init(&msg->nm_netmsg, &netisr_afree_rport,
89                     0, netmsg_pru_abort);
90         msg->nm_prufn = so->so_proto->pr_usrreqs->pru_abort;
91         msg->nm_so = so;
92         lwkt_sendmsg(port, &msg->nm_netmsg.nm_lmsg);
93 }
94
95 /*
96  * Abort a socket and free it.  Called from soabort_oncpu() only.
97  * Caller must make sure that the current CPU is inpcb's owner CPU.
98  *
99  * The SS_ABORTING flag must already be set.
100  */
101 void
102 so_pru_abort_oncpu(struct socket *so)
103 {
104         so->so_proto->pr_usrreqs->pru_abort(so);
105 }
106
107 int
108 so_pru_accept(struct socket *so, struct sockaddr **nam)
109 {
110         /* Block (memory allocation) in process context. XXX JH */
111         return ((*so->so_proto->pr_usrreqs->pru_accept)(so, nam));
112
113 #ifdef notdef
114         int error;
115         struct netmsg_pru_accept msg;
116         lwkt_port_t port;
117
118         port = so->so_proto->pr_mport(so, NULL, NULL, PRU_ACCEPT);
119         netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0,
120                     netmsg_pru_accept);
121         msg.nm_prufn = so->so_proto->pr_usrreqs->pru_accept;
122         msg.nm_so = so;
123         msg.nm_nam = nam;
124         error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0);
125         return (error);
126 #endif
127 }
128
129 int
130 so_pru_attach(struct socket *so, int proto, struct pru_attach_info *ai)
131 {
132         int error;
133         struct netmsg_pru_attach msg;
134         lwkt_port_t port;
135
136         port = so->so_proto->pr_mport(NULL, NULL, NULL, PRU_ATTACH);
137         netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0,
138                     netmsg_pru_attach);
139         msg.nm_prufn = so->so_proto->pr_usrreqs->pru_attach;
140         msg.nm_so = so;
141         msg.nm_proto = proto;
142         msg.nm_ai = ai;
143         error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0);
144         return (error);
145 }
146
147 int
148 so_pru_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
149 {
150         int error;
151         struct netmsg_pru_bind msg;
152         lwkt_port_t port;
153
154         /* Send mesg to thread for new address. */
155         port = so->so_proto->pr_mport(NULL, nam, NULL, PRU_BIND);
156         netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0,
157                     netmsg_pru_bind);
158         msg.nm_prufn = so->so_proto->pr_usrreqs->pru_bind;
159         msg.nm_so = so;
160         msg.nm_nam = nam;
161         msg.nm_td = td;         /* used only for prison_ip() XXX JH */
162         error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0);
163         return (error);
164 }
165
166 int
167 so_pru_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
168 {
169         int error;
170         struct netmsg_pru_connect msg;
171         lwkt_port_t port;
172
173         port = so->so_proto->pr_mport(so, nam, NULL, PRU_CONNECT);
174         netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0,
175                     netmsg_pru_connect);
176         msg.nm_prufn = so->so_proto->pr_usrreqs->pru_connect;
177         msg.nm_so = so;
178         msg.nm_nam = nam;
179         msg.nm_td = td;
180         error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0);
181         return (error);
182 }
183
184 int
185 so_pru_connect2(struct socket *so1, struct socket *so2)
186 {
187         int error;
188         struct netmsg_pru_connect2 msg;
189         lwkt_port_t port;
190
191         port = so1->so_proto->pr_mport(so1, NULL, NULL, PRU_CONNECT2);
192         netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0,
193                     netmsg_pru_connect2);
194         msg.nm_prufn = so1->so_proto->pr_usrreqs->pru_connect2;
195         msg.nm_so1 = so1;
196         msg.nm_so2 = so2;
197         error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0);
198         return (error);
199 }
200
201 int
202 so_pru_control(struct socket *so, u_long cmd, caddr_t data, struct ifnet *ifp)
203 {
204         return ((*so->so_proto->pr_usrreqs->pru_control)(so, cmd, data, ifp,
205             curthread));
206 #ifdef gag      /* does copyin and copyout deep inside stack XXX JH */
207         int error;
208         struct netmsg_pru_control msg;
209         lwkt_port_t port;
210
211         port = so->so_proto->pr_mport(so, NULL, NULL, PRU_CONTROL);
212         netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0,
213                     netmsg_pru_control);
214         msg.nm_prufn = so->so_proto->pr_usrreqs->pru_control;
215         msg.nm_so = so;
216         msg.nm_cmd = cmd;
217         msg.nm_data = data;
218         msg.nm_ifp = ifp;
219         msg.nm_td = td;
220         error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0);
221         return (error);
222 #endif
223 }
224
225 int
226 so_pru_detach(struct socket *so)
227 {
228         int error;
229         struct netmsg_pru_detach msg;
230         lwkt_port_t port;
231
232         port = so->so_proto->pr_mport(so, NULL, NULL, PRU_DETACH);
233         netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0,
234                     netmsg_pru_detach);
235         msg.nm_prufn = so->so_proto->pr_usrreqs->pru_detach;
236         msg.nm_so = so;
237         error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0);
238         return (error);
239 }
240
241 int
242 so_pru_disconnect(struct socket *so)
243 {
244         int error;
245         struct netmsg_pru_disconnect msg;
246         lwkt_port_t port;
247
248         port = so->so_proto->pr_mport(so, NULL, NULL, PRU_DISCONNECT);
249         netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0,
250                     netmsg_pru_disconnect);
251         msg.nm_prufn = so->so_proto->pr_usrreqs->pru_disconnect;
252         msg.nm_so = so;
253         error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0);
254         return (error);
255 }
256
257 int
258 so_pru_listen(struct socket *so, struct thread *td)
259 {
260         int error;
261         struct netmsg_pru_listen msg;
262         lwkt_port_t port;
263
264         port = so->so_proto->pr_mport(so, NULL, NULL, PRU_LISTEN);
265         netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0,
266                     netmsg_pru_listen);
267         msg.nm_prufn = so->so_proto->pr_usrreqs->pru_listen;
268         msg.nm_so = so;
269         msg.nm_td = td;         /* used only for prison_ip() XXX JH */
270         error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0);
271         return (error);
272 }
273
274 int
275 so_pru_peeraddr(struct socket *so, struct sockaddr **nam)
276 {
277         int error;
278         struct netmsg_pru_peeraddr msg;
279         lwkt_port_t port;
280
281         port = so->so_proto->pr_mport(so, NULL, NULL, PRU_PEERADDR);
282         netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0,
283                     netmsg_pru_peeraddr);
284         msg.nm_prufn = so->so_proto->pr_usrreqs->pru_peeraddr;
285         msg.nm_so = so;
286         msg.nm_nam = nam;
287         error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0);
288         return (error);
289 }
290
291 int
292 so_pru_rcvd(struct socket *so, int flags)
293 {
294         int error;
295         struct netmsg_pru_rcvd msg;
296         lwkt_port_t port;
297
298         port = so->so_proto->pr_mport(so, NULL, NULL, PRU_RCVD);
299         netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0,
300                     netmsg_pru_rcvd);
301         msg.nm_prufn = so->so_proto->pr_usrreqs->pru_rcvd;
302         msg.nm_so = so;
303         msg.nm_flags = flags;
304         error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0);
305         return (error);
306 }
307
308 int
309 so_pru_rcvoob(struct socket *so, struct mbuf *m, int flags)
310 {
311         int error;
312         struct netmsg_pru_rcvoob msg;
313         lwkt_port_t port;
314
315         port = so->so_proto->pr_mport(so, NULL, NULL, PRU_RCVOOB);
316         netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0,
317                     netmsg_pru_rcvoob);
318         msg.nm_prufn = so->so_proto->pr_usrreqs->pru_rcvoob;
319         msg.nm_so = so;
320         msg.nm_m = m;
321         msg.nm_flags = flags;
322         error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0);
323         return (error);
324 }
325
326 int
327 so_pru_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
328     struct mbuf *control, struct thread *td)
329 {
330         int error;
331         struct netmsg_pru_send msg;
332         lwkt_port_t port;
333
334         port = so->so_proto->pr_mport(so, addr, &m, PRU_SEND);
335         if (port == NULL) {
336                 KKASSERT(m == NULL);
337                 return EINVAL;
338         }
339
340         netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0,
341                     netmsg_pru_send);
342         msg.nm_prufn = so->so_proto->pr_usrreqs->pru_send;
343         msg.nm_so = so;
344         msg.nm_flags = flags;
345         msg.nm_m = m;
346         msg.nm_addr = addr;
347         msg.nm_control = control;
348         msg.nm_td = td;
349         error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0);
350         return (error);
351 }
352
353 /*
354  * MPSAFE
355  */
356 int
357 so_pru_sense(struct socket *so, struct stat *sb)
358 {
359         int error;
360         struct netmsg_pru_sense msg;
361         lwkt_port_t port;
362
363         port = so->so_proto->pr_mport(so, NULL, NULL, PRU_SENSE);
364         netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0,
365                     netmsg_pru_sense);
366         msg.nm_prufn = so->so_proto->pr_usrreqs->pru_sense;
367         msg.nm_so = so;
368         msg.nm_stat = sb;
369         error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0);
370         return (error);
371 }
372
373 int
374 so_pru_shutdown(struct socket *so)
375 {
376         int error;
377         struct netmsg_pru_shutdown msg;
378         lwkt_port_t port;
379
380         port = so->so_proto->pr_mport(so, NULL, NULL, PRU_SHUTDOWN);
381         netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0,
382                     netmsg_pru_shutdown);
383         msg.nm_prufn = so->so_proto->pr_usrreqs->pru_shutdown;
384         msg.nm_so = so;
385         error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0);
386         return (error);
387 }
388
389 int
390 so_pru_sockaddr(struct socket *so, struct sockaddr **nam)
391 {
392         int error;
393         struct netmsg_pru_sockaddr msg;
394         lwkt_port_t port;
395
396         port = so->so_proto->pr_mport(so, NULL, NULL, PRU_SOCKADDR);
397         netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0,
398                     netmsg_pru_sockaddr);
399         msg.nm_prufn = so->so_proto->pr_usrreqs->pru_sockaddr;
400         msg.nm_so = so;
401         msg.nm_nam = nam;
402         error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0);
403         return (error);
404 }
405
406 int
407 so_pru_sopoll(struct socket *so, int events, struct ucred *cred)
408 {
409         int error;
410         struct netmsg_pru_sopoll msg;
411         lwkt_port_t port;
412
413         port = so->so_proto->pr_mport(so, NULL, NULL, PRU_SOPOLL);
414         netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0,
415                     netmsg_pru_sopoll);
416         msg.nm_prufn = so->so_proto->pr_usrreqs->pru_sopoll;
417         msg.nm_so = so;
418         msg.nm_events = events;
419         msg.nm_cred = cred;
420         msg.nm_td = curthread;
421         error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0);
422         return (error);
423 }
424
425 int
426 so_pru_ctloutput(struct socket *so, struct sockopt *sopt)
427 {
428         struct netmsg_pru_ctloutput msg;
429         lwkt_port_t port;
430         int error;
431
432         KKASSERT(!sopt->sopt_val || kva_p(sopt->sopt_val));
433         port = so->so_proto->pr_mport(so, NULL, NULL, PRU_CTLOUTPUT);
434         netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0,
435                     netmsg_pru_ctloutput);
436         /* TBD: move pr_ctloutput to pr_usrreqs */
437         msg.nm_prufn = so->so_proto->pr_ctloutput;
438         msg.nm_so = so;
439         msg.nm_sopt = sopt;
440         error = lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0);
441         return (error);
442 }
443
444 /*
445  * Protocol control input, typically via icmp.
446  *
447  * If the protocol pr_ctlport is not NULL we call it to figure out the
448  * protocol port.  If NULL is returned we can just return, otherwise
449  * we issue a netmsg to call pr_ctlinput in the proper thread.
450  *
451  * This must be done synchronously as arg and/or extra may point to
452  * temporary data.
453  */
454 void
455 so_pru_ctlinput(struct protosw *pr, int cmd, struct sockaddr *arg, void *extra)
456 {
457         struct netmsg_pru_ctlinput msg;
458         lwkt_port_t port;
459
460         if (pr->pr_ctlport == NULL)
461                 return;
462         KKASSERT(pr->pr_ctlinput != NULL);
463         port = pr->pr_ctlport(cmd, arg, extra);
464         if (port == NULL)
465                 return;
466         netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0,
467                     netmsg_pru_ctlinput);
468         msg.nm_prufn = pr->pr_ctlinput;
469         msg.nm_cmd = cmd;
470         msg.nm_arg = arg;
471         msg.nm_extra = extra;
472         lwkt_domsg(port, &msg.nm_netmsg.nm_lmsg, 0);
473 }
474
475 /*
476  * If we convert all the protosw pr_ functions for all the protocols
477  * to take a message directly, this layer can go away.  For the moment
478  * our dispatcher ignores the return value, but since we are handling
479  * the replymsg ourselves we return EASYNC by convention.
480  */
481
482 /*
483  * Abort and destroy a socket.
484  */
485 void
486 netmsg_pru_abort(netmsg_t msg)
487 {
488         struct netmsg_pru_abort *nm = (void *)msg;
489         struct socket *so = nm->nm_so;
490         int error;
491
492         KKASSERT(so->so_state & SS_ABORTING);
493         so->so_state &= ~SS_ABORTING;
494         error = nm->nm_prufn(so);
495         if (error)
496                 sofree(so);
497         lwkt_replymsg(&msg->nm_lmsg, error);
498 }
499
500 #ifdef notused
501 void
502 netmsg_pru_accept(netmsg_t msg)
503 {
504         struct netmsg_pru_accept *nm = (void *)msg;
505
506         lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so, nm->nm_nam));
507 }
508 #endif
509
510 void
511 netmsg_pru_attach(netmsg_t msg)
512 {
513         struct netmsg_pru_attach *nm = (void *)msg;
514
515         lwkt_replymsg(&msg->nm_lmsg,
516                       nm->nm_prufn(nm->nm_so, nm->nm_proto, nm->nm_ai));
517 }
518
519 void
520 netmsg_pru_bind(netmsg_t msg)
521 {
522         struct netmsg_pru_bind *nm = (void *)msg;
523
524         lwkt_replymsg(&msg->nm_lmsg,
525                       nm->nm_prufn(nm->nm_so, nm->nm_nam, nm->nm_td));
526 }
527
528 void
529 netmsg_pru_connect(netmsg_t msg)
530 {
531         struct netmsg_pru_connect *nm = (void *)msg;
532
533         lwkt_replymsg(&msg->nm_lmsg,
534                       nm->nm_prufn(nm->nm_so, nm->nm_nam, nm->nm_td));
535 }
536
537 void
538 netmsg_pru_connect2(netmsg_t msg)
539 {
540         struct netmsg_pru_connect2 *nm = (void *)msg;
541
542         lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so1, nm->nm_so2));
543 }
544
545 void
546 netmsg_pru_control(netmsg_t msg)
547 {
548         struct netmsg_pru_control *nm = (void *)msg;
549         int error;
550
551         error = nm->nm_prufn(nm->nm_so, nm->nm_cmd, nm->nm_data,
552                                 nm->nm_ifp, nm->nm_td);
553         lwkt_replymsg(&msg->nm_lmsg, error);
554 }
555
556 void
557 netmsg_pru_detach(netmsg_t msg)
558 {
559         struct netmsg_pru_detach *nm = (void *)msg;
560
561         lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so));
562 }
563
564 void
565 netmsg_pru_disconnect(netmsg_t msg)
566 {
567         struct netmsg_pru_disconnect *nm = (void *)msg;
568
569         lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so));
570 }
571
572 void
573 netmsg_pru_listen(netmsg_t msg)
574 {
575         struct netmsg_pru_listen *nm = (void *)msg;
576
577         lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so, nm->nm_td));
578 }
579
580 void
581 netmsg_pru_peeraddr(netmsg_t msg)
582 {
583         struct netmsg_pru_peeraddr *nm = (void *)msg;
584
585         lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so, nm->nm_nam));
586 }
587
588 void
589 netmsg_pru_rcvd(netmsg_t msg)
590 {
591         struct netmsg_pru_rcvd *nm = (void *)msg;
592
593         lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so, nm->nm_flags));
594 }
595
596 void
597 netmsg_pru_rcvoob(netmsg_t msg)
598 {
599         struct netmsg_pru_rcvoob *nm = (void *)msg;
600
601         lwkt_replymsg(&msg->nm_lmsg,
602                       nm->nm_prufn(nm->nm_so, nm->nm_m, nm->nm_flags));
603 }
604
605 void
606 netmsg_pru_send(netmsg_t msg)
607 {
608         struct netmsg_pru_send *nm = (void *)msg;
609         int error;
610
611         error = nm->nm_prufn(nm->nm_so, nm->nm_flags, nm->nm_m,
612                                 nm->nm_addr, nm->nm_control, nm->nm_td);
613         lwkt_replymsg(&msg->nm_lmsg, error);
614 }
615
616 void
617 netmsg_pru_sense(netmsg_t msg)
618 {
619         struct netmsg_pru_sense *nm = (void *)msg;
620
621         lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so, nm->nm_stat));
622 }
623
624 void
625 netmsg_pru_shutdown(netmsg_t msg)
626 {
627         struct netmsg_pru_shutdown *nm = (void *)msg;
628
629         lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so));
630 }
631
632 void
633 netmsg_pru_sockaddr(netmsg_t msg)
634 {
635         struct netmsg_pru_sockaddr *nm = (void *)msg;
636
637         lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so, nm->nm_nam));
638 }
639
640 void
641 netmsg_pru_sopoll(netmsg_t msg)
642 {
643         struct netmsg_pru_sopoll *nm = (void *)msg;
644         int error;
645
646         error = nm->nm_prufn(nm->nm_so, nm->nm_events, nm->nm_cred, nm->nm_td);
647         lwkt_replymsg(&msg->nm_lmsg, error);
648 }
649
650 void
651 netmsg_pru_ctloutput(netmsg_t msg)
652 {
653         struct netmsg_pru_ctloutput *nm = (void *)msg;
654
655         lwkt_replymsg(&msg->nm_lmsg, nm->nm_prufn(nm->nm_so, nm->nm_sopt));
656 }
657
658 void
659 netmsg_pru_ctlinput(netmsg_t msg)
660 {
661         struct netmsg_pru_ctlinput *nm = (void *)msg;
662
663         nm->nm_prufn(nm->nm_cmd, nm->nm_arg, nm->nm_extra);
664         lwkt_replymsg(&nm->nm_netmsg.nm_lmsg, 0);
665 }
666
667 void
668 netmsg_pr_timeout(netmsg_t msg)
669 {
670         struct netmsg_pr_timeout *nm = (void *)msg;
671
672         lwkt_replymsg(&msg->nm_lmsg, nm->nm_prfn());
673 }
674
675 /*
676  * Handle a predicate event request.  This function is only called once
677  * when the predicate message queueing request is received.
678  */
679 void
680 netmsg_so_notify(netmsg_t netmsg)
681 {
682         struct netmsg_so_notify *msg = (void *)netmsg;
683         struct signalsockbuf *ssb;
684
685         ssb = (msg->nm_etype & NM_REVENT) ?
686                         &msg->nm_so->so_rcv :
687                         &msg->nm_so->so_snd;
688
689         /*
690          * Reply immediately if the event has occured, otherwise queue the
691          * request.
692          */
693         if (msg->nm_predicate(&msg->nm_netmsg)) {
694                 lwkt_replymsg(&msg->nm_netmsg.nm_lmsg,
695                               msg->nm_netmsg.nm_lmsg.ms_error);
696         } else {
697                 TAILQ_INSERT_TAIL(&ssb->ssb_sel.si_mlist, msg, nm_list);
698                 ssb->ssb_flags |= SSB_MEVENT;
699         }
700 }
701
702 /*
703  * Called by doio when trying to abort a netmsg_so_notify message.
704  * Unlike the other functions this one is dispatched directly by
705  * the LWKT subsystem, so it takes a lwkt_msg_t as an argument.
706  *
707  * The original message, lmsg, is under the control of the caller and
708  * will not be destroyed until we return so we can safely reference it
709  * in our synchronous abort request.
710  *
711  * This part of the abort request occurs on the originating cpu which
712  * means we may race the message flags and the original message may
713  * not even have been processed by the target cpu yet.
714  */
715 void
716 netmsg_so_notify_doabort(lwkt_msg_t lmsg)
717 {
718         struct netmsg_so_notify_abort msg;
719
720         if ((lmsg->ms_flags & (MSGF_DONE | MSGF_REPLY)) == 0) {
721                 netmsg_init(&msg.nm_netmsg, &curthread->td_msgport, 0,
722                             netmsg_so_notify_abort);
723                 msg.nm_notifymsg = (void *)lmsg;
724                 lwkt_domsg(lmsg->ms_target_port, &msg.nm_netmsg.nm_lmsg, 0);
725         }
726 }
727
728 /*
729  * Predicate requests can be aborted.  This function is only called once
730  * and will interlock against processing/reply races (since such races
731  * occur on the same thread that controls the port where the abort is 
732  * requeued).
733  *
734  * This part of the abort request occurs on the target cpu.  The message
735  * flags must be tested again in case the test that we did on the
736  * originating cpu raced.  Since messages are handled in sequence, the
737  * original message will have already been handled by the loop and either
738  * replied to or queued.
739  *
740  * We really only need to interlock with MSGF_REPLY (a bit that is set on
741  * our cpu when we reply).  Note that MSGF_DONE is not set until the
742  * reply reaches the originating cpu.  Test both bits anyway.
743  */
744 void
745 netmsg_so_notify_abort(netmsg_t netmsg)
746 {
747         struct netmsg_so_notify_abort *abrtmsg = (void *)netmsg;
748         struct netmsg_so_notify *msg = abrtmsg->nm_notifymsg;
749         struct signalsockbuf *ssb;
750
751         /*
752          * The original notify message is not destroyed until after the
753          * abort request is returned, so we can check its state.
754          */
755         if ((msg->nm_netmsg.nm_lmsg.ms_flags & (MSGF_DONE | MSGF_REPLY)) == 0) {
756                 ssb = (msg->nm_etype & NM_REVENT) ?
757                                 &msg->nm_so->so_rcv :
758                                 &msg->nm_so->so_snd;
759                 TAILQ_REMOVE(&ssb->ssb_sel.si_mlist, msg, nm_list);
760                 lwkt_replymsg(&msg->nm_netmsg.nm_lmsg, EINTR);
761         }
762
763         /*
764          * Reply to the abort message
765          */
766         lwkt_replymsg(&abrtmsg->nm_netmsg.nm_lmsg, 0);
767 }
768