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