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.25 2004/06/12 01:55:59 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 <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 <sys/thread2.h>
  78 #include <sys/msgport2.h>
  79 #include <string.h>
  80 #include <machine/cpufunc.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