sysv_msg.c revision 43426
143426Sphk/* $Id: sysv_msg.c,v 1.18 1998/03/30 09:50:35 phk Exp $ */ 22729Sdfr 32729Sdfr/* 42729Sdfr * Implementation of SVID messages 52729Sdfr * 62729Sdfr * Author: Daniel Boulet 72729Sdfr * 82729Sdfr * Copyright 1993 Daniel Boulet and RTMX Inc. 92729Sdfr * 102729Sdfr * This system call was implemented by Daniel Boulet under contract from RTMX. 112729Sdfr * 122729Sdfr * Redistribution and use in source forms, with and without modification, 132729Sdfr * are permitted provided that this entire comment appears intact. 142729Sdfr * 152729Sdfr * Redistribution in binary form may occur without any restrictions. 162729Sdfr * Obviously, it would be nice if you gave credit where credit is due 172729Sdfr * but requiring it would be too onerous. 182729Sdfr * 192729Sdfr * This software is provided ``AS IS'' without any warranties of any kind. 202729Sdfr */ 212729Sdfr 222729Sdfr#include <sys/param.h> 232729Sdfr#include <sys/systm.h> 2411626Sbde#include <sys/sysproto.h> 252729Sdfr#include <sys/kernel.h> 262729Sdfr#include <sys/proc.h> 272729Sdfr#include <sys/msg.h> 2811626Sbde#include <sys/sysent.h> 292729Sdfr 3010653Sdgstatic void msginit __P((void *)); 3110358SjulianSYSINIT(sysv_msg, SI_SUB_SYSV_MSG, SI_ORDER_FIRST, msginit, NULL) 3210358Sjulian 332729Sdfr#define MSG_DEBUG 342729Sdfr#undef MSG_DEBUG_OK 352729Sdfr 3612866Speter#ifndef _SYS_SYSPROTO_H_ 3711626Sbdestruct msgctl_args; 3830994Sphkint msgctl __P((struct proc *p, struct msgctl_args *uap)); 3911626Sbdestruct msgget_args; 4030994Sphkint msgget __P((struct proc *p, struct msgget_args *uap)); 4111626Sbdestruct msgsnd_args; 4230994Sphkint msgsnd __P((struct proc *p, struct msgsnd_args *uap)); 4311626Sbdestruct msgrcv_args; 4430994Sphkint msgrcv __P((struct proc *p, struct msgrcv_args *uap)); 4512866Speter#endif 4611626Sbdestatic void msg_freehdr __P((struct msg *msghdr)); 472729Sdfr 4811626Sbde/* XXX casting to (sy_call_t *) is bogus, as usual. */ 4912819Sphkstatic sy_call_t *msgcalls[] = { 5011626Sbde (sy_call_t *)msgctl, (sy_call_t *)msgget, 5111626Sbde (sy_call_t *)msgsnd, (sy_call_t *)msgrcv 5211626Sbde}; 532729Sdfr 5412819Sphkstatic int nfree_msgmaps; /* # of free map entries */ 5512819Sphkstatic short free_msgmaps; /* head of linked list of free map entries */ 5612819Sphkstatic struct msg *free_msghdrs; /* list of free msg headers */ 579759Sbdechar *msgpool; /* MSGMAX byte long msg buffer pool */ 589759Sbdestruct msgmap *msgmaps; /* MSGSEG msgmap structures */ 599759Sbdestruct msg *msghdrs; /* MSGTQL msg headers */ 609759Sbdestruct msqid_ds *msqids; /* MSGMNI msqid_ds struct's */ 612729Sdfr 622836Sdgvoid 6311626Sbdemsginit(dummy) 6411626Sbde void *dummy; 652729Sdfr{ 662729Sdfr register int i; 672729Sdfr 682729Sdfr /* 692729Sdfr * msginfo.msgssz should be a power of two for efficiency reasons. 702729Sdfr * It is also pretty silly if msginfo.msgssz is less than 8 712729Sdfr * or greater than about 256 so ... 722729Sdfr */ 732729Sdfr 742729Sdfr i = 8; 752729Sdfr while (i < 1024 && i != msginfo.msgssz) 762729Sdfr i <<= 1; 772729Sdfr if (i != msginfo.msgssz) { 782729Sdfr printf("msginfo.msgssz=%d (0x%x)\n", msginfo.msgssz, 792729Sdfr msginfo.msgssz); 802729Sdfr panic("msginfo.msgssz not a small power of 2"); 812729Sdfr } 822729Sdfr 832729Sdfr if (msginfo.msgseg > 32767) { 842729Sdfr printf("msginfo.msgseg=%d\n", msginfo.msgseg); 852729Sdfr panic("msginfo.msgseg > 32767"); 862729Sdfr } 872729Sdfr 882729Sdfr if (msgmaps == NULL) 892729Sdfr panic("msgmaps is NULL"); 902729Sdfr 912729Sdfr for (i = 0; i < msginfo.msgseg; i++) { 922729Sdfr if (i > 0) 932729Sdfr msgmaps[i-1].next = i; 942729Sdfr msgmaps[i].next = -1; /* implies entry is available */ 952729Sdfr } 962729Sdfr free_msgmaps = 0; 972729Sdfr nfree_msgmaps = msginfo.msgseg; 982729Sdfr 992729Sdfr if (msghdrs == NULL) 1002729Sdfr panic("msghdrs is NULL"); 1012729Sdfr 1022729Sdfr for (i = 0; i < msginfo.msgtql; i++) { 1032729Sdfr msghdrs[i].msg_type = 0; 1042729Sdfr if (i > 0) 1052729Sdfr msghdrs[i-1].msg_next = &msghdrs[i]; 1062729Sdfr msghdrs[i].msg_next = NULL; 1072729Sdfr } 1082729Sdfr free_msghdrs = &msghdrs[0]; 1092729Sdfr 1102729Sdfr if (msqids == NULL) 1112729Sdfr panic("msqids is NULL"); 1122729Sdfr 1132729Sdfr for (i = 0; i < msginfo.msgmni; i++) { 1142729Sdfr msqids[i].msg_qbytes = 0; /* implies entry is available */ 1152729Sdfr msqids[i].msg_perm.seq = 0; /* reset to a known value */ 1162729Sdfr } 1172729Sdfr} 1182729Sdfr 1192729Sdfr/* 1202729Sdfr * Entry point for all MSG calls 1212729Sdfr */ 1222729Sdfrint 12330994Sphkmsgsys(p, uap) 12411626Sbde struct proc *p; 12511626Sbde /* XXX actually varargs. */ 12611626Sbde struct msgsys_args /* { 12711626Sbde u_int which; 12811626Sbde int a2; 12911626Sbde int a3; 13011626Sbde int a4; 13111626Sbde int a5; 13211626Sbde int a6; 13311626Sbde } */ *uap; 1342729Sdfr{ 1352729Sdfr 1362729Sdfr if (uap->which >= sizeof(msgcalls)/sizeof(msgcalls[0])) 1372729Sdfr return (EINVAL); 13830994Sphk return ((*msgcalls[uap->which])(p, &uap->a2)); 1392729Sdfr} 1402729Sdfr 1412729Sdfrstatic void 1422729Sdfrmsg_freehdr(msghdr) 1432729Sdfr struct msg *msghdr; 1442729Sdfr{ 1452729Sdfr while (msghdr->msg_ts > 0) { 1462729Sdfr short next; 1472729Sdfr if (msghdr->msg_spot < 0 || msghdr->msg_spot >= msginfo.msgseg) 1482729Sdfr panic("msghdr->msg_spot out of range"); 1492729Sdfr next = msgmaps[msghdr->msg_spot].next; 1502729Sdfr msgmaps[msghdr->msg_spot].next = free_msgmaps; 1512729Sdfr free_msgmaps = msghdr->msg_spot; 1522729Sdfr nfree_msgmaps++; 1532729Sdfr msghdr->msg_spot = next; 1542729Sdfr if (msghdr->msg_ts >= msginfo.msgssz) 1552729Sdfr msghdr->msg_ts -= msginfo.msgssz; 1562729Sdfr else 1572729Sdfr msghdr->msg_ts = 0; 1582729Sdfr } 1592729Sdfr if (msghdr->msg_spot != -1) 1602729Sdfr panic("msghdr->msg_spot != -1"); 1612729Sdfr msghdr->msg_next = free_msghdrs; 1622729Sdfr free_msghdrs = msghdr; 1632729Sdfr} 1642729Sdfr 16512866Speter#ifndef _SYS_SYSPROTO_H_ 1662729Sdfrstruct msgctl_args { 1672729Sdfr int msqid; 1682729Sdfr int cmd; 16912866Speter struct msqid_ds *buf; 1702729Sdfr}; 17112866Speter#endif 1722729Sdfr 17312866Speterint 17430994Sphkmsgctl(p, uap) 1752729Sdfr struct proc *p; 1762729Sdfr register struct msgctl_args *uap; 1772729Sdfr{ 1782729Sdfr int msqid = uap->msqid; 1792729Sdfr int cmd = uap->cmd; 18012866Speter struct msqid_ds *user_msqptr = uap->buf; 1812729Sdfr struct ucred *cred = p->p_ucred; 1823308Sphk int rval, eval; 1832729Sdfr struct msqid_ds msqbuf; 1842729Sdfr register struct msqid_ds *msqptr; 1852729Sdfr 1862729Sdfr#ifdef MSG_DEBUG_OK 1872729Sdfr printf("call to msgctl(%d, %d, 0x%x)\n", msqid, cmd, user_msqptr); 1882729Sdfr#endif 1892729Sdfr 1902729Sdfr msqid = IPCID_TO_IX(msqid); 1912729Sdfr 1922729Sdfr if (msqid < 0 || msqid >= msginfo.msgmni) { 1932729Sdfr#ifdef MSG_DEBUG_OK 1942729Sdfr printf("msqid (%d) out of range (0<=msqid<%d)\n", msqid, 1952729Sdfr msginfo.msgmni); 1962729Sdfr#endif 1972729Sdfr return(EINVAL); 1982729Sdfr } 1992729Sdfr 2002729Sdfr msqptr = &msqids[msqid]; 2012729Sdfr 2022729Sdfr if (msqptr->msg_qbytes == 0) { 2032729Sdfr#ifdef MSG_DEBUG_OK 2042729Sdfr printf("no such msqid\n"); 2052729Sdfr#endif 2062729Sdfr return(EINVAL); 2072729Sdfr } 2082729Sdfr if (msqptr->msg_perm.seq != IPCID_TO_SEQ(uap->msqid)) { 2092729Sdfr#ifdef MSG_DEBUG_OK 2102729Sdfr printf("wrong sequence number\n"); 2112729Sdfr#endif 2122729Sdfr return(EINVAL); 2132729Sdfr } 2142729Sdfr 2152729Sdfr eval = 0; 2162729Sdfr rval = 0; 2172729Sdfr 2182729Sdfr switch (cmd) { 2192729Sdfr 2202729Sdfr case IPC_RMID: 2212729Sdfr { 2222729Sdfr struct msg *msghdr; 2232729Sdfr if ((eval = ipcperm(cred, &msqptr->msg_perm, IPC_M))) 2242729Sdfr return(eval); 2252729Sdfr /* Free the message headers */ 2262729Sdfr msghdr = msqptr->msg_first; 2272729Sdfr while (msghdr != NULL) { 2282729Sdfr struct msg *msghdr_tmp; 2292729Sdfr 2302729Sdfr /* Free the segments of each message */ 2312729Sdfr msqptr->msg_cbytes -= msghdr->msg_ts; 2322729Sdfr msqptr->msg_qnum--; 2332729Sdfr msghdr_tmp = msghdr; 2342729Sdfr msghdr = msghdr->msg_next; 2352729Sdfr msg_freehdr(msghdr_tmp); 2362729Sdfr } 2372729Sdfr 2382729Sdfr if (msqptr->msg_cbytes != 0) 2392729Sdfr panic("msg_cbytes is screwed up"); 2402729Sdfr if (msqptr->msg_qnum != 0) 2412729Sdfr panic("msg_qnum is screwed up"); 2422729Sdfr 2432729Sdfr msqptr->msg_qbytes = 0; /* Mark it as free */ 2442729Sdfr 2452729Sdfr wakeup((caddr_t)msqptr); 2462729Sdfr } 2472729Sdfr 2482729Sdfr break; 2492729Sdfr 2502729Sdfr case IPC_SET: 2512729Sdfr if ((eval = ipcperm(cred, &msqptr->msg_perm, IPC_M))) 2522729Sdfr return(eval); 2532729Sdfr if ((eval = copyin(user_msqptr, &msqbuf, sizeof(msqbuf))) != 0) 2542729Sdfr return(eval); 25543426Sphk if (msqbuf.msg_qbytes > msqptr->msg_qbytes) { 25643426Sphk eval = suser(cred, &p->p_acflag); 25743426Sphk if (eval) 25843426Sphk return(eval); 25943426Sphk } 2602729Sdfr if (msqbuf.msg_qbytes > msginfo.msgmnb) { 2612729Sdfr#ifdef MSG_DEBUG_OK 2622729Sdfr printf("can't increase msg_qbytes beyond %d (truncating)\n", 2632729Sdfr msginfo.msgmnb); 2642729Sdfr#endif 2652729Sdfr msqbuf.msg_qbytes = msginfo.msgmnb; /* silently restrict qbytes to system limit */ 2662729Sdfr } 2672729Sdfr if (msqbuf.msg_qbytes == 0) { 2682729Sdfr#ifdef MSG_DEBUG_OK 2692729Sdfr printf("can't reduce msg_qbytes to 0\n"); 2702729Sdfr#endif 2712729Sdfr return(EINVAL); /* non-standard errno! */ 2722729Sdfr } 2732729Sdfr msqptr->msg_perm.uid = msqbuf.msg_perm.uid; /* change the owner */ 2742729Sdfr msqptr->msg_perm.gid = msqbuf.msg_perm.gid; /* change the owner */ 2752729Sdfr msqptr->msg_perm.mode = (msqptr->msg_perm.mode & ~0777) | 2762729Sdfr (msqbuf.msg_perm.mode & 0777); 2772729Sdfr msqptr->msg_qbytes = msqbuf.msg_qbytes; 27834961Sphk msqptr->msg_ctime = time_second; 2792729Sdfr break; 2802729Sdfr 2812729Sdfr case IPC_STAT: 2822729Sdfr if ((eval = ipcperm(cred, &msqptr->msg_perm, IPC_R))) { 2832729Sdfr#ifdef MSG_DEBUG_OK 2842729Sdfr printf("requester doesn't have read access\n"); 2852729Sdfr#endif 2862729Sdfr return(eval); 2872729Sdfr } 2882729Sdfr eval = copyout((caddr_t)msqptr, user_msqptr, 2892729Sdfr sizeof(struct msqid_ds)); 2902729Sdfr break; 2912729Sdfr 2922729Sdfr default: 2932729Sdfr#ifdef MSG_DEBUG_OK 2942729Sdfr printf("invalid command %d\n", cmd); 2952729Sdfr#endif 2962729Sdfr return(EINVAL); 2972729Sdfr } 2982729Sdfr 2992729Sdfr if (eval == 0) 30030994Sphk p->p_retval[0] = rval; 3012729Sdfr return(eval); 3022729Sdfr} 3032729Sdfr 30412866Speter#ifndef _SYS_SYSPROTO_H_ 3052729Sdfrstruct msgget_args { 3062729Sdfr key_t key; 3072729Sdfr int msgflg; 3082729Sdfr}; 30912866Speter#endif 3102729Sdfr 31112866Speterint 31230994Sphkmsgget(p, uap) 3132729Sdfr struct proc *p; 3142729Sdfr register struct msgget_args *uap; 3152729Sdfr{ 3162729Sdfr int msqid, eval; 3172729Sdfr int key = uap->key; 3182729Sdfr int msgflg = uap->msgflg; 3192729Sdfr struct ucred *cred = p->p_ucred; 3202836Sdg register struct msqid_ds *msqptr = NULL; 3212729Sdfr 3222729Sdfr#ifdef MSG_DEBUG_OK 3232729Sdfr printf("msgget(0x%x, 0%o)\n", key, msgflg); 3242729Sdfr#endif 3252729Sdfr 3262729Sdfr if (key != IPC_PRIVATE) { 3272729Sdfr for (msqid = 0; msqid < msginfo.msgmni; msqid++) { 3282729Sdfr msqptr = &msqids[msqid]; 3292729Sdfr if (msqptr->msg_qbytes != 0 && 3302729Sdfr msqptr->msg_perm.key == key) 3312729Sdfr break; 3322729Sdfr } 3332729Sdfr if (msqid < msginfo.msgmni) { 3342729Sdfr#ifdef MSG_DEBUG_OK 3352729Sdfr printf("found public key\n"); 3362729Sdfr#endif 3372729Sdfr if ((msgflg & IPC_CREAT) && (msgflg & IPC_EXCL)) { 3382729Sdfr#ifdef MSG_DEBUG_OK 3392729Sdfr printf("not exclusive\n"); 3402729Sdfr#endif 3412729Sdfr return(EEXIST); 3422729Sdfr } 3432729Sdfr if ((eval = ipcperm(cred, &msqptr->msg_perm, msgflg & 0700 ))) { 3442729Sdfr#ifdef MSG_DEBUG_OK 3452729Sdfr printf("requester doesn't have 0%o access\n", 3462729Sdfr msgflg & 0700); 3472729Sdfr#endif 3482729Sdfr return(eval); 3492729Sdfr } 3502729Sdfr goto found; 3512729Sdfr } 3522729Sdfr } 3532729Sdfr 3542729Sdfr#ifdef MSG_DEBUG_OK 3552729Sdfr printf("need to allocate the msqid_ds\n"); 3562729Sdfr#endif 3572729Sdfr if (key == IPC_PRIVATE || (msgflg & IPC_CREAT)) { 3582729Sdfr for (msqid = 0; msqid < msginfo.msgmni; msqid++) { 3592729Sdfr /* 3602729Sdfr * Look for an unallocated and unlocked msqid_ds. 3612729Sdfr * msqid_ds's can be locked by msgsnd or msgrcv while 3622729Sdfr * they are copying the message in/out. We can't 3632729Sdfr * re-use the entry until they release it. 3642729Sdfr */ 3652729Sdfr msqptr = &msqids[msqid]; 3662729Sdfr if (msqptr->msg_qbytes == 0 && 3672729Sdfr (msqptr->msg_perm.mode & MSG_LOCKED) == 0) 3682729Sdfr break; 3692729Sdfr } 3702729Sdfr if (msqid == msginfo.msgmni) { 3712729Sdfr#ifdef MSG_DEBUG_OK 3722729Sdfr printf("no more msqid_ds's available\n"); 3732729Sdfr#endif 3748876Srgrimes return(ENOSPC); 3752729Sdfr } 3762729Sdfr#ifdef MSG_DEBUG_OK 3772729Sdfr printf("msqid %d is available\n", msqid); 3782729Sdfr#endif 3792729Sdfr msqptr->msg_perm.key = key; 3802729Sdfr msqptr->msg_perm.cuid = cred->cr_uid; 3812729Sdfr msqptr->msg_perm.uid = cred->cr_uid; 3822729Sdfr msqptr->msg_perm.cgid = cred->cr_gid; 3832729Sdfr msqptr->msg_perm.gid = cred->cr_gid; 3842729Sdfr msqptr->msg_perm.mode = (msgflg & 0777); 3852729Sdfr /* Make sure that the returned msqid is unique */ 3862729Sdfr msqptr->msg_perm.seq++; 3872729Sdfr msqptr->msg_first = NULL; 3882729Sdfr msqptr->msg_last = NULL; 3892729Sdfr msqptr->msg_cbytes = 0; 3902729Sdfr msqptr->msg_qnum = 0; 3912729Sdfr msqptr->msg_qbytes = msginfo.msgmnb; 3922729Sdfr msqptr->msg_lspid = 0; 3932729Sdfr msqptr->msg_lrpid = 0; 3942729Sdfr msqptr->msg_stime = 0; 3952729Sdfr msqptr->msg_rtime = 0; 39634961Sphk msqptr->msg_ctime = time_second; 3972729Sdfr } else { 3982729Sdfr#ifdef MSG_DEBUG_OK 3992729Sdfr printf("didn't find it and wasn't asked to create it\n"); 4002729Sdfr#endif 4012729Sdfr return(ENOENT); 4022729Sdfr } 4032729Sdfr 4042729Sdfrfound: 4052729Sdfr /* Construct the unique msqid */ 40630994Sphk p->p_retval[0] = IXSEQ_TO_IPCID(msqid, msqptr->msg_perm); 4072729Sdfr return(0); 4082729Sdfr} 4092729Sdfr 41012866Speter#ifndef _SYS_SYSPROTO_H_ 4112729Sdfrstruct msgsnd_args { 4122729Sdfr int msqid; 41312866Speter void *msgp; 4142729Sdfr size_t msgsz; 4152729Sdfr int msgflg; 4162729Sdfr}; 41712866Speter#endif 4182729Sdfr 41912866Speterint 42030994Sphkmsgsnd(p, uap) 4212729Sdfr struct proc *p; 4222729Sdfr register struct msgsnd_args *uap; 4232729Sdfr{ 4242729Sdfr int msqid = uap->msqid; 42512866Speter void *user_msgp = uap->msgp; 4262729Sdfr size_t msgsz = uap->msgsz; 4272729Sdfr int msgflg = uap->msgflg; 4282729Sdfr int segs_needed, eval; 4292729Sdfr struct ucred *cred = p->p_ucred; 4302729Sdfr register struct msqid_ds *msqptr; 4312729Sdfr register struct msg *msghdr; 4322729Sdfr short next; 4332729Sdfr 4342729Sdfr#ifdef MSG_DEBUG_OK 4352729Sdfr printf("call to msgsnd(%d, 0x%x, %d, %d)\n", msqid, user_msgp, msgsz, 4362729Sdfr msgflg); 4372729Sdfr#endif 4382729Sdfr 4392729Sdfr msqid = IPCID_TO_IX(msqid); 4402729Sdfr 4412729Sdfr if (msqid < 0 || msqid >= msginfo.msgmni) { 4422729Sdfr#ifdef MSG_DEBUG_OK 4432729Sdfr printf("msqid (%d) out of range (0<=msqid<%d)\n", msqid, 4442729Sdfr msginfo.msgmni); 4452729Sdfr#endif 4462729Sdfr return(EINVAL); 4472729Sdfr } 4482729Sdfr 4492729Sdfr msqptr = &msqids[msqid]; 4502729Sdfr if (msqptr->msg_qbytes == 0) { 4512729Sdfr#ifdef MSG_DEBUG_OK 4522729Sdfr printf("no such message queue id\n"); 4532729Sdfr#endif 4542729Sdfr return(EINVAL); 4552729Sdfr } 4562729Sdfr if (msqptr->msg_perm.seq != IPCID_TO_SEQ(uap->msqid)) { 4572729Sdfr#ifdef MSG_DEBUG_OK 4582729Sdfr printf("wrong sequence number\n"); 4592729Sdfr#endif 4602729Sdfr return(EINVAL); 4612729Sdfr } 4622729Sdfr 4632729Sdfr if ((eval = ipcperm(cred, &msqptr->msg_perm, IPC_W))) { 4642729Sdfr#ifdef MSG_DEBUG_OK 4652729Sdfr printf("requester doesn't have write access\n"); 4662729Sdfr#endif 4672729Sdfr return(eval); 4682729Sdfr } 4692729Sdfr 4702729Sdfr segs_needed = (msgsz + msginfo.msgssz - 1) / msginfo.msgssz; 4712729Sdfr#ifdef MSG_DEBUG_OK 4722729Sdfr printf("msgsz=%d, msgssz=%d, segs_needed=%d\n", msgsz, msginfo.msgssz, 4732729Sdfr segs_needed); 4742729Sdfr#endif 4752729Sdfr for (;;) { 4762729Sdfr int need_more_resources = 0; 4772729Sdfr 4782729Sdfr /* 4792729Sdfr * check msgsz 4802729Sdfr * (inside this loop in case msg_qbytes changes while we sleep) 4812729Sdfr */ 4822729Sdfr 4832836Sdg if (msgsz > msqptr->msg_qbytes) { 4842729Sdfr#ifdef MSG_DEBUG_OK 4852729Sdfr printf("msgsz > msqptr->msg_qbytes\n"); 4862729Sdfr#endif 4872729Sdfr return(EINVAL); 4882729Sdfr } 4892729Sdfr 4902729Sdfr if (msqptr->msg_perm.mode & MSG_LOCKED) { 4912729Sdfr#ifdef MSG_DEBUG_OK 4922729Sdfr printf("msqid is locked\n"); 4932729Sdfr#endif 4942729Sdfr need_more_resources = 1; 4952729Sdfr } 4962729Sdfr if (msgsz + msqptr->msg_cbytes > msqptr->msg_qbytes) { 4972729Sdfr#ifdef MSG_DEBUG_OK 4982729Sdfr printf("msgsz + msg_cbytes > msg_qbytes\n"); 4992729Sdfr#endif 5002729Sdfr need_more_resources = 1; 5012729Sdfr } 5022729Sdfr if (segs_needed > nfree_msgmaps) { 5032729Sdfr#ifdef MSG_DEBUG_OK 5042729Sdfr printf("segs_needed > nfree_msgmaps\n"); 5052729Sdfr#endif 5062729Sdfr need_more_resources = 1; 5072729Sdfr } 5082729Sdfr if (free_msghdrs == NULL) { 5092729Sdfr#ifdef MSG_DEBUG_OK 5102729Sdfr printf("no more msghdrs\n"); 5112729Sdfr#endif 5122729Sdfr need_more_resources = 1; 5132729Sdfr } 5142729Sdfr 5152729Sdfr if (need_more_resources) { 5162729Sdfr int we_own_it; 5172729Sdfr 5182729Sdfr if ((msgflg & IPC_NOWAIT) != 0) { 5192729Sdfr#ifdef MSG_DEBUG_OK 5202729Sdfr printf("need more resources but caller doesn't want to wait\n"); 5212729Sdfr#endif 5222729Sdfr return(EAGAIN); 5232729Sdfr } 5242729Sdfr 5252729Sdfr if ((msqptr->msg_perm.mode & MSG_LOCKED) != 0) { 5262729Sdfr#ifdef MSG_DEBUG_OK 5272729Sdfr printf("we don't own the msqid_ds\n"); 5282729Sdfr#endif 5292729Sdfr we_own_it = 0; 5302729Sdfr } else { 5312729Sdfr /* Force later arrivals to wait for our 5322729Sdfr request */ 5332729Sdfr#ifdef MSG_DEBUG_OK 5342729Sdfr printf("we own the msqid_ds\n"); 5352729Sdfr#endif 5362729Sdfr msqptr->msg_perm.mode |= MSG_LOCKED; 5372729Sdfr we_own_it = 1; 5382729Sdfr } 5392729Sdfr#ifdef MSG_DEBUG_OK 5402729Sdfr printf("goodnight\n"); 5412729Sdfr#endif 5422729Sdfr eval = tsleep((caddr_t)msqptr, (PZERO - 4) | PCATCH, 5432729Sdfr "msgwait", 0); 5442729Sdfr#ifdef MSG_DEBUG_OK 5452729Sdfr printf("good morning, eval=%d\n", eval); 5462729Sdfr#endif 5472729Sdfr if (we_own_it) 5482729Sdfr msqptr->msg_perm.mode &= ~MSG_LOCKED; 5492729Sdfr if (eval != 0) { 5502729Sdfr#ifdef MSG_DEBUG_OK 5512729Sdfr printf("msgsnd: interrupted system call\n"); 5522729Sdfr#endif 5532729Sdfr return(EINTR); 5542729Sdfr } 5552729Sdfr 5562729Sdfr /* 5572729Sdfr * Make sure that the msq queue still exists 5582729Sdfr */ 5592729Sdfr 5602729Sdfr if (msqptr->msg_qbytes == 0) { 5612729Sdfr#ifdef MSG_DEBUG_OK 5622729Sdfr printf("msqid deleted\n"); 5632729Sdfr#endif 5642729Sdfr /* The SVID says to return EIDRM. */ 5652729Sdfr#ifdef EIDRM 5662729Sdfr return(EIDRM); 5672729Sdfr#else 5682729Sdfr /* Unfortunately, BSD doesn't define that code 5692729Sdfr yet! */ 5702729Sdfr return(EINVAL); 5712729Sdfr#endif 5722729Sdfr } 5732729Sdfr 5742729Sdfr } else { 5752729Sdfr#ifdef MSG_DEBUG_OK 5762729Sdfr printf("got all the resources that we need\n"); 5772729Sdfr#endif 5782729Sdfr break; 5792729Sdfr } 5802729Sdfr } 5812729Sdfr 5822729Sdfr /* 5832729Sdfr * We have the resources that we need. 5842729Sdfr * Make sure! 5852729Sdfr */ 5862729Sdfr 5872729Sdfr if (msqptr->msg_perm.mode & MSG_LOCKED) 5882729Sdfr panic("msg_perm.mode & MSG_LOCKED"); 5892729Sdfr if (segs_needed > nfree_msgmaps) 5902729Sdfr panic("segs_needed > nfree_msgmaps"); 5912729Sdfr if (msgsz + msqptr->msg_cbytes > msqptr->msg_qbytes) 5922729Sdfr panic("msgsz + msg_cbytes > msg_qbytes"); 5932729Sdfr if (free_msghdrs == NULL) 5942729Sdfr panic("no more msghdrs"); 5952729Sdfr 5962729Sdfr /* 5972729Sdfr * Re-lock the msqid_ds in case we page-fault when copying in the 5982729Sdfr * message 5992729Sdfr */ 6002729Sdfr 6012729Sdfr if ((msqptr->msg_perm.mode & MSG_LOCKED) != 0) 6022729Sdfr panic("msqid_ds is already locked"); 6032729Sdfr msqptr->msg_perm.mode |= MSG_LOCKED; 6042729Sdfr 6052729Sdfr /* 6062729Sdfr * Allocate a message header 6072729Sdfr */ 6082729Sdfr 6092729Sdfr msghdr = free_msghdrs; 6102729Sdfr free_msghdrs = msghdr->msg_next; 6112729Sdfr msghdr->msg_spot = -1; 6122729Sdfr msghdr->msg_ts = msgsz; 6132729Sdfr 6142729Sdfr /* 6152729Sdfr * Allocate space for the message 6162729Sdfr */ 6172729Sdfr 6182729Sdfr while (segs_needed > 0) { 6192729Sdfr if (nfree_msgmaps <= 0) 6202729Sdfr panic("not enough msgmaps"); 6212729Sdfr if (free_msgmaps == -1) 6222729Sdfr panic("nil free_msgmaps"); 6232729Sdfr next = free_msgmaps; 6242729Sdfr if (next <= -1) 6252729Sdfr panic("next too low #1"); 6262729Sdfr if (next >= msginfo.msgseg) 6272729Sdfr panic("next out of range #1"); 6282729Sdfr#ifdef MSG_DEBUG_OK 6292729Sdfr printf("allocating segment %d to message\n", next); 6302729Sdfr#endif 6312729Sdfr free_msgmaps = msgmaps[next].next; 6322729Sdfr nfree_msgmaps--; 6332729Sdfr msgmaps[next].next = msghdr->msg_spot; 6342729Sdfr msghdr->msg_spot = next; 6352729Sdfr segs_needed--; 6362729Sdfr } 6372729Sdfr 6382729Sdfr /* 6392729Sdfr * Copy in the message type 6402729Sdfr */ 6412729Sdfr 6422729Sdfr if ((eval = copyin(user_msgp, &msghdr->msg_type, 6432729Sdfr sizeof(msghdr->msg_type))) != 0) { 6442729Sdfr#ifdef MSG_DEBUG_OK 6452729Sdfr printf("error %d copying the message type\n", eval); 6462729Sdfr#endif 6472729Sdfr msg_freehdr(msghdr); 6482729Sdfr msqptr->msg_perm.mode &= ~MSG_LOCKED; 6492729Sdfr wakeup((caddr_t)msqptr); 6502729Sdfr return(eval); 6512729Sdfr } 65217971Sbde user_msgp = (char *)user_msgp + sizeof(msghdr->msg_type); 6532729Sdfr 6542729Sdfr /* 6552729Sdfr * Validate the message type 6562729Sdfr */ 6572729Sdfr 6582729Sdfr if (msghdr->msg_type < 1) { 6592729Sdfr msg_freehdr(msghdr); 6602729Sdfr msqptr->msg_perm.mode &= ~MSG_LOCKED; 6612729Sdfr wakeup((caddr_t)msqptr); 6622729Sdfr#ifdef MSG_DEBUG_OK 6632729Sdfr printf("mtype (%d) < 1\n", msghdr->msg_type); 6642729Sdfr#endif 6652729Sdfr return(EINVAL); 6662729Sdfr } 6672729Sdfr 6682729Sdfr /* 6692729Sdfr * Copy in the message body 6702729Sdfr */ 6712729Sdfr 6722729Sdfr next = msghdr->msg_spot; 6732729Sdfr while (msgsz > 0) { 6742729Sdfr size_t tlen; 6752729Sdfr if (msgsz > msginfo.msgssz) 6762729Sdfr tlen = msginfo.msgssz; 6772729Sdfr else 6782729Sdfr tlen = msgsz; 6792729Sdfr if (next <= -1) 6802729Sdfr panic("next too low #2"); 6812729Sdfr if (next >= msginfo.msgseg) 6822729Sdfr panic("next out of range #2"); 6832729Sdfr if ((eval = copyin(user_msgp, &msgpool[next * msginfo.msgssz], 6842729Sdfr tlen)) != 0) { 6852729Sdfr#ifdef MSG_DEBUG_OK 6862729Sdfr printf("error %d copying in message segment\n", eval); 6872729Sdfr#endif 6882729Sdfr msg_freehdr(msghdr); 6892729Sdfr msqptr->msg_perm.mode &= ~MSG_LOCKED; 6902729Sdfr wakeup((caddr_t)msqptr); 6912729Sdfr return(eval); 6922729Sdfr } 6932729Sdfr msgsz -= tlen; 69417971Sbde user_msgp = (char *)user_msgp + tlen; 6952729Sdfr next = msgmaps[next].next; 6962729Sdfr } 6972729Sdfr if (next != -1) 6982729Sdfr panic("didn't use all the msg segments"); 6992729Sdfr 7002729Sdfr /* 7012729Sdfr * We've got the message. Unlock the msqid_ds. 7022729Sdfr */ 7032729Sdfr 7042729Sdfr msqptr->msg_perm.mode &= ~MSG_LOCKED; 7052729Sdfr 7062729Sdfr /* 7072729Sdfr * Make sure that the msqid_ds is still allocated. 7082729Sdfr */ 7092729Sdfr 7102729Sdfr if (msqptr->msg_qbytes == 0) { 7112729Sdfr msg_freehdr(msghdr); 7122729Sdfr wakeup((caddr_t)msqptr); 7132729Sdfr /* The SVID says to return EIDRM. */ 7142729Sdfr#ifdef EIDRM 7152729Sdfr return(EIDRM); 7162729Sdfr#else 7172729Sdfr /* Unfortunately, BSD doesn't define that code yet! */ 7182729Sdfr return(EINVAL); 7192729Sdfr#endif 7202729Sdfr } 7212729Sdfr 7222729Sdfr /* 7232729Sdfr * Put the message into the queue 7242729Sdfr */ 7252729Sdfr 7262729Sdfr if (msqptr->msg_first == NULL) { 7272729Sdfr msqptr->msg_first = msghdr; 7282729Sdfr msqptr->msg_last = msghdr; 7292729Sdfr } else { 7302729Sdfr msqptr->msg_last->msg_next = msghdr; 7312729Sdfr msqptr->msg_last = msghdr; 7322729Sdfr } 7332729Sdfr msqptr->msg_last->msg_next = NULL; 7342729Sdfr 7352729Sdfr msqptr->msg_cbytes += msghdr->msg_ts; 7362729Sdfr msqptr->msg_qnum++; 7372729Sdfr msqptr->msg_lspid = p->p_pid; 73834961Sphk msqptr->msg_stime = time_second; 7392729Sdfr 7402729Sdfr wakeup((caddr_t)msqptr); 74130994Sphk p->p_retval[0] = 0; 7422729Sdfr return(0); 7432729Sdfr} 7442729Sdfr 74512866Speter#ifndef _SYS_SYSPROTO_H_ 7462729Sdfrstruct msgrcv_args { 7472729Sdfr int msqid; 7482729Sdfr void *msgp; 7492729Sdfr size_t msgsz; 7502729Sdfr long msgtyp; 7512729Sdfr int msgflg; 7522729Sdfr}; 75312866Speter#endif 7542729Sdfr 75512866Speterint 75630994Sphkmsgrcv(p, uap) 7572729Sdfr struct proc *p; 7582729Sdfr register struct msgrcv_args *uap; 7592729Sdfr{ 7602729Sdfr int msqid = uap->msqid; 7612729Sdfr void *user_msgp = uap->msgp; 7622729Sdfr size_t msgsz = uap->msgsz; 7632729Sdfr long msgtyp = uap->msgtyp; 7642729Sdfr int msgflg = uap->msgflg; 7652729Sdfr size_t len; 7662729Sdfr struct ucred *cred = p->p_ucred; 7672729Sdfr register struct msqid_ds *msqptr; 7682729Sdfr register struct msg *msghdr; 7692729Sdfr int eval; 7702729Sdfr short next; 7712729Sdfr 7722729Sdfr#ifdef MSG_DEBUG_OK 7732729Sdfr printf("call to msgrcv(%d, 0x%x, %d, %ld, %d)\n", msqid, user_msgp, 7742729Sdfr msgsz, msgtyp, msgflg); 7752729Sdfr#endif 7762729Sdfr 7772729Sdfr msqid = IPCID_TO_IX(msqid); 7782729Sdfr 7792729Sdfr if (msqid < 0 || msqid >= msginfo.msgmni) { 7802729Sdfr#ifdef MSG_DEBUG_OK 7812729Sdfr printf("msqid (%d) out of range (0<=msqid<%d)\n", msqid, 7822729Sdfr msginfo.msgmni); 7832729Sdfr#endif 7842729Sdfr return(EINVAL); 7852729Sdfr } 7862729Sdfr 7872729Sdfr msqptr = &msqids[msqid]; 7882729Sdfr if (msqptr->msg_qbytes == 0) { 7892729Sdfr#ifdef MSG_DEBUG_OK 7902729Sdfr printf("no such message queue id\n"); 7912729Sdfr#endif 7922729Sdfr return(EINVAL); 7932729Sdfr } 7942729Sdfr if (msqptr->msg_perm.seq != IPCID_TO_SEQ(uap->msqid)) { 7952729Sdfr#ifdef MSG_DEBUG_OK 7962729Sdfr printf("wrong sequence number\n"); 7972729Sdfr#endif 7982729Sdfr return(EINVAL); 7992729Sdfr } 8002729Sdfr 8012729Sdfr if ((eval = ipcperm(cred, &msqptr->msg_perm, IPC_R))) { 8022729Sdfr#ifdef MSG_DEBUG_OK 8032729Sdfr printf("requester doesn't have read access\n"); 8042729Sdfr#endif 8052729Sdfr return(eval); 8062729Sdfr } 8072729Sdfr 8082729Sdfr msghdr = NULL; 8092729Sdfr while (msghdr == NULL) { 8102729Sdfr if (msgtyp == 0) { 8112729Sdfr msghdr = msqptr->msg_first; 8122729Sdfr if (msghdr != NULL) { 8132729Sdfr if (msgsz < msghdr->msg_ts && 8142729Sdfr (msgflg & MSG_NOERROR) == 0) { 8152729Sdfr#ifdef MSG_DEBUG_OK 8162729Sdfr printf("first message on the queue is too big (want %d, got %d)\n", 8172729Sdfr msgsz, msghdr->msg_ts); 8182729Sdfr#endif 8192729Sdfr return(E2BIG); 8202729Sdfr } 8212729Sdfr if (msqptr->msg_first == msqptr->msg_last) { 8222729Sdfr msqptr->msg_first = NULL; 8232729Sdfr msqptr->msg_last = NULL; 8242729Sdfr } else { 8252729Sdfr msqptr->msg_first = msghdr->msg_next; 8262729Sdfr if (msqptr->msg_first == NULL) 8272729Sdfr panic("msg_first/last screwed up #1"); 8282729Sdfr } 8292729Sdfr } 8302729Sdfr } else { 8312729Sdfr struct msg *previous; 8322729Sdfr struct msg **prev; 8332729Sdfr 8342729Sdfr previous = NULL; 8352729Sdfr prev = &(msqptr->msg_first); 8362729Sdfr while ((msghdr = *prev) != NULL) { 8372729Sdfr /* 8382729Sdfr * Is this message's type an exact match or is 8392729Sdfr * this message's type less than or equal to 8402729Sdfr * the absolute value of a negative msgtyp? 8412729Sdfr * Note that the second half of this test can 8422729Sdfr * NEVER be true if msgtyp is positive since 8432729Sdfr * msg_type is always positive! 8442729Sdfr */ 8452729Sdfr 8462729Sdfr if (msgtyp == msghdr->msg_type || 8472729Sdfr msghdr->msg_type <= -msgtyp) { 8482729Sdfr#ifdef MSG_DEBUG_OK 8492729Sdfr printf("found message type %d, requested %d\n", 8502729Sdfr msghdr->msg_type, msgtyp); 8512729Sdfr#endif 8522729Sdfr if (msgsz < msghdr->msg_ts && 8532729Sdfr (msgflg & MSG_NOERROR) == 0) { 8542729Sdfr#ifdef MSG_DEBUG_OK 8552729Sdfr printf("requested message on the queue is too big (want %d, got %d)\n", 8562729Sdfr msgsz, msghdr->msg_ts); 8572729Sdfr#endif 8582729Sdfr return(E2BIG); 8592729Sdfr } 8602729Sdfr *prev = msghdr->msg_next; 8612729Sdfr if (msghdr == msqptr->msg_last) { 8622729Sdfr if (previous == NULL) { 8632729Sdfr if (prev != 8642729Sdfr &msqptr->msg_first) 8652729Sdfr panic("msg_first/last screwed up #2"); 8662729Sdfr msqptr->msg_first = 8672729Sdfr NULL; 8682729Sdfr msqptr->msg_last = 8692729Sdfr NULL; 8702729Sdfr } else { 8712729Sdfr if (prev == 8722729Sdfr &msqptr->msg_first) 8732729Sdfr panic("msg_first/last screwed up #3"); 8742729Sdfr msqptr->msg_last = 8752729Sdfr previous; 8762729Sdfr } 8772729Sdfr } 8782729Sdfr break; 8792729Sdfr } 8802729Sdfr previous = msghdr; 8812729Sdfr prev = &(msghdr->msg_next); 8822729Sdfr } 8832729Sdfr } 8842729Sdfr 8852729Sdfr /* 8862729Sdfr * We've either extracted the msghdr for the appropriate 8872729Sdfr * message or there isn't one. 8882729Sdfr * If there is one then bail out of this loop. 8892729Sdfr */ 8902729Sdfr 8912729Sdfr if (msghdr != NULL) 8922729Sdfr break; 8932729Sdfr 8942729Sdfr /* 8952729Sdfr * Hmph! No message found. Does the user want to wait? 8962729Sdfr */ 8972729Sdfr 8982729Sdfr if ((msgflg & IPC_NOWAIT) != 0) { 8992729Sdfr#ifdef MSG_DEBUG_OK 9002729Sdfr printf("no appropriate message found (msgtyp=%d)\n", 9012729Sdfr msgtyp); 9022729Sdfr#endif 9032729Sdfr /* The SVID says to return ENOMSG. */ 9042729Sdfr#ifdef ENOMSG 9052729Sdfr return(ENOMSG); 9062729Sdfr#else 9072729Sdfr /* Unfortunately, BSD doesn't define that code yet! */ 9082729Sdfr return(EAGAIN); 9092729Sdfr#endif 9102729Sdfr } 9112729Sdfr 9122729Sdfr /* 9132729Sdfr * Wait for something to happen 9142729Sdfr */ 9152729Sdfr 9162729Sdfr#ifdef MSG_DEBUG_OK 9172729Sdfr printf("msgrcv: goodnight\n"); 9182729Sdfr#endif 9192729Sdfr eval = tsleep((caddr_t)msqptr, (PZERO - 4) | PCATCH, "msgwait", 9202729Sdfr 0); 9212729Sdfr#ifdef MSG_DEBUG_OK 9222729Sdfr printf("msgrcv: good morning (eval=%d)\n", eval); 9232729Sdfr#endif 9242729Sdfr 9252729Sdfr if (eval != 0) { 9262729Sdfr#ifdef MSG_DEBUG_OK 9272729Sdfr printf("msgsnd: interrupted system call\n"); 9282729Sdfr#endif 9292729Sdfr return(EINTR); 9302729Sdfr } 9312729Sdfr 9322729Sdfr /* 9332729Sdfr * Make sure that the msq queue still exists 9342729Sdfr */ 9352729Sdfr 9362729Sdfr if (msqptr->msg_qbytes == 0 || 9372729Sdfr msqptr->msg_perm.seq != IPCID_TO_SEQ(uap->msqid)) { 9382729Sdfr#ifdef MSG_DEBUG_OK 9392729Sdfr printf("msqid deleted\n"); 9402729Sdfr#endif 9412729Sdfr /* The SVID says to return EIDRM. */ 9422729Sdfr#ifdef EIDRM 9432729Sdfr return(EIDRM); 9442729Sdfr#else 9452729Sdfr /* Unfortunately, BSD doesn't define that code yet! */ 9462729Sdfr return(EINVAL); 9472729Sdfr#endif 9482729Sdfr } 9492729Sdfr } 9502729Sdfr 9512729Sdfr /* 9522729Sdfr * Return the message to the user. 9532729Sdfr * 9542729Sdfr * First, do the bookkeeping (before we risk being interrupted). 9552729Sdfr */ 9562729Sdfr 9572729Sdfr msqptr->msg_cbytes -= msghdr->msg_ts; 9582729Sdfr msqptr->msg_qnum--; 9592729Sdfr msqptr->msg_lrpid = p->p_pid; 96034961Sphk msqptr->msg_rtime = time_second; 9612729Sdfr 9622729Sdfr /* 9632729Sdfr * Make msgsz the actual amount that we'll be returning. 9642729Sdfr * Note that this effectively truncates the message if it is too long 9652729Sdfr * (since msgsz is never increased). 9662729Sdfr */ 9672729Sdfr 9682729Sdfr#ifdef MSG_DEBUG_OK 9692729Sdfr printf("found a message, msgsz=%d, msg_ts=%d\n", msgsz, 9702729Sdfr msghdr->msg_ts); 9712729Sdfr#endif 9722729Sdfr if (msgsz > msghdr->msg_ts) 9732729Sdfr msgsz = msghdr->msg_ts; 9742729Sdfr 9752729Sdfr /* 9762729Sdfr * Return the type to the user. 9772729Sdfr */ 9782729Sdfr 9792729Sdfr eval = copyout((caddr_t)&(msghdr->msg_type), user_msgp, 9802729Sdfr sizeof(msghdr->msg_type)); 9812729Sdfr if (eval != 0) { 9822729Sdfr#ifdef MSG_DEBUG_OK 9832729Sdfr printf("error (%d) copying out message type\n", eval); 9842729Sdfr#endif 9852729Sdfr msg_freehdr(msghdr); 9862729Sdfr wakeup((caddr_t)msqptr); 9872729Sdfr return(eval); 9882729Sdfr } 98917971Sbde user_msgp = (char *)user_msgp + sizeof(msghdr->msg_type); 9902729Sdfr 9912729Sdfr /* 9922729Sdfr * Return the segments to the user 9932729Sdfr */ 9942729Sdfr 9952729Sdfr next = msghdr->msg_spot; 9962729Sdfr for (len = 0; len < msgsz; len += msginfo.msgssz) { 9972729Sdfr size_t tlen; 9982729Sdfr 9992729Sdfr if (msgsz > msginfo.msgssz) 10002729Sdfr tlen = msginfo.msgssz; 10012729Sdfr else 10022729Sdfr tlen = msgsz; 10032729Sdfr if (next <= -1) 10042729Sdfr panic("next too low #3"); 10052729Sdfr if (next >= msginfo.msgseg) 10062729Sdfr panic("next out of range #3"); 10072729Sdfr eval = copyout((caddr_t)&msgpool[next * msginfo.msgssz], 10082729Sdfr user_msgp, tlen); 10092729Sdfr if (eval != 0) { 10102729Sdfr#ifdef MSG_DEBUG_OK 10112729Sdfr printf("error (%d) copying out message segment\n", 10122729Sdfr eval); 10132729Sdfr#endif 10142729Sdfr msg_freehdr(msghdr); 10152729Sdfr wakeup((caddr_t)msqptr); 10162729Sdfr return(eval); 10172729Sdfr } 101817971Sbde user_msgp = (char *)user_msgp + tlen; 10192729Sdfr next = msgmaps[next].next; 10202729Sdfr } 10212729Sdfr 10222729Sdfr /* 10232729Sdfr * Done, return the actual number of bytes copied out. 10242729Sdfr */ 10252729Sdfr 10262729Sdfr msg_freehdr(msghdr); 10272729Sdfr wakeup((caddr_t)msqptr); 102830994Sphk p->p_retval[0] = msgsz; 10292729Sdfr return(0); 10302729Sdfr} 1031