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