Home | History | Annotate | Line # | Download | only in kern
sys_mqueue.c revision 1.47
      1  1.47  christos /*	$NetBSD: sys_mqueue.c,v 1.47 2020/05/16 18:31:50 christos Exp $	*/
      2   1.1     rmind 
      3   1.1     rmind /*
      4  1.32     rmind  * Copyright (c) 2007-2011 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.12     rmind  *
     33  1.12     rmind  * Locking
     34  1.32     rmind  *
     35  1.32     rmind  * Global list of message queues (mqueue_head) is protected by mqlist_lock.
     36  1.32     rmind  * Each message queue and its members are protected by mqueue::mq_mtx.
     37  1.32     rmind  * Note that proc_t::p_mqueue_cnt is updated atomically.
     38  1.32     rmind  *
     39   1.1     rmind  * Lock order:
     40  1.32     rmind  *
     41  1.32     rmind  *	mqlist_lock ->
     42  1.32     rmind  *		mqueue::mq_mtx
     43   1.1     rmind  */
     44   1.1     rmind 
     45   1.1     rmind #include <sys/cdefs.h>
     46  1.47  christos __KERNEL_RCSID(0, "$NetBSD: sys_mqueue.c,v 1.47 2020/05/16 18:31:50 christos Exp $");
     47   1.1     rmind 
     48   1.1     rmind #include <sys/param.h>
     49   1.1     rmind #include <sys/types.h>
     50  1.33    martin #include <sys/atomic.h>
     51  1.32     rmind 
     52   1.1     rmind #include <sys/file.h>
     53   1.1     rmind #include <sys/filedesc.h>
     54   1.1     rmind #include <sys/kauth.h>
     55   1.1     rmind #include <sys/lwp.h>
     56   1.1     rmind #include <sys/mqueue.h>
     57  1.24     rmind #include <sys/module.h>
     58   1.8     rmind #include <sys/poll.h>
     59   1.8     rmind #include <sys/select.h>
     60   1.1     rmind #include <sys/signal.h>
     61   1.1     rmind #include <sys/signalvar.h>
     62  1.12     rmind #include <sys/stat.h>
     63   1.1     rmind #include <sys/sysctl.h>
     64  1.24     rmind #include <sys/syscall.h>
     65  1.24     rmind #include <sys/syscallvar.h>
     66   1.1     rmind #include <sys/syscallargs.h>
     67   1.1     rmind 
     68  1.19      elad #include <miscfs/genfs/genfs.h>
     69  1.19      elad 
     70  1.24     rmind MODULE(MODULE_CLASS_MISC, mqueue, NULL);
     71  1.24     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 static u_int			mq_max_msgsize = 16 * MQ_DEF_MSGSIZE;
     76   1.1     rmind static u_int			mq_def_maxmsg = 32;
     77  1.28  drochner static u_int			mq_max_maxmsg = 16 * 32;
     78   1.1     rmind 
     79  1.32     rmind static pool_cache_t		mqmsg_cache	__read_mostly;
     80  1.32     rmind static kmutex_t			mqlist_lock	__cacheline_aligned;
     81  1.32     rmind static LIST_HEAD(, mqueue)	mqueue_head	__cacheline_aligned;
     82   1.1     rmind 
     83  1.34      elad static kauth_listener_t		mq_listener;
     84  1.34      elad 
     85  1.24     rmind static int	mqueue_sysinit(void);
     86  1.24     rmind static int	mqueue_sysfini(bool);
     87   1.8     rmind static int	mq_poll_fop(file_t *, int);
     88  1.15  christos static int	mq_stat_fop(file_t *, struct stat *);
     89   1.7        ad static int	mq_close_fop(file_t *);
     90   1.1     rmind 
     91   1.1     rmind static const struct fileops mqops = {
     92  1.40  christos 	.fo_name = "mq",
     93  1.14        ad 	.fo_read = fbadop_read,
     94  1.14        ad 	.fo_write = fbadop_write,
     95  1.14        ad 	.fo_ioctl = fbadop_ioctl,
     96  1.14        ad 	.fo_fcntl = fnullop_fcntl,
     97  1.14        ad 	.fo_poll = mq_poll_fop,
     98  1.15  christos 	.fo_stat = mq_stat_fop,
     99  1.14        ad 	.fo_close = mq_close_fop,
    100  1.14        ad 	.fo_kqfilter = fnullop_kqfilter,
    101  1.29       dsl 	.fo_restart = fnullop_restart,
    102   1.1     rmind };
    103   1.1     rmind 
    104  1.24     rmind static const struct syscall_package mqueue_syscalls[] = {
    105  1.24     rmind 	{ SYS_mq_open, 0, (sy_call_t *)sys_mq_open },
    106  1.24     rmind 	{ SYS_mq_close, 0, (sy_call_t *)sys_mq_close },
    107  1.24     rmind 	{ SYS_mq_unlink, 0, (sy_call_t *)sys_mq_unlink },
    108  1.24     rmind 	{ SYS_mq_getattr, 0, (sy_call_t *)sys_mq_getattr },
    109  1.24     rmind 	{ SYS_mq_setattr, 0, (sy_call_t *)sys_mq_setattr },
    110  1.24     rmind 	{ SYS_mq_notify, 0, (sy_call_t *)sys_mq_notify },
    111  1.24     rmind 	{ SYS_mq_send, 0, (sy_call_t *)sys_mq_send },
    112  1.24     rmind 	{ SYS_mq_receive, 0, (sy_call_t *)sys_mq_receive },
    113  1.24     rmind 	{ SYS___mq_timedsend50, 0, (sy_call_t *)sys___mq_timedsend50 },
    114  1.24     rmind 	{ SYS___mq_timedreceive50, 0, (sy_call_t *)sys___mq_timedreceive50 },
    115  1.24     rmind 	{ 0, 0, NULL }
    116  1.24     rmind };
    117  1.24     rmind 
    118  1.34      elad static int
    119  1.34      elad mq_listener_cb(kauth_cred_t cred, kauth_action_t action, void *cookie,
    120  1.34      elad     void *arg0, void *arg1, void *arg2, void *arg3)
    121  1.34      elad {
    122  1.34      elad 	mqueue_t *mq;
    123  1.34      elad 	int result;
    124  1.34      elad 
    125  1.34      elad 	if (action != KAUTH_SYSTEM_MQUEUE)
    126  1.34      elad 		return KAUTH_RESULT_DEFER;
    127  1.34      elad 
    128  1.34      elad 	result = KAUTH_RESULT_DEFER;
    129  1.34      elad 
    130  1.34      elad 	mq = arg1;
    131  1.34      elad 
    132  1.34      elad 	if (kauth_cred_geteuid(cred) == mq->mq_euid)
    133  1.34      elad 		result = KAUTH_RESULT_ALLOW;
    134  1.34      elad 
    135  1.34      elad 	return result;
    136  1.34      elad }
    137  1.34      elad 
    138   1.1     rmind /*
    139  1.24     rmind  * Initialisation and unloading of POSIX message queue subsystem.
    140   1.1     rmind  */
    141  1.24     rmind 
    142  1.24     rmind static int
    143   1.1     rmind mqueue_sysinit(void)
    144   1.1     rmind {
    145  1.24     rmind 	int error;
    146   1.1     rmind 
    147   1.9        ad 	mqmsg_cache = pool_cache_init(MQ_DEF_MSGSIZE, coherency_unit,
    148  1.12     rmind 	    0, 0, "mqmsgpl", NULL, IPL_NONE, NULL, NULL, NULL);
    149  1.32     rmind 	mutex_init(&mqlist_lock, MUTEX_DEFAULT, IPL_NONE);
    150  1.22     rmind 	LIST_INIT(&mqueue_head);
    151  1.24     rmind 
    152  1.24     rmind 	error = syscall_establish(NULL, mqueue_syscalls);
    153  1.34      elad 	mq_listener = kauth_listen_scope(KAUTH_SCOPE_SYSTEM,
    154  1.34      elad 	    mq_listener_cb, NULL);
    155  1.24     rmind 	return error;
    156  1.24     rmind }
    157  1.24     rmind 
    158  1.24     rmind static int
    159  1.24     rmind mqueue_sysfini(bool interface)
    160  1.24     rmind {
    161  1.24     rmind 
    162  1.24     rmind 	if (interface) {
    163  1.24     rmind 		int error;
    164  1.24     rmind 		bool inuse;
    165  1.24     rmind 
    166  1.24     rmind 		/* Stop syscall activity. */
    167  1.24     rmind 		error = syscall_disestablish(NULL, mqueue_syscalls);
    168  1.24     rmind 		if (error)
    169  1.24     rmind 			return error;
    170  1.32     rmind 		/* Check if there are any message queues in use. */
    171  1.32     rmind 		mutex_enter(&mqlist_lock);
    172  1.24     rmind 		inuse = !LIST_EMPTY(&mqueue_head);
    173  1.32     rmind 		mutex_exit(&mqlist_lock);
    174  1.24     rmind 		if (inuse) {
    175  1.24     rmind 			error = syscall_establish(NULL, mqueue_syscalls);
    176  1.24     rmind 			KASSERT(error == 0);
    177  1.24     rmind 			return EBUSY;
    178  1.24     rmind 		}
    179  1.24     rmind 	}
    180  1.30    jruoho 
    181  1.34      elad 	kauth_unlisten_scope(mq_listener);
    182  1.34      elad 
    183  1.32     rmind 	mutex_destroy(&mqlist_lock);
    184  1.24     rmind 	pool_cache_destroy(mqmsg_cache);
    185  1.24     rmind 	return 0;
    186  1.24     rmind }
    187  1.24     rmind 
    188  1.24     rmind /*
    189  1.24     rmind  * Module interface.
    190  1.24     rmind  */
    191  1.24     rmind static int
    192  1.24     rmind mqueue_modcmd(modcmd_t cmd, void *arg)
    193  1.24     rmind {
    194  1.24     rmind 
    195  1.24     rmind 	switch (cmd) {
    196  1.24     rmind 	case MODULE_CMD_INIT:
    197  1.24     rmind 		return mqueue_sysinit();
    198  1.24     rmind 	case MODULE_CMD_FINI:
    199  1.24     rmind 		return mqueue_sysfini(true);
    200  1.24     rmind 	default:
    201  1.24     rmind 		return ENOTTY;
    202  1.24     rmind 	}
    203   1.1     rmind }
    204   1.1     rmind 
    205   1.1     rmind /*
    206   1.1     rmind  * Free the message.
    207   1.1     rmind  */
    208   1.1     rmind static void
    209   1.1     rmind mqueue_freemsg(struct mq_msg *msg, const size_t size)
    210   1.1     rmind {
    211   1.1     rmind 
    212  1.22     rmind 	if (size > MQ_DEF_MSGSIZE) {
    213   1.1     rmind 		kmem_free(msg, size);
    214  1.22     rmind 	} else {
    215   1.8     rmind 		pool_cache_put(mqmsg_cache, msg);
    216  1.22     rmind 	}
    217   1.1     rmind }
    218   1.1     rmind 
    219   1.1     rmind /*
    220   1.1     rmind  * Destroy the message queue.
    221   1.1     rmind  */
    222   1.1     rmind static void
    223   1.1     rmind mqueue_destroy(struct mqueue *mq)
    224   1.1     rmind {
    225   1.1     rmind 	struct mq_msg *msg;
    226  1.22     rmind 	size_t msz;
    227  1.22     rmind 	u_int i;
    228   1.1     rmind 
    229  1.23     rmind 	/* Note MQ_PQSIZE + 1. */
    230  1.23     rmind 	for (i = 0; i <= MQ_PQSIZE; i++) {
    231  1.22     rmind 		while ((msg = TAILQ_FIRST(&mq->mq_head[i])) != NULL) {
    232  1.22     rmind 			TAILQ_REMOVE(&mq->mq_head[i], msg, msg_queue);
    233  1.22     rmind 			msz = sizeof(struct mq_msg) + msg->msg_len;
    234  1.22     rmind 			mqueue_freemsg(msg, msz);
    235  1.22     rmind 		}
    236   1.1     rmind 	}
    237  1.32     rmind 	if (mq->mq_name) {
    238  1.32     rmind 		kmem_free(mq->mq_name, MQ_NAMELEN);
    239  1.32     rmind 	}
    240   1.8     rmind 	seldestroy(&mq->mq_rsel);
    241   1.8     rmind 	seldestroy(&mq->mq_wsel);
    242   1.1     rmind 	cv_destroy(&mq->mq_send_cv);
    243   1.1     rmind 	cv_destroy(&mq->mq_recv_cv);
    244   1.1     rmind 	mutex_destroy(&mq->mq_mtx);
    245   1.1     rmind 	kmem_free(mq, sizeof(struct mqueue));
    246   1.1     rmind }
    247   1.1     rmind 
    248   1.1     rmind /*
    249  1.32     rmind  * mqueue_lookup: lookup for file name in general list of message queues.
    250  1.32     rmind  *
    251  1.32     rmind  * => locks the message queue on success
    252   1.1     rmind  */
    253  1.32     rmind static mqueue_t *
    254  1.32     rmind mqueue_lookup(const char *name)
    255   1.1     rmind {
    256  1.32     rmind 	mqueue_t *mq;
    257  1.32     rmind 
    258  1.32     rmind 	KASSERT(mutex_owned(&mqlist_lock));
    259   1.1     rmind 
    260   1.1     rmind 	LIST_FOREACH(mq, &mqueue_head, mq_list) {
    261   1.1     rmind 		if (strncmp(mq->mq_name, name, MQ_NAMELEN) == 0) {
    262   1.1     rmind 			mutex_enter(&mq->mq_mtx);
    263   1.1     rmind 			return mq;
    264   1.1     rmind 		}
    265   1.1     rmind 	}
    266   1.1     rmind 	return NULL;
    267   1.1     rmind }
    268   1.1     rmind 
    269   1.1     rmind /*
    270  1.18     rmind  * mqueue_get: get the mqueue from the descriptor.
    271  1.32     rmind  *
    272  1.32     rmind  * => locks the message queue, if found.
    273  1.32     rmind  * => holds a reference on the file descriptor.
    274   1.1     rmind  */
    275  1.38    martin int
    276  1.32     rmind mqueue_get(mqd_t mqd, int fflag, mqueue_t **mqret)
    277   1.1     rmind {
    278  1.32     rmind 	const int fd = (int)mqd;
    279  1.32     rmind 	mqueue_t *mq;
    280   1.7        ad 	file_t *fp;
    281   1.1     rmind 
    282  1.32     rmind 	fp = fd_getfile(fd);
    283  1.18     rmind 	if (__predict_false(fp == NULL)) {
    284  1.18     rmind 		return EBADF;
    285  1.18     rmind 	}
    286  1.18     rmind 	if (__predict_false(fp->f_type != DTYPE_MQUEUE)) {
    287  1.32     rmind 		fd_putfile(fd);
    288  1.32     rmind 		return EBADF;
    289  1.32     rmind 	}
    290  1.32     rmind 	if (fflag && (fp->f_flag & fflag) == 0) {
    291  1.32     rmind 		fd_putfile(fd);
    292   1.1     rmind 		return EBADF;
    293  1.18     rmind 	}
    294  1.37      matt 	mq = fp->f_mqueue;
    295   1.1     rmind 	mutex_enter(&mq->mq_mtx);
    296   1.1     rmind 
    297  1.32     rmind 	*mqret = mq;
    298   1.1     rmind 	return 0;
    299   1.1     rmind }
    300   1.1     rmind 
    301   1.1     rmind /*
    302  1.22     rmind  * mqueue_linear_insert: perform linear insert according to the message
    303  1.23     rmind  * priority into the reserved queue (MQ_PQRESQ).  Reserved queue is a
    304  1.23     rmind  * sorted list used only when mq_prio_max is increased via sysctl.
    305  1.22     rmind  */
    306  1.22     rmind static inline void
    307  1.22     rmind mqueue_linear_insert(struct mqueue *mq, struct mq_msg *msg)
    308  1.22     rmind {
    309  1.22     rmind 	struct mq_msg *mit;
    310  1.22     rmind 
    311  1.23     rmind 	TAILQ_FOREACH(mit, &mq->mq_head[MQ_PQRESQ], msg_queue) {
    312  1.22     rmind 		if (msg->msg_prio > mit->msg_prio)
    313  1.22     rmind 			break;
    314  1.22     rmind 	}
    315  1.22     rmind 	if (mit == NULL) {
    316  1.23     rmind 		TAILQ_INSERT_TAIL(&mq->mq_head[MQ_PQRESQ], msg, msg_queue);
    317  1.22     rmind 	} else {
    318  1.22     rmind 		TAILQ_INSERT_BEFORE(mit, msg, msg_queue);
    319  1.22     rmind 	}
    320  1.22     rmind }
    321  1.22     rmind 
    322   1.1     rmind static int
    323  1.15  christos mq_stat_fop(file_t *fp, struct stat *st)
    324  1.15  christos {
    325  1.37      matt 	struct mqueue *mq = fp->f_mqueue;
    326  1.15  christos 
    327  1.22     rmind 	memset(st, 0, sizeof(*st));
    328  1.16  christos 
    329  1.16  christos 	mutex_enter(&mq->mq_mtx);
    330  1.15  christos 	st->st_mode = mq->mq_mode;
    331  1.15  christos 	st->st_uid = mq->mq_euid;
    332  1.15  christos 	st->st_gid = mq->mq_egid;
    333  1.15  christos 	st->st_atimespec = mq->mq_atime;
    334  1.15  christos 	st->st_mtimespec = mq->mq_mtime;
    335  1.15  christos 	st->st_ctimespec = st->st_birthtimespec = mq->mq_btime;
    336  1.16  christos 	st->st_uid = kauth_cred_geteuid(fp->f_cred);
    337  1.16  christos 	st->st_gid = kauth_cred_getegid(fp->f_cred);
    338  1.16  christos 	mutex_exit(&mq->mq_mtx);
    339  1.16  christos 
    340  1.15  christos 	return 0;
    341  1.15  christos }
    342  1.15  christos 
    343  1.15  christos static int
    344   1.8     rmind mq_poll_fop(file_t *fp, int events)
    345   1.8     rmind {
    346  1.37      matt 	struct mqueue *mq = fp->f_mqueue;
    347  1.22     rmind 	struct mq_attr *mqattr;
    348   1.8     rmind 	int revents = 0;
    349   1.8     rmind 
    350   1.8     rmind 	mutex_enter(&mq->mq_mtx);
    351  1.22     rmind 	mqattr = &mq->mq_attrib;
    352   1.8     rmind 	if (events & (POLLIN | POLLRDNORM)) {
    353  1.31     rmind 		/* Ready for receiving, if there are messages in the queue. */
    354  1.22     rmind 		if (mqattr->mq_curmsgs)
    355  1.31     rmind 			revents |= events & (POLLIN | POLLRDNORM);
    356   1.8     rmind 		else
    357   1.8     rmind 			selrecord(curlwp, &mq->mq_rsel);
    358   1.8     rmind 	}
    359   1.8     rmind 	if (events & (POLLOUT | POLLWRNORM)) {
    360  1.31     rmind 		/* Ready for sending, if the message queue is not full. */
    361  1.22     rmind 		if (mqattr->mq_curmsgs < mqattr->mq_maxmsg)
    362  1.31     rmind 			revents |= events & (POLLOUT | POLLWRNORM);
    363   1.8     rmind 		else
    364   1.8     rmind 			selrecord(curlwp, &mq->mq_wsel);
    365   1.8     rmind 	}
    366   1.8     rmind 	mutex_exit(&mq->mq_mtx);
    367   1.8     rmind 
    368   1.8     rmind 	return revents;
    369   1.8     rmind }
    370   1.8     rmind 
    371   1.8     rmind static int
    372   1.7        ad mq_close_fop(file_t *fp)
    373   1.1     rmind {
    374  1.32     rmind 	proc_t *p = curproc;
    375  1.37      matt 	mqueue_t *mq = fp->f_mqueue;
    376  1.32     rmind 	bool destroy = false;
    377   1.1     rmind 
    378   1.1     rmind 	mutex_enter(&mq->mq_mtx);
    379  1.32     rmind 	KASSERT(mq->mq_refcnt > 0);
    380  1.32     rmind 	if (--mq->mq_refcnt == 0) {
    381  1.32     rmind 		/* Destroy if the last reference and unlinked. */
    382  1.32     rmind 		destroy = (mq->mq_attrib.mq_flags & MQ_UNLINKED) != 0;
    383  1.32     rmind 	}
    384   1.1     rmind 	mutex_exit(&mq->mq_mtx);
    385   1.1     rmind 
    386  1.32     rmind 	if (destroy) {
    387   1.1     rmind 		mqueue_destroy(mq);
    388  1.32     rmind 	}
    389  1.32     rmind 	atomic_dec_uint(&p->p_mqueue_cnt);
    390   1.1     rmind 	return 0;
    391   1.1     rmind }
    392   1.1     rmind 
    393  1.20      elad static int
    394  1.32     rmind mqueue_access(mqueue_t *mq, int access, kauth_cred_t cred)
    395  1.20      elad {
    396  1.47  christos 	accmode_t accmode = 0;
    397  1.22     rmind 
    398  1.32     rmind 	/* Note the difference between VREAD/VWRITE and FREAD/FWRITE. */
    399  1.32     rmind 	if (access & FREAD) {
    400  1.47  christos 		accmode |= VREAD;
    401  1.32     rmind 	}
    402  1.32     rmind 	if (access & FWRITE) {
    403  1.47  christos 		accmode |= VWRITE;
    404  1.32     rmind 	}
    405  1.47  christos 	if (genfs_can_access(NULL, cred, mq->mq_euid, mq->mq_egid,
    406  1.47  christos 	    mq->mq_mode, NULL, accmode)) {
    407  1.20      elad 		return EACCES;
    408  1.20      elad 	}
    409  1.32     rmind 	return 0;
    410  1.32     rmind }
    411  1.20      elad 
    412  1.32     rmind static int
    413  1.38    martin mqueue_create(lwp_t *l, char *name, struct mq_attr *attr, mode_t mode,
    414  1.32     rmind     int oflag, mqueue_t **mqret)
    415  1.32     rmind {
    416  1.32     rmind 	proc_t *p = l->l_proc;
    417  1.32     rmind 	struct cwdinfo *cwdi = p->p_cwdi;
    418  1.32     rmind 	mqueue_t *mq;
    419  1.32     rmind 	u_int i;
    420  1.32     rmind 
    421  1.32     rmind 	/* Empty name is invalid. */
    422  1.32     rmind 	if (name[0] == '\0') {
    423  1.32     rmind 		return EINVAL;
    424  1.32     rmind 	}
    425  1.32     rmind 
    426  1.32     rmind 	/* Check for mqueue attributes. */
    427  1.38    martin 	if (attr) {
    428  1.38    martin 		if (attr->mq_maxmsg <= 0 || attr->mq_maxmsg > mq_max_maxmsg ||
    429  1.38    martin 		    attr->mq_msgsize <= 0 ||
    430  1.38    martin 		    attr->mq_msgsize > mq_max_msgsize) {
    431  1.32     rmind 			return EINVAL;
    432  1.32     rmind 		}
    433  1.38    martin 		attr->mq_curmsgs = 0;
    434  1.32     rmind 	}
    435  1.32     rmind 
    436  1.32     rmind 	/*
    437  1.32     rmind 	 * Allocate new message queue, initialize data structures, copy the
    438  1.32     rmind 	 * name attributes.  Note that the initial reference is set here.
    439  1.32     rmind 	 */
    440  1.32     rmind 	mq = kmem_zalloc(sizeof(mqueue_t), KM_SLEEP);
    441  1.32     rmind 
    442  1.32     rmind 	mutex_init(&mq->mq_mtx, MUTEX_DEFAULT, IPL_NONE);
    443  1.32     rmind 	cv_init(&mq->mq_send_cv, "mqsendcv");
    444  1.32     rmind 	cv_init(&mq->mq_recv_cv, "mqrecvcv");
    445  1.32     rmind 	for (i = 0; i < (MQ_PQSIZE + 1); i++) {
    446  1.32     rmind 		TAILQ_INIT(&mq->mq_head[i]);
    447  1.32     rmind 	}
    448  1.32     rmind 	selinit(&mq->mq_rsel);
    449  1.32     rmind 	selinit(&mq->mq_wsel);
    450  1.32     rmind 	mq->mq_name = name;
    451  1.32     rmind 	mq->mq_refcnt = 1;
    452  1.32     rmind 
    453  1.38    martin 	if (attr != NULL) {
    454  1.38    martin 		memcpy(&mq->mq_attrib, attr, sizeof(struct mq_attr));
    455  1.38    martin 	} else {
    456  1.38    martin 		memset(&mq->mq_attrib, 0, sizeof(struct mq_attr));
    457  1.38    martin 		mq->mq_attrib.mq_maxmsg = mq_def_maxmsg;
    458  1.38    martin 		mq->mq_attrib.mq_msgsize = MQ_DEF_MSGSIZE - sizeof(struct mq_msg);
    459  1.38    martin 	}
    460  1.32     rmind 
    461  1.32     rmind 	CTASSERT((O_MASK & (MQ_UNLINKED | MQ_RECEIVE)) == 0);
    462  1.32     rmind 	mq->mq_attrib.mq_flags = (O_MASK & oflag);
    463  1.32     rmind 
    464  1.32     rmind 	/* Store mode and effective UID with GID. */
    465  1.32     rmind 	mq->mq_mode = ((mode & ~cwdi->cwdi_cmask) & ALLPERMS) & ~S_ISTXT;
    466  1.32     rmind 	mq->mq_euid = kauth_cred_geteuid(l->l_cred);
    467  1.32     rmind 	mq->mq_egid = kauth_cred_getegid(l->l_cred);
    468  1.32     rmind 
    469  1.32     rmind 	*mqret = mq;
    470  1.20      elad 	return 0;
    471  1.20      elad }
    472  1.20      elad 
    473   1.1     rmind /*
    474  1.38    martin  * Helper function for mq_open() - note that "u_name" is a userland pointer,
    475  1.38    martin  * while "attr" is a kernel pointer!
    476   1.1     rmind  */
    477   1.1     rmind int
    478  1.38    martin mq_handle_open(struct lwp *l, const char *u_name, int oflag, mode_t mode,
    479  1.38    martin     struct mq_attr *attr, register_t *retval)
    480   1.1     rmind {
    481   1.1     rmind 	struct proc *p = l->l_proc;
    482   1.1     rmind 	struct mqueue *mq, *mq_new = NULL;
    483  1.38    martin 	int mqd, error;
    484   1.7        ad 	file_t *fp;
    485   1.1     rmind 	char *name;
    486   1.1     rmind 
    487  1.32     rmind 	/* Get the name from the user-space. */
    488  1.32     rmind 	name = kmem_alloc(MQ_NAMELEN, KM_SLEEP);
    489  1.38    martin 	error = copyinstr(u_name, name, MQ_NAMELEN - 1, NULL);
    490   1.1     rmind 	if (error) {
    491   1.1     rmind 		kmem_free(name, MQ_NAMELEN);
    492   1.1     rmind 		return error;
    493   1.1     rmind 	}
    494   1.1     rmind 
    495  1.32     rmind 	/* Allocate file structure and descriptor. */
    496   1.7        ad 	error = fd_allocfile(&fp, &mqd);
    497   1.1     rmind 	if (error) {
    498   1.1     rmind 		kmem_free(name, MQ_NAMELEN);
    499   1.1     rmind 		return error;
    500   1.1     rmind 	}
    501  1.43  jakllsch 
    502  1.43  jakllsch 	/* Account and check for the limit. */
    503  1.43  jakllsch 	if (atomic_inc_uint_nv(&p->p_mqueue_cnt) > mq_open_max) {
    504  1.43  jakllsch 		atomic_dec_uint(&p->p_mqueue_cnt);
    505  1.43  jakllsch 		error = EMFILE;
    506  1.43  jakllsch 		goto err;
    507  1.43  jakllsch 	}
    508  1.43  jakllsch 
    509   1.1     rmind 	fp->f_type = DTYPE_MQUEUE;
    510  1.11     rmind 	fp->f_flag = FFLAGS(oflag) & (FREAD | FWRITE);
    511   1.1     rmind 	fp->f_ops = &mqops;
    512   1.1     rmind 
    513  1.32     rmind 	if (oflag & O_CREAT) {
    514  1.32     rmind 		/* Create a new message queue. */
    515  1.38    martin 		error = mqueue_create(l, name, attr, mode, oflag, &mq_new);
    516  1.32     rmind 		if (error) {
    517  1.32     rmind 			goto err;
    518  1.32     rmind 		}
    519  1.32     rmind 		KASSERT(mq_new != NULL);
    520  1.32     rmind 	}
    521  1.32     rmind 
    522  1.32     rmind 	/* Lookup for a message queue with such name. */
    523  1.32     rmind 	mutex_enter(&mqlist_lock);
    524   1.1     rmind 	mq = mqueue_lookup(name);
    525   1.1     rmind 	if (mq) {
    526  1.12     rmind 		KASSERT(mutex_owned(&mq->mq_mtx));
    527  1.32     rmind 		mutex_exit(&mqlist_lock);
    528  1.11     rmind 
    529  1.32     rmind 		/* Check for exclusive create. */
    530  1.32     rmind 		if (oflag & O_EXCL) {
    531  1.32     rmind 			mutex_exit(&mq->mq_mtx);
    532   1.1     rmind 			error = EEXIST;
    533  1.32     rmind 			goto err;
    534   1.1     rmind 		}
    535  1.18     rmind 
    536  1.32     rmind 		/* Verify permissions. */
    537  1.32     rmind 		if (mqueue_access(mq, fp->f_flag, l->l_cred) != 0) {
    538  1.32     rmind 			mutex_exit(&mq->mq_mtx);
    539   1.1     rmind 			error = EACCES;
    540  1.32     rmind 			goto err;
    541   1.1     rmind 		}
    542  1.32     rmind 
    543  1.32     rmind 		/* If we have the access, add a new reference. */
    544  1.32     rmind 		mq->mq_refcnt++;
    545  1.32     rmind 		mutex_exit(&mq->mq_mtx);
    546   1.1     rmind 	} else {
    547  1.32     rmind 		/* Fail if not found and not creating. */
    548   1.1     rmind 		if ((oflag & O_CREAT) == 0) {
    549  1.32     rmind 			mutex_exit(&mqlist_lock);
    550   1.1     rmind 			KASSERT(mq_new == NULL);
    551  1.32     rmind 			error = ENOENT;
    552  1.32     rmind 			goto err;
    553   1.1     rmind 		}
    554   1.1     rmind 
    555  1.32     rmind 		/* Initial timestamps. */
    556   1.1     rmind 		mq = mq_new;
    557  1.32     rmind 		getnanotime(&mq->mq_btime);
    558  1.32     rmind 		mq->mq_atime = mq->mq_mtime = mq->mq_btime;
    559  1.32     rmind 
    560  1.32     rmind 		/*
    561  1.32     rmind 		 * Finally, insert message queue into the list.
    562  1.32     rmind 		 * Note: it already has the initial reference.
    563  1.32     rmind 		 */
    564   1.1     rmind 		LIST_INSERT_HEAD(&mqueue_head, mq, mq_list);
    565  1.32     rmind 		mutex_exit(&mqlist_lock);
    566  1.32     rmind 
    567   1.1     rmind 		mq_new = NULL;
    568  1.32     rmind 		name = NULL;
    569   1.1     rmind 	}
    570  1.32     rmind 	KASSERT(mq != NULL);
    571  1.37      matt 	fp->f_mqueue = mq;
    572  1.32     rmind 	fd_affix(p, fp, mqd);
    573  1.32     rmind 	*retval = mqd;
    574  1.32     rmind err:
    575   1.1     rmind 	if (error) {
    576   1.7        ad 		fd_abort(p, fp, mqd);
    577   1.7        ad 	}
    578  1.32     rmind 	if (mq_new) {
    579  1.32     rmind 		/* Note: will free the 'name'. */
    580  1.32     rmind 		mqueue_destroy(mq_new);
    581  1.32     rmind 	} else if (name) {
    582  1.32     rmind 		kmem_free(name, MQ_NAMELEN);
    583  1.32     rmind 	}
    584   1.1     rmind 	return error;
    585   1.1     rmind }
    586   1.1     rmind 
    587  1.38    martin /*
    588  1.38    martin  * General mqueue system calls.
    589  1.38    martin  */
    590  1.38    martin 
    591  1.38    martin int
    592  1.38    martin sys_mq_open(struct lwp *l, const struct sys_mq_open_args *uap,
    593  1.38    martin     register_t *retval)
    594  1.38    martin {
    595  1.38    martin 	/* {
    596  1.38    martin 		syscallarg(const char *) name;
    597  1.38    martin 		syscallarg(int) oflag;
    598  1.38    martin 		syscallarg(mode_t) mode;
    599  1.38    martin 		syscallarg(struct mq_attr) attr;
    600  1.38    martin 	} */
    601  1.38    martin 	struct mq_attr *attr = NULL, a;
    602  1.38    martin 	int error;
    603  1.38    martin 
    604  1.45  christos 	if ((SCARG(uap, oflag) & O_EXEC) != 0)
    605  1.45  christos 		return EINVAL;
    606  1.45  christos 
    607  1.39  christos 	if ((SCARG(uap, oflag) & O_CREAT) != 0 && SCARG(uap, attr) != NULL) {
    608  1.39  christos 		error = copyin(SCARG(uap, attr), &a, sizeof(a));
    609  1.38    martin 		if (error)
    610  1.38    martin 			return error;
    611  1.38    martin 		attr = &a;
    612  1.38    martin 	}
    613  1.38    martin 
    614  1.38    martin 	return mq_handle_open(l, SCARG(uap, name), SCARG(uap, oflag),
    615  1.38    martin 	    SCARG(uap, mode), attr, retval);
    616  1.38    martin }
    617  1.38    martin 
    618   1.1     rmind int
    619   1.8     rmind sys_mq_close(struct lwp *l, const struct sys_mq_close_args *uap,
    620   1.8     rmind     register_t *retval)
    621   1.1     rmind {
    622   1.1     rmind 
    623   1.6       dsl 	return sys_close(l, (const void *)uap, retval);
    624   1.1     rmind }
    625   1.1     rmind 
    626   1.1     rmind /*
    627  1.25     rmind  * Primary mq_recv1() function.
    628   1.1     rmind  */
    629  1.13  christos int
    630  1.25     rmind mq_recv1(mqd_t mqdes, void *msg_ptr, size_t msg_len, u_int *msg_prio,
    631  1.25     rmind     struct timespec *ts, ssize_t *mlen)
    632   1.1     rmind {
    633   1.1     rmind 	struct mqueue *mq;
    634   1.1     rmind 	struct mq_msg *msg = NULL;
    635  1.22     rmind 	struct mq_attr *mqattr;
    636  1.23     rmind 	u_int idx;
    637   1.1     rmind 	int error;
    638   1.1     rmind 
    639  1.32     rmind 	error = mqueue_get(mqdes, FREAD, &mq);
    640  1.21     rmind 	if (error) {
    641   1.1     rmind 		return error;
    642  1.21     rmind 	}
    643  1.21     rmind 	getnanotime(&mq->mq_atime);
    644  1.22     rmind 	mqattr = &mq->mq_attrib;
    645   1.1     rmind 
    646   1.1     rmind 	/* Check the message size limits */
    647  1.22     rmind 	if (msg_len < mqattr->mq_msgsize) {
    648   1.1     rmind 		error = EMSGSIZE;
    649   1.1     rmind 		goto error;
    650   1.1     rmind 	}
    651   1.1     rmind 
    652   1.1     rmind 	/* Check if queue is empty */
    653  1.22     rmind 	while (mqattr->mq_curmsgs == 0) {
    654  1.25     rmind 		int t;
    655  1.25     rmind 
    656  1.22     rmind 		if (mqattr->mq_flags & O_NONBLOCK) {
    657   1.1     rmind 			error = EAGAIN;
    658   1.1     rmind 			goto error;
    659   1.1     rmind 		}
    660  1.28  drochner 		if (ts) {
    661  1.35  christos 			error = ts2timo(CLOCK_REALTIME, TIMER_ABSTIME, ts, &t,
    662  1.35  christos 			    NULL);
    663  1.28  drochner 			if (error)
    664  1.28  drochner 				goto error;
    665  1.28  drochner 		} else
    666  1.28  drochner 			t = 0;
    667   1.1     rmind 		/*
    668   1.1     rmind 		 * Block until someone sends the message.
    669   1.1     rmind 		 * While doing this, notification should not be sent.
    670   1.1     rmind 		 */
    671  1.22     rmind 		mqattr->mq_flags |= MQ_RECEIVE;
    672   1.1     rmind 		error = cv_timedwait_sig(&mq->mq_send_cv, &mq->mq_mtx, t);
    673  1.22     rmind 		mqattr->mq_flags &= ~MQ_RECEIVE;
    674  1.32     rmind 		if (error || (mqattr->mq_flags & MQ_UNLINKED)) {
    675   1.3     rmind 			error = (error == EWOULDBLOCK) ? ETIMEDOUT : EINTR;
    676   1.1     rmind 			goto error;
    677   1.1     rmind 		}
    678   1.1     rmind 	}
    679   1.1     rmind 
    680  1.23     rmind 	/*
    681  1.23     rmind 	 * Find the highest priority message, and remove it from the queue.
    682  1.23     rmind 	 * At first, reserved queue is checked, bitmap is next.
    683  1.23     rmind 	 */
    684  1.23     rmind 	msg = TAILQ_FIRST(&mq->mq_head[MQ_PQRESQ]);
    685  1.23     rmind 	if (__predict_true(msg == NULL)) {
    686  1.23     rmind 		idx = ffs(mq->mq_bitmap);
    687  1.23     rmind 		msg = TAILQ_FIRST(&mq->mq_head[idx]);
    688  1.23     rmind 		KASSERT(msg != NULL);
    689  1.23     rmind 	} else {
    690  1.23     rmind 		idx = MQ_PQRESQ;
    691  1.23     rmind 	}
    692  1.23     rmind 	TAILQ_REMOVE(&mq->mq_head[idx], msg, msg_queue);
    693  1.23     rmind 
    694  1.23     rmind 	/* Unmark the bit, if last message. */
    695  1.23     rmind 	if (__predict_true(idx) && TAILQ_EMPTY(&mq->mq_head[idx])) {
    696  1.23     rmind 		KASSERT((MQ_PQSIZE - idx) == msg->msg_prio);
    697  1.41     kamil 		mq->mq_bitmap &= ~(1U << --idx);
    698  1.22     rmind 	}
    699   1.1     rmind 
    700   1.1     rmind 	/* Decrement the counter and signal waiter, if any */
    701  1.22     rmind 	mqattr->mq_curmsgs--;
    702   1.1     rmind 	cv_signal(&mq->mq_recv_cv);
    703   1.8     rmind 
    704   1.8     rmind 	/* Ready for sending now */
    705   1.8     rmind 	selnotify(&mq->mq_wsel, POLLOUT | POLLWRNORM, 0);
    706   1.1     rmind error:
    707   1.1     rmind 	mutex_exit(&mq->mq_mtx);
    708   1.7        ad 	fd_putfile((int)mqdes);
    709   1.1     rmind 	if (error)
    710   1.1     rmind 		return error;
    711   1.1     rmind 
    712   1.1     rmind 	/*
    713   1.1     rmind 	 * Copy the data to the user-space.
    714   1.1     rmind 	 * Note: According to POSIX, no message should be removed from the
    715   1.1     rmind 	 * queue in case of fail - this would be violated.
    716   1.1     rmind 	 */
    717   1.1     rmind 	*mlen = msg->msg_len;
    718   1.1     rmind 	error = copyout(msg->msg_ptr, msg_ptr, msg->msg_len);
    719   1.1     rmind 	if (error == 0 && msg_prio)
    720   1.1     rmind 		error = copyout(&msg->msg_prio, msg_prio, sizeof(unsigned));
    721   1.1     rmind 	mqueue_freemsg(msg, sizeof(struct mq_msg) + msg->msg_len);
    722   1.1     rmind 
    723   1.1     rmind 	return error;
    724   1.1     rmind }
    725   1.1     rmind 
    726   1.1     rmind int
    727   1.8     rmind sys_mq_receive(struct lwp *l, const struct sys_mq_receive_args *uap,
    728   1.8     rmind     register_t *retval)
    729   1.1     rmind {
    730   1.6       dsl 	/* {
    731   1.1     rmind 		syscallarg(mqd_t) mqdes;
    732   1.1     rmind 		syscallarg(char *) msg_ptr;
    733   1.1     rmind 		syscallarg(size_t) msg_len;
    734   1.1     rmind 		syscallarg(unsigned *) msg_prio;
    735   1.6       dsl 	} */
    736  1.25     rmind 	ssize_t mlen;
    737   1.1     rmind 	int error;
    738   1.1     rmind 
    739  1.25     rmind 	error = mq_recv1(SCARG(uap, mqdes), SCARG(uap, msg_ptr),
    740  1.25     rmind 	    SCARG(uap, msg_len), SCARG(uap, msg_prio), NULL, &mlen);
    741   1.1     rmind 	if (error == 0)
    742   1.1     rmind 		*retval = mlen;
    743   1.1     rmind 
    744   1.1     rmind 	return error;
    745   1.1     rmind }
    746   1.1     rmind 
    747   1.1     rmind int
    748  1.13  christos sys___mq_timedreceive50(struct lwp *l,
    749  1.13  christos     const struct sys___mq_timedreceive50_args *uap, register_t *retval)
    750   1.1     rmind {
    751   1.6       dsl 	/* {
    752   1.1     rmind 		syscallarg(mqd_t) mqdes;
    753   1.1     rmind 		syscallarg(char *) msg_ptr;
    754   1.1     rmind 		syscallarg(size_t) msg_len;
    755   1.1     rmind 		syscallarg(unsigned *) msg_prio;
    756   1.1     rmind 		syscallarg(const struct timespec *) abs_timeout;
    757   1.6       dsl 	} */
    758  1.25     rmind 	struct timespec ts, *tsp;
    759   1.1     rmind 	ssize_t mlen;
    760  1.25     rmind 	int error;
    761   1.1     rmind 
    762   1.1     rmind 	/* Get and convert time value */
    763   1.1     rmind 	if (SCARG(uap, abs_timeout)) {
    764  1.13  christos 		error = copyin(SCARG(uap, abs_timeout), &ts, sizeof(ts));
    765  1.13  christos 		if (error)
    766  1.13  christos 			return error;
    767  1.25     rmind 		tsp = &ts;
    768  1.25     rmind 	} else {
    769  1.25     rmind 		tsp = NULL;
    770  1.25     rmind 	}
    771  1.13  christos 
    772  1.25     rmind 	error = mq_recv1(SCARG(uap, mqdes), SCARG(uap, msg_ptr),
    773  1.25     rmind 	    SCARG(uap, msg_len), SCARG(uap, msg_prio), tsp, &mlen);
    774   1.1     rmind 	if (error == 0)
    775   1.1     rmind 		*retval = mlen;
    776   1.1     rmind 
    777   1.1     rmind 	return error;
    778   1.1     rmind }
    779   1.1     rmind 
    780   1.1     rmind /*
    781   1.1     rmind  * Primary mq_send1() function.
    782   1.1     rmind  */
    783  1.13  christos int
    784  1.25     rmind mq_send1(mqd_t mqdes, const char *msg_ptr, size_t msg_len, u_int msg_prio,
    785  1.25     rmind     struct timespec *ts)
    786   1.1     rmind {
    787   1.1     rmind 	struct mqueue *mq;
    788  1.22     rmind 	struct mq_msg *msg;
    789  1.22     rmind 	struct mq_attr *mqattr;
    790   1.1     rmind 	struct proc *notify = NULL;
    791   1.1     rmind 	ksiginfo_t ksi;
    792   1.1     rmind 	size_t size;
    793   1.1     rmind 	int error;
    794   1.1     rmind 
    795   1.1     rmind 	/* Check the priority range */
    796   1.1     rmind 	if (msg_prio >= mq_prio_max)
    797   1.1     rmind 		return EINVAL;
    798   1.1     rmind 
    799   1.1     rmind 	/* Allocate a new message */
    800  1.44    martin 	if (msg_len > mq_max_msgsize)
    801  1.44    martin 		return EMSGSIZE;
    802   1.1     rmind 	size = sizeof(struct mq_msg) + msg_len;
    803   1.1     rmind 	if (size > mq_max_msgsize)
    804   1.1     rmind 		return EMSGSIZE;
    805   1.1     rmind 
    806  1.22     rmind 	if (size > MQ_DEF_MSGSIZE) {
    807   1.1     rmind 		msg = kmem_alloc(size, KM_SLEEP);
    808  1.22     rmind 	} else {
    809   1.8     rmind 		msg = pool_cache_get(mqmsg_cache, PR_WAITOK);
    810  1.22     rmind 	}
    811   1.1     rmind 
    812   1.1     rmind 	/* Get the data from user-space */
    813   1.1     rmind 	error = copyin(msg_ptr, msg->msg_ptr, msg_len);
    814   1.1     rmind 	if (error) {
    815   1.1     rmind 		mqueue_freemsg(msg, size);
    816   1.1     rmind 		return error;
    817   1.1     rmind 	}
    818   1.1     rmind 	msg->msg_len = msg_len;
    819   1.1     rmind 	msg->msg_prio = msg_prio;
    820   1.1     rmind 
    821  1.32     rmind 	error = mqueue_get(mqdes, FWRITE, &mq);
    822   1.1     rmind 	if (error) {
    823   1.1     rmind 		mqueue_freemsg(msg, size);
    824   1.1     rmind 		return error;
    825   1.1     rmind 	}
    826  1.15  christos 	getnanotime(&mq->mq_mtime);
    827  1.22     rmind 	mqattr = &mq->mq_attrib;
    828  1.15  christos 
    829   1.1     rmind 	/* Check the message size limit */
    830  1.22     rmind 	if (msg_len <= 0 || msg_len > mqattr->mq_msgsize) {
    831   1.1     rmind 		error = EMSGSIZE;
    832   1.1     rmind 		goto error;
    833   1.1     rmind 	}
    834   1.1     rmind 
    835   1.1     rmind 	/* Check if queue is full */
    836  1.22     rmind 	while (mqattr->mq_curmsgs >= mqattr->mq_maxmsg) {
    837  1.25     rmind 		int t;
    838  1.25     rmind 
    839  1.22     rmind 		if (mqattr->mq_flags & O_NONBLOCK) {
    840   1.1     rmind 			error = EAGAIN;
    841   1.1     rmind 			goto error;
    842   1.1     rmind 		}
    843  1.28  drochner 		if (ts) {
    844  1.35  christos 			error = ts2timo(CLOCK_REALTIME, TIMER_ABSTIME, ts, &t,
    845  1.35  christos 			    NULL);
    846  1.28  drochner 			if (error)
    847  1.28  drochner 				goto error;
    848  1.28  drochner 		} else
    849  1.28  drochner 			t = 0;
    850   1.1     rmind 		/* Block until queue becomes available */
    851   1.1     rmind 		error = cv_timedwait_sig(&mq->mq_recv_cv, &mq->mq_mtx, t);
    852  1.32     rmind 		if (error || (mqattr->mq_flags & MQ_UNLINKED)) {
    853   1.1     rmind 			error = (error == EWOULDBLOCK) ? ETIMEDOUT : error;
    854   1.1     rmind 			goto error;
    855   1.1     rmind 		}
    856   1.1     rmind 	}
    857  1.22     rmind 	KASSERT(mqattr->mq_curmsgs < mqattr->mq_maxmsg);
    858   1.1     rmind 
    859  1.23     rmind 	/*
    860  1.23     rmind 	 * Insert message into the queue, according to the priority.
    861  1.23     rmind 	 * Note the difference between index and priority.
    862  1.23     rmind 	 */
    863  1.22     rmind 	if (__predict_true(msg_prio < MQ_PQSIZE)) {
    864  1.23     rmind 		u_int idx = MQ_PQSIZE - msg_prio;
    865  1.23     rmind 
    866  1.23     rmind 		KASSERT(idx != MQ_PQRESQ);
    867  1.23     rmind 		TAILQ_INSERT_TAIL(&mq->mq_head[idx], msg, msg_queue);
    868  1.42     kamil 		mq->mq_bitmap |= (1U << --idx);
    869  1.22     rmind 	} else {
    870  1.22     rmind 		mqueue_linear_insert(mq, msg);
    871  1.22     rmind 	}
    872   1.1     rmind 
    873   1.1     rmind 	/* Check for the notify */
    874  1.22     rmind 	if (mqattr->mq_curmsgs == 0 && mq->mq_notify_proc &&
    875  1.28  drochner 	    (mqattr->mq_flags & MQ_RECEIVE) == 0 &&
    876  1.28  drochner 	    mq->mq_sig_notify.sigev_notify == SIGEV_SIGNAL) {
    877   1.1     rmind 		/* Initialize the signal */
    878   1.1     rmind 		KSI_INIT(&ksi);
    879   1.1     rmind 		ksi.ksi_signo = mq->mq_sig_notify.sigev_signo;
    880   1.1     rmind 		ksi.ksi_code = SI_MESGQ;
    881   1.1     rmind 		ksi.ksi_value = mq->mq_sig_notify.sigev_value;
    882   1.1     rmind 		/* Unregister the process */
    883   1.1     rmind 		notify = mq->mq_notify_proc;
    884   1.1     rmind 		mq->mq_notify_proc = NULL;
    885   1.1     rmind 	}
    886   1.1     rmind 
    887   1.1     rmind 	/* Increment the counter and signal waiter, if any */
    888  1.22     rmind 	mqattr->mq_curmsgs++;
    889   1.1     rmind 	cv_signal(&mq->mq_send_cv);
    890   1.8     rmind 
    891   1.8     rmind 	/* Ready for receiving now */
    892   1.8     rmind 	selnotify(&mq->mq_rsel, POLLIN | POLLRDNORM, 0);
    893   1.1     rmind error:
    894   1.1     rmind 	mutex_exit(&mq->mq_mtx);
    895   1.7        ad 	fd_putfile((int)mqdes);
    896   1.1     rmind 
    897   1.1     rmind 	if (error) {
    898   1.1     rmind 		mqueue_freemsg(msg, size);
    899   1.1     rmind 	} else if (notify) {
    900   1.1     rmind 		/* Send the notify, if needed */
    901  1.10        ad 		mutex_enter(proc_lock);
    902   1.1     rmind 		kpsignal(notify, &ksi, NULL);
    903  1.10        ad 		mutex_exit(proc_lock);
    904   1.1     rmind 	}
    905   1.1     rmind 	return error;
    906   1.1     rmind }
    907   1.1     rmind 
    908   1.1     rmind int
    909   1.8     rmind sys_mq_send(struct lwp *l, const struct sys_mq_send_args *uap,
    910   1.8     rmind     register_t *retval)
    911   1.1     rmind {
    912   1.6       dsl 	/* {
    913   1.1     rmind 		syscallarg(mqd_t) mqdes;
    914   1.1     rmind 		syscallarg(const char *) msg_ptr;
    915   1.1     rmind 		syscallarg(size_t) msg_len;
    916   1.1     rmind 		syscallarg(unsigned) msg_prio;
    917   1.6       dsl 	} */
    918   1.1     rmind 
    919  1.25     rmind 	return mq_send1(SCARG(uap, mqdes), SCARG(uap, msg_ptr),
    920  1.25     rmind 	    SCARG(uap, msg_len), SCARG(uap, msg_prio), NULL);
    921   1.1     rmind }
    922   1.1     rmind 
    923   1.1     rmind int
    924  1.13  christos sys___mq_timedsend50(struct lwp *l, const struct sys___mq_timedsend50_args *uap,
    925   1.8     rmind     register_t *retval)
    926   1.1     rmind {
    927   1.6       dsl 	/* {
    928   1.1     rmind 		syscallarg(mqd_t) mqdes;
    929   1.1     rmind 		syscallarg(const char *) msg_ptr;
    930   1.1     rmind 		syscallarg(size_t) msg_len;
    931   1.1     rmind 		syscallarg(unsigned) msg_prio;
    932   1.1     rmind 		syscallarg(const struct timespec *) abs_timeout;
    933   1.6       dsl 	} */
    934  1.25     rmind 	struct timespec ts, *tsp;
    935  1.13  christos 	int error;
    936   1.1     rmind 
    937   1.1     rmind 	/* Get and convert time value */
    938   1.1     rmind 	if (SCARG(uap, abs_timeout)) {
    939  1.13  christos 		error = copyin(SCARG(uap, abs_timeout), &ts, sizeof(ts));
    940  1.13  christos 		if (error)
    941  1.13  christos 			return error;
    942  1.25     rmind 		tsp = &ts;
    943  1.25     rmind 	} else {
    944  1.25     rmind 		tsp = NULL;
    945  1.25     rmind 	}
    946   1.1     rmind 
    947  1.25     rmind 	return mq_send1(SCARG(uap, mqdes), SCARG(uap, msg_ptr),
    948  1.25     rmind 	    SCARG(uap, msg_len), SCARG(uap, msg_prio), tsp);
    949   1.1     rmind }
    950   1.1     rmind 
    951   1.1     rmind int
    952   1.8     rmind sys_mq_notify(struct lwp *l, const struct sys_mq_notify_args *uap,
    953   1.8     rmind     register_t *retval)
    954   1.1     rmind {
    955   1.6       dsl 	/* {
    956   1.1     rmind 		syscallarg(mqd_t) mqdes;
    957   1.1     rmind 		syscallarg(const struct sigevent *) notification;
    958   1.6       dsl 	} */
    959   1.1     rmind 	struct mqueue *mq;
    960   1.1     rmind 	struct sigevent sig;
    961   1.1     rmind 	int error;
    962   1.1     rmind 
    963   1.1     rmind 	if (SCARG(uap, notification)) {
    964   1.1     rmind 		/* Get the signal from user-space */
    965   1.1     rmind 		error = copyin(SCARG(uap, notification), &sig,
    966   1.1     rmind 		    sizeof(struct sigevent));
    967   1.1     rmind 		if (error)
    968   1.1     rmind 			return error;
    969  1.28  drochner 		if (sig.sigev_notify == SIGEV_SIGNAL &&
    970  1.28  drochner 		    (sig.sigev_signo <=0 || sig.sigev_signo >= NSIG))
    971  1.28  drochner 			return EINVAL;
    972   1.1     rmind 	}
    973   1.1     rmind 
    974  1.32     rmind 	error = mqueue_get(SCARG(uap, mqdes), 0, &mq);
    975  1.32     rmind 	if (error) {
    976   1.1     rmind 		return error;
    977  1.32     rmind 	}
    978   1.1     rmind 	if (SCARG(uap, notification)) {
    979   1.1     rmind 		/* Register notification: set the signal and target process */
    980   1.1     rmind 		if (mq->mq_notify_proc == NULL) {
    981   1.1     rmind 			memcpy(&mq->mq_sig_notify, &sig,
    982   1.1     rmind 			    sizeof(struct sigevent));
    983   1.1     rmind 			mq->mq_notify_proc = l->l_proc;
    984   1.1     rmind 		} else {
    985   1.1     rmind 			/* Fail if someone else already registered */
    986   1.1     rmind 			error = EBUSY;
    987   1.1     rmind 		}
    988   1.1     rmind 	} else {
    989   1.1     rmind 		/* Unregister the notification */
    990   1.1     rmind 		mq->mq_notify_proc = NULL;
    991   1.1     rmind 	}
    992   1.1     rmind 	mutex_exit(&mq->mq_mtx);
    993   1.7        ad 	fd_putfile((int)SCARG(uap, mqdes));
    994   1.1     rmind 
    995   1.1     rmind 	return error;
    996   1.1     rmind }
    997   1.1     rmind 
    998   1.1     rmind int
    999   1.8     rmind sys_mq_getattr(struct lwp *l, const struct sys_mq_getattr_args *uap,
   1000   1.8     rmind     register_t *retval)
   1001   1.1     rmind {
   1002   1.6       dsl 	/* {
   1003   1.1     rmind 		syscallarg(mqd_t) mqdes;
   1004   1.1     rmind 		syscallarg(struct mq_attr *) mqstat;
   1005   1.6       dsl 	} */
   1006   1.1     rmind 	struct mqueue *mq;
   1007   1.1     rmind 	struct mq_attr attr;
   1008   1.1     rmind 	int error;
   1009   1.1     rmind 
   1010  1.32     rmind 	error = mqueue_get(SCARG(uap, mqdes), 0, &mq);
   1011  1.32     rmind 	if (error) {
   1012   1.1     rmind 		return error;
   1013  1.32     rmind 	}
   1014   1.1     rmind 	memcpy(&attr, &mq->mq_attrib, sizeof(struct mq_attr));
   1015   1.1     rmind 	mutex_exit(&mq->mq_mtx);
   1016   1.7        ad 	fd_putfile((int)SCARG(uap, mqdes));
   1017   1.1     rmind 
   1018   1.1     rmind 	return copyout(&attr, SCARG(uap, mqstat), sizeof(struct mq_attr));
   1019   1.1     rmind }
   1020   1.1     rmind 
   1021   1.1     rmind int
   1022   1.8     rmind sys_mq_setattr(struct lwp *l, const struct sys_mq_setattr_args *uap,
   1023   1.8     rmind     register_t *retval)
   1024   1.1     rmind {
   1025   1.6       dsl 	/* {
   1026   1.1     rmind 		syscallarg(mqd_t) mqdes;
   1027   1.1     rmind 		syscallarg(const struct mq_attr *) mqstat;
   1028   1.1     rmind 		syscallarg(struct mq_attr *) omqstat;
   1029   1.6       dsl 	} */
   1030   1.1     rmind 	struct mqueue *mq;
   1031   1.1     rmind 	struct mq_attr attr;
   1032   1.1     rmind 	int error, nonblock;
   1033   1.1     rmind 
   1034   1.1     rmind 	error = copyin(SCARG(uap, mqstat), &attr, sizeof(struct mq_attr));
   1035   1.1     rmind 	if (error)
   1036   1.1     rmind 		return error;
   1037   1.1     rmind 	nonblock = (attr.mq_flags & O_NONBLOCK);
   1038   1.1     rmind 
   1039  1.32     rmind 	error = mqueue_get(SCARG(uap, mqdes), 0, &mq);
   1040  1.32     rmind 	if (error) {
   1041   1.1     rmind 		return error;
   1042  1.32     rmind 	}
   1043   1.1     rmind 
   1044   1.1     rmind 	/* Copy the old attributes, if needed */
   1045  1.22     rmind 	if (SCARG(uap, omqstat)) {
   1046   1.1     rmind 		memcpy(&attr, &mq->mq_attrib, sizeof(struct mq_attr));
   1047  1.22     rmind 	}
   1048   1.1     rmind 
   1049   1.1     rmind 	/* Ignore everything, except O_NONBLOCK */
   1050   1.1     rmind 	if (nonblock)
   1051   1.1     rmind 		mq->mq_attrib.mq_flags |= O_NONBLOCK;
   1052   1.1     rmind 	else
   1053   1.1     rmind 		mq->mq_attrib.mq_flags &= ~O_NONBLOCK;
   1054   1.1     rmind 
   1055   1.1     rmind 	mutex_exit(&mq->mq_mtx);
   1056   1.7        ad 	fd_putfile((int)SCARG(uap, mqdes));
   1057   1.1     rmind 
   1058   1.1     rmind 	/*
   1059   1.1     rmind 	 * Copy the data to the user-space.
   1060   1.1     rmind 	 * Note: According to POSIX, the new attributes should not be set in
   1061   1.1     rmind 	 * case of fail - this would be violated.
   1062   1.1     rmind 	 */
   1063   1.1     rmind 	if (SCARG(uap, omqstat))
   1064   1.1     rmind 		error = copyout(&attr, SCARG(uap, omqstat),
   1065   1.1     rmind 		    sizeof(struct mq_attr));
   1066   1.1     rmind 
   1067   1.1     rmind 	return error;
   1068   1.1     rmind }
   1069   1.1     rmind 
   1070   1.1     rmind int
   1071   1.8     rmind sys_mq_unlink(struct lwp *l, const struct sys_mq_unlink_args *uap,
   1072   1.8     rmind     register_t *retval)
   1073   1.1     rmind {
   1074   1.6       dsl 	/* {
   1075   1.1     rmind 		syscallarg(const char *) name;
   1076   1.6       dsl 	} */
   1077  1.32     rmind 	mqueue_t *mq;
   1078   1.1     rmind 	char *name;
   1079   1.1     rmind 	int error, refcnt = 0;
   1080   1.1     rmind 
   1081   1.1     rmind 	/* Get the name from the user-space */
   1082  1.32     rmind 	name = kmem_alloc(MQ_NAMELEN, KM_SLEEP);
   1083   1.1     rmind 	error = copyinstr(SCARG(uap, name), name, MQ_NAMELEN - 1, NULL);
   1084   1.1     rmind 	if (error) {
   1085   1.1     rmind 		kmem_free(name, MQ_NAMELEN);
   1086   1.1     rmind 		return error;
   1087   1.1     rmind 	}
   1088   1.1     rmind 
   1089  1.32     rmind 	mutex_enter(&mqlist_lock);
   1090   1.1     rmind 	mq = mqueue_lookup(name);
   1091   1.1     rmind 	if (mq == NULL) {
   1092   1.1     rmind 		error = ENOENT;
   1093  1.32     rmind 		goto err;
   1094   1.1     rmind 	}
   1095  1.32     rmind 	KASSERT(mutex_owned(&mq->mq_mtx));
   1096   1.1     rmind 
   1097  1.32     rmind 	/* Verify permissions. */
   1098  1.34      elad 	if (kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_MQUEUE, 0, mq,
   1099  1.34      elad 	    NULL, NULL)) {
   1100   1.1     rmind 		mutex_exit(&mq->mq_mtx);
   1101   1.1     rmind 		error = EACCES;
   1102  1.32     rmind 		goto err;
   1103   1.1     rmind 	}
   1104   1.1     rmind 
   1105  1.32     rmind 	/* Remove and destroy if no references. */
   1106  1.32     rmind 	LIST_REMOVE(mq, mq_list);
   1107  1.32     rmind 	refcnt = mq->mq_refcnt;
   1108  1.32     rmind 	if (refcnt) {
   1109  1.32     rmind 		/* Mark as unlinked, if there are references. */
   1110  1.32     rmind 		mq->mq_attrib.mq_flags |= MQ_UNLINKED;
   1111  1.32     rmind 	}
   1112   1.1     rmind 
   1113  1.32     rmind 	/* Wake up waiters, if there are any. */
   1114   1.1     rmind 	cv_broadcast(&mq->mq_send_cv);
   1115   1.1     rmind 	cv_broadcast(&mq->mq_recv_cv);
   1116   1.1     rmind 
   1117   1.8     rmind 	selnotify(&mq->mq_rsel, POLLHUP, 0);
   1118   1.8     rmind 	selnotify(&mq->mq_wsel, POLLHUP, 0);
   1119   1.8     rmind 
   1120   1.1     rmind 	mutex_exit(&mq->mq_mtx);
   1121  1.32     rmind err:
   1122  1.32     rmind 	mutex_exit(&mqlist_lock);
   1123   1.1     rmind 	/*
   1124  1.32     rmind 	 * If last reference - destroy the message queue.  Otherwise,
   1125  1.32     rmind 	 * the last mq_close() call will do that.
   1126   1.1     rmind 	 */
   1127  1.32     rmind 	if (!error && refcnt == 0) {
   1128   1.1     rmind 		mqueue_destroy(mq);
   1129  1.32     rmind 	}
   1130  1.32     rmind 	kmem_free(name, MQ_NAMELEN);
   1131   1.1     rmind 
   1132   1.1     rmind 	return error;
   1133   1.1     rmind }
   1134   1.1     rmind 
   1135   1.1     rmind /*
   1136  1.22     rmind  * System control nodes.
   1137   1.1     rmind  */
   1138  1.46  pgoyette SYSCTL_SETUP(mqueue_sysctl_init, "mqueue systl")
   1139   1.1     rmind {
   1140   1.1     rmind 	const struct sysctlnode *node = NULL;
   1141   1.1     rmind 
   1142  1.46  pgoyette 	sysctl_createv(clog, 0, NULL, NULL,
   1143   1.1     rmind 		CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
   1144   1.1     rmind 		CTLTYPE_INT, "posix_msg",
   1145   1.1     rmind 		SYSCTL_DESCR("Version of IEEE Std 1003.1 and its "
   1146   1.1     rmind 			     "Message Passing option to which the "
   1147   1.1     rmind 			     "system attempts to conform"),
   1148   1.1     rmind 		NULL, _POSIX_MESSAGE_PASSING, NULL, 0,
   1149   1.1     rmind 		CTL_KERN, CTL_CREATE, CTL_EOL);
   1150  1.46  pgoyette 	sysctl_createv(clog, 0, NULL, &node,
   1151   1.1     rmind 		CTLFLAG_PERMANENT,
   1152   1.1     rmind 		CTLTYPE_NODE, "mqueue",
   1153   1.1     rmind 		SYSCTL_DESCR("Message queue options"),
   1154   1.1     rmind 		NULL, 0, NULL, 0,
   1155   1.1     rmind 		CTL_KERN, CTL_CREATE, CTL_EOL);
   1156   1.1     rmind 
   1157   1.1     rmind 	if (node == NULL)
   1158  1.46  pgoyette 		return;
   1159   1.1     rmind 
   1160  1.46  pgoyette 	sysctl_createv(clog, 0, &node, NULL,
   1161   1.1     rmind 		CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
   1162   1.1     rmind 		CTLTYPE_INT, "mq_open_max",
   1163   1.1     rmind 		SYSCTL_DESCR("Maximal number of message queue descriptors "
   1164   1.1     rmind 			     "that process could open"),
   1165   1.1     rmind 		NULL, 0, &mq_open_max, 0,
   1166   1.1     rmind 		CTL_CREATE, CTL_EOL);
   1167  1.46  pgoyette 	sysctl_createv(clog, 0, &node, NULL,
   1168   1.1     rmind 		CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
   1169   1.1     rmind 		CTLTYPE_INT, "mq_prio_max",
   1170   1.1     rmind 		SYSCTL_DESCR("Maximal priority of the message"),
   1171   1.1     rmind 		NULL, 0, &mq_prio_max, 0,
   1172   1.1     rmind 		CTL_CREATE, CTL_EOL);
   1173  1.46  pgoyette 	sysctl_createv(clog, 0, &node, NULL,
   1174   1.1     rmind 		CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
   1175   1.1     rmind 		CTLTYPE_INT, "mq_max_msgsize",
   1176   1.1     rmind 		SYSCTL_DESCR("Maximal allowed size of the message"),
   1177   1.1     rmind 		NULL, 0, &mq_max_msgsize, 0,
   1178   1.1     rmind 		CTL_CREATE, CTL_EOL);
   1179  1.46  pgoyette 	sysctl_createv(clog, 0, &node, NULL,
   1180   1.1     rmind 		CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
   1181   1.1     rmind 		CTLTYPE_INT, "mq_def_maxmsg",
   1182   1.1     rmind 		SYSCTL_DESCR("Default maximal message count"),
   1183   1.1     rmind 		NULL, 0, &mq_def_maxmsg, 0,
   1184   1.1     rmind 		CTL_CREATE, CTL_EOL);
   1185  1.46  pgoyette 	sysctl_createv(clog, 0, &node, NULL,
   1186  1.28  drochner 		CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
   1187  1.28  drochner 		CTLTYPE_INT, "mq_max_maxmsg",
   1188  1.28  drochner 		SYSCTL_DESCR("Maximal allowed message count"),
   1189  1.28  drochner 		NULL, 0, &mq_max_maxmsg, 0,
   1190  1.28  drochner 		CTL_CREATE, CTL_EOL);
   1191  1.30    jruoho 
   1192  1.46  pgoyette 	return;
   1193   1.1     rmind }
   1194   1.1     rmind 
   1195   1.1     rmind /*
   1196   1.1     rmind  * Debugging.
   1197   1.1     rmind  */
   1198   1.1     rmind #if defined(DDB)
   1199   1.1     rmind 
   1200   1.1     rmind void
   1201   1.1     rmind mqueue_print_list(void (*pr)(const char *, ...))
   1202   1.1     rmind {
   1203   1.1     rmind 	struct mqueue *mq;
   1204   1.1     rmind 
   1205   1.1     rmind 	(*pr)("Global list of the message queues:\n");
   1206   1.1     rmind 	(*pr)("%20s %10s %8s %8s %3s %4s %4s %4s\n",
   1207   1.1     rmind 	    "Name", "Ptr", "Mode", "Flags",  "Ref",
   1208   1.1     rmind 	    "MaxMsg", "MsgSze", "CurMsg");
   1209   1.1     rmind 	LIST_FOREACH(mq, &mqueue_head, mq_list) {
   1210   1.1     rmind 		(*pr)("%20s %10p %8x %8x %3u %6lu %6lu %6lu\n",
   1211   1.1     rmind 		    mq->mq_name, mq, mq->mq_mode,
   1212   1.1     rmind 		    mq->mq_attrib.mq_flags, mq->mq_refcnt,
   1213   1.1     rmind 		    mq->mq_attrib.mq_maxmsg, mq->mq_attrib.mq_msgsize,
   1214   1.1     rmind 		    mq->mq_attrib.mq_curmsgs);
   1215   1.1     rmind 	}
   1216   1.1     rmind }
   1217   1.1     rmind 
   1218   1.1     rmind #endif /* defined(DDB) */
   1219