![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sysv_msg.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / kern|
Return to sysv_msg.c CVS log | Up to [Apple XNU] / XNU / bsd / kern |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * Implementation of SVID messages
24: *
25: * Author: Daniel Boulet
26: *
27: * Copyright 1993 Daniel Boulet and RTMX Inc.
28: *
29: * This system call was implemented by Daniel Boulet under contract from RTMX.
30: *
31: * Redistribution and use in source forms, with and without modification,
32: * are permitted provided that this entire comment appears intact.
33: *
34: * Redistribution in binary form may occur without any restrictions.
35: * Obviously, it would be nice if you gave credit where credit is due
36: * but requiring it would be too onerous.
37: *
38: * This software is provided ``AS IS'' without any warranties of any kind.
39: */
40:
41: #include <sys/param.h>
42: #include <sys/systm.h>
43: #include <sys/sysproto.h>
44: #include <sys/kernel.h>
45: #include <sys/proc.h>
46: #include <sys/msg.h>
47: #include <sys/sysent.h>
48:
49: static void msginit __P((void *));
50: SYSINIT(sysv_msg, SI_SUB_SYSV_MSG, SI_ORDER_FIRST, msginit, NULL)
51:
52: #define MSG_DEBUG
53: #undef MSG_DEBUG_OK
54:
55: #ifndef _SYS_SYSPROTO_H_
56: struct msgctl_args;
57: int msgctl __P((struct proc *p, struct msgctl_args *uap));
58: struct msgget_args;
59: int msgget __P((struct proc *p, struct msgget_args *uap));
60: struct msgsnd_args;
61: int msgsnd __P((struct proc *p, struct msgsnd_args *uap));
62: struct msgrcv_args;
63: int msgrcv __P((struct proc *p, struct msgrcv_args *uap));
64: #endif
65: static void msg_freehdr __P((struct msg *msghdr));
66:
67: /* XXX casting to (sy_call_t *) is bogus, as usual. */
68: static sy_call_t *msgcalls[] = {
69: (sy_call_t *)msgctl, (sy_call_t *)msgget,
70: (sy_call_t *)msgsnd, (sy_call_t *)msgrcv
71: };
72:
73: static int nfree_msgmaps; /* # of free map entries */
74: static short free_msgmaps; /* head of linked list of free map entries */
75: static struct msg *free_msghdrs; /* list of free msg headers */
76: char *msgpool; /* MSGMAX byte long msg buffer pool */
77: struct msgmap *msgmaps; /* MSGSEG msgmap structures */
78: struct msg *msghdrs; /* MSGTQL msg headers */
79: struct msqid_ds *msqids; /* MSGMNI msqid_ds struct's */
80:
81: void
82: msginit(dummy)
83: void *dummy;
84: {
85: register int i;
86:
87: /*
88: * msginfo.msgssz should be a power of two for efficiency reasons.
89: * It is also pretty silly if msginfo.msgssz is less than 8
90: * or greater than about 256 so ...
91: */
92:
93: i = 8;
94: while (i < 1024 && i != msginfo.msgssz)
95: i <<= 1;
96: if (i != msginfo.msgssz) {
97: printf("msginfo.msgssz=%d (0x%x)\n", msginfo.msgssz,
98: msginfo.msgssz);
99: panic("msginfo.msgssz not a small power of 2");
100: }
101:
102: if (msginfo.msgseg > 32767) {
103: printf("msginfo.msgseg=%d\n", msginfo.msgseg);
104: panic("msginfo.msgseg > 32767");
105: }
106:
107: if (msgmaps == NULL)
108: panic("msgmaps is NULL");
109:
110: for (i = 0; i < msginfo.msgseg; i++) {
111: if (i > 0)
112: msgmaps[i-1].next = i;
113: msgmaps[i].next = -1; /* implies entry is available */
114: }
115: free_msgmaps = 0;
116: nfree_msgmaps = msginfo.msgseg;
117:
118: if (msghdrs == NULL)
119: panic("msghdrs is NULL");
120:
121: for (i = 0; i < msginfo.msgtql; i++) {
122: msghdrs[i].msg_type = 0;
123: if (i > 0)
124: msghdrs[i-1].msg_next = &msghdrs[i];
125: msghdrs[i].msg_next = NULL;
126: }
127: free_msghdrs = &msghdrs[0];
128:
129: if (msqids == NULL)
130: panic("msqids is NULL");
131:
132: for (i = 0; i < msginfo.msgmni; i++) {
133: msqids[i].msg_qbytes = 0; /* implies entry is available */
134: msqids[i].msg_perm.seq = 0; /* reset to a known value */
135: }
136: }
137:
138: /*
139: * Entry point for all MSG calls
140: */
141: int
142: msgsys(p, uap)
143: struct proc *p;
144: /* XXX actually varargs. */
145: struct msgsys_args /* {
146: u_int which;
147: int a2;
148: int a3;
149: int a4;
150: int a5;
151: int a6;
152: } */ *uap;
153: {
154:
155: if (uap->which >= sizeof(msgcalls)/sizeof(msgcalls[0]))
156: return (EINVAL);
157: return ((*msgcalls[uap->which])(p, &uap->a2));
158: }
159:
160: static void
161: msg_freehdr(msghdr)
162: struct msg *msghdr;
163: {
164: while (msghdr->msg_ts > 0) {
165: short next;
166: if (msghdr->msg_spot < 0 || msghdr->msg_spot >= msginfo.msgseg)
167: panic("msghdr->msg_spot out of range");
168: next = msgmaps[msghdr->msg_spot].next;
169: msgmaps[msghdr->msg_spot].next = free_msgmaps;
170: free_msgmaps = msghdr->msg_spot;
171: nfree_msgmaps++;
172: msghdr->msg_spot = next;
173: if (msghdr->msg_ts >= msginfo.msgssz)
174: msghdr->msg_ts -= msginfo.msgssz;
175: else
176: msghdr->msg_ts = 0;
177: }
178: if (msghdr->msg_spot != -1)
179: panic("msghdr->msg_spot != -1");
180: msghdr->msg_next = free_msghdrs;
181: free_msghdrs = msghdr;
182: }
183:
184: #ifndef _SYS_SYSPROTO_H_
185: struct msgctl_args {
186: int msqid;
187: int cmd;
188: struct msqid_ds *buf;
189: };
190: #endif
191:
192: int
193: msgctl(p, uap)
194: struct proc *p;
195: register struct msgctl_args *uap;
196: {
197: int msqid = uap->msqid;
198: int cmd = uap->cmd;
199: struct msqid_ds *user_msqptr = uap->buf;
200: struct ucred *cred = p->p_ucred;
201: int rval, eval;
202: struct msqid_ds msqbuf;
203: register struct msqid_ds *msqptr;
204:
205: #ifdef MSG_DEBUG_OK
206: printf("call to msgctl(%d, %d, 0x%x)\n", msqid, cmd, user_msqptr);
207: #endif
208:
209: msqid = IPCID_TO_IX(msqid);
210:
211: if (msqid < 0 || msqid >= msginfo.msgmni) {
212: #ifdef MSG_DEBUG_OK
213: printf("msqid (%d) out of range (0<=msqid<%d)\n", msqid,
214: msginfo.msgmni);
215: #endif
216: return(EINVAL);
217: }
218:
219: msqptr = &msqids[msqid];
220:
221: if (msqptr->msg_qbytes == 0) {
222: #ifdef MSG_DEBUG_OK
223: printf("no such msqid\n");
224: #endif
225: return(EINVAL);
226: }
227: if (msqptr->msg_perm.seq != IPCID_TO_SEQ(uap->msqid)) {
228: #ifdef MSG_DEBUG_OK
229: printf("wrong sequence number\n");
230: #endif
231: return(EINVAL);
232: }
233:
234: eval = 0;
235: rval = 0;
236:
237: switch (cmd) {
238:
239: case IPC_RMID:
240: {
241: struct msg *msghdr;
242: if ((eval = ipcperm(cred, &msqptr->msg_perm, IPC_M)))
243: return(eval);
244: /* Free the message headers */
245: msghdr = msqptr->msg_first;
246: while (msghdr != NULL) {
247: struct msg *msghdr_tmp;
248:
249: /* Free the segments of each message */
250: msqptr->msg_cbytes -= msghdr->msg_ts;
251: msqptr->msg_qnum--;
252: msghdr_tmp = msghdr;
253: msghdr = msghdr->msg_next;
254: msg_freehdr(msghdr_tmp);
255: }
256:
257: if (msqptr->msg_cbytes != 0)
258: panic("msg_cbytes is messed up");
259: if (msqptr->msg_qnum != 0)
260: panic("msg_qnum is messed up");
261:
262: msqptr->msg_qbytes = 0; /* Mark it as free */
263:
264: wakeup((caddr_t)msqptr);
265: }
266:
267: break;
268:
269: case IPC_SET:
270: if ((eval = ipcperm(cred, &msqptr->msg_perm, IPC_M)))
271: return(eval);
272: if ((eval = copyin(user_msqptr, &msqbuf, sizeof(msqbuf))) != 0)
273: return(eval);
274: if (msqbuf.msg_qbytes > msqptr->msg_qbytes) {
275: eval = suser(cred, &p->p_acflag);
276: if (eval)
277: return(eval);
278: }
279: if (msqbuf.msg_qbytes > msginfo.msgmnb) {
280: #ifdef MSG_DEBUG_OK
281: printf("can't increase msg_qbytes beyond %d (truncating)\n",
282: msginfo.msgmnb);
283: #endif
284: msqbuf.msg_qbytes = msginfo.msgmnb; /* silently restrict qbytes to system limit */
285: }
286: if (msqbuf.msg_qbytes == 0) {
287: #ifdef MSG_DEBUG_OK
288: printf("can't reduce msg_qbytes to 0\n");
289: #endif
290: return(EINVAL); /* non-standard errno! */
291: }
292: msqptr->msg_perm.uid = msqbuf.msg_perm.uid; /* change the owner */
293: msqptr->msg_perm.gid = msqbuf.msg_perm.gid; /* change the owner */
294: msqptr->msg_perm.mode = (msqptr->msg_perm.mode & ~0777) |
295: (msqbuf.msg_perm.mode & 0777);
296: msqptr->msg_qbytes = msqbuf.msg_qbytes;
297: msqptr->msg_ctime = time_second;
298: break;
299:
300: case IPC_STAT:
301: if ((eval = ipcperm(cred, &msqptr->msg_perm, IPC_R))) {
302: #ifdef MSG_DEBUG_OK
303: printf("requester doesn't have read access\n");
304: #endif
305: return(eval);
306: }
307: eval = copyout((caddr_t)msqptr, user_msqptr,
308: sizeof(struct msqid_ds));
309: break;
310:
311: default:
312: #ifdef MSG_DEBUG_OK
313: printf("invalid command %d\n", cmd);
314: #endif
315: return(EINVAL);
316: }
317:
318: if (eval == 0)
319: p->p_retval[0] = rval;
320: return(eval);
321: }
322:
323: #ifndef _SYS_SYSPROTO_H_
324: struct msgget_args {
325: key_t key;
326: int msgflg;
327: };
328: #endif
329:
330: int
331: msgget(p, uap)
332: struct proc *p;
333: register struct msgget_args *uap;
334: {
335: int msqid, eval;
336: int key = uap->key;
337: int msgflg = uap->msgflg;
338: struct ucred *cred = p->p_ucred;
339: register struct msqid_ds *msqptr = NULL;
340:
341: #ifdef MSG_DEBUG_OK
342: printf("msgget(0x%x, 0%o)\n", key, msgflg);
343: #endif
344:
345: if (key != IPC_PRIVATE) {
346: for (msqid = 0; msqid < msginfo.msgmni; msqid++) {
347: msqptr = &msqids[msqid];
348: if (msqptr->msg_qbytes != 0 &&
349: msqptr->msg_perm.key == key)
350: break;
351: }
352: if (msqid < msginfo.msgmni) {
353: #ifdef MSG_DEBUG_OK
354: printf("found public key\n");
355: #endif
356: if ((msgflg & IPC_CREAT) && (msgflg & IPC_EXCL)) {
357: #ifdef MSG_DEBUG_OK
358: printf("not exclusive\n");
359: #endif
360: return(EEXIST);
361: }
362: if ((eval = ipcperm(cred, &msqptr->msg_perm, msgflg & 0700 ))) {
363: #ifdef MSG_DEBUG_OK
364: printf("requester doesn't have 0%o access\n",
365: msgflg & 0700);
366: #endif
367: return(eval);
368: }
369: goto found;
370: }
371: }
372:
373: #ifdef MSG_DEBUG_OK
374: printf("need to allocate the msqid_ds\n");
375: #endif
376: if (key == IPC_PRIVATE || (msgflg & IPC_CREAT)) {
377: for (msqid = 0; msqid < msginfo.msgmni; msqid++) {
378: /*
379: * Look for an unallocated and unlocked msqid_ds.
380: * msqid_ds's can be locked by msgsnd or msgrcv while
381: * they are copying the message in/out. We can't
382: * re-use the entry until they release it.
383: */
384: msqptr = &msqids[msqid];
385: if (msqptr->msg_qbytes == 0 &&
386: (msqptr->msg_perm.mode & MSG_LOCKED) == 0)
387: break;
388: }
389: if (msqid == msginfo.msgmni) {
390: #ifdef MSG_DEBUG_OK
391: printf("no more msqid_ds's available\n");
392: #endif
393: return(ENOSPC);
394: }
395: #ifdef MSG_DEBUG_OK
396: printf("msqid %d is available\n", msqid);
397: #endif
398: msqptr->msg_perm.key = key;
399: msqptr->msg_perm.cuid = cred->cr_uid;
400: msqptr->msg_perm.uid = cred->cr_uid;
401: msqptr->msg_perm.cgid = cred->cr_gid;
402: msqptr->msg_perm.gid = cred->cr_gid;
403: msqptr->msg_perm.mode = (msgflg & 0777);
404: /* Make sure that the returned msqid is unique */
405: msqptr->msg_perm.seq++;
406: msqptr->msg_first = NULL;
407: msqptr->msg_last = NULL;
408: msqptr->msg_cbytes = 0;
409: msqptr->msg_qnum = 0;
410: msqptr->msg_qbytes = msginfo.msgmnb;
411: msqptr->msg_lspid = 0;
412: msqptr->msg_lrpid = 0;
413: msqptr->msg_stime = 0;
414: msqptr->msg_rtime = 0;
415: msqptr->msg_ctime = time_second;
416: } else {
417: #ifdef MSG_DEBUG_OK
418: printf("didn't find it and wasn't asked to create it\n");
419: #endif
420: return(ENOENT);
421: }
422:
423: found:
424: /* Construct the unique msqid */
425: p->p_retval[0] = IXSEQ_TO_IPCID(msqid, msqptr->msg_perm);
426: return(0);
427: }
428:
429: #ifndef _SYS_SYSPROTO_H_
430: struct msgsnd_args {
431: int msqid;
432: void *msgp;
433: size_t msgsz;
434: int msgflg;
435: };
436: #endif
437:
438: int
439: msgsnd(p, uap)
440: struct proc *p;
441: register struct msgsnd_args *uap;
442: {
443: int msqid = uap->msqid;
444: void *user_msgp = uap->msgp;
445: size_t msgsz = uap->msgsz;
446: int msgflg = uap->msgflg;
447: int segs_needed, eval;
448: struct ucred *cred = p->p_ucred;
449: register struct msqid_ds *msqptr;
450: register struct msg *msghdr;
451: short next;
452:
453: #ifdef MSG_DEBUG_OK
454: printf("call to msgsnd(%d, 0x%x, %d, %d)\n", msqid, user_msgp, msgsz,
455: msgflg);
456: #endif
457:
458: msqid = IPCID_TO_IX(msqid);
459:
460: if (msqid < 0 || msqid >= msginfo.msgmni) {
461: #ifdef MSG_DEBUG_OK
462: printf("msqid (%d) out of range (0<=msqid<%d)\n", msqid,
463: msginfo.msgmni);
464: #endif
465: return(EINVAL);
466: }
467:
468: msqptr = &msqids[msqid];
469: if (msqptr->msg_qbytes == 0) {
470: #ifdef MSG_DEBUG_OK
471: printf("no such message queue id\n");
472: #endif
473: return(EINVAL);
474: }
475: if (msqptr->msg_perm.seq != IPCID_TO_SEQ(uap->msqid)) {
476: #ifdef MSG_DEBUG_OK
477: printf("wrong sequence number\n");
478: #endif
479: return(EINVAL);
480: }
481:
482: if ((eval = ipcperm(cred, &msqptr->msg_perm, IPC_W))) {
483: #ifdef MSG_DEBUG_OK
484: printf("requester doesn't have write access\n");
485: #endif
486: return(eval);
487: }
488:
489: segs_needed = (msgsz + msginfo.msgssz - 1) / msginfo.msgssz;
490: #ifdef MSG_DEBUG_OK
491: printf("msgsz=%d, msgssz=%d, segs_needed=%d\n", msgsz, msginfo.msgssz,
492: segs_needed);
493: #endif
494: for (;;) {
495: int need_more_resources = 0;
496:
497: /*
498: * check msgsz
499: * (inside this loop in case msg_qbytes changes while we sleep)
500: */
501:
502: if (msgsz > msqptr->msg_qbytes) {
503: #ifdef MSG_DEBUG_OK
504: printf("msgsz > msqptr->msg_qbytes\n");
505: #endif
506: return(EINVAL);
507: }
508:
509: if (msqptr->msg_perm.mode & MSG_LOCKED) {
510: #ifdef MSG_DEBUG_OK
511: printf("msqid is locked\n");
512: #endif
513: need_more_resources = 1;
514: }
515: if (msgsz + msqptr->msg_cbytes > msqptr->msg_qbytes) {
516: #ifdef MSG_DEBUG_OK
517: printf("msgsz + msg_cbytes > msg_qbytes\n");
518: #endif
519: need_more_resources = 1;
520: }
521: if (segs_needed > nfree_msgmaps) {
522: #ifdef MSG_DEBUG_OK
523: printf("segs_needed > nfree_msgmaps\n");
524: #endif
525: need_more_resources = 1;
526: }
527: if (free_msghdrs == NULL) {
528: #ifdef MSG_DEBUG_OK
529: printf("no more msghdrs\n");
530: #endif
531: need_more_resources = 1;
532: }
533:
534: if (need_more_resources) {
535: int we_own_it;
536:
537: if ((msgflg & IPC_NOWAIT) != 0) {
538: #ifdef MSG_DEBUG_OK
539: printf("need more resources but caller doesn't want to wait\n");
540: #endif
541: return(EAGAIN);
542: }
543:
544: if ((msqptr->msg_perm.mode & MSG_LOCKED) != 0) {
545: #ifdef MSG_DEBUG_OK
546: printf("we don't own the msqid_ds\n");
547: #endif
548: we_own_it = 0;
549: } else {
550: /* Force later arrivals to wait for our
551: request */
552: #ifdef MSG_DEBUG_OK
553: printf("we own the msqid_ds\n");
554: #endif
555: msqptr->msg_perm.mode |= MSG_LOCKED;
556: we_own_it = 1;
557: }
558: #ifdef MSG_DEBUG_OK
559: printf("goodnight\n");
560: #endif
561: eval = tsleep((caddr_t)msqptr, (PZERO - 4) | PCATCH,
562: "msgwait", 0);
563: #ifdef MSG_DEBUG_OK
564: printf("good morning, eval=%d\n", eval);
565: #endif
566: if (we_own_it)
567: msqptr->msg_perm.mode &= ~MSG_LOCKED;
568: if (eval != 0) {
569: #ifdef MSG_DEBUG_OK
570: printf("msgsnd: interrupted system call\n");
571: #endif
572: return(EINTR);
573: }
574:
575: /*
576: * Make sure that the msq queue still exists
577: */
578:
579: if (msqptr->msg_qbytes == 0) {
580: #ifdef MSG_DEBUG_OK
581: printf("msqid deleted\n");
582: #endif
583: /* The SVID says to return EIDRM. */
584: #ifdef EIDRM
585: return(EIDRM);
586: #else
587: /* Unfortunately, BSD doesn't define that code
588: yet! */
589: return(EINVAL);
590: #endif
591: }
592:
593: } else {
594: #ifdef MSG_DEBUG_OK
595: printf("got all the resources that we need\n");
596: #endif
597: break;
598: }
599: }
600:
601: /*
602: * We have the resources that we need.
603: * Make sure!
604: */
605:
606: if (msqptr->msg_perm.mode & MSG_LOCKED)
607: panic("msg_perm.mode & MSG_LOCKED");
608: if (segs_needed > nfree_msgmaps)
609: panic("segs_needed > nfree_msgmaps");
610: if (msgsz + msqptr->msg_cbytes > msqptr->msg_qbytes)
611: panic("msgsz + msg_cbytes > msg_qbytes");
612: if (free_msghdrs == NULL)
613: panic("no more msghdrs");
614:
615: /*
616: * Re-lock the msqid_ds in case we page-fault when copying in the
617: * message
618: */
619:
620: if ((msqptr->msg_perm.mode & MSG_LOCKED) != 0)
621: panic("msqid_ds is already locked");
622: msqptr->msg_perm.mode |= MSG_LOCKED;
623:
624: /*
625: * Allocate a message header
626: */
627:
628: msghdr = free_msghdrs;
629: free_msghdrs = msghdr->msg_next;
630: msghdr->msg_spot = -1;
631: msghdr->msg_ts = msgsz;
632:
633: /*
634: * Allocate space for the message
635: */
636:
637: while (segs_needed > 0) {
638: if (nfree_msgmaps <= 0)
639: panic("not enough msgmaps");
640: if (free_msgmaps == -1)
641: panic("nil free_msgmaps");
642: next = free_msgmaps;
643: if (next <= -1)
644: panic("next too low #1");
645: if (next >= msginfo.msgseg)
646: panic("next out of range #1");
647: #ifdef MSG_DEBUG_OK
648: printf("allocating segment %d to message\n", next);
649: #endif
650: free_msgmaps = msgmaps[next].next;
651: nfree_msgmaps--;
652: msgmaps[next].next = msghdr->msg_spot;
653: msghdr->msg_spot = next;
654: segs_needed--;
655: }
656:
657: /*
658: * Copy in the message type
659: */
660:
661: if ((eval = copyin(user_msgp, &msghdr->msg_type,
662: sizeof(msghdr->msg_type))) != 0) {
663: #ifdef MSG_DEBUG_OK
664: printf("error %d copying the message type\n", eval);
665: #endif
666: msg_freehdr(msghdr);
667: msqptr->msg_perm.mode &= ~MSG_LOCKED;
668: wakeup((caddr_t)msqptr);
669: return(eval);
670: }
671: user_msgp = (char *)user_msgp + sizeof(msghdr->msg_type);
672:
673: /*
674: * Validate the message type
675: */
676:
677: if (msghdr->msg_type < 1) {
678: msg_freehdr(msghdr);
679: msqptr->msg_perm.mode &= ~MSG_LOCKED;
680: wakeup((caddr_t)msqptr);
681: #ifdef MSG_DEBUG_OK
682: printf("mtype (%d) < 1\n", msghdr->msg_type);
683: #endif
684: return(EINVAL);
685: }
686:
687: /*
688: * Copy in the message body
689: */
690:
691: next = msghdr->msg_spot;
692: while (msgsz > 0) {
693: size_t tlen;
694: if (msgsz > msginfo.msgssz)
695: tlen = msginfo.msgssz;
696: else
697: tlen = msgsz;
698: if (next <= -1)
699: panic("next too low #2");
700: if (next >= msginfo.msgseg)
701: panic("next out of range #2");
702: if ((eval = copyin(user_msgp, &msgpool[next * msginfo.msgssz],
703: tlen)) != 0) {
704: #ifdef MSG_DEBUG_OK
705: printf("error %d copying in message segment\n", eval);
706: #endif
707: msg_freehdr(msghdr);
708: msqptr->msg_perm.mode &= ~MSG_LOCKED;
709: wakeup((caddr_t)msqptr);
710: return(eval);
711: }
712: msgsz -= tlen;
713: user_msgp = (char *)user_msgp + tlen;
714: next = msgmaps[next].next;
715: }
716: if (next != -1)
717: panic("didn't use all the msg segments");
718:
719: /*
720: * We've got the message. Unlock the msqid_ds.
721: */
722:
723: msqptr->msg_perm.mode &= ~MSG_LOCKED;
724:
725: /*
726: * Make sure that the msqid_ds is still allocated.
727: */
728:
729: if (msqptr->msg_qbytes == 0) {
730: msg_freehdr(msghdr);
731: wakeup((caddr_t)msqptr);
732: /* The SVID says to return EIDRM. */
733: #ifdef EIDRM
734: return(EIDRM);
735: #else
736: /* Unfortunately, BSD doesn't define that code yet! */
737: return(EINVAL);
738: #endif
739: }
740:
741: /*
742: * Put the message into the queue
743: */
744:
745: if (msqptr->msg_first == NULL) {
746: msqptr->msg_first = msghdr;
747: msqptr->msg_last = msghdr;
748: } else {
749: msqptr->msg_last->msg_next = msghdr;
750: msqptr->msg_last = msghdr;
751: }
752: msqptr->msg_last->msg_next = NULL;
753:
754: msqptr->msg_cbytes += msghdr->msg_ts;
755: msqptr->msg_qnum++;
756: msqptr->msg_lspid = p->p_pid;
757: msqptr->msg_stime = time_second;
758:
759: wakeup((caddr_t)msqptr);
760: p->p_retval[0] = 0;
761: return(0);
762: }
763:
764: #ifndef _SYS_SYSPROTO_H_
765: struct msgrcv_args {
766: int msqid;
767: void *msgp;
768: size_t msgsz;
769: long msgtyp;
770: int msgflg;
771: };
772: #endif
773:
774: int
775: msgrcv(p, uap)
776: struct proc *p;
777: register struct msgrcv_args *uap;
778: {
779: int msqid = uap->msqid;
780: void *user_msgp = uap->msgp;
781: size_t msgsz = uap->msgsz;
782: long msgtyp = uap->msgtyp;
783: int msgflg = uap->msgflg;
784: size_t len;
785: struct ucred *cred = p->p_ucred;
786: register struct msqid_ds *msqptr;
787: register struct msg *msghdr;
788: int eval;
789: short next;
790:
791: #ifdef MSG_DEBUG_OK
792: printf("call to msgrcv(%d, 0x%x, %d, %ld, %d)\n", msqid, user_msgp,
793: msgsz, msgtyp, msgflg);
794: #endif
795:
796: msqid = IPCID_TO_IX(msqid);
797:
798: if (msqid < 0 || msqid >= msginfo.msgmni) {
799: #ifdef MSG_DEBUG_OK
800: printf("msqid (%d) out of range (0<=msqid<%d)\n", msqid,
801: msginfo.msgmni);
802: #endif
803: return(EINVAL);
804: }
805:
806: msqptr = &msqids[msqid];
807: if (msqptr->msg_qbytes == 0) {
808: #ifdef MSG_DEBUG_OK
809: printf("no such message queue id\n");
810: #endif
811: return(EINVAL);
812: }
813: if (msqptr->msg_perm.seq != IPCID_TO_SEQ(uap->msqid)) {
814: #ifdef MSG_DEBUG_OK
815: printf("wrong sequence number\n");
816: #endif
817: return(EINVAL);
818: }
819:
820: if ((eval = ipcperm(cred, &msqptr->msg_perm, IPC_R))) {
821: #ifdef MSG_DEBUG_OK
822: printf("requester doesn't have read access\n");
823: #endif
824: return(eval);
825: }
826:
827: msghdr = NULL;
828: while (msghdr == NULL) {
829: if (msgtyp == 0) {
830: msghdr = msqptr->msg_first;
831: if (msghdr != NULL) {
832: if (msgsz < msghdr->msg_ts &&
833: (msgflg & MSG_NOERROR) == 0) {
834: #ifdef MSG_DEBUG_OK
835: printf("first message on the queue is too big (want %d, got %d)\n",
836: msgsz, msghdr->msg_ts);
837: #endif
838: return(E2BIG);
839: }
840: if (msqptr->msg_first == msqptr->msg_last) {
841: msqptr->msg_first = NULL;
842: msqptr->msg_last = NULL;
843: } else {
844: msqptr->msg_first = msghdr->msg_next;
845: if (msqptr->msg_first == NULL)
846: panic("msg_first/last messed up #1");
847: }
848: }
849: } else {
850: struct msg *previous;
851: struct msg **prev;
852:
853: previous = NULL;
854: prev = &(msqptr->msg_first);
855: while ((msghdr = *prev) != NULL) {
856: /*
857: * Is this message's type an exact match or is
858: * this message's type less than or equal to
859: * the absolute value of a negative msgtyp?
860: * Note that the second half of this test can
861: * NEVER be true if msgtyp is positive since
862: * msg_type is always positive!
863: */
864:
865: if (msgtyp == msghdr->msg_type ||
866: msghdr->msg_type <= -msgtyp) {
867: #ifdef MSG_DEBUG_OK
868: printf("found message type %d, requested %d\n",
869: msghdr->msg_type, msgtyp);
870: #endif
871: if (msgsz < msghdr->msg_ts &&
872: (msgflg & MSG_NOERROR) == 0) {
873: #ifdef MSG_DEBUG_OK
874: printf("requested message on the queue is too big (want %d, got %d)\n",
875: msgsz, msghdr->msg_ts);
876: #endif
877: return(E2BIG);
878: }
879: *prev = msghdr->msg_next;
880: if (msghdr == msqptr->msg_last) {
881: if (previous == NULL) {
882: if (prev !=
883: &msqptr->msg_first)
884: panic("msg_first/last messed up #2");
885: msqptr->msg_first =
886: NULL;
887: msqptr->msg_last =
888: NULL;
889: } else {
890: if (prev ==
891: &msqptr->msg_first)
892: panic("msg_first/last messed up #3");
893: msqptr->msg_last =
894: previous;
895: }
896: }
897: break;
898: }
899: previous = msghdr;
900: prev = &(msghdr->msg_next);
901: }
902: }
903:
904: /*
905: * We've either extracted the msghdr for the appropriate
906: * message or there isn't one.
907: * If there is one then bail out of this loop.
908: */
909:
910: if (msghdr != NULL)
911: break;
912:
913: /*
914: * Hmph! No message found. Does the user want to wait?
915: */
916:
917: if ((msgflg & IPC_NOWAIT) != 0) {
918: #ifdef MSG_DEBUG_OK
919: printf("no appropriate message found (msgtyp=%d)\n",
920: msgtyp);
921: #endif
922: /* The SVID says to return ENOMSG. */
923: #ifdef ENOMSG
924: return(ENOMSG);
925: #else
926: /* Unfortunately, BSD doesn't define that code yet! */
927: return(EAGAIN);
928: #endif
929: }
930:
931: /*
932: * Wait for something to happen
933: */
934:
935: #ifdef MSG_DEBUG_OK
936: printf("msgrcv: goodnight\n");
937: #endif
938: eval = tsleep((caddr_t)msqptr, (PZERO - 4) | PCATCH, "msgwait",
939: 0);
940: #ifdef MSG_DEBUG_OK
941: printf("msgrcv: good morning (eval=%d)\n", eval);
942: #endif
943:
944: if (eval != 0) {
945: #ifdef MSG_DEBUG_OK
946: printf("msgsnd: interrupted system call\n");
947: #endif
948: return(EINTR);
949: }
950:
951: /*
952: * Make sure that the msq queue still exists
953: */
954:
955: if (msqptr->msg_qbytes == 0 ||
956: msqptr->msg_perm.seq != IPCID_TO_SEQ(uap->msqid)) {
957: #ifdef MSG_DEBUG_OK
958: printf("msqid deleted\n");
959: #endif
960: /* The SVID says to return EIDRM. */
961: #ifdef EIDRM
962: return(EIDRM);
963: #else
964: /* Unfortunately, BSD doesn't define that code yet! */
965: return(EINVAL);
966: #endif
967: }
968: }
969:
970: /*
971: * Return the message to the user.
972: *
973: * First, do the bookkeeping (before we risk being interrupted).
974: */
975:
976: msqptr->msg_cbytes -= msghdr->msg_ts;
977: msqptr->msg_qnum--;
978: msqptr->msg_lrpid = p->p_pid;
979: msqptr->msg_rtime = time_second;
980:
981: /*
982: * Make msgsz the actual amount that we'll be returning.
983: * Note that this effectively truncates the message if it is too long
984: * (since msgsz is never increased).
985: */
986:
987: #ifdef MSG_DEBUG_OK
988: printf("found a message, msgsz=%d, msg_ts=%d\n", msgsz,
989: msghdr->msg_ts);
990: #endif
991: if (msgsz > msghdr->msg_ts)
992: msgsz = msghdr->msg_ts;
993:
994: /*
995: * Return the type to the user.
996: */
997:
998: eval = copyout((caddr_t)&(msghdr->msg_type), user_msgp,
999: sizeof(msghdr->msg_type));
1000: if (eval != 0) {
1001: #ifdef MSG_DEBUG_OK
1002: printf("error (%d) copying out message type\n", eval);
1003: #endif
1004: msg_freehdr(msghdr);
1005: wakeup((caddr_t)msqptr);
1006: return(eval);
1007: }
1008: user_msgp = (char *)user_msgp + sizeof(msghdr->msg_type);
1009:
1010: /*
1011: * Return the segments to the user
1012: */
1013:
1014: next = msghdr->msg_spot;
1015: for (len = 0; len < msgsz; len += msginfo.msgssz) {
1016: size_t tlen;
1017:
1018: if (msgsz > msginfo.msgssz)
1019: tlen = msginfo.msgssz;
1020: else
1021: tlen = msgsz;
1022: if (next <= -1)
1023: panic("next too low #3");
1024: if (next >= msginfo.msgseg)
1025: panic("next out of range #3");
1026: eval = copyout((caddr_t)&msgpool[next * msginfo.msgssz],
1027: user_msgp, tlen);
1028: if (eval != 0) {
1029: #ifdef MSG_DEBUG_OK
1030: printf("error (%d) copying out message segment\n",
1031: eval);
1032: #endif
1033: msg_freehdr(msghdr);
1034: wakeup((caddr_t)msqptr);
1035: return(eval);
1036: }
1037: user_msgp = (char *)user_msgp + tlen;
1038: next = msgmaps[next].next;
1039: }
1040:
1041: /*
1042: * Done, return the actual number of bytes copied out.
1043: */
1044:
1045: msg_freehdr(msghdr);
1046: wakeup((caddr_t)msqptr);
1047: p->p_retval[0] = msgsz;
1048: return(0);
1049: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.