Date: Fri, 31 May 2013 21:05:07 +0000 (UTC) From: "Justin T. Gibbs" <gibbs@FreeBSD.org> To: src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-head@freebsd.org Subject: svn commit: r251195 - head/sys/dev/xen/blkfront Message-ID: <201305312105.r4VL57mw064171@svn.freebsd.org>
next in thread | raw e-mail | index | archive | help
Author: gibbs Date: Fri May 31 21:05:07 2013 New Revision: 251195 URL: http://svnweb.freebsd.org/changeset/base/251195 Log: Style cleanups. No intended functional changes. o This driver is the "xbd" driver, not the "blkfront", "blkif", "xbf", or "xb" driver. Use the "xbd_" naming conventions for all functions, structures, and constants. o The prevailing convention for structure fields in this driver is to prefix them with an abreviation of the structure type. Update "recently added" fields to match this style. o Remove unused data structures. o Remove superfluous casts. o Make a pass over the whole driver and bring it closer to style(9) conformance. Sponsored by: Spectra Logic Corporation MFC after: 1 week Modified: head/sys/dev/xen/blkfront/blkfront.c head/sys/dev/xen/blkfront/block.h Modified: head/sys/dev/xen/blkfront/blkfront.c ============================================================================== --- head/sys/dev/xen/blkfront/blkfront.c Fri May 31 20:46:08 2013 (r251194) +++ head/sys/dev/xen/blkfront/blkfront.c Fri May 31 21:05:07 2013 (r251195) @@ -1,6 +1,7 @@ /* * XenBSD block device driver * + * Copyright (c) 2010-2013 Spectra Logic Corporation * Copyright (c) 2009 Scott Long, Yahoo! * Copyright (c) 2009 Frank Suchomel, Citrix * Copyright (c) 2009 Doug F. Rabson, Citrix @@ -70,17 +71,17 @@ __FBSDID("$FreeBSD$"); #include "xenbus_if.h" /* prototypes */ -static void xb_free_command(struct xb_command *cm); -static void xb_startio(struct xb_softc *sc); -static void blkfront_connect(struct xb_softc *); -static void blkfront_closing(device_t); -static int blkfront_detach(device_t); -static int setup_blkring(struct xb_softc *); -static void blkif_int(void *); -static void blkfront_initialize(struct xb_softc *); -static int blkif_completion(struct xb_command *); -static void blkif_free(struct xb_softc *); -static void blkif_queue_cb(void *, bus_dma_segment_t *, int, int); +static void xbd_free_command(struct xbd_command *cm); +static void xbd_startio(struct xbd_softc *sc); +static void xbd_connect(struct xbd_softc *); +static void xbd_closing(device_t); +static int xbd_detach(device_t); +static int xbd_setup_ring(struct xbd_softc *); +static void xbd_int(void *); +static void xbd_initialize(struct xbd_softc *); +static int xbd_completion(struct xbd_command *); +static void xbd_free(struct xbd_softc *); +static void xbd_queue_cb(void *, bus_dma_segment_t *, int, int); static MALLOC_DEFINE(M_XENBLOCKFRONT, "xbd", "Xen Block Front driver data"); @@ -93,18 +94,18 @@ static MALLOC_DEFINE(M_XENBLOCKFRONT, "x static void vbd_update(void); #endif -#define BLKIF_STATE_DISCONNECTED 0 -#define BLKIF_STATE_CONNECTED 1 -#define BLKIF_STATE_SUSPENDED 2 +#define XBD_STATE_DISCONNECTED 0 +#define XBD_STATE_CONNECTED 1 +#define XBD_STATE_SUSPENDED 2 #ifdef notyet -static char *blkif_state_name[] = { - [BLKIF_STATE_DISCONNECTED] = "disconnected", - [BLKIF_STATE_CONNECTED] = "connected", - [BLKIF_STATE_SUSPENDED] = "closed", +static char *xbd_state_name[] = { + [XBD_STATE_DISCONNECTED] = "disconnected", + [XBD_STATE_CONNECTED] = "connected", + [XBD_STATE_SUSPENDED] = "closed", }; -static char * blkif_status_name[] = { +static char * xbd_status_name[] = { [BLKIF_INTERFACE_STATUS_CLOSED] = "closed", [BLKIF_INTERFACE_STATUS_DISCONNECTED] = "disconnected", [BLKIF_INTERFACE_STATUS_CONNECTED] = "connected", @@ -118,17 +119,17 @@ static char * blkif_status_name[] = { #define DPRINTK(fmt, args...) #endif -static int blkif_open(struct disk *dp); -static int blkif_close(struct disk *dp); -static int blkif_ioctl(struct disk *dp, u_long cmd, void *addr, int flag, struct thread *td); -static int blkif_queue_request(struct xb_softc *sc, struct xb_command *cm); -static void xb_strategy(struct bio *bp); +static int xbd_open(struct disk *dp); +static int xbd_close(struct disk *dp); +static int xbd_ioctl(struct disk *dp, u_long cmd, void *addr, int flag, struct thread *td); +static int xbd_queue_request(struct xbd_softc *sc, struct xbd_command *cm); +static void xbd_strategy(struct bio *bp); // In order to quiesce the device during kernel dumps, outstanding requests to // DOM0 for disk reads/writes need to be accounted for. -static int xb_dump(void *, void *, vm_offset_t, off_t, size_t); +static int xbd_dump(void *, void *, vm_offset_t, off_t, size_t); -/* XXX move to xb_vbd.c when VBD update support is added */ +/* XXX move to xbd_vbd.c when VBD update support is added */ #define MAX_VBDS 64 #define XBD_SECTOR_SIZE 512 /* XXX: assume for now */ @@ -140,7 +141,7 @@ static int xb_dump(void *, void *, vm_of * with blkfront as the emulated drives, easing transition slightly. */ static void -blkfront_vdevice_to_unit(uint32_t vdevice, int *unit, const char **name) +xbd_vdevice_to_unit(uint32_t vdevice, int *unit, const char **name) { static struct vdev_info { int major; @@ -203,34 +204,34 @@ blkfront_vdevice_to_unit(uint32_t vdevic } int -xlvbd_add(struct xb_softc *sc, blkif_sector_t sectors, +xbd_instance_create(struct xbd_softc *sc, blkif_sector_t sectors, int vdevice, uint16_t vdisk_info, unsigned long sector_size) { - int unit, error = 0; + int unit, error = 0; const char *name; - blkfront_vdevice_to_unit(vdevice, &unit, &name); + xbd_vdevice_to_unit(vdevice, &unit, &name); - sc->xb_unit = unit; + sc->xbd_unit = unit; if (strcmp(name, "xbd")) - device_printf(sc->xb_dev, "attaching as %s%d\n", name, unit); + device_printf(sc->xbd_dev, "attaching as %s%d\n", name, unit); - sc->xb_disk = disk_alloc(); - sc->xb_disk->d_unit = sc->xb_unit; - sc->xb_disk->d_open = blkif_open; - sc->xb_disk->d_close = blkif_close; - sc->xb_disk->d_ioctl = blkif_ioctl; - sc->xb_disk->d_strategy = xb_strategy; - sc->xb_disk->d_dump = xb_dump; - sc->xb_disk->d_name = name; - sc->xb_disk->d_drv1 = sc; - sc->xb_disk->d_sectorsize = sector_size; - - sc->xb_disk->d_mediasize = sectors * sector_size; - sc->xb_disk->d_maxsize = sc->max_request_size; - sc->xb_disk->d_flags = 0; - disk_create(sc->xb_disk, DISK_VERSION); + sc->xbd_disk = disk_alloc(); + sc->xbd_disk->d_unit = sc->xbd_unit; + sc->xbd_disk->d_open = xbd_open; + sc->xbd_disk->d_close = xbd_close; + sc->xbd_disk->d_ioctl = xbd_ioctl; + sc->xbd_disk->d_strategy = xbd_strategy; + sc->xbd_disk->d_dump = xbd_dump; + sc->xbd_disk->d_name = name; + sc->xbd_disk->d_drv1 = sc; + sc->xbd_disk->d_sectorsize = sector_size; + + sc->xbd_disk->d_mediasize = sectors * sector_size; + sc->xbd_disk->d_maxsize = sc->xbd_max_request_size; + sc->xbd_disk->d_flags = 0; + disk_create(sc->xbd_disk, DISK_VERSION); return error; } @@ -242,9 +243,9 @@ xlvbd_add(struct xb_softc *sc, blkif_sec * the sortq and kick the controller. */ static void -xb_strategy(struct bio *bp) +xbd_strategy(struct bio *bp) { - struct xb_softc *sc = (struct xb_softc *)bp->bio_disk->d_drv1; + struct xbd_softc *sc = bp->bio_disk->d_drv1; /* bogus disk? */ if (sc == NULL) { @@ -258,25 +259,25 @@ xb_strategy(struct bio *bp) /* * Place it in the queue of disk activities for this disk */ - mtx_lock(&sc->xb_io_lock); + mtx_lock(&sc->xbd_io_lock); - xb_enqueue_bio(sc, bp); - xb_startio(sc); + xbd_enqueue_bio(sc, bp); + xbd_startio(sc); - mtx_unlock(&sc->xb_io_lock); + mtx_unlock(&sc->xbd_io_lock); return; } static void -xb_bio_complete(struct xb_softc *sc, struct xb_command *cm) +xbd_bio_complete(struct xbd_softc *sc, struct xbd_command *cm) { struct bio *bp; - bp = cm->bp; + bp = cm->cm_bp; - if ( unlikely(cm->status != BLKIF_RSP_OKAY) ) { + if (unlikely(cm->cm_status != BLKIF_RSP_OKAY)) { disk_err(bp, "disk error" , -1, 0); - printf(" status: %x\n", cm->status); + printf(" status: %x\n", cm->cm_status); bp->bio_flags |= BIO_ERROR; } @@ -285,24 +286,24 @@ xb_bio_complete(struct xb_softc *sc, str else bp->bio_resid = 0; - xb_free_command(cm); + xbd_free_command(cm); biodone(bp); } // Quiesce the disk writes for a dump file before allowing the next buffer. static void -xb_quiesce(struct xb_softc *sc) +xbd_quiesce(struct xbd_softc *sc) { - int mtd; + int mtd; // While there are outstanding requests - while (!TAILQ_EMPTY(&sc->cm_busy)) { - RING_FINAL_CHECK_FOR_RESPONSES(&sc->ring, mtd); + while (!TAILQ_EMPTY(&sc->xbd_cm_busy)) { + RING_FINAL_CHECK_FOR_RESPONSES(&sc->xbd_ring, mtd); if (mtd) { /* Recieved request completions, update queue. */ - blkif_int(sc); + xbd_int(sc); } - if (!TAILQ_EMPTY(&sc->cm_busy)) { + if (!TAILQ_EMPTY(&sc->xbd_cm_busy)) { /* * Still pending requests, wait for the disk i/o * to complete. @@ -314,60 +315,60 @@ xb_quiesce(struct xb_softc *sc) /* Kernel dump function for a paravirtualized disk device */ static void -xb_dump_complete(struct xb_command *cm) +xbd_dump_complete(struct xbd_command *cm) { - xb_enqueue_complete(cm); + xbd_enqueue_complete(cm); } static int -xb_dump(void *arg, void *virtual, vm_offset_t physical, off_t offset, - size_t length) +xbd_dump(void *arg, void *virtual, vm_offset_t physical, off_t offset, + size_t length) { - struct disk *dp = arg; - struct xb_softc *sc = (struct xb_softc *) dp->d_drv1; - struct xb_command *cm; - size_t chunk; - int sbp; - int rc = 0; + struct disk *dp = arg; + struct xbd_softc *sc = dp->d_drv1; + struct xbd_command *cm; + size_t chunk; + int sbp; + int rc = 0; if (length <= 0) return (rc); - xb_quiesce(sc); /* All quiet on the western front. */ + xbd_quiesce(sc); /* All quiet on the western front. */ /* * If this lock is held, then this module is failing, and a * successful kernel dump is highly unlikely anyway. */ - mtx_lock(&sc->xb_io_lock); + mtx_lock(&sc->xbd_io_lock); /* Split the 64KB block as needed */ for (sbp=0; length > 0; sbp++) { - cm = xb_dequeue_free(sc); + cm = xbd_dequeue_free(sc); if (cm == NULL) { - mtx_unlock(&sc->xb_io_lock); - device_printf(sc->xb_dev, "dump: no more commands?\n"); + mtx_unlock(&sc->xbd_io_lock); + device_printf(sc->xbd_dev, "dump: no more commands?\n"); return (EBUSY); } - if (gnttab_alloc_grant_references(sc->max_request_segments, - &cm->gref_head) != 0) { - xb_free_command(cm); - mtx_unlock(&sc->xb_io_lock); - device_printf(sc->xb_dev, "no more grant allocs?\n"); + if (gnttab_alloc_grant_references(sc->xbd_max_request_segments, + &cm->cm_gref_head) != 0) { + xbd_free_command(cm); + mtx_unlock(&sc->xbd_io_lock); + device_printf(sc->xbd_dev, "no more grant allocs?\n"); return (EBUSY); } - chunk = length > sc->max_request_size - ? sc->max_request_size : length; - cm->data = virtual; - cm->datalen = chunk; - cm->operation = BLKIF_OP_WRITE; - cm->sector_number = offset / dp->d_sectorsize; - cm->cm_complete = xb_dump_complete; + chunk = length > sc->xbd_max_request_size ? + sc->xbd_max_request_size : length; + cm->cm_data = virtual; + cm->cm_datalen = chunk; + cm->cm_operation = BLKIF_OP_WRITE; + cm->cm_sector_number = offset / dp->d_sectorsize; + cm->cm_complete = xbd_dump_complete; - xb_enqueue_ready(cm); + xbd_enqueue_ready(cm); length -= chunk; offset += chunk; @@ -375,21 +376,21 @@ xb_dump(void *arg, void *virtual, vm_off } /* Tell DOM0 to do the I/O */ - xb_startio(sc); - mtx_unlock(&sc->xb_io_lock); + xbd_startio(sc); + mtx_unlock(&sc->xbd_io_lock); /* Poll for the completion. */ - xb_quiesce(sc); /* All quite on the eastern front */ + xbd_quiesce(sc); /* All quite on the eastern front */ /* If there were any errors, bail out... */ - while ((cm = xb_dequeue_complete(sc)) != NULL) { - if (cm->status != BLKIF_RSP_OKAY) { - device_printf(sc->xb_dev, + while ((cm = xbd_dequeue_complete(sc)) != NULL) { + if (cm->cm_status != BLKIF_RSP_OKAY) { + device_printf(sc->xbd_dev, "Dump I/O failed at sector %jd\n", - cm->sector_number); + cm->cm_sector_number); rc = EIO; } - xb_free_command(cm); + xbd_free_command(cm); } return (rc); @@ -397,7 +398,7 @@ xb_dump(void *arg, void *virtual, vm_off static int -blkfront_probe(device_t dev) +xbd_probe(device_t dev) { if (!strcmp(xenbus_get_type(dev), "vbd")) { @@ -410,37 +411,35 @@ blkfront_probe(device_t dev) } static void -xb_setup_sysctl(struct xb_softc *xb) +xbd_setup_sysctl(struct xbd_softc *xbd) { struct sysctl_ctx_list *sysctl_ctx = NULL; - struct sysctl_oid *sysctl_tree = NULL; + struct sysctl_oid *sysctl_tree = NULL; - sysctl_ctx = device_get_sysctl_ctx(xb->xb_dev); + sysctl_ctx = device_get_sysctl_ctx(xbd->xbd_dev); if (sysctl_ctx == NULL) return; - sysctl_tree = device_get_sysctl_tree(xb->xb_dev); + sysctl_tree = device_get_sysctl_tree(xbd->xbd_dev); if (sysctl_tree == NULL) return; SYSCTL_ADD_UINT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO, - "max_requests", CTLFLAG_RD, &xb->max_requests, -1, - "maximum outstanding requests (negotiated)"); + "max_requests", CTLFLAG_RD, &xbd->xbd_max_requests, -1, + "maximum outstanding requests (negotiated)"); SYSCTL_ADD_UINT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO, - "max_request_segments", CTLFLAG_RD, - &xb->max_request_segments, 0, - "maximum number of pages per requests (negotiated)"); + "max_request_segments", CTLFLAG_RD, + &xbd->xbd_max_request_segments, 0, + "maximum number of pages per requests (negotiated)"); SYSCTL_ADD_UINT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO, - "max_request_size", CTLFLAG_RD, - &xb->max_request_size, 0, - "maximum size in bytes of a request (negotiated)"); + "max_request_size", CTLFLAG_RD, &xbd->xbd_max_request_size, 0, + "maximum size in bytes of a request (negotiated)"); SYSCTL_ADD_UINT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO, - "ring_pages", CTLFLAG_RD, - &xb->ring_pages, 0, - "communication channel pages (negotiated)"); + "ring_pages", CTLFLAG_RD, &xbd->xbd_ring_pages, 0, + "communication channel pages (negotiated)"); } /* @@ -449,9 +448,9 @@ xb_setup_sysctl(struct xb_softc *xb) * ok. */ static int -blkfront_attach(device_t dev) +xbd_attach(device_t dev) { - struct xb_softc *sc; + struct xbd_softc *sc; const char *name; uint32_t vdevice; int error; @@ -467,25 +466,25 @@ blkfront_attach(device_t dev) return (error); } - blkfront_vdevice_to_unit(vdevice, &unit, &name); + xbd_vdevice_to_unit(vdevice, &unit, &name); if (!strcmp(name, "xbd")) device_set_unit(dev, unit); sc = device_get_softc(dev); - mtx_init(&sc->xb_io_lock, "blkfront i/o lock", NULL, MTX_DEF); - xb_initq_free(sc); - xb_initq_busy(sc); - xb_initq_ready(sc); - xb_initq_complete(sc); - xb_initq_bio(sc); - for (i = 0; i < XBF_MAX_RING_PAGES; i++) - sc->ring_ref[i] = GRANT_INVALID_REF; - - sc->xb_dev = dev; - sc->vdevice = vdevice; - sc->connected = BLKIF_STATE_DISCONNECTED; + mtx_init(&sc->xbd_io_lock, "blkfront i/o lock", NULL, MTX_DEF); + xbd_initq_free(sc); + xbd_initq_busy(sc); + xbd_initq_ready(sc); + xbd_initq_complete(sc); + xbd_initq_bio(sc); + for (i = 0; i < XBD_MAX_RING_PAGES; i++) + sc->xbd_ring_ref[i] = GRANT_INVALID_REF; + + sc->xbd_dev = dev; + sc->xbd_vdevice = vdevice; + sc->xbd_connected = XBD_STATE_DISCONNECTED; - xb_setup_sysctl(sc); + xbd_setup_sysctl(sc); /* Wait for backend device to publish its protocol capabilities. */ xenbus_set_state(dev, XenbusStateInitialising); @@ -494,48 +493,48 @@ blkfront_attach(device_t dev) } static int -blkfront_suspend(device_t dev) +xbd_suspend(device_t dev) { - struct xb_softc *sc = device_get_softc(dev); + struct xbd_softc *sc = device_get_softc(dev); int retval; int saved_state; /* Prevent new requests being issued until we fix things up. */ - mtx_lock(&sc->xb_io_lock); - saved_state = sc->connected; - sc->connected = BLKIF_STATE_SUSPENDED; + mtx_lock(&sc->xbd_io_lock); + saved_state = sc->xbd_connected; + sc->xbd_connected = XBD_STATE_SUSPENDED; /* Wait for outstanding I/O to drain. */ retval = 0; - while (TAILQ_EMPTY(&sc->cm_busy) == 0) { - if (msleep(&sc->cm_busy, &sc->xb_io_lock, - PRIBIO, "blkf_susp", 30 * hz) == EWOULDBLOCK) { + while (TAILQ_EMPTY(&sc->xbd_cm_busy) == 0) { + if (msleep(&sc->xbd_cm_busy, &sc->xbd_io_lock, + PRIBIO, "blkf_susp", 30 * hz) == EWOULDBLOCK) { retval = EBUSY; break; } } - mtx_unlock(&sc->xb_io_lock); + mtx_unlock(&sc->xbd_io_lock); if (retval != 0) - sc->connected = saved_state; + sc->xbd_connected = saved_state; return (retval); } static int -blkfront_resume(device_t dev) +xbd_resume(device_t dev) { - struct xb_softc *sc = device_get_softc(dev); + struct xbd_softc *sc = device_get_softc(dev); - DPRINTK("blkfront_resume: %s\n", xenbus_get_node(dev)); + DPRINTK("xbd_resume: %s\n", xenbus_get_node(dev)); - blkif_free(sc); - blkfront_initialize(sc); + xbd_free(sc); + xbd_initialize(sc); return (0); } static void -blkfront_initialize(struct xb_softc *sc) +xbd_initialize(struct xbd_softc *sc) { const char *otherend_path; const char *node_path; @@ -543,7 +542,7 @@ blkfront_initialize(struct xb_softc *sc) int error; int i; - if (xenbus_get_state(sc->xb_dev) != XenbusStateInitialising) { + if (xenbus_get_state(sc->xbd_dev) != XenbusStateInitialising) { /* Initialization has already been performed. */ return; } @@ -553,10 +552,12 @@ blkfront_initialize(struct xb_softc *sc) * setting fails. */ max_ring_page_order = 0; - sc->ring_pages = 1; - sc->max_request_segments = BLKIF_MAX_SEGMENTS_PER_HEADER_BLOCK; - sc->max_request_size = XBF_SEGS_TO_SIZE(sc->max_request_segments); - sc->max_request_blocks = BLKIF_SEGS_TO_BLOCKS(sc->max_request_segments); + sc->xbd_ring_pages = 1; + sc->xbd_max_request_segments = BLKIF_MAX_SEGMENTS_PER_HEADER_BLOCK; + sc->xbd_max_request_size = + XBD_SEGS_TO_SIZE(sc->xbd_max_request_segments); + sc->xbd_max_request_blocks = + BLKIF_SEGS_TO_BLOCKS(sc->xbd_max_request_segments); /* * Protocol negotiation. @@ -569,266 +570,279 @@ blkfront_initialize(struct xb_softc *sc) * \note xs_scanf() does not update variables for unmatched * fields. */ - otherend_path = xenbus_get_otherend_path(sc->xb_dev); - node_path = xenbus_get_node(sc->xb_dev); + otherend_path = xenbus_get_otherend_path(sc->xbd_dev); + node_path = xenbus_get_node(sc->xbd_dev); /* Support both backend schemes for relaying ring page limits. */ (void)xs_scanf(XST_NIL, otherend_path, - "max-ring-page-order", NULL, "%" PRIu32, - &max_ring_page_order); - sc->ring_pages = 1 << max_ring_page_order; + "max-ring-page-order", NULL, "%" PRIu32, + &max_ring_page_order); + sc->xbd_ring_pages = 1 << max_ring_page_order; (void)xs_scanf(XST_NIL, otherend_path, - "max-ring-pages", NULL, "%" PRIu32, - &sc->ring_pages); - if (sc->ring_pages < 1) - sc->ring_pages = 1; + "max-ring-pages", NULL, "%" PRIu32, + &sc->xbd_ring_pages); + if (sc->xbd_ring_pages < 1) + sc->xbd_ring_pages = 1; - sc->max_requests = BLKIF_MAX_RING_REQUESTS(sc->ring_pages * PAGE_SIZE); + sc->xbd_max_requests = + BLKIF_MAX_RING_REQUESTS(sc->xbd_ring_pages * PAGE_SIZE); (void)xs_scanf(XST_NIL, otherend_path, - "max-requests", NULL, "%" PRIu32, - &sc->max_requests); + "max-requests", NULL, "%" PRIu32, + &sc->xbd_max_requests); (void)xs_scanf(XST_NIL, otherend_path, - "max-request-segments", NULL, "%" PRIu32, - &sc->max_request_segments); + "max-request-segments", NULL, "%" PRIu32, + &sc->xbd_max_request_segments); (void)xs_scanf(XST_NIL, otherend_path, - "max-request-size", NULL, "%" PRIu32, - &sc->max_request_size); + "max-request-size", NULL, "%" PRIu32, + &sc->xbd_max_request_size); - if (sc->ring_pages > XBF_MAX_RING_PAGES) { - device_printf(sc->xb_dev, "Back-end specified ring-pages of " - "%u limited to front-end limit of %zu.\n", - sc->ring_pages, XBF_MAX_RING_PAGES); - sc->ring_pages = XBF_MAX_RING_PAGES; + if (sc->xbd_ring_pages > XBD_MAX_RING_PAGES) { + device_printf(sc->xbd_dev, + "Back-end specified ring-pages of %u " + "limited to front-end limit of %zu.\n", + sc->xbd_ring_pages, XBD_MAX_RING_PAGES); + sc->xbd_ring_pages = XBD_MAX_RING_PAGES; } - if (powerof2(sc->ring_pages) == 0) { + if (powerof2(sc->xbd_ring_pages) == 0) { uint32_t new_page_limit; - new_page_limit = 0x01 << (fls(sc->ring_pages) - 1); - device_printf(sc->xb_dev, "Back-end specified ring-pages of " - "%u is not a power of 2. Limited to %u.\n", - sc->ring_pages, new_page_limit); - sc->ring_pages = new_page_limit; - } - - if (sc->max_requests > XBF_MAX_REQUESTS) { - device_printf(sc->xb_dev, "Back-end specified max_requests of " - "%u limited to front-end limit of %u.\n", - sc->max_requests, XBF_MAX_REQUESTS); - sc->max_requests = XBF_MAX_REQUESTS; - } - - if (sc->max_request_segments > XBF_MAX_SEGMENTS_PER_REQUEST) { - device_printf(sc->xb_dev, "Back-end specified " - "max_request_segments of %u limited to " - "front-end limit of %u.\n", - sc->max_request_segments, - XBF_MAX_SEGMENTS_PER_REQUEST); - sc->max_request_segments = XBF_MAX_SEGMENTS_PER_REQUEST; - } - - if (sc->max_request_size > XBF_MAX_REQUEST_SIZE) { - device_printf(sc->xb_dev, "Back-end specified " - "max_request_size of %u limited to front-end " - "limit of %u.\n", sc->max_request_size, - XBF_MAX_REQUEST_SIZE); - sc->max_request_size = XBF_MAX_REQUEST_SIZE; + new_page_limit = 0x01 << (fls(sc->xbd_ring_pages) - 1); + device_printf(sc->xbd_dev, + "Back-end specified ring-pages of %u " + "is not a power of 2. Limited to %u.\n", + sc->xbd_ring_pages, new_page_limit); + sc->xbd_ring_pages = new_page_limit; + } + + if (sc->xbd_max_requests > XBD_MAX_REQUESTS) { + device_printf(sc->xbd_dev, + "Back-end specified max_requests of %u " + "limited to front-end limit of %u.\n", + sc->xbd_max_requests, XBD_MAX_REQUESTS); + sc->xbd_max_requests = XBD_MAX_REQUESTS; + } + + if (sc->xbd_max_request_segments > XBD_MAX_SEGMENTS_PER_REQUEST) { + device_printf(sc->xbd_dev, + "Back-end specified max_request_segments of %u " + "limited to front-end limit of %u.\n", + sc->xbd_max_request_segments, + XBD_MAX_SEGMENTS_PER_REQUEST); + sc->xbd_max_request_segments = XBD_MAX_SEGMENTS_PER_REQUEST; + } + + if (sc->xbd_max_request_size > XBD_MAX_REQUEST_SIZE) { + device_printf(sc->xbd_dev, + "Back-end specified max_request_size of %u " + "limited to front-end limit of %u.\n", + sc->xbd_max_request_size, + XBD_MAX_REQUEST_SIZE); + sc->xbd_max_request_size = XBD_MAX_REQUEST_SIZE; } - if (sc->max_request_size > XBF_SEGS_TO_SIZE(sc->max_request_segments)) { - device_printf(sc->xb_dev, "Back-end specified " - "max_request_size of %u limited to front-end " - "limit of %u. (Too few segments.)\n", - sc->max_request_size, - XBF_SEGS_TO_SIZE(sc->max_request_segments)); - sc->max_request_size = - XBF_SEGS_TO_SIZE(sc->max_request_segments); + if (sc->xbd_max_request_size > + XBD_SEGS_TO_SIZE(sc->xbd_max_request_segments)) { + device_printf(sc->xbd_dev, + "Back-end specified max_request_size of %u " + "limited to front-end limit of %u. (Too few segments.)\n", + sc->xbd_max_request_size, + XBD_SEGS_TO_SIZE(sc->xbd_max_request_segments)); + sc->xbd_max_request_size = + XBD_SEGS_TO_SIZE(sc->xbd_max_request_segments); } - sc->max_request_blocks = BLKIF_SEGS_TO_BLOCKS(sc->max_request_segments); + sc->xbd_max_request_blocks = + BLKIF_SEGS_TO_BLOCKS(sc->xbd_max_request_segments); /* Allocate datastructures based on negotiated values. */ - error = bus_dma_tag_create(bus_get_dma_tag(sc->xb_dev), /* parent */ - 512, PAGE_SIZE, /* algnmnt, boundary */ - BUS_SPACE_MAXADDR, /* lowaddr */ - BUS_SPACE_MAXADDR, /* highaddr */ - NULL, NULL, /* filter, filterarg */ - sc->max_request_size, - sc->max_request_segments, - PAGE_SIZE, /* maxsegsize */ - BUS_DMA_ALLOCNOW, /* flags */ - busdma_lock_mutex, /* lockfunc */ - &sc->xb_io_lock, /* lockarg */ - &sc->xb_io_dmat); + error = bus_dma_tag_create( + bus_get_dma_tag(sc->xbd_dev), /* parent */ + 512, PAGE_SIZE, /* algnmnt, boundary */ + BUS_SPACE_MAXADDR, /* lowaddr */ + BUS_SPACE_MAXADDR, /* highaddr */ + NULL, NULL, /* filter, filterarg */ + sc->xbd_max_request_size, + sc->xbd_max_request_segments, + PAGE_SIZE, /* maxsegsize */ + BUS_DMA_ALLOCNOW, /* flags */ + busdma_lock_mutex, /* lockfunc */ + &sc->xbd_io_lock, /* lockarg */ + &sc->xbd_io_dmat); if (error != 0) { - xenbus_dev_fatal(sc->xb_dev, error, - "Cannot allocate parent DMA tag\n"); + xenbus_dev_fatal(sc->xbd_dev, error, + "Cannot allocate parent DMA tag\n"); return; } /* Per-transaction data allocation. */ - sc->shadow = malloc(sizeof(*sc->shadow) * sc->max_requests, - M_XENBLOCKFRONT, M_NOWAIT|M_ZERO); - if (sc->shadow == NULL) { - bus_dma_tag_destroy(sc->xb_io_dmat); - xenbus_dev_fatal(sc->xb_dev, error, - "Cannot allocate request structures\n"); + sc->xbd_shadow = malloc(sizeof(*sc->xbd_shadow) * sc->xbd_max_requests, + M_XENBLOCKFRONT, M_NOWAIT|M_ZERO); + if (sc->xbd_shadow == NULL) { + bus_dma_tag_destroy(sc->xbd_io_dmat); + xenbus_dev_fatal(sc->xbd_dev, error, + "Cannot allocate request structures\n"); return; } - for (i = 0; i < sc->max_requests; i++) { - struct xb_command *cm; + for (i = 0; i < sc->xbd_max_requests; i++) { + struct xbd_command *cm; - cm = &sc->shadow[i]; - cm->sg_refs = malloc(sizeof(grant_ref_t) - * sc->max_request_segments, - M_XENBLOCKFRONT, M_NOWAIT); - if (cm->sg_refs == NULL) + cm = &sc->xbd_shadow[i]; + cm->cm_sg_refs = malloc( + sizeof(grant_ref_t) * sc->xbd_max_request_segments, + M_XENBLOCKFRONT, M_NOWAIT); + if (cm->cm_sg_refs == NULL) break; - cm->id = i; + cm->cm_id = i; cm->cm_sc = sc; - if (bus_dmamap_create(sc->xb_io_dmat, 0, &cm->map) != 0) + if (bus_dmamap_create(sc->xbd_io_dmat, 0, &cm->cm_map) != 0) break; - xb_free_command(cm); + xbd_free_command(cm); } - if (setup_blkring(sc) != 0) + if (xbd_setup_ring(sc) != 0) return; /* Support both backend schemes for relaying ring page limits. */ - if (sc->ring_pages > 1) { + if (sc->xbd_ring_pages > 1) { error = xs_printf(XST_NIL, node_path, - "num-ring-pages","%u", sc->ring_pages); + "num-ring-pages","%u", + sc->xbd_ring_pages); if (error) { - xenbus_dev_fatal(sc->xb_dev, error, - "writing %s/num-ring-pages", - node_path); + xenbus_dev_fatal(sc->xbd_dev, error, + "writing %s/num-ring-pages", + node_path); return; } error = xs_printf(XST_NIL, node_path, - "ring-page-order", "%u", - fls(sc->ring_pages) - 1); + "ring-page-order", "%u", + fls(sc->xbd_ring_pages) - 1); if (error) { - xenbus_dev_fatal(sc->xb_dev, error, - "writing %s/ring-page-order", - node_path); + xenbus_dev_fatal(sc->xbd_dev, error, + "writing %s/ring-page-order", + node_path); return; } } error = xs_printf(XST_NIL, node_path, - "max-requests","%u", sc->max_requests); + "max-requests","%u", + sc->xbd_max_requests); if (error) { - xenbus_dev_fatal(sc->xb_dev, error, - "writing %s/max-requests", - node_path); + xenbus_dev_fatal(sc->xbd_dev, error, + "writing %s/max-requests", + node_path); return; } error = xs_printf(XST_NIL, node_path, - "max-request-segments","%u", sc->max_request_segments); + "max-request-segments","%u", + sc->xbd_max_request_segments); if (error) { - xenbus_dev_fatal(sc->xb_dev, error, - "writing %s/max-request-segments", - node_path); + xenbus_dev_fatal(sc->xbd_dev, error, + "writing %s/max-request-segments", + node_path); return; } error = xs_printf(XST_NIL, node_path, - "max-request-size","%u", sc->max_request_size); + "max-request-size","%u", + sc->xbd_max_request_size); if (error) { - xenbus_dev_fatal(sc->xb_dev, error, - "writing %s/max-request-size", - node_path); + xenbus_dev_fatal(sc->xbd_dev, error, + "writing %s/max-request-size", + node_path); return; } error = xs_printf(XST_NIL, node_path, "event-channel", - "%u", irq_to_evtchn_port(sc->irq)); + "%u", irq_to_evtchn_port(sc->xbd_irq)); if (error) { - xenbus_dev_fatal(sc->xb_dev, error, - "writing %s/event-channel", - node_path); + xenbus_dev_fatal(sc->xbd_dev, error, + "writing %s/event-channel", + node_path); return; } - error = xs_printf(XST_NIL, node_path, - "protocol", "%s", XEN_IO_PROTO_ABI_NATIVE); + error = xs_printf(XST_NIL, node_path, "protocol", + "%s", XEN_IO_PROTO_ABI_NATIVE); if (error) { - xenbus_dev_fatal(sc->xb_dev, error, - "writing %s/protocol", - node_path); + xenbus_dev_fatal(sc->xbd_dev, error, + "writing %s/protocol", + node_path); return; } - xenbus_set_state(sc->xb_dev, XenbusStateInitialised); + xenbus_set_state(sc->xbd_dev, XenbusStateInitialised); } static int -setup_blkring(struct xb_softc *sc) +xbd_setup_ring(struct xbd_softc *sc) { blkif_sring_t *sring; uintptr_t sring_page_addr; int error; int i; - sring = malloc(sc->ring_pages * PAGE_SIZE, M_XENBLOCKFRONT, - M_NOWAIT|M_ZERO); + sring = malloc(sc->xbd_ring_pages * PAGE_SIZE, M_XENBLOCKFRONT, + M_NOWAIT|M_ZERO); if (sring == NULL) { - xenbus_dev_fatal(sc->xb_dev, ENOMEM, "allocating shared ring"); + xenbus_dev_fatal(sc->xbd_dev, ENOMEM, "allocating shared ring"); return (ENOMEM); } SHARED_RING_INIT(sring); - FRONT_RING_INIT(&sc->ring, sring, sc->ring_pages * PAGE_SIZE); + FRONT_RING_INIT(&sc->xbd_ring, sring, sc->xbd_ring_pages * PAGE_SIZE); for (i = 0, sring_page_addr = (uintptr_t)sring; - i < sc->ring_pages; + i < sc->xbd_ring_pages; i++, sring_page_addr += PAGE_SIZE) { - error = xenbus_grant_ring(sc->xb_dev, - (vtomach(sring_page_addr) >> PAGE_SHIFT), &sc->ring_ref[i]); + error = xenbus_grant_ring(sc->xbd_dev, + (vtomach(sring_page_addr) >> PAGE_SHIFT), + &sc->xbd_ring_ref[i]); if (error) { - xenbus_dev_fatal(sc->xb_dev, error, - "granting ring_ref(%d)", i); + xenbus_dev_fatal(sc->xbd_dev, error, + "granting ring_ref(%d)", i); return (error); } } - if (sc->ring_pages == 1) { - error = xs_printf(XST_NIL, xenbus_get_node(sc->xb_dev), - "ring-ref", "%u", sc->ring_ref[0]); + if (sc->xbd_ring_pages == 1) { + error = xs_printf(XST_NIL, xenbus_get_node(sc->xbd_dev), + "ring-ref", "%u", sc->xbd_ring_ref[0]); if (error) { - xenbus_dev_fatal(sc->xb_dev, error, - "writing %s/ring-ref", - xenbus_get_node(sc->xb_dev)); + xenbus_dev_fatal(sc->xbd_dev, error, + "writing %s/ring-ref", + xenbus_get_node(sc->xbd_dev)); return (error); } } else { - for (i = 0; i < sc->ring_pages; i++) { + for (i = 0; i < sc->xbd_ring_pages; i++) { char ring_ref_name[]= "ring_refXX"; snprintf(ring_ref_name, sizeof(ring_ref_name), - "ring-ref%u", i); - error = xs_printf(XST_NIL, xenbus_get_node(sc->xb_dev), - ring_ref_name, "%u", sc->ring_ref[i]); + "ring-ref%u", i); + error = xs_printf(XST_NIL, xenbus_get_node(sc->xbd_dev), + ring_ref_name, "%u", sc->xbd_ring_ref[i]); if (error) { - xenbus_dev_fatal(sc->xb_dev, error, - "writing %s/%s", - xenbus_get_node(sc->xb_dev), - ring_ref_name); + xenbus_dev_fatal(sc->xbd_dev, error, + "writing %s/%s", + xenbus_get_node(sc->xbd_dev), + ring_ref_name); return (error); } } } error = bind_listening_port_to_irqhandler( - xenbus_get_otherend_id(sc->xb_dev), - "xbd", (driver_intr_t *)blkif_int, sc, - INTR_TYPE_BIO | INTR_MPSAFE, &sc->irq); + xenbus_get_otherend_id(sc->xbd_dev), + "xbd", (driver_intr_t *)xbd_int, sc, + INTR_TYPE_BIO | INTR_MPSAFE, &sc->xbd_irq); if (error) { - xenbus_dev_fatal(sc->xb_dev, error, + xenbus_dev_fatal(sc->xbd_dev, error, "bind_evtchn_to_irqhandler failed"); return (error); } @@ -840,9 +854,9 @@ setup_blkring(struct xb_softc *sc) * Callback received when the backend's state changes. */ static void -blkfront_backend_changed(device_t dev, XenbusState backend_state) +xbd_backend_changed(device_t dev, XenbusState backend_state) { - struct xb_softc *sc = device_get_softc(dev); + struct xbd_softc *sc = device_get_softc(dev); DPRINTK("backend_state=%d\n", backend_state); @@ -856,47 +870,47 @@ blkfront_backend_changed(device_t dev, X *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201305312105.r4VL57mw064171>