sysv_msg.c revision 139804
1139804Simp/*- 22729Sdfr * Implementation of SVID messages 32729Sdfr * 42729Sdfr * Author: Daniel Boulet 52729Sdfr * 62729Sdfr * Copyright 1993 Daniel Boulet and RTMX Inc. 72729Sdfr * 82729Sdfr * This system call was implemented by Daniel Boulet under contract from RTMX. 92729Sdfr * 102729Sdfr * Redistribution and use in source forms, with and without modification, 112729Sdfr * are permitted provided that this entire comment appears intact. 122729Sdfr * 132729Sdfr * Redistribution in binary form may occur without any restrictions. 142729Sdfr * Obviously, it would be nice if you gave credit where credit is due 152729Sdfr * but requiring it would be too onerous. 162729Sdfr * 172729Sdfr * This software is provided ``AS IS'' without any warranties of any kind. 182729Sdfr */ 192729Sdfr 20116182Sobrien#include <sys/cdefs.h> 21116182Sobrien__FBSDID("$FreeBSD: head/sys/kern/sysv_msg.c 139804 2005-01-06 23:35:40Z imp $"); 22116182Sobrien 2359839Speter#include "opt_sysvipc.h" 2459839Speter 252729Sdfr#include <sys/param.h> 262729Sdfr#include <sys/systm.h> 2711626Sbde#include <sys/sysproto.h> 282729Sdfr#include <sys/kernel.h> 292729Sdfr#include <sys/proc.h> 3082607Sdillon#include <sys/lock.h> 3182607Sdillon#include <sys/mutex.h> 32129882Sphk#include <sys/module.h> 332729Sdfr#include <sys/msg.h> 3469449Salfred#include <sys/syscall.h> 3511626Sbde#include <sys/sysent.h> 3659839Speter#include <sys/sysctl.h> 3759839Speter#include <sys/malloc.h> 3868024Srwatson#include <sys/jail.h> 392729Sdfr 4059839Speterstatic MALLOC_DEFINE(M_MSG, "msg", "SVID compatible message queues"); 4159839Speter 4292723Salfredstatic void msginit(void); 4392723Salfredstatic int msgunload(void); 4492723Salfredstatic int sysvmsg_modload(struct module *, int, void *); 4510358Sjulian 46100523Salfred#ifdef MSG_DEBUG 47100523Salfred#define DPRINTF(a) printf a 48100523Salfred#else 49100523Salfred#define DPRINTF(a) 50100523Salfred#endif 512729Sdfr 5292723Salfredstatic void msg_freehdr(struct msg *msghdr); 532729Sdfr 5411626Sbde/* XXX casting to (sy_call_t *) is bogus, as usual. */ 5512819Sphkstatic sy_call_t *msgcalls[] = { 5611626Sbde (sy_call_t *)msgctl, (sy_call_t *)msgget, 5711626Sbde (sy_call_t *)msgsnd, (sy_call_t *)msgrcv 5811626Sbde}; 592729Sdfr 6059839Speter#ifndef MSGSSZ 6159839Speter#define MSGSSZ 8 /* Each segment must be 2^N long */ 6259839Speter#endif 6359839Speter#ifndef MSGSEG 6459839Speter#define MSGSEG 2048 /* must be less than 32767 */ 6559839Speter#endif 6659839Speter#define MSGMAX (MSGSSZ*MSGSEG) 6759839Speter#ifndef MSGMNB 6859839Speter#define MSGMNB 2048 /* max # of bytes in a queue */ 6959839Speter#endif 7059839Speter#ifndef MSGMNI 7159839Speter#define MSGMNI 40 7259839Speter#endif 7359839Speter#ifndef MSGTQL 7459839Speter#define MSGTQL 40 7559839Speter#endif 7659839Speter 7759839Speter/* 7859839Speter * Based on the configuration parameters described in an SVR2 (yes, two) 7959839Speter * config(1m) man page. 8059839Speter * 8159839Speter * Each message is broken up and stored in segments that are msgssz bytes 8259839Speter * long. For efficiency reasons, this should be a power of two. Also, 8359839Speter * it doesn't make sense if it is less than 8 or greater than about 256. 8459839Speter * Consequently, msginit in kern/sysv_msg.c checks that msgssz is a power of 8559839Speter * two between 8 and 1024 inclusive (and panic's if it isn't). 8659839Speter */ 8759839Speterstruct msginfo msginfo = { 8859839Speter MSGMAX, /* max chars in a message */ 8959839Speter MSGMNI, /* # of message queue identifiers */ 9059839Speter MSGMNB, /* max chars in a queue */ 9159839Speter MSGTQL, /* max messages in system */ 9259839Speter MSGSSZ, /* size of a message segment */ 9359839Speter /* (must be small power of 2 greater than 4) */ 9459839Speter MSGSEG /* number of message segments */ 9559839Speter}; 9659839Speter 9759839Speter/* 9859839Speter * macros to convert between msqid_ds's and msqid's. 9959839Speter * (specific to this implementation) 10059839Speter */ 10159839Speter#define MSQID(ix,ds) ((ix) & 0xffff | (((ds).msg_perm.seq << 16) & 0xffff0000)) 10259839Speter#define MSQID_IX(id) ((id) & 0xffff) 10359839Speter#define MSQID_SEQ(id) (((id) >> 16) & 0xffff) 10459839Speter 10559839Speter/* 10659839Speter * The rest of this file is specific to this particular implementation. 10759839Speter */ 10859839Speter 10959839Speterstruct msgmap { 11059839Speter short next; /* next segment in buffer */ 11159839Speter /* -1 -> available */ 11259839Speter /* 0..(MSGSEG-1) -> index of next segment */ 11359839Speter}; 11459839Speter 11559839Speter#define MSG_LOCKED 01000 /* Is this msqid_ds locked? */ 11659839Speter 11712819Sphkstatic int nfree_msgmaps; /* # of free map entries */ 11812819Sphkstatic short free_msgmaps; /* head of linked list of free map entries */ 11959839Speterstatic struct msg *free_msghdrs;/* list of free msg headers */ 12059839Speterstatic char *msgpool; /* MSGMAX byte long msg buffer pool */ 12159839Speterstatic struct msgmap *msgmaps; /* MSGSEG msgmap structures */ 12259839Speterstatic struct msg *msghdrs; /* MSGTQL msg headers */ 123137613Srwatsonstatic struct msqid_kernel *msqids; /* MSGMNI msqid_kernel struct's */ 124101772Salfredstatic struct mtx msq_mtx; /* global mutex for message queues. */ 1252729Sdfr 12659839Speterstatic void 12769449Salfredmsginit() 1282729Sdfr{ 1292729Sdfr register int i; 1302729Sdfr 13183765Smr TUNABLE_INT_FETCH("kern.ipc.msgseg", &msginfo.msgseg); 13283765Smr TUNABLE_INT_FETCH("kern.ipc.msgssz", &msginfo.msgssz); 13383765Smr msginfo.msgmax = msginfo.msgseg * msginfo.msgssz; 13483765Smr TUNABLE_INT_FETCH("kern.ipc.msgmni", &msginfo.msgmni); 135139436Srwatson TUNABLE_INT_FETCH("kern.ipc.msgmnb", &msginfo.msgmnb); 136139436Srwatson TUNABLE_INT_FETCH("kern.ipc.msgtql", &msginfo.msgtql); 13783765Smr 138111119Simp msgpool = malloc(msginfo.msgmax, M_MSG, M_WAITOK); 13959839Speter if (msgpool == NULL) 14059839Speter panic("msgpool is NULL"); 141111119Simp msgmaps = malloc(sizeof(struct msgmap) * msginfo.msgseg, M_MSG, M_WAITOK); 14259839Speter if (msgmaps == NULL) 14359839Speter panic("msgmaps is NULL"); 144111119Simp msghdrs = malloc(sizeof(struct msg) * msginfo.msgtql, M_MSG, M_WAITOK); 14559839Speter if (msghdrs == NULL) 14659839Speter panic("msghdrs is NULL"); 147137613Srwatson msqids = malloc(sizeof(struct msqid_kernel) * msginfo.msgmni, M_MSG, 148137613Srwatson M_WAITOK); 14959839Speter if (msqids == NULL) 15059839Speter panic("msqids is NULL"); 15159839Speter 1522729Sdfr /* 1532729Sdfr * msginfo.msgssz should be a power of two for efficiency reasons. 1542729Sdfr * It is also pretty silly if msginfo.msgssz is less than 8 1552729Sdfr * or greater than about 256 so ... 1562729Sdfr */ 1572729Sdfr 1582729Sdfr i = 8; 1592729Sdfr while (i < 1024 && i != msginfo.msgssz) 1602729Sdfr i <<= 1; 1612729Sdfr if (i != msginfo.msgssz) { 162100523Salfred DPRINTF(("msginfo.msgssz=%d (0x%x)\n", msginfo.msgssz, 163100523Salfred msginfo.msgssz)); 1642729Sdfr panic("msginfo.msgssz not a small power of 2"); 1652729Sdfr } 1662729Sdfr 1672729Sdfr if (msginfo.msgseg > 32767) { 168100523Salfred DPRINTF(("msginfo.msgseg=%d\n", msginfo.msgseg)); 1692729Sdfr panic("msginfo.msgseg > 32767"); 1702729Sdfr } 1712729Sdfr 1722729Sdfr if (msgmaps == NULL) 1732729Sdfr panic("msgmaps is NULL"); 1742729Sdfr 1752729Sdfr for (i = 0; i < msginfo.msgseg; i++) { 1762729Sdfr if (i > 0) 1772729Sdfr msgmaps[i-1].next = i; 1782729Sdfr msgmaps[i].next = -1; /* implies entry is available */ 1792729Sdfr } 1802729Sdfr free_msgmaps = 0; 1812729Sdfr nfree_msgmaps = msginfo.msgseg; 1822729Sdfr 1832729Sdfr if (msghdrs == NULL) 1842729Sdfr panic("msghdrs is NULL"); 1852729Sdfr 1862729Sdfr for (i = 0; i < msginfo.msgtql; i++) { 1872729Sdfr msghdrs[i].msg_type = 0; 1882729Sdfr if (i > 0) 1892729Sdfr msghdrs[i-1].msg_next = &msghdrs[i]; 1902729Sdfr msghdrs[i].msg_next = NULL; 1912729Sdfr } 1922729Sdfr free_msghdrs = &msghdrs[0]; 1932729Sdfr 1942729Sdfr if (msqids == NULL) 1952729Sdfr panic("msqids is NULL"); 1962729Sdfr 1972729Sdfr for (i = 0; i < msginfo.msgmni; i++) { 198137613Srwatson msqids[i].u.msg_qbytes = 0; /* implies entry is available */ 199137613Srwatson msqids[i].u.msg_perm.seq = 0; /* reset to a known value */ 200137613Srwatson msqids[i].u.msg_perm.mode = 0; 2012729Sdfr } 202101772Salfred mtx_init(&msq_mtx, "msq", NULL, MTX_DEF); 2032729Sdfr} 2042729Sdfr 20569449Salfredstatic int 20669449Salfredmsgunload() 20769449Salfred{ 208137613Srwatson struct msqid_kernel *msqkptr; 20969449Salfred int msqid; 21069449Salfred 21169449Salfred for (msqid = 0; msqid < msginfo.msgmni; msqid++) { 21269449Salfred /* 21369449Salfred * Look for an unallocated and unlocked msqid_ds. 21469449Salfred * msqid_ds's can be locked by msgsnd or msgrcv while 21569449Salfred * they are copying the message in/out. We can't 21669449Salfred * re-use the entry until they release it. 21769449Salfred */ 218137613Srwatson msqkptr = &msqids[msqid]; 219137613Srwatson if (msqkptr->u.msg_qbytes != 0 || 220137613Srwatson (msqkptr->u.msg_perm.mode & MSG_LOCKED) != 0) 22169449Salfred break; 22269449Salfred } 22369449Salfred if (msqid != msginfo.msgmni) 22469449Salfred return (EBUSY); 22569449Salfred 22669449Salfred free(msgpool, M_MSG); 22769449Salfred free(msgmaps, M_MSG); 22869449Salfred free(msghdrs, M_MSG); 22969449Salfred free(msqids, M_MSG); 230101772Salfred mtx_destroy(&msq_mtx); 23169449Salfred return (0); 23269449Salfred} 23369449Salfred 23469449Salfred 23569449Salfredstatic int 23669449Salfredsysvmsg_modload(struct module *module, int cmd, void *arg) 23769449Salfred{ 23869449Salfred int error = 0; 23969449Salfred 24069449Salfred switch (cmd) { 24169449Salfred case MOD_LOAD: 24269449Salfred msginit(); 24369449Salfred break; 24469449Salfred case MOD_UNLOAD: 24569449Salfred error = msgunload(); 24669449Salfred break; 24769449Salfred case MOD_SHUTDOWN: 24869449Salfred break; 24969449Salfred default: 25069449Salfred error = EINVAL; 25169449Salfred break; 25269449Salfred } 25369449Salfred return (error); 25469449Salfred} 25569449Salfred 25671038Sdesstatic moduledata_t sysvmsg_mod = { 25771038Sdes "sysvmsg", 25869449Salfred &sysvmsg_modload, 25969449Salfred NULL 26069449Salfred}; 26169449Salfred 26288633SalfredSYSCALL_MODULE_HELPER(msgsys); 26388633SalfredSYSCALL_MODULE_HELPER(msgctl); 26488633SalfredSYSCALL_MODULE_HELPER(msgget); 26588633SalfredSYSCALL_MODULE_HELPER(msgsnd); 26688633SalfredSYSCALL_MODULE_HELPER(msgrcv); 26769449Salfred 26871038SdesDECLARE_MODULE(sysvmsg, sysvmsg_mod, 26969449Salfred SI_SUB_SYSV_MSG, SI_ORDER_FIRST); 27071038SdesMODULE_VERSION(sysvmsg, 1); 27169449Salfred 2722729Sdfr/* 2732729Sdfr * Entry point for all MSG calls 27482607Sdillon * 27582607Sdillon * MPSAFE 2762729Sdfr */ 2772729Sdfrint 27883366Sjulianmsgsys(td, uap) 27983366Sjulian struct thread *td; 28011626Sbde /* XXX actually varargs. */ 28111626Sbde struct msgsys_args /* { 282118615Snectar int which; 28311626Sbde int a2; 28411626Sbde int a3; 28511626Sbde int a4; 28611626Sbde int a5; 28711626Sbde int a6; 28811626Sbde } */ *uap; 2892729Sdfr{ 29082607Sdillon int error; 2912729Sdfr 29291703Sjhb if (!jail_sysvipc_allowed && jailed(td->td_ucred)) 29391703Sjhb return (ENOSYS); 294118615Snectar if (uap->which < 0 || 295118615Snectar uap->which >= sizeof(msgcalls)/sizeof(msgcalls[0])) 29691703Sjhb return (EINVAL); 29783366Sjulian error = (*msgcalls[uap->which])(td, &uap->a2); 29882607Sdillon return (error); 2992729Sdfr} 3002729Sdfr 3012729Sdfrstatic void 3022729Sdfrmsg_freehdr(msghdr) 3032729Sdfr struct msg *msghdr; 3042729Sdfr{ 3052729Sdfr while (msghdr->msg_ts > 0) { 3062729Sdfr short next; 3072729Sdfr if (msghdr->msg_spot < 0 || msghdr->msg_spot >= msginfo.msgseg) 3082729Sdfr panic("msghdr->msg_spot out of range"); 3092729Sdfr next = msgmaps[msghdr->msg_spot].next; 3102729Sdfr msgmaps[msghdr->msg_spot].next = free_msgmaps; 3112729Sdfr free_msgmaps = msghdr->msg_spot; 3122729Sdfr nfree_msgmaps++; 3132729Sdfr msghdr->msg_spot = next; 3142729Sdfr if (msghdr->msg_ts >= msginfo.msgssz) 3152729Sdfr msghdr->msg_ts -= msginfo.msgssz; 3162729Sdfr else 3172729Sdfr msghdr->msg_ts = 0; 3182729Sdfr } 3192729Sdfr if (msghdr->msg_spot != -1) 3202729Sdfr panic("msghdr->msg_spot != -1"); 3212729Sdfr msghdr->msg_next = free_msghdrs; 3222729Sdfr free_msghdrs = msghdr; 3232729Sdfr} 3242729Sdfr 32512866Speter#ifndef _SYS_SYSPROTO_H_ 3262729Sdfrstruct msgctl_args { 3272729Sdfr int msqid; 3282729Sdfr int cmd; 32912866Speter struct msqid_ds *buf; 3302729Sdfr}; 33112866Speter#endif 3322729Sdfr 33382607Sdillon/* 33482607Sdillon * MPSAFE 33582607Sdillon */ 33612866Speterint 33783366Sjulianmsgctl(td, uap) 33883366Sjulian struct thread *td; 3392729Sdfr register struct msgctl_args *uap; 3402729Sdfr{ 3412729Sdfr int msqid = uap->msqid; 3422729Sdfr int cmd = uap->cmd; 34312866Speter struct msqid_ds *user_msqptr = uap->buf; 34482607Sdillon int rval, error; 3452729Sdfr struct msqid_ds msqbuf; 346137613Srwatson register struct msqid_kernel *msqkptr; 3472729Sdfr 348100523Salfred DPRINTF(("call to msgctl(%d, %d, 0x%x)\n", msqid, cmd, user_msqptr)); 34991703Sjhb if (!jail_sysvipc_allowed && jailed(td->td_ucred)) 35091703Sjhb return (ENOSYS); 35191703Sjhb 3522729Sdfr msqid = IPCID_TO_IX(msqid); 3532729Sdfr 3542729Sdfr if (msqid < 0 || msqid >= msginfo.msgmni) { 355100523Salfred DPRINTF(("msqid (%d) out of range (0<=msqid<%d)\n", msqid, 356100523Salfred msginfo.msgmni)); 357101772Salfred return (EINVAL); 3582729Sdfr } 359101772Salfred if (cmd == IPC_SET && 360101772Salfred (error = copyin(user_msqptr, &msqbuf, sizeof(msqbuf))) != 0) 361101772Salfred return (error); 3622729Sdfr 363137613Srwatson msqkptr = &msqids[msqid]; 3642729Sdfr 365101772Salfred mtx_lock(&msq_mtx); 366137613Srwatson if (msqkptr->u.msg_qbytes == 0) { 367100523Salfred DPRINTF(("no such msqid\n")); 36882607Sdillon error = EINVAL; 36982607Sdillon goto done2; 3702729Sdfr } 371137613Srwatson if (msqkptr->u.msg_perm.seq != IPCID_TO_SEQ(uap->msqid)) { 372100523Salfred DPRINTF(("wrong sequence number\n")); 37382607Sdillon error = EINVAL; 37482607Sdillon goto done2; 3752729Sdfr } 3762729Sdfr 37782607Sdillon error = 0; 3782729Sdfr rval = 0; 3792729Sdfr 3802729Sdfr switch (cmd) { 3812729Sdfr 3822729Sdfr case IPC_RMID: 3832729Sdfr { 3842729Sdfr struct msg *msghdr; 385137613Srwatson if ((error = ipcperm(td, &msqkptr->u.msg_perm, IPC_M))) 38682607Sdillon goto done2; 387137613Srwatson 3882729Sdfr /* Free the message headers */ 389137613Srwatson msghdr = msqkptr->u.msg_first; 3902729Sdfr while (msghdr != NULL) { 3912729Sdfr struct msg *msghdr_tmp; 3922729Sdfr 3932729Sdfr /* Free the segments of each message */ 394137613Srwatson msqkptr->u.msg_cbytes -= msghdr->msg_ts; 395137613Srwatson msqkptr->u.msg_qnum--; 3962729Sdfr msghdr_tmp = msghdr; 3972729Sdfr msghdr = msghdr->msg_next; 3982729Sdfr msg_freehdr(msghdr_tmp); 3992729Sdfr } 4002729Sdfr 401137613Srwatson if (msqkptr->u.msg_cbytes != 0) 4022729Sdfr panic("msg_cbytes is screwed up"); 403137613Srwatson if (msqkptr->u.msg_qnum != 0) 4042729Sdfr panic("msg_qnum is screwed up"); 4052729Sdfr 406137613Srwatson msqkptr->u.msg_qbytes = 0; /* Mark it as free */ 4072729Sdfr 408137613Srwatson wakeup(msqkptr); 4092729Sdfr } 4102729Sdfr 4112729Sdfr break; 4122729Sdfr 4132729Sdfr case IPC_SET: 414137613Srwatson if ((error = ipcperm(td, &msqkptr->u.msg_perm, IPC_M))) 41582607Sdillon goto done2; 416137613Srwatson if (msqbuf.msg_qbytes > msqkptr->u.msg_qbytes) { 41793593Sjhb error = suser(td); 41882607Sdillon if (error) 41982607Sdillon goto done2; 42043426Sphk } 4212729Sdfr if (msqbuf.msg_qbytes > msginfo.msgmnb) { 422100523Salfred DPRINTF(("can't increase msg_qbytes beyond %d" 423100523Salfred "(truncating)\n", msginfo.msgmnb)); 4242729Sdfr msqbuf.msg_qbytes = msginfo.msgmnb; /* silently restrict qbytes to system limit */ 4252729Sdfr } 4262729Sdfr if (msqbuf.msg_qbytes == 0) { 427100523Salfred DPRINTF(("can't reduce msg_qbytes to 0\n")); 42882607Sdillon error = EINVAL; /* non-standard errno! */ 42982607Sdillon goto done2; 4302729Sdfr } 431137613Srwatson msqkptr->u.msg_perm.uid = msqbuf.msg_perm.uid; /* change the owner */ 432137613Srwatson msqkptr->u.msg_perm.gid = msqbuf.msg_perm.gid; /* change the owner */ 433137613Srwatson msqkptr->u.msg_perm.mode = (msqkptr->u.msg_perm.mode & ~0777) | 4342729Sdfr (msqbuf.msg_perm.mode & 0777); 435137613Srwatson msqkptr->u.msg_qbytes = msqbuf.msg_qbytes; 436137613Srwatson msqkptr->u.msg_ctime = time_second; 4372729Sdfr break; 4382729Sdfr 4392729Sdfr case IPC_STAT: 440137613Srwatson if ((error = ipcperm(td, &msqkptr->u.msg_perm, IPC_R))) { 441100523Salfred DPRINTF(("requester doesn't have read access\n")); 44282607Sdillon goto done2; 4432729Sdfr } 4442729Sdfr break; 4452729Sdfr 4462729Sdfr default: 447100523Salfred DPRINTF(("invalid command %d\n", cmd)); 44882607Sdillon error = EINVAL; 44982607Sdillon goto done2; 4502729Sdfr } 4512729Sdfr 45282607Sdillon if (error == 0) 45383366Sjulian td->td_retval[0] = rval; 45482607Sdillondone2: 455101772Salfred mtx_unlock(&msq_mtx); 456101772Salfred if (cmd == IPC_STAT && error == 0) 457137613Srwatson error = copyout(&(msqkptr->u), user_msqptr, sizeof(struct msqid_ds)); 45882607Sdillon return(error); 4592729Sdfr} 4602729Sdfr 46112866Speter#ifndef _SYS_SYSPROTO_H_ 4622729Sdfrstruct msgget_args { 4632729Sdfr key_t key; 4642729Sdfr int msgflg; 4652729Sdfr}; 46612866Speter#endif 4672729Sdfr 46882607Sdillon/* 46982607Sdillon * MPSAFE 47082607Sdillon */ 47112866Speterint 47283366Sjulianmsgget(td, uap) 47383366Sjulian struct thread *td; 4742729Sdfr register struct msgget_args *uap; 4752729Sdfr{ 47682607Sdillon int msqid, error = 0; 4772729Sdfr int key = uap->key; 4782729Sdfr int msgflg = uap->msgflg; 47991703Sjhb struct ucred *cred = td->td_ucred; 480137613Srwatson register struct msqid_kernel *msqkptr = NULL; 4812729Sdfr 482100523Salfred DPRINTF(("msgget(0x%x, 0%o)\n", key, msgflg)); 4832729Sdfr 48491703Sjhb if (!jail_sysvipc_allowed && jailed(td->td_ucred)) 48591703Sjhb return (ENOSYS); 48691703Sjhb 487101772Salfred mtx_lock(&msq_mtx); 4882729Sdfr if (key != IPC_PRIVATE) { 4892729Sdfr for (msqid = 0; msqid < msginfo.msgmni; msqid++) { 490137613Srwatson msqkptr = &msqids[msqid]; 491137613Srwatson if (msqkptr->u.msg_qbytes != 0 && 492137613Srwatson msqkptr->u.msg_perm.key == key) 4932729Sdfr break; 4942729Sdfr } 4952729Sdfr if (msqid < msginfo.msgmni) { 496100523Salfred DPRINTF(("found public key\n")); 4972729Sdfr if ((msgflg & IPC_CREAT) && (msgflg & IPC_EXCL)) { 498100523Salfred DPRINTF(("not exclusive\n")); 49982607Sdillon error = EEXIST; 50082607Sdillon goto done2; 5012729Sdfr } 502137613Srwatson if ((error = ipcperm(td, &msqkptr->u.msg_perm, 503137613Srwatson msgflg & 0700))) { 504100523Salfred DPRINTF(("requester doesn't have 0%o access\n", 505100523Salfred msgflg & 0700)); 50682607Sdillon goto done2; 5072729Sdfr } 5082729Sdfr goto found; 5092729Sdfr } 5102729Sdfr } 5112729Sdfr 512100523Salfred DPRINTF(("need to allocate the msqid_ds\n")); 5132729Sdfr if (key == IPC_PRIVATE || (msgflg & IPC_CREAT)) { 5142729Sdfr for (msqid = 0; msqid < msginfo.msgmni; msqid++) { 5152729Sdfr /* 5162729Sdfr * Look for an unallocated and unlocked msqid_ds. 5172729Sdfr * msqid_ds's can be locked by msgsnd or msgrcv while 5182729Sdfr * they are copying the message in/out. We can't 5192729Sdfr * re-use the entry until they release it. 5202729Sdfr */ 521137613Srwatson msqkptr = &msqids[msqid]; 522137613Srwatson if (msqkptr->u.msg_qbytes == 0 && 523137613Srwatson (msqkptr->u.msg_perm.mode & MSG_LOCKED) == 0) 5242729Sdfr break; 5252729Sdfr } 5262729Sdfr if (msqid == msginfo.msgmni) { 527100523Salfred DPRINTF(("no more msqid_ds's available\n")); 52882607Sdillon error = ENOSPC; 52982607Sdillon goto done2; 5302729Sdfr } 531100523Salfred DPRINTF(("msqid %d is available\n", msqid)); 532137613Srwatson msqkptr->u.msg_perm.key = key; 533137613Srwatson msqkptr->u.msg_perm.cuid = cred->cr_uid; 534137613Srwatson msqkptr->u.msg_perm.uid = cred->cr_uid; 535137613Srwatson msqkptr->u.msg_perm.cgid = cred->cr_gid; 536137613Srwatson msqkptr->u.msg_perm.gid = cred->cr_gid; 537137613Srwatson msqkptr->u.msg_perm.mode = (msgflg & 0777); 5382729Sdfr /* Make sure that the returned msqid is unique */ 539137613Srwatson msqkptr->u.msg_perm.seq = (msqkptr->u.msg_perm.seq + 1) & 0x7fff; 540137613Srwatson msqkptr->u.msg_first = NULL; 541137613Srwatson msqkptr->u.msg_last = NULL; 542137613Srwatson msqkptr->u.msg_cbytes = 0; 543137613Srwatson msqkptr->u.msg_qnum = 0; 544137613Srwatson msqkptr->u.msg_qbytes = msginfo.msgmnb; 545137613Srwatson msqkptr->u.msg_lspid = 0; 546137613Srwatson msqkptr->u.msg_lrpid = 0; 547137613Srwatson msqkptr->u.msg_stime = 0; 548137613Srwatson msqkptr->u.msg_rtime = 0; 549137613Srwatson msqkptr->u.msg_ctime = time_second; 5502729Sdfr } else { 551100523Salfred DPRINTF(("didn't find it and wasn't asked to create it\n")); 55282607Sdillon error = ENOENT; 55382607Sdillon goto done2; 5542729Sdfr } 5552729Sdfr 5562729Sdfrfound: 5572729Sdfr /* Construct the unique msqid */ 558137613Srwatson td->td_retval[0] = IXSEQ_TO_IPCID(msqid, msqkptr->u.msg_perm); 55982607Sdillondone2: 560101772Salfred mtx_unlock(&msq_mtx); 56182607Sdillon return (error); 5622729Sdfr} 5632729Sdfr 56412866Speter#ifndef _SYS_SYSPROTO_H_ 5652729Sdfrstruct msgsnd_args { 5662729Sdfr int msqid; 567109895Salfred const void *msgp; 5682729Sdfr size_t msgsz; 5692729Sdfr int msgflg; 5702729Sdfr}; 57112866Speter#endif 5722729Sdfr 57382607Sdillon/* 57482607Sdillon * MPSAFE 57582607Sdillon */ 57612866Speterint 57783366Sjulianmsgsnd(td, uap) 57883366Sjulian struct thread *td; 5792729Sdfr register struct msgsnd_args *uap; 5802729Sdfr{ 5812729Sdfr int msqid = uap->msqid; 582109895Salfred const void *user_msgp = uap->msgp; 5832729Sdfr size_t msgsz = uap->msgsz; 5842729Sdfr int msgflg = uap->msgflg; 58582607Sdillon int segs_needed, error = 0; 586137613Srwatson register struct msqid_kernel *msqkptr; 5872729Sdfr register struct msg *msghdr; 5882729Sdfr short next; 5892729Sdfr 590100523Salfred DPRINTF(("call to msgsnd(%d, 0x%x, %d, %d)\n", msqid, user_msgp, msgsz, 591100523Salfred msgflg)); 59291703Sjhb if (!jail_sysvipc_allowed && jailed(td->td_ucred)) 59391703Sjhb return (ENOSYS); 59491703Sjhb 595101772Salfred mtx_lock(&msq_mtx); 5962729Sdfr msqid = IPCID_TO_IX(msqid); 5972729Sdfr 5982729Sdfr if (msqid < 0 || msqid >= msginfo.msgmni) { 599100523Salfred DPRINTF(("msqid (%d) out of range (0<=msqid<%d)\n", msqid, 600100523Salfred msginfo.msgmni)); 60182607Sdillon error = EINVAL; 60282607Sdillon goto done2; 6032729Sdfr } 6042729Sdfr 605137613Srwatson msqkptr = &msqids[msqid]; 606137613Srwatson if (msqkptr->u.msg_qbytes == 0) { 607100523Salfred DPRINTF(("no such message queue id\n")); 60882607Sdillon error = EINVAL; 60982607Sdillon goto done2; 6102729Sdfr } 611137613Srwatson if (msqkptr->u.msg_perm.seq != IPCID_TO_SEQ(uap->msqid)) { 612100523Salfred DPRINTF(("wrong sequence number\n")); 61382607Sdillon error = EINVAL; 61482607Sdillon goto done2; 6152729Sdfr } 6162729Sdfr 617137613Srwatson if ((error = ipcperm(td, &msqkptr->u.msg_perm, IPC_W))) { 618100523Salfred DPRINTF(("requester doesn't have write access\n")); 61982607Sdillon goto done2; 6202729Sdfr } 6212729Sdfr 6222729Sdfr segs_needed = (msgsz + msginfo.msgssz - 1) / msginfo.msgssz; 623100523Salfred DPRINTF(("msgsz=%d, msgssz=%d, segs_needed=%d\n", msgsz, msginfo.msgssz, 624100523Salfred segs_needed)); 6252729Sdfr for (;;) { 6262729Sdfr int need_more_resources = 0; 6272729Sdfr 6282729Sdfr /* 6292729Sdfr * check msgsz 6302729Sdfr * (inside this loop in case msg_qbytes changes while we sleep) 6312729Sdfr */ 6322729Sdfr 633137613Srwatson if (msgsz > msqkptr->u.msg_qbytes) { 634137613Srwatson DPRINTF(("msgsz > msqkptr->u.msg_qbytes\n")); 63582607Sdillon error = EINVAL; 63682607Sdillon goto done2; 6372729Sdfr } 6382729Sdfr 639137613Srwatson if (msqkptr->u.msg_perm.mode & MSG_LOCKED) { 640100523Salfred DPRINTF(("msqid is locked\n")); 6412729Sdfr need_more_resources = 1; 6422729Sdfr } 643137613Srwatson if (msgsz + msqkptr->u.msg_cbytes > msqkptr->u.msg_qbytes) { 644100523Salfred DPRINTF(("msgsz + msg_cbytes > msg_qbytes\n")); 6452729Sdfr need_more_resources = 1; 6462729Sdfr } 6472729Sdfr if (segs_needed > nfree_msgmaps) { 648100523Salfred DPRINTF(("segs_needed > nfree_msgmaps\n")); 6492729Sdfr need_more_resources = 1; 6502729Sdfr } 6512729Sdfr if (free_msghdrs == NULL) { 652100523Salfred DPRINTF(("no more msghdrs\n")); 6532729Sdfr need_more_resources = 1; 6542729Sdfr } 6552729Sdfr 6562729Sdfr if (need_more_resources) { 6572729Sdfr int we_own_it; 6582729Sdfr 6592729Sdfr if ((msgflg & IPC_NOWAIT) != 0) { 660100523Salfred DPRINTF(("need more resources but caller " 661100523Salfred "doesn't want to wait\n")); 66282607Sdillon error = EAGAIN; 66382607Sdillon goto done2; 6642729Sdfr } 6652729Sdfr 666137613Srwatson if ((msqkptr->u.msg_perm.mode & MSG_LOCKED) != 0) { 667100523Salfred DPRINTF(("we don't own the msqid_ds\n")); 6682729Sdfr we_own_it = 0; 6692729Sdfr } else { 6702729Sdfr /* Force later arrivals to wait for our 6712729Sdfr request */ 672100523Salfred DPRINTF(("we own the msqid_ds\n")); 673137613Srwatson msqkptr->u.msg_perm.mode |= MSG_LOCKED; 6742729Sdfr we_own_it = 1; 6752729Sdfr } 676100523Salfred DPRINTF(("goodnight\n")); 677137613Srwatson error = msleep(msqkptr, &msq_mtx, (PZERO - 4) | PCATCH, 6782729Sdfr "msgwait", 0); 679100523Salfred DPRINTF(("good morning, error=%d\n", error)); 6802729Sdfr if (we_own_it) 681137613Srwatson msqkptr->u.msg_perm.mode &= ~MSG_LOCKED; 68282607Sdillon if (error != 0) { 683100523Salfred DPRINTF(("msgsnd: interrupted system call\n")); 68482607Sdillon error = EINTR; 68582607Sdillon goto done2; 6862729Sdfr } 6872729Sdfr 6882729Sdfr /* 6892729Sdfr * Make sure that the msq queue still exists 6902729Sdfr */ 6912729Sdfr 692137613Srwatson if (msqkptr->u.msg_qbytes == 0) { 693100523Salfred DPRINTF(("msqid deleted\n")); 69482607Sdillon error = EIDRM; 69582607Sdillon goto done2; 6962729Sdfr } 6972729Sdfr 6982729Sdfr } else { 699100523Salfred DPRINTF(("got all the resources that we need\n")); 7002729Sdfr break; 7012729Sdfr } 7022729Sdfr } 7032729Sdfr 7042729Sdfr /* 7052729Sdfr * We have the resources that we need. 7062729Sdfr * Make sure! 7072729Sdfr */ 7082729Sdfr 709137613Srwatson if (msqkptr->u.msg_perm.mode & MSG_LOCKED) 7102729Sdfr panic("msg_perm.mode & MSG_LOCKED"); 7112729Sdfr if (segs_needed > nfree_msgmaps) 7122729Sdfr panic("segs_needed > nfree_msgmaps"); 713137613Srwatson if (msgsz + msqkptr->u.msg_cbytes > msqkptr->u.msg_qbytes) 7142729Sdfr panic("msgsz + msg_cbytes > msg_qbytes"); 7152729Sdfr if (free_msghdrs == NULL) 7162729Sdfr panic("no more msghdrs"); 7172729Sdfr 7182729Sdfr /* 7192729Sdfr * Re-lock the msqid_ds in case we page-fault when copying in the 7202729Sdfr * message 7212729Sdfr */ 7222729Sdfr 723137613Srwatson if ((msqkptr->u.msg_perm.mode & MSG_LOCKED) != 0) 7242729Sdfr panic("msqid_ds is already locked"); 725137613Srwatson msqkptr->u.msg_perm.mode |= MSG_LOCKED; 7262729Sdfr 7272729Sdfr /* 7282729Sdfr * Allocate a message header 7292729Sdfr */ 7302729Sdfr 7312729Sdfr msghdr = free_msghdrs; 7322729Sdfr free_msghdrs = msghdr->msg_next; 7332729Sdfr msghdr->msg_spot = -1; 7342729Sdfr msghdr->msg_ts = msgsz; 7352729Sdfr 7362729Sdfr /* 7372729Sdfr * Allocate space for the message 7382729Sdfr */ 7392729Sdfr 7402729Sdfr while (segs_needed > 0) { 7412729Sdfr if (nfree_msgmaps <= 0) 7422729Sdfr panic("not enough msgmaps"); 7432729Sdfr if (free_msgmaps == -1) 7442729Sdfr panic("nil free_msgmaps"); 7452729Sdfr next = free_msgmaps; 7462729Sdfr if (next <= -1) 7472729Sdfr panic("next too low #1"); 7482729Sdfr if (next >= msginfo.msgseg) 7492729Sdfr panic("next out of range #1"); 750100523Salfred DPRINTF(("allocating segment %d to message\n", next)); 7512729Sdfr free_msgmaps = msgmaps[next].next; 7522729Sdfr nfree_msgmaps--; 7532729Sdfr msgmaps[next].next = msghdr->msg_spot; 7542729Sdfr msghdr->msg_spot = next; 7552729Sdfr segs_needed--; 7562729Sdfr } 7572729Sdfr 7582729Sdfr /* 7592729Sdfr * Copy in the message type 7602729Sdfr */ 7612729Sdfr 762101772Salfred mtx_unlock(&msq_mtx); 76382607Sdillon if ((error = copyin(user_msgp, &msghdr->msg_type, 7642729Sdfr sizeof(msghdr->msg_type))) != 0) { 765101772Salfred mtx_lock(&msq_mtx); 766100523Salfred DPRINTF(("error %d copying the message type\n", error)); 7672729Sdfr msg_freehdr(msghdr); 768137613Srwatson msqkptr->u.msg_perm.mode &= ~MSG_LOCKED; 769137613Srwatson wakeup(msqkptr); 77082607Sdillon goto done2; 7712729Sdfr } 772101772Salfred mtx_lock(&msq_mtx); 773109906Salfred user_msgp = (const char *)user_msgp + sizeof(msghdr->msg_type); 7742729Sdfr 7752729Sdfr /* 7762729Sdfr * Validate the message type 7772729Sdfr */ 7782729Sdfr 7792729Sdfr if (msghdr->msg_type < 1) { 7802729Sdfr msg_freehdr(msghdr); 781137613Srwatson msqkptr->u.msg_perm.mode &= ~MSG_LOCKED; 782137613Srwatson wakeup(msqkptr); 783100523Salfred DPRINTF(("mtype (%d) < 1\n", msghdr->msg_type)); 78482607Sdillon error = EINVAL; 78582607Sdillon goto done2; 7862729Sdfr } 7872729Sdfr 7882729Sdfr /* 7892729Sdfr * Copy in the message body 7902729Sdfr */ 7912729Sdfr 7922729Sdfr next = msghdr->msg_spot; 7932729Sdfr while (msgsz > 0) { 7942729Sdfr size_t tlen; 7952729Sdfr if (msgsz > msginfo.msgssz) 7962729Sdfr tlen = msginfo.msgssz; 7972729Sdfr else 7982729Sdfr tlen = msgsz; 7992729Sdfr if (next <= -1) 8002729Sdfr panic("next too low #2"); 8012729Sdfr if (next >= msginfo.msgseg) 8022729Sdfr panic("next out of range #2"); 803101772Salfred mtx_unlock(&msq_mtx); 80482607Sdillon if ((error = copyin(user_msgp, &msgpool[next * msginfo.msgssz], 8052729Sdfr tlen)) != 0) { 806101772Salfred mtx_lock(&msq_mtx); 807100523Salfred DPRINTF(("error %d copying in message segment\n", 808100523Salfred error)); 8092729Sdfr msg_freehdr(msghdr); 810137613Srwatson msqkptr->u.msg_perm.mode &= ~MSG_LOCKED; 811137613Srwatson wakeup(msqkptr); 81282607Sdillon goto done2; 8132729Sdfr } 814101772Salfred mtx_lock(&msq_mtx); 8152729Sdfr msgsz -= tlen; 816109906Salfred user_msgp = (const char *)user_msgp + tlen; 8172729Sdfr next = msgmaps[next].next; 8182729Sdfr } 8192729Sdfr if (next != -1) 8202729Sdfr panic("didn't use all the msg segments"); 8212729Sdfr 8222729Sdfr /* 8232729Sdfr * We've got the message. Unlock the msqid_ds. 8242729Sdfr */ 8252729Sdfr 826137613Srwatson msqkptr->u.msg_perm.mode &= ~MSG_LOCKED; 8272729Sdfr 8282729Sdfr /* 8292729Sdfr * Make sure that the msqid_ds is still allocated. 8302729Sdfr */ 8312729Sdfr 832137613Srwatson if (msqkptr->u.msg_qbytes == 0) { 8332729Sdfr msg_freehdr(msghdr); 834137613Srwatson wakeup(msqkptr); 83582607Sdillon error = EIDRM; 83682607Sdillon goto done2; 8372729Sdfr } 8382729Sdfr 8392729Sdfr /* 8402729Sdfr * Put the message into the queue 8412729Sdfr */ 842137613Srwatson if (msqkptr->u.msg_first == NULL) { 843137613Srwatson msqkptr->u.msg_first = msghdr; 844137613Srwatson msqkptr->u.msg_last = msghdr; 8452729Sdfr } else { 846137613Srwatson msqkptr->u.msg_last->msg_next = msghdr; 847137613Srwatson msqkptr->u.msg_last = msghdr; 8482729Sdfr } 849137613Srwatson msqkptr->u.msg_last->msg_next = NULL; 8502729Sdfr 851137613Srwatson msqkptr->u.msg_cbytes += msghdr->msg_ts; 852137613Srwatson msqkptr->u.msg_qnum++; 853137613Srwatson msqkptr->u.msg_lspid = td->td_proc->p_pid; 854137613Srwatson msqkptr->u.msg_stime = time_second; 8552729Sdfr 856137613Srwatson wakeup(msqkptr); 85783366Sjulian td->td_retval[0] = 0; 85882607Sdillondone2: 859101772Salfred mtx_unlock(&msq_mtx); 86082607Sdillon return (error); 8612729Sdfr} 8622729Sdfr 86312866Speter#ifndef _SYS_SYSPROTO_H_ 8642729Sdfrstruct msgrcv_args { 8652729Sdfr int msqid; 8662729Sdfr void *msgp; 8672729Sdfr size_t msgsz; 8682729Sdfr long msgtyp; 8692729Sdfr int msgflg; 8702729Sdfr}; 87112866Speter#endif 8722729Sdfr 87382607Sdillon/* 87482607Sdillon * MPSAFE 87582607Sdillon */ 87612866Speterint 87783366Sjulianmsgrcv(td, uap) 87883366Sjulian struct thread *td; 8792729Sdfr register struct msgrcv_args *uap; 8802729Sdfr{ 8812729Sdfr int msqid = uap->msqid; 8822729Sdfr void *user_msgp = uap->msgp; 8832729Sdfr size_t msgsz = uap->msgsz; 8842729Sdfr long msgtyp = uap->msgtyp; 8852729Sdfr int msgflg = uap->msgflg; 8862729Sdfr size_t len; 887137613Srwatson register struct msqid_kernel *msqkptr; 8882729Sdfr register struct msg *msghdr; 88982607Sdillon int error = 0; 8902729Sdfr short next; 8912729Sdfr 892100523Salfred DPRINTF(("call to msgrcv(%d, 0x%x, %d, %ld, %d)\n", msqid, user_msgp, 893100523Salfred msgsz, msgtyp, msgflg)); 8942729Sdfr 89591703Sjhb if (!jail_sysvipc_allowed && jailed(td->td_ucred)) 89691703Sjhb return (ENOSYS); 89791703Sjhb 8982729Sdfr msqid = IPCID_TO_IX(msqid); 8992729Sdfr 9002729Sdfr if (msqid < 0 || msqid >= msginfo.msgmni) { 901100523Salfred DPRINTF(("msqid (%d) out of range (0<=msqid<%d)\n", msqid, 902100523Salfred msginfo.msgmni)); 903101772Salfred return (EINVAL); 9042729Sdfr } 9052729Sdfr 906137613Srwatson msqkptr = &msqids[msqid]; 907101772Salfred mtx_lock(&msq_mtx); 908137613Srwatson if (msqkptr->u.msg_qbytes == 0) { 909100523Salfred DPRINTF(("no such message queue id\n")); 91082607Sdillon error = EINVAL; 91182607Sdillon goto done2; 9122729Sdfr } 913137613Srwatson if (msqkptr->u.msg_perm.seq != IPCID_TO_SEQ(uap->msqid)) { 914100523Salfred DPRINTF(("wrong sequence number\n")); 91582607Sdillon error = EINVAL; 91682607Sdillon goto done2; 9172729Sdfr } 9182729Sdfr 919137613Srwatson if ((error = ipcperm(td, &msqkptr->u.msg_perm, IPC_R))) { 920100523Salfred DPRINTF(("requester doesn't have read access\n")); 92182607Sdillon goto done2; 9222729Sdfr } 9232729Sdfr 9242729Sdfr msghdr = NULL; 9252729Sdfr while (msghdr == NULL) { 9262729Sdfr if (msgtyp == 0) { 927137613Srwatson msghdr = msqkptr->u.msg_first; 9282729Sdfr if (msghdr != NULL) { 9292729Sdfr if (msgsz < msghdr->msg_ts && 9302729Sdfr (msgflg & MSG_NOERROR) == 0) { 931100523Salfred DPRINTF(("first message on the queue " 932100523Salfred "is too big (want %d, got %d)\n", 933100523Salfred msgsz, msghdr->msg_ts)); 93482607Sdillon error = E2BIG; 93582607Sdillon goto done2; 9362729Sdfr } 937137613Srwatson if (msqkptr->u.msg_first == msqkptr->u.msg_last) { 938137613Srwatson msqkptr->u.msg_first = NULL; 939137613Srwatson msqkptr->u.msg_last = NULL; 9402729Sdfr } else { 941137613Srwatson msqkptr->u.msg_first = msghdr->msg_next; 942137613Srwatson if (msqkptr->u.msg_first == NULL) 9432729Sdfr panic("msg_first/last screwed up #1"); 9442729Sdfr } 9452729Sdfr } 9462729Sdfr } else { 9472729Sdfr struct msg *previous; 9482729Sdfr struct msg **prev; 9492729Sdfr 9502729Sdfr previous = NULL; 951137613Srwatson prev = &(msqkptr->u.msg_first); 9522729Sdfr while ((msghdr = *prev) != NULL) { 9532729Sdfr /* 9542729Sdfr * Is this message's type an exact match or is 9552729Sdfr * this message's type less than or equal to 9562729Sdfr * the absolute value of a negative msgtyp? 9572729Sdfr * Note that the second half of this test can 9582729Sdfr * NEVER be true if msgtyp is positive since 9592729Sdfr * msg_type is always positive! 9602729Sdfr */ 9612729Sdfr 9622729Sdfr if (msgtyp == msghdr->msg_type || 9632729Sdfr msghdr->msg_type <= -msgtyp) { 964100523Salfred DPRINTF(("found message type %d, " 965100523Salfred "requested %d\n", 966100523Salfred msghdr->msg_type, msgtyp)); 9672729Sdfr if (msgsz < msghdr->msg_ts && 9682729Sdfr (msgflg & MSG_NOERROR) == 0) { 969100523Salfred DPRINTF(("requested message " 970100523Salfred "on the queue is too big " 971100523Salfred "(want %d, got %d)\n", 972100523Salfred msgsz, msghdr->msg_ts)); 97382607Sdillon error = E2BIG; 97482607Sdillon goto done2; 9752729Sdfr } 9762729Sdfr *prev = msghdr->msg_next; 977137613Srwatson if (msghdr == msqkptr->u.msg_last) { 9782729Sdfr if (previous == NULL) { 9792729Sdfr if (prev != 980137613Srwatson &msqkptr->u.msg_first) 9812729Sdfr panic("msg_first/last screwed up #2"); 982137613Srwatson msqkptr->u.msg_first = 9832729Sdfr NULL; 984137613Srwatson msqkptr->u.msg_last = 9852729Sdfr NULL; 9862729Sdfr } else { 9872729Sdfr if (prev == 988137613Srwatson &msqkptr->u.msg_first) 9892729Sdfr panic("msg_first/last screwed up #3"); 990137613Srwatson msqkptr->u.msg_last = 9912729Sdfr previous; 9922729Sdfr } 9932729Sdfr } 9942729Sdfr break; 9952729Sdfr } 9962729Sdfr previous = msghdr; 9972729Sdfr prev = &(msghdr->msg_next); 9982729Sdfr } 9992729Sdfr } 10002729Sdfr 10012729Sdfr /* 10022729Sdfr * We've either extracted the msghdr for the appropriate 10032729Sdfr * message or there isn't one. 10042729Sdfr * If there is one then bail out of this loop. 10052729Sdfr */ 10062729Sdfr 10072729Sdfr if (msghdr != NULL) 10082729Sdfr break; 10092729Sdfr 10102729Sdfr /* 10112729Sdfr * Hmph! No message found. Does the user want to wait? 10122729Sdfr */ 10132729Sdfr 10142729Sdfr if ((msgflg & IPC_NOWAIT) != 0) { 1015100523Salfred DPRINTF(("no appropriate message found (msgtyp=%d)\n", 1016100523Salfred msgtyp)); 10172729Sdfr /* The SVID says to return ENOMSG. */ 101882607Sdillon error = ENOMSG; 101982607Sdillon goto done2; 10202729Sdfr } 10212729Sdfr 10222729Sdfr /* 10232729Sdfr * Wait for something to happen 10242729Sdfr */ 10252729Sdfr 1026100523Salfred DPRINTF(("msgrcv: goodnight\n")); 1027137613Srwatson error = msleep(msqkptr, &msq_mtx, (PZERO - 4) | PCATCH, 1028101772Salfred "msgwait", 0); 1029100523Salfred DPRINTF(("msgrcv: good morning (error=%d)\n", error)); 10302729Sdfr 103182607Sdillon if (error != 0) { 1032100523Salfred DPRINTF(("msgsnd: interrupted system call\n")); 103382607Sdillon error = EINTR; 103482607Sdillon goto done2; 10352729Sdfr } 10362729Sdfr 10372729Sdfr /* 10382729Sdfr * Make sure that the msq queue still exists 10392729Sdfr */ 10402729Sdfr 1041137613Srwatson if (msqkptr->u.msg_qbytes == 0 || 1042137613Srwatson msqkptr->u.msg_perm.seq != IPCID_TO_SEQ(uap->msqid)) { 1043100523Salfred DPRINTF(("msqid deleted\n")); 104482607Sdillon error = EIDRM; 104582607Sdillon goto done2; 10462729Sdfr } 10472729Sdfr } 10482729Sdfr 10492729Sdfr /* 10502729Sdfr * Return the message to the user. 10512729Sdfr * 10522729Sdfr * First, do the bookkeeping (before we risk being interrupted). 10532729Sdfr */ 10542729Sdfr 1055137613Srwatson msqkptr->u.msg_cbytes -= msghdr->msg_ts; 1056137613Srwatson msqkptr->u.msg_qnum--; 1057137613Srwatson msqkptr->u.msg_lrpid = td->td_proc->p_pid; 1058137613Srwatson msqkptr->u.msg_rtime = time_second; 10592729Sdfr 10602729Sdfr /* 10612729Sdfr * Make msgsz the actual amount that we'll be returning. 10622729Sdfr * Note that this effectively truncates the message if it is too long 10632729Sdfr * (since msgsz is never increased). 10642729Sdfr */ 10652729Sdfr 1066100523Salfred DPRINTF(("found a message, msgsz=%d, msg_ts=%d\n", msgsz, 1067100523Salfred msghdr->msg_ts)); 10682729Sdfr if (msgsz > msghdr->msg_ts) 10692729Sdfr msgsz = msghdr->msg_ts; 10702729Sdfr 10712729Sdfr /* 10722729Sdfr * Return the type to the user. 10732729Sdfr */ 10742729Sdfr 1075101772Salfred mtx_unlock(&msq_mtx); 1076100511Salfred error = copyout(&(msghdr->msg_type), user_msgp, 10772729Sdfr sizeof(msghdr->msg_type)); 1078101772Salfred mtx_lock(&msq_mtx); 107982607Sdillon if (error != 0) { 1080100523Salfred DPRINTF(("error (%d) copying out message type\n", error)); 10812729Sdfr msg_freehdr(msghdr); 1082137613Srwatson wakeup(msqkptr); 108382607Sdillon goto done2; 10842729Sdfr } 108517971Sbde user_msgp = (char *)user_msgp + sizeof(msghdr->msg_type); 10862729Sdfr 10872729Sdfr /* 10882729Sdfr * Return the segments to the user 10892729Sdfr */ 10902729Sdfr 10912729Sdfr next = msghdr->msg_spot; 10922729Sdfr for (len = 0; len < msgsz; len += msginfo.msgssz) { 10932729Sdfr size_t tlen; 10942729Sdfr 109545921Ssada if (msgsz - len > msginfo.msgssz) 10962729Sdfr tlen = msginfo.msgssz; 10972729Sdfr else 109845921Ssada tlen = msgsz - len; 10992729Sdfr if (next <= -1) 11002729Sdfr panic("next too low #3"); 11012729Sdfr if (next >= msginfo.msgseg) 11022729Sdfr panic("next out of range #3"); 1103101772Salfred mtx_unlock(&msq_mtx); 1104100511Salfred error = copyout(&msgpool[next * msginfo.msgssz], 11052729Sdfr user_msgp, tlen); 1106101772Salfred mtx_lock(&msq_mtx); 110782607Sdillon if (error != 0) { 1108100523Salfred DPRINTF(("error (%d) copying out message segment\n", 1109100523Salfred error)); 11102729Sdfr msg_freehdr(msghdr); 1111137613Srwatson wakeup(msqkptr); 111282607Sdillon goto done2; 11132729Sdfr } 111417971Sbde user_msgp = (char *)user_msgp + tlen; 11152729Sdfr next = msgmaps[next].next; 11162729Sdfr } 11172729Sdfr 11182729Sdfr /* 11192729Sdfr * Done, return the actual number of bytes copied out. 11202729Sdfr */ 11212729Sdfr 11222729Sdfr msg_freehdr(msghdr); 1123137613Srwatson wakeup(msqkptr); 112483366Sjulian td->td_retval[0] = msgsz; 112582607Sdillondone2: 1126101772Salfred mtx_unlock(&msq_mtx); 112782607Sdillon return (error); 11282729Sdfr} 112977461Sdd 113077461Sddstatic int 113177461Sddsysctl_msqids(SYSCTL_HANDLER_ARGS) 113277461Sdd{ 113377461Sdd 113477461Sdd return (SYSCTL_OUT(req, msqids, 1135137613Srwatson sizeof(struct msqid_kernel) * msginfo.msgmni)); 113677461Sdd} 113777461Sdd 113877461SddSYSCTL_DECL(_kern_ipc); 113977461SddSYSCTL_INT(_kern_ipc, OID_AUTO, msgmax, CTLFLAG_RD, &msginfo.msgmax, 0, ""); 1140121307SsilbySYSCTL_INT(_kern_ipc, OID_AUTO, msgmni, CTLFLAG_RDTUN, &msginfo.msgmni, 0, ""); 1141139436SrwatsonSYSCTL_INT(_kern_ipc, OID_AUTO, msgmnb, CTLFLAG_RDTUN, &msginfo.msgmnb, 0, ""); 1142139436SrwatsonSYSCTL_INT(_kern_ipc, OID_AUTO, msgtql, CTLFLAG_RDTUN, &msginfo.msgtql, 0, ""); 1143121307SsilbySYSCTL_INT(_kern_ipc, OID_AUTO, msgssz, CTLFLAG_RDTUN, &msginfo.msgssz, 0, ""); 1144121307SsilbySYSCTL_INT(_kern_ipc, OID_AUTO, msgseg, CTLFLAG_RDTUN, &msginfo.msgseg, 0, ""); 114577461SddSYSCTL_PROC(_kern_ipc, OID_AUTO, msqids, CTLFLAG_RD, 114677461Sdd NULL, 0, sysctl_msqids, "", "Message queue IDs"); 1147