![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to msg.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / kernel / io.386|
Return to msg.c CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / io.386 |
1.1 ! root 1: /* ! 2: * System V Compatible Messaging ! 3: * ! 4: * This module provides System V compatible messaging operations. ! 5: * ! 6: * Author: Allan Cornish. ! 7: */ ! 8: ! 9: #include <sys/coherent.h> ! 10: #include <sys/sched.h> ! 11: #include <sys/types.h> ! 12: #include <sys/uproc.h> ! 13: #include <errno.h> ! 14: #include <sys/stat.h> ! 15: #include <sys/con.h> ! 16: #include <sys/seg.h> ! 17: #include <sys/msg.h> ! 18: #include <stdlib.h> ! 19: ! 20: #ifndef EIDRM ! 21: #define EIDRM EDOM ! 22: #endif ! 23: ! 24: /* ! 25: * Extended message queue id data structure. ! 26: * - extended to support System V.3 compatible polls. ! 27: */ ! 28: struct xmsqid_ds { ! 29: struct msqid_ds msq; ! 30: struct event ipolls; ! 31: struct event opolls; ! 32: }; ! 33: ! 34: /* ! 35: * Message Information ! 36: */ ! 37: ! 38: struct xmsqid_ds *msqs = 0; /* Pointer to array of message queues */ ! 39: /* (first queue contains free message list) */ ! 40: ! 41: struct msg * msgs = 0; /* Pointer to array of message headers */ ! 42: ! 43: #ifdef _I386 ! 44: char *msgsp; ! 45: #else ! 46: static SEG * msgsp; ! 47: #define msgsel FP_SEL(msgsp->s_faddr) ! 48: #endif ! 49: ! 50: /* ! 51: * Global Message Parameters ! 52: */ ! 53: ! 54: unsigned NMSQID = 9; /* allocated number of message queues */ ! 55: unsigned NMSQB = 2048; /* default maximum queue size in bytes */ ! 56: unsigned NMSG = 10; /* allocated messages: (NMSG * NMSC) < 2^16 */ ! 57: unsigned NMSC = 640; /* maximum message text size */ ! 58: ! 59: ! 60: /* ! 61: * Message Device Initialization. ! 62: * ! 63: * Initialize message ids. ! 64: */ ! 65: ! 66: msginit() ! 67: { ! 68: register struct xmsqid_ds *qp; ! 69: register struct msg *mp; ! 70: long wanted; ! 71: int i; ! 72: ! 73: if ( NMSG == 0 ) ! 74: NMSQID = 0; ! 75: if ( NMSC == 0 ) ! 76: NMSQID = 0; ! 77: if ( NMSQID == 0 ) ! 78: return 0; ! 79: ! 80: if ( NMSQID > 128 ) ! 81: NMSQID = 128; ! 82: ! 83: /* ! 84: * Allocate message queues and message headers. ! 85: */ ! 86: wanted = (NMSQID * (long) sizeof(struct xmsqid_ds)) + ! 87: (NMSG * (long) sizeof(struct msg)); ! 88: if (wanted > 16384) { ! 89: printf("invalid NMSQID or NMSG kernel variable\n"); ! 90: NMSQID=0; ! 91: return; ! 92: } ! 93: ! 94: /* allocate memory for the headers, msqs points to headers */ ! 95: ! 96: if ( msqs = kalloc( (unsigned) wanted) ) { ! 97: ! 98: /* ! 99: * Ensure allocated space is cleared. ! 100: */ ! 101: #ifndef _I386 ! 102: memset( msqs, 0, (unsigned) wanted ); ! 103: #else ! 104: kclear(msqs, (size_t) wanted); ! 105: #endif ! 106: /* ! 107: * Message headers are contiguous to message queues. ! 108: */ ! 109: msgs = (struct msg *) (&msqs[NMSQID]); /* msgs points to ! 110: * LAST header. ! 111: */ ! 112: /* ! 113: * Allocate message buffers. ! 114: */ ! 115: wanted = (long) NMSG * NMSC; ! 116: ! 117: if ( wanted > 0xFFFFL ) { ! 118: printf("invalid NMSG or NMSC kernel variable\n"); ! 119: kfree( msqs ); ! 120: NMSQID = 0; ! 121: msqs = 0; ! 122: return; ! 123: } ! 124: ! 125: #ifdef _I386 ! 126: msgsp = kalloc( (size_t) wanted ); ! 127: #else ! 128: msgsp = salloc( (size_t) wanted, SFHIGH|SFNSWP|SFNCLR); ! 129: #endif ! 130: if ( msgsp == 0 ) { ! 131: printf("could not kalloc %u messages\n", NMSG); ! 132: kfree( msqs ); ! 133: NMSQID = 0; ! 134: msqs = 0; ! 135: return; ! 136: } ! 137: ! 138: kclear(msgsp, (size_t) wanted); ! 139: ! 140: /* ! 141: * Initialize message queues. ! 142: */ ! 143: for ( qp = msqs, i = 0; i < NMSQID; i++, qp++ ) { ! 144: ! 145: qp->msq.msg_perm.seq = i * 256; ! 146: ! 147: qp->ipolls.e_dnext = ! 148: qp->ipolls.e_dlast = &qp->ipolls; ! 149: ! 150: qp->opolls.e_dnext = ! 151: qp->opolls.e_dlast = &qp->opolls; ! 152: } ! 153: ! 154: /* ! 155: * Initialize message headers, place on free queue. ! 156: */ ! 157: for ( qp = msqs, mp = &msgs[NMSG]; --mp >= msgs; ) { ! 158: wanted -= NMSC; /* offset for message text */ ! 159: mp->msg_spot = wanted; ! 160: mp->msg_next = qp->msq.msg_first; ! 161: qp->msq.msg_first = mp; ! 162: } ! 163: } ! 164: else { ! 165: printf("could not kalloc %u message ids\n", NMSQID); ! 166: NMSQID = 0; ! 167: } ! 168: ! 169: } ! 170: ! 171: ! 172: /* ! 173: * Msgctl - Message Control Operations. ! 174: */ ! 175: ! 176: umsgctl( qid, cmd, buf ) ! 177: ! 178: int qid; ! 179: int cmd; ! 180: struct msqid_ds *buf; ! 181: ! 182: { ! 183: register struct xmsqid_ds *qp; ! 184: register struct msg *mp; ! 185: unsigned n; ! 186: ! 187: /* ! 188: * Validate queue identifier. ! 189: */ ! 190: if ( (qid <= 0) || (qid/256 >= NMSQID) || (msqs == 0) ) { ! 191: u.u_error = EINVAL; ! 192: return -1; ! 193: } ! 194: ! 195: qp = &msqs[ qid / 256 ]; ! 196: ! 197: /* ! 198: * Validate queue existence. ! 199: */ ! 200: if ( (qp == 0) || ((qp->msq.msg_perm.mode & IPC_ALLOC) == 0) ) { ! 201: u.u_error = EINVAL; ! 202: return -1; ! 203: } ! 204: ! 205: /* ! 206: * Validate qid for all commands except for IPC_STAT. ! 207: */ ! 208: if ( (cmd != IPC_STAT) && (qp->msq.msg_perm.seq != qid) ) { ! 209: u.u_error = EINVAL; ! 210: return -1; ! 211: } ! 212: ! 213: switch ( cmd ) { ! 214: ! 215: case IPC_STAT: ! 216: /* ! 217: * Validate access authority. ! 218: */ ! 219: if ( (ipcaccess(&qp->msq.msg_perm) & MSG_R) == 0 ) { ! 220: u.u_error = EACCES; ! 221: break; ! 222: } ! 223: ! 224: /* ! 225: * Copy queue info to user. ! 226: */ ! 227: kucopy( qp, buf, sizeof(struct msqid_ds) ); ! 228: ! 229: /* ! 230: * Include input polls in receive waiting. ! 231: */ ! 232: if ( (qp->ipolls.e_dnext != NULL) ! 233: && (qp->ipolls.e_dnext != &qp->ipolls) ) { ! 234: putuwd( &buf->msg_perm.mode, ! 235: getuwd( &buf->msg_perm.mode ) | MSG_RWAIT ); ! 236: } ! 237: ! 238: /* ! 239: * Include output polls in write waiting. ! 240: */ ! 241: if ( (qp->opolls.e_dnext != NULL) ! 242: && (qp->opolls.e_dnext != &qp->opolls) ) { ! 243: putuwd( &buf->msg_perm.mode, ! 244: getuwd( &buf->msg_perm.mode ) | MSG_WWAIT ); ! 245: } ! 246: ! 247: /* ! 248: * Validate qid. ! 249: * Doing it now lets user get info on message queue. ! 250: */ ! 251: if ( qp->msq.msg_perm.seq != qid ) ! 252: u.u_error = EINVAL; ! 253: break; ! 254: ! 255: case IPC_SET: ! 256: /* ! 257: * Validate modify authority. ! 258: */ ! 259: if ( (u.u_uid != 0) && (u.u_uid != qp->msq.msg_perm.uid) ) { ! 260: u.u_error = EPERM; ! 261: break; ! 262: } ! 263: ! 264: /* ! 265: * Get desired queue size. ! 266: */ ! 267: n = getuwd( &(buf->msg_qbytes) ); ! 268: if (u.u_error) ! 269: break; ! 270: ! 271: /* ! 272: * Only super-user can increase queue size. ! 273: */ ! 274: if ( (u.u_uid != 0) && (n > qp->msq.msg_qbytes) ) { ! 275: u.u_error = EPERM; ! 276: break; ! 277: } ! 278: ! 279: /* ! 280: * Set queue parameters. ! 281: */ ! 282: qp->msq.msg_perm.uid = getuwd( &(buf->msg_perm.uid ) ); ! 283: qp->msq.msg_perm.gid = getuwd( &(buf->msg_perm.gid ) ); ! 284: qp->msq.msg_perm.mode &= ~0777; ! 285: qp->msq.msg_perm.mode |= getuwd( &(buf->msg_perm.mode) ) & 0777; ! 286: qp->msq.msg_qbytes = n; ! 287: break; ! 288: ! 289: case IPC_RMID: ! 290: /* ! 291: * Validate removal authority. ! 292: */ ! 293: if ( (u.u_uid != 0) && (u.u_uid != qp->msq.msg_perm.uid) ) { ! 294: u.u_error = EPERM; ! 295: break; ! 296: } ! 297: /* ! 298: * Free all messages on the queue being removed. ! 299: */ ! 300: while ( mp = qp->msq.msg_first ) { ! 301: qp->msq.msg_first = mp->msg_next; ! 302: mp->msg_next = msqs->msq.msg_first; ! 303: msqs->msq.msg_first = mp; ! 304: } ! 305: ! 306: /* ! 307: * Wakeup processes waiting for free message buffers. ! 308: */ ! 309: if ( msqs->msq.msg_perm.mode & MSG_RWAIT ) { ! 310: msqs->msq.msg_perm.mode &= ~MSG_RWAIT; ! 311: wakeup( msqs ); ! 312: } ! 313: if ( msqs->ipolls.e_procp ) ! 314: pollwake( &msqs->ipolls ); ! 315: ! 316: /* ! 317: * Initialize queue parameters. ! 318: */ ! 319: qp->msq.msg_last = 0; ! 320: qp->msq.msg_qnum = 0; ! 321: qp->msq.msg_cbytes = 0; ! 322: if ( (qp->msq.msg_perm.seq & 0x00FF) == 0x00FF ) ! 323: qp->msq.msg_perm.seq &= 0x7F00; ! 324: qp->msq.msg_perm.seq++; ! 325: ! 326: ! 327: /* ! 328: * Wakeup processes sleeping on the removed message queue. ! 329: */ ! 330: if ( qp->msq.msg_perm.mode & (MSG_RWAIT|MSG_WWAIT) ) ! 331: wakeup( qp ); ! 332: if ( qp->ipolls.e_procp ) ! 333: pollwake( &qp->ipolls ); ! 334: if ( qp->opolls.e_procp ) ! 335: pollwake( &qp->opolls ); ! 336: ! 337: qp->msq.msg_perm.mode = 0; ! 338: break; ! 339: ! 340: default: ! 341: u.u_error = EINVAL; ! 342: } ! 343: ! 344: if ( u.u_error ) ! 345: return -1; ! 346: ! 347: return 0; ! 348: } ! 349: ! 350: /* ! 351: * Msgget - Get set of messages ! 352: */ ! 353: ! 354: umsgget( mykey, msgflg ) ! 355: ! 356: key_t mykey; ! 357: int msgflg; ! 358: ! 359: { ! 360: register struct xmsqid_ds *qp; ! 361: register struct xmsqid_ds *freeidp = 0; ! 362: int rwmode; ! 363: ! 364: if ( msqs == 0 ) { ! 365: ! 366: msginit(); ! 367: ! 368: if ( msqs == 0 ) { ! 369: u.u_error = ENOMEM; ! 370: return; ! 371: } ! 372: } ! 373: ! 374: /* ! 375: * Extract desired access mode from flags. ! 376: */ ! 377: rwmode = msgflg & 0777; ! 378: ! 379: /* ! 380: * Search for desired message queue [also for first free queue]. ! 381: */ ! 382: for ( qp = &msqs[NMSQID]; --qp > msqs; ) { ! 383: ! 384: if ( (qp->msq.msg_perm.mode & IPC_ALLOC) == 0 ) { ! 385: ! 386: if ((freeidp == 0) || ! 387: (freeidp->msq.msg_ctime > qp->msq.msg_ctime)) ! 388: freeidp = qp; ! 389: continue; ! 390: } ! 391: ! 392: if (mykey == IPC_PRIVATE) ! 393: continue; ! 394: ! 395: if ( mykey == qp->msq.msg_perm.key ) { /* found! */ ! 396: ! 397: if ( (msgflg & IPC_CREAT) && (msgflg & IPC_EXCL) ) { ! 398: u.u_error = EEXIST; ! 399: return -1; ! 400: } ! 401: ! 402: if ( (qp->msq.msg_perm.mode & rwmode) != rwmode ) { ! 403: u.u_error = EACCES; ! 404: return -1; ! 405: } ! 406: ! 407: return qp->msq.msg_perm.seq; ! 408: } ! 409: } ! 410: ! 411: if ( ! (msgflg & IPC_CREAT) ) { ! 412: u.u_error = ENOENT; ! 413: return -1; ! 414: } ! 415: ! 416: if ( (qp = freeidp) == 0 ) { ! 417: u.u_error = ENOSPC; ! 418: return -1; ! 419: } ! 420: ! 421: qp->msq.msg_first = 0; ! 422: qp->msq.msg_last = 0; ! 423: qp->msq.msg_cbytes = 0; ! 424: qp->msq.msg_qnum = 0; ! 425: qp->msq.msg_qbytes = NMSQB; ! 426: qp->msq.msg_lspid = 0; ! 427: qp->msq.msg_lrpid = 0; ! 428: qp->msq.msg_stime = 0; ! 429: qp->msq.msg_rtime = 0; ! 430: qp->msq.msg_ctime = timer.t_time; ! 431: ! 432: qp->msq.msg_perm.cuid = qp->msq.msg_perm.uid = u.u_uid; ! 433: qp->msq.msg_perm.cgid = qp->msq.msg_perm.gid = u.u_gid; ! 434: qp->msq.msg_perm.mode = rwmode | IPC_ALLOC; ! 435: qp->msq.msg_perm.key = mykey; ! 436: ! 437: return qp->msq.msg_perm.seq; ! 438: } ! 439: ! 440: /* ! 441: * Send a Message ! 442: */ ! 443: ! 444: umsgsnd( qid, bufp, msgsz, msgflg ) ! 445: int qid; ! 446: struct msgbuf *bufp; ! 447: int msgsz, msgflg; ! 448: ! 449: { ! 450: register struct xmsqid_ds * qp; ! 451: register struct msg * mp; ! 452: ! 453: /* ! 454: * Validate queue identifier. ! 455: */ ! 456: ! 457: ! 458: if ((qid <= 0) || (qid/256 >= NMSQID) || (msgsz > NMSC) || (msqs==0)) { ! 459: u.u_error = EINVAL; ! 460: return -1; ! 461: } ! 462: ! 463: qp = &msqs[ qid / 256 ]; ! 464: ! 465: /* ! 466: * Validate queue existence. ! 467: */ ! 468: if ( (qp->msq.msg_perm.seq != qid) ! 469: || ((qp->msq.msg_perm.mode & IPC_ALLOC) == 0) ) { ! 470: u.u_error = EINVAL; ! 471: return -1; ! 472: } ! 473: ! 474: if ((ipcaccess(&qp->msq.msg_perm) & MSG_W) == 0){ /* can't send mesg */ ! 475: u.u_error = EACCES; ! 476: return -1; ! 477: } ! 478: ! 479: /* ! 480: * Wait for a free message buffer ! 481: */ ! 482: ! 483: while ( (msqs->msq.msg_first == 0) ! 484: || (qp->msq.msg_qbytes <= qp->msq.msg_cbytes)) { ! 485: ! 486: if ( msgflg & IPC_NOWAIT ) { ! 487: u.u_error = EAGAIN; ! 488: return -1; ! 489: } ! 490: ! 491: if (qp->msq.msg_qbytes <= qp->msq.msg_cbytes) { ! 492: qp->msq.msg_perm.mode |= MSG_WWAIT; ! 493: sleep( qp, CVTTOUT, IVTTOUT, SVTTOUT ); ! 494: } ! 495: else { ! 496: msqs->msq.msg_perm.mode |= MSG_RWAIT; ! 497: sleep( msqs, CVTTOUT, IVTTOUT, SVTTOUT ); ! 498: } ! 499: ! 500: /* ! 501: * Abort if a signal was received ! 502: */ ! 503: if (SELF->p_ssig && nondsig() ) { ! 504: u.u_error = EINTR; ! 505: return -1; ! 506: } ! 507: ! 508: /* ! 509: * Abort if the message queue was removed. ! 510: */ ! 511: if ( qid != qp->msq.msg_perm.seq ) { ! 512: u.u_error = EIDRM; ! 513: return -1; ! 514: } ! 515: } ! 516: ! 517: /* ! 518: * Use first message on free message queue ! 519: */ ! 520: mp = msqs->msq.msg_first; ! 521: mp->msg_ts = msgsz; ! 522: ! 523: /* ! 524: * Transfer the message type and text. ! 525: */ ! 526: ! 527: ukcopy( &(bufp->mtype), &(mp->msg_type), sizeof(mp->msg_type) ); ! 528: #ifdef _I386 ! 529: if ( ukcopy( &bufp->mtext[0],(msgsp + mp->msg_spot), msgsz ) != msgsz ) ! 530: #else ! 531: if ( ufcopy( &bufp->mtext[0],mp->msg_spot, msgsel, msgsz ) != msgsz ) ! 532: #endif ! 533: u.u_error = EFAULT; ! 534: ! 535: /* ! 536: * Abort if address fault occured during transfer. ! 537: */ ! 538: if ( u.u_error ) ! 539: return -1; ! 540: ! 541: /* ! 542: * Move the message to the desired queue. ! 543: */ ! 544: ! 545: ! 546: msqs->msq.msg_first = mp->msg_next; ! 547: mp->msg_next = 0; ! 548: ! 549: if ( qp->msq.msg_last ) ! 550: qp->msq.msg_last->msg_next = mp; ! 551: else ! 552: qp->msq.msg_first = mp; ! 553: qp->msq.msg_last = mp; ! 554: ! 555: /* ! 556: * Update queue statistics. ! 557: */ ! 558: ! 559: qp->msq.msg_cbytes += msgsz; ! 560: qp->msq.msg_qnum++; ! 561: qp->msq.msg_lspid = SELF->p_pid; ! 562: qp->msq.msg_stime = timer.t_time; ! 563: ! 564: /* ! 565: * Wake processes waiting to receive. ! 566: */ ! 567: ! 568: ! 569: if ( qp->msq.msg_perm.mode & MSG_RWAIT ) { ! 570: qp->msq.msg_perm.mode &= ~MSG_RWAIT; ! 571: wakeup( qp ); ! 572: } ! 573: if ( qp->ipolls.e_procp ) ! 574: pollwake( &qp->ipolls ); ! 575: ! 576: return 0; ! 577: } ! 578: ! 579: /* ! 580: * Receive A Message ! 581: */ ! 582: ! 583: umsgrcv( qid, bufp, msgsz, msgtyp, msgflg ) ! 584: ! 585: int qid; ! 586: struct msgbuf *bufp; ! 587: int msgsz; ! 588: long msgtyp; ! 589: int msgflg; ! 590: ! 591: { ! 592: register struct xmsqid_ds *qp; ! 593: register struct msg *mp; ! 594: register struct msg *prev; ! 595: ! 596: ! 597: /* ! 598: * Validate queue identifier. ! 599: */ ! 600: ! 601: if ( (qid <= 0) || (qid/256 >= NMSQID) || (msqs == 0) ) { ! 602: u.u_error = EINVAL; ! 603: return -1; ! 604: } ! 605: ! 606: qp = &msqs[ qid / 256 ]; ! 607: ! 608: /* ! 609: * Validate queue existence. ! 610: */ ! 611: if ( (qp->msq.msg_perm.seq != qid) ! 612: || ((qp->msq.msg_perm.mode & IPC_ALLOC) == 0) ) { ! 613: u.u_error = EINVAL; ! 614: return -1; ! 615: } ! 616: ! 617: /* ! 618: * Permission denied ! 619: */ ! 620: if ( (ipcaccess(&qp->msq.msg_perm) & MSG_R) == 0 ) { ! 621: u.u_error = EACCES; ! 622: return -1; ! 623: } ! 624: ! 625: /* ! 626: * Wait for message ! 627: */ ! 628: for (;;) { ! 629: ! 630: mp = qp->msq.msg_first; ! 631: prev = 0; ! 632: ! 633: /* ! 634: * Find mesg of type <= abs(msgtyp) ! 635: */ ! 636: ! 637: if ( msgtyp < 0 ) { ! 638: ! 639: struct msg *xp, *xprev; ! 640: ! 641: xp = 0; ! 642: xprev = 0; ! 643: msgtyp = -msgtyp; ! 644: ! 645: for ( ; mp != 0 ; prev = mp, mp = mp->msg_next ) { ! 646: ! 647: if (mp->msg_type > msgtyp) ! 648: continue; ! 649: ! 650: if ((xp==0) || (mp->msg_type < xp->msg_type)) { ! 651: xp = mp; ! 652: xprev = prev; ! 653: } ! 654: } ! 655: mp = xp; ! 656: prev = xprev; ! 657: msgtyp = -msgtyp; ! 658: } ! 659: ! 660: /* ! 661: * Find message of type == msgtyp ! 662: */ ! 663: else if ( msgtyp > 0 ) { ! 664: ! 665: while ( (mp != 0) && (mp->msg_type != msgtyp) ) { ! 666: prev = mp; ! 667: mp = mp->msg_next; ! 668: } ! 669: } ! 670: ! 671: /* ! 672: * Else take first message ! 673: */ ! 674: ! 675: if ( mp ) ! 676: break; ! 677: ! 678: /* ! 679: * Can't wait to receive mesg ! 680: */ ! 681: if ( msgflg & IPC_NOWAIT ) { ! 682: u.u_error = EAGAIN; ! 683: return -1; ! 684: } ! 685: ! 686: qp->msq.msg_perm.mode |= MSG_RWAIT; ! 687: sleep( qp, CVTTOUT, IVTTOUT, SVTTOUT ); ! 688: ! 689: /* ! 690: * Signal received ! 691: */ ! 692: if ( SELF->p_ssig && nondsig() ) { ! 693: u.u_error = EINTR; ! 694: return -1; ! 695: } ! 696: ! 697: /* ! 698: * Not same q anymore ! 699: */ ! 700: if ( qid != qp->msq.msg_perm.seq ) { ! 701: u.u_error = EIDRM; ! 702: return -1; ! 703: } ! 704: } ! 705: ! 706: /* ! 707: * Ensure entire message can be transferred, or MSG_NOERROR asserted. ! 708: */ ! 709: ! 710: if ( (msgsz < mp->msg_ts) && ((msgflg & MSG_NOERROR) == 0) ) { ! 711: u.u_error = E2BIG; ! 712: return -1; ! 713: } ! 714: ! 715: /* ! 716: * Transfer message data ! 717: */ ! 718: if ( msgsz > mp->msg_ts ) ! 719: msgsz = mp->msg_ts; ! 720: ! 721: kucopy( &(mp->msg_type), &(bufp->mtype), sizeof(mp->msg_type) ); ! 722: #ifdef _I386 ! 723: if (kucopy( (msgsp + mp->msg_spot), &(bufp->mtext[0]), msgsz ) != msgsz) ! 724: #else ! 725: if (fucopy( mp->msg_spot, msgsel, &(bufp->mtext[0]), msgsz ) != msgsz) ! 726: #endif ! 727: u.u_error = EFAULT; ! 728: ! 729: /* ! 730: * Abort if address fault occurred during transfer. ! 731: */ ! 732: if ( u.u_error ) ! 733: return -1; ! 734: ! 735: /* ! 736: * Remove message from queue ! 737: */ ! 738: if ( prev ) ! 739: prev->msg_next = mp->msg_next; ! 740: else ! 741: qp->msq.msg_first = mp->msg_next; ! 742: ! 743: if ( qp->msq.msg_last == mp ) ! 744: qp->msq.msg_last = prev; ! 745: ! 746: ! 747: /* ! 748: * Update queue statistics ! 749: */ ! 750: qp->msq.msg_cbytes -= mp->msg_ts; ! 751: qp->msq.msg_qnum--; ! 752: qp->msq.msg_lrpid = SELF->p_pid; ! 753: qp->msq.msg_rtime = timer.t_time; ! 754: ! 755: /* ! 756: * Wakeup processes waiting to send. ! 757: */ ! 758: ! 759: if (qp->msq.msg_perm.mode & MSG_WWAIT) { ! 760: qp->msq.msg_perm.mode &= ~MSG_WWAIT; ! 761: wakeup( qp ); ! 762: } ! 763: if ( qp->opolls.e_procp ) ! 764: pollwake( &qp->opolls ); ! 765: ! 766: ! 767: /* ! 768: * Place message buffer on free message queue ! 769: */ ! 770: qp = msqs; ! 771: mp->msg_next = qp->msq.msg_first; ! 772: qp->msq.msg_first = mp; ! 773: ! 774: /* ! 775: * Wakeup processes waiting for empty message buffer ! 776: */ ! 777: if ( qp->msq.msg_perm.mode & MSG_RWAIT ) { ! 778: qp->msq.msg_perm.mode &= ~MSG_RWAIT; ! 779: wakeup( qp ); ! 780: } ! 781: if ( msqs->ipolls.e_procp ) ! 782: pollwake( &msqs->ipolls ); ! 783: ! 784: ! 785: return msgsz; ! 786: } ! 787: ! 788: /* ! 789: * Msgpoll - Message Queue Polling. ! 790: */ ! 791: msgpoll( qid, ev, msec ) ! 792: int qid; ! 793: int ev; ! 794: int msec; ! 795: { ! 796: register struct xmsqid_ds * qp; ! 797: ! 798: /* ! 799: * Validate queue identifier. ! 800: */ ! 801: if ( (qid <= 0) || (qid/256 >= NMSQID) || (msqs == 0) ) ! 802: return POLLNVAL; ! 803: ! 804: qp = &msqs[ qid / 256 ]; ! 805: ! 806: /* ! 807: * Validate queue existence. ! 808: */ ! 809: if ( ((qp->msq.msg_perm.mode & IPC_ALLOC) == 0) ! 810: || (qp->msq.msg_perm.seq != qid) ) ! 811: return POLLHUP; ! 812: ! 813: /* ! 814: * Priority polls not supported. ! 815: */ ! 816: ev &= ~POLLPRI; ! 817: ! 818: /* ! 819: * Input poll. ! 820: */ ! 821: if ( ev & POLLIN ) { ! 822: ! 823: /* ! 824: * No messages on queue. ! 825: */ ! 826: if ( qp->msq.msg_qnum == 0 ) { ! 827: /* ! 828: * Enable input monitor. ! 829: */ ! 830: if ( msec != 0 ) ! 831: pollopen( &qp->ipolls ); ! 832: ev &= ~POLLIN; ! 833: } ! 834: ! 835: /* ! 836: * Prevent output monitor. ! 837: */ ! 838: else ! 839: msec = 0; ! 840: } ! 841: ! 842: /* ! 843: * Output poll. ! 844: */ ! 845: if ( ev & POLLOUT ) { ! 846: ! 847: /* ! 848: * Queue full. ! 849: */ ! 850: if ( qp->msq.msg_cbytes >= qp->msq.msg_qbytes ) { ! 851: if ( msec != 0 ) ! 852: pollopen( &qp->opolls ); ! 853: ev &= ~POLLOUT; ! 854: } ! 855: ! 856: /* ! 857: * No free message buffers. ! 858: */ ! 859: else if ( msqs->msq.msg_first == NULL ) { ! 860: if ( msec != 0 ) ! 861: pollopen( &msqs->ipolls ); ! 862: ev &= ~POLLOUT; ! 863: } ! 864: } ! 865: ! 866: return ev; ! 867: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.