1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * POSIX message queues filesystem for Linux. 4 * 5 * Copyright (C) 2003,2004 Krzysztof Benedyczak (golbi@mat.uni.torun.pl) 6 * Michal Wronski (michal.wronski@gmail.com) 7 * 8 * Spinlocks: Mohamed Abbas (abbas.mohamed@intel.com) 9 * Lockless receive & send, fd based notify: 10 * Manfred Spraul (manfred@colorfullife.com) 11 * 12 * Audit: George Wilson (ltcgcw@us.ibm.com) 13 */ 14 15 #include <linux/capability.h> 16 #include <linux/init.h> 17 #include <linux/pagemap.h> 18 #include <linux/file.h> 19 #include <linux/mount.h> 20 #include <linux/fs_context.h> 21 #include <linux/namei.h> 22 #include <linux/sysctl.h> 23 #include <linux/poll.h> 24 #include <linux/mqueue.h> 25 #include <linux/msg.h> 26 #include <linux/skbuff.h> 27 #include <linux/vmalloc.h> 28 #include <linux/netlink.h> 29 #include <linux/syscalls.h> 30 #include <linux/audit.h> 31 #include <linux/signal.h> 32 #include <linux/mutex.h> 33 #include <linux/nsproxy.h> 34 #include <linux/pid.h> 35 #include <linux/ipc_namespace.h> 36 #include <linux/user_namespace.h> 37 #include <linux/slab.h> 38 #include <linux/sched/wake_q.h> 39 #include <linux/sched/signal.h> 40 #include <linux/sched/user.h> 41 42 #include <net/sock.h> 43 #include "util.h" 44 45 struct mqueue_fs_context { 46 struct ipc_namespace *ipc_ns; 47 bool newns; /* Set if newly created ipc namespace */ 48 }; 49 50 #define MQUEUE_MAGIC 0x19800202 51 #define DIRENT_SIZE 20 52 #define FILENT_SIZE 80 53 54 #define SEND 0 55 #define RECV 1 56 57 #define STATE_NONE 0 58 #define STATE_READY 1 59 60 struct posix_msg_tree_node { 61 struct rb_node rb_node; 62 struct list_head msg_list; 63 int priority; 64 }; 65 66 /* 67 * Locking: 68 * 69 * Accesses to a message queue are synchronized by acquiring info->lock. 70 * 71 * There are two notable exceptions: 72 * - The actual wakeup of a sleeping task is performed using the wake_q 73 * framework. info->lock is already released when wake_up_q is called. 74 * - The exit codepaths after sleeping check ext_wait_queue->state without 75 * any locks. If it is STATE_READY, then the syscall is completed without 76 * acquiring info->lock. 77 * 78 * MQ_BARRIER: 79 * To achieve proper release/acquire memory barrier pairing, the state is set to 80 * STATE_READY with smp_store_release(), and it is read with READ_ONCE followed 81 * by smp_acquire__after_ctrl_dep(). In addition, wake_q_add_safe() is used. 82 * 83 * This prevents the following races: 84 * 85 * 1) With the simple wake_q_add(), the task could be gone already before 86 * the increase of the reference happens 87 * Thread A 88 * Thread B 89 * WRITE_ONCE(wait.state, STATE_NONE); 90 * schedule_hrtimeout() 91 * wake_q_add(A) 92 * if (cmpxchg()) // success 93 * ->state = STATE_READY (reordered) 94 * <timeout returns> 95 * if (wait.state == STATE_READY) return; 96 * sysret to user space 97 * sys_exit() 98 * get_task_struct() // UaF 99 * 100 * Solution: Use wake_q_add_safe() and perform the get_task_struct() before 101 * the smp_store_release() that does ->state = STATE_READY. 102 * 103 * 2) Without proper _release/_acquire barriers, the woken up task 104 * could read stale data 105 * 106 * Thread A 107 * Thread B 108 * do_mq_timedreceive 109 * WRITE_ONCE(wait.state, STATE_NONE); 110 * schedule_hrtimeout() 111 * state = STATE_READY; 112 * <timeout returns> 113 * if (wait.state == STATE_READY) return; 114 * msg_ptr = wait.msg; // Access to stale data! 115 * receiver->msg = message; (reordered) 116 * 117 * Solution: use _release and _acquire barriers. 118 * 119 * 3) There is intentionally no barrier when setting current->state 120 * to TASK_INTERRUPTIBLE: spin_unlock(&info->lock) provides the 121 * release memory barrier, and the wakeup is triggered when holding 122 * info->lock, i.e. spin_lock(&info->lock) provided a pairing 123 * acquire memory barrier. 124 */ 125 126 struct ext_wait_queue { /* queue of sleeping tasks */ 127 struct task_struct *task; 128 struct list_head list; 129 struct msg_msg *msg; /* ptr of loaded message */ 130 int state; /* one of STATE_* values */ 131 }; 132 133 struct mqueue_inode_info { 134 spinlock_t lock; 135 struct inode vfs_inode; 136 wait_queue_head_t wait_q; 137 138 struct rb_root msg_tree; 139 struct rb_node *msg_tree_rightmost; 140 struct posix_msg_tree_node *node_cache; 141 struct mq_attr attr; 142 143 struct sigevent notify; 144 struct pid *notify_owner; 145 u32 notify_self_exec_id; 146 struct user_namespace *notify_user_ns; 147 struct ucounts *ucounts; /* user who created, for accounting */ 148 struct sock *notify_sock; 149 struct sk_buff *notify_cookie; 150 151 /* for tasks waiting for free space and messages, respectively */ 152 struct ext_wait_queue e_wait_q[2]; 153 154 unsigned long qsize; /* size of queue in memory (sum of all msgs) */ 155 }; 156 157 static struct file_system_type mqueue_fs_type; 158 static const struct inode_operations mqueue_dir_inode_operations; 159 static const struct file_operations mqueue_file_operations; 160 static const struct super_operations mqueue_super_ops; 161 static const struct fs_context_operations mqueue_fs_context_ops; 162 static void remove_notification(struct mqueue_inode_info *info); 163 164 static struct kmem_cache *mqueue_inode_cachep; 165 166 static inline struct mqueue_inode_info *MQUEUE_I(struct inode *inode) 167 { 168 return container_of(inode, struct mqueue_inode_info, vfs_inode); 169 } 170 171 /* 172 * This routine should be called with the mq_lock held. 173 */ 174 static inline struct ipc_namespace *__get_ns_from_inode(struct inode *inode) 175 { 176 return get_ipc_ns(inode->i_sb->s_fs_info); 177 } 178 179 static struct ipc_namespace *get_ns_from_inode(struct inode *inode) 180 { 181 struct ipc_namespace *ns; 182 183 spin_lock(&mq_lock); 184 ns = __get_ns_from_inode(inode); 185 spin_unlock(&mq_lock); 186 return ns; 187 } 188 189 /* Auxiliary functions to manipulate messages' list */ 190 static int msg_insert(struct msg_msg *msg, struct mqueue_inode_info *info) 191 { 192 struct rb_node **p, *parent = NULL; 193 struct posix_msg_tree_node *leaf; 194 bool rightmost = true; 195 196 p = &info->msg_tree.rb_node; 197 while (*p) { 198 parent = *p; 199 leaf = rb_entry(parent, struct posix_msg_tree_node, rb_node); 200 201 if (likely(leaf->priority == msg->m_type)) 202 goto insert_msg; 203 else if (msg->m_type < leaf->priority) { 204 p = &(*p)->rb_left; 205 rightmost = false; 206 } else 207 p = &(*p)->rb_right; 208 } 209 if (info->node_cache) { 210 leaf = info->node_cache; 211 info->node_cache = NULL; 212 } else { 213 leaf = kmalloc_obj(*leaf, GFP_ATOMIC); 214 if (!leaf) 215 return -ENOMEM; 216 INIT_LIST_HEAD(&leaf->msg_list); 217 } 218 leaf->priority = msg->m_type; 219 220 if (rightmost) 221 info->msg_tree_rightmost = &leaf->rb_node; 222 223 rb_link_node(&leaf->rb_node, parent, p); 224 rb_insert_color(&leaf->rb_node, &info->msg_tree); 225 insert_msg: 226 info->attr.mq_curmsgs++; 227 info->qsize += msg->m_ts; 228 list_add_tail(&msg->m_list, &leaf->msg_list); 229 return 0; 230 } 231 232 static inline void msg_tree_erase(struct posix_msg_tree_node *leaf, 233 struct mqueue_inode_info *info) 234 { 235 struct rb_node *node = &leaf->rb_node; 236 237 if (info->msg_tree_rightmost == node) 238 info->msg_tree_rightmost = rb_prev(node); 239 240 rb_erase(node, &info->msg_tree); 241 if (info->node_cache) 242 kfree(leaf); 243 else 244 info->node_cache = leaf; 245 } 246 247 static inline struct msg_msg *msg_get(struct mqueue_inode_info *info) 248 { 249 struct rb_node *parent = NULL; 250 struct posix_msg_tree_node *leaf; 251 struct msg_msg *msg; 252 253 try_again: 254 /* 255 * During insert, low priorities go to the left and high to the 256 * right. On receive, we want the highest priorities first, so 257 * walk all the way to the right. 258 */ 259 parent = info->msg_tree_rightmost; 260 if (!parent) { 261 if (info->attr.mq_curmsgs) { 262 pr_warn_once("Inconsistency in POSIX message queue, " 263 "no tree element, but supposedly messages " 264 "should exist!\n"); 265 info->attr.mq_curmsgs = 0; 266 } 267 return NULL; 268 } 269 leaf = rb_entry(parent, struct posix_msg_tree_node, rb_node); 270 if (unlikely(list_empty(&leaf->msg_list))) { 271 pr_warn_once("Inconsistency in POSIX message queue, " 272 "empty leaf node but we haven't implemented " 273 "lazy leaf delete!\n"); 274 msg_tree_erase(leaf, info); 275 goto try_again; 276 } else { 277 msg = list_first_entry(&leaf->msg_list, 278 struct msg_msg, m_list); 279 list_del(&msg->m_list); 280 if (list_empty(&leaf->msg_list)) { 281 msg_tree_erase(leaf, info); 282 } 283 } 284 info->attr.mq_curmsgs--; 285 info->qsize -= msg->m_ts; 286 return msg; 287 } 288 289 static struct inode *mqueue_get_inode(struct super_block *sb, 290 struct ipc_namespace *ipc_ns, umode_t mode, 291 struct mq_attr *attr) 292 { 293 struct inode *inode; 294 int ret = -ENOMEM; 295 296 inode = new_inode(sb); 297 if (!inode) 298 goto err; 299 300 inode->i_ino = get_next_ino(); 301 inode->i_mode = mode; 302 inode->i_uid = current_fsuid(); 303 inode->i_gid = current_fsgid(); 304 simple_inode_init_ts(inode); 305 306 if (S_ISREG(mode)) { 307 struct mqueue_inode_info *info; 308 unsigned long mq_bytes, mq_treesize; 309 310 inode->i_fop = &mqueue_file_operations; 311 inode->i_size = FILENT_SIZE; 312 /* mqueue specific info */ 313 info = MQUEUE_I(inode); 314 spin_lock_init(&info->lock); 315 init_waitqueue_head(&info->wait_q); 316 INIT_LIST_HEAD(&info->e_wait_q[0].list); 317 INIT_LIST_HEAD(&info->e_wait_q[1].list); 318 info->notify_owner = NULL; 319 info->notify_user_ns = NULL; 320 info->qsize = 0; 321 info->ucounts = NULL; /* set when all is ok */ 322 info->msg_tree = RB_ROOT; 323 info->msg_tree_rightmost = NULL; 324 info->node_cache = NULL; 325 memset(&info->attr, 0, sizeof(info->attr)); 326 info->attr.mq_maxmsg = min(ipc_ns->mq_msg_max, 327 ipc_ns->mq_msg_default); 328 info->attr.mq_msgsize = min(ipc_ns->mq_msgsize_max, 329 ipc_ns->mq_msgsize_default); 330 if (attr) { 331 info->attr.mq_maxmsg = attr->mq_maxmsg; 332 info->attr.mq_msgsize = attr->mq_msgsize; 333 } 334 /* 335 * We used to allocate a static array of pointers and account 336 * the size of that array as well as one msg_msg struct per 337 * possible message into the queue size. That's no longer 338 * accurate as the queue is now an rbtree and will grow and 339 * shrink depending on usage patterns. We can, however, still 340 * account one msg_msg struct per message, but the nodes are 341 * allocated depending on priority usage, and most programs 342 * only use one, or a handful, of priorities. However, since 343 * this is pinned memory, we need to assume worst case, so 344 * that means the min(mq_maxmsg, max_priorities) * struct 345 * posix_msg_tree_node. 346 */ 347 348 ret = -EINVAL; 349 if (info->attr.mq_maxmsg <= 0 || info->attr.mq_msgsize <= 0) 350 goto out_inode; 351 if (capable(CAP_SYS_RESOURCE)) { 352 if (info->attr.mq_maxmsg > HARD_MSGMAX || 353 info->attr.mq_msgsize > HARD_MSGSIZEMAX) 354 goto out_inode; 355 } else { 356 if (info->attr.mq_maxmsg > ipc_ns->mq_msg_max || 357 info->attr.mq_msgsize > ipc_ns->mq_msgsize_max) 358 goto out_inode; 359 } 360 ret = -EOVERFLOW; 361 /* check for overflow */ 362 if (info->attr.mq_msgsize > ULONG_MAX/info->attr.mq_maxmsg) 363 goto out_inode; 364 mq_treesize = info->attr.mq_maxmsg * sizeof(struct msg_msg) + 365 min_t(unsigned int, info->attr.mq_maxmsg, MQ_PRIO_MAX) * 366 sizeof(struct posix_msg_tree_node); 367 mq_bytes = info->attr.mq_maxmsg * info->attr.mq_msgsize; 368 if (mq_bytes + mq_treesize < mq_bytes) 369 goto out_inode; 370 mq_bytes += mq_treesize; 371 info->ucounts = get_ucounts(current_ucounts()); 372 if (info->ucounts) { 373 long msgqueue; 374 375 spin_lock(&mq_lock); 376 msgqueue = inc_rlimit_ucounts(info->ucounts, UCOUNT_RLIMIT_MSGQUEUE, mq_bytes); 377 if (msgqueue == LONG_MAX || msgqueue > rlimit(RLIMIT_MSGQUEUE)) { 378 dec_rlimit_ucounts(info->ucounts, UCOUNT_RLIMIT_MSGQUEUE, mq_bytes); 379 spin_unlock(&mq_lock); 380 put_ucounts(info->ucounts); 381 info->ucounts = NULL; 382 /* mqueue_evict_inode() releases info->messages */ 383 ret = -EMFILE; 384 goto out_inode; 385 } 386 spin_unlock(&mq_lock); 387 } 388 } else if (S_ISDIR(mode)) { 389 inc_nlink(inode); 390 /* Some things misbehave if size == 0 on a directory */ 391 inode->i_size = 2 * DIRENT_SIZE; 392 inode->i_op = &mqueue_dir_inode_operations; 393 inode->i_fop = &simple_dir_operations; 394 } 395 396 return inode; 397 out_inode: 398 iput(inode); 399 err: 400 return ERR_PTR(ret); 401 } 402 403 static int mqueue_fill_super(struct super_block *sb, struct fs_context *fc) 404 { 405 struct inode *inode; 406 struct ipc_namespace *ns = sb->s_fs_info; 407 408 sb->s_iflags |= SB_I_NOEXEC | SB_I_NODEV; 409 sb->s_blocksize = PAGE_SIZE; 410 sb->s_blocksize_bits = PAGE_SHIFT; 411 sb->s_magic = MQUEUE_MAGIC; 412 sb->s_op = &mqueue_super_ops; 413 sb->s_d_flags = DCACHE_DONTCACHE; 414 415 inode = mqueue_get_inode(sb, ns, S_IFDIR | S_ISVTX | S_IRWXUGO, NULL); 416 if (IS_ERR(inode)) 417 return PTR_ERR(inode); 418 419 sb->s_root = d_make_root(inode); 420 if (!sb->s_root) 421 return -ENOMEM; 422 return 0; 423 } 424 425 static int mqueue_get_tree(struct fs_context *fc) 426 { 427 struct mqueue_fs_context *ctx = fc->fs_private; 428 429 /* 430 * With a newly created ipc namespace, we don't need to do a search 431 * for an ipc namespace match, but we still need to set s_fs_info. 432 */ 433 if (ctx->newns) { 434 fc->s_fs_info = ctx->ipc_ns; 435 return get_tree_nodev(fc, mqueue_fill_super); 436 } 437 return get_tree_keyed(fc, mqueue_fill_super, ctx->ipc_ns); 438 } 439 440 static void mqueue_fs_context_free(struct fs_context *fc) 441 { 442 struct mqueue_fs_context *ctx = fc->fs_private; 443 444 put_ipc_ns(ctx->ipc_ns); 445 kfree(ctx); 446 } 447 448 static int mqueue_init_fs_context(struct fs_context *fc) 449 { 450 struct mqueue_fs_context *ctx; 451 452 ctx = kzalloc_obj(struct mqueue_fs_context); 453 if (!ctx) 454 return -ENOMEM; 455 456 ctx->ipc_ns = get_ipc_ns(current->nsproxy->ipc_ns); 457 put_user_ns(fc->user_ns); 458 fc->user_ns = get_user_ns(ctx->ipc_ns->user_ns); 459 fc->fs_private = ctx; 460 fc->ops = &mqueue_fs_context_ops; 461 return 0; 462 } 463 464 /* 465 * mq_init_ns() is currently the only caller of mq_create_mount(). 466 * So the ns parameter is always a newly created ipc namespace. 467 */ 468 static struct vfsmount *mq_create_mount(struct ipc_namespace *ns) 469 { 470 struct mqueue_fs_context *ctx; 471 struct fs_context *fc; 472 struct vfsmount *mnt; 473 474 fc = fs_context_for_mount(&mqueue_fs_type, SB_KERNMOUNT); 475 if (IS_ERR(fc)) 476 return ERR_CAST(fc); 477 478 ctx = fc->fs_private; 479 ctx->newns = true; 480 put_ipc_ns(ctx->ipc_ns); 481 ctx->ipc_ns = get_ipc_ns(ns); 482 put_user_ns(fc->user_ns); 483 fc->user_ns = get_user_ns(ctx->ipc_ns->user_ns); 484 485 mnt = fc_mount_longterm(fc); 486 put_fs_context(fc); 487 return mnt; 488 } 489 490 static void init_once(void *foo) 491 { 492 struct mqueue_inode_info *p = foo; 493 494 inode_init_once(&p->vfs_inode); 495 } 496 497 static struct inode *mqueue_alloc_inode(struct super_block *sb) 498 { 499 struct mqueue_inode_info *ei; 500 501 ei = alloc_inode_sb(sb, mqueue_inode_cachep, GFP_KERNEL); 502 if (!ei) 503 return NULL; 504 return &ei->vfs_inode; 505 } 506 507 static void mqueue_free_inode(struct inode *inode) 508 { 509 kmem_cache_free(mqueue_inode_cachep, MQUEUE_I(inode)); 510 } 511 512 static void mqueue_evict_inode(struct inode *inode) 513 { 514 struct mqueue_inode_info *info; 515 struct ipc_namespace *ipc_ns; 516 struct msg_msg *msg, *nmsg; 517 LIST_HEAD(tmp_msg); 518 519 clear_inode(inode); 520 521 if (S_ISDIR(inode->i_mode)) 522 return; 523 524 ipc_ns = get_ns_from_inode(inode); 525 info = MQUEUE_I(inode); 526 spin_lock(&info->lock); 527 while ((msg = msg_get(info)) != NULL) 528 list_add_tail(&msg->m_list, &tmp_msg); 529 kfree(info->node_cache); 530 spin_unlock(&info->lock); 531 /* 532 * A shared file table can let the notification owner exit without 533 * running ->flush(). No users of the inode remain during eviction, so 534 * tear down any stale notification after dropping info->lock because 535 * netlink_sendskb() may release the final socket reference. 536 */ 537 remove_notification(info); 538 539 list_for_each_entry_safe(msg, nmsg, &tmp_msg, m_list) { 540 list_del(&msg->m_list); 541 free_msg(msg); 542 } 543 544 if (info->ucounts) { 545 unsigned long mq_bytes, mq_treesize; 546 547 /* Total amount of bytes accounted for the mqueue */ 548 mq_treesize = info->attr.mq_maxmsg * sizeof(struct msg_msg) + 549 min_t(unsigned int, info->attr.mq_maxmsg, MQ_PRIO_MAX) * 550 sizeof(struct posix_msg_tree_node); 551 552 mq_bytes = mq_treesize + (info->attr.mq_maxmsg * 553 info->attr.mq_msgsize); 554 555 spin_lock(&mq_lock); 556 dec_rlimit_ucounts(info->ucounts, UCOUNT_RLIMIT_MSGQUEUE, mq_bytes); 557 /* 558 * get_ns_from_inode() ensures that the 559 * (ipc_ns = sb->s_fs_info) is either a valid ipc_ns 560 * to which we now hold a reference, or it is NULL. 561 * We can't put it here under mq_lock, though. 562 */ 563 if (ipc_ns) 564 ipc_ns->mq_queues_count--; 565 spin_unlock(&mq_lock); 566 put_ucounts(info->ucounts); 567 info->ucounts = NULL; 568 } 569 if (ipc_ns) 570 put_ipc_ns(ipc_ns); 571 } 572 573 static int mqueue_create_attr(struct dentry *dentry, umode_t mode, void *arg) 574 { 575 struct inode *dir = dentry->d_parent->d_inode; 576 struct inode *inode; 577 struct mq_attr *attr = arg; 578 int error; 579 struct ipc_namespace *ipc_ns; 580 581 spin_lock(&mq_lock); 582 ipc_ns = __get_ns_from_inode(dir); 583 if (!ipc_ns) { 584 error = -EACCES; 585 goto out_unlock; 586 } 587 588 if (ipc_ns->mq_queues_count >= ipc_ns->mq_queues_max && 589 !capable(CAP_SYS_RESOURCE)) { 590 error = -ENOSPC; 591 goto out_unlock; 592 } 593 ipc_ns->mq_queues_count++; 594 spin_unlock(&mq_lock); 595 596 inode = mqueue_get_inode(dir->i_sb, ipc_ns, mode, attr); 597 if (IS_ERR(inode)) { 598 error = PTR_ERR(inode); 599 spin_lock(&mq_lock); 600 ipc_ns->mq_queues_count--; 601 goto out_unlock; 602 } 603 604 put_ipc_ns(ipc_ns); 605 dir->i_size += DIRENT_SIZE; 606 simple_inode_init_ts(dir); 607 608 d_make_persistent(dentry, inode); 609 return 0; 610 out_unlock: 611 spin_unlock(&mq_lock); 612 if (ipc_ns) 613 put_ipc_ns(ipc_ns); 614 return error; 615 } 616 617 static int mqueue_create(const struct mnt_idmap *idmap, struct inode *dir, 618 struct dentry *dentry, umode_t mode) 619 { 620 return mqueue_create_attr(dentry, mode, NULL); 621 } 622 623 static int mqueue_unlink(struct inode *dir, struct dentry *dentry) 624 { 625 dir->i_size -= DIRENT_SIZE; 626 return simple_unlink(dir, dentry); 627 } 628 629 /* 630 * This is routine for system read from queue file. 631 * To avoid mess with doing here some sort of mq_receive we allow 632 * to read only queue size & notification info (the only values 633 * that are interesting from user point of view and aren't accessible 634 * through std routines) 635 */ 636 static ssize_t mqueue_read_file(struct file *filp, char __user *u_data, 637 size_t count, loff_t *off) 638 { 639 struct inode *inode = file_inode(filp); 640 struct mqueue_inode_info *info = MQUEUE_I(inode); 641 char buffer[FILENT_SIZE]; 642 ssize_t ret; 643 644 spin_lock(&info->lock); 645 snprintf(buffer, sizeof(buffer), 646 "QSIZE:%-10lu NOTIFY:%-5d SIGNO:%-5d NOTIFY_PID:%-6d\n", 647 info->qsize, 648 info->notify_owner ? info->notify.sigev_notify : 0, 649 (info->notify_owner && 650 info->notify.sigev_notify == SIGEV_SIGNAL) ? 651 info->notify.sigev_signo : 0, 652 pid_vnr(info->notify_owner)); 653 spin_unlock(&info->lock); 654 buffer[sizeof(buffer)-1] = '\0'; 655 656 ret = simple_read_from_buffer(u_data, count, off, buffer, 657 strlen(buffer)); 658 if (ret <= 0) 659 return ret; 660 661 inode_set_atime_to_ts(inode, inode_set_ctime_current(inode)); 662 return ret; 663 } 664 665 static int mqueue_flush_file(struct file *filp, fl_owner_t id) 666 { 667 struct mqueue_inode_info *info = MQUEUE_I(file_inode(filp)); 668 669 spin_lock(&info->lock); 670 if (task_tgid(current) == info->notify_owner) 671 remove_notification(info); 672 673 spin_unlock(&info->lock); 674 return 0; 675 } 676 677 static __poll_t mqueue_poll_file(struct file *filp, struct poll_table_struct *poll_tab) 678 { 679 struct mqueue_inode_info *info = MQUEUE_I(file_inode(filp)); 680 __poll_t retval = 0; 681 682 poll_wait(filp, &info->wait_q, poll_tab); 683 684 spin_lock(&info->lock); 685 if (info->attr.mq_curmsgs) 686 retval = EPOLLIN | EPOLLRDNORM; 687 688 if (info->attr.mq_curmsgs < info->attr.mq_maxmsg) 689 retval |= EPOLLOUT | EPOLLWRNORM; 690 spin_unlock(&info->lock); 691 692 return retval; 693 } 694 695 /* Adds current to info->e_wait_q[sr] before element with smaller prio */ 696 static void wq_add(struct mqueue_inode_info *info, int sr, 697 struct ext_wait_queue *ewp) 698 { 699 struct ext_wait_queue *walk; 700 701 list_for_each_entry(walk, &info->e_wait_q[sr].list, list) { 702 if (walk->task->prio <= current->prio) { 703 list_add_tail(&ewp->list, &walk->list); 704 return; 705 } 706 } 707 list_add_tail(&ewp->list, &info->e_wait_q[sr].list); 708 } 709 710 /* 711 * Puts current task to sleep. Caller must hold queue lock. After return 712 * lock isn't held. 713 * sr: SEND or RECV 714 */ 715 static int wq_sleep(struct mqueue_inode_info *info, int sr, 716 ktime_t *timeout, struct ext_wait_queue *ewp) 717 __releases(&info->lock) 718 { 719 int retval; 720 signed long time; 721 722 wq_add(info, sr, ewp); 723 724 for (;;) { 725 /* memory barrier not required, we hold info->lock */ 726 __set_current_state(TASK_INTERRUPTIBLE); 727 728 spin_unlock(&info->lock); 729 time = schedule_hrtimeout_range_clock(timeout, 0, 730 HRTIMER_MODE_ABS, CLOCK_REALTIME); 731 732 if (READ_ONCE(ewp->state) == STATE_READY) { 733 /* see MQ_BARRIER for purpose/pairing */ 734 smp_acquire__after_ctrl_dep(); 735 retval = 0; 736 goto out; 737 } 738 spin_lock(&info->lock); 739 740 /* we hold info->lock, so no memory barrier required */ 741 if (READ_ONCE(ewp->state) == STATE_READY) { 742 retval = 0; 743 goto out_unlock; 744 } 745 if (signal_pending(current)) { 746 retval = -ERESTARTSYS; 747 break; 748 } 749 if (time == 0) { 750 retval = -ETIMEDOUT; 751 break; 752 } 753 } 754 list_del(&ewp->list); 755 out_unlock: 756 spin_unlock(&info->lock); 757 out: 758 return retval; 759 } 760 761 /* 762 * Returns waiting task that should be serviced first or NULL if none exists 763 */ 764 static struct ext_wait_queue *wq_get_first_waiter( 765 struct mqueue_inode_info *info, int sr) 766 { 767 struct list_head *ptr; 768 769 ptr = info->e_wait_q[sr].list.prev; 770 if (ptr == &info->e_wait_q[sr].list) 771 return NULL; 772 return list_entry(ptr, struct ext_wait_queue, list); 773 } 774 775 776 static inline void set_cookie(struct sk_buff *skb, char code) 777 { 778 ((char *)skb->data)[NOTIFY_COOKIE_LEN-1] = code; 779 } 780 781 /* 782 * The next function is only to split too long sys_mq_timedsend 783 */ 784 static void __do_notify(struct mqueue_inode_info *info) 785 { 786 /* notification 787 * invoked when there is registered process and there isn't process 788 * waiting synchronously for message AND state of queue changed from 789 * empty to not empty. Here we are sure that no one is waiting 790 * synchronously. */ 791 if (info->notify_owner && 792 info->attr.mq_curmsgs == 1) { 793 switch (info->notify.sigev_notify) { 794 case SIGEV_NONE: 795 break; 796 case SIGEV_SIGNAL: { 797 struct kernel_siginfo sig_i; 798 struct task_struct *task; 799 800 if (!info->notify.sigev_signo) 801 break; 802 803 clear_siginfo(&sig_i); 804 sig_i.si_signo = info->notify.sigev_signo; 805 sig_i.si_errno = 0; 806 sig_i.si_code = SI_MESGQ; 807 sig_i.si_value = info->notify.sigev_value; 808 rcu_read_lock(); 809 /* map current pid/uid into info->owner's namespaces */ 810 sig_i.si_pid = task_tgid_nr_ns(current, 811 ns_of_pid(info->notify_owner)); 812 sig_i.si_uid = from_kuid_munged(info->notify_user_ns, 813 current_uid()); 814 /* 815 * We can't use kill_pid_info(), this signal should 816 * bypass check_kill_permission(). It is from kernel 817 * but si_fromuser() can't know this. 818 * We do check the self_exec_id, to avoid sending 819 * signals to programs that don't expect them. 820 */ 821 task = pid_task(info->notify_owner, PIDTYPE_TGID); 822 if (task && task->self_exec_id == 823 info->notify_self_exec_id) { 824 do_send_sig_info(info->notify.sigev_signo, 825 &sig_i, task, PIDTYPE_TGID); 826 } 827 rcu_read_unlock(); 828 break; 829 } 830 case SIGEV_THREAD: 831 set_cookie(info->notify_cookie, NOTIFY_WOKENUP); 832 netlink_sendskb(info->notify_sock, info->notify_cookie); 833 break; 834 } 835 /* after notification unregisters process */ 836 put_pid(info->notify_owner); 837 put_user_ns(info->notify_user_ns); 838 info->notify_owner = NULL; 839 info->notify_user_ns = NULL; 840 } 841 wake_up(&info->wait_q); 842 } 843 844 static int prepare_timeout(const struct __kernel_timespec __user *u_abs_timeout, 845 struct timespec64 *ts) 846 { 847 if (get_timespec64(ts, u_abs_timeout)) 848 return -EFAULT; 849 if (!timespec64_valid(ts)) 850 return -EINVAL; 851 return 0; 852 } 853 854 static void remove_notification(struct mqueue_inode_info *info) 855 { 856 if (info->notify_owner != NULL && 857 info->notify.sigev_notify == SIGEV_THREAD) { 858 set_cookie(info->notify_cookie, NOTIFY_REMOVED); 859 netlink_sendskb(info->notify_sock, info->notify_cookie); 860 } 861 put_pid(info->notify_owner); 862 put_user_ns(info->notify_user_ns); 863 info->notify_owner = NULL; 864 info->notify_user_ns = NULL; 865 } 866 867 static int prepare_open(struct dentry *dentry, int oflag, int ro, 868 umode_t mode, struct filename *name, 869 struct mq_attr *attr) 870 { 871 static const int oflag2acc[O_ACCMODE] = { MAY_READ, MAY_WRITE, 872 MAY_READ | MAY_WRITE }; 873 int acc; 874 875 if (d_really_is_negative(dentry)) { 876 if (!(oflag & O_CREAT)) 877 return -ENOENT; 878 if (ro) 879 return ro; 880 audit_inode_parent_hidden(name, dentry->d_parent); 881 return vfs_mkobj(dentry, mode & ~current_umask(), 882 mqueue_create_attr, attr); 883 } 884 /* it already existed */ 885 audit_inode(name, dentry, 0); 886 if ((oflag & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL)) 887 return -EEXIST; 888 if ((oflag & O_ACCMODE) == (O_RDWR | O_WRONLY)) 889 return -EINVAL; 890 acc = oflag2acc[oflag & O_ACCMODE]; 891 return inode_permission(&nop_mnt_idmap, d_inode(dentry), acc); 892 } 893 894 static struct file *mqueue_file_open(struct filename *name, 895 struct vfsmount *mnt, int oflag, int ro, 896 umode_t mode, struct mq_attr *attr) 897 { 898 struct dentry *dentry; 899 struct file *file; 900 int ret; 901 902 dentry = start_creating_noperm(mnt->mnt_root, &QSTR(name->name)); 903 if (IS_ERR(dentry)) 904 return ERR_CAST(dentry); 905 906 ret = prepare_open(dentry, oflag, ro, mode, name, attr); 907 file = ERR_PTR(ret); 908 if (!ret) { 909 const struct path path = { .mnt = mnt, .dentry = dentry }; 910 file = dentry_open(&path, oflag, current_cred()); 911 } 912 913 end_creating(dentry); 914 return file; 915 } 916 917 static int do_mq_open(const char __user *u_name, int oflag, umode_t mode, 918 struct mq_attr *attr) 919 { 920 struct vfsmount *mnt = current->nsproxy->ipc_ns->mq_mnt; 921 int fd, ro; 922 923 audit_mq_open(oflag, mode, attr); 924 925 CLASS(filename, name)(u_name); 926 if (IS_ERR(name)) 927 return PTR_ERR(name); 928 929 ro = mnt_want_write(mnt); /* we'll drop it in any case */ 930 fd = FD_ADD(O_CLOEXEC, mqueue_file_open(name, mnt, oflag, ro, mode, attr)); 931 if (!ro) 932 mnt_drop_write(mnt); 933 return fd; 934 } 935 936 SYSCALL_DEFINE4(mq_open, const char __user *, u_name, int, oflag, umode_t, mode, 937 struct mq_attr __user *, u_attr) 938 { 939 struct mq_attr attr; 940 if (u_attr && copy_from_user(&attr, u_attr, sizeof(struct mq_attr))) 941 return -EFAULT; 942 943 return do_mq_open(u_name, oflag, mode, u_attr ? &attr : NULL); 944 } 945 946 SYSCALL_DEFINE1(mq_unlink, const char __user *, u_name) 947 { 948 int err; 949 struct dentry *dentry; 950 struct inode *inode; 951 struct ipc_namespace *ipc_ns = current->nsproxy->ipc_ns; 952 struct vfsmount *mnt = ipc_ns->mq_mnt; 953 CLASS(filename, name)(u_name); 954 955 if (IS_ERR(name)) 956 return PTR_ERR(name); 957 958 audit_inode_parent_hidden(name, mnt->mnt_root); 959 err = mnt_want_write(mnt); 960 if (err) 961 return err; 962 dentry = start_removing_noperm(mnt->mnt_root, &QSTR(name->name)); 963 if (IS_ERR(dentry)) { 964 err = PTR_ERR(dentry); 965 goto out_drop_write; 966 } 967 968 inode = d_inode(dentry); 969 ihold(inode); 970 err = vfs_unlink(&nop_mnt_idmap, d_inode(mnt->mnt_root), 971 dentry, NULL); 972 end_removing(dentry); 973 iput(inode); 974 975 out_drop_write: 976 mnt_drop_write(mnt); 977 return err; 978 } 979 980 /* Pipelined send and receive functions. 981 * 982 * If a receiver finds no waiting message, then it registers itself in the 983 * list of waiting receivers. A sender checks that list before adding the new 984 * message into the message array. If there is a waiting receiver, then it 985 * bypasses the message array and directly hands the message over to the 986 * receiver. The receiver accepts the message and returns without grabbing the 987 * queue spinlock: 988 * 989 * - Set pointer to message. 990 * - Queue the receiver task for later wakeup (without the info->lock). 991 * - Update its state to STATE_READY. Now the receiver can continue. 992 * - Wake up the process after the lock is dropped. Should the process wake up 993 * before this wakeup (due to a timeout or a signal) it will either see 994 * STATE_READY and continue or acquire the lock to check the state again. 995 * 996 * The same algorithm is used for senders. 997 */ 998 999 static inline void __pipelined_op(struct wake_q_head *wake_q, 1000 struct mqueue_inode_info *info, 1001 struct ext_wait_queue *this) 1002 { 1003 struct task_struct *task; 1004 1005 list_del(&this->list); 1006 task = get_task_struct(this->task); 1007 1008 /* see MQ_BARRIER for purpose/pairing */ 1009 smp_store_release(&this->state, STATE_READY); 1010 wake_q_add_safe(wake_q, task); 1011 } 1012 1013 /* pipelined_send() - send a message directly to the task waiting in 1014 * sys_mq_timedreceive() (without inserting message into a queue). 1015 */ 1016 static inline void pipelined_send(struct wake_q_head *wake_q, 1017 struct mqueue_inode_info *info, 1018 struct msg_msg *message, 1019 struct ext_wait_queue *receiver) 1020 { 1021 receiver->msg = message; 1022 __pipelined_op(wake_q, info, receiver); 1023 } 1024 1025 /* pipelined_receive() - if there is task waiting in sys_mq_timedsend() 1026 * gets its message and put to the queue (we have one free place for sure). */ 1027 static inline void pipelined_receive(struct wake_q_head *wake_q, 1028 struct mqueue_inode_info *info) 1029 { 1030 struct ext_wait_queue *sender = wq_get_first_waiter(info, SEND); 1031 1032 if (!sender) { 1033 /* for poll */ 1034 wake_up_interruptible(&info->wait_q); 1035 return; 1036 } 1037 if (msg_insert(sender->msg, info)) 1038 return; 1039 1040 __pipelined_op(wake_q, info, sender); 1041 } 1042 1043 static int do_mq_timedsend(mqd_t mqdes, const char __user *u_msg_ptr, 1044 size_t msg_len, unsigned int msg_prio, 1045 struct timespec64 *ts) 1046 { 1047 struct inode *inode; 1048 struct ext_wait_queue wait; 1049 struct ext_wait_queue *receiver; 1050 struct msg_msg *msg_ptr; 1051 struct mqueue_inode_info *info; 1052 ktime_t expires, *timeout = NULL; 1053 struct posix_msg_tree_node *new_leaf = NULL; 1054 int ret = 0; 1055 DEFINE_WAKE_Q(wake_q); 1056 1057 if (unlikely(msg_prio >= (unsigned long) MQ_PRIO_MAX)) 1058 return -EINVAL; 1059 1060 if (ts) { 1061 expires = timespec64_to_ktime(*ts); 1062 timeout = &expires; 1063 } 1064 1065 audit_mq_sendrecv(mqdes, msg_len, msg_prio, ts); 1066 1067 CLASS(fd, f)(mqdes); 1068 if (fd_empty(f)) 1069 return -EBADF; 1070 1071 inode = file_inode(fd_file(f)); 1072 if (unlikely(fd_file(f)->f_op != &mqueue_file_operations)) 1073 return -EBADF; 1074 info = MQUEUE_I(inode); 1075 audit_file(fd_file(f)); 1076 1077 if (unlikely(!(fd_file(f)->f_mode & FMODE_WRITE))) 1078 return -EBADF; 1079 1080 if (unlikely(msg_len > info->attr.mq_msgsize)) 1081 return -EMSGSIZE; 1082 1083 /* First try to allocate memory, before doing anything with 1084 * existing queues. */ 1085 msg_ptr = load_msg(u_msg_ptr, msg_len); 1086 if (IS_ERR(msg_ptr)) 1087 return PTR_ERR(msg_ptr); 1088 msg_ptr->m_ts = msg_len; 1089 msg_ptr->m_type = msg_prio; 1090 1091 /* 1092 * msg_insert really wants us to have a valid, spare node struct so 1093 * it doesn't have to kmalloc a GFP_ATOMIC allocation, but it will 1094 * fall back to that if necessary. 1095 */ 1096 if (!info->node_cache) 1097 new_leaf = kmalloc_obj(*new_leaf); 1098 1099 spin_lock(&info->lock); 1100 1101 if (!info->node_cache && new_leaf) { 1102 /* Save our speculative allocation into the cache */ 1103 INIT_LIST_HEAD(&new_leaf->msg_list); 1104 info->node_cache = new_leaf; 1105 new_leaf = NULL; 1106 } else { 1107 kfree(new_leaf); 1108 } 1109 1110 if (info->attr.mq_curmsgs == info->attr.mq_maxmsg) { 1111 if (fd_file(f)->f_flags & O_NONBLOCK) { 1112 ret = -EAGAIN; 1113 } else { 1114 wait.task = current; 1115 wait.msg = (void *) msg_ptr; 1116 1117 /* memory barrier not required, we hold info->lock */ 1118 WRITE_ONCE(wait.state, STATE_NONE); 1119 ret = wq_sleep(info, SEND, timeout, &wait); 1120 /* 1121 * wq_sleep must be called with info->lock held, and 1122 * returns with the lock released 1123 */ 1124 goto out_free; 1125 } 1126 } else { 1127 receiver = wq_get_first_waiter(info, RECV); 1128 if (receiver) { 1129 pipelined_send(&wake_q, info, msg_ptr, receiver); 1130 } else { 1131 /* adds message to the queue */ 1132 ret = msg_insert(msg_ptr, info); 1133 if (ret) 1134 goto out_unlock; 1135 __do_notify(info); 1136 } 1137 simple_inode_init_ts(inode); 1138 } 1139 out_unlock: 1140 spin_unlock(&info->lock); 1141 wake_up_q(&wake_q); 1142 out_free: 1143 if (ret) 1144 free_msg(msg_ptr); 1145 return ret; 1146 } 1147 1148 static int do_mq_timedreceive(mqd_t mqdes, char __user *u_msg_ptr, 1149 size_t msg_len, unsigned int __user *u_msg_prio, 1150 struct timespec64 *ts) 1151 { 1152 ssize_t ret; 1153 struct msg_msg *msg_ptr; 1154 struct inode *inode; 1155 struct mqueue_inode_info *info; 1156 struct ext_wait_queue wait; 1157 ktime_t expires, *timeout = NULL; 1158 struct posix_msg_tree_node *new_leaf = NULL; 1159 1160 if (ts) { 1161 expires = timespec64_to_ktime(*ts); 1162 timeout = &expires; 1163 } 1164 1165 audit_mq_sendrecv(mqdes, msg_len, 0, ts); 1166 1167 CLASS(fd, f)(mqdes); 1168 if (fd_empty(f)) 1169 return -EBADF; 1170 1171 inode = file_inode(fd_file(f)); 1172 if (unlikely(fd_file(f)->f_op != &mqueue_file_operations)) 1173 return -EBADF; 1174 info = MQUEUE_I(inode); 1175 audit_file(fd_file(f)); 1176 1177 if (unlikely(!(fd_file(f)->f_mode & FMODE_READ))) 1178 return -EBADF; 1179 1180 /* checks if buffer is big enough */ 1181 if (unlikely(msg_len < info->attr.mq_msgsize)) 1182 return -EMSGSIZE; 1183 1184 /* 1185 * msg_insert really wants us to have a valid, spare node struct so 1186 * it doesn't have to kmalloc a GFP_ATOMIC allocation, but it will 1187 * fall back to that if necessary. 1188 */ 1189 if (!info->node_cache) 1190 new_leaf = kmalloc_obj(*new_leaf); 1191 1192 spin_lock(&info->lock); 1193 1194 if (!info->node_cache && new_leaf) { 1195 /* Save our speculative allocation into the cache */ 1196 INIT_LIST_HEAD(&new_leaf->msg_list); 1197 info->node_cache = new_leaf; 1198 } else { 1199 kfree(new_leaf); 1200 } 1201 1202 if (info->attr.mq_curmsgs == 0) { 1203 if (fd_file(f)->f_flags & O_NONBLOCK) { 1204 spin_unlock(&info->lock); 1205 ret = -EAGAIN; 1206 } else { 1207 wait.task = current; 1208 1209 /* memory barrier not required, we hold info->lock */ 1210 WRITE_ONCE(wait.state, STATE_NONE); 1211 ret = wq_sleep(info, RECV, timeout, &wait); 1212 msg_ptr = wait.msg; 1213 } 1214 } else { 1215 DEFINE_WAKE_Q(wake_q); 1216 1217 msg_ptr = msg_get(info); 1218 1219 simple_inode_init_ts(inode); 1220 1221 /* There is now free space in queue. */ 1222 pipelined_receive(&wake_q, info); 1223 spin_unlock(&info->lock); 1224 wake_up_q(&wake_q); 1225 ret = 0; 1226 } 1227 if (ret == 0) { 1228 ret = msg_ptr->m_ts; 1229 1230 if ((u_msg_prio && put_user(msg_ptr->m_type, u_msg_prio)) || 1231 store_msg(u_msg_ptr, msg_ptr, msg_ptr->m_ts)) { 1232 ret = -EFAULT; 1233 } 1234 free_msg(msg_ptr); 1235 } 1236 return ret; 1237 } 1238 1239 SYSCALL_DEFINE5(mq_timedsend, mqd_t, mqdes, const char __user *, u_msg_ptr, 1240 size_t, msg_len, unsigned int, msg_prio, 1241 const struct __kernel_timespec __user *, u_abs_timeout) 1242 { 1243 struct timespec64 ts, *p = NULL; 1244 if (u_abs_timeout) { 1245 int res = prepare_timeout(u_abs_timeout, &ts); 1246 if (res) 1247 return res; 1248 p = &ts; 1249 } 1250 return do_mq_timedsend(mqdes, u_msg_ptr, msg_len, msg_prio, p); 1251 } 1252 1253 SYSCALL_DEFINE5(mq_timedreceive, mqd_t, mqdes, char __user *, u_msg_ptr, 1254 size_t, msg_len, unsigned int __user *, u_msg_prio, 1255 const struct __kernel_timespec __user *, u_abs_timeout) 1256 { 1257 struct timespec64 ts, *p = NULL; 1258 if (u_abs_timeout) { 1259 int res = prepare_timeout(u_abs_timeout, &ts); 1260 if (res) 1261 return res; 1262 p = &ts; 1263 } 1264 return do_mq_timedreceive(mqdes, u_msg_ptr, msg_len, u_msg_prio, p); 1265 } 1266 1267 /* 1268 * Notes: the case when user wants us to deregister (with NULL as pointer) 1269 * and he isn't currently owner of notification, will be silently discarded. 1270 * It isn't explicitly defined in the POSIX. 1271 */ 1272 static int do_mq_notify(mqd_t mqdes, const struct sigevent *notification) 1273 { 1274 int ret; 1275 struct sock *sock; 1276 struct inode *inode; 1277 struct mqueue_inode_info *info; 1278 struct sk_buff *nc; 1279 1280 audit_mq_notify(mqdes, notification); 1281 1282 nc = NULL; 1283 sock = NULL; 1284 if (notification != NULL) { 1285 if (unlikely(notification->sigev_notify != SIGEV_NONE && 1286 notification->sigev_notify != SIGEV_SIGNAL && 1287 notification->sigev_notify != SIGEV_THREAD)) 1288 return -EINVAL; 1289 if (notification->sigev_notify == SIGEV_SIGNAL && 1290 (!notification->sigev_signo || 1291 !valid_signal(notification->sigev_signo))) 1292 return -EINVAL; 1293 if (notification->sigev_notify == SIGEV_THREAD) { 1294 long timeo; 1295 1296 /* create the notify skb */ 1297 nc = alloc_skb(NOTIFY_COOKIE_LEN, GFP_KERNEL); 1298 if (!nc) 1299 return -ENOMEM; 1300 1301 if (copy_from_user(nc->data, 1302 notification->sigev_value.sival_ptr, 1303 NOTIFY_COOKIE_LEN)) { 1304 kfree_skb(nc); 1305 return -EFAULT; 1306 } 1307 1308 /* TODO: add a header? */ 1309 skb_put(nc, NOTIFY_COOKIE_LEN); 1310 /* and attach it to the socket */ 1311 retry: 1312 sock = netlink_getsockbyfd(notification->sigev_signo); 1313 if (IS_ERR(sock)) { 1314 kfree_skb(nc); 1315 return PTR_ERR(sock); 1316 } 1317 1318 timeo = MAX_SCHEDULE_TIMEOUT; 1319 ret = netlink_attachskb(sock, nc, &timeo, NULL); 1320 if (ret == 1) 1321 goto retry; 1322 if (ret) 1323 return ret; 1324 } 1325 } 1326 1327 CLASS(fd, f)(mqdes); 1328 if (fd_empty(f)) { 1329 ret = -EBADF; 1330 goto out; 1331 } 1332 1333 inode = file_inode(fd_file(f)); 1334 if (unlikely(fd_file(f)->f_op != &mqueue_file_operations)) { 1335 ret = -EBADF; 1336 goto out; 1337 } 1338 info = MQUEUE_I(inode); 1339 1340 ret = 0; 1341 spin_lock(&info->lock); 1342 if (notification == NULL) { 1343 if (info->notify_owner == task_tgid(current)) { 1344 remove_notification(info); 1345 inode_set_atime_to_ts(inode, 1346 inode_set_ctime_current(inode)); 1347 } 1348 } else if (info->notify_owner != NULL) { 1349 ret = -EBUSY; 1350 } else { 1351 switch (notification->sigev_notify) { 1352 case SIGEV_NONE: 1353 info->notify.sigev_notify = SIGEV_NONE; 1354 break; 1355 case SIGEV_THREAD: 1356 info->notify_sock = sock; 1357 info->notify_cookie = nc; 1358 sock = NULL; 1359 nc = NULL; 1360 info->notify.sigev_notify = SIGEV_THREAD; 1361 break; 1362 case SIGEV_SIGNAL: 1363 info->notify.sigev_signo = notification->sigev_signo; 1364 info->notify.sigev_value = notification->sigev_value; 1365 info->notify.sigev_notify = SIGEV_SIGNAL; 1366 info->notify_self_exec_id = current->self_exec_id; 1367 break; 1368 } 1369 1370 info->notify_owner = get_pid(task_tgid(current)); 1371 info->notify_user_ns = get_user_ns(current_user_ns()); 1372 inode_set_atime_to_ts(inode, inode_set_ctime_current(inode)); 1373 } 1374 spin_unlock(&info->lock); 1375 out: 1376 if (sock) 1377 netlink_detachskb(sock, nc); 1378 return ret; 1379 } 1380 1381 SYSCALL_DEFINE2(mq_notify, mqd_t, mqdes, 1382 const struct sigevent __user *, u_notification) 1383 { 1384 struct sigevent n, *p = NULL; 1385 if (u_notification) { 1386 if (copy_from_user(&n, u_notification, sizeof(struct sigevent))) 1387 return -EFAULT; 1388 p = &n; 1389 } 1390 return do_mq_notify(mqdes, p); 1391 } 1392 1393 static int do_mq_getsetattr(int mqdes, struct mq_attr *new, struct mq_attr *old) 1394 { 1395 struct inode *inode; 1396 struct mqueue_inode_info *info; 1397 1398 if (new && (new->mq_flags & (~O_NONBLOCK))) 1399 return -EINVAL; 1400 1401 CLASS(fd, f)(mqdes); 1402 if (fd_empty(f)) 1403 return -EBADF; 1404 1405 if (unlikely(fd_file(f)->f_op != &mqueue_file_operations)) 1406 return -EBADF; 1407 1408 inode = file_inode(fd_file(f)); 1409 info = MQUEUE_I(inode); 1410 1411 spin_lock(&info->lock); 1412 1413 if (old) { 1414 *old = info->attr; 1415 old->mq_flags = fd_file(f)->f_flags & O_NONBLOCK; 1416 } 1417 if (new) { 1418 audit_mq_getsetattr(mqdes, new); 1419 spin_lock(&fd_file(f)->f_lock); 1420 if (new->mq_flags & O_NONBLOCK) 1421 fd_file(f)->f_flags |= O_NONBLOCK; 1422 else 1423 fd_file(f)->f_flags &= ~O_NONBLOCK; 1424 spin_unlock(&fd_file(f)->f_lock); 1425 1426 inode_set_atime_to_ts(inode, inode_set_ctime_current(inode)); 1427 } 1428 1429 spin_unlock(&info->lock); 1430 return 0; 1431 } 1432 1433 SYSCALL_DEFINE3(mq_getsetattr, mqd_t, mqdes, 1434 const struct mq_attr __user *, u_mqstat, 1435 struct mq_attr __user *, u_omqstat) 1436 { 1437 int ret; 1438 struct mq_attr mqstat, omqstat; 1439 struct mq_attr *new = NULL, *old = NULL; 1440 1441 if (u_mqstat) { 1442 new = &mqstat; 1443 if (copy_from_user(new, u_mqstat, sizeof(struct mq_attr))) 1444 return -EFAULT; 1445 } 1446 if (u_omqstat) 1447 old = &omqstat; 1448 1449 ret = do_mq_getsetattr(mqdes, new, old); 1450 if (ret || !old) 1451 return ret; 1452 1453 if (copy_to_user(u_omqstat, old, sizeof(struct mq_attr))) 1454 return -EFAULT; 1455 return 0; 1456 } 1457 1458 #ifdef CONFIG_COMPAT 1459 1460 struct compat_mq_attr { 1461 compat_long_t mq_flags; /* message queue flags */ 1462 compat_long_t mq_maxmsg; /* maximum number of messages */ 1463 compat_long_t mq_msgsize; /* maximum message size */ 1464 compat_long_t mq_curmsgs; /* number of messages currently queued */ 1465 compat_long_t __reserved[4]; /* ignored for input, zeroed for output */ 1466 }; 1467 1468 static inline int get_compat_mq_attr(struct mq_attr *attr, 1469 const struct compat_mq_attr __user *uattr) 1470 { 1471 struct compat_mq_attr v; 1472 1473 if (copy_from_user(&v, uattr, sizeof(*uattr))) 1474 return -EFAULT; 1475 1476 memset(attr, 0, sizeof(*attr)); 1477 attr->mq_flags = v.mq_flags; 1478 attr->mq_maxmsg = v.mq_maxmsg; 1479 attr->mq_msgsize = v.mq_msgsize; 1480 attr->mq_curmsgs = v.mq_curmsgs; 1481 return 0; 1482 } 1483 1484 static inline int put_compat_mq_attr(const struct mq_attr *attr, 1485 struct compat_mq_attr __user *uattr) 1486 { 1487 struct compat_mq_attr v; 1488 1489 memset(&v, 0, sizeof(v)); 1490 v.mq_flags = attr->mq_flags; 1491 v.mq_maxmsg = attr->mq_maxmsg; 1492 v.mq_msgsize = attr->mq_msgsize; 1493 v.mq_curmsgs = attr->mq_curmsgs; 1494 if (copy_to_user(uattr, &v, sizeof(*uattr))) 1495 return -EFAULT; 1496 return 0; 1497 } 1498 1499 COMPAT_SYSCALL_DEFINE4(mq_open, const char __user *, u_name, 1500 int, oflag, compat_mode_t, mode, 1501 struct compat_mq_attr __user *, u_attr) 1502 { 1503 struct mq_attr attr, *p = NULL; 1504 if (u_attr && oflag & O_CREAT) { 1505 p = &attr; 1506 if (get_compat_mq_attr(&attr, u_attr)) 1507 return -EFAULT; 1508 } 1509 return do_mq_open(u_name, oflag, mode, p); 1510 } 1511 1512 COMPAT_SYSCALL_DEFINE2(mq_notify, mqd_t, mqdes, 1513 const struct compat_sigevent __user *, u_notification) 1514 { 1515 struct sigevent n, *p = NULL; 1516 if (u_notification) { 1517 if (get_compat_sigevent(&n, u_notification)) 1518 return -EFAULT; 1519 if (n.sigev_notify == SIGEV_THREAD) 1520 n.sigev_value.sival_ptr = compat_ptr(n.sigev_value.sival_int); 1521 p = &n; 1522 } 1523 return do_mq_notify(mqdes, p); 1524 } 1525 1526 COMPAT_SYSCALL_DEFINE3(mq_getsetattr, mqd_t, mqdes, 1527 const struct compat_mq_attr __user *, u_mqstat, 1528 struct compat_mq_attr __user *, u_omqstat) 1529 { 1530 int ret; 1531 struct mq_attr mqstat, omqstat; 1532 struct mq_attr *new = NULL, *old = NULL; 1533 1534 if (u_mqstat) { 1535 new = &mqstat; 1536 if (get_compat_mq_attr(new, u_mqstat)) 1537 return -EFAULT; 1538 } 1539 if (u_omqstat) 1540 old = &omqstat; 1541 1542 ret = do_mq_getsetattr(mqdes, new, old); 1543 if (ret || !old) 1544 return ret; 1545 1546 if (put_compat_mq_attr(old, u_omqstat)) 1547 return -EFAULT; 1548 return 0; 1549 } 1550 #endif 1551 1552 #ifdef CONFIG_COMPAT_32BIT_TIME 1553 static int compat_prepare_timeout(const struct old_timespec32 __user *p, 1554 struct timespec64 *ts) 1555 { 1556 if (get_old_timespec32(ts, p)) 1557 return -EFAULT; 1558 if (!timespec64_valid(ts)) 1559 return -EINVAL; 1560 return 0; 1561 } 1562 1563 SYSCALL_DEFINE5(mq_timedsend_time32, mqd_t, mqdes, 1564 const char __user *, u_msg_ptr, 1565 unsigned int, msg_len, unsigned int, msg_prio, 1566 const struct old_timespec32 __user *, u_abs_timeout) 1567 { 1568 struct timespec64 ts, *p = NULL; 1569 if (u_abs_timeout) { 1570 int res = compat_prepare_timeout(u_abs_timeout, &ts); 1571 if (res) 1572 return res; 1573 p = &ts; 1574 } 1575 return do_mq_timedsend(mqdes, u_msg_ptr, msg_len, msg_prio, p); 1576 } 1577 1578 SYSCALL_DEFINE5(mq_timedreceive_time32, mqd_t, mqdes, 1579 char __user *, u_msg_ptr, 1580 unsigned int, msg_len, unsigned int __user *, u_msg_prio, 1581 const struct old_timespec32 __user *, u_abs_timeout) 1582 { 1583 struct timespec64 ts, *p = NULL; 1584 if (u_abs_timeout) { 1585 int res = compat_prepare_timeout(u_abs_timeout, &ts); 1586 if (res) 1587 return res; 1588 p = &ts; 1589 } 1590 return do_mq_timedreceive(mqdes, u_msg_ptr, msg_len, u_msg_prio, p); 1591 } 1592 #endif 1593 1594 static const struct inode_operations mqueue_dir_inode_operations = { 1595 .lookup = simple_lookup, 1596 .create = mqueue_create, 1597 .unlink = mqueue_unlink, 1598 }; 1599 1600 static const struct file_operations mqueue_file_operations = { 1601 .flush = mqueue_flush_file, 1602 .poll = mqueue_poll_file, 1603 .read = mqueue_read_file, 1604 .llseek = default_llseek, 1605 }; 1606 1607 static const struct super_operations mqueue_super_ops = { 1608 .alloc_inode = mqueue_alloc_inode, 1609 .free_inode = mqueue_free_inode, 1610 .evict_inode = mqueue_evict_inode, 1611 .statfs = simple_statfs, 1612 }; 1613 1614 static const struct fs_context_operations mqueue_fs_context_ops = { 1615 .free = mqueue_fs_context_free, 1616 .get_tree = mqueue_get_tree, 1617 }; 1618 1619 static struct file_system_type mqueue_fs_type = { 1620 .name = "mqueue", 1621 .init_fs_context = mqueue_init_fs_context, 1622 .kill_sb = kill_anon_super, 1623 .fs_flags = FS_USERNS_MOUNT, 1624 }; 1625 1626 int mq_init_ns(struct ipc_namespace *ns) 1627 { 1628 struct vfsmount *m; 1629 1630 ns->mq_queues_count = 0; 1631 ns->mq_queues_max = DFLT_QUEUESMAX; 1632 ns->mq_msg_max = DFLT_MSGMAX; 1633 ns->mq_msgsize_max = DFLT_MSGSIZEMAX; 1634 ns->mq_msg_default = DFLT_MSG; 1635 ns->mq_msgsize_default = DFLT_MSGSIZE; 1636 1637 m = mq_create_mount(ns); 1638 if (IS_ERR(m)) 1639 return PTR_ERR(m); 1640 ns->mq_mnt = m; 1641 return 0; 1642 } 1643 1644 void mq_clear_sbinfo(struct ipc_namespace *ns) 1645 { 1646 ns->mq_mnt->mnt_sb->s_fs_info = NULL; 1647 } 1648 1649 static int __init init_mqueue_fs(void) 1650 { 1651 int error; 1652 1653 mqueue_inode_cachep = kmem_cache_create("mqueue_inode_cache", 1654 sizeof(struct mqueue_inode_info), 0, 1655 SLAB_HWCACHE_ALIGN|SLAB_ACCOUNT, init_once); 1656 if (mqueue_inode_cachep == NULL) 1657 return -ENOMEM; 1658 1659 if (!setup_mq_sysctls(&init_ipc_ns)) { 1660 pr_warn("sysctl registration failed\n"); 1661 error = -ENOMEM; 1662 goto out_kmem; 1663 } 1664 1665 error = register_filesystem(&mqueue_fs_type); 1666 if (error) 1667 goto out_sysctl; 1668 1669 spin_lock_init(&mq_lock); 1670 1671 error = mq_init_ns(&init_ipc_ns); 1672 if (error) 1673 goto out_filesystem; 1674 1675 return 0; 1676 1677 out_filesystem: 1678 unregister_filesystem(&mqueue_fs_type); 1679 out_sysctl: 1680 retire_mq_sysctls(&init_ipc_ns); 1681 out_kmem: 1682 kmem_cache_destroy(mqueue_inode_cachep); 1683 return error; 1684 } 1685 1686 device_initcall(init_mqueue_fs); 1687