Do some fairly major include file cleanups to further separate kernelland
[dragonfly.git] / sys / kern / lwkt_msgport.c
1 /*
2  * Copyright (c) 2003 Matthew Dillon <dillon@backplane.com>
3  * 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  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * NOTE! This file may be compiled for userland libraries as well as for
27  * the kernel.
28  *
29  * $DragonFly: src/sys/kern/lwkt_msgport.c,v 1.9 2003/11/21 22:46:08 dillon Exp $
30  */
31
32 #ifdef _KERNEL
33
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/kernel.h>
37 #include <sys/proc.h>
38 #include <sys/rtprio.h>
39 #include <sys/queue.h>
40 #include <sys/sysctl.h>
41 #include <sys/kthread.h>
42 #include <machine/cpu.h>
43 #include <sys/lock.h>
44
45 #include <vm/vm.h>
46 #include <vm/vm_param.h>
47 #include <vm/vm_kern.h>
48 #include <vm/vm_object.h>
49 #include <vm/vm_page.h>
50 #include <vm/vm_map.h>
51 #include <vm/vm_pager.h>
52 #include <vm/vm_extern.h>
53 #include <vm/vm_zone.h>
54
55 #include <sys/thread2.h>
56 #include <sys/msgport2.h>
57
58 #include <machine/stdarg.h>
59 #include <machine/ipl.h>
60 #ifdef SMP
61 #include <machine/smp.h>
62 #endif
63
64 #else
65
66 #include <sys/stdint.h>
67 #include <liblwkt/thread.h>
68 #include <sys/thread.h>
69 #include <sys/msgport.h>
70 #include <sys/errno.h>
71 #include <liblwkt/globaldata.h>
72 #include <sys/thread2.h>
73 #include <sys/msgport2.h>
74
75 #endif /* _KERNEL */
76
77
78 /************************************************************************
79  *                              MESSAGE FUNCTIONS                       *
80  ************************************************************************/
81
82 static void lwkt_replyport_remote(lwkt_msg_t msg);
83 static void lwkt_putport_remote(lwkt_msg_t msg);
84
85 void
86 lwkt_initmsg_td(lwkt_msg_t msg, thread_t td)
87 {
88     lwkt_initmsg(msg, &td->td_msgport, 0);
89 }
90
91 /*
92  * lwkt_sendmsg()
93  *
94  *      Send a message asynchronously.  This function requests asynchronous
95  *      completion and calls lwkt_beginmsg().  If the target port decides to
96  *      run the message synchronously this function will automatically queue
97  *      the message to the current thread's message queue to present a
98  *      consistent interface to the caller. 
99  *
100  *      The message's ms_cmd must be initialized and its ms_flags must be
101  *      at least zero'd out.  lwkt_sendmsg() will initialize the message's
102  *      reply port to the current thread's built-in reply port.
103  */
104 void
105 lwkt_sendmsg(lwkt_port_t port, lwkt_msg_t msg)
106 {
107     int error;
108
109     msg->ms_flags |= MSGF_ASYNC;
110     msg->ms_flags &= ~(MSGF_REPLY | MSGF_QUEUED);
111     msg->ms_reply_port = &curthread->td_msgport;
112     if ((error = lwkt_beginmsg(port, msg)) != EASYNC) {
113         lwkt_replymsg(msg, error);
114     }
115 }
116
117 /*
118  * lwkt_domsg()
119  *
120  *      Send a message synchronously.  This function requests synchronous
121  *      completion and calls lwkt_beginmsg().  If the target port decides to
122  *      run the message asynchronously this function will block waiting for
123  *      the message to complete.  Since MSGF_ASYNC is not set the target
124  *      will not attempt to queue the reply to a reply port but will simply
125  *      wake up anyone waiting on the message.
126  *
127  *      A synchronous error code is always returned.
128  *
129  *      The message's ms_cmd must be initialized and its ms_flags must be
130  *      at least zero'd out.  lwkt_domsg() will initialize the message's
131  *      reply port to the current thread's built-in reply port.
132  */
133 int
134 lwkt_domsg(lwkt_port_t port, lwkt_msg_t msg)
135 {
136     int error;
137
138     msg->ms_flags &= ~(MSGF_ASYNC | MSGF_REPLY | MSGF_QUEUED);
139     msg->ms_reply_port = &curthread->td_msgport;
140     if ((error = lwkt_beginmsg(port, msg)) == EASYNC) {
141         error = lwkt_waitmsg(msg);
142     }
143     return(error);
144 }
145
146 /************************************************************************
147  *                              PORT FUNCTIONS                          *
148  ************************************************************************/
149
150 /*
151  * lwkt_initport()
152  *
153  *      Initialize a port for use and assign it to the specified thread.
154  */
155 void
156 lwkt_init_port(lwkt_port_t port, thread_t td)
157 {
158     bzero(port, sizeof(*port));
159     TAILQ_INIT(&port->mp_msgq);
160     port->mp_td = td;
161     port->mp_putport = lwkt_putport;
162     port->mp_waitport =  lwkt_waitport;
163     port->mp_replyport = lwkt_replyport;
164     port->mp_abortport = lwkt_abortport;
165 }
166
167 /*
168  * The rest of the procedures implement the kernel's port functions.  Userland
169  * will have a different set of these
170  */
171
172 #ifdef _KERNEL
173
174 /*
175  * lwkt_replyport()
176  *
177  *      This function is typically assigned to the mp_replyport port vector.
178  *
179  *      The message is being returned to the specified port.  The port is
180  *      owned by the mp_td thread.  If we are on the same cpu as the mp_td
181  *      thread we can trivially queue the message to the messageq, otherwise
182  *      we have to send an ipi message to the correct cpu.   We then schedule
183  *      the target thread.
184  *
185  *      If MSGF_ASYNC is not set we do not bother queueing the message, we
186  *      just set the DONE bit.  
187  *
188  *      This inline must be entered with a critical section already held.
189  *      Note that the IPIQ callback function (*_remote) is entered with a
190  *      critical section already held, and we obtain one in lwkt_replyport().
191  */
192 static __inline
193 void
194 _lwkt_replyport(lwkt_port_t port, lwkt_msg_t msg)
195 {
196     thread_t td = port->mp_td;
197
198     if (td->td_gd == mycpu) {
199         TAILQ_INSERT_TAIL(&port->mp_msgq, msg, ms_node);
200         msg->ms_flags |= MSGF_DONE | MSGF_REPLY | MSGF_QUEUED;
201         if (port->mp_flags & MSGPORTF_WAITING)
202             lwkt_schedule(td);
203     } else {
204         lwkt_send_ipiq(td->td_gd->gd_cpuid, (ipifunc_t)lwkt_replyport_remote, msg);
205     }
206 }
207
208 static
209 void
210 lwkt_replyport_remote(lwkt_msg_t msg)
211 {
212     _lwkt_replyport(msg->ms_reply_port, msg);
213 }
214
215 void
216 lwkt_replyport(lwkt_port_t port, lwkt_msg_t msg)
217 {
218     crit_enter();
219     if (msg->ms_flags & MSGF_ASYNC) {
220         _lwkt_replyport(port, msg);
221     } else {
222         msg->ms_flags |= MSGF_DONE;
223         if (port->mp_flags & MSGPORTF_WAITING)
224             lwkt_schedule(port->mp_td);
225     }
226     crit_exit();
227 }
228
229 /*
230  * lwkt_putport()
231  *
232  *      This function is typically assigned to the mp_putport port vector.
233  *
234  *      Queue a message to the target port and wakeup the thread owning it.
235  *      This function always returns EASYNC and may be assigned to a
236  *      message port's mp_putport function vector.
237  *
238  *      You must already be in a critical section when calling
239  *      the inline function.  The _remote function will be in a critical
240  *      section due to being called from the IPI, and lwkt_putport() enters
241  *      a critical section.
242  */
243 static
244 __inline
245 void
246 _lwkt_putport(lwkt_port_t port, lwkt_msg_t msg)
247 {
248     thread_t td = port->mp_td;
249
250     if (td->td_gd == mycpu) {
251         TAILQ_INSERT_TAIL(&port->mp_msgq, msg, ms_node);
252         msg->ms_flags |= MSGF_QUEUED;
253         if (port->mp_flags & MSGPORTF_WAITING)
254             lwkt_schedule(td);
255     } else {
256         msg->ms_target_port = port;
257         lwkt_send_ipiq(td->td_gd->gd_cpuid, (ipifunc_t)lwkt_putport_remote, msg);
258     }
259 }
260
261 static
262 void
263 lwkt_putport_remote(lwkt_msg_t msg)
264 {
265     _lwkt_putport(msg->ms_target_port, msg);
266 }
267
268 int
269 lwkt_putport(lwkt_port_t port, lwkt_msg_t msg)
270 {
271     crit_enter();
272     msg->ms_flags &= ~MSGF_DONE;
273     _lwkt_putport(port, msg);
274     crit_exit();
275     return(EASYNC);
276 }
277
278 /*
279  * lwkt_abortport()
280  *
281  *      This function is typically assigned to the mp_abortport port vector.
282  *
283  *      This vector is typically called via the message's ms_target_port
284  *      pointer.  It should be noted that ms_target_port may race against
285  *      a forwarding operation run on a different cpu.  Any implementation
286  *      of lwkt_abortport() must deal with potential races by following
287  *      the message to the next appropriate port.
288  *
289  *      This function is a NOP.  by defaults message ports have no abort
290  *      capabilities.  Remember that aborts are always optional so doing 
291  *      nothing is perfectly reasonable.
292  */
293 void
294 lwkt_abortport(lwkt_port_t port, lwkt_msg_t msg)
295 {
296     /* NOP */
297 }
298
299 /*
300  * lwkt_getport()
301  *
302  *      Retrieve the next message from the port's message queue, return NULL
303  *      if no messages are pending.
304  *
305  *      The calling thread MUST own the port.
306  */
307 void *
308 lwkt_getport(lwkt_port_t port)
309 {
310     lwkt_msg_t msg;
311
312     KKASSERT(port->mp_td == curthread);
313
314     crit_enter();
315     if ((msg = TAILQ_FIRST(&port->mp_msgq)) != NULL) {
316         TAILQ_REMOVE(&port->mp_msgq, msg, ms_node);
317         msg->ms_flags &= ~MSGF_QUEUED;
318     }
319     crit_exit();
320     return(msg);
321 }
322
323 /*
324  * lwkt_waitport()
325  *
326  *      If msg is NULL, dequeue the next message from the port's message
327  *      queue, block until a message is ready.  This function never
328  *      returns NULL.
329  *
330  *      If msg is non-NULL, block until the requested message has been returned
331  *      to the port then dequeue and return it.
332  *
333  *      Note that the API does not currently support multiple threads waiting
334  *      on a port.  By virtue of owning the port it is controlled by our
335  *      cpu and we can safely manipulate it's contents.
336  */
337 void *
338 lwkt_waitport(lwkt_port_t port, lwkt_msg_t msg)
339 {
340     KKASSERT(port->mp_td == curthread);
341
342     crit_enter();
343     if (msg == NULL) {
344         if ((msg = TAILQ_FIRST(&port->mp_msgq)) == NULL) {
345             port->mp_flags |= MSGPORTF_WAITING;
346             do {
347                 lwkt_deschedule_self();
348                 lwkt_switch();
349             } while ((msg = TAILQ_FIRST(&port->mp_msgq)) == NULL);
350             port->mp_flags &= ~MSGPORTF_WAITING;
351         }
352         TAILQ_REMOVE(&port->mp_msgq, msg, ms_node);
353         msg->ms_flags &= ~MSGF_QUEUED;
354     } else {
355         /*
356          * If the message is marked done by not queued it has already been
357          * pulled off the port and returned and we do not have to do anything.
358          * Otherwise we do not own the message have to wait for message
359          * completion.  Beware of cpu races if MSGF_DONE is not foudn to be
360          * set!
361          */
362         if ((msg->ms_flags & (MSGF_DONE|MSGF_REPLY)) != MSGF_DONE) {
363             /*
364              * We must own the reply port to safely mess with it's contents.
365              */
366             port = msg->ms_reply_port;
367             KKASSERT(port->mp_td == curthread);
368
369             crit_enter();
370             if ((msg->ms_flags & MSGF_DONE) == 0) {
371                 port->mp_flags |= MSGPORTF_WAITING; /* saved by the BGL */
372                 do {
373                     lwkt_deschedule_self();
374                     lwkt_switch();
375                 } while ((msg->ms_flags & MSGF_DONE) == 0);
376                 port->mp_flags &= ~MSGPORTF_WAITING; /* saved by the BGL */
377             }
378             /*
379              * We own the message now.
380              */
381             if (msg->ms_flags & MSGF_QUEUED) {
382                 msg->ms_flags &= ~MSGF_QUEUED;
383                 TAILQ_REMOVE(&port->mp_msgq, msg, ms_node);
384             }
385         }
386     }
387     crit_exit();
388     return(msg);
389 }
390
391 #endif
392