![[BACK]](/icons/back.gif){kind=icon}
Return to sysv_msg.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern|
Return to sysv_msg.c CVS log | Up to [local] / sys / kern |
1.1 nbrk 1: /* $OpenBSD: sysv_msg.c,v 1.19 2005/12/13 10:33:14 jsg Exp $ */
2: /* $NetBSD: sysv_msg.c,v 1.19 1996/02/09 19:00:18 christos Exp $ */
3:
4: /*
5: * Implementation of SVID messages
6: *
7: * Author: Daniel Boulet
8: *
9: * Copyright 1993 Daniel Boulet and RTMX Inc.
10: *
11: * This system call was implemented by Daniel Boulet under contract from RTMX.
12: *
13: * Redistribution and use in source forms, with and without modification,
14: * are permitted provided that this entire comment appears intact.
15: *
16: * Redistribution in binary form may occur without any restrictions.
17: * Obviously, it would be nice if you gave credit where credit is due
18: * but requiring it would be too onerous.
19: *
20: * This software is provided ``AS IS'' without any warranties of any kind.
21: */
22:
23: #include <sys/param.h>
24: #include <sys/systm.h>
25: #include <sys/kernel.h>
26: #include <sys/proc.h>
27: #include <sys/msg.h>
28: #include <sys/malloc.h>
29:
30: #include <sys/mount.h>
31: #include <sys/syscallargs.h>
32:
33: #ifdef MSG_DEBUG
34: #define DPRINTF(x) printf x
35: #else
36: #define DPRINTF(x)
37: #endif
38:
39: /* XXX - OpenBSD doesn't have EIDRM or ENOMSG */
40: #ifndef EIDRM
41: #define EIDRM EINVAL
42: #endif
43: #ifndef ENOMSG
44: #define ENOMSG EAGAIN
45: #endif
46:
47: int nfree_msgmaps; /* # of free map entries */
48: short free_msgmaps; /* head of linked list of free map entries */
49: struct msg *free_msghdrs; /* list of free msg headers */
50: char *msgpool; /* MSGMAX byte long msg buffer pool */
51: struct msgmap *msgmaps; /* MSGSEG msgmap structures */
52: struct msg *msghdrs; /* MSGTQL msg headers */
53: struct msqid_ds *msqids; /* MSGMNI msqid_ds struct's */
54:
55: void msg_freehdr(struct msg *);
56:
57: void
58: msginit(void)
59: {
60: int i;
61:
62: /*
63: * msginfo.msgssz should be a power of two for efficiency reasons.
64: * It is also pretty silly if msginfo.msgssz is less than 8
65: * or greater than about 256 so ...
66: */
67:
68: i = 8;
69: while (i < 1024 && i != msginfo.msgssz)
70: i <<= 1;
71:
72: if (i != msginfo.msgssz)
73: panic("msginfo.msgssz %d not a small power of 2", msginfo.msgssz);
74: if (msginfo.msgseg > 32767)
75: panic("msginfo.msgseg %d > 32767", msginfo.msgseg);
76:
77: if (msgmaps == NULL)
78: panic("msgmaps is NULL");
79:
80: for (i = 0; i < msginfo.msgseg; i++) {
81: if (i > 0)
82: msgmaps[i-1].next = i;
83: msgmaps[i].next = -1; /* implies entry is available */
84: }
85: free_msgmaps = 0;
86: nfree_msgmaps = msginfo.msgseg;
87:
88: if (msghdrs == NULL)
89: panic("msghdrs is NULL");
90:
91: for (i = 0; i < msginfo.msgtql; i++) {
92: msghdrs[i].msg_type = 0;
93: if (i > 0)
94: msghdrs[i-1].msg_next = &msghdrs[i];
95: msghdrs[i].msg_next = NULL;
96: }
97: free_msghdrs = &msghdrs[0];
98:
99: if (msqids == NULL)
100: panic("msqids is NULL");
101:
102: for (i = 0; i < msginfo.msgmni; i++) {
103: msqids[i].msg_qbytes = 0; /* implies entry is available */
104: msqids[i].msg_perm.seq = 0; /* reset to a known value */
105: }
106: }
107:
108: void
109: msg_freehdr(struct msg *msghdr)
110: {
111: while (msghdr->msg_ts > 0) {
112: short next;
113:
114: #ifdef DIAGNOSTIC
115: if (msghdr->msg_spot < 0 || msghdr->msg_spot >= msginfo.msgseg)
116: panic("msghdr->msg_spot out of range");
117: #endif
118: next = msgmaps[msghdr->msg_spot].next;
119: msgmaps[msghdr->msg_spot].next = free_msgmaps;
120: free_msgmaps = msghdr->msg_spot;
121: nfree_msgmaps++;
122: msghdr->msg_spot = next;
123: if (msghdr->msg_ts >= msginfo.msgssz)
124: msghdr->msg_ts -= msginfo.msgssz;
125: else
126: msghdr->msg_ts = 0;
127: }
128: #ifdef DIAGNOSTIC
129: if (msghdr->msg_spot != -1)
130: panic("msghdr->msg_spot != -1");
131: #endif
132: msghdr->msg_next = free_msghdrs;
133: free_msghdrs = msghdr;
134: }
135:
136: int
137: sys_msgctl(struct proc *p, void *v, register_t *retval)
138: {
139: struct sys_msgctl_args /* {
140: syscallarg(int) msqid;
141: syscallarg(int) cmd;
142: syscallarg(struct msqid_ds *) buf;
143: } */ *uap = v;
144:
145: return (msgctl1(p, SCARG(uap, msqid), SCARG(uap, cmd),
146: (caddr_t)SCARG(uap, buf), copyin, copyout));
147: }
148:
149: int
150: msgctl1(struct proc *p, int msqid, int cmd, caddr_t buf,
151: int (*ds_copyin)(const void *, void *, size_t),
152: int (*ds_copyout)(const void *, void *, size_t))
153: {
154: struct ucred *cred = p->p_ucred;
155: struct msqid_ds msqbuf, *msqptr;
156: struct msg *msghdr;
157: int ix, error = 0;
158:
159: DPRINTF(("call to msgctl(%d, %d, %p)\n", msqid, cmd, buf));
160:
161: ix = IPCID_TO_IX(msqid);
162:
163: if (ix < 0 || ix >= msginfo.msgmni) {
164: DPRINTF(("msqid (%d) out of range (0<=msqid<%d)\n", ix,
165: msginfo.msgmni));
166: return (EINVAL);
167: }
168:
169: msqptr = &msqids[ix];
170:
171: if (msqptr->msg_qbytes == 0) {
172: DPRINTF(("no such msqid\n"));
173: return (EINVAL);
174: }
175: if (msqptr->msg_perm.seq != IPCID_TO_SEQ(msqid)) {
176: DPRINTF(("wrong sequence number\n"));
177: return (EINVAL);
178: }
179:
180: switch (cmd) {
181: case IPC_RMID:
182: if ((error = ipcperm(cred, &msqptr->msg_perm, IPC_M)) != 0)
183: return (error);
184: /* Free the message headers */
185: msghdr = msqptr->msg_first;
186: while (msghdr != NULL) {
187: struct msg *msghdr_tmp;
188:
189: /* Free the segments of each message */
190: msqptr->msg_cbytes -= msghdr->msg_ts;
191: msqptr->msg_qnum--;
192: msghdr_tmp = msghdr;
193: msghdr = msghdr->msg_next;
194: msg_freehdr(msghdr_tmp);
195: }
196:
197: #ifdef DIAGNOSTIC
198: if (msqptr->msg_cbytes != 0)
199: panic("sys_msgctl: msg_cbytes is screwed up");
200: if (msqptr->msg_qnum != 0)
201: panic("sys_msgctl: msg_qnum is screwed up");
202: #endif
203: msqptr->msg_qbytes = 0; /* Mark it as free */
204: wakeup(msqptr);
205: break;
206:
207: case IPC_SET:
208: if ((error = ipcperm(cred, &msqptr->msg_perm, IPC_M)))
209: return (error);
210: if ((error = ds_copyin(buf, &msqbuf, sizeof(msqbuf))) != 0)
211: return (error);
212: if (msqbuf.msg_qbytes > msqptr->msg_qbytes &&
213: cred->cr_uid != 0)
214: return (EPERM);
215: if (msqbuf.msg_qbytes > msginfo.msgmnb) {
216: DPRINTF(("can't increase msg_qbytes beyond %d "
217: "(truncating)\n", msginfo.msgmnb));
218: /* silently restrict qbytes to system limit */
219: msqbuf.msg_qbytes = msginfo.msgmnb;
220: }
221: if (msqbuf.msg_qbytes == 0) {
222: DPRINTF(("can't reduce msg_qbytes to 0\n"));
223: return (EINVAL); /* non-standard errno! */
224: }
225: msqptr->msg_perm.uid = msqbuf.msg_perm.uid;
226: msqptr->msg_perm.gid = msqbuf.msg_perm.gid;
227: msqptr->msg_perm.mode = (msqptr->msg_perm.mode & ~0777) |
228: (msqbuf.msg_perm.mode & 0777);
229: msqptr->msg_qbytes = msqbuf.msg_qbytes;
230: msqptr->msg_ctime = time_second;
231: break;
232:
233: case IPC_STAT:
234: if ((error = ipcperm(cred, &msqptr->msg_perm, IPC_R))) {
235: DPRINTF(("requester doesn't have read access\n"));
236: return (error);
237: }
238: error = ds_copyout(msqptr, buf, sizeof(struct msqid_ds));
239: break;
240:
241: default:
242: DPRINTF(("invalid command %d\n", cmd));
243: return (EINVAL);
244: }
245: return (error);
246: }
247:
248: int
249: sys_msgget(struct proc *p, void *v, register_t *retval)
250: {
251: struct sys_msgget_args /* {
252: syscallarg(key_t) key;
253: syscallarg(int) msgflg;
254: } */ *uap = v;
255: int msqid, eval;
256: int key = SCARG(uap, key);
257: int msgflg = SCARG(uap, msgflg);
258: struct ucred *cred = p->p_ucred;
259: struct msqid_ds *msqptr = NULL;
260:
261: DPRINTF(("msgget(0x%x, 0%o)\n", key, msgflg));
262:
263: if (key != IPC_PRIVATE) {
264: for (msqid = 0; msqid < msginfo.msgmni; msqid++) {
265: msqptr = &msqids[msqid];
266: if (msqptr->msg_qbytes != 0 &&
267: msqptr->msg_perm.key == key)
268: break;
269: }
270: if (msqid < msginfo.msgmni) {
271: DPRINTF(("found public key\n"));
272: if ((msgflg & IPC_CREAT) && (msgflg & IPC_EXCL)) {
273: DPRINTF(("not exclusive\n"));
274: return (EEXIST);
275: }
276: if ((eval = ipcperm(cred, &msqptr->msg_perm, msgflg & 0700 ))) {
277: DPRINTF(("requester doesn't have 0%o access\n",
278: msgflg & 0700));
279: return (eval);
280: }
281: goto found;
282: }
283: }
284:
285: DPRINTF(("need to allocate the msqid_ds\n"));
286: if (key == IPC_PRIVATE || (msgflg & IPC_CREAT)) {
287: for (msqid = 0; msqid < msginfo.msgmni; msqid++) {
288: /*
289: * Look for an unallocated and unlocked msqid_ds.
290: * msqid_ds's can be locked by msgsnd or msgrcv while
291: * they are copying the message in/out. We can't
292: * re-use the entry until they release it.
293: */
294: msqptr = &msqids[msqid];
295: if (msqptr->msg_qbytes == 0 &&
296: (msqptr->msg_perm.mode & MSG_LOCKED) == 0)
297: break;
298: }
299: if (msqid == msginfo.msgmni) {
300: DPRINTF(("no more msqid_ds's available\n"));
301: return (ENOSPC);
302: }
303: DPRINTF(("msqid %d is available\n", msqid));
304: msqptr->msg_perm.key = key;
305: msqptr->msg_perm.cuid = cred->cr_uid;
306: msqptr->msg_perm.uid = cred->cr_uid;
307: msqptr->msg_perm.cgid = cred->cr_gid;
308: msqptr->msg_perm.gid = cred->cr_gid;
309: msqptr->msg_perm.mode = (msgflg & 0777);
310: /* Make sure that the returned msqid is unique */
311: msqptr->msg_perm.seq = (msqptr->msg_perm.seq + 1) & 0x7fff;
312: msqptr->msg_first = NULL;
313: msqptr->msg_last = NULL;
314: msqptr->msg_cbytes = 0;
315: msqptr->msg_qnum = 0;
316: msqptr->msg_qbytes = msginfo.msgmnb;
317: msqptr->msg_lspid = 0;
318: msqptr->msg_lrpid = 0;
319: msqptr->msg_stime = 0;
320: msqptr->msg_rtime = 0;
321: msqptr->msg_ctime = time_second;
322: } else {
323: DPRINTF(("didn't find it and wasn't asked to create it\n"));
324: return (ENOENT);
325: }
326:
327: found:
328: /* Construct the unique msqid */
329: *retval = IXSEQ_TO_IPCID(msqid, msqptr->msg_perm);
330: return (0);
331: }
332:
333: int
334: sys_msgsnd(struct proc *p, void *v, register_t *retval)
335: {
336: struct sys_msgsnd_args /* {
337: syscallarg(int) msqid;
338: syscallarg(const void *) msgp;
339: syscallarg(size_t) msgsz;
340: syscallarg(int) msgflg;
341: } */ *uap = v;
342: int msqid = SCARG(uap, msqid);
343: const char *user_msgp = SCARG(uap, msgp);
344: size_t msgsz = SCARG(uap, msgsz);
345: int msgflg = SCARG(uap, msgflg);
346: int segs_needed, eval;
347: struct ucred *cred = p->p_ucred;
348: struct msqid_ds *msqptr;
349: struct msg *msghdr;
350: short next;
351:
352: DPRINTF(("call to msgsnd(%d, %p, %d, %d)\n", msqid, user_msgp, msgsz,
353: msgflg));
354:
355: msqid = IPCID_TO_IX(msqid);
356:
357: if (msqid < 0 || msqid >= msginfo.msgmni) {
358: DPRINTF(("msqid (%d) out of range (0<=msqid<%d)\n", msqid,
359: msginfo.msgmni));
360: return (EINVAL);
361: }
362:
363: msqptr = &msqids[msqid];
364: if (msqptr->msg_qbytes == 0) {
365: DPRINTF(("no such message queue id\n"));
366: return (EINVAL);
367: }
368: if (msqptr->msg_perm.seq != IPCID_TO_SEQ(SCARG(uap, msqid))) {
369: DPRINTF(("wrong sequence number\n"));
370: return (EINVAL);
371: }
372:
373: if ((eval = ipcperm(cred, &msqptr->msg_perm, IPC_W))) {
374: DPRINTF(("requester doesn't have write access\n"));
375: return (eval);
376: }
377:
378: segs_needed = (msgsz + msginfo.msgssz - 1) / msginfo.msgssz;
379: DPRINTF(("msgsz=%d, msgssz=%d, segs_needed=%d\n", msgsz,
380: msginfo.msgssz, segs_needed));
381: for (;;) {
382: int need_more_resources = 0;
383:
384: /*
385: * check msgsz [cannot be negative since it is unsigned]
386: * (inside this loop in case msg_qbytes changes while we sleep)
387: */
388:
389: if (msgsz > msqptr->msg_qbytes) {
390: DPRINTF(("msgsz > msqptr->msg_qbytes\n"));
391: return (EINVAL);
392: }
393:
394: if (msqptr->msg_perm.mode & MSG_LOCKED) {
395: DPRINTF(("msqid is locked\n"));
396: need_more_resources = 1;
397: }
398: if (msgsz + msqptr->msg_cbytes > msqptr->msg_qbytes) {
399: DPRINTF(("msgsz + msg_cbytes > msg_qbytes\n"));
400: need_more_resources = 1;
401: }
402: if (segs_needed > nfree_msgmaps) {
403: DPRINTF(("segs_needed > nfree_msgmaps\n"));
404: need_more_resources = 1;
405: }
406: if (free_msghdrs == NULL) {
407: DPRINTF(("no more msghdrs\n"));
408: need_more_resources = 1;
409: }
410:
411: if (need_more_resources) {
412: int we_own_it;
413:
414: if ((msgflg & IPC_NOWAIT) != 0) {
415: DPRINTF(("need more resources but caller "
416: "doesn't want to wait\n"));
417: return (EAGAIN);
418: }
419:
420: if ((msqptr->msg_perm.mode & MSG_LOCKED) != 0) {
421: DPRINTF(("we don't own the msqid_ds\n"));
422: we_own_it = 0;
423: } else {
424: /* Force later arrivals to wait for our
425: request */
426: DPRINTF(("we own the msqid_ds\n"));
427: msqptr->msg_perm.mode |= MSG_LOCKED;
428: we_own_it = 1;
429: }
430: DPRINTF(("goodnight\n"));
431: eval = tsleep(msqptr, (PZERO - 4) | PCATCH,
432: "msgwait", 0);
433: DPRINTF(("good morning, eval=%d\n", eval));
434: if (we_own_it)
435: msqptr->msg_perm.mode &= ~MSG_LOCKED;
436: if (eval != 0) {
437: DPRINTF(("msgsnd: interrupted system call\n"));
438: return (EINTR);
439: }
440:
441: /*
442: * Make sure that the msq queue still exists
443: */
444:
445: if (msqptr->msg_qbytes == 0) {
446: DPRINTF(("msqid deleted\n"));
447: return (EIDRM);
448: }
449:
450: } else {
451: DPRINTF(("got all the resources that we need\n"));
452: break;
453: }
454: }
455:
456: /*
457: * We have the resources that we need.
458: * Make sure!
459: */
460:
461: #ifdef DIAGNOSTIC
462: if (msqptr->msg_perm.mode & MSG_LOCKED)
463: panic("msg_perm.mode & MSG_LOCKED");
464: if (segs_needed > nfree_msgmaps)
465: panic("segs_needed > nfree_msgmaps");
466: if (msgsz + msqptr->msg_cbytes > msqptr->msg_qbytes)
467: panic("msgsz + msg_cbytes > msg_qbytes");
468: if (free_msghdrs == NULL)
469: panic("no more msghdrs");
470: #endif
471:
472: /*
473: * Re-lock the msqid_ds in case we page-fault when copying in the
474: * message
475: */
476:
477: #ifdef DIAGNOSTIC
478: if ((msqptr->msg_perm.mode & MSG_LOCKED) != 0)
479: panic("msqid_ds is already locked");
480: #endif
481: msqptr->msg_perm.mode |= MSG_LOCKED;
482:
483: /*
484: * Allocate a message header
485: */
486:
487: msghdr = free_msghdrs;
488: free_msghdrs = msghdr->msg_next;
489: msghdr->msg_spot = -1;
490: msghdr->msg_ts = msgsz;
491:
492: /*
493: * Allocate space for the message
494: */
495:
496: while (segs_needed > 0) {
497: #ifdef DIAGNOSTIC
498: if (nfree_msgmaps <= 0)
499: panic("not enough msgmaps");
500: if (free_msgmaps == -1)
501: panic("nil free_msgmaps");
502: #endif
503: next = free_msgmaps;
504: #ifdef DIAGNOSTIC
505: if (next <= -1)
506: panic("next too low #1");
507: if (next >= msginfo.msgseg)
508: panic("next out of range #1");
509: #endif
510: DPRINTF(("allocating segment %d to message\n", next));
511: free_msgmaps = msgmaps[next].next;
512: nfree_msgmaps--;
513: msgmaps[next].next = msghdr->msg_spot;
514: msghdr->msg_spot = next;
515: segs_needed--;
516: }
517:
518: /*
519: * Copy in the message type
520: */
521:
522: if ((eval = copyin(user_msgp, &msghdr->msg_type,
523: sizeof(msghdr->msg_type))) != 0) {
524: DPRINTF(("error %d copying the message type\n", eval));
525: msg_freehdr(msghdr);
526: msqptr->msg_perm.mode &= ~MSG_LOCKED;
527: wakeup(msqptr);
528: return (eval);
529: }
530: user_msgp += sizeof(msghdr->msg_type);
531:
532: /*
533: * Validate the message type
534: */
535:
536: if (msghdr->msg_type < 1) {
537: msg_freehdr(msghdr);
538: msqptr->msg_perm.mode &= ~MSG_LOCKED;
539: wakeup(msqptr);
540: DPRINTF(("mtype (%d) < 1\n", msghdr->msg_type));
541: return (EINVAL);
542: }
543:
544: /*
545: * Copy in the message body
546: */
547:
548: next = msghdr->msg_spot;
549: while (msgsz > 0) {
550: size_t tlen;
551: if (msgsz > msginfo.msgssz)
552: tlen = msginfo.msgssz;
553: else
554: tlen = msgsz;
555: #ifdef DIAGNOSTIC
556: if (next <= -1)
557: panic("next too low #2");
558: if (next >= msginfo.msgseg)
559: panic("next out of range #2");
560: #endif
561: if ((eval = copyin(user_msgp, &msgpool[next * msginfo.msgssz],
562: tlen)) != 0) {
563: DPRINTF(("error %d copying in message segment\n",
564: eval));
565: msg_freehdr(msghdr);
566: msqptr->msg_perm.mode &= ~MSG_LOCKED;
567: wakeup(msqptr);
568: return (eval);
569: }
570: msgsz -= tlen;
571: user_msgp += tlen;
572: next = msgmaps[next].next;
573: }
574: #ifdef DIAGNOSTIC
575: if (next != -1)
576: panic("didn't use all the msg segments");
577: #endif
578: /*
579: * We've got the message. Unlock the msqid_ds.
580: */
581:
582: msqptr->msg_perm.mode &= ~MSG_LOCKED;
583:
584: /*
585: * Make sure that the msqid_ds is still allocated.
586: */
587:
588: if (msqptr->msg_qbytes == 0) {
589: msg_freehdr(msghdr);
590: wakeup(msqptr);
591: return (EIDRM);
592: }
593:
594: /*
595: * Put the message into the queue
596: */
597:
598: if (msqptr->msg_first == NULL) {
599: msqptr->msg_first = msghdr;
600: msqptr->msg_last = msghdr;
601: } else {
602: msqptr->msg_last->msg_next = msghdr;
603: msqptr->msg_last = msghdr;
604: }
605: msqptr->msg_last->msg_next = NULL;
606:
607: msqptr->msg_cbytes += msghdr->msg_ts;
608: msqptr->msg_qnum++;
609: msqptr->msg_lspid = p->p_pid;
610: msqptr->msg_stime = time_second;
611:
612: wakeup(msqptr);
613: *retval = 0;
614: return (0);
615: }
616:
617: int
618: sys_msgrcv(struct proc *p, void *v, register_t *retval)
619: {
620: struct sys_msgrcv_args /* {
621: syscallarg(int) msqid;
622: syscallarg(void *) msgp;
623: syscallarg(size_t) msgsz;
624: syscallarg(long) msgtyp;
625: syscallarg(int) msgflg;
626: } */ *uap = v;
627: int msqid = SCARG(uap, msqid);
628: char *user_msgp = SCARG(uap, msgp);
629: size_t msgsz = SCARG(uap, msgsz);
630: long msgtyp = SCARG(uap, msgtyp);
631: int msgflg = SCARG(uap, msgflg);
632: size_t len;
633: struct ucred *cred = p->p_ucred;
634: struct msqid_ds *msqptr;
635: struct msg *msghdr;
636: int eval;
637: short next;
638:
639: DPRINTF(("call to msgrcv(%d, %p, %d, %ld, %d)\n", msqid, user_msgp,
640: msgsz, msgtyp, msgflg));
641:
642: msqid = IPCID_TO_IX(msqid);
643:
644: if (msqid < 0 || msqid >= msginfo.msgmni) {
645: DPRINTF(("msqid (%d) out of range (0<=msqid<%d)\n", msqid,
646: msginfo.msgmni));
647: return (EINVAL);
648: }
649:
650: msqptr = &msqids[msqid];
651: if (msqptr->msg_qbytes == 0) {
652: DPRINTF(("no such message queue id\n"));
653: return (EINVAL);
654: }
655: if (msqptr->msg_perm.seq != IPCID_TO_SEQ(SCARG(uap, msqid))) {
656: DPRINTF(("wrong sequence number\n"));
657: return (EINVAL);
658: }
659:
660: if ((eval = ipcperm(cred, &msqptr->msg_perm, IPC_R))) {
661: DPRINTF(("requester doesn't have read access\n"));
662: return (eval);
663: }
664:
665: #if 0
666: /* cannot happen, msgsz is unsigned */
667: if (msgsz < 0) {
668: DPRINTF(("msgsz < 0\n"));
669: return (EINVAL);
670: }
671: #endif
672:
673: msghdr = NULL;
674: while (msghdr == NULL) {
675: if (msgtyp == 0) {
676: msghdr = msqptr->msg_first;
677: if (msghdr != NULL) {
678: if (msgsz < msghdr->msg_ts &&
679: (msgflg & MSG_NOERROR) == 0) {
680: DPRINTF(("first message on the queue "
681: "is too big (want %d, got %d)\n",
682: msgsz, msghdr->msg_ts));
683: return (E2BIG);
684: }
685: if (msqptr->msg_first == msqptr->msg_last) {
686: msqptr->msg_first = NULL;
687: msqptr->msg_last = NULL;
688: } else {
689: msqptr->msg_first = msghdr->msg_next;
690: #ifdef DIAGNOSTIC
691: if (msqptr->msg_first == NULL)
692: panic("msg_first/last screwed up #1");
693: #endif
694: }
695: }
696: } else {
697: struct msg *previous;
698: struct msg **prev;
699:
700: for (previous = NULL, prev = &msqptr->msg_first;
701: (msghdr = *prev) != NULL;
702: previous = msghdr, prev = &msghdr->msg_next) {
703: /*
704: * Is this message's type an exact match or is
705: * this message's type less than or equal to
706: * the absolute value of a negative msgtyp?
707: * Note that the second half of this test can
708: * NEVER be true if msgtyp is positive since
709: * msg_type is always positive!
710: */
711:
712: if (msgtyp == msghdr->msg_type ||
713: msghdr->msg_type <= -msgtyp) {
714: DPRINTF(("found message type %d, "
715: "requested %d\n", msghdr->msg_type,
716: msgtyp));
717: if (msgsz < msghdr->msg_ts &&
718: (msgflg & MSG_NOERROR) == 0) {
719: DPRINTF(("requested message on "
720: "the queue is too big "
721: "(want %d, got %d)\n",
722: msgsz, msghdr->msg_ts));
723: return (E2BIG);
724: }
725: *prev = msghdr->msg_next;
726: if (msghdr == msqptr->msg_last) {
727: if (previous == NULL) {
728: #ifdef DIAGNOSTIC
729: if (prev !=
730: &msqptr->msg_first)
731: panic("msg_first/last screwed up #2");
732: #endif
733: msqptr->msg_first =
734: NULL;
735: msqptr->msg_last =
736: NULL;
737: } else {
738: #ifdef DIAGNOSTIC
739: if (prev ==
740: &msqptr->msg_first)
741: panic("msg_first/last screwed up #3");
742: #endif
743: msqptr->msg_last =
744: previous;
745: }
746: }
747: break;
748: }
749: }
750: }
751:
752: /*
753: * We've either extracted the msghdr for the appropriate
754: * message or there isn't one.
755: * If there is one then bail out of this loop.
756: */
757:
758: if (msghdr != NULL)
759: break;
760:
761: /*
762: * Hmph! No message found. Does the user want to wait?
763: */
764:
765: if ((msgflg & IPC_NOWAIT) != 0) {
766: DPRINTF(("no appropriate message found (msgtyp=%d)\n",
767: msgtyp));
768: return (ENOMSG);
769: }
770:
771: /*
772: * Wait for something to happen
773: */
774:
775: DPRINTF(("msgrcv: goodnight\n"));
776: eval = tsleep(msqptr, (PZERO - 4) | PCATCH, "msgwait",
777: 0);
778: DPRINTF(("msgrcv: good morning (eval=%d)\n", eval));
779:
780: if (eval != 0) {
781: DPRINTF(("msgsnd: interrupted system call\n"));
782: return (EINTR);
783: }
784:
785: /*
786: * Make sure that the msq queue still exists
787: */
788:
789: if (msqptr->msg_qbytes == 0 ||
790: msqptr->msg_perm.seq != IPCID_TO_SEQ(SCARG(uap, msqid))) {
791: DPRINTF(("msqid deleted\n"));
792: return (EIDRM);
793: }
794: }
795:
796: /*
797: * Return the message to the user.
798: *
799: * First, do the bookkeeping (before we risk being interrupted).
800: */
801:
802: msqptr->msg_cbytes -= msghdr->msg_ts;
803: msqptr->msg_qnum--;
804: msqptr->msg_lrpid = p->p_pid;
805: msqptr->msg_rtime = time_second;
806:
807: /*
808: * Make msgsz the actual amount that we'll be returning.
809: * Note that this effectively truncates the message if it is too long
810: * (since msgsz is never increased).
811: */
812:
813: DPRINTF(("found a message, msgsz=%d, msg_ts=%d\n", msgsz,
814: msghdr->msg_ts));
815: if (msgsz > msghdr->msg_ts)
816: msgsz = msghdr->msg_ts;
817:
818: /*
819: * Return the type to the user.
820: */
821:
822: eval = copyout(&msghdr->msg_type, user_msgp,
823: sizeof(msghdr->msg_type));
824: if (eval != 0) {
825: DPRINTF(("error (%d) copying out message type\n", eval));
826: msg_freehdr(msghdr);
827: wakeup(msqptr);
828: return (eval);
829: }
830: user_msgp += sizeof(msghdr->msg_type);
831:
832: /*
833: * Return the segments to the user
834: */
835:
836: next = msghdr->msg_spot;
837: for (len = 0; len < msgsz; len += msginfo.msgssz) {
838: size_t tlen;
839:
840: if (msgsz - len > msginfo.msgssz)
841: tlen = msginfo.msgssz;
842: else
843: tlen = msgsz - len;
844: #ifdef DIAGNOSTIC
845: if (next <= -1)
846: panic("next too low #3");
847: if (next >= msginfo.msgseg)
848: panic("next out of range #3");
849: #endif
850: eval = copyout(&msgpool[next * msginfo.msgssz],
851: user_msgp, tlen);
852: if (eval != 0) {
853: DPRINTF(("error (%d) copying out message segment\n",
854: eval));
855: msg_freehdr(msghdr);
856: wakeup(msqptr);
857: return (eval);
858: }
859: user_msgp += tlen;
860: next = msgmaps[next].next;
861: }
862:
863: /*
864: * Done, return the actual number of bytes copied out.
865: */
866:
867: msg_freehdr(msghdr);
868: wakeup(msqptr);
869: *retval = msgsz;
870: return (0);
871: }