1 /* 2 * Copyright (c) 2003,2004 The DragonFly Project. All rights reserved. 3 * 4 * This code is derived from software contributed to The DragonFly Project 5 * by Matthew Dillon <dillon@backplane.com> 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 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 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * 3. Neither the name of The DragonFly Project nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific, prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 * NOTE! This file may be compiled for userland libraries as well as for 35 * the kernel. 36 * 37 * $DragonFly: src/sys/kern/lwkt_msgport.c,v 1.37 2007/02/18 16:12:43 corecode Exp $ 38 */ 39 40 #ifdef _KERNEL 41 42 #include <sys/param.h> 43 #include <sys/systm.h> 44 #include <sys/kernel.h> 45 #include <sys/proc.h> 46 #include <sys/rtprio.h> 47 #include <sys/queue.h> 48 #include <sys/sysctl.h> 49 #include <sys/kthread.h> 50 #include <sys/signalvar.h> 51 #include <machine/cpu.h> 52 #include <sys/lock.h> 53 54 #include <vm/vm.h> 55 #include <vm/vm_param.h> 56 #include <vm/vm_kern.h> 57 #include <vm/vm_object.h> 58 #include <vm/vm_page.h> 59 #include <vm/vm_map.h> 60 #include <vm/vm_pager.h> 61 #include <vm/vm_extern.h> 62 #include <vm/vm_zone.h> 63 64 #include <sys/thread2.h> 65 #include <sys/msgport2.h> 66 67 #include <machine/stdarg.h> 68 #include <machine/cpufunc.h> 69 #ifdef SMP 70 #include <machine/smp.h> 71 #endif 72 73 #include <sys/malloc.h> 74 MALLOC_DEFINE(M_LWKTMSG, "lwkt message", "lwkt message"); 75 76 #else 77 78 #include <sys/stdint.h> 79 #include <libcaps/thread.h> 80 #include <sys/thread.h> 81 #include <sys/msgport.h> 82 #include <sys/errno.h> 83 #include <libcaps/globaldata.h> 84 #include <machine/cpufunc.h> 85 #include <sys/thread2.h> 86 #include <sys/msgport2.h> 87 #include <string.h> 88 89 #endif /* _KERNEL */ 90 91 92 /************************************************************************ 93 * MESSAGE FUNCTIONS * 94 ************************************************************************/ 95 96 #ifdef SMP 97 static void lwkt_replyport_remote(lwkt_msg_t msg); 98 static void lwkt_putport_remote(lwkt_msg_t msg); 99 static void lwkt_abortmsg_remote(lwkt_msg_t msg); 100 #endif 101 102 /* 103 * lwkt_sendmsg() 104 * 105 * Send a message asynchronously. This function requests asynchronous 106 * completion and calls lwkt_beginmsg(). If the target port decides to 107 * run the message synchronously this function will automatically queue 108 * the message to the current thread's message queue to present a 109 * consistent interface to the caller. 110 * 111 * The message's ms_cmd must be initialized and its ms_flags must 112 * be zero'd out. lwkt_sendmsg() will initialize the ms_abort_port 113 * (abort chasing port). If abort is supported, ms_abort must also be 114 * initialized. 115 * 116 * NOTE: you cannot safely request an abort until lwkt_sendmsg() returns 117 * to the caller. 118 * 119 * NOTE: MSGF_DONE is left set. The target port must clear it if the 120 * message is to be handled asynchronously, while the synchronous case 121 * can just ignore it. 122 */ 123 void 124 lwkt_sendmsg(lwkt_port_t port, lwkt_msg_t msg) 125 { 126 int error; 127 128 msg->ms_flags |= MSGF_ASYNC; 129 msg->ms_flags &= ~(MSGF_REPLY1 | MSGF_REPLY2 | MSGF_QUEUED | \ 130 MSGF_ABORTED | MSGF_RETRIEVED); 131 KKASSERT(msg->ms_reply_port != NULL); 132 msg->ms_abort_port = msg->ms_reply_port; 133 if ((error = lwkt_beginmsg(port, msg)) != EASYNC) { 134 lwkt_replymsg(msg, error); 135 } 136 } 137 138 /* 139 * lwkt_domsg() 140 * 141 * Send a message synchronously. This function requests synchronous 142 * completion and calls lwkt_beginmsg(). If the target port decides to 143 * run the message asynchronously this function will block waiting for 144 * the message to complete. Since MSGF_ASYNC is not set the target 145 * will not attempt to queue the reply to a reply port but will simply 146 * wake up anyone waiting on the message. 147 * 148 * A synchronous error code is always returned. 149 * 150 * The message's ms_cmd must be initialized, and its ms_flags must be 151 * at least zero'd out. lwkt_domsg() will initialize the message's 152 * ms_abort_port (abort chasing port). If abort is supported, ms_abort 153 * must also be initialized. 154 * 155 * NOTE: you cannot safely request an abort until lwkt_domsg() blocks. 156 * XXX this probably needs some work. 157 * 158 * NOTE: MSGF_DONE is left set. The target port must clear it if the 159 * message is to be handled asynchronously, while the synchronous case 160 * can just ignore it. 161 */ 162 int 163 lwkt_domsg(lwkt_port_t port, lwkt_msg_t msg) 164 { 165 int error; 166 167 msg->ms_flags &= ~(MSGF_ASYNC | MSGF_REPLY1 | MSGF_REPLY2 | \ 168 MSGF_QUEUED | MSGF_ABORTED | MSGF_RETRIEVED); 169 KKASSERT(msg->ms_reply_port != NULL); 170 msg->ms_abort_port = msg->ms_reply_port; 171 if ((error = lwkt_beginmsg(port, msg)) == EASYNC) { 172 error = lwkt_waitmsg(msg); 173 } 174 return(error); 175 } 176 177 /************************************************************************ 178 * PORT FUNCTIONS * 179 ************************************************************************/ 180 181 /* 182 * lwkt_initport() 183 * 184 * Initialize a port for use and assign it to the specified thread. 185 * The default reply function is to return the message to the originator. 186 */ 187 void 188 lwkt_initport(lwkt_port_t port, thread_t td) 189 { 190 bzero(port, sizeof(*port)); 191 TAILQ_INIT(&port->mp_msgq); 192 port->mp_td = td; 193 port->mp_putport = lwkt_default_putport; 194 port->mp_waitport = lwkt_default_waitport; 195 port->mp_replyport = lwkt_default_replyport; 196 port->mp_abortport = lwkt_default_abortport; 197 } 198 199 /* 200 * Similar to the standard initport, this function simply marks the message 201 * as being done and does not attempt to return it to an originating port. 202 */ 203 void 204 lwkt_initport_null_rport(lwkt_port_t port, thread_t td) 205 { 206 lwkt_initport(port, td); 207 port->mp_replyport = lwkt_null_replyport; 208 } 209 210 /* 211 * lwkt_getport() 212 * 213 * Retrieve the next message from the port's message queue, return NULL 214 * if no messages are pending. Note that callers CANNOT use the 215 * MSGF_ABORTED flag as a litmus test to determine if a message 216 * was aborted. The flag only indicates that an abort was requested. 217 * The message's error code will indicate whether an abort occured 218 * (typically by returning EINTR). 219 * 220 * Note that once a message has been dequeued it is subject to being 221 * requeued via an IPI based abort request if it is not marked MSGF_DONE. 222 * 223 * If the message has been aborted we have to guarentee that abort 224 * semantics are properly followed. The target port will always see 225 * the original message at least once, and if it does not reply the 226 * message before looping on its message port again it will then see 227 * the message again with ms_cmd set to ms_abort. 228 * 229 * The calling thread MUST own the port. 230 */ 231 232 static __inline 233 void 234 _lwkt_pullmsg(lwkt_port_t port, lwkt_msg_t msg) 235 { 236 if ((msg->ms_flags & MSGF_ABORTED) == 0) { 237 /* 238 * normal case, remove and return the message. 239 */ 240 TAILQ_REMOVE(&port->mp_msgq, msg, ms_node); 241 msg->ms_flags = (msg->ms_flags & ~MSGF_QUEUED) | MSGF_RETRIEVED; 242 } else { 243 if (msg->ms_flags & MSGF_RETRIEVED) { 244 /* 245 * abort case, message already returned once, remvoe and 246 * return the aborted message a second time after setting 247 * ms_cmd to ms_abort. 248 */ 249 TAILQ_REMOVE(&port->mp_msgq, msg, ms_node); 250 msg->ms_flags &= ~MSGF_QUEUED; 251 msg->ms_cmd = msg->ms_abort; 252 } else { 253 /* 254 * abort case, abort races initial message retrieval. The 255 * message is returned normally but not removed from the 256 * queue. On the next loop the 'aborted' message will be 257 * dequeued and returned. Note that if the caller replies 258 * to the message it will be dequeued (the abort becomes a 259 * NOP). 260 */ 261 msg->ms_flags |= MSGF_RETRIEVED; 262 } 263 } 264 } 265 266 void * 267 lwkt_getport(lwkt_port_t port) 268 { 269 lwkt_msg_t msg; 270 271 KKASSERT(port->mp_td == curthread); 272 273 crit_enter_quick(port->mp_td); 274 if ((msg = TAILQ_FIRST(&port->mp_msgq)) != NULL) 275 _lwkt_pullmsg(port, msg); 276 crit_exit_quick(port->mp_td); 277 return(msg); 278 } 279 280 /* 281 * This inline helper function completes processing of a reply from an 282 * unknown cpu context. 283 * 284 * The message is being returned to the specified port. The port is 285 * owned by the mp_td thread. If we are on the same cpu as the mp_td 286 * thread we can trivially queue the message to the reply port and schedule 287 * the target thread, otherwise we have to send an ipi message to the 288 * correct cpu. 289 * 290 * This inline must be entered with a critical section already held. 291 * Note that the IPIQ callback function (*_remote) is entered with a 292 * critical section already held, and we obtain one in lwkt_replyport(). 293 */ 294 static __inline 295 void 296 _lwkt_replyport(lwkt_port_t port, lwkt_msg_t msg, int force) 297 { 298 thread_t td = port->mp_td; 299 300 if (force || td->td_gd == mycpu) { 301 /* 302 * We can only reply the message if the abort has caught up with us, 303 * or if no abort was issued (same case). 304 */ 305 if (msg->ms_abort_port == port) { 306 KKASSERT((msg->ms_flags & MSGF_QUEUED) == 0); 307 TAILQ_INSERT_TAIL(&port->mp_msgq, msg, ms_node); 308 msg->ms_flags |= MSGF_DONE | MSGF_QUEUED | MSGF_REPLY2; 309 if (port->mp_flags & MSGPORTF_WAITING) 310 lwkt_schedule(td); 311 } 312 } else { 313 #ifdef SMP 314 lwkt_send_ipiq(td->td_gd, (ipifunc1_t)lwkt_replyport_remote, msg); 315 #else 316 panic("lwkt_replyport: thread %p has bad gd pointer", td); 317 #endif 318 } 319 } 320 321 #ifdef SMP 322 323 /* 324 * This function completes reply processing for the default case in the 325 * context of the originating cpu. 326 */ 327 static 328 void 329 lwkt_replyport_remote(lwkt_msg_t msg) 330 { 331 _lwkt_replyport(msg->ms_reply_port, msg, 1); 332 } 333 334 #endif 335 336 /* 337 * This function is called in the context of the target to reply a message. 338 * The critical section protects us from IPIs on the this CPU. 339 */ 340 void 341 lwkt_default_replyport(lwkt_port_t port, lwkt_msg_t msg) 342 { 343 crit_enter(); 344 msg->ms_flags |= MSGF_REPLY1; 345 346 /* 347 * An abort may have caught up to us while we were processing the 348 * message. If this occured we have to dequeue the message from the 349 * target port in the context of our current cpu before we can finish 350 * replying it. 351 */ 352 if (msg->ms_flags & MSGF_QUEUED) { 353 KKASSERT(msg->ms_flags & MSGF_ABORTED); 354 TAILQ_REMOVE(&msg->ms_target_port->mp_msgq, msg, ms_node); 355 msg->ms_flags &= ~MSGF_QUEUED; 356 } 357 358 /* 359 * Do reply port processing for async messages. Just mark the message 360 * done and wakeup the owner of the reply port for synchronous messages. 361 */ 362 if (msg->ms_flags & MSGF_ASYNC) { 363 _lwkt_replyport(port, msg, 0); 364 } else { 365 msg->ms_flags |= MSGF_DONE; 366 if (port->mp_flags & MSGPORTF_WAITING) 367 lwkt_schedule(port->mp_td); 368 } 369 crit_exit(); 370 } 371 372 /* 373 * You can point a port's reply vector at this function if you just want 374 * the message marked done, without any queueing or signaling. This is 375 * often used for structure-embedded messages. 376 */ 377 void 378 lwkt_null_replyport(lwkt_port_t port, lwkt_msg_t msg) 379 { 380 crit_enter(); 381 msg->ms_flags |= MSGF_DONE|MSGF_REPLY1; 382 crit_exit(); 383 } 384 385 /* 386 * lwkt_default_putport() 387 * 388 * This function is typically assigned to the mp_putport port vector. 389 * 390 * Queue a message to the target port and wakeup the thread owning it. 391 * This function always returns EASYNC and may be assigned to a 392 * message port's mp_putport function vector. Note that we must set 393 * MSGF_QUEUED prior to sending any IPIs in order to interlock against 394 * ABORT requests and other tests that might be performed. 395 * 396 * Note that messages start out as synchronous entities, and as an 397 * optimization MSGF_DONE is usually left set (so in the synchronous path 398 * no modifications to ms_flags are ever required). If a message becomes 399 * async, i.e. you return EASYNC, then MSGF_DONE must be cleared or 400 * lwkt_replymsg() will wind up being a NOP. 401 * 402 * The inline must be called from a critical section (the remote function 403 * is called from an IPI and will be in a critical section). 404 */ 405 static 406 __inline 407 void 408 _lwkt_putport(lwkt_port_t port, lwkt_msg_t msg, int force) 409 { 410 thread_t td = port->mp_td; 411 412 if (force || td->td_gd == mycpu) { 413 TAILQ_INSERT_TAIL(&port->mp_msgq, msg, ms_node); 414 if (port->mp_flags & MSGPORTF_WAITING) 415 lwkt_schedule(td); 416 } else { 417 #ifdef SMP 418 lwkt_send_ipiq(td->td_gd, (ipifunc1_t)lwkt_putport_remote, msg); 419 #else 420 panic("lwkt_putport: thread %p has bad gd pointer", td); 421 #endif 422 } 423 } 424 425 #ifdef SMP 426 427 static 428 void 429 lwkt_putport_remote(lwkt_msg_t msg) 430 { 431 #ifdef INVARIANTS 432 /* 433 * try to catch a free-after-send issue. 434 */ 435 if (msg->ms_target_port == (void *)0xdeadc0de) { 436 int i; 437 for (i = 0; i < 1000000; ++i) { 438 if (msg->ms_target_port != (void *)0xdeadc0de) 439 break; 440 cpu_lfence(); 441 } 442 panic("msg %p ms_target_port is bogus: reads %p after %d loops\n", msg, msg->ms_target_port, i); 443 } 444 #endif 445 _lwkt_putport(msg->ms_target_port, msg, 1); 446 } 447 448 #endif 449 450 int 451 lwkt_default_putport(lwkt_port_t port, lwkt_msg_t msg) 452 { 453 crit_enter(); 454 msg->ms_flags |= MSGF_QUEUED; /* abort interlock */ 455 msg->ms_flags &= ~MSGF_DONE; 456 msg->ms_target_port = port; 457 _lwkt_putport(port, msg, 0); 458 crit_exit(); 459 return(EASYNC); 460 } 461 462 /* 463 * lwkt_forwardmsg() 464 * 465 * Forward a message received on one port to another port. The forwarding 466 * function must deal with a pending abort but othewise essentially just 467 * issues a putport to the target port. 468 * 469 * An abort may have two side effects: First, the message may have been 470 * requeued to the current target port. If so, we must dequeue it before 471 * we can forward it. 472 */ 473 int 474 lwkt_forwardmsg(lwkt_port_t port, lwkt_msg_t msg) 475 { 476 int error; 477 478 crit_enter(); 479 if (msg->ms_flags & MSGF_QUEUED) { 480 KKASSERT(msg->ms_flags & MSGF_ABORTED); 481 TAILQ_REMOVE(&msg->ms_target_port->mp_msgq, msg, ms_node); 482 msg->ms_flags &= ~MSGF_QUEUED; 483 } 484 msg->ms_flags &= ~MSGF_RETRIEVED; 485 if ((error = port->mp_putport(port, msg)) != EASYNC) 486 lwkt_replymsg(msg, error); 487 crit_exit(); 488 return(error); 489 } 490 491 /* 492 * lwkt_abortmsg() 493 * 494 * Aborting a message is a fairly complex task. The first order of 495 * business is to get the message to the cpu that owns the target 496 * port, during which we may have to do some port chasing due to 497 * message forwarding operations. 498 * 499 * NOTE! Since an aborted message is requeued all message processing 500 * loops should check the MSGF_ABORTED flag. 501 */ 502 503 void 504 lwkt_abortmsg(lwkt_msg_t msg) 505 { 506 lwkt_port_t port; 507 thread_t td; 508 509 /* 510 * A critical section protects us from reply IPIs on this cpu. We 511 * can only abort messages that have not yet completed (DONE), are not 512 * in the midst of being replied (REPLY1), and which support the 513 * abort function (ABORTABLE). 514 */ 515 crit_enter(); 516 if ((msg->ms_flags & (MSGF_DONE|MSGF_REPLY1|MSGF_ABORTABLE)) == MSGF_ABORTABLE) { 517 /* 518 * Chase the message. If REPLY1 is set the message has been replied 519 * all the way back to the originator, otherwise it is sitting on 520 * ms_target_port (but we can only complete processing if we are 521 * on the same cpu as the selected port in order to avoid 522 * SMP cache synchronization issues). 523 * 524 * When chasing through multiple ports ms_flags may not be 525 * synchronized to the current cpu, but it WILL be synchronized 526 * with regards to testing the MSGF_REPLY1 bit once we reach the 527 * target port that made the reply and since the cpu owning 528 * some port X stores the new port in ms_target_port if the message 529 * is forwarded, the current port will only ever equal the target 530 * port when we are on the correct cpu. 531 */ 532 if (msg->ms_flags & MSGF_REPLY1) 533 port = msg->ms_reply_port; 534 else 535 port = msg->ms_target_port; 536 537 cpu_ccfence(); /* don't let the compiler reload ms_*_port */ 538 539 /* 540 * The chase call must run on the cpu owning the port. Fully 541 * synchronous ports (mp_td == NULL) can run the call on any cpu. 542 */ 543 td = port->mp_td; 544 if (td && td->td_gd != mycpu) { 545 #ifdef SMP 546 lwkt_send_ipiq(td->td_gd, (ipifunc1_t)lwkt_abortmsg_remote, msg); 547 #else 548 panic("lwkt_abortmsg: thread %p has bad gd pointer", td); 549 #endif 550 } else { 551 port->mp_abortport(port, msg); 552 } 553 } 554 crit_exit(); 555 } 556 557 #ifdef SMP 558 559 static 560 void 561 lwkt_abortmsg_remote(lwkt_msg_t msg) 562 { 563 lwkt_port_t port; 564 thread_t td; 565 566 if (msg->ms_flags & MSGF_REPLY1) 567 port = msg->ms_reply_port; 568 else 569 port = msg->ms_target_port; 570 cpu_ccfence(); /* don't let the compiler reload ms_*_port */ 571 td = port->mp_td; 572 if (td->td_gd != mycpu) { 573 lwkt_send_ipiq(td->td_gd, (ipifunc1_t)lwkt_abortmsg_remote, msg); 574 } else { 575 port->mp_abortport(port, msg); 576 } 577 } 578 579 #endif 580 581 /* 582 * The mp_abortport function is called when the abort has finally caught up 583 * to the target port or (if the message has been replied) the reply port. 584 */ 585 void 586 lwkt_default_abortport(lwkt_port_t port, lwkt_msg_t msg) 587 { 588 /* 589 * Set ms_abort_port to ms_reply_port to indicate the completion of 590 * the messaging chasing portion of the abort request. Note that 591 * the passed port is the port that we finally caught up to, not 592 * necessarily the reply port. 593 */ 594 msg->ms_abort_port = msg->ms_reply_port; 595 596 if (msg->ms_flags & MSGF_REPLY2) { 597 /* 598 * If REPLY2 is set we must have chased it all the way back to 599 * the reply port, but the replyport code has not queued the message 600 * (because it was waiting for the abort to catch up). We become 601 * responsible for queueing the message to the reply port. 602 */ 603 KKASSERT((msg->ms_flags & MSGF_QUEUED) == 0); 604 KKASSERT(port == msg->ms_reply_port); 605 TAILQ_INSERT_TAIL(&port->mp_msgq, msg, ms_node); 606 msg->ms_flags |= MSGF_DONE | MSGF_QUEUED; 607 if (port->mp_flags & MSGPORTF_WAITING) 608 lwkt_schedule(port->mp_td); 609 } else if ((msg->ms_flags & (MSGF_QUEUED|MSGF_REPLY1)) == 0) { 610 /* 611 * Abort on the target port. The message has not yet been replied 612 * and must be requeued to the target port. 613 */ 614 msg->ms_flags |= MSGF_ABORTED | MSGF_QUEUED; 615 TAILQ_INSERT_TAIL(&port->mp_msgq, msg, ms_node); 616 if (port->mp_flags & MSGPORTF_WAITING) 617 lwkt_schedule(port->mp_td); 618 } else if ((msg->ms_flags & MSGF_REPLY1) == 0) { 619 /* 620 * The message has not yet been retrieved by the target port, set 621 * MSGF_ABORTED so the target port can requeue the message abort after 622 * retrieving it. 623 */ 624 msg->ms_flags |= MSGF_ABORTED; 625 } 626 } 627 628 /* 629 * lwkt_default_waitport() 630 * 631 * If msg is NULL, dequeue the next message from the port's message 632 * queue, block until a message is ready. This function never 633 * returns NULL. 634 * 635 * If msg is non-NULL, block until the requested message has been returned 636 * to the port then dequeue and return it. DO NOT USE THIS TO WAIT FOR 637 * INCOMING REQUESTS, ONLY USE THIS TO WAIT FOR REPLIES. 638 * 639 * Note that the API does not currently support multiple threads waiting 640 * on a port. By virtue of owning the port it is controlled by our 641 * cpu and we can safely manipulate it's contents. 642 */ 643 void * 644 lwkt_default_waitport(lwkt_port_t port, lwkt_msg_t msg) 645 { 646 thread_t td = curthread; 647 int sentabort; 648 649 KKASSERT(port->mp_td == td); 650 crit_enter_quick(td); 651 if (msg == NULL) { 652 if ((msg = TAILQ_FIRST(&port->mp_msgq)) == NULL) { 653 port->mp_flags |= MSGPORTF_WAITING; 654 td->td_flags |= TDF_BLOCKED; 655 do { 656 lwkt_deschedule_self(td); 657 lwkt_switch(); 658 } while ((msg = TAILQ_FIRST(&port->mp_msgq)) == NULL); 659 td->td_flags &= ~TDF_BLOCKED; 660 port->mp_flags &= ~MSGPORTF_WAITING; 661 } 662 _lwkt_pullmsg(port, msg); 663 } else { 664 /* 665 * If a message is not marked done, or if it is queued, we have work 666 * to do. Note that MSGF_DONE is always set in the context of the 667 * reply port's cpu. 668 */ 669 if ((msg->ms_flags & (MSGF_DONE|MSGF_QUEUED)) != MSGF_DONE) { 670 /* 671 * We must own the reply port to safely mess with it's contents. 672 */ 673 port = msg->ms_reply_port; 674 KKASSERT(port->mp_td == td); 675 676 if ((msg->ms_flags & MSGF_DONE) == 0) { 677 port->mp_flags |= MSGPORTF_WAITING; /* saved by the BGL */ 678 sentabort = 0; 679 do { 680 #ifdef _KERNEL 681 /* 682 * MSGF_PCATCH is only set by processes which wish to 683 * abort the message they are blocked on when a signal 684 * occurs. Note that we still must wait for message 685 * completion after sending an abort request. 686 */ 687 if (msg->ms_flags & MSGF_PCATCH) { 688 if (sentabort == 0 && CURSIG(port->mp_td->td_lwp)) { 689 sentabort = 1; 690 lwkt_abortmsg(msg); 691 continue; 692 } 693 } 694 #endif 695 /* 696 * XXX set TDF_SINTR so 'ps' knows the difference between 697 * an interruptable wait and a disk wait. YYY eventually 698 * move LWP_SINTR to TDF_SINTR to reduce duplication. 699 */ 700 td->td_flags |= TDF_SINTR | TDF_BLOCKED; 701 lwkt_deschedule_self(td); 702 lwkt_switch(); 703 td->td_flags &= ~(TDF_SINTR | TDF_BLOCKED); 704 } while ((msg->ms_flags & MSGF_DONE) == 0); 705 port->mp_flags &= ~MSGPORTF_WAITING; /* saved by the BGL */ 706 } 707 /* 708 * We own the message now. 709 */ 710 if (msg->ms_flags & MSGF_QUEUED) { 711 msg->ms_flags &= ~MSGF_QUEUED; 712 TAILQ_REMOVE(&port->mp_msgq, msg, ms_node); 713 } 714 } 715 } 716 crit_exit_quick(td); 717 return(msg); 718 } 719 720