sys/kern/uipc_mqueue.c

   1 /*-
   2  * Copyright (c) 2005 David Xu <davidxu@freebsd.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  */
  27
  28 /*
  29  * POSIX message queue implementation.
  30  *
  31  * 1) A mqueue filesystem can be mounted, each message queue appears
  32  *    in mounted directory, user can change queue's permission and
  33  *    ownership, or remove a queue. Manually creating a file in the
  34  *    directory causes a message queue to be created in the kernel with
  35  *    default message queue attributes applied and same name used, this
  36  *    method is not advocated since mq_open syscall allows user to specify
  37  *    different attributes. Also the file system can be mounted multiple
  38  *    times at different mount points but shows same contents.
  39  *
  40  * 2) Standard POSIX message queue API. The syscalls do not use vfs layer,
  41  *    but directly operate on internal data structure, this allows user to
  42  *    use the IPC facility without having to mount mqueue file system.
  43  */
  44
  45 #include <sys/cdefs.h>
  46 __FBSDID("$FreeBSD$");
  47
  48 #include "opt_compat.h"
  49
  50 #include <sys/param.h>
  51 #include <sys/kernel.h>
  52 #include <sys/systm.h>
  53 #include <sys/limits.h>
  54 #include <sys/buf.h>
  55 #include <sys/dirent.h>
  56 #include <sys/event.h>
  57 #include <sys/eventhandler.h>
  58 #include <sys/fcntl.h>
  59 #include <sys/file.h>
  60 #include <sys/filedesc.h>
  61 #include <sys/lock.h>
  62 #include <sys/malloc.h>
  63 #include <sys/module.h>
  64 #include <sys/mount.h>
  65 #include <sys/mqueue.h>
  66 #include <sys/mutex.h>
  67 #include <sys/namei.h>
  68 #include <sys/posix4.h>
  69 #include <sys/poll.h>
  70 #include <sys/priv.h>
  71 #include <sys/proc.h>
  72 #include <sys/queue.h>
  73 #include <sys/sysproto.h>
  74 #include <sys/stat.h>
  75 #include <sys/syscall.h>
  76 #include <sys/syscallsubr.h>
  77 #include <sys/sysent.h>
  78 #include <sys/sx.h>
  79 #include <sys/sysctl.h>
  80 #include <sys/taskqueue.h>
  81 #include <sys/unistd.h>
  82 #include <sys/vnode.h>
  83 #include <machine/atomic.h>
  84
  85 /*
  86  * Limits and constants
  87  */
  88 #define MQFS_NAMELEN            NAME_MAX
  89 #define MQFS_DELEN              (8 + MQFS_NAMELEN)
  90
  91 /* node types */
  92 typedef enum {
  93         mqfstype_none = 0,
  94         mqfstype_root,
  95         mqfstype_dir,
  96         mqfstype_this,
  97         mqfstype_parent,
  98         mqfstype_file,
  99         mqfstype_symlink,
 100 } mqfs_type_t;
 101
 102 struct mqfs_node;
 103
 104 /*
 105  * mqfs_info: describes a mqfs instance
 106  */
 107 struct mqfs_info {
 108         struct sx               mi_lock;
 109         struct mqfs_node        *mi_root;
 110         struct unrhdr           *mi_unrhdr;
 111 };
 112
 113 struct mqfs_vdata {
 114         LIST_ENTRY(mqfs_vdata)  mv_link;
 115         struct mqfs_node        *mv_node;
 116         struct vnode            *mv_vnode;
 117         struct task             mv_task;
 118 };
 119
 120 /*
 121  * mqfs_node: describes a node (file or directory) within a mqfs
 122  */
 123 struct mqfs_node {
 124         char                    mn_name[MQFS_NAMELEN+1];
 125         struct mqfs_info        *mn_info;
 126         struct mqfs_node        *mn_parent;
 127         LIST_HEAD(,mqfs_node)   mn_children;
 128         LIST_ENTRY(mqfs_node)   mn_sibling;
 129         LIST_HEAD(,mqfs_vdata)  mn_vnodes;
 130         int                     mn_refcount;
 131         mqfs_type_t             mn_type;
 132         int                     mn_deleted;
 133         uint32_t                mn_fileno;
 134         void                    *mn_data;
 135         struct timespec         mn_birth;
 136         struct timespec         mn_ctime;
 137         struct timespec         mn_atime;
 138         struct timespec         mn_mtime;
 139         uid_t                   mn_uid;
 140         gid_t                   mn_gid;
 141         int                     mn_mode;
 142 };
 143
 144 #define VTON(vp)        (((struct mqfs_vdata *)((vp)->v_data))->mv_node)
 145 #define VTOMQ(vp)       ((struct mqueue *)(VTON(vp)->mn_data))
 146 #define VFSTOMQFS(m)    ((struct mqfs_info *)((m)->mnt_data))
 147 #define FPTOMQ(fp)      ((struct mqueue *)(((struct mqfs_node *) \
 148                                 (fp)->f_data)->mn_data))
 149
 150 TAILQ_HEAD(msgq, mqueue_msg);
 151
 152 struct mqueue;
 153
 154 struct mqueue_notifier {
 155         LIST_ENTRY(mqueue_notifier)     nt_link;
 156         struct sigevent                 nt_sigev;
 157         ksiginfo_t                      nt_ksi;
 158         struct proc                     *nt_proc;
 159 };
 160
 161 struct mqueue {
 162         struct mtx      mq_mutex;
 163         int             mq_flags;
 164         long            mq_maxmsg;
 165         long            mq_msgsize;
 166         long            mq_curmsgs;
 167         long            mq_totalbytes;
 168         struct msgq     mq_msgq;
 169         int             mq_receivers;
 170         int             mq_senders;
 171         struct selinfo  mq_rsel;
 172         struct selinfo  mq_wsel;
 173         struct mqueue_notifier  *mq_notifier;
 174 };
 175
 176 #define MQ_RSEL         0x01
 177 #define MQ_WSEL         0x02
 178
 179 struct mqueue_msg {
 180         TAILQ_ENTRY(mqueue_msg) msg_link;
 181         unsigned int    msg_prio;
 182         unsigned int    msg_size;
 183         /* following real data... */
 184 };
 185
 186 SYSCTL_NODE(_kern, OID_AUTO, mqueue, CTLFLAG_RW, 0,
 187         "POSIX real time message queue");
 188
 189 static int      default_maxmsg  = 10;
 190 static int      default_msgsize = 1024;
 191
 192 static int      maxmsg = 100;
 193 SYSCTL_INT(_kern_mqueue, OID_AUTO, maxmsg, CTLFLAG_RW,
 194     &maxmsg, 0, "Default maximum messages in queue");
 195 static int      maxmsgsize = 16384;
 196 SYSCTL_INT(_kern_mqueue, OID_AUTO, maxmsgsize, CTLFLAG_RW,
 197     &maxmsgsize, 0, "Default maximum message size");
 198 static int      maxmq = 100;
 199 SYSCTL_INT(_kern_mqueue, OID_AUTO, maxmq, CTLFLAG_RW,
 200     &maxmq, 0, "maximum message queues");
 201 static int      curmq = 0;
 202 SYSCTL_INT(_kern_mqueue, OID_AUTO, curmq, CTLFLAG_RW,
 203     &curmq, 0, "current message queue number");
 204 static int      unloadable = 0;
 205 static MALLOC_DEFINE(M_MQUEUEDATA, "mqdata", "mqueue data");
 206
 207 static eventhandler_tag exit_tag;
 208
 209 /* Only one instance per-system */
 210 static struct mqfs_info         mqfs_data;
 211 static uma_zone_t               mqnode_zone;
 212 static uma_zone_t               mqueue_zone;
 213 static uma_zone_t               mvdata_zone;
 214 static uma_zone_t               mqnoti_zone;
 215 static struct vop_vector        mqfs_vnodeops;
 216 static struct fileops           mqueueops;
 217
 218 /*
 219  * Directory structure construction and manipulation
 220  */
 221 #ifdef notyet
 222 static struct mqfs_node *mqfs_create_dir(struct mqfs_node *parent,
 223         const char *name, int namelen, struct ucred *cred, int mode);
 224 static struct mqfs_node *mqfs_create_link(struct mqfs_node *parent,
 225         const char *name, int namelen, struct ucred *cred, int mode);
 226 #endif
 227
 228 static struct mqfs_node *mqfs_create_file(struct mqfs_node *parent,
 229         const char *name, int namelen, struct ucred *cred, int mode);
 230 static int      mqfs_destroy(struct mqfs_node *mn);
 231 static void     mqfs_fileno_alloc(struct mqfs_info *mi, struct mqfs_node *mn);
 232 static void     mqfs_fileno_free(struct mqfs_info *mi, struct mqfs_node *mn);
 233 static int      mqfs_allocv(struct mount *mp, struct vnode **vpp, struct mqfs_node *pn);
 234
 235 /*
 236  * Message queue construction and maniplation
 237  */
 238 static struct mqueue    *mqueue_alloc(const struct mq_attr *attr);
 239 static void     mqueue_free(struct mqueue *mq);
 240 static int      mqueue_send(struct mqueue *mq, const char *msg_ptr,
 241                         size_t msg_len, unsigned msg_prio, int waitok,
 242                         const struct timespec *abs_timeout);
 243 static int      mqueue_receive(struct mqueue *mq, char *msg_ptr,
 244                         size_t msg_len, unsigned *msg_prio, int waitok,
 245                         const struct timespec *abs_timeout);
 246 static int      _mqueue_send(struct mqueue *mq, struct mqueue_msg *msg,
 247                         int timo);
 248 static int      _mqueue_recv(struct mqueue *mq, struct mqueue_msg **msg,
 249                         int timo);
 250 static void     mqueue_send_notification(struct mqueue *mq);
 251 static void     mqueue_fdclose(struct thread *td, int fd, struct file *fp);
 252 static void     mq_proc_exit(void *arg, struct proc *p);
 253
 254 /*
 255  * kqueue filters
 256  */
 257 static void     filt_mqdetach(struct knote *kn);
 258 static int      filt_mqread(struct knote *kn, long hint);
 259 static int      filt_mqwrite(struct knote *kn, long hint);
 260
 261 struct filterops mq_rfiltops = {
 262         .f_isfd = 1,
 263         .f_detach = filt_mqdetach,
 264         .f_event = filt_mqread,
 265 };
 266 struct filterops mq_wfiltops = {
 267         .f_isfd = 1,
 268         .f_detach = filt_mqdetach,
 269         .f_event = filt_mqwrite,
 270 };
 271
 272 /*
 273  * Initialize fileno bitmap
 274  */
 275 static void
 276 mqfs_fileno_init(struct mqfs_info *mi)
 277 {
 278         struct unrhdr *up;
 279
 280         up = new_unrhdr(1, INT_MAX, NULL);
 281         mi->mi_unrhdr = up;
 282 }
 283
 284 /*
 285  * Tear down fileno bitmap
 286  */
 287 static void
 288 mqfs_fileno_uninit(struct mqfs_info *mi)
 289 {
 290         struct unrhdr *up;
 291
 292         up = mi->mi_unrhdr;
 293         mi->mi_unrhdr = NULL;
 294         delete_unrhdr(up);
 295 }
 296
 297 /*
 298  * Allocate a file number
 299  */
 300 static void
 301 mqfs_fileno_alloc(struct mqfs_info *mi, struct mqfs_node *mn)
 302 {
 303         /* make sure our parent has a file number */
 304         if (mn->mn_parent && !mn->mn_parent->mn_fileno)
 305                 mqfs_fileno_alloc(mi, mn->mn_parent);
 306
 307         switch (mn->mn_type) {
 308         case mqfstype_root:
 309         case mqfstype_dir:
 310         case mqfstype_file:
 311         case mqfstype_symlink:
 312                 mn->mn_fileno = alloc_unr(mi->mi_unrhdr);
 313                 break;
 314         case mqfstype_this:
 315                 KASSERT(mn->mn_parent != NULL,
 316                     ("mqfstype_this node has no parent"));
 317                 mn->mn_fileno = mn->mn_parent->mn_fileno;
 318                 break;
 319         case mqfstype_parent:
 320                 KASSERT(mn->mn_parent != NULL,
 321                     ("mqfstype_parent node has no parent"));
 322                 if (mn->mn_parent == mi->mi_root) {
 323                         mn->mn_fileno = mn->mn_parent->mn_fileno;
 324                         break;
 325                 }
 326                 KASSERT(mn->mn_parent->mn_parent != NULL,
 327                     ("mqfstype_parent node has no grandparent"));
 328                 mn->mn_fileno = mn->mn_parent->mn_parent->mn_fileno;
 329                 break;
 330         default:
 331                 KASSERT(0,
 332                     ("mqfs_fileno_alloc() called for unknown type node: %d",
 333                         mn->mn_type));
 334                 break;
 335         }
 336 }
 337
 338 /*
 339  * Release a file number
 340  */
 341 static void
 342 mqfs_fileno_free(struct mqfs_info *mi, struct mqfs_node *mn)
 343 {
 344         switch (mn->mn_type) {
 345         case mqfstype_root:
 346         case mqfstype_dir:
 347         case mqfstype_file:
 348         case mqfstype_symlink:
 349                 free_unr(mi->mi_unrhdr, mn->mn_fileno);
 350                 break;
 351         case mqfstype_this:
 352         case mqfstype_parent:
 353                 /* ignore these, as they don't "own" their file number */
 354                 break;
 355         default:
 356                 KASSERT(0,
 357                     ("mqfs_fileno_free() called for unknown type node: %d",
 358                         mn->mn_type));
 359                 break;
 360         }
 361 }
 362
 363 static __inline struct mqfs_node *
 364 mqnode_alloc(void)
 365 {
 366         return uma_zalloc(mqnode_zone, M_WAITOK | M_ZERO);
 367 }
 368
 369 static __inline void
 370 mqnode_free(struct mqfs_node *node)
 371 {
 372         uma_zfree(mqnode_zone, node);
 373 }
 374
 375 static __inline void
 376 mqnode_addref(struct mqfs_node *node)
 377 {
 378         atomic_fetchadd_int(&node->mn_refcount, 1);
 379 }
 380
 381 static __inline void
 382 mqnode_release(struct mqfs_node *node)
 383 {
 384         struct mqfs_info *mqfs;
 385         int old, exp;
 386
 387         mqfs = node->mn_info;
 388         old = atomic_fetchadd_int(&node->mn_refcount, -1);
 389         if (node->mn_type == mqfstype_dir ||
 390             node->mn_type == mqfstype_root)
 391                 exp = 3; /* include . and .. */
 392         else
 393                 exp = 1;
 394         if (old == exp) {
 395                 int locked = sx_xlocked(&mqfs->mi_lock);
 396                 if (!locked)
 397                         sx_xlock(&mqfs->mi_lock);
 398                 mqfs_destroy(node);
 399                 if (!locked)
 400                         sx_xunlock(&mqfs->mi_lock);
 401         }
 402 }
 403
 404 /*
 405  * Add a node to a directory
 406  */
 407 static int
 408 mqfs_add_node(struct mqfs_node *parent, struct mqfs_node *node)
 409 {
 410         KASSERT(parent != NULL, ("%s(): parent is NULL", __func__));
 411         KASSERT(parent->mn_info != NULL,
 412             ("%s(): parent has no mn_info", __func__));
 413         KASSERT(parent->mn_type == mqfstype_dir ||
 414             parent->mn_type == mqfstype_root,
 415             ("%s(): parent is not a directory", __func__));
 416
 417         node->mn_info = parent->mn_info;
 418         node->mn_parent = parent;
 419         LIST_INIT(&node->mn_children);
 420         LIST_INIT(&node->mn_vnodes);
 421         LIST_INSERT_HEAD(&parent->mn_children, node, mn_sibling);
 422         mqnode_addref(parent);
 423         return (0);
 424 }
 425
 426 static struct mqfs_node *
 427 mqfs_create_node(const char *name, int namelen, struct ucred *cred, int mode,
 428         int nodetype)
 429 {
 430         struct mqfs_node *node;
 431
 432         node = mqnode_alloc();
 433         strncpy(node->mn_name, name, namelen);
 434         node->mn_type = nodetype;
 435         node->mn_refcount = 1;
 436         vfs_timestamp(&node->mn_birth);
 437         node->mn_ctime = node->mn_atime = node->mn_mtime
 438                 = node->mn_birth;
 439         node->mn_uid = cred->cr_uid;
 440         node->mn_gid = cred->cr_gid;
 441         node->mn_mode = mode;
 442         return (node);
 443 }
 444
 445 /*
 446  * Create a file
 447  */
 448 static struct mqfs_node *
 449 mqfs_create_file(struct mqfs_node *parent, const char *name, int namelen,
 450         struct ucred *cred, int mode)
 451 {
 452         struct mqfs_node *node;
 453
 454         node = mqfs_create_node(name, namelen, cred, mode, mqfstype_file);
 455         if (mqfs_add_node(parent, node) != 0) {
 456                 mqnode_free(node);
 457                 return (NULL);
 458         }
 459         return (node);
 460 }
 461
 462 /*
 463  * Add . and .. to a directory
 464  */
 465 static int
 466 mqfs_fixup_dir(struct mqfs_node *parent)
 467 {
 468         struct mqfs_node *dir;
 469
 470         dir = mqnode_alloc();
 471         dir->mn_name[0] = '.';
 472         dir->mn_type = mqfstype_this;
 473         dir->mn_refcount = 1;
 474         if (mqfs_add_node(parent, dir) != 0) {
 475                 mqnode_free(dir);
 476                 return (-1);
 477         }
 478
 479         dir = mqnode_alloc();
 480         dir->mn_name[0] = dir->mn_name[1] = '.';
 481         dir->mn_type = mqfstype_parent;
 482         dir->mn_refcount = 1;
 483
 484         if (mqfs_add_node(parent, dir) != 0) {
 485                 mqnode_free(dir);
 486                 return (-1);
 487         }
 488
 489         return (0);
 490 }
 491
 492 #ifdef notyet
 493
 494 /*
 495  * Create a directory
 496  */
 497 static struct mqfs_node *
 498 mqfs_create_dir(struct mqfs_node *parent, const char *name, int namelen,
 499         struct ucred *cred, int mode)
 500 {
 501         struct mqfs_node *node;
 502
 503         node = mqfs_create_node(name, namelen, cred, mode, mqfstype_dir);
 504         if (mqfs_add_node(parent, node) != 0) {
 505                 mqnode_free(node);
 506                 return (NULL);
 507         }
 508
 509         if (mqfs_fixup_dir(node) != 0) {
 510                 mqfs_destroy(node);
 511                 return (NULL);
 512         }
 513         return (node);
 514 }
 515
 516 /*
 517  * Create a symlink
 518  */
 519 static struct mqfs_node *
 520 mqfs_create_link(struct mqfs_node *parent, const char *name, int namelen,
 521         struct ucred *cred, int mode)
 522 {
 523         struct mqfs_node *node;
 524
 525         node = mqfs_create_node(name, namelen, cred, mode, mqfstype_symlink);
 526         if (mqfs_add_node(parent, node) != 0) {
 527                 mqnode_free(node);
 528                 return (NULL);
 529         }
 530         return (node);
 531 }
 532
 533 #endif
 534
 535 /*
 536  * Destroy a node or a tree of nodes
 537  */
 538 static int
 539 mqfs_destroy(struct mqfs_node *node)
 540 {
 541         struct mqfs_node *parent;
 542
 543         KASSERT(node != NULL,
 544             ("%s(): node is NULL", __func__));
 545         KASSERT(node->mn_info != NULL,
 546             ("%s(): node has no mn_info", __func__));
 547
 548         /* destroy children */
 549         if (node->mn_type == mqfstype_dir || node->mn_type == mqfstype_root)
 550                 while (! LIST_EMPTY(&node->mn_children))
 551                         mqfs_destroy(LIST_FIRST(&node->mn_children));
 552
 553         /* unlink from parent */
 554         if ((parent = node->mn_parent) != NULL) {
 555                 KASSERT(parent->mn_info == node->mn_info,
 556                     ("%s(): parent has different mn_info", __func__));
 557                 LIST_REMOVE(node, mn_sibling);
 558         }
 559
 560         if (node->mn_fileno != 0)
 561                 mqfs_fileno_free(node->mn_info, node);
 562         if (node->mn_data != NULL)
 563                 mqueue_free(node->mn_data);
 564         mqnode_free(node);
 565         return (0);
 566 }
 567
 568 /*
 569  * Mount a mqfs instance
 570  */
 571 static int
 572 mqfs_mount(struct mount *mp)
 573 {
 574         struct statfs *sbp;
 575
 576         if (mp->mnt_flag & MNT_UPDATE)
 577                 return (EOPNOTSUPP);
 578
 579         mp->mnt_data = &mqfs_data;
 580         MNT_ILOCK(mp);
 581         mp->mnt_flag |= MNT_LOCAL;
 582         mp->mnt_kern_flag |= MNTK_MPSAFE;
 583         MNT_IUNLOCK(mp);
 584         vfs_getnewfsid(mp);
 585
 586         sbp = &mp->mnt_stat;
 587         vfs_mountedfrom(mp, "mqueue");
 588         sbp->f_bsize = PAGE_SIZE;
 589         sbp->f_iosize = PAGE_SIZE;
 590         sbp->f_blocks = 1;
 591         sbp->f_bfree = 0;
 592         sbp->f_bavail = 0;
 593         sbp->f_files = 1;
 594         sbp->f_ffree = 0;
 595         return (0);
 596 }
 597
 598 /*
 599  * Unmount a mqfs instance
 600  */
 601 static int
 602 mqfs_unmount(struct mount *mp, int mntflags)
 603 {
 604         int error;
 605
 606         error = vflush(mp, 0, (mntflags & MNT_FORCE) ?  FORCECLOSE : 0,
 607             curthread);
 608         return (error);
 609 }
 610
 611 /*
 612  * Return a root vnode
 613  */
 614 static int
 615 mqfs_root(struct mount *mp, int flags, struct vnode **vpp)
 616 {
 617         struct mqfs_info *mqfs;
 618         int ret;
 619
 620         mqfs = VFSTOMQFS(mp);
 621         ret = mqfs_allocv(mp, vpp, mqfs->mi_root);
 622         return (ret);
 623 }
 624
 625 /*
 626  * Return filesystem stats
 627  */
 628 static int
 629 mqfs_statfs(struct mount *mp, struct statfs *sbp)
 630 {
 631         /* XXX update statistics */
 632         return (0);
 633 }
 634
 635 /*
 636  * Initialize a mqfs instance
 637  */
 638 static int
 639 mqfs_init(struct vfsconf *vfc)
 640 {
 641         struct mqfs_node *root;
 642         struct mqfs_info *mi;
 643
 644         mqnode_zone = uma_zcreate("mqnode", sizeof(struct mqfs_node),
 645                 NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
 646         mqueue_zone = uma_zcreate("mqueue", sizeof(struct mqueue),
 647                 NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
 648         mvdata_zone = uma_zcreate("mvdata",
 649                 sizeof(struct mqfs_vdata), NULL, NULL, NULL,
 650                 NULL, UMA_ALIGN_PTR, 0);
 651         mqnoti_zone = uma_zcreate("mqnotifier", sizeof(struct mqueue_notifier),
 652                 NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
 653         mi = &mqfs_data;
 654         sx_init(&mi->mi_lock, "mqfs lock");
 655         /* set up the root diretory */
 656         root = mqfs_create_node("/", 1, curthread->td_ucred, 01777,
 657                 mqfstype_root);
 658         root->mn_info = mi;
 659         LIST_INIT(&root->mn_children);
 660         LIST_INIT(&root->mn_vnodes);
 661         mi->mi_root = root;
 662         mqfs_fileno_init(mi);
 663         mqfs_fileno_alloc(mi, root);
 664         mqfs_fixup_dir(root);
 665         exit_tag = EVENTHANDLER_REGISTER(process_exit, mq_proc_exit, NULL,
 666             EVENTHANDLER_PRI_ANY);
 667         mq_fdclose = mqueue_fdclose;
 668         p31b_setcfg(CTL_P1003_1B_MESSAGE_PASSING, _POSIX_MESSAGE_PASSING);
 669         return (0);
 670 }
 671
 672 /*
 673  * Destroy a mqfs instance
 674  */
 675 static int
 676 mqfs_uninit(struct vfsconf *vfc)
 677 {
 678         struct mqfs_info *mi;
 679
 680         if (!unloadable)
 681                 return (EOPNOTSUPP);
 682         EVENTHANDLER_DEREGISTER(process_exit, exit_tag);
 683         mi = &mqfs_data;
 684         mqfs_destroy(mi->mi_root);
 685         mi->mi_root = NULL;
 686         mqfs_fileno_uninit(mi);
 687         sx_destroy(&mi->mi_lock);
 688         uma_zdestroy(mqnode_zone);
 689         uma_zdestroy(mqueue_zone);
 690         uma_zdestroy(mvdata_zone);
 691         uma_zdestroy(mqnoti_zone);
 692         return (0);
 693 }
 694
 695 /*
 696  * task routine
 697  */
 698 static void
 699 do_recycle(void *context, int pending __unused)
 700 {
 701         struct vnode *vp = (struct vnode *)context;
 702
 703         vrecycle(vp, curthread);
 704         vdrop(vp);
 705 }
 706
 707 /*
 708  * Allocate a vnode
 709  */
 710 static int
 711 mqfs_allocv(struct mount *mp, struct vnode **vpp, struct mqfs_node *pn)
 712 {
 713         struct mqfs_vdata *vd;
 714         struct mqfs_info  *mqfs;
 715         struct vnode *newvpp;
 716         int error;
 717
 718         mqfs = pn->mn_info;
 719         *vpp = NULL;
 720         sx_xlock(&mqfs->mi_lock);
 721         LIST_FOREACH(vd, &pn->mn_vnodes, mv_link) {
 722                 if (vd->mv_vnode->v_mount == mp) {
 723                         vhold(vd->mv_vnode);
 724                         break;
 725                 }
 726         }
 727
 728         if (vd != NULL) {
 729 found:
 730                 *vpp = vd->mv_vnode;
 731                 sx_xunlock(&mqfs->mi_lock);
 732                 error = vget(*vpp, LK_RETRY | LK_EXCLUSIVE, curthread);
 733                 vdrop(*vpp);
 734                 return (error);
 735         }
 736         sx_xunlock(&mqfs->mi_lock);
 737
 738         error = getnewvnode("mqueue", mp, &mqfs_vnodeops, &newvpp);
 739         if (error)
 740                 return (error);
 741         vn_lock(newvpp, LK_EXCLUSIVE | LK_RETRY);
 742         error = insmntque(newvpp, mp);
 743         if (error != 0)
 744                 return (error);
 745
 746         sx_xlock(&mqfs->mi_lock);
 747         /*
 748          * Check if it has already been allocated
 749          * while we were blocked.
 750          */
 751         LIST_FOREACH(vd, &pn->mn_vnodes, mv_link) {
 752                 if (vd->mv_vnode->v_mount == mp) {
 753                         vhold(vd->mv_vnode);
 754                         sx_xunlock(&mqfs->mi_lock);
 755
 756                         vgone(newvpp);
 757                         vput(newvpp);
 758                         goto found;
 759                 }
 760         }
 761
 762         *vpp = newvpp;
 763
 764         vd = uma_zalloc(mvdata_zone, M_WAITOK);
 765         (*vpp)->v_data = vd;
 766         vd->mv_vnode = *vpp;
 767         vd->mv_node = pn;
 768         TASK_INIT(&vd->mv_task, 0, do_recycle, *vpp);
 769         LIST_INSERT_HEAD(&pn->mn_vnodes, vd, mv_link);
 770         mqnode_addref(pn);
 771         switch (pn->mn_type) {
 772         case mqfstype_root:
 773                 (*vpp)->v_vflag = VV_ROOT;
 774                 /* fall through */
 775         case mqfstype_dir:
 776         case mqfstype_this:
 777         case mqfstype_parent:
 778                 (*vpp)->v_type = VDIR;
 779                 break;
 780         case mqfstype_file:
 781                 (*vpp)->v_type = VREG;
 782                 break;
 783         case mqfstype_symlink:
 784                 (*vpp)->v_type = VLNK;
 785                 break;
 786         case mqfstype_none:
 787                 KASSERT(0, ("mqfs_allocf called for null node\n"));
 788         default:
 789                 panic("%s has unexpected type: %d", pn->mn_name, pn->mn_type);
 790         }
 791         sx_xunlock(&mqfs->mi_lock);
 792         return (0);
 793 }
 794
 795 /*
 796  * Search a directory entry
 797  */
 798 static struct mqfs_node *
 799 mqfs_search(struct mqfs_node *pd, const char *name, int len)
 800 {
 801         struct mqfs_node *pn;
 802
 803         sx_assert(&pd->mn_info->mi_lock, SX_LOCKED);
 804         LIST_FOREACH(pn, &pd->mn_children, mn_sibling) {
 805                 if (strncmp(pn->mn_name, name, len) == 0 &&
 806                     pn->mn_name[len] == '\0')
 807                         return (pn);
 808         }
 809         return (NULL);
 810 }
 811
 812 /*
 813  * Look up a file or directory.
 814  */
 815 static int
 816 mqfs_lookupx(struct vop_cachedlookup_args *ap)
 817 {
 818         struct componentname *cnp;
 819         struct vnode *dvp, **vpp;
 820         struct mqfs_node *pd;
 821         struct mqfs_node *pn;
 822         struct mqfs_info *mqfs;
 823         int nameiop, flags, error, namelen;
 824         char *pname;
 825         struct thread *td;
 826
 827         cnp = ap->a_cnp;
 828         vpp = ap->a_vpp;
 829         dvp = ap->a_dvp;
 830         pname = cnp->cn_nameptr;
 831         namelen = cnp->cn_namelen;
 832         td = cnp->cn_thread;
 833         flags = cnp->cn_flags;
 834         nameiop = cnp->cn_nameiop;
 835         pd = VTON(dvp);
 836         pn = NULL;
 837         mqfs = pd->mn_info;
 838         *vpp = NULLVP;
 839
 840         if (dvp->v_type != VDIR)
 841                 return (ENOTDIR);
 842
 843         error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, cnp->cn_thread);
 844         if (error)
 845                 return (error);
 846
 847         /* shortcut: check if the name is too long */
 848         if (cnp->cn_namelen >= MQFS_NAMELEN)
 849                 return (ENOENT);
 850
 851         /* self */
 852         if (namelen == 1 && pname[0] == '.') {
 853                 if ((flags & ISLASTCN) && nameiop != LOOKUP)
 854                         return (EINVAL);
 855                 pn = pd;
 856                 *vpp = dvp;
 857                 VREF(dvp);
 858                 return (0);
 859         }
 860
 861         /* parent */
 862         if (cnp->cn_flags & ISDOTDOT) {
 863                 if (dvp->v_vflag & VV_ROOT)
 864                         return (EIO);
 865                 if ((flags & ISLASTCN) && nameiop != LOOKUP)
 866                         return (EINVAL);
 867                 VOP_UNLOCK(dvp, 0);
 868                 KASSERT(pd->mn_parent, ("non-root directory has no parent"));
 869                 pn = pd->mn_parent;
 870                 error = mqfs_allocv(dvp->v_mount, vpp, pn);
 871                 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
 872                 return (error);
 873         }
 874
 875         /* named node */
 876         sx_xlock(&mqfs->mi_lock);
 877         pn = mqfs_search(pd, pname, namelen);
 878         if (pn != NULL)
 879                 mqnode_addref(pn);
 880         sx_xunlock(&mqfs->mi_lock);
 881
 882         /* found */
 883         if (pn != NULL) {
 884                 /* DELETE */
 885                 if (nameiop == DELETE && (flags & ISLASTCN)) {
 886                         error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred, td);
 887                         if (error) {
 888                                 mqnode_release(pn);
 889                                 return (error);
 890                         }
 891                         if (*vpp == dvp) {
 892                                 VREF(dvp);
 893                                 *vpp = dvp;
 894                                 mqnode_release(pn);
 895                                 return (0);
 896                         }
 897                 }
 898
 899                 /* allocate vnode */
 900                 error = mqfs_allocv(dvp->v_mount, vpp, pn);
 901                 mqnode_release(pn);
 902                 if (error == 0 && cnp->cn_flags & MAKEENTRY)
 903                         cache_enter(dvp, *vpp, cnp);
 904                 return (error);
 905         }
 906
 907         /* not found */
 908
 909         /* will create a new entry in the directory ? */
 910         if ((nameiop == CREATE || nameiop == RENAME) && (flags & LOCKPARENT)
 911             && (flags & ISLASTCN)) {
 912                 error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred, td);
 913                 if (error)
 914                         return (error);
 915                 cnp->cn_flags |= SAVENAME;
 916                 return (EJUSTRETURN);
 917         }
 918         return (ENOENT);
 919 }
 920
 921 #if 0
 922 struct vop_lookup_args {
 923         struct vop_generic_args a_gen;
 924         struct vnode *a_dvp;
 925         struct vnode **a_vpp;
 926         struct componentname *a_cnp;
 927 };
 928 #endif
 929
 930 /*
 931  * vnode lookup operation
 932  */
 933 static int
 934 mqfs_lookup(struct vop_cachedlookup_args *ap)
 935 {
 936         int rc;
 937
 938         rc = mqfs_lookupx(ap);
 939         return (rc);
 940 }
 941
 942 #if 0
 943 struct vop_create_args {
 944         struct vnode *a_dvp;
 945         struct vnode **a_vpp;
 946         struct componentname *a_cnp;
 947         struct vattr *a_vap;
 948 };
 949 #endif
 950
 951 /*
 952  * vnode creation operation
 953  */
 954 static int
 955 mqfs_create(struct vop_create_args *ap)
 956 {
 957         struct mqfs_info *mqfs = VFSTOMQFS(ap->a_dvp->v_mount);
 958         struct componentname *cnp = ap->a_cnp;
 959         struct mqfs_node *pd;
 960         struct mqfs_node *pn;
 961         struct mqueue *mq;
 962         int error;
 963
 964         pd = VTON(ap->a_dvp);
 965         if (pd->mn_type != mqfstype_root && pd->mn_type != mqfstype_dir)
 966                 return (ENOTDIR);
 967         mq = mqueue_alloc(NULL);
 968         if (mq == NULL)
 969                 return (EAGAIN);
 970         sx_xlock(&mqfs->mi_lock);
 971         if ((cnp->cn_flags & HASBUF) == 0)
 972                 panic("%s: no name", __func__);
 973         pn = mqfs_create_file(pd, cnp->cn_nameptr, cnp->cn_namelen,
 974                 cnp->cn_cred, ap->a_vap->va_mode);
 975         if (pn == NULL) {
 976                 sx_xunlock(&mqfs->mi_lock);
 977                 error = ENOSPC;
 978         } else {
 979                 mqnode_addref(pn);
 980                 sx_xunlock(&mqfs->mi_lock);
 981                 error = mqfs_allocv(ap->a_dvp->v_mount, ap->a_vpp, pn);
 982                 mqnode_release(pn);
 983                 if (error)
 984                         mqfs_destroy(pn);
 985                 else
 986                         pn->mn_data = mq;
 987         }
 988         if (error)
 989                 mqueue_free(mq);
 990         return (error);
 991 }
 992
 993 /*
 994  * Remove an entry
 995  */
 996 static
 997 int do_unlink(struct mqfs_node *pn, struct ucred *ucred)
 998 {
 999         struct mqfs_node *parent;
1000         struct mqfs_vdata *vd;
1001         int error = 0;
1002
1003         sx_assert(&pn->mn_info->mi_lock, SX_LOCKED);
1004
1005         if (ucred->cr_uid != pn->mn_uid &&
1006             (error = priv_check_cred(ucred, PRIV_MQ_ADMIN, 0)) != 0)
1007                 error = EACCES;
1008         else if (!pn->mn_deleted) {
1009                 parent = pn->mn_parent;
1010                 pn->mn_parent = NULL;
1011                 pn->mn_deleted = 1;
1012                 LIST_REMOVE(pn, mn_sibling);
1013                 LIST_FOREACH(vd, &pn->mn_vnodes, mv_link) {
1014                         cache_purge(vd->mv_vnode);
1015                         vhold(vd->mv_vnode);
1016                         taskqueue_enqueue(taskqueue_thread, &vd->mv_task);
1017                 }
1018                 mqnode_release(pn);
1019                 mqnode_release(parent);
1020         } else
1021                 error = ENOENT;
1022         return (error);
1023 }
1024
1025 #if 0
1026 struct vop_remove_args {
1027         struct vnode *a_dvp;
1028         struct vnode *a_vp;
1029         struct componentname *a_cnp;
1030 };
1031 #endif
1032
1033 /*
1034  * vnode removal operation
1035  */
1036 static int
1037 mqfs_remove(struct vop_remove_args *ap)
1038 {
1039         struct mqfs_info *mqfs = VFSTOMQFS(ap->a_dvp->v_mount);
1040         struct mqfs_node *pn;
1041         int error;
1042
1043         if (ap->a_vp->v_type == VDIR)
1044                 return (EPERM);
1045         pn = VTON(ap->a_vp);
1046         sx_xlock(&mqfs->mi_lock);
1047         error = do_unlink(pn, ap->a_cnp->cn_cred);
1048         sx_xunlock(&mqfs->mi_lock);
1049         return (error);
1050 }
1051
1052 #if 0
1053 struct vop_inactive_args {
1054         struct vnode *a_vp;
1055         struct thread *a_td;
1056 };
1057 #endif
1058
1059 static int
1060 mqfs_inactive(struct vop_inactive_args *ap)
1061 {
1062         struct mqfs_node *pn = VTON(ap->a_vp);
1063
1064         if (pn->mn_deleted)
1065                 vrecycle(ap->a_vp, ap->a_td);
1066         return (0);
1067 }
1068
1069 #if 0
1070 struct vop_reclaim_args {
1071         struct vop_generic_args a_gen;
1072         struct vnode *a_vp;
1073         struct thread *a_td;
1074 };
1075 #endif
1076
1077 static int
1078 mqfs_reclaim(struct vop_reclaim_args *ap)
1079 {
1080         struct mqfs_info *mqfs = VFSTOMQFS(ap->a_vp->v_mount);
1081         struct vnode *vp = ap->a_vp;
1082         struct mqfs_node *pn;
1083         struct mqfs_vdata *vd;
1084
1085         vd = vp->v_data;
1086         pn = vd->mv_node;
1087         sx_xlock(&mqfs->mi_lock);
1088         vp->v_data = NULL;
1089         LIST_REMOVE(vd, mv_link);
1090         uma_zfree(mvdata_zone, vd);
1091         mqnode_release(pn);
1092         sx_xunlock(&mqfs->mi_lock);
1093         return (0);
1094 }
1095
1096 #if 0
1097 struct vop_open_args {
1098         struct vop_generic_args a_gen;
1099         struct vnode *a_vp;
1100         int a_mode;
1101         struct ucred *a_cred;
1102         struct thread *a_td;
1103         struct file *a_fp;
1104 };
1105 #endif
1106
1107 static int
1108 mqfs_open(struct vop_open_args *ap)
1109 {
1110         return (0);
1111 }
1112
1113 #if 0
1114 struct vop_close_args {
1115         struct vop_generic_args a_gen;
1116         struct vnode *a_vp;
1117         int a_fflag;
1118         struct ucred *a_cred;
1119         struct thread *a_td;
1120 };
1121 #endif
1122
1123 static int
1124 mqfs_close(struct vop_close_args *ap)
1125 {
1126         return (0);
1127 }
1128
1129 #if 0
1130 struct vop_access_args {
1131         struct vop_generic_args a_gen;
1132         struct vnode *a_vp;
1133         accmode_t a_accmode;
1134         struct ucred *a_cred;
1135         struct thread *a_td;
1136 };
1137 #endif
1138
1139 /*
1140  * Verify permissions
1141  */
1142 static int
1143 mqfs_access(struct vop_access_args *ap)
1144 {
1145         struct vnode *vp = ap->a_vp;
1146         struct vattr vattr;
1147         int error;
1148
1149         error = VOP_GETATTR(vp, &vattr, ap->a_cred);
1150         if (error)
1151                 return (error);
1152         error = vaccess(vp->v_type, vattr.va_mode, vattr.va_uid,
1153             vattr.va_gid, ap->a_accmode, ap->a_cred, NULL);
1154         return (error);
1155 }
1156
1157 #if 0
1158 struct vop_getattr_args {
1159         struct vop_generic_args a_gen;
1160         struct vnode *a_vp;
1161         struct vattr *a_vap;
1162         struct ucred *a_cred;
1163 };
1164 #endif
1165
1166 /*
1167  * Get file attributes
1168  */
1169 static int
1170 mqfs_getattr(struct vop_getattr_args *ap)
1171 {
1172         struct vnode *vp = ap->a_vp;
1173         struct mqfs_node *pn = VTON(vp);
1174         struct vattr *vap = ap->a_vap;
1175         int error = 0;
1176
1177         vap->va_type = vp->v_type;
1178         vap->va_mode = pn->mn_mode;
1179         vap->va_nlink = 1;
1180         vap->va_uid = pn->mn_uid;
1181         vap->va_gid = pn->mn_gid;
1182         vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
1183         vap->va_fileid = pn->mn_fileno;
1184         vap->va_size = 0;
1185         vap->va_blocksize = PAGE_SIZE;
1186         vap->va_bytes = vap->va_size = 0;
1187         vap->va_atime = pn->mn_atime;
1188         vap->va_mtime = pn->mn_mtime;
1189         vap->va_ctime = pn->mn_ctime;
1190         vap->va_birthtime = pn->mn_birth;
1191         vap->va_gen = 0;
1192         vap->va_flags = 0;
1193         vap->va_rdev = NODEV;
1194         vap->va_bytes = 0;
1195         vap->va_filerev = 0;
1196         return (error);
1197 }
1198
1199 #if 0
1200 struct vop_setattr_args {
1201         struct vop_generic_args a_gen;
1202         struct vnode *a_vp;
1203         struct vattr *a_vap;
1204         struct ucred *a_cred;
1205 };
1206 #endif
1207 /*
1208  * Set attributes
1209  */
1210 static int
1211 mqfs_setattr(struct vop_setattr_args *ap)
1212 {
1213         struct mqfs_node *pn;
1214         struct vattr *vap;
1215         struct vnode *vp;
1216         struct thread *td;
1217         int c, error;
1218         uid_t uid;
1219         gid_t gid;
1220
1221         td = curthread;
1222         vap = ap->a_vap;
1223         vp = ap->a_vp;
1224         if ((vap->va_type != VNON) ||
1225             (vap->va_nlink != VNOVAL) ||
1226             (vap->va_fsid != VNOVAL) ||
1227             (vap->va_fileid != VNOVAL) ||
1228             (vap->va_blocksize != VNOVAL) ||
1229             (vap->va_flags != VNOVAL && vap->va_flags != 0) ||
1230             (vap->va_rdev != VNOVAL) ||
1231             ((int)vap->va_bytes != VNOVAL) ||
1232             (vap->va_gen != VNOVAL)) {
1233                 return (EINVAL);
1234         }
1235
1236         pn = VTON(vp);
1237
1238         error = c = 0;
1239         if (vap->va_uid == (uid_t)VNOVAL)
1240                 uid = pn->mn_uid;
1241         else
1242                 uid = vap->va_uid;
1243         if (vap->va_gid == (gid_t)VNOVAL)
1244                 gid = pn->mn_gid;
1245         else
1246                 gid = vap->va_gid;
1247
1248         if (uid != pn->mn_uid || gid != pn->mn_gid) {
1249                 /*
1250                  * To modify the ownership of a file, must possess VADMIN
1251                  * for that file.
1252                  */
1253                 if ((error = VOP_ACCESS(vp, VADMIN, ap->a_cred, td)))
1254                         return (error);
1255
1256                 /*
1257                  * XXXRW: Why is there a privilege check here: shouldn't the
1258                  * check in VOP_ACCESS() be enough?  Also, are the group bits
1259                  * below definitely right?
1260                  */
1261                 if (((ap->a_cred->cr_uid != pn->mn_uid) || uid != pn->mn_uid ||
1262                     (gid != pn->mn_gid && !groupmember(gid, ap->a_cred))) &&
1263                     (error = priv_check(td, PRIV_MQ_ADMIN)) != 0)
1264                         return (error);
1265                 pn->mn_uid = uid;
1266                 pn->mn_gid = gid;
1267                 c = 1;
1268         }
1269
1270         if (vap->va_mode != (mode_t)VNOVAL) {
1271                 if ((ap->a_cred->cr_uid != pn->mn_uid) &&
1272                     (error = priv_check(td, PRIV_MQ_ADMIN)))
1273                         return (error);
1274                 pn->mn_mode = vap->va_mode;
1275                 c = 1;
1276         }
1277
1278         if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) {
1279                 /* See the comment in ufs_vnops::ufs_setattr(). */
1280                 if ((error = VOP_ACCESS(vp, VADMIN, ap->a_cred, td)) &&
1281                     ((vap->va_vaflags & VA_UTIMES_NULL) == 0 ||
1282                     (error = VOP_ACCESS(vp, VWRITE, ap->a_cred, td))))
1283                         return (error);
1284                 if (vap->va_atime.tv_sec != VNOVAL) {
1285                         pn->mn_atime = vap->va_atime;
1286                 }
1287                 if (vap->va_mtime.tv_sec != VNOVAL) {
1288                         pn->mn_mtime = vap->va_mtime;
1289                 }
1290                 c = 1;
1291         }
1292         if (c) {
1293                 vfs_timestamp(&pn->mn_ctime);
1294         }
1295         return (0);
1296 }
1297
1298 #if 0
1299 struct vop_read_args {
1300         struct vop_generic_args a_gen;
1301         struct vnode *a_vp;
1302         struct uio *a_uio;
1303         int a_ioflag;
1304         struct ucred *a_cred;
1305 };
1306 #endif
1307
1308 /*
1309  * Read from a file
1310  */
1311 static int
1312 mqfs_read(struct vop_read_args *ap)
1313 {
1314         char buf[80];
1315         struct vnode *vp = ap->a_vp;
1316         struct uio *uio = ap->a_uio;
1317         struct mqfs_node *pn;
1318         struct mqueue *mq;
1319         int len, error;
1320
1321         if (vp->v_type != VREG)
1322                 return (EINVAL);
1323
1324         pn = VTON(vp);
1325         mq = VTOMQ(vp);
1326         snprintf(buf, sizeof(buf),
1327                 "QSIZE:%-10ld MAXMSG:%-10ld CURMSG:%-10ld MSGSIZE:%-10ld\n",
1328                 mq->mq_totalbytes,
1329                 mq->mq_maxmsg,
1330                 mq->mq_curmsgs,
1331                 mq->mq_msgsize);
1332         buf[sizeof(buf)-1] = '\0';
1333         len = strlen(buf);
1334         error = uiomove_frombuf(buf, len, uio);
1335         return (error);
1336 }
1337
1338 #if 0
1339 struct vop_readdir_args {
1340         struct vop_generic_args a_gen;
1341         struct vnode *a_vp;
1342         struct uio *a_uio;
1343         struct ucred *a_cred;
1344         int *a_eofflag;
1345         int *a_ncookies;
1346         u_long **a_cookies;
1347 };
1348 #endif
1349
1350 /*
1351  * Return directory entries.
1352  */
1353 static int
1354 mqfs_readdir(struct vop_readdir_args *ap)
1355 {
1356         struct vnode *vp;
1357         struct mqfs_info *mi;
1358         struct mqfs_node *pd;
1359         struct mqfs_node *pn;
1360         struct dirent entry;
1361         struct uio *uio;
1362         int *tmp_ncookies = NULL;
1363         off_t offset;
1364         int error, i;
1365
1366         vp = ap->a_vp;
1367         mi = VFSTOMQFS(vp->v_mount);
1368         pd = VTON(vp);
1369         uio = ap->a_uio;
1370
1371         if (vp->v_type != VDIR)
1372                 return (ENOTDIR);
1373
1374         if (uio->uio_offset < 0)
1375                 return (EINVAL);
1376
1377         if (ap->a_ncookies != NULL) {
1378                 tmp_ncookies = ap->a_ncookies;
1379                 *ap->a_ncookies = 0;
1380                 ap->a_ncookies = NULL;
1381         }
1382
1383         error = 0;
1384         offset = 0;
1385
1386         sx_xlock(&mi->mi_lock);
1387
1388         LIST_FOREACH(pn, &pd->mn_children, mn_sibling) {
1389                 entry.d_reclen = sizeof(entry);
1390                 if (!pn->mn_fileno)
1391                         mqfs_fileno_alloc(mi, pn);
1392                 entry.d_fileno = pn->mn_fileno;
1393                 for (i = 0; i < MQFS_NAMELEN - 1 && pn->mn_name[i] != '\0'; ++i)
1394                         entry.d_name[i] = pn->mn_name[i];
1395                 entry.d_name[i] = 0;
1396                 entry.d_namlen = i;
1397                 switch (pn->mn_type) {
1398                 case mqfstype_root:
1399                 case mqfstype_dir:
1400                 case mqfstype_this:
1401                 case mqfstype_parent:
1402                         entry.d_type = DT_DIR;
1403                         break;
1404                 case mqfstype_file:
1405                         entry.d_type = DT_REG;
1406                         break;
1407                 case mqfstype_symlink:
1408                         entry.d_type = DT_LNK;
1409                         break;
1410                 default:
1411                         panic("%s has unexpected node type: %d", pn->mn_name,
1412                                 pn->mn_type);
1413                 }
1414                 if (entry.d_reclen > uio->uio_resid)
1415                         break;
1416                 if (offset >= uio->uio_offset) {
1417                         error = vfs_read_dirent(ap, &entry, offset);
1418                         if (error)
1419                                 break;
1420                 }
1421                 offset += entry.d_reclen;
1422         }
1423         sx_xunlock(&mi->mi_lock);
1424
1425         uio->uio_offset = offset;
1426
1427         if (tmp_ncookies != NULL)
1428                 ap->a_ncookies = tmp_ncookies;
1429
1430         return (error);
1431 }
1432
1433 #ifdef notyet
1434
1435 #if 0
1436 struct vop_mkdir_args {
1437         struct vnode *a_dvp;
1438         struvt vnode **a_vpp;
1439         struvt componentname *a_cnp;
1440         struct vattr *a_vap;
1441 };
1442 #endif
1443
1444 /*
1445  * Create a directory.
1446  */
1447 static int
1448 mqfs_mkdir(struct vop_mkdir_args *ap)
1449 {
1450         struct mqfs_info *mqfs = VFSTOMQFS(ap->a_dvp->v_mount);
1451         struct componentname *cnp = ap->a_cnp;
1452         struct mqfs_node *pd = VTON(ap->a_dvp);
1453         struct mqfs_node *pn;
1454         int error;
1455
1456         if (pd->mn_type != mqfstype_root && pd->mn_type != mqfstype_dir)
1457                 return (ENOTDIR);
1458         sx_xlock(&mqfs->mi_lock);
1459         if ((cnp->cn_flags & HASBUF) == 0)
1460                 panic("%s: no name", __func__);
1461         pn = mqfs_create_dir(pd, cnp->cn_nameptr, cnp->cn_namelen,
1462                 ap->a_vap->cn_cred, ap->a_vap->va_mode);
1463         if (pn != NULL)
1464                 mqnode_addref(pn);
1465         sx_xunlock(&mqfs->mi_lock);
1466         if (pn == NULL) {
1467                 error = ENOSPC;
1468         } else {
1469                 error = mqfs_allocv(ap->a_dvp->v_mount, ap->a_vpp, pn);
1470                 mqnode_release(pn);
1471         }
1472         return (error);
1473 }
1474
1475 #if 0
1476 struct vop_rmdir_args {
1477         struct vnode *a_dvp;
1478         struct vnode *a_vp;
1479         struct componentname *a_cnp;
1480 };
1481 #endif
1482
1483 /*
1484  * Remove a directory.
1485  */
1486 static int
1487 mqfs_rmdir(struct vop_rmdir_args *ap)
1488 {
1489         struct mqfs_info *mqfs = VFSTOMQFS(ap->a_dvp->v_mount);
1490         struct mqfs_node *pn = VTON(ap->a_vp);
1491         struct mqfs_node *pt;
1492
1493         if (pn->mn_type != mqfstype_dir)
1494                 return (ENOTDIR);
1495
1496         sx_xlock(&mqfs->mi_lock);
1497         if (pn->mn_deleted) {
1498                 sx_xunlock(&mqfs->mi_lock);
1499                 return (ENOENT);
1500         }
1501
1502         pt = LIST_FIRST(&pn->mn_children);
1503         pt = LIST_NEXT(pt, mn_sibling);
1504         pt = LIST_NEXT(pt, mn_sibling);
1505         if (pt != NULL) {
1506                 sx_xunlock(&mqfs->mi_lock);
1507                 return (ENOTEMPTY);
1508         }
1509         pt = pn->mn_parent;
1510         pn->mn_parent = NULL;
1511         pn->mn_deleted = 1;
1512         LIST_REMOVE(pn, mn_sibling);
1513         mqnode_release(pn);
1514         mqnode_release(pt);
1515         sx_xunlock(&mqfs->mi_lock);
1516         cache_purge(ap->a_vp);
1517         return (0);
1518 }
1519
1520 #endif /* notyet */
1521
1522 /*
1523  * Allocate a message queue
1524  */
1525 static struct mqueue *
1526 mqueue_alloc(const struct mq_attr *attr)
1527 {
1528         struct mqueue *mq;
1529
1530         if (curmq >= maxmq)
1531                 return (NULL);
1532         mq = uma_zalloc(mqueue_zone, M_WAITOK | M_ZERO);
1533         TAILQ_INIT(&mq->mq_msgq);
1534         if (attr != NULL) {
1535                 mq->mq_maxmsg = attr->mq_maxmsg;
1536                 mq->mq_msgsize = attr->mq_msgsize;
1537         } else {
1538                 mq->mq_maxmsg = default_maxmsg;
1539                 mq->mq_msgsize = default_msgsize;
1540         }
1541         mtx_init(&mq->mq_mutex, "mqueue lock", NULL, MTX_DEF);
1542         knlist_init_mtx(&mq->mq_rsel.si_note, &mq->mq_mutex);
1543         knlist_init_mtx(&mq->mq_wsel.si_note, &mq->mq_mutex);
1544         atomic_add_int(&curmq, 1);
1545         return (mq);
1546 }
1547
1548 /*
1549  * Destroy a message queue
1550  */
1551 static void
1552 mqueue_free(struct mqueue *mq)
1553 {
1554         struct mqueue_msg *msg;
1555
1556         while ((msg = TAILQ_FIRST(&mq->mq_msgq)) != NULL) {
1557                 TAILQ_REMOVE(&mq->mq_msgq, msg, msg_link);
1558                 free(msg, M_MQUEUEDATA);
1559         }
1560
1561         mtx_destroy(&mq->mq_mutex);
1562         knlist_destroy(&mq->mq_rsel.si_note);
1563         knlist_destroy(&mq->mq_wsel.si_note);
1564         uma_zfree(mqueue_zone, mq);
1565         atomic_add_int(&curmq, -1);
1566 }
1567
1568 /*
1569  * Load a message from user space
1570  */
1571 static struct mqueue_msg *
1572 mqueue_loadmsg(const char *msg_ptr, size_t msg_size, int msg_prio)
1573 {
1574         struct mqueue_msg *msg;
1575         size_t len;
1576         int error;
1577
1578         len = sizeof(struct mqueue_msg) + msg_size;
1579         msg = malloc(len, M_MQUEUEDATA, M_WAITOK);
1580         error = copyin(msg_ptr, ((char *)msg) + sizeof(struct mqueue_msg),
1581             msg_size);
1582         if (error) {
1583                 free(msg, M_MQUEUEDATA);
1584                 msg = NULL;
1585         } else {
1586                 msg->msg_size = msg_size;
1587                 msg->msg_prio = msg_prio;
1588         }
1589         return (msg);
1590 }
1591
1592 /*
1593  * Save a message to user space
1594  */
1595 static int
1596 mqueue_savemsg(struct mqueue_msg *msg, char *msg_ptr, int *msg_prio)
1597 {
1598         int error;
1599
1600         error = copyout(((char *)msg) + sizeof(*msg), msg_ptr,
1601                 msg->msg_size);
1602         if (error == 0 && msg_prio != NULL)
1603                 error = copyout(&msg->msg_prio, msg_prio, sizeof(int));
1604         return (error);
1605 }
1606
1607 /*
1608  * Free a message's memory
1609  */
1610 static __inline void
1611 mqueue_freemsg(struct mqueue_msg *msg)
1612 {
1613         free(msg, M_MQUEUEDATA);
1614 }
1615
1616 /*
1617  * Send a message. if waitok is false, thread will not be
1618  * blocked if there is no data in queue, otherwise, absolute
1619  * time will be checked.
1620  */
1621 int
1622 mqueue_send(struct mqueue *mq, const char *msg_ptr,
1623         size_t msg_len, unsigned msg_prio, int waitok,
1624         const struct timespec *abs_timeout)
1625 {
1626         struct mqueue_msg *msg;
1627         struct timespec ts, ts2;
1628         struct timeval tv;
1629         int error;
1630
1631         if (msg_prio >= MQ_PRIO_MAX)
1632                 return (EINVAL);
1633         if (msg_len > mq->mq_msgsize)
1634                 return (EMSGSIZE);
1635         msg = mqueue_loadmsg(msg_ptr, msg_len, msg_prio);
1636         if (msg == NULL)
1637                 return (EFAULT);
1638
1639         /* O_NONBLOCK case */
1640         if (!waitok) {
1641                 error = _mqueue_send(mq, msg, -1);
1642                 if (error)
1643                         goto bad;
1644                 return (0);
1645         }
1646
1647         /* we allow a null timeout (wait forever) */
1648         if (abs_timeout == NULL) {
1649                 error = _mqueue_send(mq, msg, 0);
1650                 if (error)
1651                         goto bad;
1652                 return (0);
1653         }
1654
1655         /* send it before checking time */
1656         error = _mqueue_send(mq, msg, -1);
1657         if (error == 0)
1658                 return (0);
1659
1660         if (error != EAGAIN)
1661                 goto bad;
1662
1663         if (abs_timeout->tv_nsec >= 1000000000 || abs_timeout->tv_nsec < 0) {
1664                 error = EINVAL;
1665                 goto bad;
1666         }
1667         for (;;) {
1668                 ts2 = *abs_timeout;
1669                 getnanotime(&ts);
1670                 timespecsub(&ts2, &ts);
1671                 if (ts2.tv_sec < 0 || (ts2.tv_sec == 0 && ts2.tv_nsec <= 0)) {
1672                         error = ETIMEDOUT;
1673                         break;
1674                 }
1675                 TIMESPEC_TO_TIMEVAL(&tv, &ts2);
1676                 error = _mqueue_send(mq, msg, tvtohz(&tv));
1677                 if (error != ETIMEDOUT)
1678                         break;
1679         }
1680         if (error == 0)
1681                 return (0);
1682 bad:
1683         mqueue_freemsg(msg);
1684         return (error);
1685 }
1686
1687 /*
1688  * Common routine to send a message
1689  */
1690 static int
1691 _mqueue_send(struct mqueue *mq, struct mqueue_msg *msg, int timo)
1692 {
1693         struct mqueue_msg *msg2;
1694         int error = 0;
1695
1696         mtx_lock(&mq->mq_mutex);
1697         while (mq->mq_curmsgs >= mq->mq_maxmsg && error == 0) {
1698                 if (timo < 0) {
1699                         mtx_unlock(&mq->mq_mutex);
1700                         return (EAGAIN);
1701                 }
1702                 mq->mq_senders++;
1703                 error = msleep(&mq->mq_senders, &mq->mq_mutex,
1704                             PCATCH, "mqsend", timo);
1705                 mq->mq_senders--;
1706                 if (error == EAGAIN)
1707                         error = ETIMEDOUT;
1708         }
1709         if (mq->mq_curmsgs >= mq->mq_maxmsg) {
1710                 mtx_unlock(&mq->mq_mutex);
1711                 return (error);
1712         }
1713         error = 0;
1714         if (TAILQ_EMPTY(&mq->mq_msgq)) {
1715                 TAILQ_INSERT_HEAD(&mq->mq_msgq, msg, msg_link);
1716         } else {
1717                 if (msg->msg_prio <= TAILQ_LAST(&mq->mq_msgq, msgq)->msg_prio) {
1718                         TAILQ_INSERT_TAIL(&mq->mq_msgq, msg, msg_link);
1719                 } else {
1720                         TAILQ_FOREACH(msg2, &mq->mq_msgq, msg_link) {
1721                                 if (msg2->msg_prio < msg->msg_prio)
1722                                         break;
1723                         }
1724                         TAILQ_INSERT_BEFORE(msg2, msg, msg_link);
1725                 }
1726         }
1727         mq->mq_curmsgs++;
1728         mq->mq_totalbytes += msg->msg_size;
1729         if (mq->mq_receivers)
1730                 wakeup_one(&mq->mq_receivers);
1731         else if (mq->mq_notifier != NULL)
1732                 mqueue_send_notification(mq);
1733         if (mq->mq_flags & MQ_RSEL) {
1734                 mq->mq_flags &= ~MQ_RSEL;
1735                 selwakeup(&mq->mq_rsel);
1736         }
1737         KNOTE_LOCKED(&mq->mq_rsel.si_note, 0);
1738         mtx_unlock(&mq->mq_mutex);
1739         return (0);
1740 }
1741
1742 /*
1743  * Send realtime a signal to process which registered itself
1744  * successfully by mq_notify.
1745  */
1746 static void
1747 mqueue_send_notification(struct mqueue *mq)
1748 {
1749         struct mqueue_notifier *nt;
1750         struct thread *td;
1751         struct proc *p;
1752         int error;
1753
1754         mtx_assert(&mq->mq_mutex, MA_OWNED);
1755         nt = mq->mq_notifier;
1756         if (nt->nt_sigev.sigev_notify != SIGEV_NONE) {
1757                 p = nt->nt_proc;
1758                 error = sigev_findtd(p, &nt->nt_sigev, &td);
1759                 if (error) {
1760                         mq->mq_notifier = NULL;
1761                         return;
1762                 }
1763                 if (!KSI_ONQ(&nt->nt_ksi)) {
1764                         ksiginfo_set_sigev(&nt->nt_ksi, &nt->nt_sigev);
1765                         tdsendsignal(p, td, nt->nt_ksi.ksi_signo, &nt->nt_ksi);
1766                 }
1767                 PROC_UNLOCK(p);
1768         }
1769         mq->mq_notifier = NULL;
1770 }
1771
1772 /*
1773  * Get a message. if waitok is false, thread will not be
1774  * blocked if there is no data in queue, otherwise, absolute
1775  * time will be checked.
1776  */
1777 int
1778 mqueue_receive(struct mqueue *mq, char *msg_ptr,
1779         size_t msg_len, unsigned *msg_prio, int waitok,
1780         const struct timespec *abs_timeout)
1781 {
1782         struct mqueue_msg *msg;
1783         struct timespec ts, ts2;
1784         struct timeval tv;
1785         int error;
1786
1787         if (msg_len < mq->mq_msgsize)
1788                 return (EMSGSIZE);
1789
1790         /* O_NONBLOCK case */
1791         if (!waitok) {
1792                 error = _mqueue_recv(mq, &msg, -1);
1793                 if (error)
1794                         return (error);
1795                 goto received;
1796         }
1797
1798         /* we allow a null timeout (wait forever). */
1799         if (abs_timeout == NULL) {
1800                 error = _mqueue_recv(mq, &msg, 0);
1801                 if (error)
1802                         return (error);
1803                 goto received;
1804         }
1805
1806         /* try to get a message before checking time */
1807         error = _mqueue_recv(mq, &msg, -1);
1808         if (error == 0)
1809                 goto received;
1810
1811         if (error != EAGAIN)
1812                 return (error);
1813
1814         if (abs_timeout->tv_nsec >= 1000000000 || abs_timeout->tv_nsec < 0) {
1815                 error = EINVAL;
1816                 return (error);
1817         }
1818
1819         for (;;) {
1820                 ts2 = *abs_timeout;
1821                 getnanotime(&ts);
1822                 timespecsub(&ts2, &ts);
1823                 if (ts2.tv_sec < 0 || (ts2.tv_sec == 0 && ts2.tv_nsec <= 0)) {
1824                         error = ETIMEDOUT;
1825                         return (error);
1826                 }
1827                 TIMESPEC_TO_TIMEVAL(&tv, &ts2);
1828                 error = _mqueue_recv(mq, &msg, tvtohz(&tv));
1829                 if (error == 0)
1830                         break;
1831                 if (error != ETIMEDOUT)
1832                         return (error);
1833         }
1834
1835 received:
1836         error = mqueue_savemsg(msg, msg_ptr, msg_prio);
1837         if (error == 0) {
1838                 curthread->td_retval[0] = msg->msg_size;
1839                 curthread->td_retval[1] = 0;
1840         }
1841         mqueue_freemsg(msg);
1842         return (error);
1843 }
1844
1845 /*
1846  * Common routine to receive a message
1847  */
1848 static int
1849 _mqueue_recv(struct mqueue *mq, struct mqueue_msg **msg, int timo)
1850 {
1851         int error = 0;
1852
1853         mtx_lock(&mq->mq_mutex);
1854         while ((*msg = TAILQ_FIRST(&mq->mq_msgq)) == NULL && error == 0) {
1855                 if (timo < 0) {
1856                         mtx_unlock(&mq->mq_mutex);
1857                         return (EAGAIN);
1858                 }
1859                 mq->mq_receivers++;
1860                 error = msleep(&mq->mq_receivers, &mq->mq_mutex,
1861                             PCATCH, "mqrecv", timo);
1862                 mq->mq_receivers--;
1863                 if (error == EAGAIN)
1864                         error = ETIMEDOUT;
1865         }
1866         if (*msg != NULL) {
1867                 error = 0;
1868                 TAILQ_REMOVE(&mq->mq_msgq, *msg, msg_link);
1869                 mq->mq_curmsgs--;
1870                 mq->mq_totalbytes -= (*msg)->msg_size;
1871                 if (mq->mq_senders)
1872                         wakeup_one(&mq->mq_senders);
1873                 if (mq->mq_flags & MQ_WSEL) {
1874                         mq->mq_flags &= ~MQ_WSEL;
1875                         selwakeup(&mq->mq_wsel);
1876                 }
1877                 KNOTE_LOCKED(&mq->mq_wsel.si_note, 0);
1878         }
1879         if (mq->mq_notifier != NULL && mq->mq_receivers == 0 &&
1880             !TAILQ_EMPTY(&mq->mq_msgq)) {
1881                 mqueue_send_notification(mq);
1882         }
1883         mtx_unlock(&mq->mq_mutex);
1884         return (error);
1885 }
1886
1887 static __inline struct mqueue_notifier *
1888 notifier_alloc(void)
1889 {
1890         return (uma_zalloc(mqnoti_zone, M_WAITOK | M_ZERO));
1891 }
1892
1893 static __inline void
1894 notifier_free(struct mqueue_notifier *p)
1895 {
1896         uma_zfree(mqnoti_zone, p);
1897 }
1898
1899 static struct mqueue_notifier *
1900 notifier_search(struct proc *p, int fd)
1901 {
1902         struct mqueue_notifier *nt;
1903
1904         LIST_FOREACH(nt, &p->p_mqnotifier, nt_link) {
1905                 if (nt->nt_ksi.ksi_mqd == fd)
1906                         break;
1907         }
1908         return (nt);
1909 }
1910
1911 static __inline void
1912 notifier_insert(struct proc *p, struct mqueue_notifier *nt)
1913 {
1914         LIST_INSERT_HEAD(&p->p_mqnotifier, nt, nt_link);
1915 }
1916
1917 static __inline void
1918 notifier_delete(struct proc *p, struct mqueue_notifier *nt)
1919 {
1920         LIST_REMOVE(nt, nt_link);
1921         notifier_free(nt);
1922 }
1923
1924 static void
1925 notifier_remove(struct proc *p, struct mqueue *mq, int fd)
1926 {
1927         struct mqueue_notifier *nt;
1928
1929         mtx_assert(&mq->mq_mutex, MA_OWNED);
1930         PROC_LOCK(p);
1931         nt = notifier_search(p, fd);
1932         if (nt != NULL) {
1933                 if (mq->mq_notifier == nt)
1934                         mq->mq_notifier = NULL;
1935                 sigqueue_take(&nt->nt_ksi);
1936                 notifier_delete(p, nt);
1937         }
1938         PROC_UNLOCK(p);
1939 }
1940
1941 static int
1942 kern_kmq_open(struct thread *td, const char *upath, int flags, mode_t mode,
1943     const struct mq_attr *attr)
1944 {
1945         char path[MQFS_NAMELEN + 1];
1946         struct mqfs_node *pn;
1947         struct filedesc *fdp;
1948         struct file *fp;
1949         struct mqueue *mq;
1950         int fd, error, len, cmode;
1951
1952         fdp = td->td_proc->p_fd;
1953         cmode = (((mode & ~fdp->fd_cmask) & ALLPERMS) & ~S_ISTXT);
1954         mq = NULL;
1955         if ((flags & O_CREAT) != 0 && attr != NULL) {
1956                 if (attr->mq_maxmsg <= 0 || attr->mq_maxmsg > maxmsg)
1957                         return (EINVAL);
1958                 if (attr->mq_msgsize <= 0 || attr->mq_msgsize > maxmsgsize)
1959                         return (EINVAL);
1960         }
1961
1962         error = copyinstr(upath, path, MQFS_NAMELEN + 1, NULL);
1963         if (error)
1964                 return (error);
1965
1966         /*
1967          * The first character of name must be a slash  (/) character
1968          * and the remaining characters of name cannot include any slash
1969          * characters.
1970          */
1971         len = strlen(path);
1972         if (len < 2  || path[0] != '/' || index(path + 1, '/') != NULL)
1973                 return (EINVAL);
1974
1975         error = falloc(td, &fp, &fd);
1976         if (error)
1977                 return (error);
1978
1979         sx_xlock(&mqfs_data.mi_lock);
1980         pn = mqfs_search(mqfs_data.mi_root, path + 1, len - 1);
1981         if (pn == NULL) {
1982                 if (!(flags & O_CREAT)) {
1983                         error = ENOENT;
1984                 } else {
1985                         mq = mqueue_alloc(attr);
1986                         if (mq == NULL) {
1987                                 error = ENFILE;
1988                         } else {
1989                                 pn = mqfs_create_file(mqfs_data.mi_root,
1990                                          path + 1, len - 1, td->td_ucred,
1991                                          cmode);
1992                                 if (pn == NULL) {
1993                                         error = ENOSPC;
1994                                         mqueue_free(mq);
1995                                 }
1996                         }
1997                 }
1998
1999                 if (error == 0) {
2000                         pn->mn_data = mq;
2001                 }
2002         } else {
2003                 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL)) {
2004                         error = EEXIST;
2005                 } else {
2006                         accmode_t accmode = 0;
2007
2008                         if (flags & FREAD)
2009                                 accmode |= VREAD;
2010                         if (flags & FWRITE)
2011                                 accmode |= VWRITE;
2012                         error = vaccess(VREG, pn->mn_mode, pn->mn_uid,
2013                                     pn->mn_gid, accmode, td->td_ucred, NULL);
2014                 }
2015         }
2016
2017         if (error) {
2018                 sx_xunlock(&mqfs_data.mi_lock);
2019                 fdclose(fdp, fp, fd, td);
2020                 fdrop(fp, td);
2021                 return (error);
2022         }
2023
2024         mqnode_addref(pn);
2025         sx_xunlock(&mqfs_data.mi_lock);
2026
2027         finit(fp, flags & (FREAD | FWRITE | O_NONBLOCK), DTYPE_MQUEUE, pn,
2028             &mqueueops);
2029
2030         FILEDESC_XLOCK(fdp);
2031         if (fdp->fd_ofiles[fd] == fp)
2032                 fdp->fd_ofileflags[fd] |= UF_EXCLOSE;
2033         FILEDESC_XUNLOCK(fdp);
2034         td->td_retval[0] = fd;
2035         fdrop(fp, td);
2036         return (0);
2037 }
2038
2039 /*
2040  * Syscall to open a message queue.
2041  */
2042 int
2043 kmq_open(struct thread *td, struct kmq_open_args *uap)
2044 {
2045         struct mq_attr attr;
2046         int flags, error;
2047
2048         if ((uap->flags & O_ACCMODE) == O_ACCMODE)
2049                 return (EINVAL);
2050         flags = FFLAGS(uap->flags);
2051         if ((flags & O_CREAT) != 0 && uap->attr != NULL) {
2052                 error = copyin(uap->attr, &attr, sizeof(attr));
2053                 if (error)
2054                         return (error);
2055         }
2056         return (kern_kmq_open(td, uap->path, flags, uap->mode,
2057             uap->attr != NULL ? &attr : NULL));
2058 }
2059
2060 /*
2061  * Syscall to unlink a message queue.
2062  */
2063 int
2064 kmq_unlink(struct thread *td, struct kmq_unlink_args *uap)
2065 {
2066         char path[MQFS_NAMELEN+1];
2067         struct mqfs_node *pn;
2068         int error, len;
2069
2070         error = copyinstr(uap->path, path, MQFS_NAMELEN + 1, NULL);
2071         if (error)
2072                 return (error);
2073
2074         len = strlen(path);
2075         if (len < 2  || path[0] != '/' || index(path + 1, '/') != NULL)
2076                 return (EINVAL);
2077
2078         sx_xlock(&mqfs_data.mi_lock);
2079         pn = mqfs_search(mqfs_data.mi_root, path + 1, len - 1);
2080         if (pn != NULL)
2081                 error = do_unlink(pn, td->td_ucred);
2082         else
2083                 error = ENOENT;
2084         sx_xunlock(&mqfs_data.mi_lock);
2085         return (error);
2086 }
2087
2088 typedef int (*_fgetf)(struct thread *, int, struct file **);
2089
2090 /*
2091  * Get message queue by giving file slot
2092  */
2093 static int
2094 _getmq(struct thread *td, int fd, _fgetf func,
2095        struct file **fpp, struct mqfs_node **ppn, struct mqueue **pmq)
2096 {
2097         struct mqfs_node *pn;
2098         int error;
2099
2100         error = func(td, fd, fpp);
2101         if (error)
2102                 return (error);
2103         if (&mqueueops != (*fpp)->f_ops) {
2104                 fdrop(*fpp, td);
2105                 return (EBADF);
2106         }
2107         pn = (*fpp)->f_data;
2108         if (ppn)
2109                 *ppn = pn;
2110         if (pmq)
2111                 *pmq = pn->mn_data;
2112         return (0);
2113 }
2114
2115 static __inline int
2116 getmq(struct thread *td, int fd, struct file **fpp, struct mqfs_node **ppn,
2117         struct mqueue **pmq)
2118 {
2119         return _getmq(td, fd, fget, fpp, ppn, pmq);
2120 }
2121
2122 static __inline int
2123 getmq_read(struct thread *td, int fd, struct file **fpp,
2124          struct mqfs_node **ppn, struct mqueue **pmq)
2125 {
2126         return _getmq(td, fd, fget_read, fpp, ppn, pmq);
2127 }
2128
2129 static __inline int
2130 getmq_write(struct thread *td, int fd, struct file **fpp,
2131         struct mqfs_node **ppn, struct mqueue **pmq)
2132 {
2133         return _getmq(td, fd, fget_write, fpp, ppn, pmq);
2134 }
2135
2136 static int
2137 kern_kmq_setattr(struct thread *td, int mqd, const struct mq_attr *attr,
2138     struct mq_attr *oattr)
2139 {
2140         struct mqueue *mq;
2141         struct file *fp;
2142         u_int oflag, flag;
2143         int error;
2144
2145         if (attr != NULL && (attr->mq_flags & ~O_NONBLOCK) != 0)
2146                 return (EINVAL);
2147         error = getmq(td, mqd, &fp, NULL, &mq);
2148         if (error)
2149                 return (error);
2150         oattr->mq_maxmsg  = mq->mq_maxmsg;
2151         oattr->mq_msgsize = mq->mq_msgsize;
2152         oattr->mq_curmsgs = mq->mq_curmsgs;
2153         if (attr != NULL) {
2154                 do {
2155                         oflag = flag = fp->f_flag;
2156                         flag &= ~O_NONBLOCK;
2157                         flag |= (attr->mq_flags & O_NONBLOCK);
2158                 } while (atomic_cmpset_int(&fp->f_flag, oflag, flag) == 0);
2159         } else
2160                 oflag = fp->f_flag;
2161         oattr->mq_flags = (O_NONBLOCK & oflag);
2162         fdrop(fp, td);
2163         return (error);
2164 }
2165
2166 int
2167 kmq_setattr(struct thread *td, struct kmq_setattr_args *uap)
2168 {
2169         struct mq_attr attr, oattr;
2170         int error;
2171
2172         if (uap->attr != NULL) {
2173                 error = copyin(uap->attr, &attr, sizeof(attr));
2174                 if (error != 0)
2175                         return (error);
2176         }
2177         error = kern_kmq_setattr(td, uap->mqd, uap->attr != NULL ? &attr : NULL,
2178             &oattr);
2179         if (error != 0)
2180                 return (error);
2181         if (uap->oattr != NULL)
2182                 error = copyout(&oattr, uap->oattr, sizeof(oattr));
2183         return (error);
2184 }
2185
2186 int
2187 kmq_timedreceive(struct thread *td, struct kmq_timedreceive_args *uap)
2188 {
2189         struct mqueue *mq;
2190         struct file *fp;
2191         struct timespec *abs_timeout, ets;
2192         int error;
2193         int waitok;
2194
2195         error = getmq_read(td, uap->mqd, &fp, NULL, &mq);
2196         if (error)
2197                 return (error);
2198         if (uap->abs_timeout != NULL) {
2199                 error = copyin(uap->abs_timeout, &ets, sizeof(ets));
2200                 if (error != 0)
2201                         return (error);
2202                 abs_timeout = &ets;
2203         } else
2204                 abs_timeout = NULL;
2205         waitok = !(fp->f_flag & O_NONBLOCK);
2206         error = mqueue_receive(mq, uap->msg_ptr, uap->msg_len,
2207                 uap->msg_prio, waitok, abs_timeout);
2208         fdrop(fp, td);
2209         return (error);
2210 }
2211
2212 int
2213 kmq_timedsend(struct thread *td, struct kmq_timedsend_args *uap)
2214 {
2215         struct mqueue *mq;
2216         struct file *fp;
2217         struct timespec *abs_timeout, ets;
2218         int error, waitok;
2219
2220         error = getmq_write(td, uap->mqd, &fp, NULL, &mq);
2221         if (error)
2222                 return (error);
2223         if (uap->abs_timeout != NULL) {
2224                 error = copyin(uap->abs_timeout, &ets, sizeof(ets));
2225                 if (error != 0)
2226                         return (error);
2227                 abs_timeout = &ets;
2228         } else
2229                 abs_timeout = NULL;
2230         waitok = !(fp->f_flag & O_NONBLOCK);
2231         error = mqueue_send(mq, uap->msg_ptr, uap->msg_len,
2232                 uap->msg_prio, waitok, abs_timeout);
2233         fdrop(fp, td);
2234         return (error);
2235 }
2236
2237 int
2238 kmq_notify(struct thread *td, struct kmq_notify_args *uap)
2239 {
2240         struct sigevent ev;
2241         struct filedesc *fdp;
2242         struct proc *p;
2243         struct mqueue *mq;
2244         struct file *fp;
2245         struct mqueue_notifier *nt, *newnt = NULL;
2246         int error;
2247
2248         p = td->td_proc;
2249         fdp = td->td_proc->p_fd;
2250         if (uap->sigev) {
2251                 error = copyin(uap->sigev, &ev, sizeof(ev));
2252                 if (error)
2253                         return (error);
2254                 if (ev.sigev_notify != SIGEV_SIGNAL &&
2255                     ev.sigev_notify != SIGEV_THREAD_ID &&
2256                     ev.sigev_notify != SIGEV_NONE)
2257                         return (EINVAL);
2258                 if ((ev.sigev_notify == SIGEV_SIGNAL ||
2259                      ev.sigev_notify == SIGEV_THREAD_ID) &&
2260                         !_SIG_VALID(ev.sigev_signo))
2261                         return (EINVAL);
2262         }
2263         error = getmq(td, uap->mqd, &fp, NULL, &mq);
2264         if (error)
2265                 return (error);
2266 again:
2267         FILEDESC_SLOCK(fdp);
2268         if (fget_locked(fdp, uap->mqd) != fp) {
2269                 FILEDESC_SUNLOCK(fdp);
2270                 error = EBADF;
2271                 goto out;
2272         }
2273         mtx_lock(&mq->mq_mutex);
2274         FILEDESC_SUNLOCK(fdp);
2275         if (uap->sigev != NULL) {
2276                 if (mq->mq_notifier != NULL) {
2277                         error = EBUSY;
2278                 } else {
2279                         PROC_LOCK(p);
2280                         nt = notifier_search(p, uap->mqd);
2281                         if (nt == NULL) {
2282                                 if (newnt == NULL) {
2283                                         PROC_UNLOCK(p);
2284                                         mtx_unlock(&mq->mq_mutex);
2285                                         newnt = notifier_alloc();
2286                                         goto again;
2287                                 }
2288                         }
2289
2290                         if (nt != NULL) {
2291                                 sigqueue_take(&nt->nt_ksi);
2292                                 if (newnt != NULL) {
2293                                         notifier_free(newnt);
2294                                         newnt = NULL;
2295                                 }
2296                         } else {
2297                                 nt = newnt;
2298                                 newnt = NULL;
2299                                 ksiginfo_init(&nt->nt_ksi);
2300                                 nt->nt_ksi.ksi_flags |= KSI_INS | KSI_EXT;
2301                                 nt->nt_ksi.ksi_code = SI_MESGQ;
2302                                 nt->nt_proc = p;
2303                                 nt->nt_ksi.ksi_mqd = uap->mqd;
2304                                 notifier_insert(p, nt);
2305                         }
2306                         nt->nt_sigev = ev;
2307                         mq->mq_notifier = nt;
2308                         PROC_UNLOCK(p);
2309                         /*
2310                          * if there is no receivers and message queue
2311                          * is not empty, we should send notification
2312                          * as soon as possible.
2313                          */
2314                         if (mq->mq_receivers == 0 &&
2315                             !TAILQ_EMPTY(&mq->mq_msgq))
2316                                 mqueue_send_notification(mq);
2317                 }
2318         } else {
2319                 notifier_remove(p, mq, uap->mqd);
2320         }
2321         mtx_unlock(&mq->mq_mutex);
2322
2323 out:
2324         fdrop(fp, td);
2325         if (newnt != NULL)
2326                 notifier_free(newnt);
2327         return (error);
2328 }
2329
2330 static void
2331 mqueue_fdclose(struct thread *td, int fd, struct file *fp)
2332 {
2333         struct filedesc *fdp;
2334         struct mqueue *mq;
2335
2336         fdp = td->td_proc->p_fd;
2337         FILEDESC_LOCK_ASSERT(fdp);
2338
2339         if (fp->f_ops == &mqueueops) {
2340                 mq = FPTOMQ(fp);
2341                 mtx_lock(&mq->mq_mutex);
2342                 notifier_remove(td->td_proc, mq, fd);
2343
2344                 /* have to wakeup thread in same process */
2345                 if (mq->mq_flags & MQ_RSEL) {
2346                         mq->mq_flags &= ~MQ_RSEL;
2347                         selwakeup(&mq->mq_rsel);
2348                 }
2349                 if (mq->mq_flags & MQ_WSEL) {
2350                         mq->mq_flags &= ~MQ_WSEL;
2351                         selwakeup(&mq->mq_wsel);
2352                 }
2353                 mtx_unlock(&mq->mq_mutex);
2354         }
2355 }
2356
2357 static void
2358 mq_proc_exit(void *arg __unused, struct proc *p)
2359 {
2360         struct filedesc *fdp;
2361         struct file *fp;
2362         struct mqueue *mq;
2363         int i;
2364
2365         fdp = p->p_fd;
2366         FILEDESC_SLOCK(fdp);
2367         for (i = 0; i < fdp->fd_nfiles; ++i) {
2368                 fp = fget_locked(fdp, i);
2369                 if (fp != NULL && fp->f_ops == &mqueueops) {
2370                         mq = FPTOMQ(fp);
2371                         mtx_lock(&mq->mq_mutex);
2372                         notifier_remove(p, FPTOMQ(fp), i);
2373                         mtx_unlock(&mq->mq_mutex);
2374                 }
2375         }
2376         FILEDESC_SUNLOCK(fdp);
2377         KASSERT(LIST_EMPTY(&p->p_mqnotifier), ("mq notifiers left"));
2378 }
2379
2380 static int
2381 mqf_read(struct file *fp, struct uio *uio, struct ucred *active_cred,
2382         int flags, struct thread *td)
2383 {
2384         return (EOPNOTSUPP);
2385 }
2386
2387 static int
2388 mqf_write(struct file *fp, struct uio *uio, struct ucred *active_cred,
2389         int flags, struct thread *td)
2390 {
2391         return (EOPNOTSUPP);
2392 }
2393
2394 static int
2395 mqf_truncate(struct file *fp, off_t length, struct ucred *active_cred,
2396     struct thread *td)
2397 {
2398
2399         return (EINVAL);
2400 }
2401
2402 static int
2403 mqf_ioctl(struct file *fp, u_long cmd, void *data,
2404         struct ucred *active_cred, struct thread *td)
2405 {
2406         return (ENOTTY);
2407 }
2408
2409 static int
2410 mqf_poll(struct file *fp, int events, struct ucred *active_cred,
2411         struct thread *td)
2412 {
2413         struct mqueue *mq = FPTOMQ(fp);
2414         int revents = 0;
2415
2416         mtx_lock(&mq->mq_mutex);
2417         if (events & (POLLIN | POLLRDNORM)) {
2418                 if (mq->mq_curmsgs) {
2419                         revents |= events & (POLLIN | POLLRDNORM);
2420                 } else {
2421                         mq->mq_flags |= MQ_RSEL;
2422                         selrecord(td, &mq->mq_rsel);
2423                 }
2424         }
2425         if (events & POLLOUT) {
2426                 if (mq->mq_curmsgs < mq->mq_maxmsg)
2427                         revents |= POLLOUT;
2428                 else {
2429                         mq->mq_flags |= MQ_WSEL;
2430                         selrecord(td, &mq->mq_wsel);
2431                 }
2432         }
2433         mtx_unlock(&mq->mq_mutex);
2434         return (revents);
2435 }
2436
2437 static int
2438 mqf_close(struct file *fp, struct thread *td)
2439 {
2440         struct mqfs_node *pn;
2441
2442         fp->f_ops = &badfileops;
2443         pn = fp->f_data;
2444         fp->f_data = NULL;
2445         sx_xlock(&mqfs_data.mi_lock);
2446         mqnode_release(pn);
2447         sx_xunlock(&mqfs_data.mi_lock);
2448         return (0);
2449 }
2450
2451 static int
2452 mqf_stat(struct file *fp, struct stat *st, struct ucred *active_cred,
2453         struct thread *td)
2454 {
2455         struct mqfs_node *pn = fp->f_data;
2456
2457         bzero(st, sizeof *st);
2458         st->st_atim = pn->mn_atime;
2459         st->st_mtim = pn->mn_mtime;
2460         st->st_ctim = pn->mn_ctime;
2461         st->st_birthtim = pn->mn_birth;
2462         st->st_uid = pn->mn_uid;
2463         st->st_gid = pn->mn_gid;
2464         st->st_mode = S_IFIFO | pn->mn_mode;
2465         return (0);
2466 }
2467
2468 static int
2469 mqf_kqfilter(struct file *fp, struct knote *kn)
2470 {
2471         struct mqueue *mq = FPTOMQ(fp);
2472         int error = 0;
2473
2474         if (kn->kn_filter == EVFILT_READ) {
2475                 kn->kn_fop = &mq_rfiltops;
2476                 knlist_add(&mq->mq_rsel.si_note, kn, 0);
2477         } else if (kn->kn_filter == EVFILT_WRITE) {
2478                 kn->kn_fop = &mq_wfiltops;
2479                 knlist_add(&mq->mq_wsel.si_note, kn, 0);
2480         } else
2481                 error = EINVAL;
2482         return (error);
2483 }
2484
2485 static void
2486 filt_mqdetach(struct knote *kn)
2487 {
2488         struct mqueue *mq = FPTOMQ(kn->kn_fp);
2489
2490         if (kn->kn_filter == EVFILT_READ)
2491                 knlist_remove(&mq->mq_rsel.si_note, kn, 0);
2492         else if (kn->kn_filter == EVFILT_WRITE)
2493                 knlist_remove(&mq->mq_wsel.si_note, kn, 0);
2494         else
2495                 panic("filt_mqdetach");
2496 }
2497
2498 static int
2499 filt_mqread(struct knote *kn, long hint)
2500 {
2501         struct mqueue *mq = FPTOMQ(kn->kn_fp);
2502
2503         mtx_assert(&mq->mq_mutex, MA_OWNED);
2504         return (mq->mq_curmsgs != 0);
2505 }
2506
2507 static int
2508 filt_mqwrite(struct knote *kn, long hint)
2509 {
2510         struct mqueue *mq = FPTOMQ(kn->kn_fp);
2511
2512         mtx_assert(&mq->mq_mutex, MA_OWNED);
2513         return (mq->mq_curmsgs < mq->mq_maxmsg);
2514 }
2515
2516 static struct fileops mqueueops = {
2517         .fo_read                = mqf_read,
2518         .fo_write               = mqf_write,
2519         .fo_truncate            = mqf_truncate,
2520         .fo_ioctl               = mqf_ioctl,
2521         .fo_poll                = mqf_poll,
2522         .fo_kqfilter            = mqf_kqfilter,
2523         .fo_stat                = mqf_stat,
2524         .fo_close               = mqf_close
2525 };
2526
2527 static struct vop_vector mqfs_vnodeops = {
2528         .vop_default            = &default_vnodeops,
2529         .vop_access             = mqfs_access,
2530         .vop_cachedlookup       = mqfs_lookup,
2531         .vop_lookup             = vfs_cache_lookup,
2532         .vop_reclaim            = mqfs_reclaim,
2533         .vop_create             = mqfs_create,
2534         .vop_remove             = mqfs_remove,
2535         .vop_inactive           = mqfs_inactive,
2536         .vop_open               = mqfs_open,
2537         .vop_close              = mqfs_close,
2538         .vop_getattr            = mqfs_getattr,
2539         .vop_setattr            = mqfs_setattr,
2540         .vop_read               = mqfs_read,
2541         .vop_write              = VOP_EOPNOTSUPP,
2542         .vop_readdir            = mqfs_readdir,
2543         .vop_mkdir              = VOP_EOPNOTSUPP,
2544         .vop_rmdir              = VOP_EOPNOTSUPP
2545 };
2546
2547 static struct vfsops mqfs_vfsops = {
2548         .vfs_init               = mqfs_init,
2549         .vfs_uninit             = mqfs_uninit,
2550         .vfs_mount              = mqfs_mount,
2551         .vfs_unmount            = mqfs_unmount,
2552         .vfs_root               = mqfs_root,
2553         .vfs_statfs             = mqfs_statfs,
2554 };
2555
2556 static struct vfsconf mqueuefs_vfsconf = {
2557         .vfc_version = VFS_VERSION,
2558         .vfc_name = "mqueuefs",
2559         .vfc_vfsops = &mqfs_vfsops,
2560         .vfc_typenum = -1,
2561         .vfc_flags = VFCF_SYNTHETIC
2562 };
2563
2564 static struct syscall_helper_data mq_syscalls[] = {
2565         SYSCALL_INIT_HELPER(kmq_open),
2566         SYSCALL_INIT_HELPER(kmq_setattr),
2567         SYSCALL_INIT_HELPER(kmq_timedsend),
2568         SYSCALL_INIT_HELPER(kmq_timedreceive),
2569         SYSCALL_INIT_HELPER(kmq_notify),
2570         SYSCALL_INIT_HELPER(kmq_unlink),
2571         SYSCALL_INIT_LAST
2572 };
2573
2574 #ifdef COMPAT_FREEBSD32
2575 #include <compat/freebsd32/freebsd32.h>
2576 #include <compat/freebsd32/freebsd32_proto.h>
2577 #include <compat/freebsd32/freebsd32_syscall.h>
2578 #include <compat/freebsd32/freebsd32_util.h>
2579
2580 static void
2581 mq_attr_from32(const struct mq_attr32 *from, struct mq_attr *to)
2582 {
2583
2584         to->mq_flags = from->mq_flags;
2585         to->mq_maxmsg = from->mq_maxmsg;
2586         to->mq_msgsize = from->mq_msgsize;
2587         to->mq_curmsgs = from->mq_curmsgs;
2588 }
2589
2590 static void
2591 mq_attr_to32(const struct mq_attr *from, struct mq_attr32 *to)
2592 {
2593
2594         to->mq_flags = from->mq_flags;
2595         to->mq_maxmsg = from->mq_maxmsg;
2596         to->mq_msgsize = from->mq_msgsize;
2597         to->mq_curmsgs = from->mq_curmsgs;
2598 }
2599
2600 int
2601 freebsd32_kmq_open(struct thread *td, struct freebsd32_kmq_open_args *uap)
2602 {
2603         struct mq_attr attr;
2604         struct mq_attr32 attr32;
2605         int flags, error;
2606
2607         if ((uap->flags & O_ACCMODE) == O_ACCMODE)
2608                 return (EINVAL);
2609         flags = FFLAGS(uap->flags);
2610         if ((flags & O_CREAT) != 0 && uap->attr != NULL) {
2611                 error = copyin(uap->attr, &attr32, sizeof(attr32));
2612                 if (error)
2613                         return (error);
2614                 mq_attr_from32(&attr32, &attr);
2615         }
2616         return (kern_kmq_open(td, uap->path, flags, uap->mode,
2617             uap->attr != NULL ? &attr : NULL));
2618 }
2619
2620 int
2621 freebsd32_kmq_setattr(struct thread *td, struct freebsd32_kmq_setattr_args *uap)
2622 {
2623         struct mq_attr attr, oattr;
2624         struct mq_attr32 attr32, oattr32;
2625         int error;
2626
2627         if (uap->attr != NULL) {
2628                 error = copyin(uap->attr, &attr32, sizeof(attr32));
2629                 if (error != 0)
2630                         return (error);
2631                 mq_attr_from32(&attr32, &attr);
2632         }
2633         error = kern_kmq_setattr(td, uap->mqd, uap->attr != NULL ? &attr : NULL,
2634             &oattr);
2635         if (error != 0)
2636                 return (error);
2637         if (uap->oattr != NULL) {
2638                 mq_attr_to32(&oattr, &oattr32);
2639                 error = copyout(&oattr32, uap->oattr, sizeof(oattr32));
2640         }
2641         return (error);
2642 }
2643
2644 int
2645 freebsd32_kmq_timedsend(struct thread *td,
2646     struct freebsd32_kmq_timedsend_args *uap)
2647 {
2648         struct mqueue *mq;
2649         struct file *fp;
2650         struct timespec32 ets32;
2651         struct timespec *abs_timeout, ets;
2652         int error;
2653         int waitok;
2654
2655         error = getmq_read(td, uap->mqd, &fp, NULL, &mq);
2656         if (error)
2657                 return (error);
2658         if (uap->abs_timeout != NULL) {
2659                 error = copyin(uap->abs_timeout, &ets32, sizeof(ets32));
2660                 if (error != 0)
2661                         return (error);
2662                 CP(ets32, ets, tv_sec);
2663                 CP(ets32, ets, tv_nsec);
2664                 abs_timeout = &ets;
2665         } else
2666                 abs_timeout = NULL;
2667         waitok = !(fp->f_flag & O_NONBLOCK);
2668         error = mqueue_send(mq, uap->msg_ptr, uap->msg_len,
2669                 uap->msg_prio, waitok, abs_timeout);
2670         fdrop(fp, td);
2671         return (error);
2672 }
2673
2674 int
2675 freebsd32_kmq_timedreceive(struct thread *td,
2676     struct freebsd32_kmq_timedreceive_args *uap)
2677 {
2678         struct mqueue *mq;
2679         struct file *fp;
2680         struct timespec32 ets32;
2681         struct timespec *abs_timeout, ets;
2682         int error, waitok;
2683
2684         error = getmq_write(td, uap->mqd, &fp, NULL, &mq);
2685         if (error)
2686                 return (error);
2687         if (uap->abs_timeout != NULL) {
2688                 error = copyin(uap->abs_timeout, &ets32, sizeof(ets32));
2689                 if (error != 0)
2690                         return (error);
2691                 CP(ets32, ets, tv_sec);
2692                 CP(ets32, ets, tv_nsec);
2693                 abs_timeout = &ets;
2694         } else
2695                 abs_timeout = NULL;
2696         waitok = !(fp->f_flag & O_NONBLOCK);
2697         error = mqueue_receive(mq, uap->msg_ptr, uap->msg_len,
2698                 uap->msg_prio, waitok, abs_timeout);
2699         fdrop(fp, td);
2700         return (error);
2701 }
2702
2703 static struct syscall_helper_data mq32_syscalls[] = {
2704         SYSCALL32_INIT_HELPER(freebsd32_kmq_open),
2705         SYSCALL32_INIT_HELPER(freebsd32_kmq_setattr),
2706         SYSCALL32_INIT_HELPER(freebsd32_kmq_timedsend),
2707         SYSCALL32_INIT_HELPER(freebsd32_kmq_timedreceive),
2708         SYSCALL32_INIT_HELPER(kmq_notify),
2709         SYSCALL32_INIT_HELPER(kmq_unlink),
2710         SYSCALL_INIT_LAST
2711 };
2712 #endif
2713
2714 static int
2715 mqinit(void)
2716 {
2717         int error;
2718
2719         error = syscall_helper_register(mq_syscalls);
2720         if (error != 0)
2721                 return (error);
2722 #ifdef COMPAT_FREEBSD32
2723         error = syscall32_helper_register(mq32_syscalls);
2724         if (error != 0)
2725                 return (error);
2726 #endif
2727         return (0);
2728 }
2729
2730 static int
2731 mqunload(void)
2732 {
2733
2734 #ifdef COMPAT_FREEBSD32
2735         syscall32_helper_unregister(mq32_syscalls);
2736 #endif
2737         syscall_helper_unregister(mq_syscalls);
2738         return (0);
2739 }
2740
2741 static int
2742 mq_modload(struct module *module, int cmd, void *arg)
2743 {
2744         int error = 0;
2745
2746         error = vfs_modevent(module, cmd, arg);
2747         if (error != 0)
2748                 return (error);
2749
2750         switch (cmd) {
2751         case MOD_LOAD:
2752                 error = mqinit();
2753                 if (error != 0)
2754                         mqunload();
2755                 break;
2756         case MOD_UNLOAD:
2757                 error = mqunload();
2758                 break;
2759         default:
2760                 break;
2761         }
2762         return (error);
2763 }
2764
2765 static moduledata_t mqueuefs_mod = {
2766         "mqueuefs",
2767         mq_modload,
2768         &mqueuefs_vfsconf
2769 };
2770 DECLARE_MODULE(mqueuefs, mqueuefs_mod, SI_SUB_VFS, SI_ORDER_MIDDLE);
2771 MODULE_VERSION(mqueuefs, 1);