Differential D7195 Diff 18869 head/sys/dev/hyperv/storvsc/hv_storvsc_drv_freebsd.c

Changeset View

Standalone View

head/sys/dev/hyperv/storvsc/hv_storvsc_drv_freebsd.c

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

#include <sys/param.h>		#include <sys/param.h>
#include <sys/proc.h>		#include <sys/proc.h>
#include <sys/condvar.h>		#include <sys/condvar.h>
#include <sys/time.h>		#include <sys/time.h>
#include <sys/systm.h>		#include <sys/systm.h>
		#include <sys/sysctl.h>
#include <sys/sockio.h>		#include <sys/sockio.h>
#include <sys/mbuf.h>		#include <sys/mbuf.h>
#include <sys/malloc.h>		#include <sys/malloc.h>
#include <sys/module.h>		#include <sys/module.h>
#include <sys/kernel.h>		#include <sys/kernel.h>
#include <sys/queue.h>		#include <sys/queue.h>
#include <sys/lock.h>		#include <sys/lock.h>
#include <sys/sx.h>		#include <sys/sx.h>
Show All 31 Lines
#define STORVSC_MAX_LUNS_PER_TARGET (64)		#define STORVSC_MAX_LUNS_PER_TARGET (64)
#define STORVSC_MAX_IO_REQUESTS (STORVSC_MAX_LUNS_PER_TARGET * 2)		#define STORVSC_MAX_IO_REQUESTS (STORVSC_MAX_LUNS_PER_TARGET * 2)
#define BLKVSC_MAX_IDE_DISKS_PER_TARGET (1)		#define BLKVSC_MAX_IDE_DISKS_PER_TARGET (1)
#define BLKVSC_MAX_IO_REQUESTS STORVSC_MAX_IO_REQUESTS		#define BLKVSC_MAX_IO_REQUESTS STORVSC_MAX_IO_REQUESTS
#define STORVSC_MAX_TARGETS (2)		#define STORVSC_MAX_TARGETS (2)

#define VSTOR_PKT_SIZE (sizeof(struct vstor_packet) - vmscsi_size_delta)		#define VSTOR_PKT_SIZE (sizeof(struct vstor_packet) - vmscsi_size_delta)

#define HV_ALIGN(x, a) roundup2(x, a)		#define STORVSC_DATA_SEGCNT_MAX VMBUS_CHAN_PRPLIST_MAX
		#define STORVSC_DATA_SEGSZ_MAX PAGE_SIZE
		#define STORVSC_DATA_SIZE_MAX \
		(STORVSC_DATA_SEGCNT_MAX * STORVSC_DATA_SEGSZ_MAX)

struct storvsc_softc;		struct storvsc_softc;

struct hv_sgl_node {		struct hv_sgl_node {
LIST_ENTRY(hv_sgl_node) link;		LIST_ENTRY(hv_sgl_node) link;
struct sglist *sgl_data;		struct sglist *sgl_data;
};		};

struct hv_sgl_page_pool{		struct hv_sgl_page_pool{
LIST_HEAD(, hv_sgl_node) in_use_sgl_list;		LIST_HEAD(, hv_sgl_node) in_use_sgl_list;
LIST_HEAD(, hv_sgl_node) free_sgl_list;		LIST_HEAD(, hv_sgl_node) free_sgl_list;
boolean_t is_init;		boolean_t is_init;
} g_hv_sgl_page_pool;		} g_hv_sgl_page_pool;

#define STORVSC_MAX_SG_PAGE_CNT STORVSC_MAX_IO_REQUESTS * VMBUS_CHAN_PRPLIST_MAX		#define STORVSC_MAX_SG_PAGE_CNT STORVSC_MAX_IO_REQUESTS * STORVSC_DATA_SEGCNT_MAX

enum storvsc_request_type {		enum storvsc_request_type {
WRITE_TYPE,		WRITE_TYPE,
READ_TYPE,		READ_TYPE,
UNKNOWN_TYPE		UNKNOWN_TYPE
};		};

struct hvs_gpa_range {		SYSCTL_NODE(_hw, OID_AUTO, storvsc, CTLFLAG_RD \| CTLFLAG_MPSAFE, NULL,
		"Hyper-V storage interface");

		static u_int hv_storvsc_use_pim_unmapped = 1;
		SYSCTL_INT(_hw_storvsc, OID_AUTO, use_pim_unmapped, CTLFLAG_RDTUN,
		&hv_storvsc_use_pim_unmapped, 0,
		"Optimize storvsc by using unmapped I/O");

		struct hv_storvsc_sysctl {
		u_long data_bio_cnt;
		u_long data_vaddr_cnt;
		u_long data_sg_cnt;
		};

		struct storvsc_gpa_range {
struct vmbus_gpa_range gpa_range;		struct vmbus_gpa_range gpa_range;
uint64_t gpa_page[VMBUS_CHAN_PRPLIST_MAX];		uint64_t gpa_page[STORVSC_DATA_SEGCNT_MAX];
} __packed;		} __packed;

struct hv_storvsc_request {		struct hv_storvsc_request {
LIST_ENTRY(hv_storvsc_request) link;		LIST_ENTRY(hv_storvsc_request) link;
struct vstor_packet vstor_packet;		struct vstor_packet vstor_packet;
int prp_cnt;		int prp_cnt;
struct hvs_gpa_range prp_list;		struct storvsc_gpa_range prp_list;
void *sense_data;		void *sense_data;
uint8_t sense_info_len;		uint8_t sense_info_len;
uint8_t retries;		uint8_t retries;
union ccb *ccb;		union ccb *ccb;
struct storvsc_softc *softc;		struct storvsc_softc *softc;
struct callout callout;		struct callout callout;
struct sema synch_sema; /Synchronize the request/response if needed /		struct sema synch_sema; /Synchronize the request/response if needed /
struct sglist *bounce_sgl;		struct sglist *bounce_sgl;
unsigned int bounce_sgl_count;		unsigned int bounce_sgl_count;
uint64_t not_aligned_seg_bits;		uint64_t not_aligned_seg_bits;
		bus_dmamap_t data_dmap;
};		};

struct storvsc_softc {		struct storvsc_softc {
struct vmbus_channel *hs_chan;		struct vmbus_channel *hs_chan;
LIST_HEAD(, hv_storvsc_request) hs_free_list;		LIST_HEAD(, hv_storvsc_request) hs_free_list;
struct mtx hs_lock;		struct mtx hs_lock;
struct storvsc_driver_props *hs_drv_props;		struct storvsc_driver_props *hs_drv_props;
int hs_unit;		int hs_unit;
uint32_t hs_frozen;		uint32_t hs_frozen;
struct cam_sim *hs_sim;		struct cam_sim *hs_sim;
struct cam_path *hs_path;		struct cam_path *hs_path;
uint32_t hs_num_out_reqs;		uint32_t hs_num_out_reqs;
boolean_t hs_destroy;		boolean_t hs_destroy;
boolean_t hs_drain_notify;		boolean_t hs_drain_notify;
struct sema hs_drain_sema;		struct sema hs_drain_sema;
struct hv_storvsc_request hs_init_req;		struct hv_storvsc_request hs_init_req;
struct hv_storvsc_request hs_reset_req;		struct hv_storvsc_request hs_reset_req;
device_t hs_dev;		device_t hs_dev;
		bus_dma_tag_t storvsc_req_dtag;
		struct hv_storvsc_sysctl sysctl_data;

struct vmbus_channel *hs_cpu2chan[MAXCPU];		struct vmbus_channel *hs_cpu2chan[MAXCPU];
};		};


/**		/**
* HyperV storvsc timeout testing cases:		* HyperV storvsc timeout testing cases:
* a. IO returned after first timeout;		* a. IO returned after first timeout;
▲ Show 20 Lines • Show All 718 Lines • ▼ Show 20 Lines	CPU_FOREACH(cpu) {
sc->hs_cpu2chan[cpu] = vmbus_chan_cpu2chan(sc->hs_chan, cpu);		sc->hs_cpu2chan[cpu] = vmbus_chan_cpu2chan(sc->hs_chan, cpu);
if (bootverbose) {		if (bootverbose) {
device_printf(sc->hs_dev, "cpu%d -> chan%u\n",		device_printf(sc->hs_dev, "cpu%d -> chan%u\n",
cpu, vmbus_chan_id(sc->hs_cpu2chan[cpu]));		cpu, vmbus_chan_id(sc->hs_cpu2chan[cpu]));
}		}
}		}
}		}

		static int
		storvsc_init_requests(device_t dev)
		{
		struct storvsc_softc *sc = device_get_softc(dev);
		struct hv_storvsc_request *reqp;
		int error, i;

		LIST_INIT(&sc->hs_free_list);

		error = bus_dma_tag_create(
		bus_get_dma_tag(dev), /* parent */
		1, /* alignment */
		PAGE_SIZE, /* boundary */
		BUS_SPACE_MAXADDR, /* lowaddr */
		BUS_SPACE_MAXADDR, /* highaddr */
		NULL, NULL, /* filter, filterarg */
		STORVSC_DATA_SIZE_MAX, /* maxsize */
		STORVSC_DATA_SEGCNT_MAX, /* nsegments */
		STORVSC_DATA_SEGSZ_MAX, /* maxsegsize */
		0, /* flags */
		NULL, /* lockfunc */
		NULL, /* lockfuncarg */
		&sc->storvsc_req_dtag);
		if (error) {
		device_printf(dev, "failed to create storvsc dma tag\n");
		return (error);
		}

		for (i = 0; i < sc->hs_drv_props->drv_max_ios_per_target; ++i) {
		reqp = malloc(sizeof(struct hv_storvsc_request),
		M_DEVBUF, M_WAITOK\|M_ZERO);
		reqp->softc = sc;
		error = bus_dmamap_create(sc->storvsc_req_dtag, 0,
		&reqp->data_dmap);
		if (error) {
		device_printf(dev, "failed to allocate storvsc "
		"data dmamap\n");
		goto cleanup;
		}
		LIST_INSERT_HEAD(&sc->hs_free_list, reqp, link);
		}
		return (0);

		cleanup:
		while ((reqp = LIST_FIRST(&sc->hs_free_list)) != NULL) {
		LIST_REMOVE(reqp, link);
		bus_dmamap_destroy(sc->storvsc_req_dtag, reqp->data_dmap);
		free(reqp, M_DEVBUF);
		}
		return (error);
		}

		static void
		storvsc_sysctl(device_t dev)
		{
		struct sysctl_oid_list *child;
		struct sysctl_ctx_list *ctx;
		struct storvsc_softc *sc;

		sc = device_get_softc(dev);
		ctx = device_get_sysctl_ctx(dev);
		child = SYSCTL_CHILDREN(device_get_sysctl_tree(dev));

		SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "data_bio_cnt", CTLFLAG_RW,
		&sc->sysctl_data.data_bio_cnt, "# of bio data block");
		SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "data_vaddr_cnt", CTLFLAG_RW,
		&sc->sysctl_data.data_vaddr_cnt, "# of vaddr data block");
		SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "data_sg_cnt", CTLFLAG_RW,
		&sc->sysctl_data.data_sg_cnt, "# of sg data block");
		}

/**		/**
* @brief StorVSC attach function		* @brief StorVSC attach function
*		*
* Function responsible for allocating per-device structures,		* Function responsible for allocating per-device structures,
* setting up CAM interfaces and scanning for available LUNs to		* setting up CAM interfaces and scanning for available LUNs to
* be used for SCSI device peripherals.		* be used for SCSI device peripherals.
*		*
* @param a device		* @param a device
Show All 28 Lines	storvsc_attach(device_t dev)

/* fill in driver specific properties */		/* fill in driver specific properties */
sc->hs_drv_props = &g_drv_props_table[stor_type];		sc->hs_drv_props = &g_drv_props_table[stor_type];

/* fill in device specific properties */		/* fill in device specific properties */
sc->hs_unit = device_get_unit(dev);		sc->hs_unit = device_get_unit(dev);
sc->hs_dev = dev;		sc->hs_dev = dev;

LIST_INIT(&sc->hs_free_list);
mtx_init(&sc->hs_lock, "hvslck", NULL, MTX_DEF);		mtx_init(&sc->hs_lock, "hvslck", NULL, MTX_DEF);

for (i = 0; i < sc->hs_drv_props->drv_max_ios_per_target; ++i) {		ret = storvsc_init_requests(dev);
reqp = malloc(sizeof(struct hv_storvsc_request),		if (ret != 0)
M_DEVBUF, M_WAITOK\|M_ZERO);		goto cleanup;
reqp->softc = sc;

LIST_INSERT_HEAD(&sc->hs_free_list, reqp, link);
}

/* create sg-list page pool */		/* create sg-list page pool */
if (FALSE == g_hv_sgl_page_pool.is_init) {		if (FALSE == g_hv_sgl_page_pool.is_init) {
g_hv_sgl_page_pool.is_init = TRUE;		g_hv_sgl_page_pool.is_init = TRUE;
LIST_INIT(&g_hv_sgl_page_pool.in_use_sgl_list);		LIST_INIT(&g_hv_sgl_page_pool.in_use_sgl_list);
LIST_INIT(&g_hv_sgl_page_pool.free_sgl_list);		LIST_INIT(&g_hv_sgl_page_pool.free_sgl_list);

/*		/*
* Pre-create SG list, each SG list with		* Pre-create SG list, each SG list with
* VMBUS_CHAN_PRPLIST_MAX segments, each		* STORVSC_DATA_SEGCNT_MAX segments, each
* segment has one page buffer		* segment has one page buffer
*/		*/
for (i = 0; i < STORVSC_MAX_IO_REQUESTS; i++) {		for (i = 0; i < STORVSC_MAX_IO_REQUESTS; i++) {
sgl_node = malloc(sizeof(struct hv_sgl_node),		sgl_node = malloc(sizeof(struct hv_sgl_node),
M_DEVBUF, M_WAITOK\|M_ZERO);		M_DEVBUF, M_WAITOK\|M_ZERO);

sgl_node->sgl_data =		sgl_node->sgl_data =
sglist_alloc(VMBUS_CHAN_PRPLIST_MAX,		sglist_alloc(STORVSC_DATA_SEGCNT_MAX,
M_WAITOK\|M_ZERO);		M_WAITOK\|M_ZERO);

for (j = 0; j < VMBUS_CHAN_PRPLIST_MAX; j++) {		for (j = 0; j < STORVSC_DATA_SEGCNT_MAX; j++) {
tmp_buff = malloc(PAGE_SIZE,		tmp_buff = malloc(PAGE_SIZE,
M_DEVBUF, M_WAITOK\|M_ZERO);		M_DEVBUF, M_WAITOK\|M_ZERO);

sgl_node->sgl_data->sg_segs[j].ss_paddr =		sgl_node->sgl_data->sg_segs[j].ss_paddr =
(vm_paddr_t)tmp_buff;		(vm_paddr_t)tmp_buff;
}		}

LIST_INSERT_HEAD(&g_hv_sgl_page_pool.free_sgl_list,		LIST_INSERT_HEAD(&g_hv_sgl_page_pool.free_sgl_list,
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines	if (xpt_create_path(&sc->hs_path, /periph/NULL,
mtx_unlock(&sc->hs_lock);		mtx_unlock(&sc->hs_lock);
device_printf(dev, "Unable to create path\n");		device_printf(dev, "Unable to create path\n");
ret = ENXIO;		ret = ENXIO;
goto cleanup;		goto cleanup;
}		}

mtx_unlock(&sc->hs_lock);		mtx_unlock(&sc->hs_lock);

		storvsc_sysctl(dev);

root_mount_rel(root_mount_token);		root_mount_rel(root_mount_token);
return (0);		return (0);


cleanup:		cleanup:
root_mount_rel(root_mount_token);		root_mount_rel(root_mount_token);
while (!LIST_EMPTY(&sc->hs_free_list)) {		while (!LIST_EMPTY(&sc->hs_free_list)) {
reqp = LIST_FIRST(&sc->hs_free_list);		reqp = LIST_FIRST(&sc->hs_free_list);
LIST_REMOVE(reqp, link);		LIST_REMOVE(reqp, link);
		bus_dmamap_destroy(sc->storvsc_req_dtag, reqp->data_dmap);
free(reqp, M_DEVBUF);		free(reqp, M_DEVBUF);
}		}

while (!LIST_EMPTY(&g_hv_sgl_page_pool.free_sgl_list)) {		while (!LIST_EMPTY(&g_hv_sgl_page_pool.free_sgl_list)) {
sgl_node = LIST_FIRST(&g_hv_sgl_page_pool.free_sgl_list);		sgl_node = LIST_FIRST(&g_hv_sgl_page_pool.free_sgl_list);
LIST_REMOVE(sgl_node, link);		LIST_REMOVE(sgl_node, link);
for (j = 0; j < VMBUS_CHAN_PRPLIST_MAX; j++) {		for (j = 0; j < STORVSC_DATA_SEGCNT_MAX; j++) {
if (NULL !=		if (NULL !=
(void*)sgl_node->sgl_data->sg_segs[j].ss_paddr) {		(void*)sgl_node->sgl_data->sg_segs[j].ss_paddr) {
free((void*)sgl_node->sgl_data->sg_segs[j].ss_paddr, M_DEVBUF);		free((void*)sgl_node->sgl_data->sg_segs[j].ss_paddr, M_DEVBUF);
}		}
}		}
sglist_free(sgl_node->sgl_data);		sglist_free(sgl_node->sgl_data);
free(sgl_node, M_DEVBUF);		free(sgl_node, M_DEVBUF);
}		}
Show All 38 Lines	storvsc_detach(device_t dev)
*/		*/

vmbus_chan_close(sc->hs_chan);		vmbus_chan_close(sc->hs_chan);

mtx_lock(&sc->hs_lock);		mtx_lock(&sc->hs_lock);
while (!LIST_EMPTY(&sc->hs_free_list)) {		while (!LIST_EMPTY(&sc->hs_free_list)) {
reqp = LIST_FIRST(&sc->hs_free_list);		reqp = LIST_FIRST(&sc->hs_free_list);
LIST_REMOVE(reqp, link);		LIST_REMOVE(reqp, link);
		bus_dmamap_destroy(sc->storvsc_req_dtag, reqp->data_dmap);
free(reqp, M_DEVBUF);		free(reqp, M_DEVBUF);
}		}
mtx_unlock(&sc->hs_lock);		mtx_unlock(&sc->hs_lock);

while (!LIST_EMPTY(&g_hv_sgl_page_pool.free_sgl_list)) {		while (!LIST_EMPTY(&g_hv_sgl_page_pool.free_sgl_list)) {
sgl_node = LIST_FIRST(&g_hv_sgl_page_pool.free_sgl_list);		sgl_node = LIST_FIRST(&g_hv_sgl_page_pool.free_sgl_list);
LIST_REMOVE(sgl_node, link);		LIST_REMOVE(sgl_node, link);
for (j = 0; j < VMBUS_CHAN_PRPLIST_MAX; j++){		for (j = 0; j < STORVSC_DATA_SEGCNT_MAX; j++){
if (NULL !=		if (NULL !=
(void*)sgl_node->sgl_data->sg_segs[j].ss_paddr) {		(void*)sgl_node->sgl_data->sg_segs[j].ss_paddr) {
free((void*)sgl_node->sgl_data->sg_segs[j].ss_paddr, M_DEVBUF);		free((void*)sgl_node->sgl_data->sg_segs[j].ss_paddr, M_DEVBUF);
}		}
}		}
sglist_free(sgl_node->sgl_data);		sglist_free(sgl_node->sgl_data);
free(sgl_node, M_DEVBUF);		free(sgl_node, M_DEVBUF);
}		}
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines	storvsc_action(struct cam_sim sim, union ccb ccb)
switch (ccb->ccb_h.func_code) {		switch (ccb->ccb_h.func_code) {
case XPT_PATH_INQ: {		case XPT_PATH_INQ: {
struct ccb_pathinq *cpi = &ccb->cpi;		struct ccb_pathinq *cpi = &ccb->cpi;

cpi->version_num = 1;		cpi->version_num = 1;
cpi->hba_inquiry = PI_TAG_ABLE\|PI_SDTR_ABLE;		cpi->hba_inquiry = PI_TAG_ABLE\|PI_SDTR_ABLE;
cpi->target_sprt = 0;		cpi->target_sprt = 0;
cpi->hba_misc = PIM_NOBUSRESET;		cpi->hba_misc = PIM_NOBUSRESET;
		if (hv_storvsc_use_pim_unmapped)
		cpi->hba_misc \|= PIM_UNMAPPED;
cpi->hba_eng_cnt = 0;		cpi->hba_eng_cnt = 0;
cpi->max_target = STORVSC_MAX_TARGETS;		cpi->max_target = STORVSC_MAX_TARGETS;
cpi->max_lun = sc->hs_drv_props->drv_max_luns_per_target;		cpi->max_lun = sc->hs_drv_props->drv_max_luns_per_target;
cpi->initiator_id = cpi->max_target;		cpi->initiator_id = cpi->max_target;
cpi->bus_id = cam_sim_bus(sim);		cpi->bus_id = cam_sim_bus(sim);
cpi->base_transfer_speed = 300000;		cpi->base_transfer_speed = 300000;
cpi->transport = XPORT_SAS;		cpi->transport = XPORT_SAS;
cpi->transport_version = 0;		cpi->transport_version = 0;
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines	#else
ccb->ccb_h.status = CAM_REQ_INVALID;		ccb->ccb_h.status = CAM_REQ_INVALID;
xpt_done(ccb);		xpt_done(ccb);
return;		return;
#endif /* HVS_HOST_RESET */		#endif /* HVS_HOST_RESET */
}		}
case XPT_SCSI_IO:		case XPT_SCSI_IO:
case XPT_IMMED_NOTIFY: {		case XPT_IMMED_NOTIFY: {
struct hv_storvsc_request *reqp = NULL;		struct hv_storvsc_request *reqp = NULL;
		bus_dmamap_t dmap_saved;

if (ccb->csio.cdb_len == 0) {		if (ccb->csio.cdb_len == 0) {
panic("cdl_len is 0\n");		panic("cdl_len is 0\n");
}		}

if (LIST_EMPTY(&sc->hs_free_list)) {		if (LIST_EMPTY(&sc->hs_free_list)) {
ccb->ccb_h.status = CAM_REQUEUE_REQ;		ccb->ccb_h.status = CAM_REQUEUE_REQ;
if (sc->hs_frozen == 0) {		if (sc->hs_frozen == 0) {
sc->hs_frozen = 1;		sc->hs_frozen = 1;
xpt_freeze_simq(sim, /* count*/1);		xpt_freeze_simq(sim, /* count*/1);
}		}
xpt_done(ccb);		xpt_done(ccb);
return;		return;
}		}

reqp = LIST_FIRST(&sc->hs_free_list);		reqp = LIST_FIRST(&sc->hs_free_list);
LIST_REMOVE(reqp, link);		LIST_REMOVE(reqp, link);

		/* Save the data_dmap before reset request */
		dmap_saved = reqp->data_dmap;

		/* XXX this is ugly */
bzero(reqp, sizeof(struct hv_storvsc_request));		bzero(reqp, sizeof(struct hv_storvsc_request));

		/* Restore necessary bits */
		reqp->data_dmap = dmap_saved;
reqp->softc = sc;		reqp->softc = sc;

ccb->ccb_h.status \|= CAM_SIM_QUEUED;		ccb->ccb_h.status \|= CAM_SIM_QUEUED;
if ((res = create_storvsc_request(ccb, reqp)) != 0) {		if ((res = create_storvsc_request(ccb, reqp)) != 0) {
ccb->ccb_h.status = CAM_REQ_INVALID;		ccb->ccb_h.status = CAM_REQ_INVALID;
xpt_done(ccb);		xpt_done(ccb);
return;		return;
}		}
▲ Show 20 Lines • Show All 239 Lines • ▼ Show 20 Lines	if (!found_hole) {
return (-1);		return (-1);
} else {		} else {
*bits = tmp_bits;		*bits = tmp_bits;
return 0;		return 0;
}		}
}		}

/**		/**
		* Copy bus_dma segments to multiple page buffer, which requires
		* the pages are compact composed except for the 1st and last pages.
		*/
		static void
		storvsc_xferbuf_prepare(void arg, bus_dma_segment_t segs, int nsegs, int error)
		{
		struct hv_storvsc_request *reqp = arg;
		union ccb *ccb = reqp->ccb;
		struct ccb_scsiio *csio = &ccb->csio;
		struct storvsc_gpa_range *prplist;
		int i;

		prplist = &reqp->prp_list;
		prplist->gpa_range.gpa_len = csio->dxfer_len;
		prplist->gpa_range.gpa_ofs = segs[0].ds_addr & PAGE_MASK;

		for (i = 0; i < nsegs; i++) {
		prplist->gpa_page[i] = atop(segs[i].ds_addr);
		#ifdef INVARIANTS
		if (i != 0 && i != nsegs - 1) {
		KASSERT((segs[i].ds_addr & PAGE_MASK) == 0 &&
		segs[i].ds_len == PAGE_SIZE, ("not a full page"));
		}
		#endif
		}
		reqp->prp_cnt = nsegs;
		}

		/**
* @brief Fill in a request structure based on a CAM control block		* @brief Fill in a request structure based on a CAM control block
*		*
* Fills in a request structure based on the contents of a CAM control		* Fills in a request structure based on the contents of a CAM control
* block. The request structure holds the payload information for		* block. The request structure holds the payload information for
* VSCSI protocol request.		* VSCSI protocol request.
*		*
* @param ccb pointer to a CAM contorl block		* @param ccb pointer to a CAM contorl block
* @param reqp pointer to a request structure		* @param reqp pointer to a request structure
*/		*/
static int		static int
create_storvsc_request(union ccb ccb, struct hv_storvsc_request reqp)		create_storvsc_request(union ccb ccb, struct hv_storvsc_request reqp)
{		{
struct ccb_scsiio *csio = &ccb->csio;		struct ccb_scsiio *csio = &ccb->csio;
uint64_t phys_addr;		uint64_t phys_addr;
uint32_t bytes_to_copy = 0;
uint32_t pfn_num = 0;
uint32_t pfn;		uint32_t pfn;
uint64_t not_aligned_seg_bits = 0;		uint64_t not_aligned_seg_bits = 0;
struct hvs_gpa_range *prplist;		int error;

/* refer to struct vmscsi_req for meanings of these two fields */		/* refer to struct vmscsi_req for meanings of these two fields */
reqp->vstor_packet.u.vm_srb.port =		reqp->vstor_packet.u.vm_srb.port =
cam_sim_unit(xpt_path_sim(ccb->ccb_h.path));		cam_sim_unit(xpt_path_sim(ccb->ccb_h.path));
reqp->vstor_packet.u.vm_srb.path_id =		reqp->vstor_packet.u.vm_srb.path_id =
cam_sim_bus(xpt_path_sim(ccb->ccb_h.path));		cam_sim_bus(xpt_path_sim(ccb->ccb_h.path));

reqp->vstor_packet.u.vm_srb.target_id = ccb->ccb_h.target_id;		reqp->vstor_packet.u.vm_srb.target_id = ccb->ccb_h.target_id;
Show All 27 Lines	create_storvsc_request(union ccb ccb, struct hv_storvsc_request reqp)
reqp->sense_info_len = csio->sense_len;		reqp->sense_info_len = csio->sense_len;

reqp->ccb = ccb;		reqp->ccb = ccb;

if (0 == csio->dxfer_len) {		if (0 == csio->dxfer_len) {
return (0);		return (0);
}		}

prplist = &reqp->prp_list;
prplist->gpa_range.gpa_len = csio->dxfer_len;

switch (ccb->ccb_h.flags & CAM_DATA_MASK) {		switch (ccb->ccb_h.flags & CAM_DATA_MASK) {
		case CAM_DATA_BIO:
case CAM_DATA_VADDR:		case CAM_DATA_VADDR:
{		error = bus_dmamap_load_ccb(reqp->softc->storvsc_req_dtag,
bytes_to_copy = csio->dxfer_len;		reqp->data_dmap, ccb, storvsc_xferbuf_prepare, reqp,
phys_addr = vtophys(csio->data_ptr);		BUS_DMA_NOWAIT);
prplist->gpa_range.gpa_ofs = phys_addr & PAGE_MASK;		if (error) {
		xpt_print(ccb->ccb_h.path,
while (bytes_to_copy != 0) {		"bus_dmamap_load_ccb failed: %d\n", error);
int bytes, page_offset;		return (error);
phys_addr =
vtophys(&csio->data_ptr[prplist->gpa_range.gpa_len -
bytes_to_copy]);
pfn = phys_addr >> PAGE_SHIFT;
prplist->gpa_page[pfn_num] = pfn;
page_offset = phys_addr & PAGE_MASK;

bytes = min(PAGE_SIZE - page_offset, bytes_to_copy);

bytes_to_copy -= bytes;
pfn_num++;
}		}
reqp->prp_cnt = pfn_num;		if ((ccb->ccb_h.flags & CAM_DATA_MASK) == CAM_DATA_BIO)
		reqp->softc->sysctl_data.data_bio_cnt++;
		else
		reqp->softc->sysctl_data.data_vaddr_cnt++;
break;		break;
}

case CAM_DATA_SG:		case CAM_DATA_SG:
{		{
		struct storvsc_gpa_range *prplist;
int i = 0;		int i = 0;
int offset = 0;		int offset = 0;
int ret;		int ret;

bus_dma_segment_t *storvsc_sglist =		bus_dma_segment_t *storvsc_sglist =
(bus_dma_segment_t *)ccb->csio.data_ptr;		(bus_dma_segment_t *)ccb->csio.data_ptr;
u_int16_t storvsc_sg_count = ccb->csio.sglist_cnt;		u_int16_t storvsc_sg_count = ccb->csio.sglist_cnt;

		prplist = &reqp->prp_list;
		prplist->gpa_range.gpa_len = csio->dxfer_len;

printf("Storvsc: get SG I/O operation, %d\n",		printf("Storvsc: get SG I/O operation, %d\n",
reqp->vstor_packet.u.vm_srb.data_in);		reqp->vstor_packet.u.vm_srb.data_in);

if (storvsc_sg_count > VMBUS_CHAN_PRPLIST_MAX){		if (storvsc_sg_count > STORVSC_DATA_SEGCNT_MAX){
printf("Storvsc: %d segments is too much, "		printf("Storvsc: %d segments is too much, "
"only support %d segments\n",		"only support %d segments\n",
storvsc_sg_count, VMBUS_CHAN_PRPLIST_MAX);		storvsc_sg_count, STORVSC_DATA_SEGCNT_MAX);
return (EINVAL);		return (EINVAL);
}		}

/*		/*
* We create our own bounce buffer function currently. Idealy		* We create our own bounce buffer function currently. Idealy
* we should use BUS_DMA(9) framework. But with current BUS_DMA		* we should use BUS_DMA(9) framework. But with current BUS_DMA
* code there is no callback API to check the page alignment of		* code there is no callback API to check the page alignment of
* middle segments before busdma can decide if a bounce buffer		* middle segments before busdma can decide if a bounce buffer
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines	if (ret != -1) {
PAGE_SIZE - offset);		PAGE_SIZE - offset);
pfn = phys_addr >> PAGE_SHIFT;		pfn = phys_addr >> PAGE_SHIFT;
prplist->gpa_page[i] = pfn;		prplist->gpa_page[i] = pfn;
reqp->prp_cnt++;		reqp->prp_cnt++;
}		}

reqp->bounce_sgl_count = 0;		reqp->bounce_sgl_count = 0;
}		}
		reqp->softc->sysctl_data.data_sg_cnt++;
break;		break;
}		}
default:		default:
printf("Unknow flags: %d\n", ccb->ccb_h.flags);		printf("Unknow flags: %d\n", ccb->ccb_h.flags);
return(EINVAL);		return(EINVAL);
}		}

return(0);		return(0);
▲ Show 20 Lines • Show All 227 Lines • Show Last 20 Lines