1fa0f6e62SHans Petter Selasky /* $FreeBSD$ */ 2fa0f6e62SHans Petter Selasky /*- 3fa0f6e62SHans Petter Selasky * Copyright (c) 2010-2013 Hans Petter Selasky. All rights reserved. 4fa0f6e62SHans Petter Selasky * 5fa0f6e62SHans Petter Selasky * Redistribution and use in source and binary forms, with or without 6fa0f6e62SHans Petter Selasky * modification, are permitted provided that the following conditions 7fa0f6e62SHans Petter Selasky * are met: 8fa0f6e62SHans Petter Selasky * 1. Redistributions of source code must retain the above copyright 9fa0f6e62SHans Petter Selasky * notice, this list of conditions and the following disclaimer. 10fa0f6e62SHans Petter Selasky * 2. Redistributions in binary form must reproduce the above copyright 11fa0f6e62SHans Petter Selasky * notice, this list of conditions and the following disclaimer in the 12fa0f6e62SHans Petter Selasky * documentation and/or other materials provided with the distribution. 13fa0f6e62SHans Petter Selasky * 14fa0f6e62SHans Petter Selasky * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15fa0f6e62SHans Petter Selasky * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16fa0f6e62SHans Petter Selasky * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17fa0f6e62SHans Petter Selasky * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18fa0f6e62SHans Petter Selasky * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19fa0f6e62SHans Petter Selasky * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20fa0f6e62SHans Petter Selasky * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21fa0f6e62SHans Petter Selasky * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22fa0f6e62SHans Petter Selasky * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23fa0f6e62SHans Petter Selasky * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24fa0f6e62SHans Petter Selasky * SUCH DAMAGE. 25fa0f6e62SHans Petter Selasky */ 26fa0f6e62SHans Petter Selasky 27fa0f6e62SHans Petter Selasky #include "opt_compat.h" 28fa0f6e62SHans Petter Selasky 29fa0f6e62SHans Petter Selasky #include <sys/stdint.h> 30fa0f6e62SHans Petter Selasky #include <sys/stddef.h> 31fa0f6e62SHans Petter Selasky #include <sys/param.h> 32fa0f6e62SHans Petter Selasky #include <sys/types.h> 33fa0f6e62SHans Petter Selasky #include <sys/systm.h> 34fa0f6e62SHans Petter Selasky #include <sys/conf.h> 35fa0f6e62SHans Petter Selasky #include <sys/kernel.h> 36fa0f6e62SHans Petter Selasky #include <sys/bus.h> 37fa0f6e62SHans Petter Selasky #include <sys/linker_set.h> 38fa0f6e62SHans Petter Selasky #include <sys/module.h> 39fa0f6e62SHans Petter Selasky #include <sys/lock.h> 40fa0f6e62SHans Petter Selasky #include <sys/mutex.h> 41fa0f6e62SHans Petter Selasky #include <sys/condvar.h> 42fa0f6e62SHans Petter Selasky #include <sys/sysctl.h> 43fa0f6e62SHans Petter Selasky #include <sys/unistd.h> 44fa0f6e62SHans Petter Selasky #include <sys/malloc.h> 45fa0f6e62SHans Petter Selasky #include <sys/priv.h> 46fa0f6e62SHans Petter Selasky #include <sys/uio.h> 47fa0f6e62SHans Petter Selasky #include <sys/poll.h> 48fa0f6e62SHans Petter Selasky #include <sys/sx.h> 49fa0f6e62SHans Petter Selasky #include <sys/queue.h> 50fa0f6e62SHans Petter Selasky #include <sys/fcntl.h> 51fa0f6e62SHans Petter Selasky #include <sys/proc.h> 52fa0f6e62SHans Petter Selasky #include <sys/vnode.h> 53fa0f6e62SHans Petter Selasky #include <sys/selinfo.h> 54fa0f6e62SHans Petter Selasky #include <sys/ptrace.h> 55fa0f6e62SHans Petter Selasky 56fa0f6e62SHans Petter Selasky #include <machine/bus.h> 57fa0f6e62SHans Petter Selasky 58fa0f6e62SHans Petter Selasky #include <vm/vm.h> 59fa0f6e62SHans Petter Selasky #include <vm/pmap.h> 60fa0f6e62SHans Petter Selasky 61fa0f6e62SHans Petter Selasky #include <fs/cuse/cuse_defs.h> 62fa0f6e62SHans Petter Selasky #include <fs/cuse/cuse_ioctl.h> 63fa0f6e62SHans Petter Selasky 64fa0f6e62SHans Petter Selasky MODULE_VERSION(cuse, 1); 65fa0f6e62SHans Petter Selasky 66fa0f6e62SHans Petter Selasky #define NBUSY ((uint8_t *)1) 67fa0f6e62SHans Petter Selasky 68fa0f6e62SHans Petter Selasky #ifdef FEATURE 69fa0f6e62SHans Petter Selasky FEATURE(cuse, "Userspace character devices"); 70fa0f6e62SHans Petter Selasky #endif 71fa0f6e62SHans Petter Selasky 72fa0f6e62SHans Petter Selasky struct cuse_command; 73fa0f6e62SHans Petter Selasky struct cuse_server; 74fa0f6e62SHans Petter Selasky struct cuse_client; 75fa0f6e62SHans Petter Selasky 76fa0f6e62SHans Petter Selasky struct cuse_client_command { 77fa0f6e62SHans Petter Selasky TAILQ_ENTRY(cuse_client_command) entry; 78fa0f6e62SHans Petter Selasky struct cuse_command sub; 79fa0f6e62SHans Petter Selasky struct sx sx; 80fa0f6e62SHans Petter Selasky struct cv cv; 81fa0f6e62SHans Petter Selasky struct thread *entered; 82fa0f6e62SHans Petter Selasky struct cuse_client *client; 83fa0f6e62SHans Petter Selasky struct proc *proc_curr; 84fa0f6e62SHans Petter Selasky int proc_refs; 85fa0f6e62SHans Petter Selasky int got_signal; 86fa0f6e62SHans Petter Selasky int error; 87fa0f6e62SHans Petter Selasky int command; 88fa0f6e62SHans Petter Selasky }; 89fa0f6e62SHans Petter Selasky 90fa0f6e62SHans Petter Selasky struct cuse_memory { 91fa0f6e62SHans Petter Selasky struct cuse_server *owner; 92fa0f6e62SHans Petter Selasky uint8_t *virtaddr; 93fa0f6e62SHans Petter Selasky uint32_t page_count; 94fa0f6e62SHans Petter Selasky uint32_t is_allocated; 95fa0f6e62SHans Petter Selasky }; 96fa0f6e62SHans Petter Selasky 97fa0f6e62SHans Petter Selasky struct cuse_server_dev { 98fa0f6e62SHans Petter Selasky TAILQ_ENTRY(cuse_server_dev) entry; 99fa0f6e62SHans Petter Selasky struct cuse_server *server; 100fa0f6e62SHans Petter Selasky struct cdev *kern_dev; 101fa0f6e62SHans Petter Selasky struct cuse_dev *user_dev; 102fa0f6e62SHans Petter Selasky }; 103fa0f6e62SHans Petter Selasky 104fa0f6e62SHans Petter Selasky struct cuse_server { 105fa0f6e62SHans Petter Selasky TAILQ_ENTRY(cuse_server) entry; 106fa0f6e62SHans Petter Selasky TAILQ_HEAD(, cuse_client_command) head; 107fa0f6e62SHans Petter Selasky TAILQ_HEAD(, cuse_server_dev) hdev; 108fa0f6e62SHans Petter Selasky TAILQ_HEAD(, cuse_client) hcli; 109fa0f6e62SHans Petter Selasky struct cv cv; 110fa0f6e62SHans Petter Selasky struct selinfo selinfo; 111fa0f6e62SHans Petter Selasky int is_closing; 112fa0f6e62SHans Petter Selasky int refs; 113fa0f6e62SHans Petter Selasky }; 114fa0f6e62SHans Petter Selasky 115fa0f6e62SHans Petter Selasky struct cuse_client { 116fa0f6e62SHans Petter Selasky TAILQ_ENTRY(cuse_client) entry; 117fa0f6e62SHans Petter Selasky TAILQ_ENTRY(cuse_client) entry_ref; 118fa0f6e62SHans Petter Selasky struct cuse_client_command cmds[CUSE_CMD_MAX]; 119fa0f6e62SHans Petter Selasky struct cuse_server *server; 120fa0f6e62SHans Petter Selasky struct cuse_server_dev *server_dev; 121fa0f6e62SHans Petter Selasky 122fa0f6e62SHans Petter Selasky uint8_t ioctl_buffer[CUSE_BUFFER_MAX] __aligned(4); 123fa0f6e62SHans Petter Selasky 124fa0f6e62SHans Petter Selasky int fflags; /* file flags */ 125fa0f6e62SHans Petter Selasky int cflags; /* client flags */ 126fa0f6e62SHans Petter Selasky #define CUSE_CLI_IS_CLOSING 0x01 127fa0f6e62SHans Petter Selasky #define CUSE_CLI_KNOTE_NEED_READ 0x02 128fa0f6e62SHans Petter Selasky #define CUSE_CLI_KNOTE_NEED_WRITE 0x04 129fa0f6e62SHans Petter Selasky #define CUSE_CLI_KNOTE_HAS_READ 0x08 130fa0f6e62SHans Petter Selasky #define CUSE_CLI_KNOTE_HAS_WRITE 0x10 131fa0f6e62SHans Petter Selasky }; 132fa0f6e62SHans Petter Selasky 133fa0f6e62SHans Petter Selasky #define CUSE_CLIENT_CLOSING(pcc) \ 134fa0f6e62SHans Petter Selasky ((pcc)->cflags & CUSE_CLI_IS_CLOSING) 135fa0f6e62SHans Petter Selasky 136fa0f6e62SHans Petter Selasky static MALLOC_DEFINE(M_CUSE, "cuse", "CUSE memory"); 137fa0f6e62SHans Petter Selasky 138fa0f6e62SHans Petter Selasky static TAILQ_HEAD(, cuse_server) cuse_server_head; 139fa0f6e62SHans Petter Selasky static struct mtx cuse_mtx; 140fa0f6e62SHans Petter Selasky static struct cdev *cuse_dev; 141fa0f6e62SHans Petter Selasky static struct cuse_server *cuse_alloc_unit[CUSE_DEVICES_MAX]; 142fa0f6e62SHans Petter Selasky static int cuse_alloc_unit_id[CUSE_DEVICES_MAX]; 143fa0f6e62SHans Petter Selasky static struct cuse_memory cuse_mem[CUSE_ALLOC_UNIT_MAX]; 144fa0f6e62SHans Petter Selasky 145fa0f6e62SHans Petter Selasky static void cuse_client_kqfilter_read_detach(struct knote *kn); 146fa0f6e62SHans Petter Selasky static void cuse_client_kqfilter_write_detach(struct knote *kn); 147fa0f6e62SHans Petter Selasky static int cuse_client_kqfilter_read_event(struct knote *kn, long hint); 148fa0f6e62SHans Petter Selasky static int cuse_client_kqfilter_write_event(struct knote *kn, long hint); 149fa0f6e62SHans Petter Selasky 150fa0f6e62SHans Petter Selasky static struct filterops cuse_client_kqfilter_read_ops = { 151fa0f6e62SHans Petter Selasky .f_isfd = 1, 152fa0f6e62SHans Petter Selasky .f_detach = cuse_client_kqfilter_read_detach, 153fa0f6e62SHans Petter Selasky .f_event = cuse_client_kqfilter_read_event, 154fa0f6e62SHans Petter Selasky }; 155fa0f6e62SHans Petter Selasky 156fa0f6e62SHans Petter Selasky static struct filterops cuse_client_kqfilter_write_ops = { 157fa0f6e62SHans Petter Selasky .f_isfd = 1, 158fa0f6e62SHans Petter Selasky .f_detach = cuse_client_kqfilter_write_detach, 159fa0f6e62SHans Petter Selasky .f_event = cuse_client_kqfilter_write_event, 160fa0f6e62SHans Petter Selasky }; 161fa0f6e62SHans Petter Selasky 162fa0f6e62SHans Petter Selasky static d_open_t cuse_client_open; 163fa0f6e62SHans Petter Selasky static d_close_t cuse_client_close; 164fa0f6e62SHans Petter Selasky static d_ioctl_t cuse_client_ioctl; 165fa0f6e62SHans Petter Selasky static d_read_t cuse_client_read; 166fa0f6e62SHans Petter Selasky static d_write_t cuse_client_write; 167fa0f6e62SHans Petter Selasky static d_poll_t cuse_client_poll; 168fa0f6e62SHans Petter Selasky static d_mmap_t cuse_client_mmap; 169fa0f6e62SHans Petter Selasky static d_kqfilter_t cuse_client_kqfilter; 170fa0f6e62SHans Petter Selasky 171fa0f6e62SHans Petter Selasky static struct cdevsw cuse_client_devsw = { 172fa0f6e62SHans Petter Selasky .d_version = D_VERSION, 173fa0f6e62SHans Petter Selasky .d_open = cuse_client_open, 174fa0f6e62SHans Petter Selasky .d_close = cuse_client_close, 175fa0f6e62SHans Petter Selasky .d_ioctl = cuse_client_ioctl, 176fa0f6e62SHans Petter Selasky .d_name = "cuse_client", 177fa0f6e62SHans Petter Selasky .d_flags = D_TRACKCLOSE, 178fa0f6e62SHans Petter Selasky .d_read = cuse_client_read, 179fa0f6e62SHans Petter Selasky .d_write = cuse_client_write, 180fa0f6e62SHans Petter Selasky .d_poll = cuse_client_poll, 181fa0f6e62SHans Petter Selasky .d_mmap = cuse_client_mmap, 182fa0f6e62SHans Petter Selasky .d_kqfilter = cuse_client_kqfilter, 183fa0f6e62SHans Petter Selasky }; 184fa0f6e62SHans Petter Selasky 185fa0f6e62SHans Petter Selasky static d_open_t cuse_server_open; 186fa0f6e62SHans Petter Selasky static d_close_t cuse_server_close; 187fa0f6e62SHans Petter Selasky static d_ioctl_t cuse_server_ioctl; 188fa0f6e62SHans Petter Selasky static d_read_t cuse_server_read; 189fa0f6e62SHans Petter Selasky static d_write_t cuse_server_write; 190fa0f6e62SHans Petter Selasky static d_poll_t cuse_server_poll; 191fa0f6e62SHans Petter Selasky static d_mmap_t cuse_server_mmap; 192fa0f6e62SHans Petter Selasky 193fa0f6e62SHans Petter Selasky static struct cdevsw cuse_server_devsw = { 194fa0f6e62SHans Petter Selasky .d_version = D_VERSION, 195fa0f6e62SHans Petter Selasky .d_open = cuse_server_open, 196fa0f6e62SHans Petter Selasky .d_close = cuse_server_close, 197fa0f6e62SHans Petter Selasky .d_ioctl = cuse_server_ioctl, 198fa0f6e62SHans Petter Selasky .d_name = "cuse_server", 199fa0f6e62SHans Petter Selasky .d_flags = D_TRACKCLOSE, 200fa0f6e62SHans Petter Selasky .d_read = cuse_server_read, 201fa0f6e62SHans Petter Selasky .d_write = cuse_server_write, 202fa0f6e62SHans Petter Selasky .d_poll = cuse_server_poll, 203fa0f6e62SHans Petter Selasky .d_mmap = cuse_server_mmap, 204fa0f6e62SHans Petter Selasky }; 205fa0f6e62SHans Petter Selasky 206fa0f6e62SHans Petter Selasky static void cuse_client_is_closing(struct cuse_client *); 207fa0f6e62SHans Petter Selasky static int cuse_free_unit_by_id_locked(struct cuse_server *, int); 208fa0f6e62SHans Petter Selasky 209fa0f6e62SHans Petter Selasky static void 210fa0f6e62SHans Petter Selasky cuse_lock(void) 211fa0f6e62SHans Petter Selasky { 212fa0f6e62SHans Petter Selasky mtx_lock(&cuse_mtx); 213fa0f6e62SHans Petter Selasky } 214fa0f6e62SHans Petter Selasky 215fa0f6e62SHans Petter Selasky static void 216fa0f6e62SHans Petter Selasky cuse_unlock(void) 217fa0f6e62SHans Petter Selasky { 218fa0f6e62SHans Petter Selasky mtx_unlock(&cuse_mtx); 219fa0f6e62SHans Petter Selasky } 220fa0f6e62SHans Petter Selasky 221fa0f6e62SHans Petter Selasky static void 222fa0f6e62SHans Petter Selasky cuse_cmd_lock(struct cuse_client_command *pccmd) 223fa0f6e62SHans Petter Selasky { 224fa0f6e62SHans Petter Selasky sx_xlock(&pccmd->sx); 225fa0f6e62SHans Petter Selasky } 226fa0f6e62SHans Petter Selasky 227fa0f6e62SHans Petter Selasky static void 228fa0f6e62SHans Petter Selasky cuse_cmd_unlock(struct cuse_client_command *pccmd) 229fa0f6e62SHans Petter Selasky { 230fa0f6e62SHans Petter Selasky sx_xunlock(&pccmd->sx); 231fa0f6e62SHans Petter Selasky } 232fa0f6e62SHans Petter Selasky 233fa0f6e62SHans Petter Selasky static void 234fa0f6e62SHans Petter Selasky cuse_kern_init(void *arg) 235fa0f6e62SHans Petter Selasky { 236fa0f6e62SHans Petter Selasky TAILQ_INIT(&cuse_server_head); 237fa0f6e62SHans Petter Selasky 238fa0f6e62SHans Petter Selasky mtx_init(&cuse_mtx, "cuse-mtx", NULL, MTX_DEF); 239fa0f6e62SHans Petter Selasky 240fa0f6e62SHans Petter Selasky cuse_dev = make_dev(&cuse_server_devsw, 0, 241fa0f6e62SHans Petter Selasky UID_ROOT, GID_OPERATOR, 0600, "cuse"); 242fa0f6e62SHans Petter Selasky 243fa0f6e62SHans Petter Selasky printf("Cuse v%d.%d.%d @ /dev/cuse\n", 244fa0f6e62SHans Petter Selasky (CUSE_VERSION >> 16) & 0xFF, (CUSE_VERSION >> 8) & 0xFF, 245fa0f6e62SHans Petter Selasky (CUSE_VERSION >> 0) & 0xFF); 246fa0f6e62SHans Petter Selasky } 247fa0f6e62SHans Petter Selasky 248fa0f6e62SHans Petter Selasky SYSINIT(cuse_kern_init, SI_SUB_DEVFS, SI_ORDER_ANY, cuse_kern_init, 0); 249fa0f6e62SHans Petter Selasky 250fa0f6e62SHans Petter Selasky static void 251fa0f6e62SHans Petter Selasky cuse_kern_uninit(void *arg) 252fa0f6e62SHans Petter Selasky { 253fa0f6e62SHans Petter Selasky void *ptr; 254fa0f6e62SHans Petter Selasky 255fa0f6e62SHans Petter Selasky while (1) { 256fa0f6e62SHans Petter Selasky 257fa0f6e62SHans Petter Selasky printf("Cuse: Please exit all /dev/cuse instances " 258fa0f6e62SHans Petter Selasky "and processes which have used this device.\n"); 259fa0f6e62SHans Petter Selasky 260fa0f6e62SHans Petter Selasky pause("DRAIN", 2 * hz); 261fa0f6e62SHans Petter Selasky 262fa0f6e62SHans Petter Selasky cuse_lock(); 263fa0f6e62SHans Petter Selasky ptr = TAILQ_FIRST(&cuse_server_head); 264fa0f6e62SHans Petter Selasky cuse_unlock(); 265fa0f6e62SHans Petter Selasky 266fa0f6e62SHans Petter Selasky if (ptr == NULL) 267fa0f6e62SHans Petter Selasky break; 268fa0f6e62SHans Petter Selasky } 269fa0f6e62SHans Petter Selasky 270fa0f6e62SHans Petter Selasky if (cuse_dev != NULL) 271fa0f6e62SHans Petter Selasky destroy_dev(cuse_dev); 272fa0f6e62SHans Petter Selasky 273fa0f6e62SHans Petter Selasky mtx_destroy(&cuse_mtx); 274fa0f6e62SHans Petter Selasky } 275fa0f6e62SHans Petter Selasky 276fa0f6e62SHans Petter Selasky SYSUNINIT(cuse_kern_uninit, SI_SUB_DEVFS, SI_ORDER_ANY, cuse_kern_uninit, 0); 277fa0f6e62SHans Petter Selasky 278fa0f6e62SHans Petter Selasky static int 279fa0f6e62SHans Petter Selasky cuse_server_get(struct cuse_server **ppcs) 280fa0f6e62SHans Petter Selasky { 281fa0f6e62SHans Petter Selasky struct cuse_server *pcs; 282fa0f6e62SHans Petter Selasky int error; 283fa0f6e62SHans Petter Selasky 284fa0f6e62SHans Petter Selasky error = devfs_get_cdevpriv((void **)&pcs); 285fa0f6e62SHans Petter Selasky if (error != 0) { 286fa0f6e62SHans Petter Selasky *ppcs = NULL; 287fa0f6e62SHans Petter Selasky return (error); 288fa0f6e62SHans Petter Selasky } 289fa0f6e62SHans Petter Selasky /* check if closing */ 290fa0f6e62SHans Petter Selasky cuse_lock(); 291fa0f6e62SHans Petter Selasky if (pcs->is_closing) { 292fa0f6e62SHans Petter Selasky cuse_unlock(); 293fa0f6e62SHans Petter Selasky *ppcs = NULL; 294fa0f6e62SHans Petter Selasky return (EINVAL); 295fa0f6e62SHans Petter Selasky } 296fa0f6e62SHans Petter Selasky cuse_unlock(); 297fa0f6e62SHans Petter Selasky *ppcs = pcs; 298fa0f6e62SHans Petter Selasky return (0); 299fa0f6e62SHans Petter Selasky } 300fa0f6e62SHans Petter Selasky 301fa0f6e62SHans Petter Selasky static void 302fa0f6e62SHans Petter Selasky cuse_server_is_closing(struct cuse_server *pcs) 303fa0f6e62SHans Petter Selasky { 304fa0f6e62SHans Petter Selasky struct cuse_client *pcc; 305fa0f6e62SHans Petter Selasky 306fa0f6e62SHans Petter Selasky if (pcs->is_closing) 307fa0f6e62SHans Petter Selasky return; 308fa0f6e62SHans Petter Selasky 309fa0f6e62SHans Petter Selasky pcs->is_closing = 1; 310fa0f6e62SHans Petter Selasky 311fa0f6e62SHans Petter Selasky TAILQ_FOREACH(pcc, &pcs->hcli, entry) { 312fa0f6e62SHans Petter Selasky cuse_client_is_closing(pcc); 313fa0f6e62SHans Petter Selasky } 314fa0f6e62SHans Petter Selasky } 315fa0f6e62SHans Petter Selasky 316fa0f6e62SHans Petter Selasky static struct cuse_client_command * 317fa0f6e62SHans Petter Selasky cuse_server_find_command(struct cuse_server *pcs, struct thread *td) 318fa0f6e62SHans Petter Selasky { 319fa0f6e62SHans Petter Selasky struct cuse_client *pcc; 320fa0f6e62SHans Petter Selasky int n; 321fa0f6e62SHans Petter Selasky 322fa0f6e62SHans Petter Selasky if (pcs->is_closing) 323fa0f6e62SHans Petter Selasky goto done; 324fa0f6e62SHans Petter Selasky 325fa0f6e62SHans Petter Selasky TAILQ_FOREACH(pcc, &pcs->hcli, entry) { 326fa0f6e62SHans Petter Selasky if (CUSE_CLIENT_CLOSING(pcc)) 327fa0f6e62SHans Petter Selasky continue; 328fa0f6e62SHans Petter Selasky for (n = 0; n != CUSE_CMD_MAX; n++) { 329fa0f6e62SHans Petter Selasky if (pcc->cmds[n].entered == td) 330fa0f6e62SHans Petter Selasky return (&pcc->cmds[n]); 331fa0f6e62SHans Petter Selasky } 332fa0f6e62SHans Petter Selasky } 333fa0f6e62SHans Petter Selasky done: 334fa0f6e62SHans Petter Selasky return (NULL); 335fa0f6e62SHans Petter Selasky } 336fa0f6e62SHans Petter Selasky 337fa0f6e62SHans Petter Selasky static void 338fa0f6e62SHans Petter Selasky cuse_str_filter(char *ptr) 339fa0f6e62SHans Petter Selasky { 340fa0f6e62SHans Petter Selasky int c; 341fa0f6e62SHans Petter Selasky 342fa0f6e62SHans Petter Selasky while (((c = *ptr) != 0)) { 343fa0f6e62SHans Petter Selasky 344fa0f6e62SHans Petter Selasky if ((c >= 'a') && (c <= 'z')) { 345fa0f6e62SHans Petter Selasky ptr++; 346fa0f6e62SHans Petter Selasky continue; 347fa0f6e62SHans Petter Selasky } 348fa0f6e62SHans Petter Selasky if ((c >= 'A') && (c <= 'Z')) { 349fa0f6e62SHans Petter Selasky ptr++; 350fa0f6e62SHans Petter Selasky continue; 351fa0f6e62SHans Petter Selasky } 352fa0f6e62SHans Petter Selasky if ((c >= '0') && (c <= '9')) { 353fa0f6e62SHans Petter Selasky ptr++; 354fa0f6e62SHans Petter Selasky continue; 355fa0f6e62SHans Petter Selasky } 356fa0f6e62SHans Petter Selasky if ((c == '.') || (c == '_') || (c == '/')) { 357fa0f6e62SHans Petter Selasky ptr++; 358fa0f6e62SHans Petter Selasky continue; 359fa0f6e62SHans Petter Selasky } 360fa0f6e62SHans Petter Selasky *ptr = '_'; 361fa0f6e62SHans Petter Selasky 362fa0f6e62SHans Petter Selasky ptr++; 363fa0f6e62SHans Petter Selasky } 364fa0f6e62SHans Petter Selasky } 365fa0f6e62SHans Petter Selasky 366fa0f6e62SHans Petter Selasky static int 367fa0f6e62SHans Petter Selasky cuse_convert_error(int error) 368fa0f6e62SHans Petter Selasky { 369fa0f6e62SHans Petter Selasky ; /* indent fix */ 370fa0f6e62SHans Petter Selasky switch (error) { 371fa0f6e62SHans Petter Selasky case CUSE_ERR_NONE: 372fa0f6e62SHans Petter Selasky return (0); 373fa0f6e62SHans Petter Selasky case CUSE_ERR_BUSY: 374fa0f6e62SHans Petter Selasky return (EBUSY); 375fa0f6e62SHans Petter Selasky case CUSE_ERR_WOULDBLOCK: 376fa0f6e62SHans Petter Selasky return (EWOULDBLOCK); 377fa0f6e62SHans Petter Selasky case CUSE_ERR_INVALID: 378fa0f6e62SHans Petter Selasky return (EINVAL); 379fa0f6e62SHans Petter Selasky case CUSE_ERR_NO_MEMORY: 380fa0f6e62SHans Petter Selasky return (ENOMEM); 381fa0f6e62SHans Petter Selasky case CUSE_ERR_FAULT: 382fa0f6e62SHans Petter Selasky return (EFAULT); 383fa0f6e62SHans Petter Selasky case CUSE_ERR_SIGNAL: 384fa0f6e62SHans Petter Selasky return (EINTR); 385fa0f6e62SHans Petter Selasky default: 386fa0f6e62SHans Petter Selasky return (ENXIO); 387fa0f6e62SHans Petter Selasky } 388fa0f6e62SHans Petter Selasky } 389fa0f6e62SHans Petter Selasky 390fa0f6e62SHans Petter Selasky static void 391fa0f6e62SHans Petter Selasky cuse_server_free_memory(struct cuse_server *pcs) 392fa0f6e62SHans Petter Selasky { 393fa0f6e62SHans Petter Selasky struct cuse_memory *mem; 394fa0f6e62SHans Petter Selasky uint32_t n; 395fa0f6e62SHans Petter Selasky 396fa0f6e62SHans Petter Selasky for (n = 0; n != CUSE_ALLOC_UNIT_MAX; n++) { 397fa0f6e62SHans Petter Selasky mem = &cuse_mem[n]; 398fa0f6e62SHans Petter Selasky 399fa0f6e62SHans Petter Selasky /* this memory is never freed */ 400fa0f6e62SHans Petter Selasky if (mem->owner == pcs) { 401fa0f6e62SHans Petter Selasky mem->owner = NULL; 402fa0f6e62SHans Petter Selasky mem->is_allocated = 0; 403fa0f6e62SHans Petter Selasky } 404fa0f6e62SHans Petter Selasky } 405fa0f6e62SHans Petter Selasky } 406fa0f6e62SHans Petter Selasky 407fa0f6e62SHans Petter Selasky static int 408fa0f6e62SHans Petter Selasky cuse_server_alloc_memory(struct cuse_server *pcs, 409fa0f6e62SHans Petter Selasky struct cuse_memory *mem, uint32_t page_count) 410fa0f6e62SHans Petter Selasky { 411fa0f6e62SHans Petter Selasky void *ptr; 412fa0f6e62SHans Petter Selasky int error; 413fa0f6e62SHans Petter Selasky 414fa0f6e62SHans Petter Selasky cuse_lock(); 415fa0f6e62SHans Petter Selasky 416fa0f6e62SHans Petter Selasky if (mem->virtaddr == NBUSY) { 417fa0f6e62SHans Petter Selasky cuse_unlock(); 418fa0f6e62SHans Petter Selasky return (EBUSY); 419fa0f6e62SHans Petter Selasky } 420fa0f6e62SHans Petter Selasky if (mem->virtaddr != NULL) { 421fa0f6e62SHans Petter Selasky if (mem->is_allocated != 0) { 422fa0f6e62SHans Petter Selasky cuse_unlock(); 423fa0f6e62SHans Petter Selasky return (EBUSY); 424fa0f6e62SHans Petter Selasky } 425fa0f6e62SHans Petter Selasky if (mem->page_count == page_count) { 426fa0f6e62SHans Petter Selasky mem->is_allocated = 1; 427fa0f6e62SHans Petter Selasky mem->owner = pcs; 428fa0f6e62SHans Petter Selasky cuse_unlock(); 429fa0f6e62SHans Petter Selasky return (0); 430fa0f6e62SHans Petter Selasky } 431fa0f6e62SHans Petter Selasky cuse_unlock(); 432fa0f6e62SHans Petter Selasky return (EBUSY); 433fa0f6e62SHans Petter Selasky } 434fa0f6e62SHans Petter Selasky memset(mem, 0, sizeof(*mem)); 435fa0f6e62SHans Petter Selasky 436fa0f6e62SHans Petter Selasky mem->virtaddr = NBUSY; 437fa0f6e62SHans Petter Selasky 438fa0f6e62SHans Petter Selasky cuse_unlock(); 439fa0f6e62SHans Petter Selasky 440fa0f6e62SHans Petter Selasky ptr = malloc(page_count * PAGE_SIZE, M_CUSE, M_WAITOK | M_ZERO); 441fa0f6e62SHans Petter Selasky if (ptr == NULL) 442fa0f6e62SHans Petter Selasky error = ENOMEM; 443fa0f6e62SHans Petter Selasky else 444fa0f6e62SHans Petter Selasky error = 0; 445fa0f6e62SHans Petter Selasky 446fa0f6e62SHans Petter Selasky cuse_lock(); 447fa0f6e62SHans Petter Selasky 448fa0f6e62SHans Petter Selasky if (error) { 449fa0f6e62SHans Petter Selasky mem->virtaddr = NULL; 450fa0f6e62SHans Petter Selasky cuse_unlock(); 451fa0f6e62SHans Petter Selasky return (error); 452fa0f6e62SHans Petter Selasky } 453fa0f6e62SHans Petter Selasky mem->virtaddr = ptr; 454fa0f6e62SHans Petter Selasky mem->page_count = page_count; 455fa0f6e62SHans Petter Selasky mem->is_allocated = 1; 456fa0f6e62SHans Petter Selasky mem->owner = pcs; 457fa0f6e62SHans Petter Selasky cuse_unlock(); 458fa0f6e62SHans Petter Selasky 459fa0f6e62SHans Petter Selasky return (0); 460fa0f6e62SHans Petter Selasky } 461fa0f6e62SHans Petter Selasky 462fa0f6e62SHans Petter Selasky static int 463fa0f6e62SHans Petter Selasky cuse_client_get(struct cuse_client **ppcc) 464fa0f6e62SHans Petter Selasky { 465fa0f6e62SHans Petter Selasky struct cuse_client *pcc; 466fa0f6e62SHans Petter Selasky int error; 467fa0f6e62SHans Petter Selasky 468fa0f6e62SHans Petter Selasky /* try to get private data */ 469fa0f6e62SHans Petter Selasky error = devfs_get_cdevpriv((void **)&pcc); 470fa0f6e62SHans Petter Selasky if (error != 0) { 471fa0f6e62SHans Petter Selasky *ppcc = NULL; 472fa0f6e62SHans Petter Selasky return (error); 473fa0f6e62SHans Petter Selasky } 474fa0f6e62SHans Petter Selasky /* check if closing */ 475fa0f6e62SHans Petter Selasky cuse_lock(); 476fa0f6e62SHans Petter Selasky if (CUSE_CLIENT_CLOSING(pcc) || pcc->server->is_closing) { 477fa0f6e62SHans Petter Selasky cuse_unlock(); 478fa0f6e62SHans Petter Selasky *ppcc = NULL; 479fa0f6e62SHans Petter Selasky return (EINVAL); 480fa0f6e62SHans Petter Selasky } 481fa0f6e62SHans Petter Selasky cuse_unlock(); 482fa0f6e62SHans Petter Selasky *ppcc = pcc; 483fa0f6e62SHans Petter Selasky return (0); 484fa0f6e62SHans Petter Selasky } 485fa0f6e62SHans Petter Selasky 486fa0f6e62SHans Petter Selasky static void 487fa0f6e62SHans Petter Selasky cuse_client_is_closing(struct cuse_client *pcc) 488fa0f6e62SHans Petter Selasky { 489fa0f6e62SHans Petter Selasky struct cuse_client_command *pccmd; 490fa0f6e62SHans Petter Selasky uint32_t n; 491fa0f6e62SHans Petter Selasky 492fa0f6e62SHans Petter Selasky if (CUSE_CLIENT_CLOSING(pcc)) 493fa0f6e62SHans Petter Selasky return; 494fa0f6e62SHans Petter Selasky 495fa0f6e62SHans Petter Selasky pcc->cflags |= CUSE_CLI_IS_CLOSING; 496fa0f6e62SHans Petter Selasky pcc->server_dev = NULL; 497fa0f6e62SHans Petter Selasky 498fa0f6e62SHans Petter Selasky for (n = 0; n != CUSE_CMD_MAX; n++) { 499fa0f6e62SHans Petter Selasky 500fa0f6e62SHans Petter Selasky pccmd = &pcc->cmds[n]; 501fa0f6e62SHans Petter Selasky 502fa0f6e62SHans Petter Selasky if (pccmd->entry.tqe_prev != NULL) { 503fa0f6e62SHans Petter Selasky TAILQ_REMOVE(&pcc->server->head, pccmd, entry); 504fa0f6e62SHans Petter Selasky pccmd->entry.tqe_prev = NULL; 505fa0f6e62SHans Petter Selasky } 506fa0f6e62SHans Petter Selasky cv_broadcast(&pccmd->cv); 507fa0f6e62SHans Petter Selasky } 508fa0f6e62SHans Petter Selasky } 509fa0f6e62SHans Petter Selasky 510fa0f6e62SHans Petter Selasky static void 511fa0f6e62SHans Petter Selasky cuse_client_send_command_locked(struct cuse_client_command *pccmd, 512fa0f6e62SHans Petter Selasky unsigned long data_ptr, unsigned long arg, int fflags, int ioflag) 513fa0f6e62SHans Petter Selasky { 514fa0f6e62SHans Petter Selasky unsigned long cuse_fflags = 0; 515fa0f6e62SHans Petter Selasky struct cuse_server *pcs; 516fa0f6e62SHans Petter Selasky 517fa0f6e62SHans Petter Selasky if (fflags & FREAD) 518fa0f6e62SHans Petter Selasky cuse_fflags |= CUSE_FFLAG_READ; 519fa0f6e62SHans Petter Selasky 520fa0f6e62SHans Petter Selasky if (fflags & FWRITE) 521fa0f6e62SHans Petter Selasky cuse_fflags |= CUSE_FFLAG_WRITE; 522fa0f6e62SHans Petter Selasky 523fa0f6e62SHans Petter Selasky if (ioflag & IO_NDELAY) 524fa0f6e62SHans Petter Selasky cuse_fflags |= CUSE_FFLAG_NONBLOCK; 525fa0f6e62SHans Petter Selasky 526fa0f6e62SHans Petter Selasky pccmd->sub.fflags = cuse_fflags; 527fa0f6e62SHans Petter Selasky pccmd->sub.data_pointer = data_ptr; 528fa0f6e62SHans Petter Selasky pccmd->sub.argument = arg; 529fa0f6e62SHans Petter Selasky 530fa0f6e62SHans Petter Selasky pcs = pccmd->client->server; 531fa0f6e62SHans Petter Selasky 532fa0f6e62SHans Petter Selasky if ((pccmd->entry.tqe_prev == NULL) && 533fa0f6e62SHans Petter Selasky (CUSE_CLIENT_CLOSING(pccmd->client) == 0) && 534fa0f6e62SHans Petter Selasky (pcs->is_closing == 0)) { 535fa0f6e62SHans Petter Selasky TAILQ_INSERT_TAIL(&pcs->head, pccmd, entry); 536fa0f6e62SHans Petter Selasky cv_signal(&pcs->cv); 537fa0f6e62SHans Petter Selasky } 538fa0f6e62SHans Petter Selasky } 539fa0f6e62SHans Petter Selasky 540fa0f6e62SHans Petter Selasky static void 541fa0f6e62SHans Petter Selasky cuse_client_got_signal(struct cuse_client_command *pccmd) 542fa0f6e62SHans Petter Selasky { 543fa0f6e62SHans Petter Selasky struct cuse_server *pcs; 544fa0f6e62SHans Petter Selasky 545fa0f6e62SHans Petter Selasky pccmd->got_signal = 1; 546fa0f6e62SHans Petter Selasky 547fa0f6e62SHans Petter Selasky pccmd = &pccmd->client->cmds[CUSE_CMD_SIGNAL]; 548fa0f6e62SHans Petter Selasky 549fa0f6e62SHans Petter Selasky pcs = pccmd->client->server; 550fa0f6e62SHans Petter Selasky 551fa0f6e62SHans Petter Selasky if ((pccmd->entry.tqe_prev == NULL) && 552fa0f6e62SHans Petter Selasky (CUSE_CLIENT_CLOSING(pccmd->client) == 0) && 553fa0f6e62SHans Petter Selasky (pcs->is_closing == 0)) { 554fa0f6e62SHans Petter Selasky TAILQ_INSERT_TAIL(&pcs->head, pccmd, entry); 555fa0f6e62SHans Petter Selasky cv_signal(&pcs->cv); 556fa0f6e62SHans Petter Selasky } 557fa0f6e62SHans Petter Selasky } 558fa0f6e62SHans Petter Selasky 559fa0f6e62SHans Petter Selasky static int 560fa0f6e62SHans Petter Selasky cuse_client_receive_command_locked(struct cuse_client_command *pccmd, 561fa0f6e62SHans Petter Selasky uint8_t *arg_ptr, uint32_t arg_len) 562fa0f6e62SHans Petter Selasky { 563fa0f6e62SHans Petter Selasky int error; 564fa0f6e62SHans Petter Selasky 565fa0f6e62SHans Petter Selasky error = 0; 566fa0f6e62SHans Petter Selasky 567fa0f6e62SHans Petter Selasky pccmd->proc_curr = curthread->td_proc; 568fa0f6e62SHans Petter Selasky 569fa0f6e62SHans Petter Selasky if (CUSE_CLIENT_CLOSING(pccmd->client) || 570fa0f6e62SHans Petter Selasky pccmd->client->server->is_closing) { 571fa0f6e62SHans Petter Selasky error = CUSE_ERR_OTHER; 572fa0f6e62SHans Petter Selasky goto done; 573fa0f6e62SHans Petter Selasky } 574fa0f6e62SHans Petter Selasky while (pccmd->command == CUSE_CMD_NONE) { 575fa0f6e62SHans Petter Selasky if (error != 0) { 576fa0f6e62SHans Petter Selasky cv_wait(&pccmd->cv, &cuse_mtx); 577fa0f6e62SHans Petter Selasky } else { 578fa0f6e62SHans Petter Selasky error = cv_wait_sig(&pccmd->cv, &cuse_mtx); 579fa0f6e62SHans Petter Selasky 580fa0f6e62SHans Petter Selasky if (error != 0) 581fa0f6e62SHans Petter Selasky cuse_client_got_signal(pccmd); 582fa0f6e62SHans Petter Selasky } 583fa0f6e62SHans Petter Selasky if (CUSE_CLIENT_CLOSING(pccmd->client) || 584fa0f6e62SHans Petter Selasky pccmd->client->server->is_closing) { 585fa0f6e62SHans Petter Selasky error = CUSE_ERR_OTHER; 586fa0f6e62SHans Petter Selasky goto done; 587fa0f6e62SHans Petter Selasky } 588fa0f6e62SHans Petter Selasky } 589fa0f6e62SHans Petter Selasky 590fa0f6e62SHans Petter Selasky error = pccmd->error; 591fa0f6e62SHans Petter Selasky pccmd->command = CUSE_CMD_NONE; 592fa0f6e62SHans Petter Selasky cv_signal(&pccmd->cv); 593fa0f6e62SHans Petter Selasky 594fa0f6e62SHans Petter Selasky done: 595fa0f6e62SHans Petter Selasky 596fa0f6e62SHans Petter Selasky /* wait until all process references are gone */ 597fa0f6e62SHans Petter Selasky 598fa0f6e62SHans Petter Selasky pccmd->proc_curr = NULL; 599fa0f6e62SHans Petter Selasky 600fa0f6e62SHans Petter Selasky while (pccmd->proc_refs != 0) 601fa0f6e62SHans Petter Selasky cv_wait(&pccmd->cv, &cuse_mtx); 602fa0f6e62SHans Petter Selasky 603fa0f6e62SHans Petter Selasky return (error); 604fa0f6e62SHans Petter Selasky } 605fa0f6e62SHans Petter Selasky 606fa0f6e62SHans Petter Selasky /*------------------------------------------------------------------------* 607fa0f6e62SHans Petter Selasky * CUSE SERVER PART 608fa0f6e62SHans Petter Selasky *------------------------------------------------------------------------*/ 609fa0f6e62SHans Petter Selasky 610fa0f6e62SHans Petter Selasky static void 611fa0f6e62SHans Petter Selasky cuse_server_free_dev(struct cuse_server_dev *pcsd) 612fa0f6e62SHans Petter Selasky { 613fa0f6e62SHans Petter Selasky struct cuse_server *pcs; 614fa0f6e62SHans Petter Selasky struct cuse_client *pcc; 615fa0f6e62SHans Petter Selasky 616fa0f6e62SHans Petter Selasky /* get server pointer */ 617fa0f6e62SHans Petter Selasky pcs = pcsd->server; 618fa0f6e62SHans Petter Selasky 619fa0f6e62SHans Petter Selasky /* prevent creation of more devices */ 620fa0f6e62SHans Petter Selasky cuse_lock(); 621fa0f6e62SHans Petter Selasky if (pcsd->kern_dev != NULL) 622fa0f6e62SHans Petter Selasky pcsd->kern_dev->si_drv1 = NULL; 623fa0f6e62SHans Petter Selasky 624fa0f6e62SHans Petter Selasky TAILQ_FOREACH(pcc, &pcs->hcli, entry) { 625fa0f6e62SHans Petter Selasky if (pcc->server_dev == pcsd) 626fa0f6e62SHans Petter Selasky cuse_client_is_closing(pcc); 627fa0f6e62SHans Petter Selasky } 628fa0f6e62SHans Petter Selasky cuse_unlock(); 629fa0f6e62SHans Petter Selasky 630fa0f6e62SHans Petter Selasky /* destroy device, if any */ 631fa0f6e62SHans Petter Selasky if (pcsd->kern_dev != NULL) { 632fa0f6e62SHans Petter Selasky /* destroy device synchronously */ 633fa0f6e62SHans Petter Selasky destroy_dev(pcsd->kern_dev); 634fa0f6e62SHans Petter Selasky } 635fa0f6e62SHans Petter Selasky free(pcsd, M_CUSE); 636fa0f6e62SHans Petter Selasky } 637fa0f6e62SHans Petter Selasky 638fa0f6e62SHans Petter Selasky static void 639fa0f6e62SHans Petter Selasky cuse_server_free(void *arg) 640fa0f6e62SHans Petter Selasky { 641fa0f6e62SHans Petter Selasky struct cuse_server *pcs = arg; 642fa0f6e62SHans Petter Selasky struct cuse_server_dev *pcsd; 643fa0f6e62SHans Petter Selasky 644fa0f6e62SHans Petter Selasky cuse_lock(); 645fa0f6e62SHans Petter Selasky pcs->refs--; 646fa0f6e62SHans Petter Selasky if (pcs->refs != 0) { 647fa0f6e62SHans Petter Selasky cuse_unlock(); 648fa0f6e62SHans Petter Selasky return; 649fa0f6e62SHans Petter Selasky } 650fa0f6e62SHans Petter Selasky cuse_server_is_closing(pcs); 651fa0f6e62SHans Petter Selasky 652fa0f6e62SHans Petter Selasky TAILQ_REMOVE(&cuse_server_head, pcs, entry); 653fa0f6e62SHans Petter Selasky 654fa0f6e62SHans Petter Selasky cuse_free_unit_by_id_locked(pcs, -1); 655fa0f6e62SHans Petter Selasky 656fa0f6e62SHans Petter Selasky while ((pcsd = TAILQ_FIRST(&pcs->hdev)) != NULL) { 657fa0f6e62SHans Petter Selasky TAILQ_REMOVE(&pcs->hdev, pcsd, entry); 658fa0f6e62SHans Petter Selasky cuse_unlock(); 659fa0f6e62SHans Petter Selasky cuse_server_free_dev(pcsd); 660fa0f6e62SHans Petter Selasky cuse_lock(); 661fa0f6e62SHans Petter Selasky } 662fa0f6e62SHans Petter Selasky 663fa0f6e62SHans Petter Selasky cuse_server_free_memory(pcs); 664fa0f6e62SHans Petter Selasky 665fa0f6e62SHans Petter Selasky knlist_clear(&pcs->selinfo.si_note, 1); 666fa0f6e62SHans Petter Selasky knlist_destroy(&pcs->selinfo.si_note); 667fa0f6e62SHans Petter Selasky 668fa0f6e62SHans Petter Selasky cuse_unlock(); 669fa0f6e62SHans Petter Selasky 670fa0f6e62SHans Petter Selasky seldrain(&pcs->selinfo); 671fa0f6e62SHans Petter Selasky 672fa0f6e62SHans Petter Selasky cv_destroy(&pcs->cv); 673fa0f6e62SHans Petter Selasky 674fa0f6e62SHans Petter Selasky free(pcs, M_CUSE); 675fa0f6e62SHans Petter Selasky } 676fa0f6e62SHans Petter Selasky 677fa0f6e62SHans Petter Selasky static int 678fa0f6e62SHans Petter Selasky cuse_server_open(struct cdev *dev, int fflags, int devtype, struct thread *td) 679fa0f6e62SHans Petter Selasky { 680fa0f6e62SHans Petter Selasky struct cuse_server *pcs; 681fa0f6e62SHans Petter Selasky 682fa0f6e62SHans Petter Selasky pcs = malloc(sizeof(*pcs), M_CUSE, M_WAITOK | M_ZERO); 683fa0f6e62SHans Petter Selasky if (pcs == NULL) 684fa0f6e62SHans Petter Selasky return (ENOMEM); 685fa0f6e62SHans Petter Selasky 686fa0f6e62SHans Petter Selasky if (devfs_set_cdevpriv(pcs, &cuse_server_free)) { 687fa0f6e62SHans Petter Selasky printf("Cuse: Cannot set cdevpriv.\n"); 688fa0f6e62SHans Petter Selasky free(pcs, M_CUSE); 689fa0f6e62SHans Petter Selasky return (ENOMEM); 690fa0f6e62SHans Petter Selasky } 691fa0f6e62SHans Petter Selasky TAILQ_INIT(&pcs->head); 692fa0f6e62SHans Petter Selasky TAILQ_INIT(&pcs->hdev); 693fa0f6e62SHans Petter Selasky TAILQ_INIT(&pcs->hcli); 694fa0f6e62SHans Petter Selasky 695fa0f6e62SHans Petter Selasky cv_init(&pcs->cv, "cuse-server-cv"); 696fa0f6e62SHans Petter Selasky 697fa0f6e62SHans Petter Selasky knlist_init_mtx(&pcs->selinfo.si_note, &cuse_mtx); 698fa0f6e62SHans Petter Selasky 699fa0f6e62SHans Petter Selasky cuse_lock(); 700fa0f6e62SHans Petter Selasky pcs->refs++; 701fa0f6e62SHans Petter Selasky TAILQ_INSERT_TAIL(&cuse_server_head, pcs, entry); 702fa0f6e62SHans Petter Selasky cuse_unlock(); 703fa0f6e62SHans Petter Selasky 704fa0f6e62SHans Petter Selasky return (0); 705fa0f6e62SHans Petter Selasky } 706fa0f6e62SHans Petter Selasky 707fa0f6e62SHans Petter Selasky static int 708fa0f6e62SHans Petter Selasky cuse_server_close(struct cdev *dev, int fflag, int devtype, struct thread *td) 709fa0f6e62SHans Petter Selasky { 710fa0f6e62SHans Petter Selasky struct cuse_server *pcs; 711fa0f6e62SHans Petter Selasky int error; 712fa0f6e62SHans Petter Selasky 713fa0f6e62SHans Petter Selasky error = cuse_server_get(&pcs); 714fa0f6e62SHans Petter Selasky if (error != 0) 715fa0f6e62SHans Petter Selasky goto done; 716fa0f6e62SHans Petter Selasky 717fa0f6e62SHans Petter Selasky cuse_lock(); 718fa0f6e62SHans Petter Selasky cuse_server_is_closing(pcs); 719fa0f6e62SHans Petter Selasky knlist_clear(&pcs->selinfo.si_note, 1); 720fa0f6e62SHans Petter Selasky cuse_unlock(); 721fa0f6e62SHans Petter Selasky 722fa0f6e62SHans Petter Selasky done: 723fa0f6e62SHans Petter Selasky return (0); 724fa0f6e62SHans Petter Selasky } 725fa0f6e62SHans Petter Selasky 726fa0f6e62SHans Petter Selasky static int 727fa0f6e62SHans Petter Selasky cuse_server_read(struct cdev *dev, struct uio *uio, int ioflag) 728fa0f6e62SHans Petter Selasky { 729fa0f6e62SHans Petter Selasky return (ENXIO); 730fa0f6e62SHans Petter Selasky } 731fa0f6e62SHans Petter Selasky 732fa0f6e62SHans Petter Selasky static int 733fa0f6e62SHans Petter Selasky cuse_server_write(struct cdev *dev, struct uio *uio, int ioflag) 734fa0f6e62SHans Petter Selasky { 735fa0f6e62SHans Petter Selasky return (ENXIO); 736fa0f6e62SHans Petter Selasky } 737fa0f6e62SHans Petter Selasky 738fa0f6e62SHans Petter Selasky static int 739fa0f6e62SHans Petter Selasky cuse_server_ioctl_copy_locked(struct cuse_client_command *pccmd, 740fa0f6e62SHans Petter Selasky struct cuse_data_chunk *pchk, int isread) 741fa0f6e62SHans Petter Selasky { 742fa0f6e62SHans Petter Selasky struct proc *p_proc; 743fa0f6e62SHans Petter Selasky uint32_t offset; 744fa0f6e62SHans Petter Selasky int error; 745fa0f6e62SHans Petter Selasky 746fa0f6e62SHans Petter Selasky offset = pchk->peer_ptr - CUSE_BUF_MIN_PTR; 747fa0f6e62SHans Petter Selasky 748fa0f6e62SHans Petter Selasky if (pchk->length > CUSE_BUFFER_MAX) 749fa0f6e62SHans Petter Selasky return (EFAULT); 750fa0f6e62SHans Petter Selasky 751fa0f6e62SHans Petter Selasky if (offset >= CUSE_BUFFER_MAX) 752fa0f6e62SHans Petter Selasky return (EFAULT); 753fa0f6e62SHans Petter Selasky 754fa0f6e62SHans Petter Selasky if ((offset + pchk->length) > CUSE_BUFFER_MAX) 755fa0f6e62SHans Petter Selasky return (EFAULT); 756fa0f6e62SHans Petter Selasky 757fa0f6e62SHans Petter Selasky p_proc = pccmd->proc_curr; 758fa0f6e62SHans Petter Selasky if (p_proc == NULL) 759fa0f6e62SHans Petter Selasky return (ENXIO); 760fa0f6e62SHans Petter Selasky 761fa0f6e62SHans Petter Selasky if (pccmd->proc_refs < 0) 762fa0f6e62SHans Petter Selasky return (ENOMEM); 763fa0f6e62SHans Petter Selasky 764fa0f6e62SHans Petter Selasky pccmd->proc_refs++; 765fa0f6e62SHans Petter Selasky 766fa0f6e62SHans Petter Selasky cuse_unlock(); 767fa0f6e62SHans Petter Selasky 768fa0f6e62SHans Petter Selasky if (isread == 0) { 769fa0f6e62SHans Petter Selasky error = copyin( 770fa0f6e62SHans Petter Selasky (void *)pchk->local_ptr, 771fa0f6e62SHans Petter Selasky pccmd->client->ioctl_buffer + offset, 772fa0f6e62SHans Petter Selasky pchk->length); 773fa0f6e62SHans Petter Selasky } else { 774fa0f6e62SHans Petter Selasky error = copyout( 775fa0f6e62SHans Petter Selasky pccmd->client->ioctl_buffer + offset, 776fa0f6e62SHans Petter Selasky (void *)pchk->local_ptr, 777fa0f6e62SHans Petter Selasky pchk->length); 778fa0f6e62SHans Petter Selasky } 779fa0f6e62SHans Petter Selasky 780fa0f6e62SHans Petter Selasky cuse_lock(); 781fa0f6e62SHans Petter Selasky 782fa0f6e62SHans Petter Selasky pccmd->proc_refs--; 783fa0f6e62SHans Petter Selasky 784fa0f6e62SHans Petter Selasky if (pccmd->proc_curr == NULL) 785fa0f6e62SHans Petter Selasky cv_signal(&pccmd->cv); 786fa0f6e62SHans Petter Selasky 787fa0f6e62SHans Petter Selasky return (error); 788fa0f6e62SHans Petter Selasky } 789fa0f6e62SHans Petter Selasky 790fa0f6e62SHans Petter Selasky static int 791fa0f6e62SHans Petter Selasky cuse_proc2proc_copy(struct proc *proc_s, vm_offset_t data_s, 792fa0f6e62SHans Petter Selasky struct proc *proc_d, vm_offset_t data_d, size_t len) 793fa0f6e62SHans Petter Selasky { 794fa0f6e62SHans Petter Selasky struct thread *td; 795fa0f6e62SHans Petter Selasky struct proc *proc_cur; 796fa0f6e62SHans Petter Selasky int error; 797fa0f6e62SHans Petter Selasky 798fa0f6e62SHans Petter Selasky td = curthread; 799fa0f6e62SHans Petter Selasky proc_cur = td->td_proc; 800fa0f6e62SHans Petter Selasky 801fa0f6e62SHans Petter Selasky if (proc_cur == proc_d) { 802fa0f6e62SHans Petter Selasky struct iovec iov = { 803fa0f6e62SHans Petter Selasky .iov_base = (caddr_t)data_d, 804fa0f6e62SHans Petter Selasky .iov_len = len, 805fa0f6e62SHans Petter Selasky }; 806fa0f6e62SHans Petter Selasky struct uio uio = { 807fa0f6e62SHans Petter Selasky .uio_iov = &iov, 808fa0f6e62SHans Petter Selasky .uio_iovcnt = 1, 809fa0f6e62SHans Petter Selasky .uio_offset = (off_t)data_s, 810fa0f6e62SHans Petter Selasky .uio_resid = len, 811fa0f6e62SHans Petter Selasky .uio_segflg = UIO_USERSPACE, 812fa0f6e62SHans Petter Selasky .uio_rw = UIO_READ, 813fa0f6e62SHans Petter Selasky .uio_td = td, 814fa0f6e62SHans Petter Selasky }; 815fa0f6e62SHans Petter Selasky 8165928e3b9SHans Petter Selasky PHOLD(proc_s); 817fa0f6e62SHans Petter Selasky error = proc_rwmem(proc_s, &uio); 8185928e3b9SHans Petter Selasky PRELE(proc_s); 819fa0f6e62SHans Petter Selasky 820fa0f6e62SHans Petter Selasky } else if (proc_cur == proc_s) { 821fa0f6e62SHans Petter Selasky struct iovec iov = { 822fa0f6e62SHans Petter Selasky .iov_base = (caddr_t)data_s, 823fa0f6e62SHans Petter Selasky .iov_len = len, 824fa0f6e62SHans Petter Selasky }; 825fa0f6e62SHans Petter Selasky struct uio uio = { 826fa0f6e62SHans Petter Selasky .uio_iov = &iov, 827fa0f6e62SHans Petter Selasky .uio_iovcnt = 1, 828fa0f6e62SHans Petter Selasky .uio_offset = (off_t)data_d, 829fa0f6e62SHans Petter Selasky .uio_resid = len, 830fa0f6e62SHans Petter Selasky .uio_segflg = UIO_USERSPACE, 831fa0f6e62SHans Petter Selasky .uio_rw = UIO_WRITE, 832fa0f6e62SHans Petter Selasky .uio_td = td, 833fa0f6e62SHans Petter Selasky }; 834fa0f6e62SHans Petter Selasky 8355928e3b9SHans Petter Selasky PHOLD(proc_d); 836fa0f6e62SHans Petter Selasky error = proc_rwmem(proc_d, &uio); 8375928e3b9SHans Petter Selasky PRELE(proc_d); 838fa0f6e62SHans Petter Selasky } else { 839fa0f6e62SHans Petter Selasky error = EINVAL; 840fa0f6e62SHans Petter Selasky } 841fa0f6e62SHans Petter Selasky return (error); 842fa0f6e62SHans Petter Selasky } 843fa0f6e62SHans Petter Selasky 844fa0f6e62SHans Petter Selasky static int 845fa0f6e62SHans Petter Selasky cuse_server_data_copy_locked(struct cuse_client_command *pccmd, 846fa0f6e62SHans Petter Selasky struct cuse_data_chunk *pchk, int isread) 847fa0f6e62SHans Petter Selasky { 848fa0f6e62SHans Petter Selasky struct proc *p_proc; 849fa0f6e62SHans Petter Selasky int error; 850fa0f6e62SHans Petter Selasky 851fa0f6e62SHans Petter Selasky p_proc = pccmd->proc_curr; 852fa0f6e62SHans Petter Selasky if (p_proc == NULL) 853fa0f6e62SHans Petter Selasky return (ENXIO); 854fa0f6e62SHans Petter Selasky 855fa0f6e62SHans Petter Selasky if (pccmd->proc_refs < 0) 856fa0f6e62SHans Petter Selasky return (ENOMEM); 857fa0f6e62SHans Petter Selasky 858fa0f6e62SHans Petter Selasky pccmd->proc_refs++; 859fa0f6e62SHans Petter Selasky 860fa0f6e62SHans Petter Selasky cuse_unlock(); 861fa0f6e62SHans Petter Selasky 862fa0f6e62SHans Petter Selasky if (isread == 0) { 863fa0f6e62SHans Petter Selasky error = cuse_proc2proc_copy( 864fa0f6e62SHans Petter Selasky curthread->td_proc, pchk->local_ptr, 865fa0f6e62SHans Petter Selasky p_proc, pchk->peer_ptr, 866fa0f6e62SHans Petter Selasky pchk->length); 867fa0f6e62SHans Petter Selasky } else { 868fa0f6e62SHans Petter Selasky error = cuse_proc2proc_copy( 869fa0f6e62SHans Petter Selasky p_proc, pchk->peer_ptr, 870fa0f6e62SHans Petter Selasky curthread->td_proc, pchk->local_ptr, 871fa0f6e62SHans Petter Selasky pchk->length); 872fa0f6e62SHans Petter Selasky } 873fa0f6e62SHans Petter Selasky 874fa0f6e62SHans Petter Selasky cuse_lock(); 875fa0f6e62SHans Petter Selasky 876fa0f6e62SHans Petter Selasky pccmd->proc_refs--; 877fa0f6e62SHans Petter Selasky 878fa0f6e62SHans Petter Selasky if (pccmd->proc_curr == NULL) 879fa0f6e62SHans Petter Selasky cv_signal(&pccmd->cv); 880fa0f6e62SHans Petter Selasky 881fa0f6e62SHans Petter Selasky return (error); 882fa0f6e62SHans Petter Selasky } 883fa0f6e62SHans Petter Selasky 884fa0f6e62SHans Petter Selasky static int 885fa0f6e62SHans Petter Selasky cuse_alloc_unit_by_id_locked(struct cuse_server *pcs, int id) 886fa0f6e62SHans Petter Selasky { 887fa0f6e62SHans Petter Selasky int n; 888fa0f6e62SHans Petter Selasky int x = 0; 889fa0f6e62SHans Petter Selasky int match; 890fa0f6e62SHans Petter Selasky 891fa0f6e62SHans Petter Selasky do { 892fa0f6e62SHans Petter Selasky for (match = n = 0; n != CUSE_DEVICES_MAX; n++) { 893fa0f6e62SHans Petter Selasky if (cuse_alloc_unit[n] != NULL) { 894fa0f6e62SHans Petter Selasky if ((cuse_alloc_unit_id[n] ^ id) & CUSE_ID_MASK) 895fa0f6e62SHans Petter Selasky continue; 896fa0f6e62SHans Petter Selasky if ((cuse_alloc_unit_id[n] & ~CUSE_ID_MASK) == x) { 897fa0f6e62SHans Petter Selasky x++; 898fa0f6e62SHans Petter Selasky match = 1; 899fa0f6e62SHans Petter Selasky } 900fa0f6e62SHans Petter Selasky } 901fa0f6e62SHans Petter Selasky } 902fa0f6e62SHans Petter Selasky } while (match); 903fa0f6e62SHans Petter Selasky 904fa0f6e62SHans Petter Selasky if (x < 256) { 905fa0f6e62SHans Petter Selasky for (n = 0; n != CUSE_DEVICES_MAX; n++) { 906fa0f6e62SHans Petter Selasky if (cuse_alloc_unit[n] == NULL) { 907fa0f6e62SHans Petter Selasky cuse_alloc_unit[n] = pcs; 908fa0f6e62SHans Petter Selasky cuse_alloc_unit_id[n] = id | x; 909fa0f6e62SHans Petter Selasky return (x); 910fa0f6e62SHans Petter Selasky } 911fa0f6e62SHans Petter Selasky } 912fa0f6e62SHans Petter Selasky } 913fa0f6e62SHans Petter Selasky return (-1); 914fa0f6e62SHans Petter Selasky } 915fa0f6e62SHans Petter Selasky 916fa0f6e62SHans Petter Selasky static void 917fa0f6e62SHans Petter Selasky cuse_server_wakeup_locked(struct cuse_server *pcs) 918fa0f6e62SHans Petter Selasky { 919fa0f6e62SHans Petter Selasky selwakeup(&pcs->selinfo); 920fa0f6e62SHans Petter Selasky KNOTE_LOCKED(&pcs->selinfo.si_note, 0); 921fa0f6e62SHans Petter Selasky } 922fa0f6e62SHans Petter Selasky 923fa0f6e62SHans Petter Selasky static int 924fa0f6e62SHans Petter Selasky cuse_free_unit_by_id_locked(struct cuse_server *pcs, int id) 925fa0f6e62SHans Petter Selasky { 926fa0f6e62SHans Petter Selasky int n; 927fa0f6e62SHans Petter Selasky int found = 0; 928fa0f6e62SHans Petter Selasky 929fa0f6e62SHans Petter Selasky for (n = 0; n != CUSE_DEVICES_MAX; n++) { 930fa0f6e62SHans Petter Selasky if (cuse_alloc_unit[n] == pcs) { 931fa0f6e62SHans Petter Selasky if (cuse_alloc_unit_id[n] == id || id == -1) { 932fa0f6e62SHans Petter Selasky cuse_alloc_unit[n] = NULL; 933fa0f6e62SHans Petter Selasky cuse_alloc_unit_id[n] = 0; 934fa0f6e62SHans Petter Selasky found = 1; 935fa0f6e62SHans Petter Selasky } 936fa0f6e62SHans Petter Selasky } 937fa0f6e62SHans Petter Selasky } 938fa0f6e62SHans Petter Selasky 939fa0f6e62SHans Petter Selasky return (found ? 0 : EINVAL); 940fa0f6e62SHans Petter Selasky } 941fa0f6e62SHans Petter Selasky 942fa0f6e62SHans Petter Selasky static int 943fa0f6e62SHans Petter Selasky cuse_server_ioctl(struct cdev *dev, unsigned long cmd, 944fa0f6e62SHans Petter Selasky caddr_t data, int fflag, struct thread *td) 945fa0f6e62SHans Petter Selasky { 946fa0f6e62SHans Petter Selasky struct cuse_server *pcs; 947fa0f6e62SHans Petter Selasky int error; 948fa0f6e62SHans Petter Selasky 949fa0f6e62SHans Petter Selasky error = cuse_server_get(&pcs); 950fa0f6e62SHans Petter Selasky if (error != 0) 951fa0f6e62SHans Petter Selasky return (error); 952fa0f6e62SHans Petter Selasky 953fa0f6e62SHans Petter Selasky switch (cmd) { 954fa0f6e62SHans Petter Selasky struct cuse_client_command *pccmd; 955fa0f6e62SHans Petter Selasky struct cuse_client *pcc; 956fa0f6e62SHans Petter Selasky struct cuse_command *pcmd; 957fa0f6e62SHans Petter Selasky struct cuse_alloc_info *pai; 958fa0f6e62SHans Petter Selasky struct cuse_create_dev *pcd; 959fa0f6e62SHans Petter Selasky struct cuse_server_dev *pcsd; 960fa0f6e62SHans Petter Selasky struct cuse_data_chunk *pchk; 961fa0f6e62SHans Petter Selasky int n; 962fa0f6e62SHans Petter Selasky 963fa0f6e62SHans Petter Selasky case CUSE_IOCTL_GET_COMMAND: 964fa0f6e62SHans Petter Selasky pcmd = (void *)data; 965fa0f6e62SHans Petter Selasky 966fa0f6e62SHans Petter Selasky cuse_lock(); 967fa0f6e62SHans Petter Selasky 968fa0f6e62SHans Petter Selasky while ((pccmd = TAILQ_FIRST(&pcs->head)) == NULL) { 969fa0f6e62SHans Petter Selasky error = cv_wait_sig(&pcs->cv, &cuse_mtx); 970fa0f6e62SHans Petter Selasky 971fa0f6e62SHans Petter Selasky if (pcs->is_closing) 972fa0f6e62SHans Petter Selasky error = ENXIO; 973fa0f6e62SHans Petter Selasky 974fa0f6e62SHans Petter Selasky if (error) { 975fa0f6e62SHans Petter Selasky cuse_unlock(); 976fa0f6e62SHans Petter Selasky return (error); 977fa0f6e62SHans Petter Selasky } 978fa0f6e62SHans Petter Selasky } 979fa0f6e62SHans Petter Selasky 980fa0f6e62SHans Petter Selasky TAILQ_REMOVE(&pcs->head, pccmd, entry); 981fa0f6e62SHans Petter Selasky pccmd->entry.tqe_prev = NULL; 982fa0f6e62SHans Petter Selasky 983fa0f6e62SHans Petter Selasky pccmd->entered = curthread; 984fa0f6e62SHans Petter Selasky 985fa0f6e62SHans Petter Selasky *pcmd = pccmd->sub; 986fa0f6e62SHans Petter Selasky 987fa0f6e62SHans Petter Selasky cuse_unlock(); 988fa0f6e62SHans Petter Selasky 989fa0f6e62SHans Petter Selasky break; 990fa0f6e62SHans Petter Selasky 991fa0f6e62SHans Petter Selasky case CUSE_IOCTL_SYNC_COMMAND: 992fa0f6e62SHans Petter Selasky 993fa0f6e62SHans Petter Selasky cuse_lock(); 994fa0f6e62SHans Petter Selasky while ((pccmd = cuse_server_find_command(pcs, curthread)) != NULL) { 995fa0f6e62SHans Petter Selasky 996fa0f6e62SHans Petter Selasky /* send sync command */ 997fa0f6e62SHans Petter Selasky pccmd->entered = NULL; 998fa0f6e62SHans Petter Selasky pccmd->error = *(int *)data; 999fa0f6e62SHans Petter Selasky pccmd->command = CUSE_CMD_SYNC; 1000fa0f6e62SHans Petter Selasky 1001fa0f6e62SHans Petter Selasky /* signal peer, if any */ 1002fa0f6e62SHans Petter Selasky cv_signal(&pccmd->cv); 1003fa0f6e62SHans Petter Selasky } 1004fa0f6e62SHans Petter Selasky cuse_unlock(); 1005fa0f6e62SHans Petter Selasky 1006fa0f6e62SHans Petter Selasky break; 1007fa0f6e62SHans Petter Selasky 1008fa0f6e62SHans Petter Selasky case CUSE_IOCTL_ALLOC_UNIT: 1009fa0f6e62SHans Petter Selasky 1010fa0f6e62SHans Petter Selasky cuse_lock(); 1011fa0f6e62SHans Petter Selasky n = cuse_alloc_unit_by_id_locked(pcs, 1012fa0f6e62SHans Petter Selasky CUSE_ID_DEFAULT(0)); 1013fa0f6e62SHans Petter Selasky cuse_unlock(); 1014fa0f6e62SHans Petter Selasky 1015fa0f6e62SHans Petter Selasky if (n < 0) 1016fa0f6e62SHans Petter Selasky error = ENOMEM; 1017fa0f6e62SHans Petter Selasky else 1018fa0f6e62SHans Petter Selasky *(int *)data = n; 1019fa0f6e62SHans Petter Selasky break; 1020fa0f6e62SHans Petter Selasky 1021fa0f6e62SHans Petter Selasky case CUSE_IOCTL_ALLOC_UNIT_BY_ID: 1022fa0f6e62SHans Petter Selasky 1023fa0f6e62SHans Petter Selasky n = *(int *)data; 1024fa0f6e62SHans Petter Selasky 1025fa0f6e62SHans Petter Selasky n = (n & CUSE_ID_MASK); 1026fa0f6e62SHans Petter Selasky 1027fa0f6e62SHans Petter Selasky cuse_lock(); 1028fa0f6e62SHans Petter Selasky n = cuse_alloc_unit_by_id_locked(pcs, n); 1029fa0f6e62SHans Petter Selasky cuse_unlock(); 1030fa0f6e62SHans Petter Selasky 1031fa0f6e62SHans Petter Selasky if (n < 0) 1032fa0f6e62SHans Petter Selasky error = ENOMEM; 1033fa0f6e62SHans Petter Selasky else 1034fa0f6e62SHans Petter Selasky *(int *)data = n; 1035fa0f6e62SHans Petter Selasky break; 1036fa0f6e62SHans Petter Selasky 1037fa0f6e62SHans Petter Selasky case CUSE_IOCTL_FREE_UNIT: 1038fa0f6e62SHans Petter Selasky 1039fa0f6e62SHans Petter Selasky n = *(int *)data; 1040fa0f6e62SHans Petter Selasky 1041fa0f6e62SHans Petter Selasky n = CUSE_ID_DEFAULT(n); 1042fa0f6e62SHans Petter Selasky 1043fa0f6e62SHans Petter Selasky cuse_lock(); 1044fa0f6e62SHans Petter Selasky error = cuse_free_unit_by_id_locked(pcs, n); 1045fa0f6e62SHans Petter Selasky cuse_unlock(); 1046fa0f6e62SHans Petter Selasky break; 1047fa0f6e62SHans Petter Selasky 1048fa0f6e62SHans Petter Selasky case CUSE_IOCTL_FREE_UNIT_BY_ID: 1049fa0f6e62SHans Petter Selasky 1050fa0f6e62SHans Petter Selasky n = *(int *)data; 1051fa0f6e62SHans Petter Selasky 1052fa0f6e62SHans Petter Selasky cuse_lock(); 1053fa0f6e62SHans Petter Selasky error = cuse_free_unit_by_id_locked(pcs, n); 1054fa0f6e62SHans Petter Selasky cuse_unlock(); 1055fa0f6e62SHans Petter Selasky break; 1056fa0f6e62SHans Petter Selasky 1057fa0f6e62SHans Petter Selasky case CUSE_IOCTL_ALLOC_MEMORY: 1058fa0f6e62SHans Petter Selasky 1059fa0f6e62SHans Petter Selasky pai = (void *)data; 1060fa0f6e62SHans Petter Selasky 1061fa0f6e62SHans Petter Selasky if (pai->alloc_nr >= CUSE_ALLOC_UNIT_MAX) { 1062fa0f6e62SHans Petter Selasky error = ENOMEM; 1063fa0f6e62SHans Petter Selasky break; 1064fa0f6e62SHans Petter Selasky } 1065fa0f6e62SHans Petter Selasky if (pai->page_count > CUSE_ALLOC_PAGES_MAX) { 1066fa0f6e62SHans Petter Selasky error = ENOMEM; 1067fa0f6e62SHans Petter Selasky break; 1068fa0f6e62SHans Petter Selasky } 1069fa0f6e62SHans Petter Selasky error = cuse_server_alloc_memory(pcs, 1070fa0f6e62SHans Petter Selasky &cuse_mem[pai->alloc_nr], pai->page_count); 1071fa0f6e62SHans Petter Selasky break; 1072fa0f6e62SHans Petter Selasky 1073fa0f6e62SHans Petter Selasky case CUSE_IOCTL_FREE_MEMORY: 1074fa0f6e62SHans Petter Selasky pai = (void *)data; 1075fa0f6e62SHans Petter Selasky 1076fa0f6e62SHans Petter Selasky if (pai->alloc_nr >= CUSE_ALLOC_UNIT_MAX) { 1077fa0f6e62SHans Petter Selasky error = ENOMEM; 1078fa0f6e62SHans Petter Selasky break; 1079fa0f6e62SHans Petter Selasky } 1080fa0f6e62SHans Petter Selasky /* we trust the character device driver in this case */ 1081fa0f6e62SHans Petter Selasky 1082fa0f6e62SHans Petter Selasky cuse_lock(); 1083fa0f6e62SHans Petter Selasky if (cuse_mem[pai->alloc_nr].owner == pcs) { 1084fa0f6e62SHans Petter Selasky cuse_mem[pai->alloc_nr].is_allocated = 0; 1085fa0f6e62SHans Petter Selasky cuse_mem[pai->alloc_nr].owner = NULL; 1086fa0f6e62SHans Petter Selasky } else { 1087fa0f6e62SHans Petter Selasky error = EINVAL; 1088fa0f6e62SHans Petter Selasky } 1089fa0f6e62SHans Petter Selasky cuse_unlock(); 1090fa0f6e62SHans Petter Selasky break; 1091fa0f6e62SHans Petter Selasky 1092fa0f6e62SHans Petter Selasky case CUSE_IOCTL_GET_SIG: 1093fa0f6e62SHans Petter Selasky 1094fa0f6e62SHans Petter Selasky cuse_lock(); 1095fa0f6e62SHans Petter Selasky pccmd = cuse_server_find_command(pcs, curthread); 1096fa0f6e62SHans Petter Selasky 1097fa0f6e62SHans Petter Selasky if (pccmd != NULL) { 1098fa0f6e62SHans Petter Selasky n = pccmd->got_signal; 1099fa0f6e62SHans Petter Selasky pccmd->got_signal = 0; 1100fa0f6e62SHans Petter Selasky } else { 1101fa0f6e62SHans Petter Selasky n = 0; 1102fa0f6e62SHans Petter Selasky } 1103fa0f6e62SHans Petter Selasky cuse_unlock(); 1104fa0f6e62SHans Petter Selasky 1105fa0f6e62SHans Petter Selasky *(int *)data = n; 1106fa0f6e62SHans Petter Selasky 1107fa0f6e62SHans Petter Selasky break; 1108fa0f6e62SHans Petter Selasky 1109fa0f6e62SHans Petter Selasky case CUSE_IOCTL_SET_PFH: 1110fa0f6e62SHans Petter Selasky 1111fa0f6e62SHans Petter Selasky cuse_lock(); 1112fa0f6e62SHans Petter Selasky pccmd = cuse_server_find_command(pcs, curthread); 1113fa0f6e62SHans Petter Selasky 1114fa0f6e62SHans Petter Selasky if (pccmd != NULL) { 1115fa0f6e62SHans Petter Selasky pcc = pccmd->client; 1116fa0f6e62SHans Petter Selasky for (n = 0; n != CUSE_CMD_MAX; n++) { 1117fa0f6e62SHans Petter Selasky pcc->cmds[n].sub.per_file_handle = *(unsigned long *)data; 1118fa0f6e62SHans Petter Selasky } 1119fa0f6e62SHans Petter Selasky } else { 1120fa0f6e62SHans Petter Selasky error = ENXIO; 1121fa0f6e62SHans Petter Selasky } 1122fa0f6e62SHans Petter Selasky cuse_unlock(); 1123fa0f6e62SHans Petter Selasky break; 1124fa0f6e62SHans Petter Selasky 1125fa0f6e62SHans Petter Selasky case CUSE_IOCTL_CREATE_DEV: 1126fa0f6e62SHans Petter Selasky 1127fa0f6e62SHans Petter Selasky error = priv_check(curthread, PRIV_DRIVER); 1128fa0f6e62SHans Petter Selasky if (error) 1129fa0f6e62SHans Petter Selasky break; 1130fa0f6e62SHans Petter Selasky 1131fa0f6e62SHans Petter Selasky pcd = (void *)data; 1132fa0f6e62SHans Petter Selasky 1133fa0f6e62SHans Petter Selasky /* filter input */ 1134fa0f6e62SHans Petter Selasky 1135fa0f6e62SHans Petter Selasky pcd->devname[sizeof(pcd->devname) - 1] = 0; 1136fa0f6e62SHans Petter Selasky 1137fa0f6e62SHans Petter Selasky if (pcd->devname[0] == 0) { 1138fa0f6e62SHans Petter Selasky error = EINVAL; 1139fa0f6e62SHans Petter Selasky break; 1140fa0f6e62SHans Petter Selasky } 1141fa0f6e62SHans Petter Selasky cuse_str_filter(pcd->devname); 1142fa0f6e62SHans Petter Selasky 1143fa0f6e62SHans Petter Selasky pcd->permissions &= 0777; 1144fa0f6e62SHans Petter Selasky 1145fa0f6e62SHans Petter Selasky /* try to allocate a character device */ 1146fa0f6e62SHans Petter Selasky 1147fa0f6e62SHans Petter Selasky pcsd = malloc(sizeof(*pcsd), M_CUSE, M_WAITOK | M_ZERO); 1148fa0f6e62SHans Petter Selasky 1149fa0f6e62SHans Petter Selasky if (pcsd == NULL) { 1150fa0f6e62SHans Petter Selasky error = ENOMEM; 1151fa0f6e62SHans Petter Selasky break; 1152fa0f6e62SHans Petter Selasky } 1153fa0f6e62SHans Petter Selasky pcsd->server = pcs; 1154fa0f6e62SHans Petter Selasky 1155fa0f6e62SHans Petter Selasky pcsd->user_dev = pcd->dev; 1156fa0f6e62SHans Petter Selasky 1157fa0f6e62SHans Petter Selasky pcsd->kern_dev = make_dev_credf(MAKEDEV_CHECKNAME, 1158fa0f6e62SHans Petter Selasky &cuse_client_devsw, 0, NULL, pcd->user_id, pcd->group_id, 1159fa0f6e62SHans Petter Selasky pcd->permissions, "%s", pcd->devname); 1160fa0f6e62SHans Petter Selasky 1161fa0f6e62SHans Petter Selasky if (pcsd->kern_dev == NULL) { 1162fa0f6e62SHans Petter Selasky free(pcsd, M_CUSE); 1163fa0f6e62SHans Petter Selasky error = ENOMEM; 1164fa0f6e62SHans Petter Selasky break; 1165fa0f6e62SHans Petter Selasky } 1166fa0f6e62SHans Petter Selasky pcsd->kern_dev->si_drv1 = pcsd; 1167fa0f6e62SHans Petter Selasky 1168fa0f6e62SHans Petter Selasky cuse_lock(); 1169fa0f6e62SHans Petter Selasky TAILQ_INSERT_TAIL(&pcs->hdev, pcsd, entry); 1170fa0f6e62SHans Petter Selasky cuse_unlock(); 1171fa0f6e62SHans Petter Selasky 1172fa0f6e62SHans Petter Selasky break; 1173fa0f6e62SHans Petter Selasky 1174fa0f6e62SHans Petter Selasky case CUSE_IOCTL_DESTROY_DEV: 1175fa0f6e62SHans Petter Selasky 1176fa0f6e62SHans Petter Selasky error = priv_check(curthread, PRIV_DRIVER); 1177fa0f6e62SHans Petter Selasky if (error) 1178fa0f6e62SHans Petter Selasky break; 1179fa0f6e62SHans Petter Selasky 1180fa0f6e62SHans Petter Selasky cuse_lock(); 1181fa0f6e62SHans Petter Selasky 1182fa0f6e62SHans Petter Selasky error = EINVAL; 1183fa0f6e62SHans Petter Selasky 1184fa0f6e62SHans Petter Selasky pcsd = TAILQ_FIRST(&pcs->hdev); 1185fa0f6e62SHans Petter Selasky while (pcsd != NULL) { 1186fa0f6e62SHans Petter Selasky if (pcsd->user_dev == *(struct cuse_dev **)data) { 1187fa0f6e62SHans Petter Selasky TAILQ_REMOVE(&pcs->hdev, pcsd, entry); 1188fa0f6e62SHans Petter Selasky cuse_unlock(); 1189fa0f6e62SHans Petter Selasky cuse_server_free_dev(pcsd); 1190fa0f6e62SHans Petter Selasky cuse_lock(); 1191fa0f6e62SHans Petter Selasky error = 0; 1192fa0f6e62SHans Petter Selasky pcsd = TAILQ_FIRST(&pcs->hdev); 1193fa0f6e62SHans Petter Selasky } else { 1194fa0f6e62SHans Petter Selasky pcsd = TAILQ_NEXT(pcsd, entry); 1195fa0f6e62SHans Petter Selasky } 1196fa0f6e62SHans Petter Selasky } 1197fa0f6e62SHans Petter Selasky 1198fa0f6e62SHans Petter Selasky cuse_unlock(); 1199fa0f6e62SHans Petter Selasky break; 1200fa0f6e62SHans Petter Selasky 1201fa0f6e62SHans Petter Selasky case CUSE_IOCTL_WRITE_DATA: 1202fa0f6e62SHans Petter Selasky case CUSE_IOCTL_READ_DATA: 1203fa0f6e62SHans Petter Selasky 1204fa0f6e62SHans Petter Selasky cuse_lock(); 1205fa0f6e62SHans Petter Selasky pchk = (struct cuse_data_chunk *)data; 1206fa0f6e62SHans Petter Selasky 1207fa0f6e62SHans Petter Selasky pccmd = cuse_server_find_command(pcs, curthread); 1208fa0f6e62SHans Petter Selasky 1209fa0f6e62SHans Petter Selasky if (pccmd == NULL) { 1210fa0f6e62SHans Petter Selasky error = ENXIO; /* invalid request */ 1211fa0f6e62SHans Petter Selasky } else if (pchk->peer_ptr < CUSE_BUF_MIN_PTR) { 1212fa0f6e62SHans Petter Selasky error = EFAULT; /* NULL pointer */ 1213fa0f6e62SHans Petter Selasky } else if (pchk->peer_ptr < CUSE_BUF_MAX_PTR) { 1214fa0f6e62SHans Petter Selasky error = cuse_server_ioctl_copy_locked(pccmd, 1215fa0f6e62SHans Petter Selasky pchk, cmd == CUSE_IOCTL_READ_DATA); 1216fa0f6e62SHans Petter Selasky } else { 1217fa0f6e62SHans Petter Selasky error = cuse_server_data_copy_locked(pccmd, 1218fa0f6e62SHans Petter Selasky pchk, cmd == CUSE_IOCTL_READ_DATA); 1219fa0f6e62SHans Petter Selasky } 1220fa0f6e62SHans Petter Selasky cuse_unlock(); 1221fa0f6e62SHans Petter Selasky break; 1222fa0f6e62SHans Petter Selasky 1223fa0f6e62SHans Petter Selasky case CUSE_IOCTL_SELWAKEUP: 1224fa0f6e62SHans Petter Selasky cuse_lock(); 1225fa0f6e62SHans Petter Selasky /* 1226fa0f6e62SHans Petter Selasky * We don't know which direction caused the event. 1227fa0f6e62SHans Petter Selasky * Wakeup both! 1228fa0f6e62SHans Petter Selasky */ 1229fa0f6e62SHans Petter Selasky TAILQ_FOREACH(pcc, &pcs->hcli, entry) { 1230fa0f6e62SHans Petter Selasky pcc->cflags |= (CUSE_CLI_KNOTE_NEED_READ | 1231fa0f6e62SHans Petter Selasky CUSE_CLI_KNOTE_NEED_WRITE); 1232fa0f6e62SHans Petter Selasky } 1233fa0f6e62SHans Petter Selasky cuse_server_wakeup_locked(pcs); 1234fa0f6e62SHans Petter Selasky cuse_unlock(); 1235fa0f6e62SHans Petter Selasky break; 1236fa0f6e62SHans Petter Selasky 1237fa0f6e62SHans Petter Selasky default: 1238fa0f6e62SHans Petter Selasky error = ENXIO; 1239fa0f6e62SHans Petter Selasky break; 1240fa0f6e62SHans Petter Selasky } 1241fa0f6e62SHans Petter Selasky return (error); 1242fa0f6e62SHans Petter Selasky } 1243fa0f6e62SHans Petter Selasky 1244fa0f6e62SHans Petter Selasky static int 1245fa0f6e62SHans Petter Selasky cuse_server_poll(struct cdev *dev, int events, struct thread *td) 1246fa0f6e62SHans Petter Selasky { 1247fa0f6e62SHans Petter Selasky return (events & (POLLHUP | POLLPRI | POLLIN | 1248fa0f6e62SHans Petter Selasky POLLRDNORM | POLLOUT | POLLWRNORM)); 1249fa0f6e62SHans Petter Selasky } 1250fa0f6e62SHans Petter Selasky 1251fa0f6e62SHans Petter Selasky static int 1252fa0f6e62SHans Petter Selasky cuse_server_mmap(struct cdev *dev, vm_ooffset_t offset, vm_paddr_t *paddr, int nprot, vm_memattr_t *memattr) 1253fa0f6e62SHans Petter Selasky { 1254fa0f6e62SHans Petter Selasky uint32_t page_nr = offset / PAGE_SIZE; 1255fa0f6e62SHans Petter Selasky uint32_t alloc_nr = page_nr / CUSE_ALLOC_PAGES_MAX; 1256fa0f6e62SHans Petter Selasky struct cuse_memory *mem; 1257fa0f6e62SHans Petter Selasky struct cuse_server *pcs; 1258fa0f6e62SHans Petter Selasky uint8_t *ptr; 1259fa0f6e62SHans Petter Selasky int error; 1260fa0f6e62SHans Petter Selasky 1261fa0f6e62SHans Petter Selasky if (alloc_nr >= CUSE_ALLOC_UNIT_MAX) 1262fa0f6e62SHans Petter Selasky return (ENOMEM); 1263fa0f6e62SHans Petter Selasky 1264fa0f6e62SHans Petter Selasky error = cuse_server_get(&pcs); 1265fa0f6e62SHans Petter Selasky if (error != 0) 1266fa0f6e62SHans Petter Selasky pcs = NULL; 1267fa0f6e62SHans Petter Selasky 1268fa0f6e62SHans Petter Selasky cuse_lock(); 1269fa0f6e62SHans Petter Selasky mem = &cuse_mem[alloc_nr]; 1270fa0f6e62SHans Petter Selasky 1271fa0f6e62SHans Petter Selasky /* try to enforce slight ownership */ 1272fa0f6e62SHans Petter Selasky if ((pcs != NULL) && (mem->owner != pcs)) { 1273fa0f6e62SHans Petter Selasky cuse_unlock(); 1274fa0f6e62SHans Petter Selasky return (EINVAL); 1275fa0f6e62SHans Petter Selasky } 1276fa0f6e62SHans Petter Selasky if (mem->virtaddr == NULL) { 1277fa0f6e62SHans Petter Selasky cuse_unlock(); 1278fa0f6e62SHans Petter Selasky return (ENOMEM); 1279fa0f6e62SHans Petter Selasky } 1280fa0f6e62SHans Petter Selasky if (mem->virtaddr == NBUSY) { 1281fa0f6e62SHans Petter Selasky cuse_unlock(); 1282fa0f6e62SHans Petter Selasky return (ENOMEM); 1283fa0f6e62SHans Petter Selasky } 1284fa0f6e62SHans Petter Selasky page_nr %= CUSE_ALLOC_PAGES_MAX; 1285fa0f6e62SHans Petter Selasky 1286fa0f6e62SHans Petter Selasky if (page_nr >= mem->page_count) { 1287fa0f6e62SHans Petter Selasky cuse_unlock(); 1288fa0f6e62SHans Petter Selasky return (ENXIO); 1289fa0f6e62SHans Petter Selasky } 1290fa0f6e62SHans Petter Selasky ptr = mem->virtaddr + (page_nr * PAGE_SIZE); 1291fa0f6e62SHans Petter Selasky cuse_unlock(); 1292fa0f6e62SHans Petter Selasky 1293fa0f6e62SHans Petter Selasky *paddr = vtophys(ptr); 1294fa0f6e62SHans Petter Selasky 1295fa0f6e62SHans Petter Selasky return (0); 1296fa0f6e62SHans Petter Selasky } 1297fa0f6e62SHans Petter Selasky 1298fa0f6e62SHans Petter Selasky /*------------------------------------------------------------------------* 1299fa0f6e62SHans Petter Selasky * CUSE CLIENT PART 1300fa0f6e62SHans Petter Selasky *------------------------------------------------------------------------*/ 1301fa0f6e62SHans Petter Selasky static void 1302fa0f6e62SHans Petter Selasky cuse_client_free(void *arg) 1303fa0f6e62SHans Petter Selasky { 1304fa0f6e62SHans Petter Selasky struct cuse_client *pcc = arg; 1305fa0f6e62SHans Petter Selasky struct cuse_client_command *pccmd; 1306fa0f6e62SHans Petter Selasky struct cuse_server *pcs; 1307fa0f6e62SHans Petter Selasky int n; 1308fa0f6e62SHans Petter Selasky 1309fa0f6e62SHans Petter Selasky cuse_lock(); 1310fa0f6e62SHans Petter Selasky cuse_client_is_closing(pcc); 1311fa0f6e62SHans Petter Selasky TAILQ_REMOVE(&pcc->server->hcli, pcc, entry); 1312fa0f6e62SHans Petter Selasky cuse_unlock(); 1313fa0f6e62SHans Petter Selasky 1314fa0f6e62SHans Petter Selasky for (n = 0; n != CUSE_CMD_MAX; n++) { 1315fa0f6e62SHans Petter Selasky 1316fa0f6e62SHans Petter Selasky pccmd = &pcc->cmds[n]; 1317fa0f6e62SHans Petter Selasky 1318fa0f6e62SHans Petter Selasky sx_destroy(&pccmd->sx); 1319fa0f6e62SHans Petter Selasky cv_destroy(&pccmd->cv); 1320fa0f6e62SHans Petter Selasky } 1321fa0f6e62SHans Petter Selasky 1322fa0f6e62SHans Petter Selasky pcs = pcc->server; 1323fa0f6e62SHans Petter Selasky 1324fa0f6e62SHans Petter Selasky free(pcc, M_CUSE); 1325fa0f6e62SHans Petter Selasky 1326fa0f6e62SHans Petter Selasky /* drop reference on server */ 1327fa0f6e62SHans Petter Selasky cuse_server_free(pcs); 1328fa0f6e62SHans Petter Selasky } 1329fa0f6e62SHans Petter Selasky 1330fa0f6e62SHans Petter Selasky static int 1331fa0f6e62SHans Petter Selasky cuse_client_open(struct cdev *dev, int fflags, int devtype, struct thread *td) 1332fa0f6e62SHans Petter Selasky { 1333fa0f6e62SHans Petter Selasky struct cuse_client_command *pccmd; 1334fa0f6e62SHans Petter Selasky struct cuse_server_dev *pcsd; 1335fa0f6e62SHans Petter Selasky struct cuse_client *pcc; 1336fa0f6e62SHans Petter Selasky struct cuse_server *pcs; 1337fa0f6e62SHans Petter Selasky struct cuse_dev *pcd; 1338fa0f6e62SHans Petter Selasky int error; 1339fa0f6e62SHans Petter Selasky int n; 1340fa0f6e62SHans Petter Selasky 1341fa0f6e62SHans Petter Selasky cuse_lock(); 1342fa0f6e62SHans Petter Selasky pcsd = dev->si_drv1; 1343fa0f6e62SHans Petter Selasky if (pcsd != NULL) { 1344fa0f6e62SHans Petter Selasky pcs = pcsd->server; 1345fa0f6e62SHans Petter Selasky pcd = pcsd->user_dev; 1346fa0f6e62SHans Petter Selasky pcs->refs++; 1347fa0f6e62SHans Petter Selasky if (pcs->refs < 0) { 1348fa0f6e62SHans Petter Selasky /* overflow */ 1349fa0f6e62SHans Petter Selasky pcs->refs--; 1350fa0f6e62SHans Petter Selasky pcsd = NULL; 1351fa0f6e62SHans Petter Selasky } 1352fa0f6e62SHans Petter Selasky } else { 1353fa0f6e62SHans Petter Selasky pcs = NULL; 1354fa0f6e62SHans Petter Selasky pcd = NULL; 1355fa0f6e62SHans Petter Selasky } 1356fa0f6e62SHans Petter Selasky cuse_unlock(); 1357fa0f6e62SHans Petter Selasky 1358fa0f6e62SHans Petter Selasky if (pcsd == NULL) 1359fa0f6e62SHans Petter Selasky return (EINVAL); 1360fa0f6e62SHans Petter Selasky 1361fa0f6e62SHans Petter Selasky pcc = malloc(sizeof(*pcc), M_CUSE, M_WAITOK | M_ZERO); 1362fa0f6e62SHans Petter Selasky if (pcc == NULL) { 1363fa0f6e62SHans Petter Selasky /* drop reference on server */ 1364fa0f6e62SHans Petter Selasky cuse_server_free(pcs); 1365fa0f6e62SHans Petter Selasky return (ENOMEM); 1366fa0f6e62SHans Petter Selasky } 1367fa0f6e62SHans Petter Selasky if (devfs_set_cdevpriv(pcc, &cuse_client_free)) { 1368fa0f6e62SHans Petter Selasky printf("Cuse: Cannot set cdevpriv.\n"); 1369fa0f6e62SHans Petter Selasky /* drop reference on server */ 1370fa0f6e62SHans Petter Selasky cuse_server_free(pcs); 1371fa0f6e62SHans Petter Selasky free(pcc, M_CUSE); 1372fa0f6e62SHans Petter Selasky return (ENOMEM); 1373fa0f6e62SHans Petter Selasky } 1374fa0f6e62SHans Petter Selasky pcc->fflags = fflags; 1375fa0f6e62SHans Petter Selasky pcc->server_dev = pcsd; 1376fa0f6e62SHans Petter Selasky pcc->server = pcs; 1377fa0f6e62SHans Petter Selasky 1378fa0f6e62SHans Petter Selasky for (n = 0; n != CUSE_CMD_MAX; n++) { 1379fa0f6e62SHans Petter Selasky 1380fa0f6e62SHans Petter Selasky pccmd = &pcc->cmds[n]; 1381fa0f6e62SHans Petter Selasky 1382fa0f6e62SHans Petter Selasky pccmd->sub.dev = pcd; 1383fa0f6e62SHans Petter Selasky pccmd->sub.command = n; 1384fa0f6e62SHans Petter Selasky pccmd->client = pcc; 1385fa0f6e62SHans Petter Selasky 1386fa0f6e62SHans Petter Selasky sx_init(&pccmd->sx, "cuse-client-sx"); 1387fa0f6e62SHans Petter Selasky cv_init(&pccmd->cv, "cuse-client-cv"); 1388fa0f6e62SHans Petter Selasky } 1389fa0f6e62SHans Petter Selasky 1390fa0f6e62SHans Petter Selasky cuse_lock(); 1391fa0f6e62SHans Petter Selasky 1392fa0f6e62SHans Petter Selasky /* cuse_client_free() assumes that the client is listed somewhere! */ 1393fa0f6e62SHans Petter Selasky /* always enqueue */ 1394fa0f6e62SHans Petter Selasky 1395fa0f6e62SHans Petter Selasky TAILQ_INSERT_TAIL(&pcs->hcli, pcc, entry); 1396fa0f6e62SHans Petter Selasky 1397fa0f6e62SHans Petter Selasky /* check if server is closing */ 1398fa0f6e62SHans Petter Selasky if ((pcs->is_closing != 0) || (dev->si_drv1 == NULL)) { 1399fa0f6e62SHans Petter Selasky error = EINVAL; 1400fa0f6e62SHans Petter Selasky } else { 1401fa0f6e62SHans Petter Selasky error = 0; 1402fa0f6e62SHans Petter Selasky } 1403fa0f6e62SHans Petter Selasky cuse_unlock(); 1404fa0f6e62SHans Petter Selasky 1405fa0f6e62SHans Petter Selasky if (error) { 1406fa0f6e62SHans Petter Selasky devfs_clear_cdevpriv(); /* XXX bugfix */ 1407fa0f6e62SHans Petter Selasky return (error); 1408fa0f6e62SHans Petter Selasky } 1409fa0f6e62SHans Petter Selasky pccmd = &pcc->cmds[CUSE_CMD_OPEN]; 1410fa0f6e62SHans Petter Selasky 1411fa0f6e62SHans Petter Selasky cuse_cmd_lock(pccmd); 1412fa0f6e62SHans Petter Selasky 1413fa0f6e62SHans Petter Selasky cuse_lock(); 1414fa0f6e62SHans Petter Selasky cuse_client_send_command_locked(pccmd, 0, 0, pcc->fflags, 0); 1415fa0f6e62SHans Petter Selasky 1416fa0f6e62SHans Petter Selasky error = cuse_client_receive_command_locked(pccmd, 0, 0); 1417fa0f6e62SHans Petter Selasky cuse_unlock(); 1418fa0f6e62SHans Petter Selasky 1419fa0f6e62SHans Petter Selasky if (error < 0) { 1420fa0f6e62SHans Petter Selasky error = cuse_convert_error(error); 1421fa0f6e62SHans Petter Selasky } else { 1422fa0f6e62SHans Petter Selasky error = 0; 1423fa0f6e62SHans Petter Selasky } 1424fa0f6e62SHans Petter Selasky 1425fa0f6e62SHans Petter Selasky cuse_cmd_unlock(pccmd); 1426fa0f6e62SHans Petter Selasky 1427fa0f6e62SHans Petter Selasky if (error) 1428fa0f6e62SHans Petter Selasky devfs_clear_cdevpriv(); /* XXX bugfix */ 1429fa0f6e62SHans Petter Selasky 1430fa0f6e62SHans Petter Selasky return (error); 1431fa0f6e62SHans Petter Selasky } 1432fa0f6e62SHans Petter Selasky 1433fa0f6e62SHans Petter Selasky static int 1434fa0f6e62SHans Petter Selasky cuse_client_close(struct cdev *dev, int fflag, int devtype, struct thread *td) 1435fa0f6e62SHans Petter Selasky { 1436fa0f6e62SHans Petter Selasky struct cuse_client_command *pccmd; 1437fa0f6e62SHans Petter Selasky struct cuse_client *pcc; 1438fa0f6e62SHans Petter Selasky int error; 1439fa0f6e62SHans Petter Selasky 1440fa0f6e62SHans Petter Selasky error = cuse_client_get(&pcc); 1441fa0f6e62SHans Petter Selasky if (error != 0) 1442fa0f6e62SHans Petter Selasky return (0); 1443fa0f6e62SHans Petter Selasky 1444fa0f6e62SHans Petter Selasky pccmd = &pcc->cmds[CUSE_CMD_CLOSE]; 1445fa0f6e62SHans Petter Selasky 1446fa0f6e62SHans Petter Selasky cuse_cmd_lock(pccmd); 1447fa0f6e62SHans Petter Selasky 1448fa0f6e62SHans Petter Selasky cuse_lock(); 1449fa0f6e62SHans Petter Selasky cuse_client_send_command_locked(pccmd, 0, 0, pcc->fflags, 0); 1450fa0f6e62SHans Petter Selasky 1451fa0f6e62SHans Petter Selasky error = cuse_client_receive_command_locked(pccmd, 0, 0); 1452fa0f6e62SHans Petter Selasky cuse_unlock(); 1453fa0f6e62SHans Petter Selasky 1454fa0f6e62SHans Petter Selasky cuse_cmd_unlock(pccmd); 1455fa0f6e62SHans Petter Selasky 1456fa0f6e62SHans Petter Selasky cuse_lock(); 1457fa0f6e62SHans Petter Selasky cuse_client_is_closing(pcc); 1458fa0f6e62SHans Petter Selasky cuse_unlock(); 1459fa0f6e62SHans Petter Selasky 1460fa0f6e62SHans Petter Selasky return (0); 1461fa0f6e62SHans Petter Selasky } 1462fa0f6e62SHans Petter Selasky 1463fa0f6e62SHans Petter Selasky static void 1464fa0f6e62SHans Petter Selasky cuse_client_kqfilter_poll(struct cdev *dev, struct cuse_client *pcc) 1465fa0f6e62SHans Petter Selasky { 1466fa0f6e62SHans Petter Selasky int temp; 1467fa0f6e62SHans Petter Selasky 1468fa0f6e62SHans Petter Selasky cuse_lock(); 1469fa0f6e62SHans Petter Selasky temp = (pcc->cflags & (CUSE_CLI_KNOTE_HAS_READ | 1470fa0f6e62SHans Petter Selasky CUSE_CLI_KNOTE_HAS_WRITE)); 1471fa0f6e62SHans Petter Selasky pcc->cflags &= ~(CUSE_CLI_KNOTE_NEED_READ | 1472fa0f6e62SHans Petter Selasky CUSE_CLI_KNOTE_NEED_WRITE); 1473fa0f6e62SHans Petter Selasky cuse_unlock(); 1474fa0f6e62SHans Petter Selasky 1475fa0f6e62SHans Petter Selasky if (temp != 0) { 1476fa0f6e62SHans Petter Selasky /* get the latest polling state from the server */ 1477fa0f6e62SHans Petter Selasky temp = cuse_client_poll(dev, POLLIN | POLLOUT, NULL); 1478fa0f6e62SHans Petter Selasky 1479fa0f6e62SHans Petter Selasky cuse_lock(); 1480fa0f6e62SHans Petter Selasky if (temp & (POLLIN | POLLOUT)) { 1481fa0f6e62SHans Petter Selasky if (temp & POLLIN) 1482fa0f6e62SHans Petter Selasky pcc->cflags |= CUSE_CLI_KNOTE_NEED_READ; 1483fa0f6e62SHans Petter Selasky if (temp & POLLOUT) 1484fa0f6e62SHans Petter Selasky pcc->cflags |= CUSE_CLI_KNOTE_NEED_WRITE; 1485fa0f6e62SHans Petter Selasky 1486fa0f6e62SHans Petter Selasky /* make sure the "knote" gets woken up */ 1487fa0f6e62SHans Petter Selasky cuse_server_wakeup_locked(pcc->server); 1488fa0f6e62SHans Petter Selasky } 1489fa0f6e62SHans Petter Selasky cuse_unlock(); 1490fa0f6e62SHans Petter Selasky } 1491fa0f6e62SHans Petter Selasky } 1492fa0f6e62SHans Petter Selasky 1493fa0f6e62SHans Petter Selasky static int 1494fa0f6e62SHans Petter Selasky cuse_client_read(struct cdev *dev, struct uio *uio, int ioflag) 1495fa0f6e62SHans Petter Selasky { 1496fa0f6e62SHans Petter Selasky struct cuse_client_command *pccmd; 1497fa0f6e62SHans Petter Selasky struct cuse_client *pcc; 1498fa0f6e62SHans Petter Selasky int error; 1499fa0f6e62SHans Petter Selasky int len; 1500fa0f6e62SHans Petter Selasky 1501fa0f6e62SHans Petter Selasky error = cuse_client_get(&pcc); 1502fa0f6e62SHans Petter Selasky if (error != 0) 1503fa0f6e62SHans Petter Selasky return (error); 1504fa0f6e62SHans Petter Selasky 1505fa0f6e62SHans Petter Selasky pccmd = &pcc->cmds[CUSE_CMD_READ]; 1506fa0f6e62SHans Petter Selasky 1507fa0f6e62SHans Petter Selasky if (uio->uio_segflg != UIO_USERSPACE) { 1508fa0f6e62SHans Petter Selasky return (EINVAL); 1509fa0f6e62SHans Petter Selasky } 1510fa0f6e62SHans Petter Selasky uio->uio_segflg = UIO_NOCOPY; 1511fa0f6e62SHans Petter Selasky 1512fa0f6e62SHans Petter Selasky cuse_cmd_lock(pccmd); 1513fa0f6e62SHans Petter Selasky 1514fa0f6e62SHans Petter Selasky while (uio->uio_resid != 0) { 1515fa0f6e62SHans Petter Selasky 1516fa0f6e62SHans Petter Selasky if (uio->uio_iov->iov_len > CUSE_LENGTH_MAX) { 1517fa0f6e62SHans Petter Selasky error = ENOMEM; 1518fa0f6e62SHans Petter Selasky break; 1519fa0f6e62SHans Petter Selasky } 1520fa0f6e62SHans Petter Selasky 1521fa0f6e62SHans Petter Selasky len = uio->uio_iov->iov_len; 1522fa0f6e62SHans Petter Selasky 1523fa0f6e62SHans Petter Selasky cuse_lock(); 1524fa0f6e62SHans Petter Selasky cuse_client_send_command_locked(pccmd, 1525fa0f6e62SHans Petter Selasky (unsigned long)uio->uio_iov->iov_base, 1526fa0f6e62SHans Petter Selasky (unsigned long)(unsigned int)len, pcc->fflags, ioflag); 1527fa0f6e62SHans Petter Selasky 1528fa0f6e62SHans Petter Selasky error = cuse_client_receive_command_locked(pccmd, 0, 0); 1529fa0f6e62SHans Petter Selasky cuse_unlock(); 1530fa0f6e62SHans Petter Selasky 1531fa0f6e62SHans Petter Selasky if (error < 0) { 1532fa0f6e62SHans Petter Selasky error = cuse_convert_error(error); 1533fa0f6e62SHans Petter Selasky break; 1534fa0f6e62SHans Petter Selasky } else if (error == len) { 1535fa0f6e62SHans Petter Selasky error = uiomove(NULL, error, uio); 1536fa0f6e62SHans Petter Selasky if (error) 1537fa0f6e62SHans Petter Selasky break; 1538fa0f6e62SHans Petter Selasky } else { 1539fa0f6e62SHans Petter Selasky error = uiomove(NULL, error, uio); 1540fa0f6e62SHans Petter Selasky break; 1541fa0f6e62SHans Petter Selasky } 1542fa0f6e62SHans Petter Selasky } 1543fa0f6e62SHans Petter Selasky cuse_cmd_unlock(pccmd); 1544fa0f6e62SHans Petter Selasky 1545fa0f6e62SHans Petter Selasky uio->uio_segflg = UIO_USERSPACE;/* restore segment flag */ 1546fa0f6e62SHans Petter Selasky 1547fa0f6e62SHans Petter Selasky if (error == EWOULDBLOCK) 1548fa0f6e62SHans Petter Selasky cuse_client_kqfilter_poll(dev, pcc); 1549fa0f6e62SHans Petter Selasky 1550fa0f6e62SHans Petter Selasky return (error); 1551fa0f6e62SHans Petter Selasky } 1552fa0f6e62SHans Petter Selasky 1553fa0f6e62SHans Petter Selasky static int 1554fa0f6e62SHans Petter Selasky cuse_client_write(struct cdev *dev, struct uio *uio, int ioflag) 1555fa0f6e62SHans Petter Selasky { 1556fa0f6e62SHans Petter Selasky struct cuse_client_command *pccmd; 1557fa0f6e62SHans Petter Selasky struct cuse_client *pcc; 1558fa0f6e62SHans Petter Selasky int error; 1559fa0f6e62SHans Petter Selasky int len; 1560fa0f6e62SHans Petter Selasky 1561fa0f6e62SHans Petter Selasky error = cuse_client_get(&pcc); 1562fa0f6e62SHans Petter Selasky if (error != 0) 1563fa0f6e62SHans Petter Selasky return (error); 1564fa0f6e62SHans Petter Selasky 1565fa0f6e62SHans Petter Selasky pccmd = &pcc->cmds[CUSE_CMD_WRITE]; 1566fa0f6e62SHans Petter Selasky 1567fa0f6e62SHans Petter Selasky if (uio->uio_segflg != UIO_USERSPACE) { 1568fa0f6e62SHans Petter Selasky return (EINVAL); 1569fa0f6e62SHans Petter Selasky } 1570fa0f6e62SHans Petter Selasky uio->uio_segflg = UIO_NOCOPY; 1571fa0f6e62SHans Petter Selasky 1572fa0f6e62SHans Petter Selasky cuse_cmd_lock(pccmd); 1573fa0f6e62SHans Petter Selasky 1574fa0f6e62SHans Petter Selasky while (uio->uio_resid != 0) { 1575fa0f6e62SHans Petter Selasky 1576fa0f6e62SHans Petter Selasky if (uio->uio_iov->iov_len > CUSE_LENGTH_MAX) { 1577fa0f6e62SHans Petter Selasky error = ENOMEM; 1578fa0f6e62SHans Petter Selasky break; 1579fa0f6e62SHans Petter Selasky } 1580fa0f6e62SHans Petter Selasky 1581fa0f6e62SHans Petter Selasky len = uio->uio_iov->iov_len; 1582fa0f6e62SHans Petter Selasky 1583fa0f6e62SHans Petter Selasky cuse_lock(); 1584fa0f6e62SHans Petter Selasky cuse_client_send_command_locked(pccmd, 1585fa0f6e62SHans Petter Selasky (unsigned long)uio->uio_iov->iov_base, 1586fa0f6e62SHans Petter Selasky (unsigned long)(unsigned int)len, pcc->fflags, ioflag); 1587fa0f6e62SHans Petter Selasky 1588fa0f6e62SHans Petter Selasky error = cuse_client_receive_command_locked(pccmd, 0, 0); 1589fa0f6e62SHans Petter Selasky cuse_unlock(); 1590fa0f6e62SHans Petter Selasky 1591fa0f6e62SHans Petter Selasky if (error < 0) { 1592fa0f6e62SHans Petter Selasky error = cuse_convert_error(error); 1593fa0f6e62SHans Petter Selasky break; 1594fa0f6e62SHans Petter Selasky } else if (error == len) { 1595fa0f6e62SHans Petter Selasky error = uiomove(NULL, error, uio); 1596fa0f6e62SHans Petter Selasky if (error) 1597fa0f6e62SHans Petter Selasky break; 1598fa0f6e62SHans Petter Selasky } else { 1599fa0f6e62SHans Petter Selasky error = uiomove(NULL, error, uio); 1600fa0f6e62SHans Petter Selasky break; 1601fa0f6e62SHans Petter Selasky } 1602fa0f6e62SHans Petter Selasky } 1603fa0f6e62SHans Petter Selasky cuse_cmd_unlock(pccmd); 1604fa0f6e62SHans Petter Selasky 1605fa0f6e62SHans Petter Selasky uio->uio_segflg = UIO_USERSPACE;/* restore segment flag */ 1606fa0f6e62SHans Petter Selasky 1607fa0f6e62SHans Petter Selasky if (error == EWOULDBLOCK) 1608fa0f6e62SHans Petter Selasky cuse_client_kqfilter_poll(dev, pcc); 1609fa0f6e62SHans Petter Selasky 1610fa0f6e62SHans Petter Selasky return (error); 1611fa0f6e62SHans Petter Selasky } 1612fa0f6e62SHans Petter Selasky 1613fa0f6e62SHans Petter Selasky int 1614fa0f6e62SHans Petter Selasky cuse_client_ioctl(struct cdev *dev, unsigned long cmd, 1615fa0f6e62SHans Petter Selasky caddr_t data, int fflag, struct thread *td) 1616fa0f6e62SHans Petter Selasky { 1617fa0f6e62SHans Petter Selasky struct cuse_client_command *pccmd; 1618fa0f6e62SHans Petter Selasky struct cuse_client *pcc; 1619fa0f6e62SHans Petter Selasky int error; 1620fa0f6e62SHans Petter Selasky int len; 1621fa0f6e62SHans Petter Selasky 1622fa0f6e62SHans Petter Selasky error = cuse_client_get(&pcc); 1623fa0f6e62SHans Petter Selasky if (error != 0) 1624fa0f6e62SHans Petter Selasky return (error); 1625fa0f6e62SHans Petter Selasky 1626fa0f6e62SHans Petter Selasky len = IOCPARM_LEN(cmd); 1627fa0f6e62SHans Petter Selasky if (len > CUSE_BUFFER_MAX) 1628fa0f6e62SHans Petter Selasky return (ENOMEM); 1629fa0f6e62SHans Petter Selasky 1630fa0f6e62SHans Petter Selasky pccmd = &pcc->cmds[CUSE_CMD_IOCTL]; 1631fa0f6e62SHans Petter Selasky 1632fa0f6e62SHans Petter Selasky cuse_cmd_lock(pccmd); 1633fa0f6e62SHans Petter Selasky 1634fa0f6e62SHans Petter Selasky if (cmd & IOC_IN) 1635fa0f6e62SHans Petter Selasky memcpy(pcc->ioctl_buffer, data, len); 1636fa0f6e62SHans Petter Selasky 1637fa0f6e62SHans Petter Selasky /* 1638fa0f6e62SHans Petter Selasky * When the ioctl-length is zero drivers can pass information 1639fa0f6e62SHans Petter Selasky * through the data pointer of the ioctl. Make sure this information 1640fa0f6e62SHans Petter Selasky * is forwarded to the driver. 1641fa0f6e62SHans Petter Selasky */ 1642fa0f6e62SHans Petter Selasky 1643fa0f6e62SHans Petter Selasky cuse_lock(); 1644fa0f6e62SHans Petter Selasky cuse_client_send_command_locked(pccmd, 1645fa0f6e62SHans Petter Selasky (len == 0) ? *(long *)data : CUSE_BUF_MIN_PTR, 1646fa0f6e62SHans Petter Selasky (unsigned long)cmd, pcc->fflags, 1647fa0f6e62SHans Petter Selasky (fflag & O_NONBLOCK) ? IO_NDELAY : 0); 1648fa0f6e62SHans Petter Selasky 1649fa0f6e62SHans Petter Selasky error = cuse_client_receive_command_locked(pccmd, data, len); 1650fa0f6e62SHans Petter Selasky cuse_unlock(); 1651fa0f6e62SHans Petter Selasky 1652fa0f6e62SHans Petter Selasky if (error < 0) { 1653fa0f6e62SHans Petter Selasky error = cuse_convert_error(error); 1654fa0f6e62SHans Petter Selasky } else { 1655fa0f6e62SHans Petter Selasky error = 0; 1656fa0f6e62SHans Petter Selasky } 1657fa0f6e62SHans Petter Selasky 1658fa0f6e62SHans Petter Selasky if (cmd & IOC_OUT) 1659fa0f6e62SHans Petter Selasky memcpy(data, pcc->ioctl_buffer, len); 1660fa0f6e62SHans Petter Selasky 1661fa0f6e62SHans Petter Selasky cuse_cmd_unlock(pccmd); 1662fa0f6e62SHans Petter Selasky 1663fa0f6e62SHans Petter Selasky if (error == EWOULDBLOCK) 1664fa0f6e62SHans Petter Selasky cuse_client_kqfilter_poll(dev, pcc); 1665fa0f6e62SHans Petter Selasky 1666fa0f6e62SHans Petter Selasky return (error); 1667fa0f6e62SHans Petter Selasky } 1668fa0f6e62SHans Petter Selasky 1669fa0f6e62SHans Petter Selasky static int 1670fa0f6e62SHans Petter Selasky cuse_client_poll(struct cdev *dev, int events, struct thread *td) 1671fa0f6e62SHans Petter Selasky { 1672fa0f6e62SHans Petter Selasky struct cuse_client_command *pccmd; 1673fa0f6e62SHans Petter Selasky struct cuse_client *pcc; 1674fa0f6e62SHans Petter Selasky unsigned long temp; 1675fa0f6e62SHans Petter Selasky int error; 1676fa0f6e62SHans Petter Selasky int revents; 1677fa0f6e62SHans Petter Selasky 1678fa0f6e62SHans Petter Selasky error = cuse_client_get(&pcc); 1679fa0f6e62SHans Petter Selasky if (error != 0) 1680fa0f6e62SHans Petter Selasky return (POLLNVAL); 1681fa0f6e62SHans Petter Selasky 1682fa0f6e62SHans Petter Selasky temp = 0; 1683fa0f6e62SHans Petter Selasky 1684fa0f6e62SHans Petter Selasky if (events & (POLLPRI | POLLIN | POLLRDNORM)) 1685fa0f6e62SHans Petter Selasky temp |= CUSE_POLL_READ; 1686fa0f6e62SHans Petter Selasky 1687fa0f6e62SHans Petter Selasky if (events & (POLLOUT | POLLWRNORM)) 1688fa0f6e62SHans Petter Selasky temp |= CUSE_POLL_WRITE; 1689fa0f6e62SHans Petter Selasky 1690fa0f6e62SHans Petter Selasky if (events & POLLHUP) 1691fa0f6e62SHans Petter Selasky temp |= CUSE_POLL_ERROR; 1692fa0f6e62SHans Petter Selasky 1693fa0f6e62SHans Petter Selasky pccmd = &pcc->cmds[CUSE_CMD_POLL]; 1694fa0f6e62SHans Petter Selasky 1695fa0f6e62SHans Petter Selasky cuse_cmd_lock(pccmd); 1696fa0f6e62SHans Petter Selasky 1697fa0f6e62SHans Petter Selasky /* Need to selrecord() first to not loose any events. */ 1698fa0f6e62SHans Petter Selasky if (temp != 0 && td != NULL) 1699fa0f6e62SHans Petter Selasky selrecord(td, &pcc->server->selinfo); 1700fa0f6e62SHans Petter Selasky 1701fa0f6e62SHans Petter Selasky cuse_lock(); 1702fa0f6e62SHans Petter Selasky cuse_client_send_command_locked(pccmd, 1703fa0f6e62SHans Petter Selasky 0, temp, pcc->fflags, IO_NDELAY); 1704fa0f6e62SHans Petter Selasky 1705fa0f6e62SHans Petter Selasky error = cuse_client_receive_command_locked(pccmd, 0, 0); 1706fa0f6e62SHans Petter Selasky cuse_unlock(); 1707fa0f6e62SHans Petter Selasky 1708fa0f6e62SHans Petter Selasky if (error < 0) { 1709fa0f6e62SHans Petter Selasky revents = POLLNVAL; 1710fa0f6e62SHans Petter Selasky } else { 1711fa0f6e62SHans Petter Selasky revents = 0; 1712fa0f6e62SHans Petter Selasky if (error & CUSE_POLL_READ) 1713fa0f6e62SHans Petter Selasky revents |= (events & (POLLPRI | POLLIN | POLLRDNORM)); 1714fa0f6e62SHans Petter Selasky if (error & CUSE_POLL_WRITE) 1715fa0f6e62SHans Petter Selasky revents |= (events & (POLLOUT | POLLWRNORM)); 1716fa0f6e62SHans Petter Selasky if (error & CUSE_POLL_ERROR) 1717fa0f6e62SHans Petter Selasky revents |= (events & POLLHUP); 1718fa0f6e62SHans Petter Selasky } 1719fa0f6e62SHans Petter Selasky 1720fa0f6e62SHans Petter Selasky cuse_cmd_unlock(pccmd); 1721fa0f6e62SHans Petter Selasky 1722fa0f6e62SHans Petter Selasky return (revents); 1723fa0f6e62SHans Petter Selasky } 1724fa0f6e62SHans Petter Selasky 1725fa0f6e62SHans Petter Selasky static int 1726fa0f6e62SHans Petter Selasky cuse_client_mmap(struct cdev *dev, vm_ooffset_t offset, vm_paddr_t *paddr, int nprot, vm_memattr_t *memattr) 1727fa0f6e62SHans Petter Selasky { 1728fa0f6e62SHans Petter Selasky uint32_t page_nr = offset / PAGE_SIZE; 1729fa0f6e62SHans Petter Selasky uint32_t alloc_nr = page_nr / CUSE_ALLOC_PAGES_MAX; 1730fa0f6e62SHans Petter Selasky struct cuse_memory *mem; 1731fa0f6e62SHans Petter Selasky struct cuse_server *pcs; 1732fa0f6e62SHans Petter Selasky struct cuse_client *pcc; 1733fa0f6e62SHans Petter Selasky uint8_t *ptr; 1734fa0f6e62SHans Petter Selasky int error; 1735fa0f6e62SHans Petter Selasky 1736fa0f6e62SHans Petter Selasky if (alloc_nr >= CUSE_ALLOC_UNIT_MAX) 1737fa0f6e62SHans Petter Selasky return (ENOMEM); 1738fa0f6e62SHans Petter Selasky 1739fa0f6e62SHans Petter Selasky error = cuse_client_get(&pcc); 1740fa0f6e62SHans Petter Selasky if (error != 0) 1741fa0f6e62SHans Petter Selasky pcs = NULL; 1742fa0f6e62SHans Petter Selasky else 1743fa0f6e62SHans Petter Selasky pcs = pcc->server; 1744fa0f6e62SHans Petter Selasky 1745fa0f6e62SHans Petter Selasky cuse_lock(); 1746fa0f6e62SHans Petter Selasky mem = &cuse_mem[alloc_nr]; 1747fa0f6e62SHans Petter Selasky 1748fa0f6e62SHans Petter Selasky /* try to enforce slight ownership */ 1749fa0f6e62SHans Petter Selasky if ((pcs != NULL) && (mem->owner != pcs)) { 1750fa0f6e62SHans Petter Selasky cuse_unlock(); 1751fa0f6e62SHans Petter Selasky return (EINVAL); 1752fa0f6e62SHans Petter Selasky } 1753fa0f6e62SHans Petter Selasky if (mem->virtaddr == NULL) { 1754fa0f6e62SHans Petter Selasky cuse_unlock(); 1755fa0f6e62SHans Petter Selasky return (ENOMEM); 1756fa0f6e62SHans Petter Selasky } 1757fa0f6e62SHans Petter Selasky if (mem->virtaddr == NBUSY) { 1758fa0f6e62SHans Petter Selasky cuse_unlock(); 1759fa0f6e62SHans Petter Selasky return (ENOMEM); 1760fa0f6e62SHans Petter Selasky } 1761fa0f6e62SHans Petter Selasky page_nr %= CUSE_ALLOC_PAGES_MAX; 1762fa0f6e62SHans Petter Selasky 1763fa0f6e62SHans Petter Selasky if (page_nr >= mem->page_count) { 1764fa0f6e62SHans Petter Selasky cuse_unlock(); 1765fa0f6e62SHans Petter Selasky return (ENXIO); 1766fa0f6e62SHans Petter Selasky } 1767fa0f6e62SHans Petter Selasky ptr = mem->virtaddr + (page_nr * PAGE_SIZE); 1768fa0f6e62SHans Petter Selasky cuse_unlock(); 1769fa0f6e62SHans Petter Selasky 1770fa0f6e62SHans Petter Selasky *paddr = vtophys(ptr); 1771fa0f6e62SHans Petter Selasky 1772fa0f6e62SHans Petter Selasky return (0); 1773fa0f6e62SHans Petter Selasky } 1774fa0f6e62SHans Petter Selasky 1775fa0f6e62SHans Petter Selasky static void 1776fa0f6e62SHans Petter Selasky cuse_client_kqfilter_read_detach(struct knote *kn) 1777fa0f6e62SHans Petter Selasky { 1778fa0f6e62SHans Petter Selasky struct cuse_client *pcc; 1779fa0f6e62SHans Petter Selasky 1780fa0f6e62SHans Petter Selasky cuse_lock(); 1781fa0f6e62SHans Petter Selasky pcc = kn->kn_hook; 1782fa0f6e62SHans Petter Selasky knlist_remove(&pcc->server->selinfo.si_note, kn, 1); 1783fa0f6e62SHans Petter Selasky cuse_unlock(); 1784fa0f6e62SHans Petter Selasky } 1785fa0f6e62SHans Petter Selasky 1786fa0f6e62SHans Petter Selasky static void 1787fa0f6e62SHans Petter Selasky cuse_client_kqfilter_write_detach(struct knote *kn) 1788fa0f6e62SHans Petter Selasky { 1789fa0f6e62SHans Petter Selasky struct cuse_client *pcc; 1790fa0f6e62SHans Petter Selasky 1791fa0f6e62SHans Petter Selasky cuse_lock(); 1792fa0f6e62SHans Petter Selasky pcc = kn->kn_hook; 1793fa0f6e62SHans Petter Selasky knlist_remove(&pcc->server->selinfo.si_note, kn, 1); 1794fa0f6e62SHans Petter Selasky cuse_unlock(); 1795fa0f6e62SHans Petter Selasky } 1796fa0f6e62SHans Petter Selasky 1797fa0f6e62SHans Petter Selasky static int 1798fa0f6e62SHans Petter Selasky cuse_client_kqfilter_read_event(struct knote *kn, long hint) 1799fa0f6e62SHans Petter Selasky { 1800fa0f6e62SHans Petter Selasky struct cuse_client *pcc; 1801fa0f6e62SHans Petter Selasky 1802fa0f6e62SHans Petter Selasky mtx_assert(&cuse_mtx, MA_OWNED); 1803fa0f6e62SHans Petter Selasky 1804fa0f6e62SHans Petter Selasky pcc = kn->kn_hook; 1805fa0f6e62SHans Petter Selasky return ((pcc->cflags & CUSE_CLI_KNOTE_NEED_READ) ? 1 : 0); 1806fa0f6e62SHans Petter Selasky } 1807fa0f6e62SHans Petter Selasky 1808fa0f6e62SHans Petter Selasky static int 1809fa0f6e62SHans Petter Selasky cuse_client_kqfilter_write_event(struct knote *kn, long hint) 1810fa0f6e62SHans Petter Selasky { 1811fa0f6e62SHans Petter Selasky struct cuse_client *pcc; 1812fa0f6e62SHans Petter Selasky 1813fa0f6e62SHans Petter Selasky mtx_assert(&cuse_mtx, MA_OWNED); 1814fa0f6e62SHans Petter Selasky 1815fa0f6e62SHans Petter Selasky pcc = kn->kn_hook; 1816fa0f6e62SHans Petter Selasky return ((pcc->cflags & CUSE_CLI_KNOTE_NEED_WRITE) ? 1 : 0); 1817fa0f6e62SHans Petter Selasky } 1818fa0f6e62SHans Petter Selasky 1819fa0f6e62SHans Petter Selasky static int 1820fa0f6e62SHans Petter Selasky cuse_client_kqfilter(struct cdev *dev, struct knote *kn) 1821fa0f6e62SHans Petter Selasky { 1822fa0f6e62SHans Petter Selasky struct cuse_client *pcc; 1823fa0f6e62SHans Petter Selasky struct cuse_server *pcs; 1824fa0f6e62SHans Petter Selasky int error; 1825fa0f6e62SHans Petter Selasky 1826fa0f6e62SHans Petter Selasky error = cuse_client_get(&pcc); 1827fa0f6e62SHans Petter Selasky if (error != 0) 1828fa0f6e62SHans Petter Selasky return (error); 1829fa0f6e62SHans Petter Selasky 1830fa0f6e62SHans Petter Selasky cuse_lock(); 1831fa0f6e62SHans Petter Selasky pcs = pcc->server; 1832fa0f6e62SHans Petter Selasky switch (kn->kn_filter) { 1833fa0f6e62SHans Petter Selasky case EVFILT_READ: 1834fa0f6e62SHans Petter Selasky pcc->cflags |= CUSE_CLI_KNOTE_HAS_READ; 1835fa0f6e62SHans Petter Selasky kn->kn_hook = pcc; 1836fa0f6e62SHans Petter Selasky kn->kn_fop = &cuse_client_kqfilter_read_ops; 1837fa0f6e62SHans Petter Selasky knlist_add(&pcs->selinfo.si_note, kn, 1); 1838fa0f6e62SHans Petter Selasky break; 1839fa0f6e62SHans Petter Selasky case EVFILT_WRITE: 1840fa0f6e62SHans Petter Selasky pcc->cflags |= CUSE_CLI_KNOTE_HAS_WRITE; 1841fa0f6e62SHans Petter Selasky kn->kn_hook = pcc; 1842fa0f6e62SHans Petter Selasky kn->kn_fop = &cuse_client_kqfilter_write_ops; 1843fa0f6e62SHans Petter Selasky knlist_add(&pcs->selinfo.si_note, kn, 1); 1844fa0f6e62SHans Petter Selasky break; 1845fa0f6e62SHans Petter Selasky default: 1846fa0f6e62SHans Petter Selasky error = EINVAL; 1847fa0f6e62SHans Petter Selasky break; 1848fa0f6e62SHans Petter Selasky } 1849fa0f6e62SHans Petter Selasky cuse_unlock(); 1850fa0f6e62SHans Petter Selasky 1851fa0f6e62SHans Petter Selasky if (error == 0) 1852fa0f6e62SHans Petter Selasky cuse_client_kqfilter_poll(dev, pcc); 1853fa0f6e62SHans Petter Selasky return (error); 1854fa0f6e62SHans Petter Selasky } 1855