1 /* $NetBSD: sys_mqueue.c,v 1.16 2009/04/11 23:05:26 christos Exp $ */
4 * Copyright (c) 2007, 2008 Mindaugas Rasiukevicius <rmind at NetBSD org>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * Implementation of POSIX message queues.
31 * Defined in the Base Definitions volume of IEEE Std 1003.1-2001.
35 * Global list of message queues (mqueue_head) and proc_t::p_mqueue_cnt
36 * counter are protected by mqlist_mtx lock. The very message queue and
37 * its members are protected by mqueue::mq_mtx.
45 #include <sys/param.h>
46 #include <sys/types.h>
47 #include <sys/errno.h>
48 #include <sys/fcntl.h>
50 #include <sys/filedesc.h>
51 #include <sys/ucred.h>
53 #include <sys/kernel.h>
54 #include <sys/malloc.h>
55 #include <sys/mplock2.h>
56 #include <sys/mqueue.h>
57 #include <sys/objcache.h>
59 #include <sys/queue.h>
60 #include <sys/event.h>
61 #include <sys/serialize.h>
62 #include <sys/signal.h>
63 #include <sys/signalvar.h>
64 #include <sys/spinlock.h>
65 #include <sys/spinlock2.h>
67 #include <sys/sysctl.h>
68 #include <sys/sysproto.h>
69 #include <sys/systm.h>
71 #include <sys/unistd.h>
72 #include <sys/vnode.h>
74 /* System-wide limits. */
75 static u_int mq_open_max = MQ_OPEN_MAX;
76 static u_int mq_prio_max = MQ_PRIO_MAX;
77 static u_int mq_max_msgsize = 16 * MQ_DEF_MSGSIZE;
78 static u_int mq_def_maxmsg = 32;
79 static u_int mq_max_maxmsg = 16 * 32;
81 struct lock mqlist_mtx;
82 static struct objcache * mqmsg_cache;
83 static LIST_HEAD(, mqueue) mqueue_head =
84 LIST_HEAD_INITIALIZER(mqueue_head);
86 typedef struct file file_t; /* XXX: Should we put this in sys/types.h ? */
88 /* Function prototypes */
89 static int mq_stat_fop(file_t *, struct stat *, struct ucred *cred);
90 static int mq_close_fop(file_t *);
91 static int mq_kqfilter_fop(struct file *fp, struct knote *kn);
92 static void mqfilter_read_detach(struct knote *kn);
93 static void mqfilter_write_detach(struct knote *kn);
94 static int mqfilter_read(struct knote *kn, long hint);
95 static int mqfilter_write(struct knote *kn, long hint);
97 /* Some time-related utility functions */
98 static int itimespecfix(struct timespec *ts);
99 static int tstohz(const struct timespec *ts);
101 /* File operations vector */
102 static struct fileops mqops = {
103 .fo_read = badfo_readwrite,
104 .fo_write = badfo_readwrite,
105 .fo_ioctl = badfo_ioctl,
106 .fo_stat = mq_stat_fop,
107 .fo_close = mq_close_fop,
108 .fo_kqfilter = mq_kqfilter_fop,
109 .fo_shutdown = badfo_shutdown
112 /* Define a new malloc type for message queues */
113 MALLOC_DECLARE(M_MQBUF);
114 MALLOC_DEFINE(M_MQBUF, "mqueues", "Buffers to message queues");
116 /* Malloc arguments for object cache */
117 struct objcache_malloc_args mqueue_malloc_args = {
118 sizeof(struct mqueue), M_MQBUF };
121 * Initialize POSIX message queue subsystem.
126 mqmsg_cache = objcache_create("mqmsg_cache",
127 0, /* infinite depot's capacity */
128 0, /* default magazine's capacity */
129 NULL, /* constructor */
130 NULL, /* deconstructor */
132 objcache_malloc_alloc,
133 objcache_malloc_free,
134 &mqueue_malloc_args);
136 lockinit(&mqlist_mtx, "mqlist_mtx", 0, LK_CANRECURSE);
143 mqueue_freemsg(struct mq_msg *msg, const size_t size)
146 if (size > MQ_DEF_MSGSIZE) {
149 objcache_put(mqmsg_cache, msg);
154 * Destroy the message queue.
157 mqueue_destroy(struct mqueue *mq)
163 /* Note MQ_PQSIZE + 1. */
164 for (i = 0; i < MQ_PQSIZE + 1; i++) {
165 while ((msg = TAILQ_FIRST(&mq->mq_head[i])) != NULL) {
166 TAILQ_REMOVE(&mq->mq_head[i], msg, msg_queue);
167 msz = sizeof(struct mq_msg) + msg->msg_len;
168 mqueue_freemsg(msg, msz);
171 lockuninit(&mq->mq_mtx);
176 * Lookup for file name in general list of message queues.
177 * => locks the message queue
180 mqueue_lookup(char *name)
184 KKASSERT(lockstatus(&mqlist_mtx, curthread));
186 LIST_FOREACH(mq, &mqueue_head, mq_list) {
187 if (strncmp(mq->mq_name, name, MQ_NAMELEN) == 0) {
188 lockmgr(&mq->mq_mtx, LK_EXCLUSIVE);
197 * mqueue_get: get the mqueue from the descriptor.
198 * => locks the message queue, if found.
199 * => holds a reference on the file descriptor.
202 mqueue_get(struct lwp *l, mqd_t mqd, file_t **fpr)
207 fp = holdfp(curproc->p_fd, (int)mqd, -1); /* XXX: Why -1 ? */
208 if (__predict_false(fp == NULL))
211 if (__predict_false(fp->f_type != DTYPE_MQUEUE)) {
216 lockmgr(&mq->mq_mtx, LK_EXCLUSIVE);
223 * mqueue_linear_insert: perform linear insert according to the message
224 * priority into the reserved queue (MQ_PQRESQ). Reserved queue is a
225 * sorted list used only when mq_prio_max is increased via sysctl.
228 mqueue_linear_insert(struct mqueue *mq, struct mq_msg *msg)
232 TAILQ_FOREACH(mit, &mq->mq_head[MQ_PQRESQ], msg_queue) {
233 if (msg->msg_prio > mit->msg_prio)
237 TAILQ_INSERT_TAIL(&mq->mq_head[MQ_PQRESQ], msg, msg_queue);
239 TAILQ_INSERT_BEFORE(mit, msg, msg_queue);
247 itimespecfix(struct timespec *ts)
249 if (ts->tv_sec < 0 || ts->tv_nsec < 0 || ts->tv_nsec >= 1000000000)
251 if (ts->tv_sec == 0 && ts->tv_nsec != 0 && ts->tv_nsec < nstick)
252 ts->tv_nsec = nstick;
257 * Compute number of ticks in the specified amount of time.
260 tstohz(const struct timespec *ts)
265 * usec has great enough resolution for hz, so convert to a
266 * timeval and use tvtohz() above.
268 TIMESPEC_TO_TIMEVAL(&tv, ts);
269 return tvtohz_high(&tv); /* XXX Why _high() and not _low() ? */
273 * Converter from struct timespec to the ticks.
274 * Used by mq_timedreceive(), mq_timedsend().
277 abstimeout2timo(struct timespec *ts, int *timo)
282 error = itimespecfix(ts);
287 timespecsub(ts, &tsd);
288 if (ts->tv_sec < 0 || (ts->tv_sec == 0 && ts->tv_nsec <= 0)) {
292 KKASSERT(*timo != 0);
298 mq_stat_fop(file_t *fp, struct stat *st, struct ucred *cred)
300 struct mqueue *mq = fp->f_data;
302 (void)memset(st, 0, sizeof(*st));
304 lockmgr(&mq->mq_mtx, LK_EXCLUSIVE);
305 st->st_mode = mq->mq_mode;
306 st->st_uid = mq->mq_euid;
307 st->st_gid = mq->mq_egid;
308 st->st_atimespec = mq->mq_atime;
309 st->st_mtimespec = mq->mq_mtime;
310 /*st->st_ctimespec = st->st_birthtimespec = mq->mq_btime;*/
311 st->st_uid = fp->f_cred->cr_uid;
312 st->st_gid = fp->f_cred->cr_svgid;
313 lockmgr(&mq->mq_mtx, LK_RELEASE);
318 static struct filterops mqfiltops_read =
319 { FILTEROP_ISFD, NULL, mqfilter_read_detach, mqfilter_read };
320 static struct filterops mqfiltops_write =
321 { FILTEROP_ISFD, NULL, mqfilter_write_detach, mqfilter_write };
324 mq_kqfilter_fop(struct file *fp, struct knote *kn)
326 struct mqueue *mq = fp->f_data;
329 lockmgr(&mq->mq_mtx, LK_EXCLUSIVE);
331 switch (kn->kn_filter) {
333 kn->kn_fop = &mqfiltops_read;
334 kn->kn_hook = (caddr_t)mq;
335 klist = &mq->mq_rkq.ki_note;
338 kn->kn_fop = &mqfiltops_write;
339 kn->kn_hook = (caddr_t)mq;
340 klist = &mq->mq_wkq.ki_note;
343 lockmgr(&mq->mq_mtx, LK_RELEASE);
347 knote_insert(klist, kn);
348 lockmgr(&mq->mq_mtx, LK_RELEASE);
354 mqfilter_read_detach(struct knote *kn)
356 struct mqueue *mq = (struct mqueue *)kn->kn_hook;
358 lockmgr(&mq->mq_mtx, LK_EXCLUSIVE);
359 struct klist *klist = &mq->mq_rkq.ki_note;
360 knote_remove(klist, kn);
361 lockmgr(&mq->mq_mtx, LK_RELEASE);
365 mqfilter_write_detach(struct knote *kn)
367 struct mqueue *mq = (struct mqueue *)kn->kn_hook;
369 lockmgr(&mq->mq_mtx, LK_EXCLUSIVE);
370 struct klist *klist = &mq->mq_wkq.ki_note;
371 knote_remove(klist, kn);
372 lockmgr(&mq->mq_mtx, LK_RELEASE);
376 mqfilter_read(struct knote *kn, long hint)
378 struct mqueue *mq = (struct mqueue *)kn->kn_hook;
379 struct mq_attr *mqattr;
382 lockmgr(&mq->mq_mtx, LK_EXCLUSIVE);
383 mqattr = &mq->mq_attrib;
384 /* Ready for receiving, if there are messages in the queue */
385 if (mqattr->mq_curmsgs)
387 lockmgr(&mq->mq_mtx, LK_RELEASE);
393 mqfilter_write(struct knote *kn, long hint)
395 struct mqueue *mq = (struct mqueue *)kn->kn_hook;
396 struct mq_attr *mqattr;
399 lockmgr(&mq->mq_mtx, LK_EXCLUSIVE);
400 mqattr = &mq->mq_attrib;
401 /* Ready for sending, if the message queue is not full */
402 if (mqattr->mq_curmsgs < mqattr->mq_maxmsg)
404 lockmgr(&mq->mq_mtx, LK_RELEASE);
410 mq_close_fop(file_t *fp)
412 struct proc *p = curproc;
413 struct mqueue *mq = fp->f_data;
416 lockmgr(&mqlist_mtx, LK_EXCLUSIVE);
417 lockmgr(&mq->mq_mtx, LK_EXCLUSIVE);
419 /* Decrease the counters */
423 /* Remove notification if registered for this process */
424 if (mq->mq_notify_proc == p)
425 mq->mq_notify_proc = NULL;
428 * If this is the last reference and mqueue is marked for unlink,
429 * remove and later destroy the message queue.
431 if (mq->mq_refcnt == 0 && (mq->mq_attrib.mq_flags & MQ_UNLINK)) {
432 LIST_REMOVE(mq, mq_list);
437 lockmgr(&mq->mq_mtx, LK_RELEASE);
438 lockmgr(&mqlist_mtx, LK_RELEASE);
447 * General mqueue system calls.
451 sys_mq_open(struct mq_open_args *uap)
454 syscallarg(const char *) name;
455 syscallarg(int) oflag;
456 syscallarg(mode_t) mode;
457 syscallarg(struct mq_attr) attr;
459 struct thread *td = curthread;
460 struct proc *p = td->td_proc;
461 struct filedesc *fdp = p->p_fd;
462 struct mqueue *mq, *mq_new = NULL;
465 int mqd, error, oflag;
467 /* Check access mode flags */
468 oflag = SCARG(uap, oflag);
469 if ((oflag & O_ACCMODE) == (O_WRONLY | O_RDWR)) {
473 /* Get the name from the user-space */
474 name = kmalloc(MQ_NAMELEN, M_MQBUF, M_WAITOK | M_ZERO | M_NULLOK);
477 error = copyinstr(SCARG(uap, name), name, MQ_NAMELEN - 1, NULL);
479 kfree(name, M_MQBUF);
483 if (oflag & O_CREAT) {
487 /* Check the limit */
488 if (p->p_mqueue_cnt == mq_open_max) {
489 kfree(name, M_MQBUF);
493 /* Empty name is invalid */
494 if (name[0] == '\0') {
495 kfree(name, M_MQBUF);
499 /* Check for mqueue attributes */
500 if (SCARG(uap, attr)) {
501 error = copyin(SCARG(uap, attr), &attr,
502 sizeof(struct mq_attr));
504 kfree(name, M_MQBUF);
507 if (attr.mq_maxmsg <= 0 ||
508 attr.mq_maxmsg > mq_max_maxmsg ||
509 attr.mq_msgsize <= 0 ||
510 attr.mq_msgsize > mq_max_msgsize) {
511 kfree(name, M_MQBUF);
516 memset(&attr, 0, sizeof(struct mq_attr));
517 attr.mq_maxmsg = mq_def_maxmsg;
519 MQ_DEF_MSGSIZE - sizeof(struct mq_msg);
523 * Allocate new mqueue, initialize data structures,
524 * copy the name, attributes and set the flag.
526 mq_new = kmalloc(sizeof(struct mqueue), M_MQBUF,
527 M_WAITOK | M_ZERO | M_NULLOK);
528 if (mq_new == NULL) {
529 kfree(name, M_MQBUF);
533 lockinit(&mq_new->mq_mtx, "mq_new->mq_mtx", 0, LK_CANRECURSE);
534 for (i = 0; i < (MQ_PQSIZE + 1); i++) {
535 TAILQ_INIT(&mq_new->mq_head[i]);
538 strlcpy(mq_new->mq_name, name, MQ_NAMELEN);
539 memcpy(&mq_new->mq_attrib, &attr, sizeof(struct mq_attr));
541 /*CTASSERT((O_MASK & (MQ_UNLINK | MQ_RECEIVE)) == 0);*/
542 /* mq_new->mq_attrib.mq_flags = (O_MASK & oflag); */
543 mq_new->mq_attrib.mq_flags = oflag;
545 /* Store mode and effective UID with GID */
546 mq_new->mq_mode = ((SCARG(uap, mode) &
547 ~p->p_fd->fd_cmask) & ALLPERMS) & ~S_ISTXT;
548 mq_new->mq_euid = td->td_ucred->cr_uid;
549 mq_new->mq_egid = td->td_ucred->cr_svgid;
552 /* Allocate file structure and descriptor */
553 error = falloc(td->td_lwp, &fp, &mqd);
556 mqueue_destroy(mq_new);
557 kfree(name, M_MQBUF);
560 fp->f_type = DTYPE_MQUEUE;
561 fp->f_flag = FFLAGS(oflag) & (FREAD | FWRITE);
564 /* Look up for mqueue with such name */
565 lockmgr(&mqlist_mtx, LK_EXCLUSIVE);
566 mq = mqueue_lookup(name);
570 KKASSERT(lockstatus(&mq->mq_mtx, curthread));
572 /* Check if mqueue is not marked as unlinking */
573 if (mq->mq_attrib.mq_flags & MQ_UNLINK) {
577 /* Fail if O_EXCL is set, and mqueue already exists */
578 if ((oflag & O_CREAT) && (oflag & O_EXCL)) {
584 * Check the permissions. Note the difference between
585 * VREAD/VWRITE and FREAD/FWRITE.
588 if (fp->f_flag & FREAD) {
591 if (fp->f_flag & FWRITE) {
594 if (vaccess(VNON, mq->mq_mode, mq->mq_euid, mq->mq_egid,
595 acc_mode, td->td_ucred)) {
601 /* Fail if mqueue neither exists, nor we create it */
602 if ((oflag & O_CREAT) == 0) {
603 lockmgr(&mqlist_mtx, LK_RELEASE);
604 KKASSERT(mq_new == NULL);
605 fsetfd(fdp, NULL, mqd);
606 fp->f_ops = &badfileops;
608 kfree(name, M_MQBUF);
612 /* Check the limit */
613 if (p->p_mqueue_cnt == mq_open_max) {
618 /* Insert the queue to the list */
620 lockmgr(&mq->mq_mtx, LK_EXCLUSIVE);
621 LIST_INSERT_HEAD(&mqueue_head, mq, mq_list);
623 getnanotime(&mq->mq_btime);
624 mq->mq_atime = mq->mq_mtime = mq->mq_btime;
627 /* Increase the counters, and make descriptor ready */
632 lockmgr(&mq->mq_mtx, LK_RELEASE);
633 lockmgr(&mqlist_mtx, LK_RELEASE);
636 mqueue_destroy(mq_new);
638 fsetfd(fdp, NULL, mqd);
639 fp->f_ops = &badfileops;
641 fsetfd(fdp, fp, mqd);
642 uap->sysmsg_result = mqd;
645 kfree(name, M_MQBUF);
651 sys_mq_close(struct mq_close_args *uap)
653 return sys_close((void *)uap);
657 * Primary mq_receive1() function.
660 mq_receive1(struct lwp *l, mqd_t mqdes, void *msg_ptr, size_t msg_len,
661 unsigned *msg_prio, struct timespec *ts, ssize_t *mlen)
665 struct mq_msg *msg = NULL;
666 struct mq_attr *mqattr;
670 /* Get the message queue */
671 error = mqueue_get(l, mqdes, &fp);
676 if ((fp->f_flag & FREAD) == 0) {
680 getnanotime(&mq->mq_atime);
681 mqattr = &mq->mq_attrib;
683 /* Check the message size limits */
684 if (msg_len < mqattr->mq_msgsize) {
689 /* Check if queue is empty */
690 while (mqattr->mq_curmsgs == 0) {
693 if (mqattr->mq_flags & O_NONBLOCK) {
698 error = abstimeout2timo(ts, &t);
704 * Block until someone sends the message.
705 * While doing this, notification should not be sent.
707 mqattr->mq_flags |= MQ_RECEIVE;
708 error = lksleep(&mq->mq_send_cv, &mq->mq_mtx, PCATCH, "mqsend", t);
709 mqattr->mq_flags &= ~MQ_RECEIVE;
710 if (error || (mqattr->mq_flags & MQ_UNLINK)) {
711 error = (error == EWOULDBLOCK) ? ETIMEDOUT : EINTR;
718 * Find the highest priority message, and remove it from the queue.
719 * At first, reserved queue is checked, bitmap is next.
721 msg = TAILQ_FIRST(&mq->mq_head[MQ_PQRESQ]);
722 if (__predict_true(msg == NULL)) {
723 idx = ffs(mq->mq_bitmap);
724 msg = TAILQ_FIRST(&mq->mq_head[idx]);
725 KKASSERT(msg != NULL);
729 TAILQ_REMOVE(&mq->mq_head[idx], msg, msg_queue);
731 /* Unmark the bit, if last message. */
732 if (__predict_true(idx) && TAILQ_EMPTY(&mq->mq_head[idx])) {
733 KKASSERT((MQ_PQSIZE - idx) == msg->msg_prio);
734 mq->mq_bitmap &= ~(1 << --idx);
737 /* Decrement the counter and signal waiter, if any */
738 mqattr->mq_curmsgs--;
739 wakeup_one(&mq->mq_recv_cv);
741 /* Ready for sending now */
742 KNOTE(&mq->mq_wkq.ki_note, 0);
744 lockmgr(&mq->mq_mtx, LK_RELEASE);
750 * Copy the data to the user-space.
751 * Note: According to POSIX, no message should be removed from the
752 * queue in case of fail - this would be violated.
754 *mlen = msg->msg_len;
755 error = copyout(msg->msg_ptr, msg_ptr, msg->msg_len);
756 if (error == 0 && msg_prio)
757 error = copyout(&msg->msg_prio, msg_prio, sizeof(unsigned));
758 mqueue_freemsg(msg, sizeof(struct mq_msg) + msg->msg_len);
764 sys_mq_receive(struct mq_receive_args *uap)
767 syscallarg(mqd_t) mqdes;
768 syscallarg(char *) msg_ptr;
769 syscallarg(size_t) msg_len;
770 syscallarg(unsigned *) msg_prio;
775 error = mq_receive1(curthread->td_lwp, SCARG(uap, mqdes), SCARG(uap, msg_ptr),
776 SCARG(uap, msg_len), SCARG(uap, msg_prio), 0, &mlen);
778 uap->sysmsg_result = mlen;
784 sys_mq_timedreceive(struct mq_timedreceive_args *uap)
787 syscallarg(mqd_t) mqdes;
788 syscallarg(char *) msg_ptr;
789 syscallarg(size_t) msg_len;
790 syscallarg(unsigned *) msg_prio;
791 syscallarg(const struct timespec *) abs_timeout;
795 struct timespec ts, *tsp;
797 /* Get and convert time value */
798 if (SCARG(uap, abs_timeout)) {
799 error = copyin(SCARG(uap, abs_timeout), &ts, sizeof(ts));
807 error = mq_receive1(curthread->td_lwp, SCARG(uap, mqdes), SCARG(uap, msg_ptr),
808 SCARG(uap, msg_len), SCARG(uap, msg_prio), tsp, &mlen);
810 uap->sysmsg_result = mlen;
816 * Primary mq_send1() function.
819 mq_send1(struct lwp *l, mqd_t mqdes, const char *msg_ptr, size_t msg_len,
820 unsigned msg_prio, struct timespec *ts)
825 struct mq_attr *mqattr;
826 struct proc *notify = NULL;
831 /* Check the priority range */
832 if (msg_prio >= mq_prio_max)
835 /* Allocate a new message */
836 size = sizeof(struct mq_msg) + msg_len;
837 if (size > mq_max_msgsize)
840 if (size > MQ_DEF_MSGSIZE) {
841 msg = kmalloc(size, M_MQBUF, M_WAITOK | M_NULLOK);
843 msg = objcache_get(mqmsg_cache, M_WAITOK | M_NULLOK);
849 /* Get the data from user-space */
850 error = copyin(msg_ptr, msg->msg_ptr, msg_len);
852 mqueue_freemsg(msg, size);
855 msg->msg_len = msg_len;
856 msg->msg_prio = msg_prio;
859 error = mqueue_get(l, mqdes, &fp);
861 mqueue_freemsg(msg, size);
865 if ((fp->f_flag & FWRITE) == 0) {
869 getnanotime(&mq->mq_mtime);
870 mqattr = &mq->mq_attrib;
872 /* Check the message size limit */
873 if (msg_len <= 0 || msg_len > mqattr->mq_msgsize) {
878 /* Check if queue is full */
879 while (mqattr->mq_curmsgs >= mqattr->mq_maxmsg) {
882 if (mqattr->mq_flags & O_NONBLOCK) {
887 error = abstimeout2timo(ts, &t);
892 /* Block until queue becomes available */
893 error = lksleep(&mq->mq_recv_cv, &mq->mq_mtx, PCATCH, "mqrecv", t);
894 if (error || (mqattr->mq_flags & MQ_UNLINK)) {
895 error = (error == EWOULDBLOCK) ? ETIMEDOUT : error;
899 KKASSERT(mq->mq_attrib.mq_curmsgs < mq->mq_attrib.mq_maxmsg);
902 * Insert message into the queue, according to the priority.
903 * Note the difference between index and priority.
905 if (__predict_true(msg_prio < MQ_PQSIZE)) {
906 u_int idx = MQ_PQSIZE - msg_prio;
908 KKASSERT(idx != MQ_PQRESQ);
909 TAILQ_INSERT_TAIL(&mq->mq_head[idx], msg, msg_queue);
910 mq->mq_bitmap |= (1 << --idx);
912 mqueue_linear_insert(mq, msg);
915 /* Check for the notify */
916 if (mqattr->mq_curmsgs == 0 && mq->mq_notify_proc &&
917 (mqattr->mq_flags & MQ_RECEIVE) == 0 &&
918 mq->mq_sig_notify.sigev_notify == SIGEV_SIGNAL) {
919 /* Initialize the signal */
921 /*ksi.ksi_signo = mq->mq_sig_notify.sigev_signo;*/
922 /*ksi.ksi_code = SI_MESGQ;*/
923 /*ksi.ksi_value = mq->mq_sig_notify.sigev_value;*/
924 /* Unregister the process */
925 notify = mq->mq_notify_proc;
926 mq->mq_notify_proc = NULL;
929 /* Increment the counter and signal waiter, if any */
930 mqattr->mq_curmsgs++;
931 wakeup_one(&mq->mq_send_cv);
933 /* Ready for receiving now */
934 KNOTE(&mq->mq_rkq.ki_note, 0);
936 lockmgr(&mq->mq_mtx, LK_RELEASE);
940 mqueue_freemsg(msg, size);
942 /* Send the notify, if needed */
943 lwkt_gettoken(&proc_token);
944 /*kpsignal(notify, &ksi, NULL);*/
945 ksignal(notify, mq->mq_sig_notify.sigev_signo);
946 lwkt_reltoken(&proc_token);
953 sys_mq_send(struct mq_send_args *uap)
956 syscallarg(mqd_t) mqdes;
957 syscallarg(const char *) msg_ptr;
958 syscallarg(size_t) msg_len;
959 syscallarg(unsigned) msg_prio;
962 return mq_send1(curthread->td_lwp, SCARG(uap, mqdes), SCARG(uap, msg_ptr),
963 SCARG(uap, msg_len), SCARG(uap, msg_prio), 0);
967 sys_mq_timedsend(struct mq_timedsend_args *uap)
970 syscallarg(mqd_t) mqdes;
971 syscallarg(const char *) msg_ptr;
972 syscallarg(size_t) msg_len;
973 syscallarg(unsigned) msg_prio;
974 syscallarg(const struct timespec *) abs_timeout;
976 struct timespec ts, *tsp;
979 /* Get and convert time value */
980 if (SCARG(uap, abs_timeout)) {
981 error = copyin(SCARG(uap, abs_timeout), &ts, sizeof(ts));
989 return mq_send1(curthread->td_lwp, SCARG(uap, mqdes), SCARG(uap, msg_ptr),
990 SCARG(uap, msg_len), SCARG(uap, msg_prio), tsp);
994 sys_mq_notify(struct mq_notify_args *uap)
997 syscallarg(mqd_t) mqdes;
998 syscallarg(const struct sigevent *) notification;
1002 struct sigevent sig;
1005 if (SCARG(uap, notification)) {
1006 /* Get the signal from user-space */
1007 error = copyin(SCARG(uap, notification), &sig,
1008 sizeof(struct sigevent));
1011 if (sig.sigev_notify == SIGEV_SIGNAL &&
1012 (sig.sigev_signo <= 0 || sig.sigev_signo >= NSIG))
1016 error = mqueue_get(curthread->td_lwp, SCARG(uap, mqdes), &fp);
1021 if (SCARG(uap, notification)) {
1022 /* Register notification: set the signal and target process */
1023 if (mq->mq_notify_proc == NULL) {
1024 memcpy(&mq->mq_sig_notify, &sig,
1025 sizeof(struct sigevent));
1026 mq->mq_notify_proc = curproc;
1028 /* Fail if someone else already registered */
1032 /* Unregister the notification */
1033 mq->mq_notify_proc = NULL;
1035 lockmgr(&mq->mq_mtx, LK_RELEASE);
1042 sys_mq_getattr(struct mq_getattr_args *uap)
1045 syscallarg(mqd_t) mqdes;
1046 syscallarg(struct mq_attr *) mqstat;
1050 struct mq_attr attr;
1053 /* Get the message queue */
1054 error = mqueue_get(curthread->td_lwp, SCARG(uap, mqdes), &fp);
1058 memcpy(&attr, &mq->mq_attrib, sizeof(struct mq_attr));
1059 lockmgr(&mq->mq_mtx, LK_RELEASE);
1062 return copyout(&attr, SCARG(uap, mqstat), sizeof(struct mq_attr));
1066 sys_mq_setattr(struct mq_setattr_args *uap)
1069 syscallarg(mqd_t) mqdes;
1070 syscallarg(const struct mq_attr *) mqstat;
1071 syscallarg(struct mq_attr *) omqstat;
1075 struct mq_attr attr;
1076 int error, nonblock;
1078 error = copyin(SCARG(uap, mqstat), &attr, sizeof(struct mq_attr));
1081 nonblock = (attr.mq_flags & O_NONBLOCK);
1083 /* Get the message queue */
1084 error = mqueue_get(curthread->td_lwp, SCARG(uap, mqdes), &fp);
1089 /* Copy the old attributes, if needed */
1090 if (SCARG(uap, omqstat)) {
1091 memcpy(&attr, &mq->mq_attrib, sizeof(struct mq_attr));
1094 /* Ignore everything, except O_NONBLOCK */
1096 mq->mq_attrib.mq_flags |= O_NONBLOCK;
1098 mq->mq_attrib.mq_flags &= ~O_NONBLOCK;
1100 lockmgr(&mq->mq_mtx, LK_RELEASE);
1104 * Copy the data to the user-space.
1105 * Note: According to POSIX, the new attributes should not be set in
1106 * case of fail - this would be violated.
1108 if (SCARG(uap, omqstat))
1109 error = copyout(&attr, SCARG(uap, omqstat),
1110 sizeof(struct mq_attr));
1116 sys_mq_unlink(struct mq_unlink_args *uap)
1119 syscallarg(const char *) name;
1121 struct thread *td = curthread;
1124 int error, refcnt = 0;
1126 /* Get the name from the user-space */
1127 name = kmalloc(MQ_NAMELEN, M_MQBUF, M_WAITOK | M_ZERO | M_NULLOK);
1130 error = copyinstr(SCARG(uap, name), name, MQ_NAMELEN - 1, NULL);
1132 kfree(name, M_MQBUF);
1136 /* Lookup for this file */
1137 lockmgr(&mqlist_mtx, LK_EXCLUSIVE);
1138 mq = mqueue_lookup(name);
1144 /* Check the permissions */
1145 if (td->td_ucred->cr_uid != mq->mq_euid &&
1146 priv_check(td, PRIV_ROOT) != 0) {
1147 lockmgr(&mq->mq_mtx, LK_RELEASE);
1152 /* Mark message queue as unlinking, before leaving the window */
1153 mq->mq_attrib.mq_flags |= MQ_UNLINK;
1155 /* Wake up all waiters, if there are such */
1156 wakeup(&mq->mq_send_cv);
1157 wakeup(&mq->mq_recv_cv);
1159 KNOTE(&mq->mq_rkq.ki_note, 0);
1160 KNOTE(&mq->mq_wkq.ki_note, 0);
1162 refcnt = mq->mq_refcnt;
1164 LIST_REMOVE(mq, mq_list);
1166 lockmgr(&mq->mq_mtx, LK_RELEASE);
1168 lockmgr(&mqlist_mtx, LK_RELEASE);
1171 * If there are no references - destroy the message
1172 * queue, otherwise, the last mq_close() will do that.
1174 if (error == 0 && refcnt == 0)
1177 kfree(name, M_MQBUF);
1184 SYSCTL_NODE(_kern, OID_AUTO, mqueue,
1185 CTLFLAG_RW, 0, "Message queue options");
1187 SYSCTL_INT(_kern_mqueue, OID_AUTO, mq_open_max,
1188 CTLFLAG_RW, &mq_open_max, 0,
1189 "Maximal number of message queue descriptors per process");
1191 SYSCTL_INT(_kern_mqueue, OID_AUTO, mq_prio_max,
1192 CTLFLAG_RW, &mq_prio_max, 0,
1193 "Maximal priority of the message");
1195 SYSCTL_INT(_kern_mqueue, OID_AUTO, mq_max_msgsize,
1196 CTLFLAG_RW, &mq_max_msgsize, 0,
1197 "Maximal allowed size of the message");
1199 SYSCTL_INT(_kern_mqueue, OID_AUTO, mq_def_maxmsg,
1200 CTLFLAG_RW, &mq_def_maxmsg, 0,
1201 "Default maximal message count");
1203 SYSCTL_INT(_kern_mqueue, OID_AUTO, mq_max_maxmsg,
1204 CTLFLAG_RW, &mq_max_maxmsg, 0,
1205 "Maximal allowed message count");
1207 SYSINIT(sys_mqueue_init, SI_SUB_PRE_DRIVERS, SI_ORDER_ANY, mqueue_sysinit, NULL);