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