1 /* $NetBSD: puffs_rumpglue.c,v 1.11 2009/10/14 18:18:53 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.11 2009/10/14 18:18:53 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 } 190