File Manager

003 File Manager

Current Path: /usr/src/usr.sbin/bhyve

📁 ..
📄 Makefile(2.18 KB)
📄 Makefile.depend(434 B)
📄 Makefile.depend.options(115 B)
📄 acpi.c(29.64 KB)
📄 acpi.h(2.26 KB)
📄 ahci.h(10.72 KB)
📄 atkbdc.c(15.5 KB)
📄 atkbdc.h(1.66 KB)
📄 audio.c(6.84 KB)
📄 audio.h(2.91 KB)
📄 bhyve.8(18.81 KB)
📄 bhyvegc.c(2.76 KB)
📄 bhyvegc.h(1.83 KB)
📄 bhyverun.c(33 KB)
📄 bhyverun.h(2.06 KB)
📄 block_if.c(21.38 KB)
📄 block_if.h(3.37 KB)
📄 bootrom.c(4.92 KB)
📄 bootrom.h(1.8 KB)
📄 console.c(3 KB)
📄 console.h(2.18 KB)
📄 debug.h(1.74 KB)
📄 fwctl.c(9.7 KB)
📄 fwctl.h(1.87 KB)
📄 gdb.c(37.2 KB)
📄 gdb.h(1.65 KB)
📄 hda_codec.c(24.56 KB)
📄 hda_reg.h(57.84 KB)
📄 hdac_reg.h(10.96 KB)
📄 inout.c(6.97 KB)
📄 inout.h(2.54 KB)
📄 ioapic.c(2.45 KB)
📄 ioapic.h(1.65 KB)
📄 iov.c(3.47 KB)
📄 iov.h(1.93 KB)
📄 kernemu_dev.c(2.95 KB)
📄 kernemu_dev.h(1.44 KB)
📄 mem.c(8.78 KB)
📄 mem.h(2.31 KB)
📄 mevent.c(9.86 KB)
📄 mevent.h(1.95 KB)
📄 mevent_test.c(5.36 KB)
📄 mptbl.c(9.44 KB)
📄 mptbl.h(1.53 KB)
📄 net_backends.c(24.6 KB)
📄 net_backends.h(4.19 KB)
📄 net_utils.c(3.04 KB)
📄 net_utils.h(1.67 KB)
📄 pci_ahci.c(64.56 KB)
📄 pci_e82545.c(65.54 KB)
📄 pci_emul.c(54.54 KB)
📄 pci_emul.h(8.47 KB)
📄 pci_fbuf.c(10.34 KB)
📄 pci_hda.c(30.87 KB)
📄 pci_hda.h(2.73 KB)
📄 pci_hostbridge.c(2.43 KB)
📄 pci_irq.c(9.19 KB)
📄 pci_irq.h(1.85 KB)
📄 pci_lpc.c(11.06 KB)
📄 pci_lpc.h(2.41 KB)
📄 pci_nvme.c(73.14 KB)
📄 pci_passthru.c(22.85 KB)
📄 pci_uart.c(3.2 KB)
📄 pci_virtio_9p.c(9.1 KB)
📄 pci_virtio_block.c(15.89 KB)
📄 pci_virtio_console.c(15.86 KB)
📄 pci_virtio_net.c(20.05 KB)
📄 pci_virtio_rnd.c(5.23 KB)
📄 pci_virtio_scsi.c(19.95 KB)
📄 pci_xhci.c(80.6 KB)
📄 pci_xhci.h(13.02 KB)
📄 pctestdev.c(6.3 KB)
📄 pctestdev.h(1.65 KB)
📄 pm.c(8.9 KB)
📄 post.c(1.8 KB)
📄 ps2kbd.c(10.24 KB)
📄 ps2kbd.h(1.8 KB)
📄 ps2mouse.c(9.85 KB)
📄 ps2mouse.h(1.94 KB)
📄 rfb.c(25.9 KB)
📄 rfb.h(1.56 KB)
📄 rtc.c(3.4 KB)
📄 rtc.h(1.52 KB)
📄 smbiostbl.c(25.33 KB)
📄 smbiostbl.h(1.54 KB)
📄 snapshot.c(38.16 KB)
📄 snapshot.h(3.51 KB)
📄 sockstream.c(2.16 KB)
📄 sockstream.h(1.54 KB)
📄 spinup_ap.c(3 KB)
📄 spinup_ap.h(1.5 KB)
📄 task_switch.c(25.78 KB)
📄 uart_emul.c(15.75 KB)
📄 uart_emul.h(1.99 KB)
📄 usb_emul.c(2.3 KB)
📄 usb_emul.h(4.56 KB)
📄 usb_mouse.c(19.9 KB)
📄 vga.c(33.42 KB)
📄 vga.h(5.32 KB)
📄 virtio.c(25.01 KB)
📄 virtio.h(18.67 KB)
📄 vmgenc.c(3.27 KB)
📄 vmgenc.h(1.48 KB)
📄 xmsr.c(5.28 KB)
📄 xmsr.h(1.59 KB)

Editing: pci_virtio_9p.c

/*-
 * Copyright (c) 2015 iXsystems Inc.
 * Copyright (c) 2017-2018 Jakub Klama <jceel@FreeBSD.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer
 *    in this position and unchanged.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * VirtIO filesystem passthrough using 9p protocol.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/param.h>
#include <sys/linker_set.h>
#include <sys/uio.h>
#include <sys/capsicum.h>

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <assert.h>
#include <pthread.h>

#include <lib9p.h>
#include <backend/fs.h>

#include "bhyverun.h"
#include "pci_emul.h"
#include "virtio.h"

#define	VT9P_MAX_IOV	128
#define VT9P_RINGSZ	256
#define	VT9P_MAXTAGSZ	256
#define	VT9P_CONFIGSPACESZ	(VT9P_MAXTAGSZ + sizeof(uint16_t))

static int pci_vt9p_debug;
#define DPRINTF(params) if (pci_vt9p_debug) printf params
#define WPRINTF(params) printf params

/*
 * Per-device softc
 */
struct pci_vt9p_softc {
	struct virtio_softc      vsc_vs;
	struct vqueue_info       vsc_vq;
	pthread_mutex_t          vsc_mtx;
	uint64_t                 vsc_cfg;
	uint64_t                 vsc_features;
	char *                   vsc_rootpath;
	struct pci_vt9p_config * vsc_config;
	struct l9p_backend *     vsc_fs_backend;
	struct l9p_server *      vsc_server;
        struct l9p_connection *  vsc_conn;
};

struct pci_vt9p_request {
	struct pci_vt9p_softc *	vsr_sc;
	struct iovec *		vsr_iov;
	size_t			vsr_niov;
	size_t			vsr_respidx;
	size_t			vsr_iolen;
	uint16_t		vsr_idx;
};

struct pci_vt9p_config {
	uint16_t tag_len;
	char tag[0];
} __attribute__((packed));

static int pci_vt9p_send(struct l9p_request *, const struct iovec *,
    const size_t, const size_t, void *);
static void pci_vt9p_drop(struct l9p_request *, const struct iovec *, size_t,
    void *);
static void pci_vt9p_reset(void *);
static void pci_vt9p_notify(void *, struct vqueue_info *);
static int pci_vt9p_cfgread(void *, int, int, uint32_t *);
static void pci_vt9p_neg_features(void *, uint64_t);

static struct virtio_consts vt9p_vi_consts = {
	"vt9p",			/* our name */
	1,			/* we support 1 virtqueue */
	VT9P_CONFIGSPACESZ,	/* config reg size */
	pci_vt9p_reset,		/* reset */
	pci_vt9p_notify,	/* device-wide qnotify */
	pci_vt9p_cfgread,	/* read virtio config */
	NULL,			/* write virtio config */
	pci_vt9p_neg_features,	/* apply negotiated features */
	(1 << 0),		/* our capabilities */
};

static void
pci_vt9p_reset(void *vsc)
{
	struct pci_vt9p_softc *sc;

sc = vsc;

DPRINTF(("vt9p: device reset requested !\n"));
	vi_reset_dev(&sc->vsc_vs);
}

static void
pci_vt9p_neg_features(void *vsc, uint64_t negotiated_features)
{
	struct pci_vt9p_softc *sc = vsc;

sc->vsc_features = negotiated_features;
}

static int
pci_vt9p_cfgread(void *vsc, int offset, int size, uint32_t *retval)
{
	struct pci_vt9p_softc *sc = vsc;
	void *ptr;

ptr = (uint8_t *)sc->vsc_config + offset;
	memcpy(retval, ptr, size);
	return (0);
}

static int
pci_vt9p_get_buffer(struct l9p_request *req, struct iovec *iov, size_t *niov,
    void *arg)
{
	struct pci_vt9p_request *preq = req->lr_aux;
	size_t n = preq->vsr_niov - preq->vsr_respidx;
	
	memcpy(iov, preq->vsr_iov + preq->vsr_respidx,
	    n * sizeof(struct iovec));
	*niov = n;
	return (0);
}

static int
pci_vt9p_send(struct l9p_request *req, const struct iovec *iov,
    const size_t niov, const size_t iolen, void *arg)
{
	struct pci_vt9p_request *preq = req->lr_aux;
	struct pci_vt9p_softc *sc = preq->vsr_sc;

preq->vsr_iolen = iolen;

pthread_mutex_lock(&sc->vsc_mtx);
	vq_relchain(&sc->vsc_vq, preq->vsr_idx, preq->vsr_iolen);
	vq_endchains(&sc->vsc_vq, 1);
	pthread_mutex_unlock(&sc->vsc_mtx);
	free(preq);
	return (0);
}

static void
pci_vt9p_drop(struct l9p_request *req, const struct iovec *iov, size_t niov,
    void *arg)
{
	struct pci_vt9p_request *preq = req->lr_aux;
	struct pci_vt9p_softc *sc = preq->vsr_sc;

pthread_mutex_lock(&sc->vsc_mtx);
	vq_relchain(&sc->vsc_vq, preq->vsr_idx, 0);
	vq_endchains(&sc->vsc_vq, 1);
	pthread_mutex_unlock(&sc->vsc_mtx);
	free(preq);
}

static void
pci_vt9p_notify(void *vsc, struct vqueue_info *vq)
{
	struct iovec iov[VT9P_MAX_IOV];
	struct pci_vt9p_softc *sc;
	struct pci_vt9p_request *preq;
	int n;
	uint16_t idx, i;
	uint16_t flags[VT9P_MAX_IOV];

sc = vsc;

while (vq_has_descs(vq)) {
		n = vq_getchain(vq, &idx, iov, VT9P_MAX_IOV, flags);
		assert(n >= 1 && n <= VT9P_MAX_IOV);
		preq = calloc(1, sizeof(struct pci_vt9p_request));
		preq->vsr_sc = sc;
		preq->vsr_idx = idx;
		preq->vsr_iov = iov;
		preq->vsr_niov = n;
		preq->vsr_respidx = 0;

/* Count readable descriptors */
		for (i = 0; i < n; i++) {
			if (flags[i] & VRING_DESC_F_WRITE)
				break;

preq->vsr_respidx++;
		}

for (int i = 0; i < n; i++) {
			DPRINTF(("vt9p: vt9p_notify(): desc%d base=%p, "
			    "len=%zu, flags=0x%04x\r\n", i, iov[i].iov_base,
			    iov[i].iov_len, flags[i]));
		}

l9p_connection_recv(sc->vsc_conn, iov, preq->vsr_respidx, preq);
	}
}

static int
pci_vt9p_init(struct vmctx *ctx, struct pci_devinst *pi, char *opts)
{
	struct pci_vt9p_softc *sc;
	char *opt;
	char *sharename = NULL;
	char *rootpath = NULL;
	int rootfd;
	bool ro = false;
	cap_rights_t rootcap;

if (opts == NULL) {
		printf("virtio-9p: share name and path required\n");
		return (1);
	}

while ((opt = strsep(&opts, ",")) != NULL) {
		if (strchr(opt, '=') != NULL) {
			if (sharename != NULL) {
				printf("virtio-9p: more than one share name given\n");
				return (1);
			}

sharename = strsep(&opt, "=");
			rootpath = opt;
			continue;
		}

if (strcmp(opt, "ro") == 0) {
			DPRINTF(("read-only mount requested\r\n"));
			ro = true;
			continue;
		}

printf("virtio-9p: invalid option '%s'\n", opt);
		return (1);
	}

if (strlen(sharename) > VT9P_MAXTAGSZ) {
		printf("virtio-9p: share name too long\n");
		return (1);
	}

rootfd = open(rootpath, O_DIRECTORY);
	if (rootfd < 0)
		return (-1);

sc = calloc(1, sizeof(struct pci_vt9p_softc));
	sc->vsc_config = calloc(1, sizeof(struct pci_vt9p_config) +
	    VT9P_MAXTAGSZ);

pthread_mutex_init(&sc->vsc_mtx, NULL);

cap_rights_init(&rootcap,
	    CAP_LOOKUP, CAP_ACL_CHECK, CAP_ACL_DELETE, CAP_ACL_GET,
	    CAP_ACL_SET, CAP_READ, CAP_WRITE, CAP_SEEK, CAP_FSTAT,
	    CAP_CREATE, CAP_FCHMODAT, CAP_FCHOWNAT, CAP_FTRUNCATE,
	    CAP_LINKAT_SOURCE, CAP_LINKAT_TARGET, CAP_MKDIRAT, CAP_MKNODAT,
	    CAP_PREAD, CAP_PWRITE, CAP_RENAMEAT_SOURCE, CAP_RENAMEAT_TARGET,
	    CAP_SEEK, CAP_SYMLINKAT, CAP_UNLINKAT, CAP_EXTATTR_DELETE,
	    CAP_EXTATTR_GET, CAP_EXTATTR_LIST, CAP_EXTATTR_SET,
	    CAP_FUTIMES, CAP_FSTATFS, CAP_FSYNC, CAP_FPATHCONF);

if (cap_rights_limit(rootfd, &rootcap) != 0)
		return (1);

sc->vsc_config->tag_len = (uint16_t)strlen(sharename);
	memcpy(sc->vsc_config->tag, sharename, sc->vsc_config->tag_len);
	
	if (l9p_backend_fs_init(&sc->vsc_fs_backend, rootfd, ro) != 0) {
		errno = ENXIO;
		return (1);
	}

if (l9p_server_init(&sc->vsc_server, sc->vsc_fs_backend) != 0) {
		errno = ENXIO;
		return (1);
	}

if (l9p_connection_init(sc->vsc_server, &sc->vsc_conn) != 0) {
		errno = EIO;
		return (1);
	}

sc->vsc_conn->lc_msize = L9P_MAX_IOV * PAGE_SIZE;
	sc->vsc_conn->lc_lt.lt_get_response_buffer = pci_vt9p_get_buffer;
	sc->vsc_conn->lc_lt.lt_send_response = pci_vt9p_send;
	sc->vsc_conn->lc_lt.lt_drop_response = pci_vt9p_drop;

vi_softc_linkup(&sc->vsc_vs, &vt9p_vi_consts, sc, pi, &sc->vsc_vq);
	sc->vsc_vs.vs_mtx = &sc->vsc_mtx;
	sc->vsc_vq.vq_qsize = VT9P_RINGSZ;

/* initialize config space */
	pci_set_cfgdata16(pi, PCIR_DEVICE, VIRTIO_DEV_9P);
	pci_set_cfgdata16(pi, PCIR_VENDOR, VIRTIO_VENDOR);
	pci_set_cfgdata8(pi, PCIR_CLASS, PCIC_STORAGE);
	pci_set_cfgdata16(pi, PCIR_SUBDEV_0, VIRTIO_TYPE_9P);
	pci_set_cfgdata16(pi, PCIR_SUBVEND_0, VIRTIO_VENDOR);

if (vi_intr_init(&sc->vsc_vs, 1, fbsdrun_virtio_msix()))
		return (1);
	vi_set_io_bar(&sc->vsc_vs, 0);

return (0);
}

struct pci_devemu pci_de_v9p = {
	.pe_emu =	"virtio-9p",
	.pe_init =	pci_vt9p_init,
	.pe_barwrite =	vi_pci_write,
	.pe_barread =	vi_pci_read
};
PCI_EMUL_SET(pci_de_v9p);

003 File Manager

Editing: pci_virtio_9p.c

Upload File

Create Folder