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