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