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