Home | History | Annotate | Line # | Download | only in kern
sys_mqueue.c revision 1.9
      1  1.9     ad /*	$NetBSD: sys_mqueue.c,v 1.9 2008/03/27 18:30:15 ad Exp $	*/
      2  1.1  rmind 
      3  1.1  rmind /*
      4  1.8  rmind  * Copyright (c) 2007, 2008 Mindaugas Rasiukevicius <rmind at NetBSD org>
      5  1.5  rmind  * All rights reserved.
      6  1.1  rmind  *
      7  1.1  rmind  * Redistribution and use in source and binary forms, with or without
      8  1.1  rmind  * modification, are permitted provided that the following conditions
      9  1.1  rmind  * are met:
     10  1.1  rmind  * 1. Redistributions of source code must retain the above copyright
     11  1.1  rmind  *    notice, this list of conditions and the following disclaimer.
     12  1.1  rmind  * 2. Redistributions in binary form must reproduce the above copyright
     13  1.1  rmind  *    notice, this list of conditions and the following disclaimer in the
     14  1.1  rmind  *    documentation and/or other materials provided with the distribution.
     15  1.1  rmind  *
     16  1.8  rmind  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
     17  1.8  rmind  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     18  1.8  rmind  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     19  1.8  rmind  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     20  1.8  rmind  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     21  1.8  rmind  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     22  1.8  rmind  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     23  1.8  rmind  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     24  1.8  rmind  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     25  1.8  rmind  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     26  1.8  rmind  * SUCH DAMAGE.
     27  1.1  rmind  */
     28  1.1  rmind 
     29  1.1  rmind /*
     30  1.1  rmind  * Implementation of POSIX message queues.
     31  1.1  rmind  * Defined in the Base Definitions volume of IEEE Std 1003.1-2001.
     32  1.1  rmind  *
     33  1.1  rmind  * Locking
     34  1.1  rmind  *  Global list of message queues and proc::p_mqueue_cnt counter are protected
     35  1.1  rmind  *  by mqlist_mtx lock.  Concrete message queue and its members are protected
     36  1.1  rmind  *  by mqueue::mq_mtx.
     37  1.1  rmind  *
     38  1.1  rmind  * Lock order:
     39  1.1  rmind  * 	mqlist_mtx
     40  1.1  rmind  * 	  -> mqueue::mq_mtx
     41  1.1  rmind  */
     42  1.1  rmind 
     43  1.1  rmind #include <sys/cdefs.h>
     44  1.9     ad __KERNEL_RCSID(0, "$NetBSD: sys_mqueue.c,v 1.9 2008/03/27 18:30:15 ad Exp $");
     45  1.1  rmind 
     46  1.1  rmind #include <sys/param.h>
     47  1.1  rmind #include <sys/types.h>
     48  1.1  rmind #include <sys/condvar.h>
     49  1.1  rmind #include <sys/errno.h>
     50  1.1  rmind #include <sys/fcntl.h>
     51  1.1  rmind #include <sys/file.h>
     52  1.1  rmind #include <sys/filedesc.h>
     53  1.1  rmind #include <sys/kauth.h>
     54  1.1  rmind #include <sys/kernel.h>
     55  1.1  rmind #include <sys/kmem.h>
     56  1.1  rmind #include <sys/lwp.h>
     57  1.1  rmind #include <sys/mqueue.h>
     58  1.1  rmind #include <sys/mutex.h>
     59  1.1  rmind #include <sys/pool.h>
     60  1.8  rmind #include <sys/poll.h>
     61  1.1  rmind #include <sys/proc.h>
     62  1.1  rmind #include <sys/queue.h>
     63  1.8  rmind #include <sys/select.h>
     64  1.1  rmind #include <sys/signal.h>
     65  1.1  rmind #include <sys/signalvar.h>
     66  1.1  rmind #include <sys/sysctl.h>
     67  1.1  rmind #include <sys/syscallargs.h>
     68  1.1  rmind #include <sys/systm.h>
     69  1.1  rmind #include <sys/unistd.h>
     70  1.1  rmind #include <sys/vnode.h>
     71  1.1  rmind 
     72  1.1  rmind /* System-wide limits. */
     73  1.1  rmind static u_int			mq_open_max = MQ_OPEN_MAX;
     74  1.1  rmind static u_int			mq_prio_max = MQ_PRIO_MAX;
     75  1.1  rmind 
     76  1.1  rmind static u_int			mq_max_msgsize = 16 * MQ_DEF_MSGSIZE;
     77  1.1  rmind static u_int			mq_def_maxmsg = 32;
     78  1.1  rmind 
     79  1.1  rmind static kmutex_t			mqlist_mtx;
     80  1.8  rmind static pool_cache_t		mqmsg_cache;
     81  1.4   matt static LIST_HEAD(, mqueue)	mqueue_head =
     82  1.4   matt 	LIST_HEAD_INITIALIZER(mqueue_head);
     83  1.1  rmind 
     84  1.8  rmind static int	mq_poll_fop(file_t *, int);
     85  1.7     ad static int	mq_close_fop(file_t *);
     86  1.1  rmind 
     87  1.1  rmind static const struct fileops mqops = {
     88  1.8  rmind 	fbadop_read, fbadop_write, fbadop_ioctl, fnullop_fcntl, mq_poll_fop,
     89  1.1  rmind 	fbadop_stat, mq_close_fop, fnullop_kqfilter
     90  1.1  rmind };
     91  1.1  rmind 
     92  1.1  rmind /*
     93  1.1  rmind  * Initialize POSIX message queue subsystem.
     94  1.1  rmind  */
     95  1.1  rmind void
     96  1.1  rmind mqueue_sysinit(void)
     97  1.1  rmind {
     98  1.1  rmind 
     99  1.9     ad 	mqmsg_cache = pool_cache_init(MQ_DEF_MSGSIZE, coherency_unit,
    100  1.8  rmind 	    0, 0, "mqmsg_cache", NULL, IPL_NONE, NULL, NULL, NULL);
    101  1.1  rmind 	mutex_init(&mqlist_mtx, MUTEX_DEFAULT, IPL_NONE);
    102  1.1  rmind }
    103  1.1  rmind 
    104  1.1  rmind /*
    105  1.1  rmind  * Free the message.
    106  1.1  rmind  */
    107  1.1  rmind static void
    108  1.1  rmind mqueue_freemsg(struct mq_msg *msg, const size_t size)
    109  1.1  rmind {
    110  1.1  rmind 
    111  1.1  rmind 	if (size > MQ_DEF_MSGSIZE)
    112  1.1  rmind 		kmem_free(msg, size);
    113  1.1  rmind 	else
    114  1.8  rmind 		pool_cache_put(mqmsg_cache, msg);
    115  1.1  rmind }
    116  1.1  rmind 
    117  1.1  rmind /*
    118  1.1  rmind  * Destroy the message queue.
    119  1.1  rmind  */
    120  1.1  rmind static void
    121  1.1  rmind mqueue_destroy(struct mqueue *mq)
    122  1.1  rmind {
    123  1.1  rmind 	struct mq_msg *msg;
    124  1.1  rmind 
    125  1.1  rmind 	while ((msg = TAILQ_FIRST(&mq->mq_head)) != NULL) {
    126  1.1  rmind 		TAILQ_REMOVE(&mq->mq_head, msg, msg_queue);
    127  1.1  rmind 		mqueue_freemsg(msg, sizeof(struct mq_msg) + msg->msg_len);
    128  1.1  rmind 	}
    129  1.8  rmind 	seldestroy(&mq->mq_rsel);
    130  1.8  rmind 	seldestroy(&mq->mq_wsel);
    131  1.1  rmind 	cv_destroy(&mq->mq_send_cv);
    132  1.1  rmind 	cv_destroy(&mq->mq_recv_cv);
    133  1.1  rmind 	mutex_destroy(&mq->mq_mtx);
    134  1.1  rmind 	kmem_free(mq, sizeof(struct mqueue));
    135  1.1  rmind }
    136  1.1  rmind 
    137  1.1  rmind /*
    138  1.1  rmind  * Lookup for file name in general list of message queues.
    139  1.1  rmind  *  => locks the message queue
    140  1.1  rmind  */
    141  1.1  rmind static void *
    142  1.1  rmind mqueue_lookup(char *name)
    143  1.1  rmind {
    144  1.1  rmind 	struct mqueue *mq;
    145  1.1  rmind 	KASSERT(mutex_owned(&mqlist_mtx));
    146  1.1  rmind 
    147  1.1  rmind 	LIST_FOREACH(mq, &mqueue_head, mq_list) {
    148  1.1  rmind 		if (strncmp(mq->mq_name, name, MQ_NAMELEN) == 0) {
    149  1.1  rmind 			mutex_enter(&mq->mq_mtx);
    150  1.1  rmind 			return mq;
    151  1.1  rmind 		}
    152  1.1  rmind 	}
    153  1.1  rmind 
    154  1.1  rmind 	return NULL;
    155  1.1  rmind }
    156  1.1  rmind 
    157  1.1  rmind /*
    158  1.1  rmind  * Check access against message queue.
    159  1.1  rmind  */
    160  1.1  rmind static inline int
    161  1.1  rmind mqueue_access(struct lwp *l, struct mqueue *mq, mode_t acc_mode)
    162  1.1  rmind {
    163  1.1  rmind 
    164  1.1  rmind 	KASSERT(mutex_owned(&mq->mq_mtx));
    165  1.1  rmind 	return vaccess(VNON, mq->mq_mode, mq->mq_euid, mq->mq_egid,
    166  1.1  rmind 	    acc_mode, l->l_cred);
    167  1.1  rmind }
    168  1.1  rmind 
    169  1.1  rmind /*
    170  1.1  rmind  * Get the mqueue from the descriptor.
    171  1.1  rmind  *  => locks the message queue
    172  1.1  rmind  *  => increments the reference on file entry
    173  1.1  rmind  */
    174  1.1  rmind static int
    175  1.7     ad mqueue_get(struct lwp *l, mqd_t mqd, mode_t acc_mode, file_t **fpr)
    176  1.1  rmind {
    177  1.7     ad 	file_t *fp;
    178  1.1  rmind 	struct mqueue *mq;
    179  1.1  rmind 
    180  1.1  rmind 	/* Get the file and descriptor */
    181  1.7     ad 	fp = fd_getfile((int)mqd);
    182  1.1  rmind 	if (fp == NULL)
    183  1.1  rmind 		return EBADF;
    184  1.1  rmind 
    185  1.1  rmind 	/* Increment the reference of file entry, and lock the mqueue */
    186  1.1  rmind 	mq = fp->f_data;
    187  1.1  rmind 	*fpr = fp;
    188  1.1  rmind 	mutex_enter(&mq->mq_mtx);
    189  1.1  rmind 
    190  1.1  rmind 	/* Check the access mode and permission if needed */
    191  1.1  rmind 	if (acc_mode == VNOVAL)
    192  1.1  rmind 		return 0;
    193  1.1  rmind 	if ((acc_mode & fp->f_flag) == 0 || mqueue_access(l, mq, acc_mode)) {
    194  1.1  rmind 		mutex_exit(&mq->mq_mtx);
    195  1.7     ad 		fd_putfile((int)mqd);
    196  1.1  rmind 		return EPERM;
    197  1.1  rmind 	}
    198  1.1  rmind 
    199  1.1  rmind 	return 0;
    200  1.1  rmind }
    201  1.1  rmind 
    202  1.1  rmind /*
    203  1.1  rmind  * Converter from struct timespec to the ticks.
    204  1.1  rmind  * Used by mq_timedreceive(), mq_timedsend().
    205  1.1  rmind  */
    206  1.1  rmind static int
    207  1.1  rmind abstimeout2timo(const void *uaddr, int *timo)
    208  1.1  rmind {
    209  1.1  rmind 	struct timespec ts;
    210  1.1  rmind 	int error;
    211  1.1  rmind 
    212  1.1  rmind 	error = copyin(uaddr, &ts, sizeof(struct timespec));
    213  1.1  rmind 	if (error)
    214  1.1  rmind 		return error;
    215  1.1  rmind 
    216  1.1  rmind 	/*
    217  1.1  rmind 	 * According to POSIX, validation check is needed only in case of
    218  1.1  rmind 	 * blocking.  Thus, set the invalid value right now, and fail latter.
    219  1.1  rmind 	 */
    220  1.1  rmind 	error = itimespecfix(&ts);
    221  1.1  rmind 	*timo = (error == 0) ? tstohz(&ts) : -1;
    222  1.1  rmind 
    223  1.1  rmind 	return 0;
    224  1.1  rmind }
    225  1.1  rmind 
    226  1.1  rmind static int
    227  1.8  rmind mq_poll_fop(file_t *fp, int events)
    228  1.8  rmind {
    229  1.8  rmind 	struct mqueue *mq = fp->f_data;
    230  1.8  rmind 	int revents = 0;
    231  1.8  rmind 
    232  1.8  rmind 	mutex_enter(&mq->mq_mtx);
    233  1.8  rmind 	if (events & (POLLIN | POLLRDNORM)) {
    234  1.8  rmind 		/* Ready for receiving, if there are messages in the queue */
    235  1.8  rmind 		if (mq->mq_attrib.mq_curmsgs)
    236  1.8  rmind 			revents |= (POLLIN | POLLRDNORM);
    237  1.8  rmind 		else
    238  1.8  rmind 			selrecord(curlwp, &mq->mq_rsel);
    239  1.8  rmind 	}
    240  1.8  rmind 	if (events & (POLLOUT | POLLWRNORM)) {
    241  1.8  rmind 		/* Ready for sending, if the message queue is not full */
    242  1.8  rmind 		if (mq->mq_attrib.mq_curmsgs < mq->mq_attrib.mq_maxmsg)
    243  1.8  rmind 			revents |= (POLLOUT | POLLWRNORM);
    244  1.8  rmind 		else
    245  1.8  rmind 			selrecord(curlwp, &mq->mq_wsel);
    246  1.8  rmind 	}
    247  1.8  rmind 	mutex_exit(&mq->mq_mtx);
    248  1.8  rmind 
    249  1.8  rmind 	return revents;
    250  1.8  rmind }
    251  1.8  rmind 
    252  1.8  rmind static int
    253  1.7     ad mq_close_fop(file_t *fp)
    254  1.1  rmind {
    255  1.7     ad 	struct proc *p = curproc;
    256  1.1  rmind 	struct mqueue *mq = fp->f_data;
    257  1.1  rmind 	bool destroy;
    258  1.1  rmind 
    259  1.1  rmind 	mutex_enter(&mqlist_mtx);
    260  1.1  rmind 	mutex_enter(&mq->mq_mtx);
    261  1.1  rmind 
    262  1.1  rmind 	/* Decrease the counters */
    263  1.1  rmind 	p->p_mqueue_cnt--;
    264  1.1  rmind 	mq->mq_refcnt--;
    265  1.1  rmind 
    266  1.1  rmind 	/* Remove notification if registered for this process */
    267  1.1  rmind 	if (mq->mq_notify_proc == p)
    268  1.1  rmind 		mq->mq_notify_proc = NULL;
    269  1.1  rmind 
    270  1.1  rmind 	/*
    271  1.1  rmind 	 * If this is the last reference and mqueue is marked for unlink,
    272  1.1  rmind 	 * remove and later destroy the message queue.
    273  1.1  rmind 	 */
    274  1.1  rmind 	if (mq->mq_refcnt == 0 && (mq->mq_attrib.mq_flags & MQ_UNLINK)) {
    275  1.1  rmind 		LIST_REMOVE(mq, mq_list);
    276  1.1  rmind 		destroy = true;
    277  1.1  rmind 	} else
    278  1.1  rmind 		destroy = false;
    279  1.1  rmind 
    280  1.1  rmind 	mutex_exit(&mq->mq_mtx);
    281  1.1  rmind 	mutex_exit(&mqlist_mtx);
    282  1.1  rmind 
    283  1.1  rmind 	if (destroy)
    284  1.1  rmind 		mqueue_destroy(mq);
    285  1.1  rmind 
    286  1.1  rmind 	return 0;
    287  1.1  rmind }
    288  1.1  rmind 
    289  1.1  rmind /*
    290  1.1  rmind  * General mqueue system calls.
    291  1.1  rmind  */
    292  1.1  rmind 
    293  1.1  rmind int
    294  1.8  rmind sys_mq_open(struct lwp *l, const struct sys_mq_open_args *uap,
    295  1.8  rmind     register_t *retval)
    296  1.1  rmind {
    297  1.6    dsl 	/* {
    298  1.1  rmind 		syscallarg(const char *) name;
    299  1.1  rmind 		syscallarg(int) oflag;
    300  1.1  rmind 		syscallarg(mode_t) mode;
    301  1.1  rmind 		syscallarg(struct mq_attr) attr;
    302  1.6    dsl 	} */
    303  1.1  rmind 	struct proc *p = l->l_proc;
    304  1.1  rmind 	struct mqueue *mq, *mq_new = NULL;
    305  1.7     ad 	file_t *fp;
    306  1.1  rmind 	char *name;
    307  1.1  rmind 	int mqd, error, oflag;
    308  1.1  rmind 
    309  1.1  rmind 	/* Check access mode flags */
    310  1.1  rmind 	oflag = SCARG(uap, oflag);
    311  1.1  rmind 	if ((oflag & (O_RDWR | O_RDONLY | O_WRONLY)) == 0)
    312  1.1  rmind 		return EINVAL;
    313  1.1  rmind 
    314  1.1  rmind 	/* Get the name from the user-space */
    315  1.1  rmind 	name = kmem_zalloc(MQ_NAMELEN, KM_SLEEP);
    316  1.1  rmind 	error = copyinstr(SCARG(uap, name), name, MQ_NAMELEN - 1, NULL);
    317  1.1  rmind 	if (error) {
    318  1.1  rmind 		kmem_free(name, MQ_NAMELEN);
    319  1.1  rmind 		return error;
    320  1.1  rmind 	}
    321  1.1  rmind 
    322  1.1  rmind 	if (oflag & O_CREAT) {
    323  1.1  rmind 		struct mq_attr attr;
    324  1.1  rmind 
    325  1.1  rmind 		/* Check the limit */
    326  1.1  rmind 		if (p->p_mqueue_cnt == mq_open_max) {
    327  1.1  rmind 			kmem_free(name, MQ_NAMELEN);
    328  1.1  rmind 			return EMFILE;
    329  1.1  rmind 		}
    330  1.1  rmind 
    331  1.1  rmind 		/* Check for mqueue attributes */
    332  1.1  rmind 		if (SCARG(uap, attr)) {
    333  1.1  rmind 			error = copyin(SCARG(uap, attr), &attr,
    334  1.1  rmind 				sizeof(struct mq_attr));
    335  1.1  rmind 			if (error) {
    336  1.1  rmind 				kmem_free(name, MQ_NAMELEN);
    337  1.1  rmind 				return error;
    338  1.1  rmind 			}
    339  1.1  rmind 			if (attr.mq_maxmsg <= 0 || attr.mq_msgsize <= 0 ||
    340  1.1  rmind 			    attr.mq_msgsize > mq_max_msgsize) {
    341  1.1  rmind 				kmem_free(name, MQ_NAMELEN);
    342  1.1  rmind 				return EINVAL;
    343  1.1  rmind 			}
    344  1.1  rmind 			attr.mq_curmsgs = 0;
    345  1.1  rmind 		} else {
    346  1.1  rmind 			memset(&attr, 0, sizeof(struct mq_attr));
    347  1.1  rmind 			attr.mq_maxmsg = mq_def_maxmsg;
    348  1.1  rmind 			attr.mq_msgsize =
    349  1.1  rmind 			    MQ_DEF_MSGSIZE - sizeof(struct mq_msg);
    350  1.1  rmind 		}
    351  1.1  rmind 
    352  1.1  rmind 		/*
    353  1.1  rmind 		 * Allocate new mqueue, initialize data structures,
    354  1.1  rmind 		 * copy the name, attributes and set the flag.
    355  1.1  rmind 		 */
    356  1.1  rmind 		mq_new = kmem_zalloc(sizeof(struct mqueue), KM_SLEEP);
    357  1.1  rmind 
    358  1.1  rmind 		mutex_init(&mq_new->mq_mtx, MUTEX_DEFAULT, IPL_NONE);
    359  1.1  rmind 		cv_init(&mq_new->mq_send_cv, "mqsendcv");
    360  1.1  rmind 		cv_init(&mq_new->mq_recv_cv, "mqrecvcv");
    361  1.1  rmind 		TAILQ_INIT(&mq_new->mq_head);
    362  1.8  rmind 		selinit(&mq_new->mq_rsel);
    363  1.8  rmind 		selinit(&mq_new->mq_wsel);
    364  1.1  rmind 
    365  1.1  rmind 		strlcpy(mq_new->mq_name, name, MQ_NAMELEN);
    366  1.1  rmind 		memcpy(&mq_new->mq_attrib, &attr, sizeof(struct mq_attr));
    367  1.1  rmind 		mq_new->mq_attrib.mq_flags = oflag;
    368  1.1  rmind 
    369  1.1  rmind 		/* Store mode and effective UID with GID */
    370  1.1  rmind 		mq_new->mq_mode = SCARG(uap, mode);
    371  1.1  rmind 		mq_new->mq_euid = kauth_cred_geteuid(l->l_cred);
    372  1.1  rmind 		mq_new->mq_egid = kauth_cred_getegid(l->l_cred);
    373  1.1  rmind 	}
    374  1.1  rmind 
    375  1.1  rmind 	/* Allocate file structure and descriptor */
    376  1.7     ad 	error = fd_allocfile(&fp, &mqd);
    377  1.1  rmind 	if (error) {
    378  1.1  rmind 		if (mq_new)
    379  1.1  rmind 			mqueue_destroy(mq_new);
    380  1.1  rmind 		kmem_free(name, MQ_NAMELEN);
    381  1.1  rmind 		return error;
    382  1.1  rmind 	}
    383  1.1  rmind 	fp->f_type = DTYPE_MQUEUE;
    384  1.1  rmind 	fp->f_flag = (oflag & O_RDWR) ? (VREAD | VWRITE) :
    385  1.1  rmind 	    ((oflag & O_RDONLY) ? VREAD : VWRITE);
    386  1.1  rmind 	fp->f_ops = &mqops;
    387  1.1  rmind 
    388  1.1  rmind 	/* Look up for mqueue with such name */
    389  1.1  rmind 	mutex_enter(&mqlist_mtx);
    390  1.1  rmind 	mq = mqueue_lookup(name);
    391  1.1  rmind 	if (mq) {
    392  1.1  rmind 		KASSERT(mutex_owned(&mq->mq_mtx));
    393  1.1  rmind 		/* Check if mqueue is not marked as unlinking */
    394  1.1  rmind 		if (mq->mq_attrib.mq_flags & MQ_UNLINK) {
    395  1.1  rmind 			error = EACCES;
    396  1.1  rmind 			goto exit;
    397  1.1  rmind 		}
    398  1.1  rmind 		/* Fail if O_EXCL is set, and mqueue already exists */
    399  1.1  rmind 		if ((oflag & O_CREAT) && (oflag & O_EXCL)) {
    400  1.1  rmind 			error = EEXIST;
    401  1.1  rmind 			goto exit;
    402  1.1  rmind 		}
    403  1.1  rmind 		/* Check the permission */
    404  1.1  rmind 		if (mqueue_access(l, mq, fp->f_flag)) {
    405  1.1  rmind 			error = EACCES;
    406  1.1  rmind 			goto exit;
    407  1.1  rmind 		}
    408  1.1  rmind 	} else {
    409  1.1  rmind 		/* Fail if mqueue neither exists, nor we create it */
    410  1.1  rmind 		if ((oflag & O_CREAT) == 0) {
    411  1.1  rmind 			mutex_exit(&mqlist_mtx);
    412  1.1  rmind 			KASSERT(mq_new == NULL);
    413  1.7     ad 			fd_abort(p, fp, mqd);
    414  1.1  rmind 			kmem_free(name, MQ_NAMELEN);
    415  1.1  rmind 			return ENOENT;
    416  1.1  rmind 		}
    417  1.1  rmind 
    418  1.1  rmind 		/* Check the limit */
    419  1.1  rmind 		if (p->p_mqueue_cnt == mq_open_max) {
    420  1.1  rmind 			error = EMFILE;
    421  1.1  rmind 			goto exit;
    422  1.1  rmind 		}
    423  1.1  rmind 
    424  1.1  rmind 		/* Insert the queue to the list */
    425  1.1  rmind 		mq = mq_new;
    426  1.1  rmind 		mutex_enter(&mq->mq_mtx);
    427  1.1  rmind 		LIST_INSERT_HEAD(&mqueue_head, mq, mq_list);
    428  1.1  rmind 		mq_new = NULL;
    429  1.1  rmind 	}
    430  1.1  rmind 
    431  1.1  rmind 	/* Increase the counters, and make descriptor ready */
    432  1.1  rmind 	p->p_mqueue_cnt++;
    433  1.1  rmind 	mq->mq_refcnt++;
    434  1.1  rmind 	fp->f_data = mq;
    435  1.1  rmind exit:
    436  1.1  rmind 	mutex_exit(&mq->mq_mtx);
    437  1.1  rmind 	mutex_exit(&mqlist_mtx);
    438  1.1  rmind 
    439  1.1  rmind 	if (mq_new)
    440  1.1  rmind 		mqueue_destroy(mq_new);
    441  1.1  rmind 	if (error) {
    442  1.7     ad 		fd_abort(p, fp, mqd);
    443  1.7     ad 	} else {
    444  1.7     ad 		fd_affix(p, fp, mqd);
    445  1.1  rmind 		*retval = mqd;
    446  1.7     ad 	}
    447  1.1  rmind 	kmem_free(name, MQ_NAMELEN);
    448  1.1  rmind 
    449  1.1  rmind 	return error;
    450  1.1  rmind }
    451  1.1  rmind 
    452  1.1  rmind int
    453  1.8  rmind sys_mq_close(struct lwp *l, const struct sys_mq_close_args *uap,
    454  1.8  rmind     register_t *retval)
    455  1.1  rmind {
    456  1.1  rmind 
    457  1.6    dsl 	return sys_close(l, (const void *)uap, retval);
    458  1.1  rmind }
    459  1.1  rmind 
    460  1.1  rmind /*
    461  1.1  rmind  * Primary mq_receive1() function.
    462  1.1  rmind  */
    463  1.1  rmind static int
    464  1.1  rmind mq_receive1(struct lwp *l, mqd_t mqdes, void *msg_ptr, size_t msg_len,
    465  1.1  rmind     unsigned *msg_prio, int t, ssize_t *mlen)
    466  1.1  rmind {
    467  1.7     ad 	file_t *fp = NULL;
    468  1.1  rmind 	struct mqueue *mq;
    469  1.1  rmind 	struct mq_msg *msg = NULL;
    470  1.1  rmind 	int error;
    471  1.1  rmind 
    472  1.1  rmind 	/* Get the message queue */
    473  1.1  rmind 	error = mqueue_get(l, mqdes, VREAD, &fp);
    474  1.1  rmind 	if (error)
    475  1.1  rmind 		return error;
    476  1.1  rmind 	mq = fp->f_data;
    477  1.1  rmind 
    478  1.1  rmind 	/* Check the message size limits */
    479  1.1  rmind 	if (msg_len < mq->mq_attrib.mq_msgsize) {
    480  1.1  rmind 		error = EMSGSIZE;
    481  1.1  rmind 		goto error;
    482  1.1  rmind 	}
    483  1.1  rmind 
    484  1.1  rmind 	/* Check if queue is empty */
    485  1.2     ad 	while (TAILQ_EMPTY(&mq->mq_head)) {
    486  1.1  rmind 		if (mq->mq_attrib.mq_flags & O_NONBLOCK) {
    487  1.1  rmind 			error = EAGAIN;
    488  1.1  rmind 			goto error;
    489  1.1  rmind 		}
    490  1.1  rmind 		if (t < 0) {
    491  1.1  rmind 			error = EINVAL;
    492  1.1  rmind 			goto error;
    493  1.1  rmind 		}
    494  1.1  rmind 		/*
    495  1.1  rmind 		 * Block until someone sends the message.
    496  1.1  rmind 		 * While doing this, notification should not be sent.
    497  1.1  rmind 		 */
    498  1.1  rmind 		mq->mq_attrib.mq_flags |= MQ_RECEIVE;
    499  1.1  rmind 		error = cv_timedwait_sig(&mq->mq_send_cv, &mq->mq_mtx, t);
    500  1.1  rmind 		mq->mq_attrib.mq_flags &= ~MQ_RECEIVE;
    501  1.1  rmind 		if (error || (mq->mq_attrib.mq_flags & MQ_UNLINK)) {
    502  1.3  rmind 			error = (error == EWOULDBLOCK) ? ETIMEDOUT : EINTR;
    503  1.1  rmind 			goto error;
    504  1.1  rmind 		}
    505  1.1  rmind 	}
    506  1.1  rmind 
    507  1.1  rmind 	/* Remove the message from the queue */
    508  1.1  rmind 	msg = TAILQ_FIRST(&mq->mq_head);
    509  1.1  rmind 	KASSERT(msg != NULL);
    510  1.1  rmind 	TAILQ_REMOVE(&mq->mq_head, msg, msg_queue);
    511  1.1  rmind 
    512  1.1  rmind 	/* Decrement the counter and signal waiter, if any */
    513  1.1  rmind 	mq->mq_attrib.mq_curmsgs--;
    514  1.1  rmind 	cv_signal(&mq->mq_recv_cv);
    515  1.8  rmind 
    516  1.8  rmind 	/* Ready for sending now */
    517  1.8  rmind 	selnotify(&mq->mq_wsel, POLLOUT | POLLWRNORM, 0);
    518  1.1  rmind error:
    519  1.1  rmind 	mutex_exit(&mq->mq_mtx);
    520  1.7     ad 	fd_putfile((int)mqdes);
    521  1.1  rmind 	if (error)
    522  1.1  rmind 		return error;
    523  1.1  rmind 
    524  1.1  rmind 	/*
    525  1.1  rmind 	 * Copy the data to the user-space.
    526  1.1  rmind 	 * Note: According to POSIX, no message should be removed from the
    527  1.1  rmind 	 * queue in case of fail - this would be violated.
    528  1.1  rmind 	 */
    529  1.1  rmind 	*mlen = msg->msg_len;
    530  1.1  rmind 	error = copyout(msg->msg_ptr, msg_ptr, msg->msg_len);
    531  1.1  rmind 	if (error == 0 && msg_prio)
    532  1.1  rmind 		error = copyout(&msg->msg_prio, msg_prio, sizeof(unsigned));
    533  1.1  rmind 	mqueue_freemsg(msg, sizeof(struct mq_msg) + msg->msg_len);
    534  1.1  rmind 
    535  1.1  rmind 	return error;
    536  1.1  rmind }
    537  1.1  rmind 
    538  1.1  rmind int
    539  1.8  rmind sys_mq_receive(struct lwp *l, const struct sys_mq_receive_args *uap,
    540  1.8  rmind     register_t *retval)
    541  1.1  rmind {
    542  1.6    dsl 	/* {
    543  1.1  rmind 		syscallarg(mqd_t) mqdes;
    544  1.1  rmind 		syscallarg(char *) msg_ptr;
    545  1.1  rmind 		syscallarg(size_t) msg_len;
    546  1.1  rmind 		syscallarg(unsigned *) msg_prio;
    547  1.6    dsl 	} */
    548  1.1  rmind 	int error;
    549  1.1  rmind 	ssize_t mlen;
    550  1.1  rmind 
    551  1.1  rmind 	error = mq_receive1(l, SCARG(uap, mqdes), SCARG(uap, msg_ptr),
    552  1.1  rmind 	    SCARG(uap, msg_len), SCARG(uap, msg_prio), 0, &mlen);
    553  1.1  rmind 	if (error == 0)
    554  1.1  rmind 		*retval = mlen;
    555  1.1  rmind 
    556  1.1  rmind 	return error;
    557  1.1  rmind }
    558  1.1  rmind 
    559  1.1  rmind int
    560  1.8  rmind sys_mq_timedreceive(struct lwp *l, const struct sys_mq_timedreceive_args *uap,
    561  1.8  rmind     register_t *retval)
    562  1.1  rmind {
    563  1.6    dsl 	/* {
    564  1.1  rmind 		syscallarg(mqd_t) mqdes;
    565  1.1  rmind 		syscallarg(char *) msg_ptr;
    566  1.1  rmind 		syscallarg(size_t) msg_len;
    567  1.1  rmind 		syscallarg(unsigned *) msg_prio;
    568  1.1  rmind 		syscallarg(const struct timespec *) abs_timeout;
    569  1.6    dsl 	} */
    570  1.1  rmind 	int error, t;
    571  1.1  rmind 	ssize_t mlen;
    572  1.1  rmind 
    573  1.1  rmind 	/* Get and convert time value */
    574  1.1  rmind 	if (SCARG(uap, abs_timeout)) {
    575  1.1  rmind 		error = abstimeout2timo(SCARG(uap, abs_timeout), &t);
    576  1.1  rmind 		if (error)
    577  1.1  rmind 			return error;
    578  1.1  rmind 	} else
    579  1.1  rmind 		t = 0;
    580  1.1  rmind 
    581  1.1  rmind 	error = mq_receive1(l, SCARG(uap, mqdes), SCARG(uap, msg_ptr),
    582  1.1  rmind 	    SCARG(uap, msg_len), SCARG(uap, msg_prio), t, &mlen);
    583  1.1  rmind 	if (error == 0)
    584  1.1  rmind 		*retval = mlen;
    585  1.1  rmind 
    586  1.1  rmind 	return error;
    587  1.1  rmind }
    588  1.1  rmind 
    589  1.1  rmind /*
    590  1.1  rmind  * Primary mq_send1() function.
    591  1.1  rmind  */
    592  1.1  rmind static int
    593  1.1  rmind mq_send1(struct lwp *l, mqd_t mqdes, const char *msg_ptr, size_t msg_len,
    594  1.1  rmind     unsigned msg_prio, int t)
    595  1.1  rmind {
    596  1.7     ad 	file_t *fp = NULL;
    597  1.1  rmind 	struct mqueue *mq;
    598  1.1  rmind 	struct mq_msg *msg, *pos_msg;
    599  1.1  rmind 	struct proc *notify = NULL;
    600  1.1  rmind 	ksiginfo_t ksi;
    601  1.1  rmind 	size_t size;
    602  1.1  rmind 	int error;
    603  1.1  rmind 
    604  1.1  rmind 	/* Check the priority range */
    605  1.1  rmind 	if (msg_prio >= mq_prio_max)
    606  1.1  rmind 		return EINVAL;
    607  1.1  rmind 
    608  1.1  rmind 	/* Allocate a new message */
    609  1.1  rmind 	size = sizeof(struct mq_msg) + msg_len;
    610  1.1  rmind 	if (size > mq_max_msgsize)
    611  1.1  rmind 		return EMSGSIZE;
    612  1.1  rmind 
    613  1.1  rmind 	if (size > MQ_DEF_MSGSIZE)
    614  1.1  rmind 		msg = kmem_alloc(size, KM_SLEEP);
    615  1.1  rmind 	else
    616  1.8  rmind 		msg = pool_cache_get(mqmsg_cache, PR_WAITOK);
    617  1.1  rmind 
    618  1.1  rmind 	/* Get the data from user-space */
    619  1.1  rmind 	error = copyin(msg_ptr, msg->msg_ptr, msg_len);
    620  1.1  rmind 	if (error) {
    621  1.1  rmind 		mqueue_freemsg(msg, size);
    622  1.1  rmind 		return error;
    623  1.1  rmind 	}
    624  1.1  rmind 	msg->msg_len = msg_len;
    625  1.1  rmind 	msg->msg_prio = msg_prio;
    626  1.1  rmind 
    627  1.1  rmind 	/* Get the mqueue */
    628  1.1  rmind 	error = mqueue_get(l, mqdes, VWRITE, &fp);
    629  1.1  rmind 	if (error) {
    630  1.1  rmind 		mqueue_freemsg(msg, size);
    631  1.1  rmind 		return error;
    632  1.1  rmind 	}
    633  1.1  rmind 	mq = fp->f_data;
    634  1.1  rmind 
    635  1.1  rmind 	/* Check the message size limit */
    636  1.1  rmind 	if (msg_len <= 0 || msg_len > mq->mq_attrib.mq_msgsize) {
    637  1.1  rmind 		error = EMSGSIZE;
    638  1.1  rmind 		goto error;
    639  1.1  rmind 	}
    640  1.1  rmind 
    641  1.1  rmind 	/* Check if queue is full */
    642  1.2     ad 	while (mq->mq_attrib.mq_curmsgs >= mq->mq_attrib.mq_maxmsg) {
    643  1.1  rmind 		if (mq->mq_attrib.mq_flags & O_NONBLOCK) {
    644  1.1  rmind 			error = EAGAIN;
    645  1.1  rmind 			goto error;
    646  1.1  rmind 		}
    647  1.1  rmind 		if (t < 0) {
    648  1.1  rmind 			error = EINVAL;
    649  1.1  rmind 			goto error;
    650  1.1  rmind 		}
    651  1.1  rmind 		/* Block until queue becomes available */
    652  1.1  rmind 		error = cv_timedwait_sig(&mq->mq_recv_cv, &mq->mq_mtx, t);
    653  1.1  rmind 		if (error || (mq->mq_attrib.mq_flags & MQ_UNLINK)) {
    654  1.1  rmind 			error = (error == EWOULDBLOCK) ? ETIMEDOUT : error;
    655  1.1  rmind 			goto error;
    656  1.1  rmind 		}
    657  1.1  rmind 	}
    658  1.1  rmind 	KASSERT(mq->mq_attrib.mq_curmsgs < mq->mq_attrib.mq_maxmsg);
    659  1.1  rmind 
    660  1.1  rmind 	/* Insert message into the queue, according to the priority */
    661  1.1  rmind 	TAILQ_FOREACH(pos_msg, &mq->mq_head, msg_queue)
    662  1.1  rmind 		if (msg->msg_prio > pos_msg->msg_prio)
    663  1.1  rmind 			break;
    664  1.1  rmind 	if (pos_msg == NULL)
    665  1.1  rmind 		TAILQ_INSERT_TAIL(&mq->mq_head, msg, msg_queue);
    666  1.1  rmind 	else
    667  1.1  rmind 		TAILQ_INSERT_BEFORE(pos_msg, msg, msg_queue);
    668  1.1  rmind 
    669  1.1  rmind 	/* Check for the notify */
    670  1.1  rmind 	if (mq->mq_attrib.mq_curmsgs == 0 && mq->mq_notify_proc &&
    671  1.1  rmind 	    (mq->mq_attrib.mq_flags & MQ_RECEIVE) == 0) {
    672  1.1  rmind 		/* Initialize the signal */
    673  1.1  rmind 		KSI_INIT(&ksi);
    674  1.1  rmind 		ksi.ksi_signo = mq->mq_sig_notify.sigev_signo;
    675  1.1  rmind 		ksi.ksi_code = SI_MESGQ;
    676  1.1  rmind 		ksi.ksi_value = mq->mq_sig_notify.sigev_value;
    677  1.1  rmind 		/* Unregister the process */
    678  1.1  rmind 		notify = mq->mq_notify_proc;
    679  1.1  rmind 		mq->mq_notify_proc = NULL;
    680  1.1  rmind 	}
    681  1.1  rmind 
    682  1.1  rmind 	/* Increment the counter and signal waiter, if any */
    683  1.1  rmind 	mq->mq_attrib.mq_curmsgs++;
    684  1.1  rmind 	cv_signal(&mq->mq_send_cv);
    685  1.8  rmind 
    686  1.8  rmind 	/* Ready for receiving now */
    687  1.8  rmind 	selnotify(&mq->mq_rsel, POLLIN | POLLRDNORM, 0);
    688  1.1  rmind error:
    689  1.1  rmind 	mutex_exit(&mq->mq_mtx);
    690  1.7     ad 	fd_putfile((int)mqdes);
    691  1.1  rmind 
    692  1.1  rmind 	if (error) {
    693  1.1  rmind 		mqueue_freemsg(msg, size);
    694  1.1  rmind 	} else if (notify) {
    695  1.1  rmind 		/* Send the notify, if needed */
    696  1.1  rmind 		mutex_enter(&proclist_mutex);
    697  1.1  rmind 		kpsignal(notify, &ksi, NULL);
    698  1.1  rmind 		mutex_exit(&proclist_mutex);
    699  1.1  rmind 	}
    700  1.1  rmind 
    701  1.1  rmind 	return error;
    702  1.1  rmind }
    703  1.1  rmind 
    704  1.1  rmind int
    705  1.8  rmind sys_mq_send(struct lwp *l, const struct sys_mq_send_args *uap,
    706  1.8  rmind     register_t *retval)
    707  1.1  rmind {
    708  1.6    dsl 	/* {
    709  1.1  rmind 		syscallarg(mqd_t) mqdes;
    710  1.1  rmind 		syscallarg(const char *) msg_ptr;
    711  1.1  rmind 		syscallarg(size_t) msg_len;
    712  1.1  rmind 		syscallarg(unsigned) msg_prio;
    713  1.6    dsl 	} */
    714  1.1  rmind 
    715  1.1  rmind 	return mq_send1(l, SCARG(uap, mqdes), SCARG(uap, msg_ptr),
    716  1.1  rmind 	    SCARG(uap, msg_len), SCARG(uap, msg_prio), 0);
    717  1.1  rmind }
    718  1.1  rmind 
    719  1.1  rmind int
    720  1.8  rmind sys_mq_timedsend(struct lwp *l, const struct sys_mq_timedsend_args *uap,
    721  1.8  rmind     register_t *retval)
    722  1.1  rmind {
    723  1.6    dsl 	/* {
    724  1.1  rmind 		syscallarg(mqd_t) mqdes;
    725  1.1  rmind 		syscallarg(const char *) msg_ptr;
    726  1.1  rmind 		syscallarg(size_t) msg_len;
    727  1.1  rmind 		syscallarg(unsigned) msg_prio;
    728  1.1  rmind 		syscallarg(const struct timespec *) abs_timeout;
    729  1.6    dsl 	} */
    730  1.1  rmind 	int t;
    731  1.1  rmind 
    732  1.1  rmind 	/* Get and convert time value */
    733  1.1  rmind 	if (SCARG(uap, abs_timeout)) {
    734  1.1  rmind 		int error = abstimeout2timo(SCARG(uap, abs_timeout), &t);
    735  1.1  rmind 		if (error)
    736  1.1  rmind 			return error;
    737  1.1  rmind 	} else
    738  1.1  rmind 		t = 0;
    739  1.1  rmind 
    740  1.1  rmind 	return mq_send1(l, SCARG(uap, mqdes), SCARG(uap, msg_ptr),
    741  1.1  rmind 	    SCARG(uap, msg_len), SCARG(uap, msg_prio), t);
    742  1.1  rmind }
    743  1.1  rmind 
    744  1.1  rmind int
    745  1.8  rmind sys_mq_notify(struct lwp *l, const struct sys_mq_notify_args *uap,
    746  1.8  rmind     register_t *retval)
    747  1.1  rmind {
    748  1.6    dsl 	/* {
    749  1.1  rmind 		syscallarg(mqd_t) mqdes;
    750  1.1  rmind 		syscallarg(const struct sigevent *) notification;
    751  1.6    dsl 	} */
    752  1.7     ad 	file_t *fp = NULL;
    753  1.1  rmind 	struct mqueue *mq;
    754  1.1  rmind 	struct sigevent sig;
    755  1.1  rmind 	int error;
    756  1.1  rmind 
    757  1.1  rmind 	if (SCARG(uap, notification)) {
    758  1.1  rmind 		/* Get the signal from user-space */
    759  1.1  rmind 		error = copyin(SCARG(uap, notification), &sig,
    760  1.1  rmind 		    sizeof(struct sigevent));
    761  1.1  rmind 		if (error)
    762  1.1  rmind 			return error;
    763  1.1  rmind 	}
    764  1.1  rmind 
    765  1.1  rmind 	error = mqueue_get(l, SCARG(uap, mqdes), VNOVAL, &fp);
    766  1.1  rmind 	if (error)
    767  1.1  rmind 		return error;
    768  1.1  rmind 	mq = fp->f_data;
    769  1.1  rmind 
    770  1.1  rmind 	if (SCARG(uap, notification)) {
    771  1.1  rmind 		/* Register notification: set the signal and target process */
    772  1.1  rmind 		if (mq->mq_notify_proc == NULL) {
    773  1.1  rmind 			memcpy(&mq->mq_sig_notify, &sig,
    774  1.1  rmind 			    sizeof(struct sigevent));
    775  1.1  rmind 			mq->mq_notify_proc = l->l_proc;
    776  1.1  rmind 		} else {
    777  1.1  rmind 			/* Fail if someone else already registered */
    778  1.1  rmind 			error = EBUSY;
    779  1.1  rmind 		}
    780  1.1  rmind 	} else {
    781  1.1  rmind 		/* Unregister the notification */
    782  1.1  rmind 		mq->mq_notify_proc = NULL;
    783  1.1  rmind 	}
    784  1.1  rmind 	mutex_exit(&mq->mq_mtx);
    785  1.7     ad 	fd_putfile((int)SCARG(uap, mqdes));
    786  1.1  rmind 
    787  1.1  rmind 	return error;
    788  1.1  rmind }
    789  1.1  rmind 
    790  1.1  rmind int
    791  1.8  rmind sys_mq_getattr(struct lwp *l, const struct sys_mq_getattr_args *uap,
    792  1.8  rmind     register_t *retval)
    793  1.1  rmind {
    794  1.6    dsl 	/* {
    795  1.1  rmind 		syscallarg(mqd_t) mqdes;
    796  1.1  rmind 		syscallarg(struct mq_attr *) mqstat;
    797  1.6    dsl 	} */
    798  1.7     ad 	file_t *fp = NULL;
    799  1.1  rmind 	struct mqueue *mq;
    800  1.1  rmind 	struct mq_attr attr;
    801  1.1  rmind 	int error;
    802  1.1  rmind 
    803  1.1  rmind 	/* Get the message queue */
    804  1.1  rmind 	error = mqueue_get(l, SCARG(uap, mqdes), VNOVAL, &fp);
    805  1.1  rmind 	if (error)
    806  1.1  rmind 		return error;
    807  1.1  rmind 	mq = fp->f_data;
    808  1.1  rmind 	memcpy(&attr, &mq->mq_attrib, sizeof(struct mq_attr));
    809  1.1  rmind 	mutex_exit(&mq->mq_mtx);
    810  1.7     ad 	fd_putfile((int)SCARG(uap, mqdes));
    811  1.1  rmind 
    812  1.1  rmind 	return copyout(&attr, SCARG(uap, mqstat), sizeof(struct mq_attr));
    813  1.1  rmind }
    814  1.1  rmind 
    815  1.1  rmind int
    816  1.8  rmind sys_mq_setattr(struct lwp *l, const struct sys_mq_setattr_args *uap,
    817  1.8  rmind     register_t *retval)
    818  1.1  rmind {
    819  1.6    dsl 	/* {
    820  1.1  rmind 		syscallarg(mqd_t) mqdes;
    821  1.1  rmind 		syscallarg(const struct mq_attr *) mqstat;
    822  1.1  rmind 		syscallarg(struct mq_attr *) omqstat;
    823  1.6    dsl 	} */
    824  1.7     ad 	file_t *fp = NULL;
    825  1.1  rmind 	struct mqueue *mq;
    826  1.1  rmind 	struct mq_attr attr;
    827  1.1  rmind 	int error, nonblock;
    828  1.1  rmind 
    829  1.1  rmind 	error = copyin(SCARG(uap, mqstat), &attr, sizeof(struct mq_attr));
    830  1.1  rmind 	if (error)
    831  1.1  rmind 		return error;
    832  1.1  rmind 	nonblock = (attr.mq_flags & O_NONBLOCK);
    833  1.1  rmind 
    834  1.1  rmind 	/* Get the message queue */
    835  1.1  rmind 	error = mqueue_get(l, SCARG(uap, mqdes), VNOVAL, &fp);
    836  1.1  rmind 	if (error)
    837  1.1  rmind 		return error;
    838  1.1  rmind 	mq = fp->f_data;
    839  1.1  rmind 
    840  1.1  rmind 	/* Copy the old attributes, if needed */
    841  1.1  rmind 	if (SCARG(uap, omqstat))
    842  1.1  rmind 		memcpy(&attr, &mq->mq_attrib, sizeof(struct mq_attr));
    843  1.1  rmind 
    844  1.1  rmind 	/* Ignore everything, except O_NONBLOCK */
    845  1.1  rmind 	if (nonblock)
    846  1.1  rmind 		mq->mq_attrib.mq_flags |= O_NONBLOCK;
    847  1.1  rmind 	else
    848  1.1  rmind 		mq->mq_attrib.mq_flags &= ~O_NONBLOCK;
    849  1.1  rmind 
    850  1.1  rmind 	mutex_exit(&mq->mq_mtx);
    851  1.7     ad 	fd_putfile((int)SCARG(uap, mqdes));
    852  1.1  rmind 
    853  1.1  rmind 	/*
    854  1.1  rmind 	 * Copy the data to the user-space.
    855  1.1  rmind 	 * Note: According to POSIX, the new attributes should not be set in
    856  1.1  rmind 	 * case of fail - this would be violated.
    857  1.1  rmind 	 */
    858  1.1  rmind 	if (SCARG(uap, omqstat))
    859  1.1  rmind 		error = copyout(&attr, SCARG(uap, omqstat),
    860  1.1  rmind 		    sizeof(struct mq_attr));
    861  1.1  rmind 
    862  1.1  rmind 	return error;
    863  1.1  rmind }
    864  1.1  rmind 
    865  1.1  rmind int
    866  1.8  rmind sys_mq_unlink(struct lwp *l, const struct sys_mq_unlink_args *uap,
    867  1.8  rmind     register_t *retval)
    868  1.1  rmind {
    869  1.6    dsl 	/* {
    870  1.1  rmind 		syscallarg(const char *) name;
    871  1.6    dsl 	} */
    872  1.1  rmind 	struct mqueue *mq;
    873  1.1  rmind 	char *name;
    874  1.1  rmind 	int error, refcnt = 0;
    875  1.1  rmind 
    876  1.1  rmind 	/* Get the name from the user-space */
    877  1.1  rmind 	name = kmem_zalloc(MQ_NAMELEN, KM_SLEEP);
    878  1.1  rmind 	error = copyinstr(SCARG(uap, name), name, MQ_NAMELEN - 1, NULL);
    879  1.1  rmind 	if (error) {
    880  1.1  rmind 		kmem_free(name, MQ_NAMELEN);
    881  1.1  rmind 		return error;
    882  1.1  rmind 	}
    883  1.1  rmind 
    884  1.1  rmind 	/* Lookup for this file */
    885  1.1  rmind 	mutex_enter(&mqlist_mtx);
    886  1.1  rmind 	mq = mqueue_lookup(name);
    887  1.1  rmind 	if (mq == NULL) {
    888  1.1  rmind 		error = ENOENT;
    889  1.1  rmind 		goto error;
    890  1.1  rmind 	}
    891  1.1  rmind 
    892  1.1  rmind 	/* Check the permissions */
    893  1.1  rmind 	if (mqueue_access(l, mq, VWRITE)) {
    894  1.1  rmind 		mutex_exit(&mq->mq_mtx);
    895  1.1  rmind 		error = EACCES;
    896  1.1  rmind 		goto error;
    897  1.1  rmind 	}
    898  1.1  rmind 
    899  1.1  rmind 	/* Mark message queue as unlinking, before leaving the window */
    900  1.1  rmind 	mq->mq_attrib.mq_flags |= MQ_UNLINK;
    901  1.1  rmind 
    902  1.1  rmind 	/* Wake up all waiters, if there are such */
    903  1.1  rmind 	cv_broadcast(&mq->mq_send_cv);
    904  1.1  rmind 	cv_broadcast(&mq->mq_recv_cv);
    905  1.1  rmind 
    906  1.8  rmind 	selnotify(&mq->mq_rsel, POLLHUP, 0);
    907  1.8  rmind 	selnotify(&mq->mq_wsel, POLLHUP, 0);
    908  1.8  rmind 
    909  1.1  rmind 	refcnt = mq->mq_refcnt;
    910  1.1  rmind 	if (refcnt == 0)
    911  1.1  rmind 		LIST_REMOVE(mq, mq_list);
    912  1.1  rmind 
    913  1.1  rmind 	mutex_exit(&mq->mq_mtx);
    914  1.1  rmind error:
    915  1.1  rmind 	mutex_exit(&mqlist_mtx);
    916  1.1  rmind 
    917  1.1  rmind 	/*
    918  1.1  rmind 	 * If there are no references - destroy the message
    919  1.1  rmind 	 * queue, otherwise, the last mq_close() will do that.
    920  1.1  rmind 	 */
    921  1.1  rmind 	if (error == 0 && refcnt == 0)
    922  1.1  rmind 		mqueue_destroy(mq);
    923  1.1  rmind 
    924  1.1  rmind 	kmem_free(name, MQ_NAMELEN);
    925  1.1  rmind 	return error;
    926  1.1  rmind }
    927  1.1  rmind 
    928  1.1  rmind /*
    929  1.1  rmind  * SysCtl.
    930  1.1  rmind  */
    931  1.1  rmind 
    932  1.1  rmind SYSCTL_SETUP(sysctl_mqueue_setup, "sysctl mqueue setup")
    933  1.1  rmind {
    934  1.1  rmind 	const struct sysctlnode *node = NULL;
    935  1.1  rmind 
    936  1.1  rmind 	sysctl_createv(clog, 0, NULL, NULL,
    937  1.1  rmind 		CTLFLAG_PERMANENT,
    938  1.1  rmind 		CTLTYPE_NODE, "kern", NULL,
    939  1.1  rmind 		NULL, 0, NULL, 0,
    940  1.1  rmind 		CTL_KERN, CTL_EOL);
    941  1.1  rmind 	sysctl_createv(clog, 0, NULL, NULL,
    942  1.1  rmind 		CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
    943  1.1  rmind 		CTLTYPE_INT, "posix_msg",
    944  1.1  rmind 		SYSCTL_DESCR("Version of IEEE Std 1003.1 and its "
    945  1.1  rmind 			     "Message Passing option to which the "
    946  1.1  rmind 			     "system attempts to conform"),
    947  1.1  rmind 		NULL, _POSIX_MESSAGE_PASSING, NULL, 0,
    948  1.1  rmind 		CTL_KERN, CTL_CREATE, CTL_EOL);
    949  1.1  rmind 	sysctl_createv(clog, 0, NULL, &node,
    950  1.1  rmind 		CTLFLAG_PERMANENT,
    951  1.1  rmind 		CTLTYPE_NODE, "mqueue",
    952  1.1  rmind 		SYSCTL_DESCR("Message queue options"),
    953  1.1  rmind 		NULL, 0, NULL, 0,
    954  1.1  rmind 		CTL_KERN, CTL_CREATE, CTL_EOL);
    955  1.1  rmind 
    956  1.1  rmind 	if (node == NULL)
    957  1.1  rmind 		return;
    958  1.1  rmind 
    959  1.1  rmind 	sysctl_createv(clog, 0, &node, NULL,
    960  1.1  rmind 		CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
    961  1.1  rmind 		CTLTYPE_INT, "mq_open_max",
    962  1.1  rmind 		SYSCTL_DESCR("Maximal number of message queue descriptors "
    963  1.1  rmind 			     "that process could open"),
    964  1.1  rmind 		NULL, 0, &mq_open_max, 0,
    965  1.1  rmind 		CTL_CREATE, CTL_EOL);
    966  1.1  rmind 	sysctl_createv(clog, 0, &node, NULL,
    967  1.1  rmind 		CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
    968  1.1  rmind 		CTLTYPE_INT, "mq_prio_max",
    969  1.1  rmind 		SYSCTL_DESCR("Maximal priority of the message"),
    970  1.1  rmind 		NULL, 0, &mq_prio_max, 0,
    971  1.1  rmind 		CTL_CREATE, CTL_EOL);
    972  1.1  rmind 	sysctl_createv(clog, 0, &node, NULL,
    973  1.1  rmind 		CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
    974  1.1  rmind 		CTLTYPE_INT, "mq_max_msgsize",
    975  1.1  rmind 		SYSCTL_DESCR("Maximal allowed size of the message"),
    976  1.1  rmind 		NULL, 0, &mq_max_msgsize, 0,
    977  1.1  rmind 		CTL_CREATE, CTL_EOL);
    978  1.1  rmind 	sysctl_createv(clog, 0, &node, NULL,
    979  1.1  rmind 		CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
    980  1.1  rmind 		CTLTYPE_INT, "mq_def_maxmsg",
    981  1.1  rmind 		SYSCTL_DESCR("Default maximal message count"),
    982  1.1  rmind 		NULL, 0, &mq_def_maxmsg, 0,
    983  1.1  rmind 		CTL_CREATE, CTL_EOL);
    984  1.1  rmind }
    985  1.1  rmind 
    986  1.1  rmind /*
    987  1.1  rmind  * Debugging.
    988  1.1  rmind  */
    989  1.1  rmind #if defined(DDB)
    990  1.1  rmind 
    991  1.1  rmind void
    992  1.1  rmind mqueue_print_list(void (*pr)(const char *, ...))
    993  1.1  rmind {
    994  1.1  rmind 	struct mqueue *mq;
    995  1.1  rmind 
    996  1.1  rmind 	(*pr)("Global list of the message queues:\n");
    997  1.1  rmind 	(*pr)("%20s %10s %8s %8s %3s %4s %4s %4s\n",
    998  1.1  rmind 	    "Name", "Ptr", "Mode", "Flags",  "Ref",
    999  1.1  rmind 	    "MaxMsg", "MsgSze", "CurMsg");
   1000  1.1  rmind 	LIST_FOREACH(mq, &mqueue_head, mq_list) {
   1001  1.1  rmind 		(*pr)("%20s %10p %8x %8x %3u %6lu %6lu %6lu\n",
   1002  1.1  rmind 		    mq->mq_name, mq, mq->mq_mode,
   1003  1.1  rmind 		    mq->mq_attrib.mq_flags, mq->mq_refcnt,
   1004  1.1  rmind 		    mq->mq_attrib.mq_maxmsg, mq->mq_attrib.mq_msgsize,
   1005  1.1  rmind 		    mq->mq_attrib.mq_curmsgs);
   1006  1.1  rmind 	}
   1007  1.1  rmind }
   1008  1.1  rmind 
   1009  1.1  rmind #endif /* defined(DDB) */
   1010