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