The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/uipc_mqueue.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

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

Cache object: c4d06b9b88be372d4d71c843b88a1926


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.