![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ipc_mqueue.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / OSKit-Mach / ipc|
Return to ipc_mqueue.c CVS log | Up to [GnuMach] / OSKit-Mach / ipc |
1.1 ! root 1: /* ! 2: * Mach Operating System ! 3: * Copyright (c) 1991,1990,1989 Carnegie Mellon University. ! 4: * Copyright (c) 1993,1994 The University of Utah and ! 5: * the Computer Systems Laboratory (CSL). ! 6: * All rights reserved. ! 7: * ! 8: * Permission to use, copy, modify and distribute this software and its ! 9: * documentation is hereby granted, provided that both the copyright ! 10: * notice and this permission notice appear in all copies of the ! 11: * software, derivative works or modified versions, and any portions ! 12: * thereof, and that both notices appear in supporting documentation. ! 13: * ! 14: * CARNEGIE MELLON, THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF ! 15: * THIS SOFTWARE IN ITS "AS IS" CONDITION, AND DISCLAIM ANY LIABILITY ! 16: * OF ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF ! 17: * THIS SOFTWARE. ! 18: * ! 19: * Carnegie Mellon requests users of this software to return to ! 20: * ! 21: * Software Distribution Coordinator or [email protected] ! 22: * School of Computer Science ! 23: * Carnegie Mellon University ! 24: * Pittsburgh PA 15213-3890 ! 25: * ! 26: * any improvements or extensions that they make and grant Carnegie Mellon ! 27: * the rights to redistribute these changes. ! 28: */ ! 29: /* ! 30: * File: ipc/ipc_mqueue.c ! 31: * Author: Rich Draves ! 32: * Date: 1989 ! 33: * ! 34: * Functions to manipulate IPC message queues. ! 35: */ ! 36: ! 37: #include <norma_ipc.h> ! 38: ! 39: #include <mach/port.h> ! 40: #include <mach/message.h> ! 41: #include <kern/assert.h> ! 42: #include <kern/counters.h> ! 43: #include <kern/sched_prim.h> ! 44: #include <kern/ipc_sched.h> ! 45: #include <kern/ipc_kobject.h> ! 46: #include <ipc/ipc_mqueue.h> ! 47: #include <ipc/ipc_thread.h> ! 48: #include <ipc/ipc_kmsg.h> ! 49: #include <ipc/ipc_port.h> ! 50: #include <ipc/ipc_pset.h> ! 51: #include <ipc/ipc_space.h> ! 52: #include <ipc/ipc_marequest.h> ! 53: ! 54: ! 55: ! 56: #if NORMA_IPC ! 57: extern ipc_mqueue_t norma_ipc_handoff_mqueue; ! 58: extern ipc_kmsg_t norma_ipc_handoff_msg; ! 59: extern mach_msg_size_t norma_ipc_handoff_max_size; ! 60: extern mach_msg_size_t norma_ipc_handoff_msg_size; ! 61: extern ipc_kmsg_t norma_ipc_kmsg_accept(); ! 62: #endif /* NORMA_IPC */ ! 63: ! 64: /* ! 65: * Routine: ipc_mqueue_init ! 66: * Purpose: ! 67: * Initialize a newly-allocated message queue. ! 68: */ ! 69: ! 70: void ! 71: ipc_mqueue_init( ! 72: ipc_mqueue_t mqueue) ! 73: { ! 74: imq_lock_init(mqueue); ! 75: ipc_kmsg_queue_init(&mqueue->imq_messages); ! 76: ipc_thread_queue_init(&mqueue->imq_threads); ! 77: } ! 78: ! 79: /* ! 80: * Routine: ipc_mqueue_move ! 81: * Purpose: ! 82: * Move messages from one queue (source) to another (dest). ! 83: * Only moves messages sent to the specified port. ! 84: * Conditions: ! 85: * Both queues must be locked. ! 86: * (This is sufficient to manipulate port->ip_seqno.) ! 87: */ ! 88: ! 89: void ! 90: ipc_mqueue_move( ! 91: ipc_mqueue_t dest, ! 92: ipc_mqueue_t source, ! 93: ipc_port_t port) ! 94: { ! 95: ipc_kmsg_queue_t oldq, newq; ! 96: ipc_thread_queue_t blockedq; ! 97: ipc_kmsg_t kmsg, next; ! 98: ipc_thread_t th; ! 99: ! 100: oldq = &source->imq_messages; ! 101: newq = &dest->imq_messages; ! 102: blockedq = &dest->imq_threads; ! 103: ! 104: for (kmsg = ipc_kmsg_queue_first(oldq); ! 105: kmsg != IKM_NULL; kmsg = next) { ! 106: next = ipc_kmsg_queue_next(oldq, kmsg); ! 107: ! 108: /* only move messages sent to port */ ! 109: ! 110: if (kmsg->ikm_header.msgh_remote_port != (mach_port_t) port) ! 111: continue; ! 112: ! 113: ipc_kmsg_rmqueue(oldq, kmsg); ! 114: ! 115: /* before adding kmsg to newq, check for a blocked receiver */ ! 116: ! 117: while ((th = ipc_thread_dequeue(blockedq)) != ITH_NULL) { ! 118: assert(ipc_kmsg_queue_empty(newq)); ! 119: ! 120: thread_go(th); ! 121: ! 122: /* check if the receiver can handle the message */ ! 123: ! 124: if (kmsg->ikm_header.msgh_size <= th->ith_msize) { ! 125: th->ith_state = MACH_MSG_SUCCESS; ! 126: th->ith_kmsg = kmsg; ! 127: th->ith_seqno = port->ip_seqno++; ! 128: ! 129: goto next_kmsg; ! 130: } ! 131: ! 132: th->ith_state = MACH_RCV_TOO_LARGE; ! 133: th->ith_msize = kmsg->ikm_header.msgh_size; ! 134: } ! 135: ! 136: /* didn't find a receiver to handle the message */ ! 137: ! 138: ipc_kmsg_enqueue(newq, kmsg); ! 139: next_kmsg:; ! 140: } ! 141: } ! 142: ! 143: /* ! 144: * Routine: ipc_mqueue_changed ! 145: * Purpose: ! 146: * Wake up receivers waiting in a message queue. ! 147: * Conditions: ! 148: * The message queue is locked. ! 149: */ ! 150: ! 151: void ! 152: ipc_mqueue_changed( ! 153: ipc_mqueue_t mqueue, ! 154: mach_msg_return_t mr) ! 155: { ! 156: ipc_thread_t th; ! 157: ! 158: while ((th = ipc_thread_dequeue(&mqueue->imq_threads)) != ITH_NULL) { ! 159: th->ith_state = mr; ! 160: thread_go(th); ! 161: } ! 162: } ! 163: ! 164: /* ! 165: * Routine: ipc_mqueue_send ! 166: * Purpose: ! 167: * Send a message to a port. The message holds a reference ! 168: * for the destination port in the msgh_remote_port field. ! 169: * ! 170: * If unsuccessful, the caller still has possession of ! 171: * the message and must do something with it. If successful, ! 172: * the message is queued, given to a receiver, destroyed, ! 173: * or handled directly by the kernel via mach_msg. ! 174: * Conditions: ! 175: * Nothing locked. ! 176: * Returns: ! 177: * MACH_MSG_SUCCESS The message was accepted. ! 178: * MACH_SEND_TIMED_OUT Caller still has message. ! 179: * MACH_SEND_INTERRUPTED Caller still has message. ! 180: */ ! 181: ! 182: mach_msg_return_t ! 183: ipc_mqueue_send(kmsg, option, time_out) ! 184: ipc_kmsg_t kmsg; ! 185: mach_msg_option_t option; ! 186: mach_msg_timeout_t time_out; ! 187: { ! 188: ipc_port_t port; ! 189: ! 190: port = (ipc_port_t) kmsg->ikm_header.msgh_remote_port; ! 191: assert(IP_VALID(port)); ! 192: ! 193: ip_lock(port); ! 194: ! 195: if (port->ip_receiver == ipc_space_kernel) { ! 196: ipc_kmsg_t reply; ! 197: ! 198: /* ! 199: * We can check ip_receiver == ipc_space_kernel ! 200: * before checking that the port is active because ! 201: * ipc_port_dealloc_kernel clears ip_receiver ! 202: * before destroying a kernel port. ! 203: */ ! 204: ! 205: assert(ip_active(port)); ! 206: ip_unlock(port); ! 207: ! 208: reply = ipc_kobject_server(kmsg); ! 209: if (reply != IKM_NULL) ! 210: ipc_mqueue_send_always(reply); ! 211: ! 212: return MACH_MSG_SUCCESS; ! 213: } ! 214: ! 215: #if NORMA_IPC ! 216: if (IP_NORMA_IS_PROXY(port)) { ! 217: mach_msg_return_t mr; ! 218: ! 219: mr = norma_ipc_send(kmsg); ! 220: ip_unlock(port); ! 221: return mr; ! 222: } ! 223: #endif /* NORMA_IPC */ ! 224: ! 225: for (;;) { ! 226: ipc_thread_t self; ! 227: ! 228: /* ! 229: * Can't deliver to a dead port. ! 230: * However, we can pretend it got sent ! 231: * and was then immediately destroyed. ! 232: */ ! 233: ! 234: if (!ip_active(port)) { ! 235: /* ! 236: * We can't let ipc_kmsg_destroy deallocate ! 237: * the port right, because we might end up ! 238: * in an infinite loop trying to deliver ! 239: * a send-once notification. ! 240: */ ! 241: ! 242: ip_release(port); ! 243: ip_check_unlock(port); ! 244: kmsg->ikm_header.msgh_remote_port = MACH_PORT_NULL; ! 245: #if NORMA_IPC ! 246: /* XXX until ipc_kmsg_destroy is fixed... */ ! 247: norma_ipc_finish_receiving(&kmsg); ! 248: #endif /* NORMA_IPC */ ! 249: ipc_kmsg_destroy(kmsg); ! 250: return MACH_MSG_SUCCESS; ! 251: } ! 252: ! 253: /* ! 254: * Don't block if: ! 255: * 1) We're under the queue limit. ! 256: * 2) Caller used the MACH_SEND_ALWAYS internal option. ! 257: * 3) Message is sent to a send-once right. ! 258: */ ! 259: ! 260: if ((port->ip_msgcount < port->ip_qlimit) || ! 261: (option & MACH_SEND_ALWAYS) || ! 262: (MACH_MSGH_BITS_REMOTE(kmsg->ikm_header.msgh_bits) == ! 263: MACH_MSG_TYPE_PORT_SEND_ONCE)) ! 264: break; ! 265: ! 266: /* must block waiting for queue to clear */ ! 267: ! 268: self = current_thread(); ! 269: ! 270: if (option & MACH_SEND_TIMEOUT) { ! 271: if (time_out == 0) { ! 272: ip_unlock(port); ! 273: return MACH_SEND_TIMED_OUT; ! 274: } ! 275: ! 276: thread_will_wait_with_timeout(self, time_out); ! 277: } else ! 278: thread_will_wait(self); ! 279: ! 280: ipc_thread_enqueue(&port->ip_blocked, self); ! 281: self->ith_state = MACH_SEND_IN_PROGRESS; ! 282: ! 283: ip_unlock(port); ! 284: counter(c_ipc_mqueue_send_block++); ! 285: thread_block((void (*)(void)) 0); ! 286: ip_lock(port); ! 287: ! 288: /* why did we wake up? */ ! 289: ! 290: if (self->ith_state == MACH_MSG_SUCCESS) ! 291: continue; ! 292: assert(self->ith_state == MACH_SEND_IN_PROGRESS); ! 293: ! 294: /* take ourselves off blocked queue */ ! 295: ! 296: ipc_thread_rmqueue(&port->ip_blocked, self); ! 297: ! 298: /* ! 299: * Thread wakeup-reason field tells us why ! 300: * the wait was interrupted. ! 301: */ ! 302: ! 303: switch (self->ith_wait_result) { ! 304: case THREAD_INTERRUPTED: ! 305: /* send was interrupted - give up */ ! 306: ! 307: ip_unlock(port); ! 308: return MACH_SEND_INTERRUPTED; ! 309: ! 310: case THREAD_TIMED_OUT: ! 311: /* timeout expired */ ! 312: ! 313: assert(option & MACH_SEND_TIMEOUT); ! 314: time_out = 0; ! 315: break; ! 316: ! 317: case THREAD_RESTART: ! 318: default: ! 319: #if MACH_ASSERT ! 320: assert(!"ipc_mqueue_send"); ! 321: #else ! 322: panic("ipc_mqueue_send"); ! 323: #endif ! 324: } ! 325: } ! 326: ! 327: if (kmsg->ikm_header.msgh_bits & MACH_MSGH_BITS_CIRCULAR) { ! 328: ip_unlock(port); ! 329: ! 330: /* don't allow the creation of a circular loop */ ! 331: ! 332: #if NORMA_IPC ! 333: /* XXX until ipc_kmsg_destroy is fixed... */ ! 334: norma_ipc_finish_receiving(&kmsg); ! 335: #endif /* NORMA_IPC */ ! 336: ipc_kmsg_destroy(kmsg); ! 337: return MACH_MSG_SUCCESS; ! 338: } ! 339: ! 340: { ! 341: ipc_mqueue_t mqueue; ! 342: ipc_pset_t pset; ! 343: ipc_thread_t receiver; ! 344: ipc_thread_queue_t receivers; ! 345: ! 346: port->ip_msgcount++; ! 347: assert(port->ip_msgcount > 0); ! 348: ! 349: pset = port->ip_pset; ! 350: if (pset == IPS_NULL) ! 351: mqueue = &port->ip_messages; ! 352: else ! 353: mqueue = &pset->ips_messages; ! 354: ! 355: imq_lock(mqueue); ! 356: receivers = &mqueue->imq_threads; ! 357: ! 358: /* ! 359: * Can unlock the port now that the msg queue is locked ! 360: * and we know the port is active. While the msg queue ! 361: * is locked, we have control of the kmsg, so the ref in ! 362: * it for the port is still good. If the msg queue is in ! 363: * a set (dead or alive), then we're OK because the port ! 364: * is still a member of the set and the set won't go away ! 365: * until the port is taken out, which tries to lock the ! 366: * set's msg queue to remove the port's msgs. ! 367: */ ! 368: ! 369: ip_unlock(port); ! 370: ! 371: /* check for a receiver for the message */ ! 372: ! 373: #if NORMA_IPC ! 374: if (mqueue == norma_ipc_handoff_mqueue) { ! 375: norma_ipc_handoff_msg = kmsg; ! 376: if (kmsg->ikm_header.msgh_size <= norma_ipc_handoff_max_size) { ! 377: imq_unlock(mqueue); ! 378: return MACH_MSG_SUCCESS; ! 379: } ! 380: norma_ipc_handoff_msg_size = kmsg->ikm_header.msgh_size; ! 381: } ! 382: #endif /* NORMA_IPC */ ! 383: for (;;) { ! 384: receiver = ipc_thread_queue_first(receivers); ! 385: if (receiver == ITH_NULL) { ! 386: /* no receivers; queue kmsg */ ! 387: ! 388: ipc_kmsg_enqueue_macro(&mqueue->imq_messages, kmsg); ! 389: imq_unlock(mqueue); ! 390: break; ! 391: } ! 392: ! 393: ipc_thread_rmqueue_first_macro(receivers, receiver); ! 394: assert(ipc_kmsg_queue_empty(&mqueue->imq_messages)); ! 395: ! 396: if (kmsg->ikm_header.msgh_size <= receiver->ith_msize) { ! 397: /* got a successful receiver */ ! 398: ! 399: receiver->ith_state = MACH_MSG_SUCCESS; ! 400: receiver->ith_kmsg = kmsg; ! 401: receiver->ith_seqno = port->ip_seqno++; ! 402: imq_unlock(mqueue); ! 403: ! 404: thread_go(receiver); ! 405: break; ! 406: } ! 407: ! 408: receiver->ith_state = MACH_RCV_TOO_LARGE; ! 409: receiver->ith_msize = kmsg->ikm_header.msgh_size; ! 410: thread_go(receiver); ! 411: } ! 412: } ! 413: ! 414: return MACH_MSG_SUCCESS; ! 415: } ! 416: ! 417: /* ! 418: * Routine: ipc_mqueue_copyin ! 419: * Purpose: ! 420: * Convert a name in a space to a message queue. ! 421: * Conditions: ! 422: * Nothing locked. If successful, the message queue ! 423: * is returned locked and caller gets a ref for the object. ! 424: * This ref ensures the continued existence of the queue. ! 425: * Returns: ! 426: * MACH_MSG_SUCCESS Found a message queue. ! 427: * MACH_RCV_INVALID_NAME The space is dead. ! 428: * MACH_RCV_INVALID_NAME The name doesn't denote a right. ! 429: * MACH_RCV_INVALID_NAME ! 430: * The denoted right is not receive or port set. ! 431: * MACH_RCV_IN_SET Receive right is a member of a set. ! 432: */ ! 433: ! 434: mach_msg_return_t ! 435: ipc_mqueue_copyin( ! 436: ipc_space_t space, ! 437: mach_port_t name, ! 438: ipc_mqueue_t *mqueuep, ! 439: ipc_object_t *objectp) ! 440: { ! 441: ipc_entry_t entry; ! 442: ipc_entry_bits_t bits; ! 443: ipc_object_t object; ! 444: ipc_mqueue_t mqueue; ! 445: ! 446: is_read_lock(space); ! 447: if (!space->is_active) { ! 448: is_read_unlock(space); ! 449: return MACH_RCV_INVALID_NAME; ! 450: } ! 451: ! 452: entry = ipc_entry_lookup(space, name); ! 453: if (entry == IE_NULL) { ! 454: is_read_unlock(space); ! 455: return MACH_RCV_INVALID_NAME; ! 456: } ! 457: ! 458: bits = entry->ie_bits; ! 459: object = entry->ie_object; ! 460: ! 461: if (bits & MACH_PORT_TYPE_RECEIVE) { ! 462: ipc_port_t port; ! 463: ipc_pset_t pset; ! 464: ! 465: port = (ipc_port_t) object; ! 466: assert(port != IP_NULL); ! 467: ! 468: ip_lock(port); ! 469: assert(ip_active(port)); ! 470: assert(port->ip_receiver_name == name); ! 471: assert(port->ip_receiver == space); ! 472: is_read_unlock(space); ! 473: ! 474: pset = port->ip_pset; ! 475: if (pset != IPS_NULL) { ! 476: ips_lock(pset); ! 477: if (ips_active(pset)) { ! 478: ips_unlock(pset); ! 479: ip_unlock(port); ! 480: return MACH_RCV_IN_SET; ! 481: } ! 482: ! 483: ipc_pset_remove(pset, port); ! 484: ips_check_unlock(pset); ! 485: assert(port->ip_pset == IPS_NULL); ! 486: } ! 487: ! 488: mqueue = &port->ip_messages; ! 489: } else if (bits & MACH_PORT_TYPE_PORT_SET) { ! 490: ipc_pset_t pset; ! 491: ! 492: pset = (ipc_pset_t) object; ! 493: assert(pset != IPS_NULL); ! 494: ! 495: ips_lock(pset); ! 496: assert(ips_active(pset)); ! 497: assert(pset->ips_local_name == name); ! 498: is_read_unlock(space); ! 499: ! 500: mqueue = &pset->ips_messages; ! 501: } else { ! 502: is_read_unlock(space); ! 503: return MACH_RCV_INVALID_NAME; ! 504: } ! 505: ! 506: /* ! 507: * At this point, the object is locked and active, ! 508: * the space is unlocked, and mqueue is initialized. ! 509: */ ! 510: ! 511: io_reference(object); ! 512: imq_lock(mqueue); ! 513: io_unlock(object); ! 514: ! 515: *objectp = object; ! 516: *mqueuep = mqueue; ! 517: return MACH_MSG_SUCCESS; ! 518: } ! 519: ! 520: /* ! 521: * Routine: ipc_mqueue_receive ! 522: * Purpose: ! 523: * Receive a message from a message queue. ! 524: * ! 525: * If continuation is non-zero, then we might discard ! 526: * our kernel stack when we block. We will continue ! 527: * after unblocking by executing continuation. ! 528: * ! 529: * If resume is true, then we are resuming a receive ! 530: * operation after a blocked receive discarded our stack. ! 531: * Conditions: ! 532: * The message queue is locked; it will be returned unlocked. ! 533: * ! 534: * Our caller must hold a reference for the port or port set ! 535: * to which this queue belongs, to keep the queue ! 536: * from being deallocated. Furthermore, the port or set ! 537: * must have been active when the queue was locked. ! 538: * ! 539: * The kmsg is returned with clean header fields ! 540: * and with the circular bit turned off. ! 541: * Returns: ! 542: * MACH_MSG_SUCCESS Message returned in kmsgp. ! 543: * MACH_RCV_TOO_LARGE Message size returned in kmsgp. ! 544: * MACH_RCV_TIMED_OUT No message obtained. ! 545: * MACH_RCV_INTERRUPTED No message obtained. ! 546: * MACH_RCV_PORT_DIED Port/set died; no message. ! 547: * MACH_RCV_PORT_CHANGED Port moved into set; no msg. ! 548: * ! 549: */ ! 550: ! 551: mach_msg_return_t ! 552: ipc_mqueue_receive( ! 553: ipc_mqueue_t mqueue, ! 554: mach_msg_option_t option, ! 555: mach_msg_size_t max_size, ! 556: mach_msg_timeout_t time_out, ! 557: boolean_t resume, ! 558: void (*continuation)(void), ! 559: ipc_kmsg_t *kmsgp, ! 560: mach_port_seqno_t *seqnop) ! 561: { ! 562: ipc_port_t port; ! 563: ipc_kmsg_t kmsg; ! 564: mach_port_seqno_t seqno; ! 565: ! 566: { ! 567: ipc_kmsg_queue_t kmsgs = &mqueue->imq_messages; ! 568: ipc_thread_t self = current_thread(); ! 569: ! 570: if (resume) ! 571: goto after_thread_block; ! 572: ! 573: for (;;) { ! 574: kmsg = ipc_kmsg_queue_first(kmsgs); ! 575: #if NORMA_IPC ! 576: /* ! 577: * It may be possible to make this work even when a timeout ! 578: * is specified. ! 579: * ! 580: * Netipc_replenish should be moved somewhere else. ! 581: */ ! 582: if (kmsg == IKM_NULL && ! (option & MACH_RCV_TIMEOUT)) { ! 583: netipc_replenish(FALSE); ! 584: *kmsgp = IKM_NULL; ! 585: kmsg = norma_ipc_kmsg_accept(mqueue, max_size, ! 586: (mach_msg_size_t *)kmsgp); ! 587: if (kmsg != IKM_NULL) { ! 588: port = (ipc_port_t) ! 589: kmsg->ikm_header.msgh_remote_port; ! 590: seqno = port->ip_seqno++; ! 591: break; ! 592: } ! 593: if (*kmsgp) { ! 594: imq_unlock(mqueue); ! 595: return MACH_RCV_TOO_LARGE; ! 596: } ! 597: } ! 598: #endif /* NORMA_IPC */ ! 599: if (kmsg != IKM_NULL) { ! 600: /* check space requirements */ ! 601: ! 602: if (kmsg->ikm_header.msgh_size > max_size) { ! 603: * (mach_msg_size_t *) kmsgp = ! 604: kmsg->ikm_header.msgh_size; ! 605: imq_unlock(mqueue); ! 606: return MACH_RCV_TOO_LARGE; ! 607: } ! 608: ! 609: ipc_kmsg_rmqueue_first_macro(kmsgs, kmsg); ! 610: port = (ipc_port_t) kmsg->ikm_header.msgh_remote_port; ! 611: seqno = port->ip_seqno++; ! 612: break; ! 613: } ! 614: ! 615: /* must block waiting for a message */ ! 616: ! 617: if (option & MACH_RCV_TIMEOUT) { ! 618: if (time_out == 0) { ! 619: imq_unlock(mqueue); ! 620: return MACH_RCV_TIMED_OUT; ! 621: } ! 622: ! 623: thread_will_wait_with_timeout(self, time_out); ! 624: } else ! 625: thread_will_wait(self); ! 626: ! 627: ipc_thread_enqueue_macro(&mqueue->imq_threads, self); ! 628: self->ith_state = MACH_RCV_IN_PROGRESS; ! 629: self->ith_msize = max_size; ! 630: ! 631: imq_unlock(mqueue); ! 632: if (continuation != (void (*)(void)) 0) { ! 633: counter(c_ipc_mqueue_receive_block_user++); ! 634: } else { ! 635: counter(c_ipc_mqueue_receive_block_kernel++); ! 636: } ! 637: thread_block(continuation); ! 638: after_thread_block: ! 639: imq_lock(mqueue); ! 640: ! 641: /* why did we wake up? */ ! 642: ! 643: if (self->ith_state == MACH_MSG_SUCCESS) { ! 644: /* pick up the message that was handed to us */ ! 645: ! 646: kmsg = self->ith_kmsg; ! 647: seqno = self->ith_seqno; ! 648: port = (ipc_port_t) kmsg->ikm_header.msgh_remote_port; ! 649: break; ! 650: } ! 651: ! 652: switch (self->ith_state) { ! 653: case MACH_RCV_TOO_LARGE: ! 654: /* pick up size of the too-large message */ ! 655: ! 656: * (mach_msg_size_t *) kmsgp = self->ith_msize; ! 657: /* fall-through */ ! 658: ! 659: case MACH_RCV_PORT_DIED: ! 660: case MACH_RCV_PORT_CHANGED: ! 661: /* something bad happened to the port/set */ ! 662: ! 663: imq_unlock(mqueue); ! 664: return self->ith_state; ! 665: ! 666: case MACH_RCV_IN_PROGRESS: ! 667: /* ! 668: * Awakened for other than IPC completion. ! 669: * Remove ourselves from the waiting queue, ! 670: * then check the wakeup cause. ! 671: */ ! 672: ! 673: ipc_thread_rmqueue(&mqueue->imq_threads, self); ! 674: ! 675: switch (self->ith_wait_result) { ! 676: case THREAD_INTERRUPTED: ! 677: /* receive was interrupted - give up */ ! 678: ! 679: imq_unlock(mqueue); ! 680: return MACH_RCV_INTERRUPTED; ! 681: ! 682: case THREAD_TIMED_OUT: ! 683: /* timeout expired */ ! 684: ! 685: assert(option & MACH_RCV_TIMEOUT); ! 686: time_out = 0; ! 687: break; ! 688: ! 689: case THREAD_RESTART: ! 690: default: ! 691: #if MACH_ASSERT ! 692: assert(!"ipc_mqueue_receive"); ! 693: #else ! 694: panic("ipc_mqueue_receive"); ! 695: #endif ! 696: } ! 697: break; ! 698: ! 699: default: ! 700: #if MACH_ASSERT ! 701: assert(!"ipc_mqueue_receive: strange ith_state"); ! 702: #else ! 703: panic("ipc_mqueue_receive: strange ith_state"); ! 704: #endif ! 705: } ! 706: } ! 707: ! 708: /* we have a kmsg; unlock the msg queue */ ! 709: ! 710: imq_unlock(mqueue); ! 711: assert(kmsg->ikm_header.msgh_size <= max_size); ! 712: } ! 713: ! 714: { ! 715: ipc_marequest_t marequest; ! 716: ! 717: marequest = kmsg->ikm_marequest; ! 718: if (marequest != IMAR_NULL) { ! 719: ipc_marequest_destroy(marequest); ! 720: kmsg->ikm_marequest = IMAR_NULL; ! 721: } ! 722: assert((kmsg->ikm_header.msgh_bits & MACH_MSGH_BITS_CIRCULAR) == 0); ! 723: ! 724: assert(port == (ipc_port_t) kmsg->ikm_header.msgh_remote_port); ! 725: ip_lock(port); ! 726: ! 727: if (ip_active(port)) { ! 728: ipc_thread_queue_t senders; ! 729: ipc_thread_t sender; ! 730: ! 731: assert(port->ip_msgcount > 0); ! 732: port->ip_msgcount--; ! 733: ! 734: senders = &port->ip_blocked; ! 735: sender = ipc_thread_queue_first(senders); ! 736: ! 737: if ((sender != ITH_NULL) && ! 738: (port->ip_msgcount < port->ip_qlimit)) { ! 739: ipc_thread_rmqueue(senders, sender); ! 740: sender->ith_state = MACH_MSG_SUCCESS; ! 741: thread_go(sender); ! 742: } ! 743: } ! 744: ! 745: ip_unlock(port); ! 746: } ! 747: ! 748: #if NORMA_IPC ! 749: norma_ipc_finish_receiving(&kmsg); ! 750: #endif /* NORMA_IPC */ ! 751: *kmsgp = kmsg; ! 752: *seqnop = seqno; ! 753: return MACH_MSG_SUCCESS; ! 754: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.