usr.sbin/bhyve/pci_virtio_9p.c

   1 /*-
   2  * Copyright (c) 2015 iXsystems Inc.
   3  * Copyright (c) 2017-2018 Jakub Klama <jceel@FreeBSD.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer
  11  *    in this position and unchanged.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 /*
  30  * VirtIO filesystem passthrough using 9p protocol.
  31  */
  32
  33 #include <sys/cdefs.h>
  34 __FBSDID("$FreeBSD$");
  35
  36 #include <sys/param.h>
  37 #include <sys/linker_set.h>
  38 #include <sys/uio.h>
  39 #include <sys/capsicum.h>
  40
  41 #include <errno.h>
  42 #include <fcntl.h>
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <string.h>
  46 #include <unistd.h>
  47 #include <assert.h>
  48 #include <pthread.h>
  49
  50 #include <lib9p.h>
  51 #include <backend/fs.h>
  52
  53 #include "bhyverun.h"
  54 #include "config.h"
  55 #include "debug.h"
  56 #include "pci_emul.h"
  57 #include "virtio.h"
  58
  59 #define VT9P_MAX_IOV    128
  60 #define VT9P_RINGSZ     256
  61 #define VT9P_MAXTAGSZ   256
  62 #define VT9P_CONFIGSPACESZ      (VT9P_MAXTAGSZ + sizeof(uint16_t))
  63
  64 static int pci_vt9p_debug;
  65 #define DPRINTF(params) if (pci_vt9p_debug) printf params
  66 #define WPRINTF(params) printf params
  67
  68 /*
  69  * Per-device softc
  70  */
  71 struct pci_vt9p_softc {
  72         struct virtio_softc      vsc_vs;
  73         struct vqueue_info       vsc_vq;
  74         pthread_mutex_t          vsc_mtx;
  75         uint64_t                 vsc_cfg;
  76         uint64_t                 vsc_features;
  77         char *                   vsc_rootpath;
  78         struct pci_vt9p_config * vsc_config;
  79         struct l9p_backend *     vsc_fs_backend;
  80         struct l9p_server *      vsc_server;
  81         struct l9p_connection *  vsc_conn;
  82 };
  83
  84 struct pci_vt9p_request {
  85         struct pci_vt9p_softc * vsr_sc;
  86         struct iovec *          vsr_iov;
  87         size_t                  vsr_niov;
  88         size_t                  vsr_respidx;
  89         size_t                  vsr_iolen;
  90         uint16_t                vsr_idx;
  91 };
  92
  93 struct pci_vt9p_config {
  94         uint16_t tag_len;
  95         char tag[0];
  96 } __attribute__((packed));
  97
  98 static int pci_vt9p_send(struct l9p_request *, const struct iovec *,
  99     const size_t, const size_t, void *);
 100 static void pci_vt9p_drop(struct l9p_request *, const struct iovec *, size_t,
 101     void *);
 102 static void pci_vt9p_reset(void *);
 103 static void pci_vt9p_notify(void *, struct vqueue_info *);
 104 static int pci_vt9p_cfgread(void *, int, int, uint32_t *);
 105 static void pci_vt9p_neg_features(void *, uint64_t);
 106
 107 static struct virtio_consts vt9p_vi_consts = {
 108         .vc_name =      "vt9p",
 109         .vc_nvq =       1,
 110         .vc_cfgsize =   VT9P_CONFIGSPACESZ,
 111         .vc_reset =     pci_vt9p_reset,
 112         .vc_qnotify =   pci_vt9p_notify,
 113         .vc_cfgread =   pci_vt9p_cfgread,
 114         .vc_apply_features = pci_vt9p_neg_features,
 115         .vc_hv_caps =   (1 << 0),
 116 };
 117
 118 static void
 119 pci_vt9p_reset(void *vsc)
 120 {
 121         struct pci_vt9p_softc *sc;
 122
 123         sc = vsc;
 124
 125         DPRINTF(("vt9p: device reset requested !\n"));
 126         vi_reset_dev(&sc->vsc_vs);
 127 }
 128
 129 static void
 130 pci_vt9p_neg_features(void *vsc, uint64_t negotiated_features)
 131 {
 132         struct pci_vt9p_softc *sc = vsc;
 133
 134         sc->vsc_features = negotiated_features;
 135 }
 136
 137 static int
 138 pci_vt9p_cfgread(void *vsc, int offset, int size, uint32_t *retval)
 139 {
 140         struct pci_vt9p_softc *sc = vsc;
 141         void *ptr;
 142
 143         ptr = (uint8_t *)sc->vsc_config + offset;
 144         memcpy(retval, ptr, size);
 145         return (0);
 146 }
 147
 148 static int
 149 pci_vt9p_get_buffer(struct l9p_request *req, struct iovec *iov, size_t *niov,
 150     void *arg __unused)
 151 {
 152         struct pci_vt9p_request *preq = req->lr_aux;
 153         size_t n = preq->vsr_niov - preq->vsr_respidx;
 154
 155         memcpy(iov, preq->vsr_iov + preq->vsr_respidx,
 156             n * sizeof(struct iovec));
 157         *niov = n;
 158         return (0);
 159 }
 160
 161 static int
 162 pci_vt9p_send(struct l9p_request *req, const struct iovec *iov __unused,
 163     const size_t niov __unused, const size_t iolen, void *arg __unused)
 164 {
 165         struct pci_vt9p_request *preq = req->lr_aux;
 166         struct pci_vt9p_softc *sc = preq->vsr_sc;
 167
 168         preq->vsr_iolen = iolen;
 169
 170         pthread_mutex_lock(&sc->vsc_mtx);
 171         vq_relchain(&sc->vsc_vq, preq->vsr_idx, preq->vsr_iolen);
 172         vq_endchains(&sc->vsc_vq, 1);
 173         pthread_mutex_unlock(&sc->vsc_mtx);
 174         free(preq);
 175         return (0);
 176 }
 177
 178 static void
 179 pci_vt9p_drop(struct l9p_request *req, const struct iovec *iov __unused,
 180     size_t niov __unused, void *arg __unused)
 181 {
 182         struct pci_vt9p_request *preq = req->lr_aux;
 183         struct pci_vt9p_softc *sc = preq->vsr_sc;
 184
 185         pthread_mutex_lock(&sc->vsc_mtx);
 186         vq_relchain(&sc->vsc_vq, preq->vsr_idx, 0);
 187         vq_endchains(&sc->vsc_vq, 1);
 188         pthread_mutex_unlock(&sc->vsc_mtx);
 189         free(preq);
 190 }
 191
 192 static void
 193 pci_vt9p_notify(void *vsc, struct vqueue_info *vq)
 194 {
 195         struct iovec iov[VT9P_MAX_IOV];
 196         struct pci_vt9p_softc *sc;
 197         struct pci_vt9p_request *preq;
 198         struct vi_req req;
 199         int n;
 200
 201         sc = vsc;
 202
 203         while (vq_has_descs(vq)) {
 204                 n = vq_getchain(vq, iov, VT9P_MAX_IOV, &req);
 205                 assert(n >= 1 && n <= VT9P_MAX_IOV);
 206                 preq = calloc(1, sizeof(struct pci_vt9p_request));
 207                 preq->vsr_sc = sc;
 208                 preq->vsr_idx = req.idx;
 209                 preq->vsr_iov = iov;
 210                 preq->vsr_niov = n;
 211                 preq->vsr_respidx = req.readable;
 212
 213                 for (int i = 0; i < n; i++) {
 214                         DPRINTF(("vt9p: vt9p_notify(): desc%d base=%p, "
 215                             "len=%zu\r\n", i, iov[i].iov_base,
 216                             iov[i].iov_len));
 217                 }
 218
 219                 l9p_connection_recv(sc->vsc_conn, iov, preq->vsr_respidx, preq);
 220         }
 221 }
 222
 223 static int
 224 pci_vt9p_legacy_config(nvlist_t *nvl, const char *opts)
 225 {
 226         char *sharename = NULL, *tofree, *token, *tokens;
 227
 228         if (opts == NULL)
 229                 return (0);
 230
 231         tokens = tofree = strdup(opts);
 232         while ((token = strsep(&tokens, ",")) != NULL) {
 233                 if (strchr(token, '=') != NULL) {
 234                         if (sharename != NULL) {
 235                                 EPRINTLN(
 236                             "virtio-9p: more than one share name given");
 237                                 return (-1);
 238                         }
 239
 240                         sharename = strsep(&token, "=");
 241                         set_config_value_node(nvl, "sharename", sharename);
 242                         set_config_value_node(nvl, "path", token);
 243                 } else
 244                         set_config_bool_node(nvl, token, true);
 245         }
 246         free(tofree);
 247         return (0);
 248 }
 249
 250 static int
 251 pci_vt9p_init(struct vmctx *ctx __unused, struct pci_devinst *pi, nvlist_t *nvl)
 252 {
 253         struct pci_vt9p_softc *sc;
 254         const char *value;
 255         const char *sharename;
 256         int rootfd;
 257         bool ro;
 258         cap_rights_t rootcap;
 259
 260         ro = get_config_bool_node_default(nvl, "ro", false);
 261
 262         value = get_config_value_node(nvl, "path");
 263         if (value == NULL) {
 264                 EPRINTLN("virtio-9p: path required");
 265                 return (1);
 266         }
 267         rootfd = open(value, O_DIRECTORY);
 268         if (rootfd < 0) {
 269                 EPRINTLN("virtio-9p: failed to open '%s': %s", value,
 270                     strerror(errno));
 271                 return (-1);
 272         }
 273
 274         sharename = get_config_value_node(nvl, "sharename");
 275         if (sharename == NULL) {
 276                 EPRINTLN("virtio-9p: share name required");
 277                 return (1);
 278         }
 279         if (strlen(sharename) > VT9P_MAXTAGSZ) {
 280                 EPRINTLN("virtio-9p: share name too long");
 281                 return (1);
 282         }
 283
 284         sc = calloc(1, sizeof(struct pci_vt9p_softc));
 285         sc->vsc_config = calloc(1, sizeof(struct pci_vt9p_config) +
 286             VT9P_MAXTAGSZ);
 287
 288         pthread_mutex_init(&sc->vsc_mtx, NULL);
 289
 290         cap_rights_init(&rootcap,
 291             CAP_LOOKUP, CAP_ACL_CHECK, CAP_ACL_DELETE, CAP_ACL_GET,
 292             CAP_ACL_SET, CAP_READ, CAP_WRITE, CAP_SEEK, CAP_FSTAT,
 293             CAP_CREATE, CAP_FCHMODAT, CAP_FCHOWNAT, CAP_FTRUNCATE,
 294             CAP_LINKAT_SOURCE, CAP_LINKAT_TARGET, CAP_MKDIRAT, CAP_MKNODAT,
 295             CAP_PREAD, CAP_PWRITE, CAP_RENAMEAT_SOURCE, CAP_RENAMEAT_TARGET,
 296             CAP_SEEK, CAP_SYMLINKAT, CAP_UNLINKAT, CAP_EXTATTR_DELETE,
 297             CAP_EXTATTR_GET, CAP_EXTATTR_LIST, CAP_EXTATTR_SET,
 298             CAP_FUTIMES, CAP_FSTATFS, CAP_FSYNC, CAP_FPATHCONF);
 299
 300         if (cap_rights_limit(rootfd, &rootcap) != 0)
 301                 return (1);
 302
 303         sc->vsc_config->tag_len = (uint16_t)strlen(sharename);
 304         memcpy(sc->vsc_config->tag, sharename, sc->vsc_config->tag_len);
 305
 306         if (l9p_backend_fs_init(&sc->vsc_fs_backend, rootfd, ro) != 0) {
 307                 errno = ENXIO;
 308                 return (1);
 309         }
 310
 311         if (l9p_server_init(&sc->vsc_server, sc->vsc_fs_backend) != 0) {
 312                 errno = ENXIO;
 313                 return (1);
 314         }
 315
 316         if (l9p_connection_init(sc->vsc_server, &sc->vsc_conn) != 0) {
 317                 errno = EIO;
 318                 return (1);
 319         }
 320
 321         sc->vsc_conn->lc_msize = L9P_MAX_IOV * PAGE_SIZE;
 322         sc->vsc_conn->lc_lt.lt_get_response_buffer = pci_vt9p_get_buffer;
 323         sc->vsc_conn->lc_lt.lt_send_response = pci_vt9p_send;
 324         sc->vsc_conn->lc_lt.lt_drop_response = pci_vt9p_drop;
 325
 326         vi_softc_linkup(&sc->vsc_vs, &vt9p_vi_consts, sc, pi, &sc->vsc_vq);
 327         sc->vsc_vs.vs_mtx = &sc->vsc_mtx;
 328         sc->vsc_vq.vq_qsize = VT9P_RINGSZ;
 329
 330         /* initialize config space */
 331         pci_set_cfgdata16(pi, PCIR_DEVICE, VIRTIO_DEV_9P);
 332         pci_set_cfgdata16(pi, PCIR_VENDOR, VIRTIO_VENDOR);
 333         pci_set_cfgdata8(pi, PCIR_CLASS, PCIC_STORAGE);
 334         pci_set_cfgdata16(pi, PCIR_SUBDEV_0, VIRTIO_ID_9P);
 335         pci_set_cfgdata16(pi, PCIR_SUBVEND_0, VIRTIO_VENDOR);
 336
 337         if (vi_intr_init(&sc->vsc_vs, 1, fbsdrun_virtio_msix()))
 338                 return (1);
 339         vi_set_io_bar(&sc->vsc_vs, 0);
 340
 341         return (0);
 342 }
 343
 344 static const struct pci_devemu pci_de_v9p = {
 345         .pe_emu =       "virtio-9p",
 346         .pe_legacy_config = pci_vt9p_legacy_config,
 347         .pe_init =      pci_vt9p_init,
 348         .pe_barwrite =  vi_pci_write,
 349         .pe_barread =   vi_pci_read
 350 };
 351 PCI_EMUL_SET(pci_de_v9p);