sys/rump/fs/lib/libsyspuffs/puffs_rumpglue.c

   1 /*      $NetBSD: puffs_rumpglue.c,v 1.10 2009/10/14 17:29:19 pooka Exp $        */
   2
   3 /*
   4  * Copyright (c) 2008 Antti Kantee.  All Rights Reserved.
   5  *
   6  * Development of this software was supported by the
   7  * Research Foundation of Helsinki University of Technology
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
  19  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  21  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  24  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __KERNEL_RCSID(0, "$NetBSD: puffs_rumpglue.c,v 1.10 2009/10/14 17:29:19 pooka Exp $");
  33
  34 #include <sys/param.h>
  35 #include <sys/conf.h>
  36 #include <sys/file.h>
  37 #include <sys/filedesc.h>
  38 #include <sys/kthread.h>
  39 #include <sys/mount.h>
  40
  41 #include <dev/putter/putter.h>
  42 #include <dev/putter/putter_sys.h>
  43
  44 #include <rump/rump.h>
  45 #include <rump/rumpuser.h>
  46
  47 #include "rump_vfs_private.h"
  48
  49 void putterattach(void); /* XXX: from autoconf */
  50 dev_type_open(puttercdopen);
  51
  52 struct ptargs {
  53         int comfd;
  54         int fpfd;
  55         struct filedesc *fdp;
  56 };
  57
  58 #define BUFSIZE (64*1024)
  59 extern int hz;
  60
  61 /*
  62  * Read requests from /dev/puffs and forward them to comfd
  63  *
  64  * XXX: the init detection is really sucky, but let's not
  65  * waste too much energy for a better one here
  66  */
  67 static void
  68 readthread(void *arg)
  69 {
  70         struct ptargs *pap = arg;
  71         struct file *fp;
  72         register_t rv;
  73         char *buf;
  74         off_t off;
  75         int error, inited;
  76
  77         buf = kmem_alloc(BUFSIZE, KM_SLEEP);
  78         inited = 0;
  79
  80  retry:
  81         kpause(NULL, 0, hz/4, NULL);
  82
  83         for (;;) {
  84                 ssize_t n;
  85
  86                 off = 0;
  87                 fp = fd_getfile(pap->fpfd);
  88                 error = dofileread(pap->fpfd, fp, buf, BUFSIZE,
  89                     &off, 0, &rv);
  90                 if (error) {
  91                         if (error == ENOENT && inited == 0)
  92                                 goto retry;
  93                         if (error == ENXIO)
  94                                 break;
  95                         panic("fileread failed: %d", error);
  96                 }
  97                 inited = 1;
  98
  99                 while (rv) {
 100                         n = rumpuser_write(pap->comfd, buf, rv, &error);
 101                         if (n == -1)
 102                                 panic("fileread failed: %d", error);
 103                         if (n == 0)
 104                                 panic("fileread failed: closed");
 105                         rv -= n;
 106                 }
 107         }
 108
 109         kthread_exit(0);
 110 }
 111
 112 /* Read requests from comfd and proxy them to /dev/puffs */
 113 static void
 114 writethread(void *arg)
 115 {
 116         struct ptargs *pap = arg;
 117         struct file *fp;
 118         struct putter_hdr *phdr;
 119         register_t rv;
 120         char *buf;
 121         off_t off;
 122         size_t toread;
 123         int error;
 124
 125         buf = kmem_alloc(BUFSIZE, KM_SLEEP);
 126         phdr = (struct putter_hdr *)buf;
 127
 128         for (;;) {
 129                 ssize_t n;
 130
 131                 /*
 132                  * Need to write everything to the "kernel" in one chunk,
 133                  * so make sure we have it here.
 134                  */
 135                 off = 0;
 136                 toread = sizeof(struct putter_hdr);
 137                 do {
 138                         n = rumpuser_read(pap->comfd, buf+off, toread, &error);
 139                         if (n <= 0) {
 140                                 if (n == 0)
 141                                         goto out;
 142                                 panic("rumpuser_read %zd %d", n, error);
 143                         }
 144                         off += n;
 145                         if (off >= sizeof(struct putter_hdr))
 146                                 toread = phdr->pth_framelen - off;
 147                         else
 148                                 toread = off - sizeof(struct putter_hdr);
 149                 } while (toread);
 150
 151                 off = 0;
 152                 rv = 0;
 153                 fp = fd_getfile(pap->fpfd);
 154                 error = dofilewrite(pap->fpfd, fp, buf, phdr->pth_framelen,
 155                     &off, 0, &rv);
 156                 if (error == ENXIO)
 157                         goto out;
 158                 KASSERT(rv == phdr->pth_framelen);
 159         }
 160  out:
 161
 162         kthread_exit(0);
 163 }
 164
 165 int
 166 rump_syspuffs_glueinit(int fd, int *newfd)
 167 {
 168         struct ptargs *pap;
 169         int rv;
 170
 171         if ((rv = rump_init()) != 0)
 172                 return rv;
 173
 174         putterattach();
 175         rv = puttercdopen(makedev(178, 0), 0, 0, curlwp);
 176         if (rv && rv != EMOVEFD)
 177                 return rv;
 178
 179         pap = kmem_alloc(sizeof(struct ptargs), KM_SLEEP);
 180         pap->comfd = fd;
 181         pap->fpfd = curlwp->l_dupfd;
 182         pap->fdp = curlwp->l_proc->p_fd;
 183
 184         kthread_create(PRI_NONE, 0, NULL, readthread, pap, NULL, "rputter");
 185         kthread_create(PRI_NONE, 0, NULL, writethread, pap, NULL, "wputter");
 186
 187         *newfd = curlwp->l_dupfd;
 188         return 0;
 189 }