sys/kern: Adjust some function declaration vs. definition mismatches.
[dragonfly.git] / sys / kern / sys_mqueue.c
CommitLineData
f2df0f7c
SK
1/* $NetBSD: sys_mqueue.c,v 1.16 2009/04/11 23:05:26 christos Exp $ */
2
3/*
4 * Copyright (c) 2007, 2008 Mindaugas Rasiukevicius <rmind at NetBSD org>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
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.
15 *
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
26 * SUCH DAMAGE.
27 */
28
29/*
30 * Implementation of POSIX message queues.
31 * Defined in the Base Definitions volume of IEEE Std 1003.1-2001.
32 *
33 * Locking
34 *
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.
38 *
39 * Lock order:
40 * mqlist_mtx
41 * -> mqueue::mq_mtx
42 */
43
f2df0f7c
SK
44#include <stdbool.h>
45#include <sys/param.h>
46#include <sys/types.h>
47#include <sys/errno.h>
48#include <sys/fcntl.h>
49#include <sys/file.h>
50#include <sys/filedesc.h>
51#include <sys/ucred.h>
52#include <sys/priv.h>
53#include <sys/kernel.h>
54#include <sys/malloc.h>
55#include <sys/mqueue.h>
f2df0f7c
SK
56#include <sys/proc.h>
57#include <sys/queue.h>
b06aab00 58#include <sys/event.h>
f2df0f7c
SK
59#include <sys/serialize.h>
60#include <sys/signal.h>
61#include <sys/signalvar.h>
62#include <sys/spinlock.h>
63#include <sys/spinlock2.h>
64#include <sys/stat.h>
65#include <sys/sysctl.h>
66#include <sys/sysproto.h>
67#include <sys/systm.h>
68#include <sys/lock.h>
69#include <sys/unistd.h>
70#include <sys/vnode.h>
71
72/* System-wide limits. */
73static u_int mq_open_max = MQ_OPEN_MAX;
74static u_int mq_prio_max = MQ_PRIO_MAX;
75static u_int mq_max_msgsize = 16 * MQ_DEF_MSGSIZE;
76static u_int mq_def_maxmsg = 32;
8658b626 77static u_int mq_max_maxmsg = 16 * 32;
f2df0f7c
SK
78
79struct lock mqlist_mtx;
f2df0f7c
SK
80static LIST_HEAD(, mqueue) mqueue_head =
81 LIST_HEAD_INITIALIZER(mqueue_head);
82
83typedef struct file file_t; /* XXX: Should we put this in sys/types.h ? */
84
85/* Function prototypes */
f2df0f7c
SK
86static int mq_stat_fop(file_t *, struct stat *, struct ucred *cred);
87static int mq_close_fop(file_t *);
b06aab00
SG
88static int mq_kqfilter_fop(struct file *fp, struct knote *kn);
89static void mqfilter_read_detach(struct knote *kn);
90static void mqfilter_write_detach(struct knote *kn);
91static int mqfilter_read(struct knote *kn, long hint);
92static int mqfilter_write(struct knote *kn, long hint);
f2df0f7c
SK
93
94/* Some time-related utility functions */
95static int itimespecfix(struct timespec *ts);
96static int tstohz(const struct timespec *ts);
97
98/* File operations vector */
99static struct fileops mqops = {
100 .fo_read = badfo_readwrite,
101 .fo_write = badfo_readwrite,
102 .fo_ioctl = badfo_ioctl,
f2df0f7c
SK
103 .fo_stat = mq_stat_fop,
104 .fo_close = mq_close_fop,
b06aab00 105 .fo_kqfilter = mq_kqfilter_fop,
f2df0f7c
SK
106 .fo_shutdown = badfo_shutdown
107};
108
109/* Define a new malloc type for message queues */
110MALLOC_DECLARE(M_MQBUF);
111MALLOC_DEFINE(M_MQBUF, "mqueues", "Buffers to message queues");
112
f2df0f7c
SK
113/*
114 * Initialize POSIX message queue subsystem.
115 */
116void
117mqueue_sysinit(void)
118{
f2df0f7c
SK
119 lockinit(&mqlist_mtx, "mqlist_mtx", 0, LK_CANRECURSE);
120}
121
122/*
123 * Free the message.
124 */
125static void
126mqueue_freemsg(struct mq_msg *msg, const size_t size)
127{
88be9cd1 128 kfree(msg, M_MQBUF);
f2df0f7c
SK
129}
130
131/*
132 * Destroy the message queue.
133 */
134static void
135mqueue_destroy(struct mqueue *mq)
136{
137 struct mq_msg *msg;
138 size_t msz;
139 u_int i;
140
141 /* Note MQ_PQSIZE + 1. */
142 for (i = 0; i < MQ_PQSIZE + 1; i++) {
143 while ((msg = TAILQ_FIRST(&mq->mq_head[i])) != NULL) {
144 TAILQ_REMOVE(&mq->mq_head[i], msg, msg_queue);
145 msz = sizeof(struct mq_msg) + msg->msg_len;
146 mqueue_freemsg(msg, msz);
147 }
148 }
149 lockuninit(&mq->mq_mtx);
150 kfree(mq, M_MQBUF);
151}
152
153/*
154 * Lookup for file name in general list of message queues.
155 * => locks the message queue
156 */
157static void *
158mqueue_lookup(char *name)
159{
160 struct mqueue *mq;
161
162 KKASSERT(lockstatus(&mqlist_mtx, curthread));
163
164 LIST_FOREACH(mq, &mqueue_head, mq_list) {
165 if (strncmp(mq->mq_name, name, MQ_NAMELEN) == 0) {
166 lockmgr(&mq->mq_mtx, LK_EXCLUSIVE);
167 return mq;
168 }
169 }
170
171 return NULL;
172}
173
174/*
175 * mqueue_get: get the mqueue from the descriptor.
176 * => locks the message queue, if found.
d1d64679 177 * => holds a reference on the file descriptor.
f2df0f7c
SK
178 */
179static int
180mqueue_get(struct lwp *l, mqd_t mqd, file_t **fpr)
181{
182 struct mqueue *mq;
183 file_t *fp;
184
185 fp = holdfp(curproc->p_fd, (int)mqd, -1); /* XXX: Why -1 ? */
186 if (__predict_false(fp == NULL))
187 return EBADF;
188
189 if (__predict_false(fp->f_type != DTYPE_MQUEUE)) {
190 fdrop(fp);
191 return EBADF;
192 }
193 mq = fp->f_data;
194 lockmgr(&mq->mq_mtx, LK_EXCLUSIVE);
195
196 *fpr = fp;
197 return 0;
198}
199
200/*
201 * mqueue_linear_insert: perform linear insert according to the message
202 * priority into the reserved queue (MQ_PQRESQ). Reserved queue is a
203 * sorted list used only when mq_prio_max is increased via sysctl.
204 */
205static inline void
206mqueue_linear_insert(struct mqueue *mq, struct mq_msg *msg)
207{
208 struct mq_msg *mit;
209
210 TAILQ_FOREACH(mit, &mq->mq_head[MQ_PQRESQ], msg_queue) {
211 if (msg->msg_prio > mit->msg_prio)
212 break;
213 }
214 if (mit == NULL) {
215 TAILQ_INSERT_TAIL(&mq->mq_head[MQ_PQRESQ], msg, msg_queue);
216 } else {
217 TAILQ_INSERT_BEFORE(mit, msg, msg_queue);
218 }
219}
220
221/*
222 * Validate input.
223 */
59b728a7 224static int
f2df0f7c
SK
225itimespecfix(struct timespec *ts)
226{
227 if (ts->tv_sec < 0 || ts->tv_nsec < 0 || ts->tv_nsec >= 1000000000)
228 return (EINVAL);
a591f597
MD
229 if (ts->tv_sec == 0 && ts->tv_nsec != 0 && ts->tv_nsec < nstick)
230 ts->tv_nsec = nstick;
f2df0f7c
SK
231 return (0);
232}
233
234/*
235 * Compute number of ticks in the specified amount of time.
236 */
59b728a7 237static int
f2df0f7c
SK
238tstohz(const struct timespec *ts)
239{
240 struct timeval tv;
241
242 /*
243 * usec has great enough resolution for hz, so convert to a
244 * timeval and use tvtohz() above.
245 */
246 TIMESPEC_TO_TIMEVAL(&tv, ts);
247 return tvtohz_high(&tv); /* XXX Why _high() and not _low() ? */
248}
249
250/*
251 * Converter from struct timespec to the ticks.
252 * Used by mq_timedreceive(), mq_timedsend().
253 */
254int
255abstimeout2timo(struct timespec *ts, int *timo)
256{
257 struct timespec tsd;
258 int error;
259
959f863f
SK
260 error = itimespecfix(ts);
261 if (error) {
262 return error;
a27ab186 263 }
f2df0f7c
SK
264 getnanotime(&tsd);
265 timespecsub(ts, &tsd);
266 if (ts->tv_sec < 0 || (ts->tv_sec == 0 && ts->tv_nsec <= 0)) {
267 return ETIMEDOUT;
268 }
f2df0f7c
SK
269 *timo = tstohz(ts);
270 KKASSERT(*timo != 0);
271
272 return 0;
273}
274
275static int
276mq_stat_fop(file_t *fp, struct stat *st, struct ucred *cred)
277{
278 struct mqueue *mq = fp->f_data;
279
280 (void)memset(st, 0, sizeof(*st));
281
282 lockmgr(&mq->mq_mtx, LK_EXCLUSIVE);
283 st->st_mode = mq->mq_mode;
284 st->st_uid = mq->mq_euid;
285 st->st_gid = mq->mq_egid;
286 st->st_atimespec = mq->mq_atime;
287 st->st_mtimespec = mq->mq_mtime;
288 /*st->st_ctimespec = st->st_birthtimespec = mq->mq_btime;*/
289 st->st_uid = fp->f_cred->cr_uid;
290 st->st_gid = fp->f_cred->cr_svgid;
291 lockmgr(&mq->mq_mtx, LK_RELEASE);
292
293 return 0;
294}
295
b06aab00 296static struct filterops mqfiltops_read =
45a3dbb7 297{ FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, mqfilter_read_detach, mqfilter_read };
b06aab00 298static struct filterops mqfiltops_write =
45a3dbb7 299{ FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, mqfilter_write_detach, mqfilter_write };
b06aab00
SG
300
301static int
302mq_kqfilter_fop(struct file *fp, struct knote *kn)
303{
304 struct mqueue *mq = fp->f_data;
305 struct klist *klist;
306
307 lockmgr(&mq->mq_mtx, LK_EXCLUSIVE);
308
309 switch (kn->kn_filter) {
310 case EVFILT_READ:
311 kn->kn_fop = &mqfiltops_read;
312 kn->kn_hook = (caddr_t)mq;
5b22f1a7 313 klist = &mq->mq_rkq.ki_note;
b06aab00
SG
314 break;
315 case EVFILT_WRITE:
316 kn->kn_fop = &mqfiltops_write;
317 kn->kn_hook = (caddr_t)mq;
5b22f1a7 318 klist = &mq->mq_wkq.ki_note;
b06aab00
SG
319 break;
320 default:
321 lockmgr(&mq->mq_mtx, LK_RELEASE);
322 return (EOPNOTSUPP);
323 }
324
5b22f1a7 325 knote_insert(klist, kn);
b06aab00
SG
326 lockmgr(&mq->mq_mtx, LK_RELEASE);
327
328 return (0);
329}
330
331static void
332mqfilter_read_detach(struct knote *kn)
333{
334 struct mqueue *mq = (struct mqueue *)kn->kn_hook;
335
336 lockmgr(&mq->mq_mtx, LK_EXCLUSIVE);
5b22f1a7
SG
337 struct klist *klist = &mq->mq_rkq.ki_note;
338 knote_remove(klist, kn);
b06aab00
SG
339 lockmgr(&mq->mq_mtx, LK_RELEASE);
340}
341
342static void
343mqfilter_write_detach(struct knote *kn)
344{
345 struct mqueue *mq = (struct mqueue *)kn->kn_hook;
346
347 lockmgr(&mq->mq_mtx, LK_EXCLUSIVE);
5b22f1a7
SG
348 struct klist *klist = &mq->mq_wkq.ki_note;
349 knote_remove(klist, kn);
b06aab00
SG
350 lockmgr(&mq->mq_mtx, LK_RELEASE);
351}
352
353static int
354mqfilter_read(struct knote *kn, long hint)
355{
356 struct mqueue *mq = (struct mqueue *)kn->kn_hook;
357 struct mq_attr *mqattr;
358 int ready = 0;
359
360 lockmgr(&mq->mq_mtx, LK_EXCLUSIVE);
361 mqattr = &mq->mq_attrib;
362 /* Ready for receiving, if there are messages in the queue */
363 if (mqattr->mq_curmsgs)
364 ready = 1;
365 lockmgr(&mq->mq_mtx, LK_RELEASE);
366
367 return (ready);
368}
369
370static int
371mqfilter_write(struct knote *kn, long hint)
372{
373 struct mqueue *mq = (struct mqueue *)kn->kn_hook;
374 struct mq_attr *mqattr;
375 int ready = 0;
376
377 lockmgr(&mq->mq_mtx, LK_EXCLUSIVE);
378 mqattr = &mq->mq_attrib;
379 /* Ready for sending, if the message queue is not full */
380 if (mqattr->mq_curmsgs < mqattr->mq_maxmsg)
381 ready = 1;
382 lockmgr(&mq->mq_mtx, LK_RELEASE);
383
384 return (ready);
385}
386
f2df0f7c
SK
387static int
388mq_close_fop(file_t *fp)
389{
390 struct proc *p = curproc;
391 struct mqueue *mq = fp->f_data;
392 bool destroy;
393
394 lockmgr(&mqlist_mtx, LK_EXCLUSIVE);
395 lockmgr(&mq->mq_mtx, LK_EXCLUSIVE);
396
397 /* Decrease the counters */
398 p->p_mqueue_cnt--;
399 mq->mq_refcnt--;
400
401 /* Remove notification if registered for this process */
402 if (mq->mq_notify_proc == p)
403 mq->mq_notify_proc = NULL;
404
405 /*
406 * If this is the last reference and mqueue is marked for unlink,
407 * remove and later destroy the message queue.
408 */
409 if (mq->mq_refcnt == 0 && (mq->mq_attrib.mq_flags & MQ_UNLINK)) {
410 LIST_REMOVE(mq, mq_list);
411 destroy = true;
412 } else
413 destroy = false;
414
415 lockmgr(&mq->mq_mtx, LK_RELEASE);
416 lockmgr(&mqlist_mtx, LK_RELEASE);
417
418 if (destroy)
419 mqueue_destroy(mq);
420
421 return 0;
422}
423
424/*
425 * General mqueue system calls.
426 */
427
428int
429sys_mq_open(struct mq_open_args *uap)
430{
431 /* {
432 syscallarg(const char *) name;
433 syscallarg(int) oflag;
434 syscallarg(mode_t) mode;
435 syscallarg(struct mq_attr) attr;
436 } */
9910d07b
MD
437 struct thread *td = curthread;
438 struct proc *p = td->td_proc;
f3a2d8c4 439 struct filedesc *fdp = p->p_fd;
f2df0f7c
SK
440 struct mqueue *mq, *mq_new = NULL;
441 file_t *fp;
442 char *name;
443 int mqd, error, oflag;
444
445 /* Check access mode flags */
446 oflag = SCARG(uap, oflag);
447 if ((oflag & O_ACCMODE) == (O_WRONLY | O_RDWR)) {
448 return EINVAL;
449 }
450
451 /* Get the name from the user-space */
d3a2b23d
VS
452 name = kmalloc(MQ_NAMELEN, M_MQBUF, M_WAITOK | M_ZERO | M_NULLOK);
453 if (name == NULL)
454 return (ENOMEM);
f2df0f7c
SK
455 error = copyinstr(SCARG(uap, name), name, MQ_NAMELEN - 1, NULL);
456 if (error) {
457 kfree(name, M_MQBUF);
458 return error;
459 }
460
461 if (oflag & O_CREAT) {
462 struct mq_attr attr;
463 u_int i;
464
465 /* Check the limit */
466 if (p->p_mqueue_cnt == mq_open_max) {
467 kfree(name, M_MQBUF);
468 return EMFILE;
469 }
470
471 /* Empty name is invalid */
472 if (name[0] == '\0') {
473 kfree(name, M_MQBUF);
474 return EINVAL;
475 }
476
477 /* Check for mqueue attributes */
478 if (SCARG(uap, attr)) {
479 error = copyin(SCARG(uap, attr), &attr,
480 sizeof(struct mq_attr));
481 if (error) {
482 kfree(name, M_MQBUF);
483 return error;
484 }
8658b626
SK
485 if (attr.mq_maxmsg <= 0 ||
486 attr.mq_maxmsg > mq_max_maxmsg ||
487 attr.mq_msgsize <= 0 ||
f2df0f7c
SK
488 attr.mq_msgsize > mq_max_msgsize) {
489 kfree(name, M_MQBUF);
490 return EINVAL;
491 }
492 attr.mq_curmsgs = 0;
493 } else {
494 memset(&attr, 0, sizeof(struct mq_attr));
495 attr.mq_maxmsg = mq_def_maxmsg;
496 attr.mq_msgsize =
497 MQ_DEF_MSGSIZE - sizeof(struct mq_msg);
498 }
499
500 /*
501 * Allocate new mqueue, initialize data structures,
502 * copy the name, attributes and set the flag.
503 */
d3a2b23d
VS
504 mq_new = kmalloc(sizeof(struct mqueue), M_MQBUF,
505 M_WAITOK | M_ZERO | M_NULLOK);
506 if (mq_new == NULL) {
507 kfree(name, M_MQBUF);
508 return (ENOMEM);
509 }
f2df0f7c
SK
510
511 lockinit(&mq_new->mq_mtx, "mq_new->mq_mtx", 0, LK_CANRECURSE);
512 for (i = 0; i < (MQ_PQSIZE + 1); i++) {
513 TAILQ_INIT(&mq_new->mq_head[i]);
514 }
515
516 strlcpy(mq_new->mq_name, name, MQ_NAMELEN);
517 memcpy(&mq_new->mq_attrib, &attr, sizeof(struct mq_attr));
518
519 /*CTASSERT((O_MASK & (MQ_UNLINK | MQ_RECEIVE)) == 0);*/
520 /* mq_new->mq_attrib.mq_flags = (O_MASK & oflag); */
521 mq_new->mq_attrib.mq_flags = oflag;
522
523 /* Store mode and effective UID with GID */
524 mq_new->mq_mode = ((SCARG(uap, mode) &
525 ~p->p_fd->fd_cmask) & ALLPERMS) & ~S_ISTXT;
9910d07b
MD
526 mq_new->mq_euid = td->td_ucred->cr_uid;
527 mq_new->mq_egid = td->td_ucred->cr_svgid;
f2df0f7c
SK
528 }
529
530 /* Allocate file structure and descriptor */
f3a2d8c4 531 error = falloc(td->td_lwp, &fp, &mqd);
f2df0f7c
SK
532 if (error) {
533 if (mq_new)
534 mqueue_destroy(mq_new);
535 kfree(name, M_MQBUF);
536 return error;
537 }
538 fp->f_type = DTYPE_MQUEUE;
539 fp->f_flag = FFLAGS(oflag) & (FREAD | FWRITE);
540 fp->f_ops = &mqops;
541
542 /* Look up for mqueue with such name */
543 lockmgr(&mqlist_mtx, LK_EXCLUSIVE);
544 mq = mqueue_lookup(name);
545 if (mq) {
546 int acc_mode;
547
548 KKASSERT(lockstatus(&mq->mq_mtx, curthread));
549
550 /* Check if mqueue is not marked as unlinking */
551 if (mq->mq_attrib.mq_flags & MQ_UNLINK) {
552 error = EACCES;
553 goto exit;
554 }
555 /* Fail if O_EXCL is set, and mqueue already exists */
556 if ((oflag & O_CREAT) && (oflag & O_EXCL)) {
557 error = EEXIST;
558 goto exit;
559 }
560
561 /*
562 * Check the permissions. Note the difference between
563 * VREAD/VWRITE and FREAD/FWRITE.
564 */
565 acc_mode = 0;
566 if (fp->f_flag & FREAD) {
567 acc_mode |= VREAD;
568 }
569 if (fp->f_flag & FWRITE) {
570 acc_mode |= VWRITE;
571 }
572 if (vaccess(VNON, mq->mq_mode, mq->mq_euid, mq->mq_egid,
9910d07b 573 acc_mode, td->td_ucred)) {
f2df0f7c
SK
574
575 error = EACCES;
576 goto exit;
577 }
578 } else {
579 /* Fail if mqueue neither exists, nor we create it */
580 if ((oflag & O_CREAT) == 0) {
581 lockmgr(&mqlist_mtx, LK_RELEASE);
582 KKASSERT(mq_new == NULL);
f3a2d8c4 583 fsetfd(fdp, NULL, mqd);
f2df0f7c
SK
584 fp->f_ops = &badfileops;
585 fdrop(fp);
586 kfree(name, M_MQBUF);
587 return ENOENT;
588 }
589
590 /* Check the limit */
591 if (p->p_mqueue_cnt == mq_open_max) {
592 error = EMFILE;
593 goto exit;
594 }
595
596 /* Insert the queue to the list */
597 mq = mq_new;
598 lockmgr(&mq->mq_mtx, LK_EXCLUSIVE);
599 LIST_INSERT_HEAD(&mqueue_head, mq, mq_list);
600 mq_new = NULL;
601 getnanotime(&mq->mq_btime);
602 mq->mq_atime = mq->mq_mtime = mq->mq_btime;
603 }
604
605 /* Increase the counters, and make descriptor ready */
606 p->p_mqueue_cnt++;
607 mq->mq_refcnt++;
608 fp->f_data = mq;
609exit:
610 lockmgr(&mq->mq_mtx, LK_RELEASE);
611 lockmgr(&mqlist_mtx, LK_RELEASE);
612
613 if (mq_new)
614 mqueue_destroy(mq_new);
615 if (error) {
f3a2d8c4 616 fsetfd(fdp, NULL, mqd);
f2df0f7c
SK
617 fp->f_ops = &badfileops;
618 } else {
f3a2d8c4 619 fsetfd(fdp, fp, mqd);
f2df0f7c
SK
620 uap->sysmsg_result = mqd;
621 }
622 fdrop(fp);
623 kfree(name, M_MQBUF);
624
625 return error;
626}
627
628int
629sys_mq_close(struct mq_close_args *uap)
630{
631 return sys_close((void *)uap);
632}
633
634/*
635 * Primary mq_receive1() function.
636 */
637int
638mq_receive1(struct lwp *l, mqd_t mqdes, void *msg_ptr, size_t msg_len,
639 unsigned *msg_prio, struct timespec *ts, ssize_t *mlen)
640{
641 file_t *fp = NULL;
642 struct mqueue *mq;
643 struct mq_msg *msg = NULL;
644 struct mq_attr *mqattr;
645 u_int idx;
646 int error;
647
648 /* Get the message queue */
649 error = mqueue_get(l, mqdes, &fp);
650 if (error) {
651 return error;
652 }
653 mq = fp->f_data;
654 if ((fp->f_flag & FREAD) == 0) {
655 error = EBADF;
656 goto error;
657 }
658 getnanotime(&mq->mq_atime);
659 mqattr = &mq->mq_attrib;
660
661 /* Check the message size limits */
662 if (msg_len < mqattr->mq_msgsize) {
663 error = EMSGSIZE;
664 goto error;
665 }
666
667 /* Check if queue is empty */
668 while (mqattr->mq_curmsgs == 0) {
669 int t;
670
671 if (mqattr->mq_flags & O_NONBLOCK) {
672 error = EAGAIN;
673 goto error;
674 }
c8b16402
SK
675 if (ts) {
676 error = abstimeout2timo(ts, &t);
677 if (error)
678 goto error;
679 } else
680 t = 0;
f2df0f7c
SK
681 /*
682 * Block until someone sends the message.
683 * While doing this, notification should not be sent.
684 */
685 mqattr->mq_flags |= MQ_RECEIVE;
acb0b16f 686 error = lksleep(&mq->mq_send_cv, &mq->mq_mtx, PCATCH, "mqsend", t);
f2df0f7c
SK
687 mqattr->mq_flags &= ~MQ_RECEIVE;
688 if (error || (mqattr->mq_flags & MQ_UNLINK)) {
689 error = (error == EWOULDBLOCK) ? ETIMEDOUT : EINTR;
690 goto error;
691 }
692 }
693
694
695 /*
696 * Find the highest priority message, and remove it from the queue.
697 * At first, reserved queue is checked, bitmap is next.
698 */
699 msg = TAILQ_FIRST(&mq->mq_head[MQ_PQRESQ]);
700 if (__predict_true(msg == NULL)) {
701 idx = ffs(mq->mq_bitmap);
702 msg = TAILQ_FIRST(&mq->mq_head[idx]);
703 KKASSERT(msg != NULL);
704 } else {
705 idx = MQ_PQRESQ;
706 }
707 TAILQ_REMOVE(&mq->mq_head[idx], msg, msg_queue);
708
709 /* Unmark the bit, if last message. */
710 if (__predict_true(idx) && TAILQ_EMPTY(&mq->mq_head[idx])) {
711 KKASSERT((MQ_PQSIZE - idx) == msg->msg_prio);
712 mq->mq_bitmap &= ~(1 << --idx);
713 }
714
715 /* Decrement the counter and signal waiter, if any */
716 mqattr->mq_curmsgs--;
717 wakeup_one(&mq->mq_recv_cv);
718
719 /* Ready for sending now */
5b22f1a7 720 KNOTE(&mq->mq_wkq.ki_note, 0);
f2df0f7c
SK
721error:
722 lockmgr(&mq->mq_mtx, LK_RELEASE);
723 fdrop(fp);
724 if (error)
725 return error;
726
727 /*
728 * Copy the data to the user-space.
729 * Note: According to POSIX, no message should be removed from the
730 * queue in case of fail - this would be violated.
731 */
732 *mlen = msg->msg_len;
733 error = copyout(msg->msg_ptr, msg_ptr, msg->msg_len);
734 if (error == 0 && msg_prio)
735 error = copyout(&msg->msg_prio, msg_prio, sizeof(unsigned));
736 mqueue_freemsg(msg, sizeof(struct mq_msg) + msg->msg_len);
737
738 return error;
739}
740
741int
742sys_mq_receive(struct mq_receive_args *uap)
743{
744 /* {
745 syscallarg(mqd_t) mqdes;
746 syscallarg(char *) msg_ptr;
747 syscallarg(size_t) msg_len;
748 syscallarg(unsigned *) msg_prio;
749 } */
750 ssize_t mlen;
751 int error;
752
753 error = mq_receive1(curthread->td_lwp, SCARG(uap, mqdes), SCARG(uap, msg_ptr),
754 SCARG(uap, msg_len), SCARG(uap, msg_prio), 0, &mlen);
755 if (error == 0)
756 uap->sysmsg_result = mlen;
757
758 return error;
759}
760
761int
762sys_mq_timedreceive(struct mq_timedreceive_args *uap)
763{
764 /* {
765 syscallarg(mqd_t) mqdes;
766 syscallarg(char *) msg_ptr;
767 syscallarg(size_t) msg_len;
768 syscallarg(unsigned *) msg_prio;
769 syscallarg(const struct timespec *) abs_timeout;
770 } */
771 int error;
772 ssize_t mlen;
773 struct timespec ts, *tsp;
774
775 /* Get and convert time value */
776 if (SCARG(uap, abs_timeout)) {
777 error = copyin(SCARG(uap, abs_timeout), &ts, sizeof(ts));
778 if (error)
779 return error;
780 tsp = &ts;
781 } else {
782 tsp = NULL;
783 }
784
785 error = mq_receive1(curthread->td_lwp, SCARG(uap, mqdes), SCARG(uap, msg_ptr),
786 SCARG(uap, msg_len), SCARG(uap, msg_prio), tsp, &mlen);
787 if (error == 0)
788 uap->sysmsg_result = mlen;
789
790 return error;
791}
792
793/*
794 * Primary mq_send1() function.
795 */
796int
797mq_send1(struct lwp *l, mqd_t mqdes, const char *msg_ptr, size_t msg_len,
798 unsigned msg_prio, struct timespec *ts)
799{
800 file_t *fp = NULL;
801 struct mqueue *mq;
802 struct mq_msg *msg;
803 struct mq_attr *mqattr;
804 struct proc *notify = NULL;
805 /*ksiginfo_t ksi;*/
806 size_t size;
807 int error;
808
809 /* Check the priority range */
810 if (msg_prio >= mq_prio_max)
811 return EINVAL;
812
813 /* Allocate a new message */
814 size = sizeof(struct mq_msg) + msg_len;
815 if (size > mq_max_msgsize)
816 return EMSGSIZE;
817
88be9cd1 818 msg = kmalloc(size, M_MQBUF, M_WAITOK | M_NULLOK);
d3a2b23d
VS
819 if (msg == NULL)
820 return (ENOMEM);
821
f2df0f7c
SK
822
823 /* Get the data from user-space */
824 error = copyin(msg_ptr, msg->msg_ptr, msg_len);
825 if (error) {
826 mqueue_freemsg(msg, size);
827 return error;
828 }
829 msg->msg_len = msg_len;
830 msg->msg_prio = msg_prio;
831
832 /* Get the mqueue */
833 error = mqueue_get(l, mqdes, &fp);
834 if (error) {
835 mqueue_freemsg(msg, size);
836 return error;
837 }
838 mq = fp->f_data;
839 if ((fp->f_flag & FWRITE) == 0) {
840 error = EBADF;
841 goto error;
842 }
843 getnanotime(&mq->mq_mtime);
844 mqattr = &mq->mq_attrib;
845
846 /* Check the message size limit */
847 if (msg_len <= 0 || msg_len > mqattr->mq_msgsize) {
848 error = EMSGSIZE;
849 goto error;
850 }
851
852 /* Check if queue is full */
853 while (mqattr->mq_curmsgs >= mqattr->mq_maxmsg) {
854 int t;
855
856 if (mqattr->mq_flags & O_NONBLOCK) {
857 error = EAGAIN;
858 goto error;
859 }
c8b16402
SK
860 if (ts) {
861 error = abstimeout2timo(ts, &t);
862 if (error)
863 goto error;
864 } else
865 t = 0;
f2df0f7c 866 /* Block until queue becomes available */
acb0b16f 867 error = lksleep(&mq->mq_recv_cv, &mq->mq_mtx, PCATCH, "mqrecv", t);
f2df0f7c
SK
868 if (error || (mqattr->mq_flags & MQ_UNLINK)) {
869 error = (error == EWOULDBLOCK) ? ETIMEDOUT : error;
870 goto error;
871 }
872 }
873 KKASSERT(mq->mq_attrib.mq_curmsgs < mq->mq_attrib.mq_maxmsg);
874
875 /*
876 * Insert message into the queue, according to the priority.
877 * Note the difference between index and priority.
878 */
879 if (__predict_true(msg_prio < MQ_PQSIZE)) {
880 u_int idx = MQ_PQSIZE - msg_prio;
881
882 KKASSERT(idx != MQ_PQRESQ);
883 TAILQ_INSERT_TAIL(&mq->mq_head[idx], msg, msg_queue);
884 mq->mq_bitmap |= (1 << --idx);
885 } else {
886 mqueue_linear_insert(mq, msg);
887 }
888
889 /* Check for the notify */
890 if (mqattr->mq_curmsgs == 0 && mq->mq_notify_proc &&
c8b16402
SK
891 (mqattr->mq_flags & MQ_RECEIVE) == 0 &&
892 mq->mq_sig_notify.sigev_notify == SIGEV_SIGNAL) {
f2df0f7c
SK
893 /* Initialize the signal */
894 /*KSI_INIT(&ksi);*/
895 /*ksi.ksi_signo = mq->mq_sig_notify.sigev_signo;*/
896 /*ksi.ksi_code = SI_MESGQ;*/
897 /*ksi.ksi_value = mq->mq_sig_notify.sigev_value;*/
898 /* Unregister the process */
899 notify = mq->mq_notify_proc;
900 mq->mq_notify_proc = NULL;
901 }
902
903 /* Increment the counter and signal waiter, if any */
904 mqattr->mq_curmsgs++;
905 wakeup_one(&mq->mq_send_cv);
906
907 /* Ready for receiving now */
5b22f1a7 908 KNOTE(&mq->mq_rkq.ki_note, 0);
f2df0f7c 909error:
f2df0f7c 910 if (error) {
a8d3ab53
MD
911 lockmgr(&mq->mq_mtx, LK_RELEASE);
912 fdrop(fp);
f2df0f7c
SK
913 mqueue_freemsg(msg, size);
914 } else if (notify) {
a8d3ab53
MD
915 PHOLD(notify);
916 lockmgr(&mq->mq_mtx, LK_RELEASE);
917 fdrop(fp);
f2df0f7c 918 /* Send the notify, if needed */
f2df0f7c
SK
919 /*kpsignal(notify, &ksi, NULL);*/
920 ksignal(notify, mq->mq_sig_notify.sigev_signo);
a8d3ab53
MD
921 PRELE(notify);
922 } else {
923 lockmgr(&mq->mq_mtx, LK_RELEASE);
924 fdrop(fp);
f2df0f7c 925 }
f2df0f7c
SK
926 return error;
927}
928
929int
930sys_mq_send(struct mq_send_args *uap)
931{
932 /* {
933 syscallarg(mqd_t) mqdes;
934 syscallarg(const char *) msg_ptr;
935 syscallarg(size_t) msg_len;
936 syscallarg(unsigned) msg_prio;
937 } */
938
939 return mq_send1(curthread->td_lwp, SCARG(uap, mqdes), SCARG(uap, msg_ptr),
940 SCARG(uap, msg_len), SCARG(uap, msg_prio), 0);
941}
942
943int
944sys_mq_timedsend(struct mq_timedsend_args *uap)
945{
946 /* {
947 syscallarg(mqd_t) mqdes;
948 syscallarg(const char *) msg_ptr;
949 syscallarg(size_t) msg_len;
950 syscallarg(unsigned) msg_prio;
951 syscallarg(const struct timespec *) abs_timeout;
952 } */
953 struct timespec ts, *tsp;
954 int error;
955
956 /* Get and convert time value */
957 if (SCARG(uap, abs_timeout)) {
958 error = copyin(SCARG(uap, abs_timeout), &ts, sizeof(ts));
959 if (error)
960 return error;
961 tsp = &ts;
962 } else {
963 tsp = NULL;
964 }
965
966 return mq_send1(curthread->td_lwp, SCARG(uap, mqdes), SCARG(uap, msg_ptr),
967 SCARG(uap, msg_len), SCARG(uap, msg_prio), tsp);
968}
969
970int
971sys_mq_notify(struct mq_notify_args *uap)
972{
973 /* {
974 syscallarg(mqd_t) mqdes;
975 syscallarg(const struct sigevent *) notification;
976 } */
977 file_t *fp = NULL;
978 struct mqueue *mq;
979 struct sigevent sig;
980 int error;
981
982 if (SCARG(uap, notification)) {
983 /* Get the signal from user-space */
984 error = copyin(SCARG(uap, notification), &sig,
985 sizeof(struct sigevent));
986 if (error)
987 return error;
c8b16402
SK
988 if (sig.sigev_notify == SIGEV_SIGNAL &&
989 (sig.sigev_signo <= 0 || sig.sigev_signo >= NSIG))
990 return EINVAL;
f2df0f7c
SK
991 }
992
993 error = mqueue_get(curthread->td_lwp, SCARG(uap, mqdes), &fp);
994 if (error)
995 return error;
996 mq = fp->f_data;
997
998 if (SCARG(uap, notification)) {
999 /* Register notification: set the signal and target process */
1000 if (mq->mq_notify_proc == NULL) {
1001 memcpy(&mq->mq_sig_notify, &sig,
1002 sizeof(struct sigevent));
1003 mq->mq_notify_proc = curproc;
1004 } else {
1005 /* Fail if someone else already registered */
1006 error = EBUSY;
1007 }
1008 } else {
1009 /* Unregister the notification */
1010 mq->mq_notify_proc = NULL;
1011 }
1012 lockmgr(&mq->mq_mtx, LK_RELEASE);
1013 fdrop(fp);
1014
1015 return error;
1016}
1017
1018int
1019sys_mq_getattr(struct mq_getattr_args *uap)
1020{
1021 /* {
1022 syscallarg(mqd_t) mqdes;
1023 syscallarg(struct mq_attr *) mqstat;
1024 } */
1025 file_t *fp = NULL;
1026 struct mqueue *mq;
1027 struct mq_attr attr;
1028 int error;
1029
1030 /* Get the message queue */
766730da 1031 error = mqueue_get(curthread->td_lwp, SCARG(uap, mqdes), &fp);
f2df0f7c
SK
1032 if (error)
1033 return error;
1034 mq = fp->f_data;
1035 memcpy(&attr, &mq->mq_attrib, sizeof(struct mq_attr));
1036 lockmgr(&mq->mq_mtx, LK_RELEASE);
1037 fdrop(fp);
1038
1039 return copyout(&attr, SCARG(uap, mqstat), sizeof(struct mq_attr));
1040}
1041
1042int
1043sys_mq_setattr(struct mq_setattr_args *uap)
1044{
1045 /* {
1046 syscallarg(mqd_t) mqdes;
1047 syscallarg(const struct mq_attr *) mqstat;
1048 syscallarg(struct mq_attr *) omqstat;
1049 } */
1050 file_t *fp = NULL;
1051 struct mqueue *mq;
1052 struct mq_attr attr;
1053 int error, nonblock;
1054
1055 error = copyin(SCARG(uap, mqstat), &attr, sizeof(struct mq_attr));
1056 if (error)
1057 return error;
1058 nonblock = (attr.mq_flags & O_NONBLOCK);
1059
1060 /* Get the message queue */
766730da 1061 error = mqueue_get(curthread->td_lwp, SCARG(uap, mqdes), &fp);
f2df0f7c
SK
1062 if (error)
1063 return error;
1064 mq = fp->f_data;
1065
1066 /* Copy the old attributes, if needed */
d1d64679 1067 if (SCARG(uap, omqstat)) {
f2df0f7c 1068 memcpy(&attr, &mq->mq_attrib, sizeof(struct mq_attr));
d1d64679 1069 }
f2df0f7c
SK
1070
1071 /* Ignore everything, except O_NONBLOCK */
1072 if (nonblock)
1073 mq->mq_attrib.mq_flags |= O_NONBLOCK;
1074 else
1075 mq->mq_attrib.mq_flags &= ~O_NONBLOCK;
1076
1077 lockmgr(&mq->mq_mtx, LK_RELEASE);
1078 fdrop(fp);
1079
1080 /*
1081 * Copy the data to the user-space.
1082 * Note: According to POSIX, the new attributes should not be set in
1083 * case of fail - this would be violated.
1084 */
1085 if (SCARG(uap, omqstat))
1086 error = copyout(&attr, SCARG(uap, omqstat),
1087 sizeof(struct mq_attr));
1088
1089 return error;
1090}
1091
1092int
1093sys_mq_unlink(struct mq_unlink_args *uap)
1094{
1095 /* {
1096 syscallarg(const char *) name;
1097 } */
9910d07b 1098 struct thread *td = curthread;
f2df0f7c
SK
1099 struct mqueue *mq;
1100 char *name;
1101 int error, refcnt = 0;
1102
1103 /* Get the name from the user-space */
d3a2b23d
VS
1104 name = kmalloc(MQ_NAMELEN, M_MQBUF, M_WAITOK | M_ZERO | M_NULLOK);
1105 if (name == NULL)
1106 return (ENOMEM);
f2df0f7c
SK
1107 error = copyinstr(SCARG(uap, name), name, MQ_NAMELEN - 1, NULL);
1108 if (error) {
1109 kfree(name, M_MQBUF);
1110 return error;
1111 }
1112
1113 /* Lookup for this file */
1114 lockmgr(&mqlist_mtx, LK_EXCLUSIVE);
1115 mq = mqueue_lookup(name);
1116 if (mq == NULL) {
1117 error = ENOENT;
1118 goto error;
1119 }
1120
1121 /* Check the permissions */
9910d07b
MD
1122 if (td->td_ucred->cr_uid != mq->mq_euid &&
1123 priv_check(td, PRIV_ROOT) != 0) {
f2df0f7c
SK
1124 lockmgr(&mq->mq_mtx, LK_RELEASE);
1125 error = EACCES;
1126 goto error;
1127 }
1128
1129 /* Mark message queue as unlinking, before leaving the window */
1130 mq->mq_attrib.mq_flags |= MQ_UNLINK;
1131
1132 /* Wake up all waiters, if there are such */
1133 wakeup(&mq->mq_send_cv);
1134 wakeup(&mq->mq_recv_cv);
1135
5b22f1a7
SG
1136 KNOTE(&mq->mq_rkq.ki_note, 0);
1137 KNOTE(&mq->mq_wkq.ki_note, 0);
f2df0f7c
SK
1138
1139 refcnt = mq->mq_refcnt;
1140 if (refcnt == 0)
1141 LIST_REMOVE(mq, mq_list);
1142
1143 lockmgr(&mq->mq_mtx, LK_RELEASE);
1144error:
1145 lockmgr(&mqlist_mtx, LK_RELEASE);
1146
1147 /*
1148 * If there are no references - destroy the message
1149 * queue, otherwise, the last mq_close() will do that.
1150 */
1151 if (error == 0 && refcnt == 0)
1152 mqueue_destroy(mq);
1153
1154 kfree(name, M_MQBUF);
1155 return error;
1156}
1157
1158/*
1159 * SysCtl.
1160 */
1161SYSCTL_NODE(_kern, OID_AUTO, mqueue,
1162 CTLFLAG_RW, 0, "Message queue options");
1163
1164SYSCTL_INT(_kern_mqueue, OID_AUTO, mq_open_max,
1165 CTLFLAG_RW, &mq_open_max, 0,
1166 "Maximal number of message queue descriptors per process");
1167
1168SYSCTL_INT(_kern_mqueue, OID_AUTO, mq_prio_max,
1169 CTLFLAG_RW, &mq_prio_max, 0,
1170 "Maximal priority of the message");
1171
1172SYSCTL_INT(_kern_mqueue, OID_AUTO, mq_max_msgsize,
1173 CTLFLAG_RW, &mq_max_msgsize, 0,
1174 "Maximal allowed size of the message");
1175
1176SYSCTL_INT(_kern_mqueue, OID_AUTO, mq_def_maxmsg,
1177 CTLFLAG_RW, &mq_def_maxmsg, 0,
1178 "Default maximal message count");
1179
8658b626
SK
1180SYSCTL_INT(_kern_mqueue, OID_AUTO, mq_max_maxmsg,
1181 CTLFLAG_RW, &mq_max_maxmsg, 0,
1182 "Maximal allowed message count");
1183
f2df0f7c 1184SYSINIT(sys_mqueue_init, SI_SUB_PRE_DRIVERS, SI_ORDER_ANY, mqueue_sysinit, NULL);