Rearrange the machine/cpufunc.h header and add it where needed to make libcaps
[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.26 2004/07/04 22:44:27 eirikn 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 <sys/signalvar.h>
43 #include <machine/cpu.h>
44 #include <sys/lock.h>
45
46 #include <vm/vm.h>
47 #include <vm/vm_param.h>
48 #include <vm/vm_kern.h>
49 #include <vm/vm_object.h>
50 #include <vm/vm_page.h>
51 #include <vm/vm_map.h>
52 #include <vm/vm_pager.h>
53 #include <vm/vm_extern.h>
54 #include <vm/vm_zone.h>
55
56 #include <sys/thread2.h>
57 #include <sys/msgport2.h>
58
59 #include <machine/stdarg.h>
60 #include <machine/ipl.h>
61 #include <machine/cpufunc.h>
62 #ifdef SMP
63 #include <machine/smp.h>
64 #endif
65
66 #include <sys/malloc.h>
67 MALLOC_DEFINE(M_LWKTMSG, "lwkt message", "lwkt message");
68
69 #else
70
71 #include <sys/stdint.h>
72 #include <libcaps/thread.h>
73 #include <sys/thread.h>
74 #include <sys/msgport.h>
75 #include <sys/errno.h>
76 #include <libcaps/globaldata.h>
77 #include <machine/cpufunc.h>
78 #include <sys/thread2.h>
79 #include <sys/msgport2.h>
80 #include <string.h>
81
82 #endif /* _KERNEL */
83
84
85 /************************************************************************
86  *                              MESSAGE FUNCTIONS                       *
87  ************************************************************************/
88
89 static void lwkt_replyport_remote(lwkt_msg_t msg);
90 static void lwkt_putport_remote(lwkt_msg_t msg);
91
92 /*
93  * lwkt_sendmsg()
94  *
95  *      Send a message asynchronously.  This function requests asynchronous
96  *      completion and calls lwkt_beginmsg().  If the target port decides to
97  *      run the message synchronously this function will automatically queue
98  *      the message to the current thread's message queue to present a
99  *      consistent interface to the caller. 
100  *
101  *      The message's ms_cmd must be initialized and its ms_flags must
102  *      be zero'd out.  lwkt_sendmsg() will initialize the ms_abort_port
103  *      (abort chasing port).  If abort is supported, ms_abort must also be
104  *      initialized.
105  *
106  *      NOTE: you cannot safely request an abort until lwkt_sendmsg() returns
107  *      to the caller.
108  *
109  *      NOTE: MSGF_DONE is left set.  The target port must clear it if the
110  *      message is to be handled asynchronously, while the synchronous case
111  *      can just ignore it.
112  */
113 void
114 lwkt_sendmsg(lwkt_port_t port, lwkt_msg_t msg)
115 {
116     int error;
117
118     msg->ms_flags |= MSGF_ASYNC;
119     msg->ms_flags &= ~(MSGF_REPLY1 | MSGF_REPLY2 | MSGF_QUEUED | \
120                         MSGF_ABORTED | MSGF_RETRIEVED);
121     KKASSERT(msg->ms_reply_port != NULL);
122     msg->ms_abort_port = msg->ms_reply_port;
123     if ((error = lwkt_beginmsg(port, msg)) != EASYNC) {
124         lwkt_replymsg(msg, error);
125     }
126 }
127
128 /*
129  * lwkt_domsg()
130  *
131  *      Send a message synchronously.  This function requests synchronous
132  *      completion and calls lwkt_beginmsg().  If the target port decides to
133  *      run the message asynchronously this function will block waiting for
134  *      the message to complete.  Since MSGF_ASYNC is not set the target
135  *      will not attempt to queue the reply to a reply port but will simply
136  *      wake up anyone waiting on the message.
137  *
138  *      A synchronous error code is always returned.
139  *
140  *      The message's ms_cmd must be initialized, and its ms_flags must be
141  *      at least zero'd out.  lwkt_domsg() will initialize the message's
142  *      ms_abort_port (abort chasing port).  If abort is supported, ms_abort
143  *      must also be initialized.
144  *
145  *      NOTE: you cannot safely request an abort until lwkt_domsg() blocks.
146  *      XXX this probably needs some work.
147  *
148  *      NOTE: MSGF_DONE is left set.  The target port must clear it if the
149  *      message is to be handled asynchronously, while the synchronous case
150  *      can just ignore it.
151  */
152 int
153 lwkt_domsg(lwkt_port_t port, lwkt_msg_t msg)
154 {
155     int error;
156
157     msg->ms_flags &= ~(MSGF_ASYNC | MSGF_REPLY1 | MSGF_REPLY2 | \
158                         MSGF_QUEUED | MSGF_ABORTED | MSGF_RETRIEVED);
159     KKASSERT(msg->ms_reply_port != NULL);
160     msg->ms_abort_port = msg->ms_reply_port;
161     if ((error = lwkt_beginmsg(port, msg)) == EASYNC) {
162         error = lwkt_waitmsg(msg);
163     }
164     return(error);
165 }
166
167 /************************************************************************
168  *                              PORT FUNCTIONS                          *
169  ************************************************************************/
170
171 /*
172  * lwkt_initport()
173  *
174  *      Initialize a port for use and assign it to the specified thread.
175  */
176 void
177 lwkt_initport(lwkt_port_t port, thread_t td)
178 {
179     bzero(port, sizeof(*port));
180     TAILQ_INIT(&port->mp_msgq);
181     port->mp_td = td;
182     port->mp_putport = lwkt_default_putport;
183     port->mp_waitport =  lwkt_default_waitport;
184     port->mp_replyport = lwkt_default_replyport;
185     port->mp_abortport = lwkt_default_abortport;
186 }
187
188 /*
189  * lwkt_getport()
190  *
191  *      Retrieve the next message from the port's message queue, return NULL
192  *      if no messages are pending.  Note that callers CANNOT use the
193  *      MSGF_ABORTED flag as a litmus test to determine if a message
194  *      was aborted.  The flag only indicates that an abort was requested.
195  *      The message's error code will indicate whether an abort occured
196  *      (typically by returning EINTR).
197  *
198  *      Note that once a message has been dequeued it is subject to being
199  *      requeued via an IPI based abort request if it is not marked MSGF_DONE.
200  *
201  *      If the message has been aborted we have to guarentee that abort 
202  *      semantics are properly followed.   The target port will always see
203  *      the original message at least once, and if it does not reply the 
204  *      message before looping on its message port again it will then see
205  *      the message again with ms_cmd set to ms_abort.
206  *
207  *      The calling thread MUST own the port.
208  */
209
210 static __inline
211 void
212 _lwkt_pullmsg(lwkt_port_t port, lwkt_msg_t msg)
213 {
214     if ((msg->ms_flags & MSGF_ABORTED) == 0) {
215         /*
216          * normal case, remove and return the message.
217          */
218         TAILQ_REMOVE(&port->mp_msgq, msg, ms_node);
219         msg->ms_flags = (msg->ms_flags & ~MSGF_QUEUED) | MSGF_RETRIEVED;
220     } else {
221         if (msg->ms_flags & MSGF_RETRIEVED) {
222             /*
223              * abort case, message already returned once, remvoe and
224              * return the aborted message a second time after setting
225              * ms_cmd to ms_abort.
226              */
227             TAILQ_REMOVE(&port->mp_msgq, msg, ms_node);
228             msg->ms_flags &= ~MSGF_QUEUED;
229             msg->ms_cmd = msg->ms_abort;
230         } else {
231             /*
232              * abort case, abort races initial message retrieval.  The
233              * message is returned normally but not removed from the 
234              * queue.  On the next loop the 'aborted' message will be
235              * dequeued and returned.  Note that if the caller replies
236              * to the message it will be dequeued (the abort becomes a
237              * NOP).
238              */
239             msg->ms_flags |= MSGF_RETRIEVED;
240         }
241     }
242 }
243
244 void *
245 lwkt_getport(lwkt_port_t port)
246 {
247     lwkt_msg_t msg;
248
249     KKASSERT(port->mp_td == curthread);
250
251     crit_enter_quick(port->mp_td);
252     if ((msg = TAILQ_FIRST(&port->mp_msgq)) != NULL)
253         _lwkt_pullmsg(port, msg);
254     crit_exit_quick(port->mp_td);
255     return(msg);
256 }
257
258 /*
259  * This inline helper function completes processing of a reply from an
260  * unknown cpu context.
261  *
262  * The message is being returned to the specified port.  The port is
263  * owned by the mp_td thread.  If we are on the same cpu as the mp_td
264  * thread we can trivially queue the message to the reply port and schedule
265  * the target thread, otherwise we have to send an ipi message to the
266  * correct cpu.
267  *
268  * This inline must be entered with a critical section already held.
269  * Note that the IPIQ callback function (*_remote) is entered with a
270  * critical section already held, and we obtain one in lwkt_replyport().
271  */
272 static __inline
273 void
274 _lwkt_replyport(lwkt_port_t port, lwkt_msg_t msg, int force)
275 {
276     thread_t td = port->mp_td;
277
278     if (force || td->td_gd == mycpu) {
279         /*
280          * We can only reply the message if the abort has caught up with us,
281          * or if no abort was issued (same case).
282          */
283         if (msg->ms_abort_port == port) {
284             KKASSERT((msg->ms_flags & MSGF_QUEUED) == 0);
285             TAILQ_INSERT_TAIL(&port->mp_msgq, msg, ms_node);
286             msg->ms_flags |= MSGF_DONE | MSGF_QUEUED | MSGF_REPLY2;
287             if (port->mp_flags & MSGPORTF_WAITING)
288                 lwkt_schedule(td);
289         } 
290     } else {
291         lwkt_send_ipiq(td->td_gd, (ipifunc_t)lwkt_replyport_remote, msg);
292     }
293 }
294
295 /*
296  * This function completes reply processing for the default case in the
297  * context of the originating cpu.
298  */
299 static
300 void
301 lwkt_replyport_remote(lwkt_msg_t msg)
302 {
303     _lwkt_replyport(msg->ms_reply_port, msg, 1);
304 }
305
306 /*
307  * This function is called in the context of the target to reply a message.
308  * Note that the lwkt_replymsg() inline has already set MSGF_REPLY1 and
309  * entered a critical section for us.
310  */
311
312 void
313 lwkt_default_replyport(lwkt_port_t port, lwkt_msg_t msg)
314 {
315     crit_enter();
316     msg->ms_flags |= MSGF_REPLY1;
317
318     /*
319      * An abort may have caught up to us while we were processing the
320      * message.  If this occured we have to dequeue the message from the
321      * target port in the context of our current cpu before we can finish
322      * replying it.
323      */
324     if (msg->ms_flags & MSGF_QUEUED) {
325         KKASSERT(msg->ms_flags & MSGF_ABORTED);
326         TAILQ_REMOVE(&msg->ms_target_port->mp_msgq, msg, ms_node);
327         msg->ms_flags &= ~MSGF_QUEUED;
328     }
329
330     /*
331      * Do reply port processing for async messages.  Just mark the message
332      * done and wakeup the owner of the reply port for synchronous messages.
333      */
334     if (msg->ms_flags & MSGF_ASYNC) {
335         _lwkt_replyport(port, msg, 0);
336     } else {
337         msg->ms_flags |= MSGF_DONE;
338         if (port->mp_flags & MSGPORTF_WAITING)
339             lwkt_schedule(port->mp_td);
340     }
341     crit_exit();
342 }
343
344 /*
345  * lwkt_default_putport()
346  *
347  *      This function is typically assigned to the mp_putport port vector.
348  *
349  *      Queue a message to the target port and wakeup the thread owning it.
350  *      This function always returns EASYNC and may be assigned to a
351  *      message port's mp_putport function vector.  Note that we must set
352  *      MSGF_QUEUED prior to sending any IPIs in order to interlock against
353  *      ABORT requests and other tests that might be performed.
354  *
355  *      Note that messages start out as synchronous entities, and as an
356  *      optimization MSGF_DONE is usually left set (so in the synchronous path
357  *      no modifications to ms_flags are ever required).  If a message becomes
358  *      async, i.e. you return EASYNC, then MSGF_DONE must be cleared or
359  *      lwkt_replymsg() will wind up being a NOP.
360  *
361  *      The inline must be called from a critical section (the remote function
362  *      is called from an IPI and will be in a critical section).
363  */
364 static
365 __inline
366 void
367 _lwkt_putport(lwkt_port_t port, lwkt_msg_t msg, int force)
368 {
369     thread_t td = port->mp_td;
370
371     if (force || td->td_gd == mycpu) {
372         TAILQ_INSERT_TAIL(&port->mp_msgq, msg, ms_node);
373         if (port->mp_flags & MSGPORTF_WAITING)
374             lwkt_schedule(td);
375     } else {
376         lwkt_send_ipiq(td->td_gd, (ipifunc_t)lwkt_putport_remote, msg);
377     }
378 }
379
380 static
381 void
382 lwkt_putport_remote(lwkt_msg_t msg)
383 {
384     _lwkt_putport(msg->ms_target_port, msg, 1);
385 }
386
387 int
388 lwkt_default_putport(lwkt_port_t port, lwkt_msg_t msg)
389 {
390     crit_enter();
391     msg->ms_flags |= MSGF_QUEUED;       /* abort interlock */
392     msg->ms_flags &= ~MSGF_DONE;
393     msg->ms_target_port = port;
394     _lwkt_putport(port, msg, 0);
395     crit_exit();
396     return(EASYNC);
397 }
398
399 /*
400  * lwkt_forwardmsg()
401  *
402  * Forward a message received on one port to another port.  The forwarding
403  * function must deal with a pending abort but othewise essentially just
404  * issues a putport to the target port.
405  *
406  * An abort may have two side effects:  First, the message may have been
407  * requeued to the current target port.  If so, we must dequeue it before
408  * we can forward it.
409  */
410 int
411 lwkt_forwardmsg(lwkt_port_t port, lwkt_msg_t msg)
412 {   
413     int error;
414
415     crit_enter();
416     if (msg->ms_flags & MSGF_QUEUED) {
417         KKASSERT(msg->ms_flags & MSGF_ABORTED);
418         TAILQ_REMOVE(&msg->ms_target_port->mp_msgq, msg, ms_node);
419         msg->ms_flags &= ~MSGF_QUEUED;
420     }
421     msg->ms_flags &= ~MSGF_RETRIEVED;
422     if ((error = port->mp_putport(port, msg)) != EASYNC)
423         lwkt_replymsg(msg, error);
424     crit_exit();
425     return(error);
426 }
427
428 /*
429  * lwkt_abortmsg()
430  *
431  *      Aborting a message is a fairly complex task.  The first order of
432  *      business is to get the message to the cpu that owns the target
433  *      port, during which we may have to do some port chasing due to 
434  *      message forwarding operations.
435  *
436  *      NOTE!  Since an aborted message is requeued all message processing
437  *      loops should check the MSGF_ABORTED flag.
438  */
439 static void lwkt_abortmsg_remote(lwkt_msg_t msg);
440
441 void
442 lwkt_abortmsg(lwkt_msg_t msg)
443 {
444     lwkt_port_t port;
445     thread_t td;
446
447     /*
448      * A critical section protects us from reply IPIs on this cpu.   We 
449      * can only abort messages that have not yet completed (DONE), are not
450      * in the midst of being replied (REPLY1), and which support the
451      * abort function (ABORTABLE).
452      */
453     crit_enter();
454     if ((msg->ms_flags & (MSGF_DONE|MSGF_REPLY1|MSGF_ABORTABLE)) == MSGF_ABORTABLE) {
455         /*
456          * Chase the message.  If REPLY1 is set the message has been replied
457          * all the way back to the originator, otherwise it is sitting on
458          * ms_target_port (but we can only complete processing if we are
459          * on the same cpu as the selected port in order to avoid
460          * SMP cache synchronization issues).
461          *
462          * When chasing through multiple ports ms_flags may not be 
463          * synchronized to the current cpu, but it WILL be synchronized
464          * with regards to testing the MSGF_REPLY1 bit once we reach the
465          * target port that made the reply and since the cpu owning
466          * some port X stores the new port in ms_target_port if the message
467          * is forwarded, the current port will only ever equal the target
468          * port when we are on the correct cpu.
469          */
470         if (msg->ms_flags & MSGF_REPLY1)
471             port = msg->ms_reply_port;
472         else
473             port = msg->ms_target_port;
474         cpu_mb1();
475
476         /*
477          * The chase call must run on the cpu owning the port.  Fully
478          * synchronous ports (mp_td == NULL) can run the call on any cpu.
479          */
480         td = port->mp_td;
481         if (td && td->td_gd != mycpu) {
482             lwkt_send_ipiq(td->td_gd, (ipifunc_t)lwkt_abortmsg_remote, msg);
483         } else {
484             port->mp_abortport(port, msg);
485         }
486     }
487     crit_exit();
488 }
489
490 static
491 void
492 lwkt_abortmsg_remote(lwkt_msg_t msg)
493 {
494     lwkt_port_t port;
495     thread_t td;
496
497     if (msg->ms_flags & MSGF_REPLY1)
498         port = msg->ms_reply_port;
499     else
500         port = msg->ms_target_port;
501     cpu_mb1();
502     td = port->mp_td;
503     if (td->td_gd != mycpu) {
504         lwkt_send_ipiq(td->td_gd, (ipifunc_t)lwkt_abortmsg_remote, msg);
505     } else {
506         port->mp_abortport(port, msg);
507     }
508 }
509
510 /*
511  * The mp_abortport function is called when the abort has finally caught up
512  * to the target port or (if the message has been replied) the reply port.
513  */
514 void
515 lwkt_default_abortport(lwkt_port_t port, lwkt_msg_t msg)
516 {
517     /*
518      * Set ms_abort_port to ms_reply_port to indicate the completion of
519      * the messaging chasing portion of the abort request.  Note that
520      * the passed port is the port that we finally caught up to, not
521      * necessarily the reply port.
522      */
523     msg->ms_abort_port = msg->ms_reply_port;
524
525     if (msg->ms_flags & MSGF_REPLY2) {
526         /*
527          * If REPLY2 is set we must have chased it all the way back to
528          * the reply port, but the replyport code has not queued the message
529          * (because it was waiting for the abort to catch up).  We become
530          * responsible for queueing the message to the reply port.
531          */
532         KKASSERT((msg->ms_flags & MSGF_QUEUED) == 0);
533         KKASSERT(port == msg->ms_reply_port);
534         TAILQ_INSERT_TAIL(&port->mp_msgq, msg, ms_node);
535         msg->ms_flags |= MSGF_DONE | MSGF_QUEUED;
536         if (port->mp_flags & MSGPORTF_WAITING)
537             lwkt_schedule(port->mp_td);
538     } else if ((msg->ms_flags & (MSGF_QUEUED|MSGF_REPLY1)) == 0) {
539         /*
540          * Abort on the target port.  The message has not yet been replied
541          * and must be requeued to the target port.
542          */
543         msg->ms_flags |= MSGF_ABORTED | MSGF_QUEUED;
544         TAILQ_INSERT_TAIL(&port->mp_msgq, msg, ms_node);
545         if (port->mp_flags & MSGPORTF_WAITING)
546             lwkt_schedule(port->mp_td);
547     } else if ((msg->ms_flags & MSGF_REPLY1) == 0) {
548         /*
549          * The message has not yet been retrieved by the target port, set
550          * MSGF_ABORTED so the target port can requeue the message abort after
551          * retrieving it.
552          */
553         msg->ms_flags |= MSGF_ABORTED;
554     }
555 }
556
557 /*
558  * lwkt_default_waitport()
559  *
560  *      If msg is NULL, dequeue the next message from the port's message
561  *      queue, block until a message is ready.  This function never
562  *      returns NULL.
563  *
564  *      If msg is non-NULL, block until the requested message has been returned
565  *      to the port then dequeue and return it.  DO NOT USE THIS TO WAIT FOR
566  *      INCOMING REQUESTS, ONLY USE THIS TO WAIT FOR REPLIES.
567  *
568  *      Note that the API does not currently support multiple threads waiting
569  *      on a port.  By virtue of owning the port it is controlled by our
570  *      cpu and we can safely manipulate it's contents.
571  */
572 void *
573 lwkt_default_waitport(lwkt_port_t port, lwkt_msg_t msg)
574 {
575     thread_t td = curthread;
576     int sentabort;
577
578     KKASSERT(port->mp_td == td);
579     crit_enter_quick(td);
580     if (msg == NULL) {
581         if ((msg = TAILQ_FIRST(&port->mp_msgq)) == NULL) {
582             port->mp_flags |= MSGPORTF_WAITING;
583             do {
584                 lwkt_deschedule_self(td);
585                 lwkt_switch();
586             } while ((msg = TAILQ_FIRST(&port->mp_msgq)) == NULL);
587             port->mp_flags &= ~MSGPORTF_WAITING;
588         }
589         _lwkt_pullmsg(port, msg);
590     } else {
591         /*
592          * If a message is not marked done, or if it is queued, we have work
593          * to do.  Note that MSGF_DONE is always set in the context of the
594          * reply port's cpu.
595          */
596         if ((msg->ms_flags & (MSGF_DONE|MSGF_QUEUED)) != MSGF_DONE) {
597             /*
598              * We must own the reply port to safely mess with it's contents.
599              */
600             port = msg->ms_reply_port;
601             KKASSERT(port->mp_td == td);
602
603             if ((msg->ms_flags & MSGF_DONE) == 0) {
604                 port->mp_flags |= MSGPORTF_WAITING; /* saved by the BGL */
605                 sentabort = 0;
606                 do {
607 #ifdef _KERNEL
608                     /*
609                      * MSGF_PCATCH is only set by processes which wish to
610                      * abort the message they are blocked on when a signal
611                      * occurs.  Note that we still must wait for message
612                      * completion after sending an abort request.
613                      */
614                     if (msg->ms_flags & MSGF_PCATCH) {
615                         if (sentabort == 0 && CURSIG(port->mp_td->td_proc)) {
616                             sentabort = 1;
617                             lwkt_abortmsg(msg);
618                             continue;
619                         }
620                     }
621 #endif
622                     /*
623                      * XXX set TDF_SINTR so 'ps' knows the difference between
624                      * an interruptable wait and a disk wait.  YYY eventually
625                      * move P_SINTR to TDF_SINTR to reduce duplication.
626                      */
627                     td->td_flags |= TDF_SINTR;
628                     lwkt_deschedule_self(td);
629                     lwkt_switch();
630                     td->td_flags &= ~TDF_SINTR;
631                 } while ((msg->ms_flags & MSGF_DONE) == 0);
632                 port->mp_flags &= ~MSGPORTF_WAITING; /* saved by the BGL */
633             }
634             /*
635              * We own the message now.
636              */
637             if (msg->ms_flags & MSGF_QUEUED) {
638                 msg->ms_flags &= ~MSGF_QUEUED;
639                 TAILQ_REMOVE(&port->mp_msgq, msg, ms_node);
640             }
641         }
642     }
643     crit_exit_quick(td);
644     return(msg);
645 }
646