sysv_msg.c revision 116182
12729Sdfr/* 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 116182 2003-06-11 00:56:59Z obrien $"); 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> 322729Sdfr#include <sys/msg.h> 3369449Salfred#include <sys/syscall.h> 3411626Sbde#include <sys/sysent.h> 3559839Speter#include <sys/sysctl.h> 3659839Speter#include <sys/malloc.h> 3768024Srwatson#include <sys/jail.h> 382729Sdfr 3959839Speterstatic MALLOC_DEFINE(M_MSG, "msg", "SVID compatible message queues"); 4059839Speter 4192723Salfredstatic void msginit(void); 4292723Salfredstatic int msgunload(void); 4392723Salfredstatic int sysvmsg_modload(struct module *, int, void *); 4410358Sjulian 45100523Salfred#ifdef MSG_DEBUG 46100523Salfred#define DPRINTF(a) printf a 47100523Salfred#else 48100523Salfred#define DPRINTF(a) 49100523Salfred#endif 502729Sdfr 5192723Salfredstatic void msg_freehdr(struct msg *msghdr); 522729Sdfr 5311626Sbde/* XXX casting to (sy_call_t *) is bogus, as usual. */ 5412819Sphkstatic sy_call_t *msgcalls[] = { 5511626Sbde (sy_call_t *)msgctl, (sy_call_t *)msgget, 5611626Sbde (sy_call_t *)msgsnd, (sy_call_t *)msgrcv 5711626Sbde}; 582729Sdfr 5959839Speterstruct msg { 6059839Speter struct msg *msg_next; /* next msg in the chain */ 6159839Speter long msg_type; /* type of this message */ 6259839Speter /* >0 -> type of this message */ 6359839Speter /* 0 -> free header */ 6459839Speter u_short msg_ts; /* size of this message */ 6559839Speter short msg_spot; /* location of start of msg in buffer */ 6659839Speter}; 6759839Speter 6859839Speter 6959839Speter#ifndef MSGSSZ 7059839Speter#define MSGSSZ 8 /* Each segment must be 2^N long */ 7159839Speter#endif 7259839Speter#ifndef MSGSEG 7359839Speter#define MSGSEG 2048 /* must be less than 32767 */ 7459839Speter#endif 7559839Speter#define MSGMAX (MSGSSZ*MSGSEG) 7659839Speter#ifndef MSGMNB 7759839Speter#define MSGMNB 2048 /* max # of bytes in a queue */ 7859839Speter#endif 7959839Speter#ifndef MSGMNI 8059839Speter#define MSGMNI 40 8159839Speter#endif 8259839Speter#ifndef MSGTQL 8359839Speter#define MSGTQL 40 8459839Speter#endif 8559839Speter 8659839Speter/* 8759839Speter * Based on the configuration parameters described in an SVR2 (yes, two) 8859839Speter * config(1m) man page. 8959839Speter * 9059839Speter * Each message is broken up and stored in segments that are msgssz bytes 9159839Speter * long. For efficiency reasons, this should be a power of two. Also, 9259839Speter * it doesn't make sense if it is less than 8 or greater than about 256. 9359839Speter * Consequently, msginit in kern/sysv_msg.c checks that msgssz is a power of 9459839Speter * two between 8 and 1024 inclusive (and panic's if it isn't). 9559839Speter */ 9659839Speterstruct msginfo msginfo = { 9759839Speter MSGMAX, /* max chars in a message */ 9859839Speter MSGMNI, /* # of message queue identifiers */ 9959839Speter MSGMNB, /* max chars in a queue */ 10059839Speter MSGTQL, /* max messages in system */ 10159839Speter MSGSSZ, /* size of a message segment */ 10259839Speter /* (must be small power of 2 greater than 4) */ 10359839Speter MSGSEG /* number of message segments */ 10459839Speter}; 10559839Speter 10659839Speter/* 10759839Speter * macros to convert between msqid_ds's and msqid's. 10859839Speter * (specific to this implementation) 10959839Speter */ 11059839Speter#define MSQID(ix,ds) ((ix) & 0xffff | (((ds).msg_perm.seq << 16) & 0xffff0000)) 11159839Speter#define MSQID_IX(id) ((id) & 0xffff) 11259839Speter#define MSQID_SEQ(id) (((id) >> 16) & 0xffff) 11359839Speter 11459839Speter/* 11559839Speter * The rest of this file is specific to this particular implementation. 11659839Speter */ 11759839Speter 11859839Speterstruct msgmap { 11959839Speter short next; /* next segment in buffer */ 12059839Speter /* -1 -> available */ 12159839Speter /* 0..(MSGSEG-1) -> index of next segment */ 12259839Speter}; 12359839Speter 12459839Speter#define MSG_LOCKED 01000 /* Is this msqid_ds locked? */ 12559839Speter 12612819Sphkstatic int nfree_msgmaps; /* # of free map entries */ 12712819Sphkstatic short free_msgmaps; /* head of linked list of free map entries */ 12859839Speterstatic struct msg *free_msghdrs;/* list of free msg headers */ 12959839Speterstatic char *msgpool; /* MSGMAX byte long msg buffer pool */ 13059839Speterstatic struct msgmap *msgmaps; /* MSGSEG msgmap structures */ 13159839Speterstatic struct msg *msghdrs; /* MSGTQL msg headers */ 13259839Speterstatic struct msqid_ds *msqids; /* MSGMNI msqid_ds struct's */ 133101772Salfredstatic struct mtx msq_mtx; /* global mutex for message queues. */ 1342729Sdfr 13559839Speterstatic void 13669449Salfredmsginit() 1372729Sdfr{ 1382729Sdfr register int i; 1392729Sdfr 14083765Smr TUNABLE_INT_FETCH("kern.ipc.msgseg", &msginfo.msgseg); 14183765Smr TUNABLE_INT_FETCH("kern.ipc.msgssz", &msginfo.msgssz); 14283765Smr msginfo.msgmax = msginfo.msgseg * msginfo.msgssz; 14383765Smr TUNABLE_INT_FETCH("kern.ipc.msgmni", &msginfo.msgmni); 14483765Smr 145111119Simp msgpool = malloc(msginfo.msgmax, M_MSG, M_WAITOK); 14659839Speter if (msgpool == NULL) 14759839Speter panic("msgpool is NULL"); 148111119Simp msgmaps = malloc(sizeof(struct msgmap) * msginfo.msgseg, M_MSG, M_WAITOK); 14959839Speter if (msgmaps == NULL) 15059839Speter panic("msgmaps is NULL"); 151111119Simp msghdrs = malloc(sizeof(struct msg) * msginfo.msgtql, M_MSG, M_WAITOK); 15259839Speter if (msghdrs == NULL) 15359839Speter panic("msghdrs is NULL"); 154111119Simp msqids = malloc(sizeof(struct msqid_ds) * msginfo.msgmni, M_MSG, M_WAITOK); 15559839Speter if (msqids == NULL) 15659839Speter panic("msqids is NULL"); 15759839Speter 1582729Sdfr /* 1592729Sdfr * msginfo.msgssz should be a power of two for efficiency reasons. 1602729Sdfr * It is also pretty silly if msginfo.msgssz is less than 8 1612729Sdfr * or greater than about 256 so ... 1622729Sdfr */ 1632729Sdfr 1642729Sdfr i = 8; 1652729Sdfr while (i < 1024 && i != msginfo.msgssz) 1662729Sdfr i <<= 1; 1672729Sdfr if (i != msginfo.msgssz) { 168100523Salfred DPRINTF(("msginfo.msgssz=%d (0x%x)\n", msginfo.msgssz, 169100523Salfred msginfo.msgssz)); 1702729Sdfr panic("msginfo.msgssz not a small power of 2"); 1712729Sdfr } 1722729Sdfr 1732729Sdfr if (msginfo.msgseg > 32767) { 174100523Salfred DPRINTF(("msginfo.msgseg=%d\n", msginfo.msgseg)); 1752729Sdfr panic("msginfo.msgseg > 32767"); 1762729Sdfr } 1772729Sdfr 1782729Sdfr if (msgmaps == NULL) 1792729Sdfr panic("msgmaps is NULL"); 1802729Sdfr 1812729Sdfr for (i = 0; i < msginfo.msgseg; i++) { 1822729Sdfr if (i > 0) 1832729Sdfr msgmaps[i-1].next = i; 1842729Sdfr msgmaps[i].next = -1; /* implies entry is available */ 1852729Sdfr } 1862729Sdfr free_msgmaps = 0; 1872729Sdfr nfree_msgmaps = msginfo.msgseg; 1882729Sdfr 1892729Sdfr if (msghdrs == NULL) 1902729Sdfr panic("msghdrs is NULL"); 1912729Sdfr 1922729Sdfr for (i = 0; i < msginfo.msgtql; i++) { 1932729Sdfr msghdrs[i].msg_type = 0; 1942729Sdfr if (i > 0) 1952729Sdfr msghdrs[i-1].msg_next = &msghdrs[i]; 1962729Sdfr msghdrs[i].msg_next = NULL; 1972729Sdfr } 1982729Sdfr free_msghdrs = &msghdrs[0]; 1992729Sdfr 2002729Sdfr if (msqids == NULL) 2012729Sdfr panic("msqids is NULL"); 2022729Sdfr 2032729Sdfr for (i = 0; i < msginfo.msgmni; i++) { 2042729Sdfr msqids[i].msg_qbytes = 0; /* implies entry is available */ 2052729Sdfr msqids[i].msg_perm.seq = 0; /* reset to a known value */ 20666085Speter msqids[i].msg_perm.mode = 0; 2072729Sdfr } 208101772Salfred mtx_init(&msq_mtx, "msq", NULL, MTX_DEF); 2092729Sdfr} 2102729Sdfr 21169449Salfredstatic int 21269449Salfredmsgunload() 21369449Salfred{ 21469449Salfred struct msqid_ds *msqptr; 21569449Salfred int msqid; 21669449Salfred 21769449Salfred for (msqid = 0; msqid < msginfo.msgmni; msqid++) { 21869449Salfred /* 21969449Salfred * Look for an unallocated and unlocked msqid_ds. 22069449Salfred * msqid_ds's can be locked by msgsnd or msgrcv while 22169449Salfred * they are copying the message in/out. We can't 22269449Salfred * re-use the entry until they release it. 22369449Salfred */ 22469449Salfred msqptr = &msqids[msqid]; 22569449Salfred if (msqptr->msg_qbytes != 0 || 22669449Salfred (msqptr->msg_perm.mode & MSG_LOCKED) != 0) 22769449Salfred break; 22869449Salfred } 22969449Salfred if (msqid != msginfo.msgmni) 23069449Salfred return (EBUSY); 23169449Salfred 23269449Salfred free(msgpool, M_MSG); 23369449Salfred free(msgmaps, M_MSG); 23469449Salfred free(msghdrs, M_MSG); 23569449Salfred free(msqids, M_MSG); 236101772Salfred mtx_destroy(&msq_mtx); 23769449Salfred return (0); 23869449Salfred} 23969449Salfred 24069449Salfred 24169449Salfredstatic int 24269449Salfredsysvmsg_modload(struct module *module, int cmd, void *arg) 24369449Salfred{ 24469449Salfred int error = 0; 24569449Salfred 24669449Salfred switch (cmd) { 24769449Salfred case MOD_LOAD: 24869449Salfred msginit(); 24969449Salfred break; 25069449Salfred case MOD_UNLOAD: 25169449Salfred error = msgunload(); 25269449Salfred break; 25369449Salfred case MOD_SHUTDOWN: 25469449Salfred break; 25569449Salfred default: 25669449Salfred error = EINVAL; 25769449Salfred break; 25869449Salfred } 25969449Salfred return (error); 26069449Salfred} 26169449Salfred 26271038Sdesstatic moduledata_t sysvmsg_mod = { 26371038Sdes "sysvmsg", 26469449Salfred &sysvmsg_modload, 26569449Salfred NULL 26669449Salfred}; 26769449Salfred 26888633SalfredSYSCALL_MODULE_HELPER(msgsys); 26988633SalfredSYSCALL_MODULE_HELPER(msgctl); 27088633SalfredSYSCALL_MODULE_HELPER(msgget); 27188633SalfredSYSCALL_MODULE_HELPER(msgsnd); 27288633SalfredSYSCALL_MODULE_HELPER(msgrcv); 27369449Salfred 27471038SdesDECLARE_MODULE(sysvmsg, sysvmsg_mod, 27569449Salfred SI_SUB_SYSV_MSG, SI_ORDER_FIRST); 27671038SdesMODULE_VERSION(sysvmsg, 1); 27769449Salfred 2782729Sdfr/* 2792729Sdfr * Entry point for all MSG calls 28082607Sdillon * 28182607Sdillon * MPSAFE 2822729Sdfr */ 2832729Sdfrint 28483366Sjulianmsgsys(td, uap) 28583366Sjulian struct thread *td; 28611626Sbde /* XXX actually varargs. */ 28711626Sbde struct msgsys_args /* { 28811626Sbde u_int which; 28911626Sbde int a2; 29011626Sbde int a3; 29111626Sbde int a4; 29211626Sbde int a5; 29311626Sbde int a6; 29411626Sbde } */ *uap; 2952729Sdfr{ 29682607Sdillon int error; 2972729Sdfr 29891703Sjhb if (!jail_sysvipc_allowed && jailed(td->td_ucred)) 29991703Sjhb return (ENOSYS); 30091703Sjhb if (uap->which >= sizeof(msgcalls)/sizeof(msgcalls[0])) 30191703Sjhb return (EINVAL); 30283366Sjulian error = (*msgcalls[uap->which])(td, &uap->a2); 30382607Sdillon return (error); 3042729Sdfr} 3052729Sdfr 3062729Sdfrstatic void 3072729Sdfrmsg_freehdr(msghdr) 3082729Sdfr struct msg *msghdr; 3092729Sdfr{ 3102729Sdfr while (msghdr->msg_ts > 0) { 3112729Sdfr short next; 3122729Sdfr if (msghdr->msg_spot < 0 || msghdr->msg_spot >= msginfo.msgseg) 3132729Sdfr panic("msghdr->msg_spot out of range"); 3142729Sdfr next = msgmaps[msghdr->msg_spot].next; 3152729Sdfr msgmaps[msghdr->msg_spot].next = free_msgmaps; 3162729Sdfr free_msgmaps = msghdr->msg_spot; 3172729Sdfr nfree_msgmaps++; 3182729Sdfr msghdr->msg_spot = next; 3192729Sdfr if (msghdr->msg_ts >= msginfo.msgssz) 3202729Sdfr msghdr->msg_ts -= msginfo.msgssz; 3212729Sdfr else 3222729Sdfr msghdr->msg_ts = 0; 3232729Sdfr } 3242729Sdfr if (msghdr->msg_spot != -1) 3252729Sdfr panic("msghdr->msg_spot != -1"); 3262729Sdfr msghdr->msg_next = free_msghdrs; 3272729Sdfr free_msghdrs = msghdr; 3282729Sdfr} 3292729Sdfr 33012866Speter#ifndef _SYS_SYSPROTO_H_ 3312729Sdfrstruct msgctl_args { 3322729Sdfr int msqid; 3332729Sdfr int cmd; 33412866Speter struct msqid_ds *buf; 3352729Sdfr}; 33612866Speter#endif 3372729Sdfr 33882607Sdillon/* 33982607Sdillon * MPSAFE 34082607Sdillon */ 34112866Speterint 34283366Sjulianmsgctl(td, uap) 34383366Sjulian struct thread *td; 3442729Sdfr register struct msgctl_args *uap; 3452729Sdfr{ 3462729Sdfr int msqid = uap->msqid; 3472729Sdfr int cmd = uap->cmd; 34812866Speter struct msqid_ds *user_msqptr = uap->buf; 34982607Sdillon int rval, error; 3502729Sdfr struct msqid_ds msqbuf; 3512729Sdfr register struct msqid_ds *msqptr; 3522729Sdfr 353100523Salfred DPRINTF(("call to msgctl(%d, %d, 0x%x)\n", msqid, cmd, user_msqptr)); 35491703Sjhb if (!jail_sysvipc_allowed && jailed(td->td_ucred)) 35591703Sjhb return (ENOSYS); 35691703Sjhb 3572729Sdfr msqid = IPCID_TO_IX(msqid); 3582729Sdfr 3592729Sdfr if (msqid < 0 || msqid >= msginfo.msgmni) { 360100523Salfred DPRINTF(("msqid (%d) out of range (0<=msqid<%d)\n", msqid, 361100523Salfred msginfo.msgmni)); 362101772Salfred return (EINVAL); 3632729Sdfr } 364101772Salfred if (cmd == IPC_SET && 365101772Salfred (error = copyin(user_msqptr, &msqbuf, sizeof(msqbuf))) != 0) 366101772Salfred return (error); 3672729Sdfr 3682729Sdfr msqptr = &msqids[msqid]; 3692729Sdfr 370101772Salfred mtx_lock(&msq_mtx); 3712729Sdfr if (msqptr->msg_qbytes == 0) { 372100523Salfred DPRINTF(("no such msqid\n")); 37382607Sdillon error = EINVAL; 37482607Sdillon goto done2; 3752729Sdfr } 3762729Sdfr if (msqptr->msg_perm.seq != IPCID_TO_SEQ(uap->msqid)) { 377100523Salfred DPRINTF(("wrong sequence number\n")); 37882607Sdillon error = EINVAL; 37982607Sdillon goto done2; 3802729Sdfr } 3812729Sdfr 38282607Sdillon error = 0; 3832729Sdfr rval = 0; 3842729Sdfr 3852729Sdfr switch (cmd) { 3862729Sdfr 3872729Sdfr case IPC_RMID: 3882729Sdfr { 3892729Sdfr struct msg *msghdr; 39083366Sjulian if ((error = ipcperm(td, &msqptr->msg_perm, IPC_M))) 39182607Sdillon goto done2; 3922729Sdfr /* Free the message headers */ 3932729Sdfr msghdr = msqptr->msg_first; 3942729Sdfr while (msghdr != NULL) { 3952729Sdfr struct msg *msghdr_tmp; 3962729Sdfr 3972729Sdfr /* Free the segments of each message */ 3982729Sdfr msqptr->msg_cbytes -= msghdr->msg_ts; 3992729Sdfr msqptr->msg_qnum--; 4002729Sdfr msghdr_tmp = msghdr; 4012729Sdfr msghdr = msghdr->msg_next; 4022729Sdfr msg_freehdr(msghdr_tmp); 4032729Sdfr } 4042729Sdfr 4052729Sdfr if (msqptr->msg_cbytes != 0) 4062729Sdfr panic("msg_cbytes is screwed up"); 4072729Sdfr if (msqptr->msg_qnum != 0) 4082729Sdfr panic("msg_qnum is screwed up"); 4092729Sdfr 4102729Sdfr msqptr->msg_qbytes = 0; /* Mark it as free */ 4112729Sdfr 412100511Salfred wakeup(msqptr); 4132729Sdfr } 4142729Sdfr 4152729Sdfr break; 4162729Sdfr 4172729Sdfr case IPC_SET: 41883366Sjulian if ((error = ipcperm(td, &msqptr->msg_perm, IPC_M))) 41982607Sdillon goto done2; 42043426Sphk if (msqbuf.msg_qbytes > msqptr->msg_qbytes) { 42193593Sjhb error = suser(td); 42282607Sdillon if (error) 42382607Sdillon goto done2; 42443426Sphk } 4252729Sdfr if (msqbuf.msg_qbytes > msginfo.msgmnb) { 426100523Salfred DPRINTF(("can't increase msg_qbytes beyond %d" 427100523Salfred "(truncating)\n", msginfo.msgmnb)); 4282729Sdfr msqbuf.msg_qbytes = msginfo.msgmnb; /* silently restrict qbytes to system limit */ 4292729Sdfr } 4302729Sdfr if (msqbuf.msg_qbytes == 0) { 431100523Salfred DPRINTF(("can't reduce msg_qbytes to 0\n")); 43282607Sdillon error = EINVAL; /* non-standard errno! */ 43382607Sdillon goto done2; 4342729Sdfr } 4352729Sdfr msqptr->msg_perm.uid = msqbuf.msg_perm.uid; /* change the owner */ 4362729Sdfr msqptr->msg_perm.gid = msqbuf.msg_perm.gid; /* change the owner */ 4372729Sdfr msqptr->msg_perm.mode = (msqptr->msg_perm.mode & ~0777) | 4382729Sdfr (msqbuf.msg_perm.mode & 0777); 4392729Sdfr msqptr->msg_qbytes = msqbuf.msg_qbytes; 44034961Sphk msqptr->msg_ctime = time_second; 4412729Sdfr break; 4422729Sdfr 4432729Sdfr case IPC_STAT: 44483366Sjulian if ((error = ipcperm(td, &msqptr->msg_perm, IPC_R))) { 445100523Salfred DPRINTF(("requester doesn't have read access\n")); 44682607Sdillon goto done2; 4472729Sdfr } 4482729Sdfr break; 4492729Sdfr 4502729Sdfr default: 451100523Salfred DPRINTF(("invalid command %d\n", cmd)); 45282607Sdillon error = EINVAL; 45382607Sdillon goto done2; 4542729Sdfr } 4552729Sdfr 45682607Sdillon if (error == 0) 45783366Sjulian td->td_retval[0] = rval; 45882607Sdillondone2: 459101772Salfred mtx_unlock(&msq_mtx); 460101772Salfred if (cmd == IPC_STAT && error == 0) 461101772Salfred error = copyout(msqptr, user_msqptr, sizeof(struct msqid_ds)); 46282607Sdillon return(error); 4632729Sdfr} 4642729Sdfr 46512866Speter#ifndef _SYS_SYSPROTO_H_ 4662729Sdfrstruct msgget_args { 4672729Sdfr key_t key; 4682729Sdfr int msgflg; 4692729Sdfr}; 47012866Speter#endif 4712729Sdfr 47282607Sdillon/* 47382607Sdillon * MPSAFE 47482607Sdillon */ 47512866Speterint 47683366Sjulianmsgget(td, uap) 47783366Sjulian struct thread *td; 4782729Sdfr register struct msgget_args *uap; 4792729Sdfr{ 48082607Sdillon int msqid, error = 0; 4812729Sdfr int key = uap->key; 4822729Sdfr int msgflg = uap->msgflg; 48391703Sjhb struct ucred *cred = td->td_ucred; 4842836Sdg register struct msqid_ds *msqptr = NULL; 4852729Sdfr 486100523Salfred DPRINTF(("msgget(0x%x, 0%o)\n", key, msgflg)); 4872729Sdfr 48891703Sjhb if (!jail_sysvipc_allowed && jailed(td->td_ucred)) 48991703Sjhb return (ENOSYS); 49091703Sjhb 491101772Salfred mtx_lock(&msq_mtx); 4922729Sdfr if (key != IPC_PRIVATE) { 4932729Sdfr for (msqid = 0; msqid < msginfo.msgmni; msqid++) { 4942729Sdfr msqptr = &msqids[msqid]; 4952729Sdfr if (msqptr->msg_qbytes != 0 && 4962729Sdfr msqptr->msg_perm.key == key) 4972729Sdfr break; 4982729Sdfr } 4992729Sdfr if (msqid < msginfo.msgmni) { 500100523Salfred DPRINTF(("found public key\n")); 5012729Sdfr if ((msgflg & IPC_CREAT) && (msgflg & IPC_EXCL)) { 502100523Salfred DPRINTF(("not exclusive\n")); 50382607Sdillon error = EEXIST; 50482607Sdillon goto done2; 5052729Sdfr } 50683366Sjulian if ((error = ipcperm(td, &msqptr->msg_perm, msgflg & 0700 ))) { 507100523Salfred DPRINTF(("requester doesn't have 0%o access\n", 508100523Salfred msgflg & 0700)); 50982607Sdillon goto done2; 5102729Sdfr } 5112729Sdfr goto found; 5122729Sdfr } 5132729Sdfr } 5142729Sdfr 515100523Salfred DPRINTF(("need to allocate the msqid_ds\n")); 5162729Sdfr if (key == IPC_PRIVATE || (msgflg & IPC_CREAT)) { 5172729Sdfr for (msqid = 0; msqid < msginfo.msgmni; msqid++) { 5182729Sdfr /* 5192729Sdfr * Look for an unallocated and unlocked msqid_ds. 5202729Sdfr * msqid_ds's can be locked by msgsnd or msgrcv while 5212729Sdfr * they are copying the message in/out. We can't 5222729Sdfr * re-use the entry until they release it. 5232729Sdfr */ 5242729Sdfr msqptr = &msqids[msqid]; 5252729Sdfr if (msqptr->msg_qbytes == 0 && 5262729Sdfr (msqptr->msg_perm.mode & MSG_LOCKED) == 0) 5272729Sdfr break; 5282729Sdfr } 5292729Sdfr if (msqid == msginfo.msgmni) { 530100523Salfred DPRINTF(("no more msqid_ds's available\n")); 53182607Sdillon error = ENOSPC; 53282607Sdillon goto done2; 5332729Sdfr } 534100523Salfred DPRINTF(("msqid %d is available\n", msqid)); 5352729Sdfr msqptr->msg_perm.key = key; 5362729Sdfr msqptr->msg_perm.cuid = cred->cr_uid; 5372729Sdfr msqptr->msg_perm.uid = cred->cr_uid; 5382729Sdfr msqptr->msg_perm.cgid = cred->cr_gid; 5392729Sdfr msqptr->msg_perm.gid = cred->cr_gid; 5402729Sdfr msqptr->msg_perm.mode = (msgflg & 0777); 5412729Sdfr /* Make sure that the returned msqid is unique */ 542107896Smaxim msqptr->msg_perm.seq = (msqptr->msg_perm.seq + 1) & 0x7fff; 5432729Sdfr msqptr->msg_first = NULL; 5442729Sdfr msqptr->msg_last = NULL; 5452729Sdfr msqptr->msg_cbytes = 0; 5462729Sdfr msqptr->msg_qnum = 0; 5472729Sdfr msqptr->msg_qbytes = msginfo.msgmnb; 5482729Sdfr msqptr->msg_lspid = 0; 5492729Sdfr msqptr->msg_lrpid = 0; 5502729Sdfr msqptr->msg_stime = 0; 5512729Sdfr msqptr->msg_rtime = 0; 55234961Sphk msqptr->msg_ctime = time_second; 5532729Sdfr } else { 554100523Salfred DPRINTF(("didn't find it and wasn't asked to create it\n")); 55582607Sdillon error = ENOENT; 55682607Sdillon goto done2; 5572729Sdfr } 5582729Sdfr 5592729Sdfrfound: 5602729Sdfr /* Construct the unique msqid */ 56183366Sjulian td->td_retval[0] = IXSEQ_TO_IPCID(msqid, msqptr->msg_perm); 56282607Sdillondone2: 563101772Salfred mtx_unlock(&msq_mtx); 56482607Sdillon return (error); 5652729Sdfr} 5662729Sdfr 56712866Speter#ifndef _SYS_SYSPROTO_H_ 5682729Sdfrstruct msgsnd_args { 5692729Sdfr int msqid; 570109895Salfred const void *msgp; 5712729Sdfr size_t msgsz; 5722729Sdfr int msgflg; 5732729Sdfr}; 57412866Speter#endif 5752729Sdfr 57682607Sdillon/* 57782607Sdillon * MPSAFE 57882607Sdillon */ 57912866Speterint 58083366Sjulianmsgsnd(td, uap) 58183366Sjulian struct thread *td; 5822729Sdfr register struct msgsnd_args *uap; 5832729Sdfr{ 5842729Sdfr int msqid = uap->msqid; 585109895Salfred const void *user_msgp = uap->msgp; 5862729Sdfr size_t msgsz = uap->msgsz; 5872729Sdfr int msgflg = uap->msgflg; 58882607Sdillon int segs_needed, error = 0; 5892729Sdfr register struct msqid_ds *msqptr; 5902729Sdfr register struct msg *msghdr; 5912729Sdfr short next; 5922729Sdfr 593100523Salfred DPRINTF(("call to msgsnd(%d, 0x%x, %d, %d)\n", msqid, user_msgp, msgsz, 594100523Salfred msgflg)); 59591703Sjhb if (!jail_sysvipc_allowed && jailed(td->td_ucred)) 59691703Sjhb return (ENOSYS); 59791703Sjhb 598101772Salfred mtx_lock(&msq_mtx); 5992729Sdfr msqid = IPCID_TO_IX(msqid); 6002729Sdfr 6012729Sdfr if (msqid < 0 || msqid >= msginfo.msgmni) { 602100523Salfred DPRINTF(("msqid (%d) out of range (0<=msqid<%d)\n", msqid, 603100523Salfred msginfo.msgmni)); 60482607Sdillon error = EINVAL; 60582607Sdillon goto done2; 6062729Sdfr } 6072729Sdfr 6082729Sdfr msqptr = &msqids[msqid]; 6092729Sdfr if (msqptr->msg_qbytes == 0) { 610100523Salfred DPRINTF(("no such message queue id\n")); 61182607Sdillon error = EINVAL; 61282607Sdillon goto done2; 6132729Sdfr } 6142729Sdfr if (msqptr->msg_perm.seq != IPCID_TO_SEQ(uap->msqid)) { 615100523Salfred DPRINTF(("wrong sequence number\n")); 61682607Sdillon error = EINVAL; 61782607Sdillon goto done2; 6182729Sdfr } 6192729Sdfr 62083366Sjulian if ((error = ipcperm(td, &msqptr->msg_perm, IPC_W))) { 621100523Salfred DPRINTF(("requester doesn't have write access\n")); 62282607Sdillon goto done2; 6232729Sdfr } 6242729Sdfr 6252729Sdfr segs_needed = (msgsz + msginfo.msgssz - 1) / msginfo.msgssz; 626100523Salfred DPRINTF(("msgsz=%d, msgssz=%d, segs_needed=%d\n", msgsz, msginfo.msgssz, 627100523Salfred segs_needed)); 6282729Sdfr for (;;) { 6292729Sdfr int need_more_resources = 0; 6302729Sdfr 6312729Sdfr /* 6322729Sdfr * check msgsz 6332729Sdfr * (inside this loop in case msg_qbytes changes while we sleep) 6342729Sdfr */ 6352729Sdfr 6362836Sdg if (msgsz > msqptr->msg_qbytes) { 637100523Salfred DPRINTF(("msgsz > msqptr->msg_qbytes\n")); 63882607Sdillon error = EINVAL; 63982607Sdillon goto done2; 6402729Sdfr } 6412729Sdfr 6422729Sdfr if (msqptr->msg_perm.mode & MSG_LOCKED) { 643100523Salfred DPRINTF(("msqid is locked\n")); 6442729Sdfr need_more_resources = 1; 6452729Sdfr } 6462729Sdfr if (msgsz + msqptr->msg_cbytes > msqptr->msg_qbytes) { 647100523Salfred DPRINTF(("msgsz + msg_cbytes > msg_qbytes\n")); 6482729Sdfr need_more_resources = 1; 6492729Sdfr } 6502729Sdfr if (segs_needed > nfree_msgmaps) { 651100523Salfred DPRINTF(("segs_needed > nfree_msgmaps\n")); 6522729Sdfr need_more_resources = 1; 6532729Sdfr } 6542729Sdfr if (free_msghdrs == NULL) { 655100523Salfred DPRINTF(("no more msghdrs\n")); 6562729Sdfr need_more_resources = 1; 6572729Sdfr } 6582729Sdfr 6592729Sdfr if (need_more_resources) { 6602729Sdfr int we_own_it; 6612729Sdfr 6622729Sdfr if ((msgflg & IPC_NOWAIT) != 0) { 663100523Salfred DPRINTF(("need more resources but caller " 664100523Salfred "doesn't want to wait\n")); 66582607Sdillon error = EAGAIN; 66682607Sdillon goto done2; 6672729Sdfr } 6682729Sdfr 6692729Sdfr if ((msqptr->msg_perm.mode & MSG_LOCKED) != 0) { 670100523Salfred DPRINTF(("we don't own the msqid_ds\n")); 6712729Sdfr we_own_it = 0; 6722729Sdfr } else { 6732729Sdfr /* Force later arrivals to wait for our 6742729Sdfr request */ 675100523Salfred DPRINTF(("we own the msqid_ds\n")); 6762729Sdfr msqptr->msg_perm.mode |= MSG_LOCKED; 6772729Sdfr we_own_it = 1; 6782729Sdfr } 679100523Salfred DPRINTF(("goodnight\n")); 680101772Salfred error = msleep(msqptr, &msq_mtx, (PZERO - 4) | PCATCH, 6812729Sdfr "msgwait", 0); 682100523Salfred DPRINTF(("good morning, error=%d\n", error)); 6832729Sdfr if (we_own_it) 6842729Sdfr msqptr->msg_perm.mode &= ~MSG_LOCKED; 68582607Sdillon if (error != 0) { 686100523Salfred DPRINTF(("msgsnd: interrupted system call\n")); 68782607Sdillon error = EINTR; 68882607Sdillon goto done2; 6892729Sdfr } 6902729Sdfr 6912729Sdfr /* 6922729Sdfr * Make sure that the msq queue still exists 6932729Sdfr */ 6942729Sdfr 6952729Sdfr if (msqptr->msg_qbytes == 0) { 696100523Salfred DPRINTF(("msqid deleted\n")); 69782607Sdillon error = EIDRM; 69882607Sdillon goto done2; 6992729Sdfr } 7002729Sdfr 7012729Sdfr } else { 702100523Salfred DPRINTF(("got all the resources that we need\n")); 7032729Sdfr break; 7042729Sdfr } 7052729Sdfr } 7062729Sdfr 7072729Sdfr /* 7082729Sdfr * We have the resources that we need. 7092729Sdfr * Make sure! 7102729Sdfr */ 7112729Sdfr 7122729Sdfr if (msqptr->msg_perm.mode & MSG_LOCKED) 7132729Sdfr panic("msg_perm.mode & MSG_LOCKED"); 7142729Sdfr if (segs_needed > nfree_msgmaps) 7152729Sdfr panic("segs_needed > nfree_msgmaps"); 7162729Sdfr if (msgsz + msqptr->msg_cbytes > msqptr->msg_qbytes) 7172729Sdfr panic("msgsz + msg_cbytes > msg_qbytes"); 7182729Sdfr if (free_msghdrs == NULL) 7192729Sdfr panic("no more msghdrs"); 7202729Sdfr 7212729Sdfr /* 7222729Sdfr * Re-lock the msqid_ds in case we page-fault when copying in the 7232729Sdfr * message 7242729Sdfr */ 7252729Sdfr 7262729Sdfr if ((msqptr->msg_perm.mode & MSG_LOCKED) != 0) 7272729Sdfr panic("msqid_ds is already locked"); 7282729Sdfr msqptr->msg_perm.mode |= MSG_LOCKED; 7292729Sdfr 7302729Sdfr /* 7312729Sdfr * Allocate a message header 7322729Sdfr */ 7332729Sdfr 7342729Sdfr msghdr = free_msghdrs; 7352729Sdfr free_msghdrs = msghdr->msg_next; 7362729Sdfr msghdr->msg_spot = -1; 7372729Sdfr msghdr->msg_ts = msgsz; 7382729Sdfr 7392729Sdfr /* 7402729Sdfr * Allocate space for the message 7412729Sdfr */ 7422729Sdfr 7432729Sdfr while (segs_needed > 0) { 7442729Sdfr if (nfree_msgmaps <= 0) 7452729Sdfr panic("not enough msgmaps"); 7462729Sdfr if (free_msgmaps == -1) 7472729Sdfr panic("nil free_msgmaps"); 7482729Sdfr next = free_msgmaps; 7492729Sdfr if (next <= -1) 7502729Sdfr panic("next too low #1"); 7512729Sdfr if (next >= msginfo.msgseg) 7522729Sdfr panic("next out of range #1"); 753100523Salfred DPRINTF(("allocating segment %d to message\n", next)); 7542729Sdfr free_msgmaps = msgmaps[next].next; 7552729Sdfr nfree_msgmaps--; 7562729Sdfr msgmaps[next].next = msghdr->msg_spot; 7572729Sdfr msghdr->msg_spot = next; 7582729Sdfr segs_needed--; 7592729Sdfr } 7602729Sdfr 7612729Sdfr /* 7622729Sdfr * Copy in the message type 7632729Sdfr */ 7642729Sdfr 765101772Salfred mtx_unlock(&msq_mtx); 76682607Sdillon if ((error = copyin(user_msgp, &msghdr->msg_type, 7672729Sdfr sizeof(msghdr->msg_type))) != 0) { 768101772Salfred mtx_lock(&msq_mtx); 769100523Salfred DPRINTF(("error %d copying the message type\n", error)); 7702729Sdfr msg_freehdr(msghdr); 7712729Sdfr msqptr->msg_perm.mode &= ~MSG_LOCKED; 772100511Salfred wakeup(msqptr); 77382607Sdillon goto done2; 7742729Sdfr } 775101772Salfred mtx_lock(&msq_mtx); 776109906Salfred user_msgp = (const char *)user_msgp + sizeof(msghdr->msg_type); 7772729Sdfr 7782729Sdfr /* 7792729Sdfr * Validate the message type 7802729Sdfr */ 7812729Sdfr 7822729Sdfr if (msghdr->msg_type < 1) { 7832729Sdfr msg_freehdr(msghdr); 7842729Sdfr msqptr->msg_perm.mode &= ~MSG_LOCKED; 785100511Salfred wakeup(msqptr); 786100523Salfred DPRINTF(("mtype (%d) < 1\n", msghdr->msg_type)); 78782607Sdillon error = EINVAL; 78882607Sdillon goto done2; 7892729Sdfr } 7902729Sdfr 7912729Sdfr /* 7922729Sdfr * Copy in the message body 7932729Sdfr */ 7942729Sdfr 7952729Sdfr next = msghdr->msg_spot; 7962729Sdfr while (msgsz > 0) { 7972729Sdfr size_t tlen; 7982729Sdfr if (msgsz > msginfo.msgssz) 7992729Sdfr tlen = msginfo.msgssz; 8002729Sdfr else 8012729Sdfr tlen = msgsz; 8022729Sdfr if (next <= -1) 8032729Sdfr panic("next too low #2"); 8042729Sdfr if (next >= msginfo.msgseg) 8052729Sdfr panic("next out of range #2"); 806101772Salfred mtx_unlock(&msq_mtx); 80782607Sdillon if ((error = copyin(user_msgp, &msgpool[next * msginfo.msgssz], 8082729Sdfr tlen)) != 0) { 809101772Salfred mtx_lock(&msq_mtx); 810100523Salfred DPRINTF(("error %d copying in message segment\n", 811100523Salfred error)); 8122729Sdfr msg_freehdr(msghdr); 8132729Sdfr msqptr->msg_perm.mode &= ~MSG_LOCKED; 814100511Salfred wakeup(msqptr); 81582607Sdillon goto done2; 8162729Sdfr } 817101772Salfred mtx_lock(&msq_mtx); 8182729Sdfr msgsz -= tlen; 819109906Salfred user_msgp = (const char *)user_msgp + tlen; 8202729Sdfr next = msgmaps[next].next; 8212729Sdfr } 8222729Sdfr if (next != -1) 8232729Sdfr panic("didn't use all the msg segments"); 8242729Sdfr 8252729Sdfr /* 8262729Sdfr * We've got the message. Unlock the msqid_ds. 8272729Sdfr */ 8282729Sdfr 8292729Sdfr msqptr->msg_perm.mode &= ~MSG_LOCKED; 8302729Sdfr 8312729Sdfr /* 8322729Sdfr * Make sure that the msqid_ds is still allocated. 8332729Sdfr */ 8342729Sdfr 8352729Sdfr if (msqptr->msg_qbytes == 0) { 8362729Sdfr msg_freehdr(msghdr); 837100511Salfred wakeup(msqptr); 83882607Sdillon error = EIDRM; 83982607Sdillon goto done2; 8402729Sdfr } 8412729Sdfr 8422729Sdfr /* 8432729Sdfr * Put the message into the queue 8442729Sdfr */ 8452729Sdfr 8462729Sdfr if (msqptr->msg_first == NULL) { 8472729Sdfr msqptr->msg_first = msghdr; 8482729Sdfr msqptr->msg_last = msghdr; 8492729Sdfr } else { 8502729Sdfr msqptr->msg_last->msg_next = msghdr; 8512729Sdfr msqptr->msg_last = msghdr; 8522729Sdfr } 8532729Sdfr msqptr->msg_last->msg_next = NULL; 8542729Sdfr 8552729Sdfr msqptr->msg_cbytes += msghdr->msg_ts; 8562729Sdfr msqptr->msg_qnum++; 85783366Sjulian msqptr->msg_lspid = td->td_proc->p_pid; 85834961Sphk msqptr->msg_stime = time_second; 8592729Sdfr 860100511Salfred wakeup(msqptr); 86183366Sjulian td->td_retval[0] = 0; 86282607Sdillondone2: 863101772Salfred mtx_unlock(&msq_mtx); 86482607Sdillon return (error); 8652729Sdfr} 8662729Sdfr 86712866Speter#ifndef _SYS_SYSPROTO_H_ 8682729Sdfrstruct msgrcv_args { 8692729Sdfr int msqid; 8702729Sdfr void *msgp; 8712729Sdfr size_t msgsz; 8722729Sdfr long msgtyp; 8732729Sdfr int msgflg; 8742729Sdfr}; 87512866Speter#endif 8762729Sdfr 87782607Sdillon/* 87882607Sdillon * MPSAFE 87982607Sdillon */ 88012866Speterint 88183366Sjulianmsgrcv(td, uap) 88283366Sjulian struct thread *td; 8832729Sdfr register struct msgrcv_args *uap; 8842729Sdfr{ 8852729Sdfr int msqid = uap->msqid; 8862729Sdfr void *user_msgp = uap->msgp; 8872729Sdfr size_t msgsz = uap->msgsz; 8882729Sdfr long msgtyp = uap->msgtyp; 8892729Sdfr int msgflg = uap->msgflg; 8902729Sdfr size_t len; 8912729Sdfr register struct msqid_ds *msqptr; 8922729Sdfr register struct msg *msghdr; 89382607Sdillon int error = 0; 8942729Sdfr short next; 8952729Sdfr 896100523Salfred DPRINTF(("call to msgrcv(%d, 0x%x, %d, %ld, %d)\n", msqid, user_msgp, 897100523Salfred msgsz, msgtyp, msgflg)); 8982729Sdfr 89991703Sjhb if (!jail_sysvipc_allowed && jailed(td->td_ucred)) 90091703Sjhb return (ENOSYS); 90191703Sjhb 9022729Sdfr msqid = IPCID_TO_IX(msqid); 9032729Sdfr 9042729Sdfr if (msqid < 0 || msqid >= msginfo.msgmni) { 905100523Salfred DPRINTF(("msqid (%d) out of range (0<=msqid<%d)\n", msqid, 906100523Salfred msginfo.msgmni)); 907101772Salfred return (EINVAL); 9082729Sdfr } 9092729Sdfr 9102729Sdfr msqptr = &msqids[msqid]; 911101772Salfred mtx_lock(&msq_mtx); 9122729Sdfr if (msqptr->msg_qbytes == 0) { 913100523Salfred DPRINTF(("no such message queue id\n")); 91482607Sdillon error = EINVAL; 91582607Sdillon goto done2; 9162729Sdfr } 9172729Sdfr if (msqptr->msg_perm.seq != IPCID_TO_SEQ(uap->msqid)) { 918100523Salfred DPRINTF(("wrong sequence number\n")); 91982607Sdillon error = EINVAL; 92082607Sdillon goto done2; 9212729Sdfr } 9222729Sdfr 92383366Sjulian if ((error = ipcperm(td, &msqptr->msg_perm, IPC_R))) { 924100523Salfred DPRINTF(("requester doesn't have read access\n")); 92582607Sdillon goto done2; 9262729Sdfr } 9272729Sdfr 9282729Sdfr msghdr = NULL; 9292729Sdfr while (msghdr == NULL) { 9302729Sdfr if (msgtyp == 0) { 9312729Sdfr msghdr = msqptr->msg_first; 9322729Sdfr if (msghdr != NULL) { 9332729Sdfr if (msgsz < msghdr->msg_ts && 9342729Sdfr (msgflg & MSG_NOERROR) == 0) { 935100523Salfred DPRINTF(("first message on the queue " 936100523Salfred "is too big (want %d, got %d)\n", 937100523Salfred msgsz, msghdr->msg_ts)); 93882607Sdillon error = E2BIG; 93982607Sdillon goto done2; 9402729Sdfr } 9412729Sdfr if (msqptr->msg_first == msqptr->msg_last) { 9422729Sdfr msqptr->msg_first = NULL; 9432729Sdfr msqptr->msg_last = NULL; 9442729Sdfr } else { 9452729Sdfr msqptr->msg_first = msghdr->msg_next; 9462729Sdfr if (msqptr->msg_first == NULL) 9472729Sdfr panic("msg_first/last screwed up #1"); 9482729Sdfr } 9492729Sdfr } 9502729Sdfr } else { 9512729Sdfr struct msg *previous; 9522729Sdfr struct msg **prev; 9532729Sdfr 9542729Sdfr previous = NULL; 9552729Sdfr prev = &(msqptr->msg_first); 9562729Sdfr while ((msghdr = *prev) != NULL) { 9572729Sdfr /* 9582729Sdfr * Is this message's type an exact match or is 9592729Sdfr * this message's type less than or equal to 9602729Sdfr * the absolute value of a negative msgtyp? 9612729Sdfr * Note that the second half of this test can 9622729Sdfr * NEVER be true if msgtyp is positive since 9632729Sdfr * msg_type is always positive! 9642729Sdfr */ 9652729Sdfr 9662729Sdfr if (msgtyp == msghdr->msg_type || 9672729Sdfr msghdr->msg_type <= -msgtyp) { 968100523Salfred DPRINTF(("found message type %d, " 969100523Salfred "requested %d\n", 970100523Salfred msghdr->msg_type, msgtyp)); 9712729Sdfr if (msgsz < msghdr->msg_ts && 9722729Sdfr (msgflg & MSG_NOERROR) == 0) { 973100523Salfred DPRINTF(("requested message " 974100523Salfred "on the queue is too big " 975100523Salfred "(want %d, got %d)\n", 976100523Salfred msgsz, msghdr->msg_ts)); 97782607Sdillon error = E2BIG; 97882607Sdillon goto done2; 9792729Sdfr } 9802729Sdfr *prev = msghdr->msg_next; 9812729Sdfr if (msghdr == msqptr->msg_last) { 9822729Sdfr if (previous == NULL) { 9832729Sdfr if (prev != 9842729Sdfr &msqptr->msg_first) 9852729Sdfr panic("msg_first/last screwed up #2"); 9862729Sdfr msqptr->msg_first = 9872729Sdfr NULL; 9882729Sdfr msqptr->msg_last = 9892729Sdfr NULL; 9902729Sdfr } else { 9912729Sdfr if (prev == 9922729Sdfr &msqptr->msg_first) 9932729Sdfr panic("msg_first/last screwed up #3"); 9942729Sdfr msqptr->msg_last = 9952729Sdfr previous; 9962729Sdfr } 9972729Sdfr } 9982729Sdfr break; 9992729Sdfr } 10002729Sdfr previous = msghdr; 10012729Sdfr prev = &(msghdr->msg_next); 10022729Sdfr } 10032729Sdfr } 10042729Sdfr 10052729Sdfr /* 10062729Sdfr * We've either extracted the msghdr for the appropriate 10072729Sdfr * message or there isn't one. 10082729Sdfr * If there is one then bail out of this loop. 10092729Sdfr */ 10102729Sdfr 10112729Sdfr if (msghdr != NULL) 10122729Sdfr break; 10132729Sdfr 10142729Sdfr /* 10152729Sdfr * Hmph! No message found. Does the user want to wait? 10162729Sdfr */ 10172729Sdfr 10182729Sdfr if ((msgflg & IPC_NOWAIT) != 0) { 1019100523Salfred DPRINTF(("no appropriate message found (msgtyp=%d)\n", 1020100523Salfred msgtyp)); 10212729Sdfr /* The SVID says to return ENOMSG. */ 102282607Sdillon error = ENOMSG; 102382607Sdillon goto done2; 10242729Sdfr } 10252729Sdfr 10262729Sdfr /* 10272729Sdfr * Wait for something to happen 10282729Sdfr */ 10292729Sdfr 1030100523Salfred DPRINTF(("msgrcv: goodnight\n")); 1031101772Salfred error = msleep(msqptr, &msq_mtx, (PZERO - 4) | PCATCH, 1032101772Salfred "msgwait", 0); 1033100523Salfred DPRINTF(("msgrcv: good morning (error=%d)\n", error)); 10342729Sdfr 103582607Sdillon if (error != 0) { 1036100523Salfred DPRINTF(("msgsnd: interrupted system call\n")); 103782607Sdillon error = EINTR; 103882607Sdillon goto done2; 10392729Sdfr } 10402729Sdfr 10412729Sdfr /* 10422729Sdfr * Make sure that the msq queue still exists 10432729Sdfr */ 10442729Sdfr 10452729Sdfr if (msqptr->msg_qbytes == 0 || 10462729Sdfr msqptr->msg_perm.seq != IPCID_TO_SEQ(uap->msqid)) { 1047100523Salfred DPRINTF(("msqid deleted\n")); 104882607Sdillon error = EIDRM; 104982607Sdillon goto done2; 10502729Sdfr } 10512729Sdfr } 10522729Sdfr 10532729Sdfr /* 10542729Sdfr * Return the message to the user. 10552729Sdfr * 10562729Sdfr * First, do the bookkeeping (before we risk being interrupted). 10572729Sdfr */ 10582729Sdfr 10592729Sdfr msqptr->msg_cbytes -= msghdr->msg_ts; 10602729Sdfr msqptr->msg_qnum--; 106183366Sjulian msqptr->msg_lrpid = td->td_proc->p_pid; 106234961Sphk msqptr->msg_rtime = time_second; 10632729Sdfr 10642729Sdfr /* 10652729Sdfr * Make msgsz the actual amount that we'll be returning. 10662729Sdfr * Note that this effectively truncates the message if it is too long 10672729Sdfr * (since msgsz is never increased). 10682729Sdfr */ 10692729Sdfr 1070100523Salfred DPRINTF(("found a message, msgsz=%d, msg_ts=%d\n", msgsz, 1071100523Salfred msghdr->msg_ts)); 10722729Sdfr if (msgsz > msghdr->msg_ts) 10732729Sdfr msgsz = msghdr->msg_ts; 10742729Sdfr 10752729Sdfr /* 10762729Sdfr * Return the type to the user. 10772729Sdfr */ 10782729Sdfr 1079101772Salfred mtx_unlock(&msq_mtx); 1080100511Salfred error = copyout(&(msghdr->msg_type), user_msgp, 10812729Sdfr sizeof(msghdr->msg_type)); 1082101772Salfred mtx_lock(&msq_mtx); 108382607Sdillon if (error != 0) { 1084100523Salfred DPRINTF(("error (%d) copying out message type\n", error)); 10852729Sdfr msg_freehdr(msghdr); 1086100511Salfred wakeup(msqptr); 108782607Sdillon goto done2; 10882729Sdfr } 108917971Sbde user_msgp = (char *)user_msgp + sizeof(msghdr->msg_type); 10902729Sdfr 10912729Sdfr /* 10922729Sdfr * Return the segments to the user 10932729Sdfr */ 10942729Sdfr 10952729Sdfr next = msghdr->msg_spot; 10962729Sdfr for (len = 0; len < msgsz; len += msginfo.msgssz) { 10972729Sdfr size_t tlen; 10982729Sdfr 109945921Ssada if (msgsz - len > msginfo.msgssz) 11002729Sdfr tlen = msginfo.msgssz; 11012729Sdfr else 110245921Ssada tlen = msgsz - len; 11032729Sdfr if (next <= -1) 11042729Sdfr panic("next too low #3"); 11052729Sdfr if (next >= msginfo.msgseg) 11062729Sdfr panic("next out of range #3"); 1107101772Salfred mtx_unlock(&msq_mtx); 1108100511Salfred error = copyout(&msgpool[next * msginfo.msgssz], 11092729Sdfr user_msgp, tlen); 1110101772Salfred mtx_lock(&msq_mtx); 111182607Sdillon if (error != 0) { 1112100523Salfred DPRINTF(("error (%d) copying out message segment\n", 1113100523Salfred error)); 11142729Sdfr msg_freehdr(msghdr); 1115100511Salfred wakeup(msqptr); 111682607Sdillon goto done2; 11172729Sdfr } 111817971Sbde user_msgp = (char *)user_msgp + tlen; 11192729Sdfr next = msgmaps[next].next; 11202729Sdfr } 11212729Sdfr 11222729Sdfr /* 11232729Sdfr * Done, return the actual number of bytes copied out. 11242729Sdfr */ 11252729Sdfr 11262729Sdfr msg_freehdr(msghdr); 1127100511Salfred wakeup(msqptr); 112883366Sjulian td->td_retval[0] = msgsz; 112982607Sdillondone2: 1130101772Salfred mtx_unlock(&msq_mtx); 113182607Sdillon return (error); 11322729Sdfr} 113377461Sdd 113477461Sddstatic int 113577461Sddsysctl_msqids(SYSCTL_HANDLER_ARGS) 113677461Sdd{ 113777461Sdd 113877461Sdd return (SYSCTL_OUT(req, msqids, 113977461Sdd sizeof(struct msqid_ds) * msginfo.msgmni)); 114077461Sdd} 114177461Sdd 114277461SddSYSCTL_DECL(_kern_ipc); 114377461SddSYSCTL_INT(_kern_ipc, OID_AUTO, msgmax, CTLFLAG_RD, &msginfo.msgmax, 0, ""); 114477461SddSYSCTL_INT(_kern_ipc, OID_AUTO, msgmni, CTLFLAG_RD, &msginfo.msgmni, 0, ""); 114577461SddSYSCTL_INT(_kern_ipc, OID_AUTO, msgmnb, CTLFLAG_RD, &msginfo.msgmnb, 0, ""); 114677461SddSYSCTL_INT(_kern_ipc, OID_AUTO, msgtql, CTLFLAG_RD, &msginfo.msgtql, 0, ""); 114777461SddSYSCTL_INT(_kern_ipc, OID_AUTO, msgssz, CTLFLAG_RD, &msginfo.msgssz, 0, ""); 1148100076SmarkmSYSCTL_INT(_kern_ipc, OID_AUTO, msgseg, CTLFLAG_RD, &msginfo.msgseg, 0, ""); 114977461SddSYSCTL_PROC(_kern_ipc, OID_AUTO, msqids, CTLFLAG_RD, 115077461Sdd NULL, 0, sysctl_msqids, "", "Message queue IDs"); 1151