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  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  FREEBSD22  -  cheribsd  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1  -  FREEBSD-LIBC  -  FREEBSD8-LIBC  -  FREEBSD7-LIBC  -  FREEBSD6-LIBC  -  GLIBC27 
SearchContext: -  none  -  3  -  10 

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

Cache object: 25306f74c8471804ed1d499575516f8f


[ 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.