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