/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2009 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * xdf.c - Xen Virtual Block Device Driver * TODO: * - support alternate block size (currently only DEV_BSIZE supported) * - revalidate geometry for removable devices * * This driver export solaris disk device nodes, accepts IO requests from * those nodes, and services those requests by talking to a backend device * in another domain. * * Communication with the backend device is done via a ringbuffer (which is * managed via xvdi interfaces) and dma memory (which is managed via ddi * interfaces). * * Communication with the backend device is dependant upon establishing a * connection to the backend device. This connection process involves * reading device configuration information from xenbus and publishing * some frontend runtime configuration parameters via the xenbus (for * consumption by the backend). Once we've published runtime configuration * information via the xenbus, the backend device can enter the connected * state and we'll enter the XD_CONNECTED state. But before we can allow * random IO to begin, we need to do IO to the backend device to determine * the device label and if flush operations are supported. Once this is * done we enter the XD_READY state and can process any IO operations. * * We recieve notifications of xenbus state changes for the backend device * (aka, the "other end") via the xdf_oe_change() callback. This callback * is single threaded, meaning that we can't recieve new notification of * other end state changes while we're processing an outstanding * notification of an other end state change. There for we can't do any * blocking operations from the xdf_oe_change() callback. This is why we * have a seperate taskq (xdf_ready_tq) which exists to do the necessary * IO to get us from the XD_CONNECTED to the XD_READY state. All IO * generated by the xdf_ready_tq thread (xdf_ready_tq_thread) will go * throught xdf_lb_rdwr(), which is a synchronous IO interface. IOs * generated by the xdf_ready_tq_thread thread have priority over all * other IO requests. * * We also communicate with the backend device via the xenbus "media-req" * (XBP_MEDIA_REQ) property. For more information on this see the * comments in blkif.h. */ #include #include #include #include #include #include #include #ifdef XPV_HVM_DRIVER #include #include #else /* !XPV_HVM_DRIVER */ #include #endif /* !XPV_HVM_DRIVER */ #include #include #include #include #include #include /* * DEBUG_EVAL can be used to include debug only statements without * having to use '#ifdef DEBUG' statements */ #ifdef DEBUG #define DEBUG_EVAL(x) (x) #else /* !DEBUG */ #define DEBUG_EVAL(x) #endif /* !DEBUG */ #define XDF_DRAIN_MSEC_DELAY (50*1000) /* 00.05 sec */ #define XDF_DRAIN_RETRY_COUNT 200 /* 10.00 sec */ #define INVALID_DOMID ((domid_t)-1) #define FLUSH_DISKCACHE 0x1 #define WRITE_BARRIER 0x2 #define DEFAULT_FLUSH_BLOCK 156 /* block to write to cause a cache flush */ #define USE_WRITE_BARRIER(vdp) \ ((vdp)->xdf_feature_barrier && !(vdp)->xdf_flush_supported) #define USE_FLUSH_DISKCACHE(vdp) \ ((vdp)->xdf_feature_barrier && (vdp)->xdf_flush_supported) #define IS_WRITE_BARRIER(vdp, bp) \ (!IS_READ(bp) && USE_WRITE_BARRIER(vdp) && \ ((bp)->b_un.b_addr == (vdp)->xdf_cache_flush_block)) #define IS_FLUSH_DISKCACHE(bp) \ (!IS_READ(bp) && USE_FLUSH_DISKCACHE(vdp) && ((bp)->b_bcount == 0)) #define VREQ_DONE(vreq) \ VOID2BOOLEAN(((vreq)->v_status == VREQ_DMAWIN_DONE) && \ (((vreq)->v_flush_diskcache == FLUSH_DISKCACHE) || \ (((vreq)->v_dmaw + 1) == (vreq)->v_ndmaws))) #define BP_VREQ(bp) ((v_req_t *)((bp)->av_back)) #define BP_VREQ_SET(bp, vreq) (((bp)->av_back = (buf_t *)(vreq))) extern int do_polled_io; /* run-time tunables that we don't want the compiler to optimize away */ volatile int xdf_debug = 0; volatile boolean_t xdf_barrier_flush_disable = B_FALSE; /* per module globals */ major_t xdf_major; static void *xdf_ssp; static kmem_cache_t *xdf_vreq_cache; static kmem_cache_t *xdf_gs_cache; static int xdf_maxphys = XB_MAXPHYS; static diskaddr_t xdf_flush_block = DEFAULT_FLUSH_BLOCK; static int xdf_fbrewrites; /* flush block re-write count */ /* misc public functions (used by xdf_shell.c) */ int xdf_lb_rdwr(dev_info_t *, uchar_t, void *, diskaddr_t, size_t, void *); int xdf_lb_getinfo(dev_info_t *, int, void *, void *); /* misc private functions */ static void xdf_io_start(xdf_t *); /* callbacks from commmon label */ static cmlb_tg_ops_t xdf_lb_ops = { TG_DK_OPS_VERSION_1, xdf_lb_rdwr, xdf_lb_getinfo }; /* * I/O buffer DMA attributes * Make sure: one DMA window contains BLKIF_MAX_SEGMENTS_PER_REQUEST at most */ static ddi_dma_attr_t xb_dma_attr = { DMA_ATTR_V0, (uint64_t)0, /* lowest address */ (uint64_t)0xffffffffffffffff, /* highest usable address */ (uint64_t)0xffffff, /* DMA counter limit max */ (uint64_t)XB_BSIZE, /* alignment in bytes */ XB_BSIZE - 1, /* bitmap of burst sizes */ XB_BSIZE, /* min transfer */ (uint64_t)XB_MAX_XFER, /* maximum transfer */ (uint64_t)PAGEOFFSET, /* 1 page segment length */ BLKIF_MAX_SEGMENTS_PER_REQUEST, /* maximum number of segments */ XB_BSIZE, /* granularity */ 0, /* flags (reserved) */ }; static ddi_device_acc_attr_t xc_acc_attr = { DDI_DEVICE_ATTR_V0, DDI_NEVERSWAP_ACC, DDI_STRICTORDER_ACC }; static void xdf_timeout_handler(void *arg) { xdf_t *vdp = arg; mutex_enter(&vdp->xdf_dev_lk); vdp->xdf_timeout_id = 0; mutex_exit(&vdp->xdf_dev_lk); /* new timeout thread could be re-scheduled */ xdf_io_start(vdp); } /* * callback func when DMA/GTE resources is available * * Note: we only register one callback function to grant table subsystem * since we only have one 'struct gnttab_free_callback' in xdf_t. */ static int xdf_dmacallback(caddr_t arg) { xdf_t *vdp = (xdf_t *)arg; ASSERT(vdp != NULL); DPRINTF(DMA_DBG, ("xdf@%s: DMA callback started\n", vdp->xdf_addr)); ddi_trigger_softintr(vdp->xdf_softintr_id); return (DDI_DMA_CALLBACK_DONE); } static ge_slot_t * gs_get(xdf_t *vdp, int isread) { grant_ref_t gh; ge_slot_t *gs; /* try to alloc GTEs needed in this slot, first */ if (gnttab_alloc_grant_references( BLKIF_MAX_SEGMENTS_PER_REQUEST, &gh) == -1) { if (vdp->xdf_gnt_callback.next == NULL) { SETDMACBON(vdp); gnttab_request_free_callback( &vdp->xdf_gnt_callback, (void (*)(void *))xdf_dmacallback, (void *)vdp, BLKIF_MAX_SEGMENTS_PER_REQUEST); } return (NULL); } gs = kmem_cache_alloc(xdf_gs_cache, KM_NOSLEEP); if (gs == NULL) { gnttab_free_grant_references(gh); if (vdp->xdf_timeout_id == 0) /* restart I/O after one second */ vdp->xdf_timeout_id = timeout(xdf_timeout_handler, vdp, hz); return (NULL); } /* init gs_slot */ gs->gs_oeid = vdp->xdf_peer; gs->gs_isread = isread; gs->gs_ghead = gh; gs->gs_ngrefs = 0; return (gs); } static void gs_free(ge_slot_t *gs) { int i; /* release all grant table entry resources used in this slot */ for (i = 0; i < gs->gs_ngrefs; i++) gnttab_end_foreign_access(gs->gs_ge[i], !gs->gs_isread, 0); gnttab_free_grant_references(gs->gs_ghead); list_remove(&gs->gs_vreq->v_gs, gs); kmem_cache_free(xdf_gs_cache, gs); } static grant_ref_t gs_grant(ge_slot_t *gs, mfn_t mfn) { grant_ref_t gr = gnttab_claim_grant_reference(&gs->gs_ghead); ASSERT(gr != -1); ASSERT(gs->gs_ngrefs < BLKIF_MAX_SEGMENTS_PER_REQUEST); gs->gs_ge[gs->gs_ngrefs++] = gr; gnttab_grant_foreign_access_ref(gr, gs->gs_oeid, mfn, !gs->gs_isread); return (gr); } /* * Alloc a vreq for this bp * bp->av_back contains the pointer to the vreq upon return */ static v_req_t * vreq_get(xdf_t *vdp, buf_t *bp) { v_req_t *vreq = NULL; ASSERT(BP_VREQ(bp) == NULL); vreq = kmem_cache_alloc(xdf_vreq_cache, KM_NOSLEEP); if (vreq == NULL) { if (vdp->xdf_timeout_id == 0) /* restart I/O after one second */ vdp->xdf_timeout_id = timeout(xdf_timeout_handler, vdp, hz); return (NULL); } bzero(vreq, sizeof (v_req_t)); list_create(&vreq->v_gs, sizeof (ge_slot_t), offsetof(ge_slot_t, gs_vreq_link)); vreq->v_buf = bp; vreq->v_status = VREQ_INIT; vreq->v_runq = B_FALSE; BP_VREQ_SET(bp, vreq); /* init of other fields in vreq is up to the caller */ list_insert_head(&vdp->xdf_vreq_act, (void *)vreq); return (vreq); } static void vreq_free(xdf_t *vdp, v_req_t *vreq) { buf_t *bp = vreq->v_buf; ASSERT(MUTEX_HELD(&vdp->xdf_dev_lk)); ASSERT(BP_VREQ(bp) == vreq); list_remove(&vdp->xdf_vreq_act, vreq); if (vreq->v_flush_diskcache == FLUSH_DISKCACHE) goto done; switch (vreq->v_status) { case VREQ_DMAWIN_DONE: case VREQ_GS_ALLOCED: case VREQ_DMABUF_BOUND: (void) ddi_dma_unbind_handle(vreq->v_dmahdl); /*FALLTHRU*/ case VREQ_DMAMEM_ALLOCED: if (!ALIGNED_XFER(bp)) { ASSERT(vreq->v_abuf != NULL); if (!IS_ERROR(bp) && IS_READ(bp)) bcopy(vreq->v_abuf, bp->b_un.b_addr, bp->b_bcount); ddi_dma_mem_free(&vreq->v_align); } /*FALLTHRU*/ case VREQ_MEMDMAHDL_ALLOCED: if (!ALIGNED_XFER(bp)) ddi_dma_free_handle(&vreq->v_memdmahdl); /*FALLTHRU*/ case VREQ_DMAHDL_ALLOCED: ddi_dma_free_handle(&vreq->v_dmahdl); break; default: break; } done: ASSERT(!vreq->v_runq); list_destroy(&vreq->v_gs); kmem_cache_free(xdf_vreq_cache, vreq); } /* * Snarf new data if our flush block was re-written */ static void check_fbwrite(xdf_t *vdp, buf_t *bp, daddr_t blkno) { int nblks; boolean_t mapin; if (IS_WRITE_BARRIER(vdp, bp)) return; /* write was a flush write */ mapin = B_FALSE; nblks = bp->b_bcount >> DEV_BSHIFT; if (xdf_flush_block >= blkno && xdf_flush_block < (blkno + nblks)) { xdf_fbrewrites++; if (bp->b_flags & (B_PAGEIO | B_PHYS)) { mapin = B_TRUE; bp_mapin(bp); } bcopy(bp->b_un.b_addr + ((xdf_flush_block - blkno) << DEV_BSHIFT), vdp->xdf_cache_flush_block, DEV_BSIZE); if (mapin) bp_mapout(bp); } } /* * Initalize the DMA and grant table resources for the buf */ static int vreq_setup(xdf_t *vdp, v_req_t *vreq) { int rc; ddi_dma_attr_t dmaattr; uint_t ndcs, ndws; ddi_dma_handle_t dh; ddi_dma_handle_t mdh; ddi_dma_cookie_t dc; ddi_acc_handle_t abh; caddr_t aba; ge_slot_t *gs; size_t bufsz; off_t off; size_t sz; buf_t *bp = vreq->v_buf; int dma_flags = (IS_READ(bp) ? DDI_DMA_READ : DDI_DMA_WRITE) | DDI_DMA_STREAMING | DDI_DMA_PARTIAL; switch (vreq->v_status) { case VREQ_INIT: if (IS_FLUSH_DISKCACHE(bp)) { if ((gs = gs_get(vdp, IS_READ(bp))) == NULL) { DPRINTF(DMA_DBG, ("xdf@%s: " "get ge_slotfailed\n", vdp->xdf_addr)); return (DDI_FAILURE); } vreq->v_blkno = 0; vreq->v_nslots = 1; vreq->v_flush_diskcache = FLUSH_DISKCACHE; vreq->v_status = VREQ_GS_ALLOCED; gs->gs_vreq = vreq; list_insert_head(&vreq->v_gs, gs); return (DDI_SUCCESS); } if (IS_WRITE_BARRIER(vdp, bp)) vreq->v_flush_diskcache = WRITE_BARRIER; vreq->v_blkno = bp->b_blkno + (diskaddr_t)(uintptr_t)bp->b_private; /* See if we wrote new data to our flush block */ if (!IS_READ(bp) && USE_WRITE_BARRIER(vdp)) check_fbwrite(vdp, bp, vreq->v_blkno); vreq->v_status = VREQ_INIT_DONE; /*FALLTHRU*/ case VREQ_INIT_DONE: /* * alloc DMA handle */ rc = ddi_dma_alloc_handle(vdp->xdf_dip, &xb_dma_attr, xdf_dmacallback, (caddr_t)vdp, &dh); if (rc != DDI_SUCCESS) { SETDMACBON(vdp); DPRINTF(DMA_DBG, ("xdf@%s: DMA handle alloc failed\n", vdp->xdf_addr)); return (DDI_FAILURE); } vreq->v_dmahdl = dh; vreq->v_status = VREQ_DMAHDL_ALLOCED; /*FALLTHRU*/ case VREQ_DMAHDL_ALLOCED: /* * alloc dma handle for 512-byte aligned buf */ if (!ALIGNED_XFER(bp)) { /* * XXPV: we need to temporarily enlarge the seg * boundary and s/g length to work round CR6381968 */ dmaattr = xb_dma_attr; dmaattr.dma_attr_seg = (uint64_t)-1; dmaattr.dma_attr_sgllen = INT_MAX; rc = ddi_dma_alloc_handle(vdp->xdf_dip, &dmaattr, xdf_dmacallback, (caddr_t)vdp, &mdh); if (rc != DDI_SUCCESS) { SETDMACBON(vdp); DPRINTF(DMA_DBG, ("xdf@%s: " "unaligned buf DMAhandle alloc failed\n", vdp->xdf_addr)); return (DDI_FAILURE); } vreq->v_memdmahdl = mdh; vreq->v_status = VREQ_MEMDMAHDL_ALLOCED; } /*FALLTHRU*/ case VREQ_MEMDMAHDL_ALLOCED: /* * alloc 512-byte aligned buf */ if (!ALIGNED_XFER(bp)) { if (bp->b_flags & (B_PAGEIO | B_PHYS)) bp_mapin(bp); rc = ddi_dma_mem_alloc(vreq->v_memdmahdl, roundup(bp->b_bcount, XB_BSIZE), &xc_acc_attr, DDI_DMA_STREAMING, xdf_dmacallback, (caddr_t)vdp, &aba, &bufsz, &abh); if (rc != DDI_SUCCESS) { SETDMACBON(vdp); DPRINTF(DMA_DBG, ("xdf@%s: " "DMA mem allocation failed\n", vdp->xdf_addr)); return (DDI_FAILURE); } vreq->v_abuf = aba; vreq->v_align = abh; vreq->v_status = VREQ_DMAMEM_ALLOCED; ASSERT(bufsz >= bp->b_bcount); if (!IS_READ(bp)) bcopy(bp->b_un.b_addr, vreq->v_abuf, bp->b_bcount); } /*FALLTHRU*/ case VREQ_DMAMEM_ALLOCED: /* * dma bind */ if (ALIGNED_XFER(bp)) { rc = ddi_dma_buf_bind_handle(vreq->v_dmahdl, bp, dma_flags, xdf_dmacallback, (caddr_t)vdp, &dc, &ndcs); } else { rc = ddi_dma_addr_bind_handle(vreq->v_dmahdl, NULL, vreq->v_abuf, bp->b_bcount, dma_flags, xdf_dmacallback, (caddr_t)vdp, &dc, &ndcs); } if (rc == DDI_DMA_MAPPED || rc == DDI_DMA_PARTIAL_MAP) { /* get num of dma windows */ if (rc == DDI_DMA_PARTIAL_MAP) { rc = ddi_dma_numwin(vreq->v_dmahdl, &ndws); ASSERT(rc == DDI_SUCCESS); } else { ndws = 1; } } else { SETDMACBON(vdp); DPRINTF(DMA_DBG, ("xdf@%s: DMA bind failed\n", vdp->xdf_addr)); return (DDI_FAILURE); } vreq->v_dmac = dc; vreq->v_dmaw = 0; vreq->v_ndmacs = ndcs; vreq->v_ndmaws = ndws; vreq->v_nslots = ndws; vreq->v_status = VREQ_DMABUF_BOUND; /*FALLTHRU*/ case VREQ_DMABUF_BOUND: /* * get ge_slot, callback is set upon failure from gs_get(), * if not set previously */ if ((gs = gs_get(vdp, IS_READ(bp))) == NULL) { DPRINTF(DMA_DBG, ("xdf@%s: get ge_slot failed\n", vdp->xdf_addr)); return (DDI_FAILURE); } vreq->v_status = VREQ_GS_ALLOCED; gs->gs_vreq = vreq; list_insert_head(&vreq->v_gs, gs); break; case VREQ_GS_ALLOCED: /* nothing need to be done */ break; case VREQ_DMAWIN_DONE: /* * move to the next dma window */ ASSERT((vreq->v_dmaw + 1) < vreq->v_ndmaws); /* get a ge_slot for this DMA window */ if ((gs = gs_get(vdp, IS_READ(bp))) == NULL) { DPRINTF(DMA_DBG, ("xdf@%s: get ge_slot failed\n", vdp->xdf_addr)); return (DDI_FAILURE); } vreq->v_dmaw++; VERIFY(ddi_dma_getwin(vreq->v_dmahdl, vreq->v_dmaw, &off, &sz, &vreq->v_dmac, &vreq->v_ndmacs) == DDI_SUCCESS); vreq->v_status = VREQ_GS_ALLOCED; gs->gs_vreq = vreq; list_insert_head(&vreq->v_gs, gs); break; default: return (DDI_FAILURE); } return (DDI_SUCCESS); } static int xdf_cmlb_attach(xdf_t *vdp) { dev_info_t *dip = vdp->xdf_dip; return (cmlb_attach(dip, &xdf_lb_ops, XD_IS_CD(vdp) ? DTYPE_RODIRECT : DTYPE_DIRECT, XD_IS_RM(vdp), B_TRUE, XD_IS_CD(vdp) ? DDI_NT_CD_XVMD : DDI_NT_BLOCK_XVMD, #if defined(XPV_HVM_DRIVER) (XD_IS_CD(vdp) ? 0 : CMLB_CREATE_ALTSLICE_VTOC_16_DTYPE_DIRECT) | CMLB_INTERNAL_MINOR_NODES, #else /* !XPV_HVM_DRIVER */ XD_IS_CD(vdp) ? 0 : CMLB_FAKE_LABEL_ONE_PARTITION, #endif /* !XPV_HVM_DRIVER */ vdp->xdf_vd_lbl, NULL)); } static void xdf_io_err(buf_t *bp, int err, size_t resid) { bioerror(bp, err); if (resid == 0) bp->b_resid = bp->b_bcount; biodone(bp); } static void xdf_kstat_enter(xdf_t *vdp, buf_t *bp) { v_req_t *vreq = BP_VREQ(bp); ASSERT(MUTEX_HELD(&vdp->xdf_dev_lk)); if (vdp->xdf_xdev_iostat == NULL) return; if ((vreq != NULL) && vreq->v_runq) { kstat_runq_enter(KSTAT_IO_PTR(vdp->xdf_xdev_iostat)); } else { kstat_waitq_enter(KSTAT_IO_PTR(vdp->xdf_xdev_iostat)); } } static void xdf_kstat_exit(xdf_t *vdp, buf_t *bp) { v_req_t *vreq = BP_VREQ(bp); ASSERT(MUTEX_HELD(&vdp->xdf_dev_lk)); if (vdp->xdf_xdev_iostat == NULL) return; if ((vreq != NULL) && vreq->v_runq) { kstat_runq_exit(KSTAT_IO_PTR(vdp->xdf_xdev_iostat)); } else { kstat_waitq_exit(KSTAT_IO_PTR(vdp->xdf_xdev_iostat)); } } static void xdf_kstat_waitq_to_runq(xdf_t *vdp, buf_t *bp) { v_req_t *vreq = BP_VREQ(bp); ASSERT(MUTEX_HELD(&vdp->xdf_dev_lk)); ASSERT(!vreq->v_runq); vreq->v_runq = B_TRUE; if (vdp->xdf_xdev_iostat == NULL) return; kstat_waitq_to_runq(KSTAT_IO_PTR(vdp->xdf_xdev_iostat)); } static void xdf_kstat_runq_to_waitq(xdf_t *vdp, buf_t *bp) { v_req_t *vreq = BP_VREQ(bp); ASSERT(MUTEX_HELD(&vdp->xdf_dev_lk)); ASSERT(vreq->v_runq); vreq->v_runq = B_FALSE; if (vdp->xdf_xdev_iostat == NULL) return; kstat_runq_back_to_waitq(KSTAT_IO_PTR(vdp->xdf_xdev_iostat)); } int xdf_kstat_create(dev_info_t *dip, char *ks_module, int instance) { xdf_t *vdp = (xdf_t *)ddi_get_driver_private(dip); kstat_t *kstat; buf_t *bp; if ((kstat = kstat_create( ks_module, instance, NULL, "disk", KSTAT_TYPE_IO, 1, KSTAT_FLAG_PERSISTENT)) == NULL) return (-1); /* See comment about locking in xdf_kstat_delete(). */ mutex_enter(&vdp->xdf_iostat_lk); mutex_enter(&vdp->xdf_dev_lk); /* only one kstat can exist at a time */ if (vdp->xdf_xdev_iostat != NULL) { mutex_exit(&vdp->xdf_dev_lk); mutex_exit(&vdp->xdf_iostat_lk); kstat_delete(kstat); return (-1); } vdp->xdf_xdev_iostat = kstat; vdp->xdf_xdev_iostat->ks_lock = &vdp->xdf_dev_lk; kstat_install(vdp->xdf_xdev_iostat); /* * Now that we've created a kstat, we need to update the waitq and * runq counts for the kstat to reflect our current state. * * For a buf_t structure to be on the runq, it must have a ring * buffer slot associated with it. To get a ring buffer slot the * buf must first have a v_req_t and a ge_slot_t associated with it. * Then when it is granted a ring buffer slot, v_runq will be set to * true. * * For a buf_t structure to be on the waitq, it must not be on the * runq. So to find all the buf_t's that should be on waitq, we * walk the active buf list and add any buf_t's which aren't on the * runq to the waitq. */ bp = vdp->xdf_f_act; while (bp != NULL) { xdf_kstat_enter(vdp, bp); bp = bp->av_forw; } if (vdp->xdf_ready_tq_bp != NULL) xdf_kstat_enter(vdp, vdp->xdf_ready_tq_bp); mutex_exit(&vdp->xdf_dev_lk); mutex_exit(&vdp->xdf_iostat_lk); return (0); } void xdf_kstat_delete(dev_info_t *dip) { xdf_t *vdp = (xdf_t *)ddi_get_driver_private(dip); kstat_t *kstat; buf_t *bp; /* * The locking order here is xdf_iostat_lk and then xdf_dev_lk. * xdf_dev_lk is used to protect the xdf_xdev_iostat pointer * and the contents of the our kstat. xdf_iostat_lk is used * to protect the allocation and freeing of the actual kstat. * xdf_dev_lk can't be used for this purpose because kstat * readers use it to access the contents of the kstat and * hence it can't be held when calling kstat_delete(). */ mutex_enter(&vdp->xdf_iostat_lk); mutex_enter(&vdp->xdf_dev_lk); if (vdp->xdf_xdev_iostat == NULL) { mutex_exit(&vdp->xdf_dev_lk); mutex_exit(&vdp->xdf_iostat_lk); return; } /* * We're about to destroy the kstat structures, so it isn't really * necessary to update the runq and waitq counts. But, since this * isn't a hot code path we can afford to be a little pedantic and * go ahead and decrement the runq and waitq kstat counters to zero * before free'ing them. This helps us ensure that we've gotten all * our accounting correct. * * For an explanation of how we determine which buffers go on the * runq vs which go on the waitq, see the comments in * xdf_kstat_create(). */ bp = vdp->xdf_f_act; while (bp != NULL) { xdf_kstat_exit(vdp, bp); bp = bp->av_forw; } if (vdp->xdf_ready_tq_bp != NULL) xdf_kstat_exit(vdp, vdp->xdf_ready_tq_bp); kstat = vdp->xdf_xdev_iostat; vdp->xdf_xdev_iostat = NULL; mutex_exit(&vdp->xdf_dev_lk); kstat_delete(kstat); mutex_exit(&vdp->xdf_iostat_lk); } /* * Add an IO requests onto the active queue. * * We have to detect IOs generated by xdf_ready_tq_thread. These IOs * are used to establish a connection to the backend, so they recieve * priority over all other IOs. Since xdf_ready_tq_thread only does * synchronous IO, there can only be one xdf_ready_tq_thread request at any * given time and we record the buf associated with that request in * xdf_ready_tq_bp. */ static void xdf_bp_push(xdf_t *vdp, buf_t *bp) { ASSERT(MUTEX_HELD(&vdp->xdf_dev_lk)); ASSERT(bp->av_forw == NULL); xdf_kstat_enter(vdp, bp); if (curthread == vdp->xdf_ready_tq_thread) { /* new IO requests from the ready thread */ ASSERT(vdp->xdf_ready_tq_bp == NULL); vdp->xdf_ready_tq_bp = bp; return; } /* this is normal IO request */ ASSERT(bp != vdp->xdf_ready_tq_bp); if (vdp->xdf_f_act == NULL) { /* this is only only IO on the active queue */ ASSERT(vdp->xdf_l_act == NULL); ASSERT(vdp->xdf_i_act == NULL); vdp->xdf_f_act = vdp->xdf_l_act = vdp->xdf_i_act = bp; return; } /* add this IO to the tail of the active queue */ vdp->xdf_l_act->av_forw = bp; vdp->xdf_l_act = bp; if (vdp->xdf_i_act == NULL) vdp->xdf_i_act = bp; } static void xdf_bp_pop(xdf_t *vdp, buf_t *bp) { buf_t *bp_iter; ASSERT(MUTEX_HELD(&vdp->xdf_dev_lk)); ASSERT(VREQ_DONE(BP_VREQ(bp))); if (vdp->xdf_ready_tq_bp == bp) { /* we're done with a ready thread IO request */ ASSERT(bp->av_forw == NULL); vdp->xdf_ready_tq_bp = NULL; return; } /* we're done with a normal IO request */ ASSERT((bp->av_forw != NULL) || (bp == vdp->xdf_l_act)); ASSERT((bp->av_forw == NULL) || (bp != vdp->xdf_l_act)); ASSERT(VREQ_DONE(BP_VREQ(vdp->xdf_f_act))); ASSERT(vdp->xdf_f_act != vdp->xdf_i_act); if (bp == vdp->xdf_f_act) { /* This IO was at the head of our active queue. */ vdp->xdf_f_act = bp->av_forw; if (bp == vdp->xdf_l_act) vdp->xdf_l_act = NULL; } else { /* There IO finished before some other pending IOs. */ bp_iter = vdp->xdf_f_act; while (bp != bp_iter->av_forw) { bp_iter = bp_iter->av_forw; ASSERT(VREQ_DONE(BP_VREQ(bp_iter))); ASSERT(bp_iter != vdp->xdf_i_act); } bp_iter->av_forw = bp->av_forw; if (bp == vdp->xdf_l_act) vdp->xdf_l_act = bp_iter; } bp->av_forw = NULL; } static buf_t * xdf_bp_next(xdf_t *vdp) { v_req_t *vreq; buf_t *bp; if (vdp->xdf_state == XD_CONNECTED) { /* * If we're in the XD_CONNECTED state, we only service IOs * from the xdf_ready_tq_thread thread. */ if ((bp = vdp->xdf_ready_tq_bp) == NULL) return (NULL); if (((vreq = BP_VREQ(bp)) == NULL) || (!VREQ_DONE(vreq))) return (bp); return (NULL); } /* if we're not in the XD_CONNECTED or XD_READY state we can't do IO */ if (vdp->xdf_state != XD_READY) return (NULL); ASSERT(vdp->xdf_ready_tq_bp == NULL); for (;;) { if ((bp = vdp->xdf_i_act) == NULL) return (NULL); if (((vreq = BP_VREQ(bp)) == NULL) || (!VREQ_DONE(vreq))) return (bp); /* advance the active buf index pointer */ vdp->xdf_i_act = bp->av_forw; } } static void xdf_io_fini(xdf_t *vdp, uint64_t id, int bioerr) { ge_slot_t *gs = (ge_slot_t *)(uintptr_t)id; v_req_t *vreq = gs->gs_vreq; buf_t *bp = vreq->v_buf; ASSERT(MUTEX_HELD(&vdp->xdf_dev_lk)); ASSERT(BP_VREQ(bp) == vreq); gs_free(gs); if (bioerr != 0) bioerror(bp, bioerr); ASSERT(vreq->v_nslots > 0); if (--vreq->v_nslots > 0) return; /* remove this IO from our active queue */ xdf_bp_pop(vdp, bp); ASSERT(vreq->v_runq); xdf_kstat_exit(vdp, bp); vreq->v_runq = B_FALSE; vreq_free(vdp, vreq); if (IS_ERROR(bp)) { xdf_io_err(bp, geterror(bp), 0); } else if (bp->b_resid != 0) { /* Partial transfers are an error */ xdf_io_err(bp, EIO, bp->b_resid); } else { biodone(bp); } } /* * xdf interrupt handler */ static uint_t xdf_intr_locked(xdf_t *vdp) { xendev_ring_t *xbr; blkif_response_t *resp; int bioerr; uint64_t id; uint8_t op; uint16_t status; ddi_acc_handle_t acchdl; ASSERT(MUTEX_HELD(&vdp->xdf_dev_lk)); if ((xbr = vdp->xdf_xb_ring) == NULL) return (DDI_INTR_UNCLAIMED); acchdl = vdp->xdf_xb_ring_hdl; /* * complete all requests which have a response */ while (resp = xvdi_ring_get_response(xbr)) { id = ddi_get64(acchdl, &resp->id); op = ddi_get8(acchdl, &resp->operation); status = ddi_get16(acchdl, (uint16_t *)&resp->status); DPRINTF(INTR_DBG, ("resp: op %d id %"PRIu64" status %d\n", op, id, status)); if (status != BLKIF_RSP_OKAY) { DPRINTF(IO_DBG, ("xdf@%s: I/O error while %s", vdp->xdf_addr, (op == BLKIF_OP_READ) ? "reading" : "writing")); bioerr = EIO; } else { bioerr = 0; } xdf_io_fini(vdp, id, bioerr); } return (DDI_INTR_CLAIMED); } static uint_t xdf_intr(caddr_t arg) { xdf_t *vdp = (xdf_t *)arg; int rv; mutex_enter(&vdp->xdf_dev_lk); rv = xdf_intr_locked(vdp); mutex_exit(&vdp->xdf_dev_lk); if (!do_polled_io) xdf_io_start(vdp); return (rv); } static void xdf_ring_push(xdf_t *vdp) { ASSERT(MUTEX_HELD(&vdp->xdf_dev_lk)); if (vdp->xdf_xb_ring == NULL) return; if (xvdi_ring_push_request(vdp->xdf_xb_ring)) { DPRINTF(IO_DBG, ( "xdf@%s: xdf_ring_push: sent request(s) to backend\n", vdp->xdf_addr)); } if (xvdi_get_evtchn(vdp->xdf_dip) != INVALID_EVTCHN) xvdi_notify_oe(vdp->xdf_dip); } static int xdf_ring_drain_locked(xdf_t *vdp) { int pollc, rv = 0; ASSERT(MUTEX_HELD(&vdp->xdf_dev_lk)); if (xdf_debug & SUSRES_DBG) xen_printf("xdf_ring_drain: start\n"); for (pollc = 0; pollc < XDF_DRAIN_RETRY_COUNT; pollc++) { if (vdp->xdf_xb_ring == NULL) goto out; if (xvdi_ring_has_unconsumed_responses(vdp->xdf_xb_ring)) (void) xdf_intr_locked(vdp); if (!xvdi_ring_has_incomp_request(vdp->xdf_xb_ring)) goto out; xdf_ring_push(vdp); /* file-backed devices can be slow */ mutex_exit(&vdp->xdf_dev_lk); #ifdef XPV_HVM_DRIVER (void) HYPERVISOR_yield(); #endif /* XPV_HVM_DRIVER */ delay(drv_usectohz(XDF_DRAIN_MSEC_DELAY)); mutex_enter(&vdp->xdf_dev_lk); } cmn_err(CE_WARN, "xdf@%s: xdf_ring_drain: timeout", vdp->xdf_addr); out: if (vdp->xdf_xb_ring != NULL) { if (xvdi_ring_has_incomp_request(vdp->xdf_xb_ring) || xvdi_ring_has_unconsumed_responses(vdp->xdf_xb_ring)) rv = EIO; } if (xdf_debug & SUSRES_DBG) xen_printf("xdf@%s: xdf_ring_drain: end, err=%d\n", vdp->xdf_addr, rv); return (rv); } static int xdf_ring_drain(xdf_t *vdp) { int rv; mutex_enter(&vdp->xdf_dev_lk); rv = xdf_ring_drain_locked(vdp); mutex_exit(&vdp->xdf_dev_lk); return (rv); } /* * Destroy all v_req_t, grant table entries, and our ring buffer. */ static void xdf_ring_destroy(xdf_t *vdp) { v_req_t *vreq; buf_t *bp; ge_slot_t *gs; ASSERT(MUTEX_HELD(&vdp->xdf_cb_lk)); ASSERT(MUTEX_HELD(&vdp->xdf_dev_lk)); if ((vdp->xdf_state != XD_INIT) && (vdp->xdf_state != XD_CONNECTED) && (vdp->xdf_state != XD_READY)) { ASSERT(vdp->xdf_xb_ring == NULL); ASSERT(vdp->xdf_xb_ring_hdl == NULL); ASSERT(vdp->xdf_peer == INVALID_DOMID); ASSERT(vdp->xdf_evtchn == INVALID_EVTCHN); ASSERT(list_is_empty(&vdp->xdf_vreq_act)); return; } /* * We don't want to recieve async notifications from the backend * when it finishes processing ring entries. */ #ifdef XPV_HVM_DRIVER ec_unbind_evtchn(vdp->xdf_evtchn); #else /* !XPV_HVM_DRIVER */ (void) ddi_remove_intr(vdp->xdf_dip, 0, NULL); #endif /* !XPV_HVM_DRIVER */ /* * Drain any requests in the ring. We need to do this before we * can free grant table entries, because if active ring entries * point to grants, then the backend could be trying to access * those grants. */ (void) xdf_ring_drain_locked(vdp); /* We're done talking to the backend so free up our event channel */ xvdi_free_evtchn(vdp->xdf_dip); vdp->xdf_evtchn = INVALID_EVTCHN; while ((vreq = list_head(&vdp->xdf_vreq_act)) != NULL) { bp = vreq->v_buf; ASSERT(BP_VREQ(bp) == vreq); /* Free up any grant table entries associaed with this IO */ while ((gs = list_head(&vreq->v_gs)) != NULL) gs_free(gs); /* If this IO was on the runq, move it back to the waitq. */ if (vreq->v_runq) xdf_kstat_runq_to_waitq(vdp, bp); /* * Reset any buf IO state since we're going to re-issue the * IO when we reconnect. */ vreq_free(vdp, vreq); BP_VREQ_SET(bp, NULL); bioerror(bp, 0); } /* reset the active queue index pointer */ vdp->xdf_i_act = vdp->xdf_f_act; /* Destroy the ring */ xvdi_free_ring(vdp->xdf_xb_ring); vdp->xdf_xb_ring = NULL; vdp->xdf_xb_ring_hdl = NULL; vdp->xdf_peer = INVALID_DOMID; } void xdfmin(struct buf *bp) { if (bp->b_bcount > xdf_maxphys) bp->b_bcount = xdf_maxphys; } /* * Check if we have a pending "eject" media request. */ static int xdf_eject_pending(xdf_t *vdp) { dev_info_t *dip = vdp->xdf_dip; char *xsname, *str; if (!vdp->xdf_media_req_supported) return (B_FALSE); if (((xsname = xvdi_get_xsname(dip)) == NULL) || (xenbus_read_str(xsname, XBP_MEDIA_REQ, &str) != 0)) return (B_FALSE); if (strcmp(str, XBV_MEDIA_REQ_EJECT) != 0) { strfree(str); return (B_FALSE); } strfree(str); return (B_TRUE); } /* * Generate a media request. */ static int xdf_media_req(xdf_t *vdp, char *req, boolean_t media_required) { dev_info_t *dip = vdp->xdf_dip; char *xsname; ASSERT(MUTEX_HELD(&vdp->xdf_cb_lk)); if ((xsname = xvdi_get_xsname(dip)) == NULL) return (ENXIO); /* Check if we support media requests */ if (!XD_IS_CD(vdp) || !vdp->xdf_media_req_supported) return (ENOTTY); /* If an eject is pending then don't allow any new requests */ if (xdf_eject_pending(vdp)) return (ENXIO); /* Make sure that there is media present */ if (media_required && (vdp->xdf_xdev_nblocks == 0)) return (ENXIO); /* We only allow operations when the device is ready and connected */ if (vdp->xdf_state != XD_READY) return (EIO); if (xenbus_printf(XBT_NULL, xsname, XBP_MEDIA_REQ, "%s", req) != 0) return (EIO); return (0); } /* * populate a single blkif_request_t w/ a buf */ static void xdf_process_rreq(xdf_t *vdp, struct buf *bp, blkif_request_t *rreq) { grant_ref_t gr; uint8_t fsect, lsect; size_t bcnt; paddr_t dma_addr; off_t blk_off; dev_info_t *dip = vdp->xdf_dip; blkif_vdev_t vdev = xvdi_get_vdevnum(dip); v_req_t *vreq = BP_VREQ(bp); uint64_t blkno = vreq->v_blkno; uint_t ndmacs = vreq->v_ndmacs; ddi_acc_handle_t acchdl = vdp->xdf_xb_ring_hdl; int seg = 0; int isread = IS_READ(bp); ge_slot_t *gs = list_head(&vreq->v_gs); ASSERT(MUTEX_HELD(&vdp->xdf_dev_lk)); ASSERT(vreq->v_status == VREQ_GS_ALLOCED); if (isread) ddi_put8(acchdl, &rreq->operation, BLKIF_OP_READ); else { switch (vreq->v_flush_diskcache) { case FLUSH_DISKCACHE: ddi_put8(acchdl, &rreq->operation, BLKIF_OP_FLUSH_DISKCACHE); ddi_put16(acchdl, &rreq->handle, vdev); ddi_put64(acchdl, &rreq->id, (uint64_t)(uintptr_t)(gs)); ddi_put8(acchdl, &rreq->nr_segments, 0); vreq->v_status = VREQ_DMAWIN_DONE; return; case WRITE_BARRIER: ddi_put8(acchdl, &rreq->operation, BLKIF_OP_WRITE_BARRIER); break; default: if (!vdp->xdf_wce) ddi_put8(acchdl, &rreq->operation, BLKIF_OP_WRITE_BARRIER); else ddi_put8(acchdl, &rreq->operation, BLKIF_OP_WRITE); break; } } ddi_put16(acchdl, &rreq->handle, vdev); ddi_put64(acchdl, &rreq->sector_number, blkno); ddi_put64(acchdl, &rreq->id, (uint64_t)(uintptr_t)(gs)); /* * loop until all segments are populated or no more dma cookie in buf */ for (;;) { /* * Each segment of a blkif request can transfer up to * one 4K page of data. */ bcnt = vreq->v_dmac.dmac_size; dma_addr = vreq->v_dmac.dmac_laddress; blk_off = (uint_t)((paddr_t)XB_SEGOFFSET & dma_addr); fsect = blk_off >> XB_BSHIFT; lsect = fsect + (bcnt >> XB_BSHIFT) - 1; ASSERT(bcnt <= PAGESIZE); ASSERT((bcnt % XB_BSIZE) == 0); ASSERT((blk_off & XB_BMASK) == 0); ASSERT(fsect < XB_MAX_SEGLEN / XB_BSIZE && lsect < XB_MAX_SEGLEN / XB_BSIZE); gr = gs_grant(gs, PATOMA(dma_addr) >> PAGESHIFT); ddi_put32(acchdl, &rreq->seg[seg].gref, gr); ddi_put8(acchdl, &rreq->seg[seg].first_sect, fsect); ddi_put8(acchdl, &rreq->seg[seg].last_sect, lsect); DPRINTF(IO_DBG, ( "xdf@%s: seg%d: dmacS %lu blk_off %ld\n", vdp->xdf_addr, seg, vreq->v_dmac.dmac_size, blk_off)); DPRINTF(IO_DBG, ( "xdf@%s: seg%d: fs %d ls %d gr %d dma 0x%"PRIx64"\n", vdp->xdf_addr, seg, fsect, lsect, gr, dma_addr)); blkno += (bcnt >> XB_BSHIFT); seg++; ASSERT(seg <= BLKIF_MAX_SEGMENTS_PER_REQUEST); if (--ndmacs) { ddi_dma_nextcookie(vreq->v_dmahdl, &vreq->v_dmac); continue; } vreq->v_status = VREQ_DMAWIN_DONE; vreq->v_blkno = blkno; break; } ddi_put8(acchdl, &rreq->nr_segments, seg); DPRINTF(IO_DBG, ( "xdf@%s: xdf_process_rreq: request id=%"PRIx64" ready\n", vdp->xdf_addr, rreq->id)); } static void xdf_io_start(xdf_t *vdp) { struct buf *bp; v_req_t *vreq; blkif_request_t *rreq; boolean_t rreqready = B_FALSE; mutex_enter(&vdp->xdf_dev_lk); /* * Populate the ring request(s). Loop until there is no buf to * transfer or no free slot available in I/O ring. */ for (;;) { /* don't start any new IO if we're suspending */ if (vdp->xdf_suspending) break; if ((bp = xdf_bp_next(vdp)) == NULL) break; /* if the buf doesn't already have a vreq, allocate one */ if (((vreq = BP_VREQ(bp)) == NULL) && ((vreq = vreq_get(vdp, bp)) == NULL)) break; /* alloc DMA/GTE resources */ if (vreq_setup(vdp, vreq) != DDI_SUCCESS) break; /* get next blkif_request in the ring */ if ((rreq = xvdi_ring_get_request(vdp->xdf_xb_ring)) == NULL) break; bzero(rreq, sizeof (blkif_request_t)); rreqready = B_TRUE; /* populate blkif_request with this buf */ xdf_process_rreq(vdp, bp, rreq); /* * This buffer/vreq pair is has been allocated a ring buffer * resources, so if it isn't already in our runq, add it. */ if (!vreq->v_runq) xdf_kstat_waitq_to_runq(vdp, bp); } /* Send the request(s) to the backend */ if (rreqready) xdf_ring_push(vdp); mutex_exit(&vdp->xdf_dev_lk); } /* check if partition is open, -1 - check all partitions on the disk */ static boolean_t xdf_isopen(xdf_t *vdp, int partition) { int i; ulong_t parbit; boolean_t rval = B_FALSE; ASSERT((partition == -1) || ((partition >= 0) || (partition < XDF_PEXT))); if (partition == -1) parbit = (ulong_t)-1; else parbit = 1 << partition; for (i = 0; i < OTYPCNT; i++) { if (vdp->xdf_vd_open[i] & parbit) rval = B_TRUE; } return (rval); } /* * The connection should never be closed as long as someone is holding * us open, there is pending IO, or someone is waiting waiting for a * connection. */ static boolean_t xdf_busy(xdf_t *vdp) { ASSERT(MUTEX_HELD(&vdp->xdf_dev_lk)); if ((vdp->xdf_xb_ring != NULL) && xvdi_ring_has_unconsumed_responses(vdp->xdf_xb_ring)) { ASSERT(vdp->xdf_state != XD_CLOSED); return (B_TRUE); } if (!list_is_empty(&vdp->xdf_vreq_act) || (vdp->xdf_f_act != NULL)) { ASSERT(vdp->xdf_state != XD_CLOSED); return (B_TRUE); } if (xdf_isopen(vdp, -1)) { ASSERT(vdp->xdf_state != XD_CLOSED); return (B_TRUE); } if (vdp->xdf_connect_req > 0) { ASSERT(vdp->xdf_state != XD_CLOSED); return (B_TRUE); } return (B_FALSE); } static void xdf_set_state(xdf_t *vdp, xdf_state_t new_state) { ASSERT(MUTEX_HELD(&vdp->xdf_dev_lk)); DPRINTF(DDI_DBG, ("xdf@%s: state change %d -> %d\n", vdp->xdf_addr, vdp->xdf_state, new_state)); vdp->xdf_state = new_state; cv_broadcast(&vdp->xdf_dev_cv); } static void xdf_disconnect(xdf_t *vdp, xdf_state_t new_state, boolean_t quiet) { dev_info_t *dip = vdp->xdf_dip; boolean_t busy; ASSERT(MUTEX_HELD(&vdp->xdf_cb_lk)); ASSERT(MUTEX_NOT_HELD(&vdp->xdf_dev_lk)); ASSERT((new_state == XD_UNKNOWN) || (new_state == XD_CLOSED)); /* Check if we're already there. */ if (vdp->xdf_state == new_state) return; mutex_enter(&vdp->xdf_dev_lk); busy = xdf_busy(vdp); /* If we're already closed then there's nothing todo. */ if (vdp->xdf_state == XD_CLOSED) { ASSERT(!busy); xdf_set_state(vdp, new_state); mutex_exit(&vdp->xdf_dev_lk); return; } #ifdef DEBUG /* UhOh. Warn the user that something bad has happened. */ if (!quiet && busy && (vdp->xdf_state == XD_READY) && (vdp->xdf_xdev_nblocks != 0)) { cmn_err(CE_WARN, "xdf@%s: disconnected while in use", vdp->xdf_addr); } #endif /* DEBUG */ xdf_ring_destroy(vdp); /* If we're busy then we can only go into the unknown state */ xdf_set_state(vdp, (busy) ? XD_UNKNOWN : new_state); mutex_exit(&vdp->xdf_dev_lk); /* if we're closed now, let the other end know */ if (vdp->xdf_state == XD_CLOSED) (void) xvdi_switch_state(dip, XBT_NULL, XenbusStateClosed); } /* * Kick-off connect process * Status should be XD_UNKNOWN or XD_CLOSED * On success, status will be changed to XD_INIT * On error, it will be changed to XD_UNKNOWN */ static int xdf_setstate_init(xdf_t *vdp) { dev_info_t *dip = vdp->xdf_dip; xenbus_transaction_t xbt; grant_ref_t gref; char *xsname, *str; int rv; ASSERT(MUTEX_HELD(&vdp->xdf_cb_lk)); ASSERT(MUTEX_NOT_HELD(&vdp->xdf_dev_lk)); ASSERT((vdp->xdf_state == XD_UNKNOWN) || (vdp->xdf_state == XD_CLOSED)); DPRINTF(DDI_DBG, ("xdf@%s: starting connection process\n", vdp->xdf_addr)); /* * If an eject is pending then don't allow a new connection, but * we want to return without displaying an error message. */ if (xdf_eject_pending(vdp)) { xdf_disconnect(vdp, XD_UNKNOWN, B_FALSE); return (DDI_FAILURE); } if ((xsname = xvdi_get_xsname(dip)) == NULL) goto errout; if ((vdp->xdf_peer = xvdi_get_oeid(dip)) == INVALID_DOMID) goto errout; (void) xvdi_switch_state(dip, XBT_NULL, XenbusStateInitialising); /* * Sanity check for the existance of the xenbus device-type property. * This property might not exist if we our xenbus device nodes was * force destroyed while we were still connected to the backend. */ if (xenbus_read_str(xsname, XBP_DEV_TYPE, &str) != 0) goto errout; strfree(str); if (xvdi_alloc_evtchn(dip) != DDI_SUCCESS) goto errout; vdp->xdf_evtchn = xvdi_get_evtchn(dip); #ifdef XPV_HVM_DRIVER ec_bind_evtchn_to_handler(vdp->xdf_evtchn, IPL_VBD, xdf_intr, vdp); #else /* !XPV_HVM_DRIVER */ if (ddi_add_intr(dip, 0, NULL, NULL, xdf_intr, (caddr_t)vdp) != DDI_SUCCESS) { cmn_err(CE_WARN, "xdf@%s: xdf_setstate_init: " "failed to add intr handler", vdp->xdf_addr); goto errout1; } #endif /* !XPV_HVM_DRIVER */ if (xvdi_alloc_ring(dip, BLKIF_RING_SIZE, sizeof (union blkif_sring_entry), &gref, &vdp->xdf_xb_ring) != DDI_SUCCESS) { cmn_err(CE_WARN, "xdf@%s: failed to alloc comm ring", vdp->xdf_addr); goto errout2; } vdp->xdf_xb_ring_hdl = vdp->xdf_xb_ring->xr_acc_hdl; /* ugly!! */ /* * Write into xenstore the info needed by backend */ trans_retry: if (xenbus_transaction_start(&xbt)) { cmn_err(CE_WARN, "xdf@%s: failed to start transaction", vdp->xdf_addr); xvdi_fatal_error(dip, EIO, "connect transaction init"); goto fail_trans; } /* * XBP_PROTOCOL is written by the domain builder in the case of PV * domains. However, it is not written for HVM domains, so let's * write it here. */ if (((rv = xenbus_printf(xbt, xsname, XBP_MEDIA_REQ, "%s", XBV_MEDIA_REQ_NONE)) != 0) || ((rv = xenbus_printf(xbt, xsname, XBP_RING_REF, "%u", gref)) != 0) || ((rv = xenbus_printf(xbt, xsname, XBP_EVENT_CHAN, "%u", vdp->xdf_evtchn)) != 0) || ((rv = xenbus_printf(xbt, xsname, XBP_PROTOCOL, "%s", XEN_IO_PROTO_ABI_NATIVE)) != 0) || ((rv = xvdi_switch_state(dip, xbt, XenbusStateInitialised)) > 0)) { (void) xenbus_transaction_end(xbt, 1); xvdi_fatal_error(dip, rv, "connect transaction setup"); goto fail_trans; } /* kick-off connect process */ if (rv = xenbus_transaction_end(xbt, 0)) { if (rv == EAGAIN) goto trans_retry; xvdi_fatal_error(dip, rv, "connect transaction commit"); goto fail_trans; } ASSERT(MUTEX_HELD(&vdp->xdf_cb_lk)); mutex_enter(&vdp->xdf_dev_lk); xdf_set_state(vdp, XD_INIT); mutex_exit(&vdp->xdf_dev_lk); return (DDI_SUCCESS); fail_trans: xvdi_free_ring(vdp->xdf_xb_ring); errout2: #ifdef XPV_HVM_DRIVER ec_unbind_evtchn(vdp->xdf_evtchn); #else /* !XPV_HVM_DRIVER */ (void) ddi_remove_intr(vdp->xdf_dip, 0, NULL); #endif /* !XPV_HVM_DRIVER */ errout1: xvdi_free_evtchn(dip); vdp->xdf_evtchn = INVALID_EVTCHN; errout: xdf_disconnect(vdp, XD_UNKNOWN, B_FALSE); cmn_err(CE_WARN, "xdf@%s: failed to start connection to backend", vdp->xdf_addr); return (DDI_FAILURE); } int xdf_get_flush_block(xdf_t *vdp) { /* * Get a DEV_BSIZE aligned bufer */ vdp->xdf_flush_mem = kmem_alloc(DEV_BSIZE * 2, KM_SLEEP); vdp->xdf_cache_flush_block = (char *)P2ROUNDUP((uintptr_t)(vdp->xdf_flush_mem), DEV_BSIZE); if (xdf_lb_rdwr(vdp->xdf_dip, TG_READ, vdp->xdf_cache_flush_block, xdf_flush_block, DEV_BSIZE, NULL) != 0) return (DDI_FAILURE); return (DDI_SUCCESS); } static void xdf_setstate_ready(void *arg) { xdf_t *vdp = (xdf_t *)arg; vdp->xdf_ready_tq_thread = curthread; /* * We've created all the minor nodes via cmlb_attach() using default * value in xdf_attach() to make it possible to block in xdf_open(), * in case there's anyone (say, booting thread) ever trying to open * it before connected to backend. We will refresh all those minor * nodes w/ latest info we've got now when we are almost connected. */ mutex_enter(&vdp->xdf_dev_lk); if (vdp->xdf_cmbl_reattach) { vdp->xdf_cmbl_reattach = B_FALSE; mutex_exit(&vdp->xdf_dev_lk); if (xdf_cmlb_attach(vdp) != 0) { xdf_disconnect(vdp, XD_UNKNOWN, B_FALSE); return; } mutex_enter(&vdp->xdf_dev_lk); } /* If we're not still trying to get to the ready state, then bail. */ if (vdp->xdf_state != XD_CONNECTED) { mutex_exit(&vdp->xdf_dev_lk); return; } mutex_exit(&vdp->xdf_dev_lk); /* * If backend has feature-barrier, see if it supports disk * cache flush op. */ vdp->xdf_flush_supported = B_FALSE; if (vdp->xdf_feature_barrier) { /* * Pretend we already know flush is supported so probe * will attempt the correct op. */ vdp->xdf_flush_supported = B_TRUE; if (xdf_lb_rdwr(vdp->xdf_dip, TG_WRITE, NULL, 0, 0, 0) == 0) { vdp->xdf_flush_supported = B_TRUE; } else { vdp->xdf_flush_supported = B_FALSE; /* * If the other end does not support the cache flush op * then we must use a barrier-write to force disk * cache flushing. Barrier writes require that a data * block actually be written. * Cache a block to barrier-write when we are * asked to perform a flush. * XXX - would it be better to just copy 1 block * (512 bytes) from whatever write we did last * and rewrite that block? */ if (xdf_get_flush_block(vdp) != DDI_SUCCESS) { xdf_disconnect(vdp, XD_UNKNOWN, B_FALSE); return; } } } mutex_enter(&vdp->xdf_cb_lk); mutex_enter(&vdp->xdf_dev_lk); if (vdp->xdf_state == XD_CONNECTED) xdf_set_state(vdp, XD_READY); mutex_exit(&vdp->xdf_dev_lk); /* Restart any currently queued up io */ xdf_io_start(vdp); mutex_exit(&vdp->xdf_cb_lk); } /* * synthetic geometry */ #define XDF_NSECTS 256 #define XDF_NHEADS 16 static void xdf_synthetic_pgeom(dev_info_t *dip, cmlb_geom_t *geomp) { xdf_t *vdp; uint_t ncyl; vdp = ddi_get_soft_state(xdf_ssp, ddi_get_instance(dip)); ncyl = vdp->xdf_xdev_nblocks / (XDF_NHEADS * XDF_NSECTS); bzero(geomp, sizeof (*geomp)); geomp->g_ncyl = ncyl == 0 ? 1 : ncyl; geomp->g_acyl = 0; geomp->g_nhead = XDF_NHEADS; geomp->g_nsect = XDF_NSECTS; geomp->g_secsize = XB_BSIZE; geomp->g_capacity = vdp->xdf_xdev_nblocks; geomp->g_intrlv = 0; geomp->g_rpm = 7200; } /* * Finish other initialization after we've connected to backend * Status should be XD_INIT before calling this routine * On success, status should be changed to XD_CONNECTED. * On error, status should stay XD_INIT */ static int xdf_setstate_connected(xdf_t *vdp) { dev_info_t *dip = vdp->xdf_dip; cmlb_geom_t pgeom; diskaddr_t nblocks = 0; char *oename, *xsname, *str; uint_t dinfo; ASSERT(MUTEX_HELD(&vdp->xdf_cb_lk)); ASSERT(MUTEX_NOT_HELD(&vdp->xdf_dev_lk)); ASSERT(vdp->xdf_state == XD_INIT); if (((xsname = xvdi_get_xsname(dip)) == NULL) || ((oename = xvdi_get_oename(dip)) == NULL)) return (DDI_FAILURE); /* Determine if feature barrier is supported by backend */ if (!(vdp->xdf_feature_barrier = xenbus_exists(oename, XBP_FB))) cmn_err(CE_NOTE, "xdf@%s: failed to read feature-barrier", vdp->xdf_addr); /* * Probe backend. Read the device size into xdf_xdev_nblocks * and set the VDISK_READONLY, VDISK_CDROM, and VDISK_REMOVABLE * flags in xdf_dinfo. If the emulated device type is "cdrom", * we always set VDISK_CDROM, regardless of if it's present in * the xenbus info parameter. */ if (xenbus_gather(XBT_NULL, oename, XBP_SECTORS, "%"SCNu64, &nblocks, XBP_INFO, "%u", &dinfo, NULL) != 0) { cmn_err(CE_WARN, "xdf@%s: xdf_setstate_connected: " "cannot read backend info", vdp->xdf_addr); return (DDI_FAILURE); } if (xenbus_read_str(xsname, XBP_DEV_TYPE, &str) != 0) { cmn_err(CE_WARN, "xdf@%s: cannot read device-type", vdp->xdf_addr); return (DDI_FAILURE); } if (strcmp(str, XBV_DEV_TYPE_CD) == 0) dinfo |= VDISK_CDROM; strfree(str); vdp->xdf_xdev_nblocks = nblocks; #ifdef _ILP32 if (vdp->xdf_xdev_nblocks > DK_MAX_BLOCKS) { cmn_err(CE_WARN, "xdf@%s: xdf_setstate_connected: " "backend disk device too large with %llu blocks for" " 32-bit kernel", vdp->xdf_addr, vdp->xdf_xdev_nblocks); xvdi_fatal_error(dip, EFBIG, "reading backend info"); return (DDI_FAILURE); } #endif /* * If the physical geometry for a fixed disk has been explicity * set then make sure that the specified physical geometry isn't * larger than the device we connected to. */ if (vdp->xdf_pgeom_fixed && (vdp->xdf_pgeom.g_capacity > vdp->xdf_xdev_nblocks)) { cmn_err(CE_WARN, "xdf@%s: connect failed, fixed geometry too large", vdp->xdf_addr); return (DDI_FAILURE); } vdp->xdf_media_req_supported = xenbus_exists(oename, XBP_MEDIA_REQ_SUP); /* mark vbd is ready for I/O */ mutex_enter(&vdp->xdf_dev_lk); xdf_set_state(vdp, XD_CONNECTED); /* check if the cmlb label should be updated */ xdf_synthetic_pgeom(dip, &pgeom); if ((vdp->xdf_dinfo != dinfo) || (!vdp->xdf_pgeom_fixed && (memcmp(&vdp->xdf_pgeom, &pgeom, sizeof (pgeom)) != 0))) { vdp->xdf_cmbl_reattach = B_TRUE; vdp->xdf_dinfo = dinfo; if (!vdp->xdf_pgeom_fixed) vdp->xdf_pgeom = pgeom; } if (XD_IS_CD(vdp) || XD_IS_RM(vdp)) { if (vdp->xdf_xdev_nblocks == 0) { vdp->xdf_mstate = DKIO_EJECTED; cv_broadcast(&vdp->xdf_mstate_cv); } else { vdp->xdf_mstate = DKIO_INSERTED; cv_broadcast(&vdp->xdf_mstate_cv); } } else { if (vdp->xdf_mstate != DKIO_NONE) { vdp->xdf_mstate = DKIO_NONE; cv_broadcast(&vdp->xdf_mstate_cv); } } mutex_exit(&vdp->xdf_dev_lk); cmn_err(CE_CONT, "?xdf@%s: %"PRIu64" blocks", vdp->xdf_addr, (uint64_t)vdp->xdf_xdev_nblocks); /* Restart any currently queued up io */ xdf_io_start(vdp); /* * To get to the ready state we have to do IO to the backend device, * but we can't initiate IO from the other end change callback thread * (which is the current context we're executing in.) This is because * if the other end disconnects while we're doing IO from the callback * thread, then we can't recieve that disconnect event and we hang * waiting for an IO that can never complete. */ (void) ddi_taskq_dispatch(vdp->xdf_ready_tq, xdf_setstate_ready, vdp, DDI_SLEEP); (void) xvdi_switch_state(dip, XBT_NULL, XenbusStateConnected); return (DDI_SUCCESS); } /*ARGSUSED*/ static void xdf_oe_change(dev_info_t *dip, ddi_eventcookie_t id, void *arg, void *impl_data) { XenbusState new_state = *(XenbusState *)impl_data; xdf_t *vdp = (xdf_t *)ddi_get_driver_private(dip); DPRINTF(DDI_DBG, ("xdf@%s: otherend state change to %d!\n", vdp->xdf_addr, new_state)); mutex_enter(&vdp->xdf_cb_lk); /* We assume that this callback is single threaded */ ASSERT(vdp->xdf_oe_change_thread == NULL); DEBUG_EVAL(vdp->xdf_oe_change_thread = curthread); /* ignore any backend state changes if we're suspending/suspended */ if (vdp->xdf_suspending || (vdp->xdf_state == XD_SUSPEND)) { DEBUG_EVAL(vdp->xdf_oe_change_thread = NULL); mutex_exit(&vdp->xdf_cb_lk); return; } switch (new_state) { case XenbusStateUnknown: case XenbusStateInitialising: case XenbusStateInitWait: case XenbusStateInitialised: if (vdp->xdf_state == XD_INIT) break; xdf_disconnect(vdp, XD_UNKNOWN, B_FALSE); if (xdf_setstate_init(vdp) != DDI_SUCCESS) break; ASSERT(vdp->xdf_state == XD_INIT); break; case XenbusStateConnected: if ((vdp->xdf_state == XD_CONNECTED) || (vdp->xdf_state == XD_READY)) break; if (vdp->xdf_state != XD_INIT) { xdf_disconnect(vdp, XD_UNKNOWN, B_FALSE); if (xdf_setstate_init(vdp) != DDI_SUCCESS) break; ASSERT(vdp->xdf_state == XD_INIT); } if (xdf_setstate_connected(vdp) != DDI_SUCCESS) { xdf_disconnect(vdp, XD_UNKNOWN, B_FALSE); break; } ASSERT(vdp->xdf_state == XD_CONNECTED); break; case XenbusStateClosing: if (xdf_isopen(vdp, -1)) { cmn_err(CE_NOTE, "xdf@%s: hot-unplug failed, still in use", vdp->xdf_addr); break; } /*FALLTHROUGH*/ case XenbusStateClosed: xdf_disconnect(vdp, XD_CLOSED, B_FALSE); break; } /* notify anybody waiting for oe state change */ cv_broadcast(&vdp->xdf_dev_cv); DEBUG_EVAL(vdp->xdf_oe_change_thread = NULL); mutex_exit(&vdp->xdf_cb_lk); } static int xdf_connect_locked(xdf_t *vdp, boolean_t wait) { int rv; ASSERT(MUTEX_HELD(&vdp->xdf_cb_lk)); ASSERT(MUTEX_HELD(&vdp->xdf_dev_lk)); /* we can't connect once we're in the closed state */ if (vdp->xdf_state == XD_CLOSED) return (XD_CLOSED); vdp->xdf_connect_req++; while (vdp->xdf_state != XD_READY) { mutex_exit(&vdp->xdf_dev_lk); if (vdp->xdf_state == XD_UNKNOWN) (void) xdf_setstate_init(vdp); mutex_enter(&vdp->xdf_dev_lk); if (!wait || (vdp->xdf_state == XD_READY)) goto out; mutex_exit((&vdp->xdf_cb_lk)); rv = cv_wait_sig(&vdp->xdf_dev_cv, &vdp->xdf_dev_lk); mutex_exit((&vdp->xdf_dev_lk)); mutex_enter((&vdp->xdf_cb_lk)); mutex_enter((&vdp->xdf_dev_lk)); if (rv == 0) goto out; } out: ASSERT(MUTEX_HELD(&vdp->xdf_cb_lk)); ASSERT(MUTEX_HELD(&vdp->xdf_dev_lk)); /* Try to lock the media */ (void) xdf_media_req(vdp, XBV_MEDIA_REQ_LOCK, B_TRUE); vdp->xdf_connect_req--; return (vdp->xdf_state); } static uint_t xdf_iorestart(caddr_t arg) { xdf_t *vdp = (xdf_t *)arg; ASSERT(vdp != NULL); mutex_enter(&vdp->xdf_dev_lk); ASSERT(ISDMACBON(vdp)); SETDMACBOFF(vdp); mutex_exit(&vdp->xdf_dev_lk); xdf_io_start(vdp); return (DDI_INTR_CLAIMED); } #if defined(XPV_HVM_DRIVER) typedef struct xdf_hvm_entry { list_node_t xdf_he_list; char *xdf_he_path; dev_info_t *xdf_he_dip; } xdf_hvm_entry_t; static list_t xdf_hvm_list; static kmutex_t xdf_hvm_list_lock; static xdf_hvm_entry_t * i_xdf_hvm_find(const char *path, dev_info_t *dip) { xdf_hvm_entry_t *i; ASSERT((path != NULL) || (dip != NULL)); ASSERT(MUTEX_HELD(&xdf_hvm_list_lock)); i = list_head(&xdf_hvm_list); while (i != NULL) { if ((path != NULL) && strcmp(i->xdf_he_path, path) != 0) { i = list_next(&xdf_hvm_list, i); continue; } if ((dip != NULL) && (i->xdf_he_dip != dip)) { i = list_next(&xdf_hvm_list, i); continue; } break; } return (i); } dev_info_t * xdf_hvm_hold(const char *path) { xdf_hvm_entry_t *i; dev_info_t *dip; mutex_enter(&xdf_hvm_list_lock); i = i_xdf_hvm_find(path, NULL); if (i == NULL) { mutex_exit(&xdf_hvm_list_lock); return (B_FALSE); } ndi_hold_devi(dip = i->xdf_he_dip); mutex_exit(&xdf_hvm_list_lock); return (dip); } static void xdf_hvm_add(dev_info_t *dip) { xdf_hvm_entry_t *i; char *path; /* figure out the path for the dip */ path = kmem_zalloc(MAXPATHLEN, KM_SLEEP); (void) ddi_pathname(dip, path); i = kmem_alloc(sizeof (*i), KM_SLEEP); i->xdf_he_dip = dip; i->xdf_he_path = i_ddi_strdup(path, KM_SLEEP); mutex_enter(&xdf_hvm_list_lock); ASSERT(i_xdf_hvm_find(path, NULL) == NULL); ASSERT(i_xdf_hvm_find(NULL, dip) == NULL); list_insert_head(&xdf_hvm_list, i); mutex_exit(&xdf_hvm_list_lock); kmem_free(path, MAXPATHLEN); } static void xdf_hvm_rm(dev_info_t *dip) { xdf_hvm_entry_t *i; mutex_enter(&xdf_hvm_list_lock); VERIFY((i = i_xdf_hvm_find(NULL, dip)) != NULL); list_remove(&xdf_hvm_list, i); mutex_exit(&xdf_hvm_list_lock); kmem_free(i->xdf_he_path, strlen(i->xdf_he_path) + 1); kmem_free(i, sizeof (*i)); } static void xdf_hvm_init(void) { list_create(&xdf_hvm_list, sizeof (xdf_hvm_entry_t), offsetof(xdf_hvm_entry_t, xdf_he_list)); mutex_init(&xdf_hvm_list_lock, NULL, MUTEX_DEFAULT, NULL); } static void xdf_hvm_fini(void) { ASSERT(list_head(&xdf_hvm_list) == NULL); list_destroy(&xdf_hvm_list); mutex_destroy(&xdf_hvm_list_lock); } boolean_t xdf_hvm_connect(dev_info_t *dip) { xdf_t *vdp = (xdf_t *)ddi_get_driver_private(dip); char *oename, *str; int rv; mutex_enter(&vdp->xdf_cb_lk); mutex_enter(&vdp->xdf_dev_lk); /* * Before try to establish a connection we need to wait for the * backend hotplug scripts to have run. Once they are run the * "/hotplug-status" property will be set to "connected". */ for (;;) { ASSERT(MUTEX_HELD(&vdp->xdf_cb_lk)); ASSERT(MUTEX_HELD(&vdp->xdf_dev_lk)); /* * Get the xenbus path to the backend device. Note that * we can't cache this path (and we look it up on each pass * through this loop) because it could change during * suspend, resume, and migration operations. */ if ((oename = xvdi_get_oename(dip)) == NULL) { mutex_exit(&vdp->xdf_dev_lk); mutex_exit(&vdp->xdf_cb_lk); return (B_FALSE); } str = NULL; if ((xenbus_read_str(oename, XBP_HP_STATUS, &str) == 0) && (strcmp(str, XBV_HP_STATUS_CONN) == 0)) break; if (str != NULL) strfree(str); /* wait for an update to "/hotplug-status" */ mutex_exit(&vdp->xdf_dev_lk); if (cv_wait_sig(&vdp->xdf_hp_status_cv, &vdp->xdf_cb_lk) == 0) { /* we got interrupted by a signal */ mutex_exit(&vdp->xdf_cb_lk); return (B_FALSE); } mutex_enter(&vdp->xdf_dev_lk); } /* Good news. The backend hotplug scripts have been run. */ ASSERT(MUTEX_HELD(&vdp->xdf_cb_lk)); ASSERT(MUTEX_HELD(&vdp->xdf_dev_lk)); ASSERT(strcmp(str, XBV_HP_STATUS_CONN) == 0); strfree(str); /* * If we're emulating a cd device and if the backend doesn't support * media request opreations, then we're not going to bother trying * to establish a connection for a couple reasons. First off, media * requests support is required to support operations like eject and * media locking. Second, other backend platforms like Linux don't * support hvm pv cdrom access. They don't even have a backend pv * driver for cdrom device nodes, so we don't want to block forever * waiting for a connection to a backend driver that doesn't exist. */ if (XD_IS_CD(vdp) && !xenbus_exists(oename, XBP_MEDIA_REQ_SUP)) { mutex_exit(&vdp->xdf_dev_lk); mutex_exit(&vdp->xdf_cb_lk); return (B_FALSE); } rv = xdf_connect_locked(vdp, B_TRUE); mutex_exit(&vdp->xdf_dev_lk); mutex_exit(&vdp->xdf_cb_lk); return ((rv == XD_READY) ? B_TRUE : B_FALSE); } int xdf_hvm_setpgeom(dev_info_t *dip, cmlb_geom_t *geomp) { xdf_t *vdp = (xdf_t *)ddi_get_driver_private(dip); /* sanity check the requested physical geometry */ mutex_enter(&vdp->xdf_dev_lk); if ((geomp->g_secsize != XB_BSIZE) || (geomp->g_capacity == 0)) { mutex_exit(&vdp->xdf_dev_lk); return (EINVAL); } /* * If we've already connected to the backend device then make sure * we're not defining a physical geometry larger than our backend * device. */ if ((vdp->xdf_xdev_nblocks != 0) && (geomp->g_capacity > vdp->xdf_xdev_nblocks)) { mutex_exit(&vdp->xdf_dev_lk); return (EINVAL); } bzero(&vdp->xdf_pgeom, sizeof (vdp->xdf_pgeom)); vdp->xdf_pgeom.g_ncyl = geomp->g_ncyl; vdp->xdf_pgeom.g_acyl = geomp->g_acyl; vdp->xdf_pgeom.g_nhead = geomp->g_nhead; vdp->xdf_pgeom.g_nsect = geomp->g_nsect; vdp->xdf_pgeom.g_secsize = geomp->g_secsize; vdp->xdf_pgeom.g_capacity = geomp->g_capacity; vdp->xdf_pgeom.g_intrlv = geomp->g_intrlv; vdp->xdf_pgeom.g_rpm = geomp->g_rpm; vdp->xdf_pgeom_fixed = B_TRUE; mutex_exit(&vdp->xdf_dev_lk); /* force a re-validation */ cmlb_invalidate(vdp->xdf_vd_lbl, NULL); return (0); } boolean_t xdf_is_cd(dev_info_t *dip) { xdf_t *vdp = (xdf_t *)ddi_get_driver_private(dip); boolean_t rv; mutex_enter(&vdp->xdf_cb_lk); rv = XD_IS_CD(vdp); mutex_exit(&vdp->xdf_cb_lk); return (rv); } boolean_t xdf_is_rm(dev_info_t *dip) { xdf_t *vdp = (xdf_t *)ddi_get_driver_private(dip); boolean_t rv; mutex_enter(&vdp->xdf_cb_lk); rv = XD_IS_RM(vdp); mutex_exit(&vdp->xdf_cb_lk); return (rv); } boolean_t xdf_media_req_supported(dev_info_t *dip) { xdf_t *vdp = (xdf_t *)ddi_get_driver_private(dip); boolean_t rv; mutex_enter(&vdp->xdf_cb_lk); rv = vdp->xdf_media_req_supported; mutex_exit(&vdp->xdf_cb_lk); return (rv); } #endif /* XPV_HVM_DRIVER */ static int xdf_lb_getcap(dev_info_t *dip, diskaddr_t *capp) { xdf_t *vdp; vdp = ddi_get_soft_state(xdf_ssp, ddi_get_instance(dip)); if (vdp == NULL) return (ENXIO); mutex_enter(&vdp->xdf_dev_lk); *capp = vdp->xdf_pgeom.g_capacity; DPRINTF(LBL_DBG, ("xdf@%s:capacity %llu\n", vdp->xdf_addr, *capp)); mutex_exit(&vdp->xdf_dev_lk); return (0); } static int xdf_lb_getpgeom(dev_info_t *dip, cmlb_geom_t *geomp) { xdf_t *vdp; if ((vdp = ddi_get_soft_state(xdf_ssp, ddi_get_instance(dip))) == NULL) return (ENXIO); *geomp = vdp->xdf_pgeom; return (0); } /* * No real HBA, no geometry available from it */ /*ARGSUSED*/ static int xdf_lb_getvgeom(dev_info_t *dip, cmlb_geom_t *geomp) { return (EINVAL); } static int xdf_lb_getattribute(dev_info_t *dip, tg_attribute_t *tgattributep) { xdf_t *vdp; if (!(vdp = ddi_get_soft_state(xdf_ssp, ddi_get_instance(dip)))) return (ENXIO); if (XD_IS_RO(vdp)) tgattributep->media_is_writable = 0; else tgattributep->media_is_writable = 1; return (0); } /* ARGSUSED3 */ int xdf_lb_getinfo(dev_info_t *dip, int cmd, void *arg, void *tg_cookie) { switch (cmd) { case TG_GETPHYGEOM: return (xdf_lb_getpgeom(dip, (cmlb_geom_t *)arg)); case TG_GETVIRTGEOM: return (xdf_lb_getvgeom(dip, (cmlb_geom_t *)arg)); case TG_GETCAPACITY: return (xdf_lb_getcap(dip, (diskaddr_t *)arg)); case TG_GETBLOCKSIZE: *(uint32_t *)arg = XB_BSIZE; return (0); case TG_GETATTR: return (xdf_lb_getattribute(dip, (tg_attribute_t *)arg)); default: return (ENOTTY); } } /* ARGSUSED5 */ int xdf_lb_rdwr(dev_info_t *dip, uchar_t cmd, void *bufp, diskaddr_t start, size_t reqlen, void *tg_cookie) { xdf_t *vdp; struct buf *bp; int err = 0; vdp = ddi_get_soft_state(xdf_ssp, ddi_get_instance(dip)); /* We don't allow IO from the oe_change callback thread */ ASSERT(curthread != vdp->xdf_oe_change_thread); if ((start + (reqlen >> DEV_BSHIFT)) > vdp->xdf_pgeom.g_capacity) return (EINVAL); bp = getrbuf(KM_SLEEP); if (cmd == TG_READ) bp->b_flags = B_BUSY | B_READ; else bp->b_flags = B_BUSY | B_WRITE; bp->b_un.b_addr = bufp; bp->b_bcount = reqlen; bp->b_blkno = start; bp->b_edev = DDI_DEV_T_NONE; /* don't have dev_t */ mutex_enter(&vdp->xdf_dev_lk); xdf_bp_push(vdp, bp); mutex_exit(&vdp->xdf_dev_lk); xdf_io_start(vdp); if (curthread == vdp->xdf_ready_tq_thread) (void) xdf_ring_drain(vdp); err = biowait(bp); ASSERT(bp->b_flags & B_DONE); freerbuf(bp); return (err); } /* * Lock the current media. Set the media state to "lock". * (Media locks are only respected by the backend driver.) */ static int xdf_ioctl_mlock(xdf_t *vdp) { int rv; mutex_enter(&vdp->xdf_cb_lk); rv = xdf_media_req(vdp, XBV_MEDIA_REQ_LOCK, B_TRUE); mutex_exit(&vdp->xdf_cb_lk); return (rv); } /* * Release a media lock. Set the media state to "none". */ static int xdf_ioctl_munlock(xdf_t *vdp) { int rv; mutex_enter(&vdp->xdf_cb_lk); rv = xdf_media_req(vdp, XBV_MEDIA_REQ_NONE, B_TRUE); mutex_exit(&vdp->xdf_cb_lk); return (rv); } /* * Eject the current media. Ignores any media locks. (Media locks * are only for benifit of the the backend.) */ static int xdf_ioctl_eject(xdf_t *vdp) { int rv; mutex_enter(&vdp->xdf_cb_lk); if ((rv = xdf_media_req(vdp, XBV_MEDIA_REQ_EJECT, B_FALSE)) != 0) { mutex_exit(&vdp->xdf_cb_lk); return (rv); } /* * We've set the media requests xenbus parameter to eject, so now * disconnect from the backend, wait for the backend to clear * the media requets xenbus paramter, and then we can reconnect * to the backend. */ (void) xdf_disconnect(vdp, XD_UNKNOWN, B_TRUE); mutex_enter(&vdp->xdf_dev_lk); if (xdf_connect_locked(vdp, B_TRUE) != XD_READY) { mutex_exit(&vdp->xdf_dev_lk); mutex_exit(&vdp->xdf_cb_lk); return (EIO); } mutex_exit(&vdp->xdf_dev_lk); mutex_exit(&vdp->xdf_cb_lk); return (0); } /* * Watch for media state changes. This can be an insertion of a device * (triggered by a 'xm block-configure' request in another domain) or * the ejection of a device (triggered by a local "eject" operation). * For a full description of the DKIOCSTATE ioctl behavior see dkio(7I). */ static int xdf_dkstate(xdf_t *vdp, enum dkio_state mstate) { enum dkio_state prev_state; mutex_enter(&vdp->xdf_cb_lk); prev_state = vdp->xdf_mstate; if (vdp->xdf_mstate == mstate) { while (vdp->xdf_mstate == prev_state) { if (cv_wait_sig(&vdp->xdf_mstate_cv, &vdp->xdf_cb_lk) == 0) { mutex_exit(&vdp->xdf_cb_lk); return (EINTR); } } } if ((prev_state != DKIO_INSERTED) && (vdp->xdf_mstate == DKIO_INSERTED)) { (void) xdf_media_req(vdp, XBV_MEDIA_REQ_LOCK, B_TRUE); mutex_exit(&vdp->xdf_cb_lk); return (0); } mutex_exit(&vdp->xdf_cb_lk); return (0); } /*ARGSUSED*/ static int xdf_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, int *rvalp) { minor_t minor = getminor(dev); int part = XDF_PART(minor); xdf_t *vdp; int rv; if (((vdp = ddi_get_soft_state(xdf_ssp, XDF_INST(minor))) == NULL) || (!xdf_isopen(vdp, part))) return (ENXIO); DPRINTF(IOCTL_DBG, ("xdf@%s:ioctl: cmd %d (0x%x)\n", vdp->xdf_addr, cmd, cmd)); switch (cmd) { default: return (ENOTTY); case DKIOCG_PHYGEOM: case DKIOCG_VIRTGEOM: case DKIOCGGEOM: case DKIOCSGEOM: case DKIOCGAPART: case DKIOCSAPART: case DKIOCGVTOC: case DKIOCSVTOC: case DKIOCPARTINFO: case DKIOCGEXTVTOC: case DKIOCSEXTVTOC: case DKIOCEXTPARTINFO: case DKIOCGMBOOT: case DKIOCSMBOOT: case DKIOCGETEFI: case DKIOCSETEFI: case DKIOCPARTITION: return (cmlb_ioctl(vdp->xdf_vd_lbl, dev, cmd, arg, mode, credp, rvalp, NULL)); case FDEJECT: case DKIOCEJECT: case CDROMEJECT: return (xdf_ioctl_eject(vdp)); case DKIOCLOCK: return (xdf_ioctl_mlock(vdp)); case DKIOCUNLOCK: return (xdf_ioctl_munlock(vdp)); case CDROMREADOFFSET: { int offset = 0; if (!XD_IS_CD(vdp)) return (ENOTTY); if (ddi_copyout(&offset, (void *)arg, sizeof (int), mode)) return (EFAULT); return (0); } case DKIOCGMEDIAINFO: { struct dk_minfo media_info; media_info.dki_lbsize = DEV_BSIZE; media_info.dki_capacity = vdp->xdf_pgeom.g_capacity; if (XD_IS_CD(vdp)) media_info.dki_media_type = DK_CDROM; else media_info.dki_media_type = DK_FIXED_DISK; if (ddi_copyout(&media_info, (void *)arg, sizeof (struct dk_minfo), mode)) return (EFAULT); return (0); } case DKIOCINFO: { struct dk_cinfo info; /* controller information */ if (XD_IS_CD(vdp)) info.dki_ctype = DKC_CDROM; else info.dki_ctype = DKC_VBD; info.dki_cnum = 0; (void) strncpy((char *)(&info.dki_cname), "xdf", 8); /* unit information */ info.dki_unit = ddi_get_instance(vdp->xdf_dip); (void) strncpy((char *)(&info.dki_dname), "xdf", 8); info.dki_flags = DKI_FMTVOL; info.dki_partition = part; info.dki_maxtransfer = maxphys / DEV_BSIZE; info.dki_addr = 0; info.dki_space = 0; info.dki_prio = 0; info.dki_vec = 0; if (ddi_copyout(&info, (void *)arg, sizeof (info), mode)) return (EFAULT); return (0); } case DKIOCSTATE: { enum dkio_state mstate; if (ddi_copyin((void *)arg, &mstate, sizeof (mstate), mode) != 0) return (EFAULT); if ((rv = xdf_dkstate(vdp, mstate)) != 0) return (rv); mstate = vdp->xdf_mstate; if (ddi_copyout(&mstate, (void *)arg, sizeof (mstate), mode) != 0) return (EFAULT); return (0); } case DKIOCREMOVABLE: { int i = BOOLEAN2VOID(XD_IS_RM(vdp)); if (ddi_copyout(&i, (caddr_t)arg, sizeof (i), mode)) return (EFAULT); return (0); } case DKIOCGETWCE: { int i = BOOLEAN2VOID(XD_IS_RM(vdp)); if (ddi_copyout(&i, (void *)arg, sizeof (i), mode)) return (EFAULT); return (0); } case DKIOCSETWCE: { int i; if (ddi_copyin((void *)arg, &i, sizeof (i), mode)) return (EFAULT); vdp->xdf_wce = VOID2BOOLEAN(i); return (0); } case DKIOCFLUSHWRITECACHE: { struct dk_callback *dkc = (struct dk_callback *)arg; if (vdp->xdf_flush_supported) { rv = xdf_lb_rdwr(vdp->xdf_dip, TG_WRITE, NULL, 0, 0, (void *)dev); } else if (vdp->xdf_feature_barrier && !xdf_barrier_flush_disable) { rv = xdf_lb_rdwr(vdp->xdf_dip, TG_WRITE, vdp->xdf_cache_flush_block, xdf_flush_block, DEV_BSIZE, (void *)dev); } else { return (ENOTTY); } if ((mode & FKIOCTL) && (dkc != NULL) && (dkc->dkc_callback != NULL)) { (*dkc->dkc_callback)(dkc->dkc_cookie, rv); /* need to return 0 after calling callback */ rv = 0; } return (rv); } } /*NOTREACHED*/ } static int xdf_strategy(struct buf *bp) { xdf_t *vdp; minor_t minor; diskaddr_t p_blkct, p_blkst; ulong_t nblks; int part; minor = getminor(bp->b_edev); part = XDF_PART(minor); vdp = ddi_get_soft_state(xdf_ssp, XDF_INST(minor)); mutex_enter(&vdp->xdf_dev_lk); if (!xdf_isopen(vdp, part)) { mutex_exit(&vdp->xdf_dev_lk); xdf_io_err(bp, ENXIO, 0); return (0); } /* We don't allow IO from the oe_change callback thread */ ASSERT(curthread != vdp->xdf_oe_change_thread); /* Check for writes to a read only device */ if (!IS_READ(bp) && XD_IS_RO(vdp)) { mutex_exit(&vdp->xdf_dev_lk); xdf_io_err(bp, EROFS, 0); return (0); } /* Check if this I/O is accessing a partition or the entire disk */ if ((long)bp->b_private == XB_SLICE_NONE) { /* This I/O is using an absolute offset */ p_blkct = vdp->xdf_xdev_nblocks; p_blkst = 0; } else { /* This I/O is using a partition relative offset */ mutex_exit(&vdp->xdf_dev_lk); if (cmlb_partinfo(vdp->xdf_vd_lbl, part, &p_blkct, &p_blkst, NULL, NULL, NULL)) { xdf_io_err(bp, ENXIO, 0); return (0); } mutex_enter(&vdp->xdf_dev_lk); } /* check for a starting block beyond the disk or partition limit */ if (bp->b_blkno > p_blkct) { DPRINTF(IO_DBG, ("xdf@%s: block %lld exceeds VBD size %"PRIu64, vdp->xdf_addr, (longlong_t)bp->b_blkno, (uint64_t)p_blkct)); xdf_io_err(bp, EINVAL, 0); return (0); } /* Legacy: don't set error flag at this case */ if (bp->b_blkno == p_blkct) { bp->b_resid = bp->b_bcount; biodone(bp); return (0); } /* sanitize the input buf */ bioerror(bp, 0); bp->b_resid = 0; bp->av_back = bp->av_forw = NULL; /* Adjust for partial transfer, this will result in an error later */ nblks = bp->b_bcount >> XB_BSHIFT; if ((bp->b_blkno + nblks) > p_blkct) { bp->b_resid = ((bp->b_blkno + nblks) - p_blkct) << XB_BSHIFT; bp->b_bcount -= bp->b_resid; } DPRINTF(IO_DBG, ("xdf@%s: strategy blk %lld len %lu\n", vdp->xdf_addr, (longlong_t)bp->b_blkno, (ulong_t)bp->b_bcount)); /* Fix up the buf struct */ bp->b_flags |= B_BUSY; bp->b_private = (void *)(uintptr_t)p_blkst; xdf_bp_push(vdp, bp); mutex_exit(&vdp->xdf_dev_lk); xdf_io_start(vdp); if (do_polled_io) (void) xdf_ring_drain(vdp); return (0); } /*ARGSUSED*/ static int xdf_read(dev_t dev, struct uio *uiop, cred_t *credp) { xdf_t *vdp; minor_t minor; diskaddr_t p_blkcnt; int part; minor = getminor(dev); if ((vdp = ddi_get_soft_state(xdf_ssp, XDF_INST(minor))) == NULL) return (ENXIO); DPRINTF(IO_DBG, ("xdf@%s: read offset 0x%"PRIx64"\n", vdp->xdf_addr, (int64_t)uiop->uio_offset)); part = XDF_PART(minor); if (!xdf_isopen(vdp, part)) return (ENXIO); if (cmlb_partinfo(vdp->xdf_vd_lbl, part, &p_blkcnt, NULL, NULL, NULL, NULL)) return (ENXIO); if (U_INVAL(uiop)) return (EINVAL); return (physio(xdf_strategy, NULL, dev, B_READ, xdfmin, uiop)); } /*ARGSUSED*/ static int xdf_write(dev_t dev, struct uio *uiop, cred_t *credp) { xdf_t *vdp; minor_t minor; diskaddr_t p_blkcnt; int part; minor = getminor(dev); if ((vdp = ddi_get_soft_state(xdf_ssp, XDF_INST(minor))) == NULL) return (ENXIO); DPRINTF(IO_DBG, ("xdf@%s: write offset 0x%"PRIx64"\n", vdp->xdf_addr, (int64_t)uiop->uio_offset)); part = XDF_PART(minor); if (!xdf_isopen(vdp, part)) return (ENXIO); if (cmlb_partinfo(vdp->xdf_vd_lbl, part, &p_blkcnt, NULL, NULL, NULL, NULL)) return (ENXIO); if (uiop->uio_loffset >= XB_DTOB(p_blkcnt)) return (ENOSPC); if (U_INVAL(uiop)) return (EINVAL); return (physio(xdf_strategy, NULL, dev, B_WRITE, xdfmin, uiop)); } /*ARGSUSED*/ static int xdf_aread(dev_t dev, struct aio_req *aiop, cred_t *credp) { xdf_t *vdp; minor_t minor; struct uio *uiop = aiop->aio_uio; diskaddr_t p_blkcnt; int part; minor = getminor(dev); if ((vdp = ddi_get_soft_state(xdf_ssp, XDF_INST(minor))) == NULL) return (ENXIO); part = XDF_PART(minor); if (!xdf_isopen(vdp, part)) return (ENXIO); if (cmlb_partinfo(vdp->xdf_vd_lbl, part, &p_blkcnt, NULL, NULL, NULL, NULL)) return (ENXIO); if (uiop->uio_loffset >= XB_DTOB(p_blkcnt)) return (ENOSPC); if (U_INVAL(uiop)) return (EINVAL); return (aphysio(xdf_strategy, anocancel, dev, B_READ, xdfmin, aiop)); } /*ARGSUSED*/ static int xdf_awrite(dev_t dev, struct aio_req *aiop, cred_t *credp) { xdf_t *vdp; minor_t minor; struct uio *uiop = aiop->aio_uio; diskaddr_t p_blkcnt; int part; minor = getminor(dev); if ((vdp = ddi_get_soft_state(xdf_ssp, XDF_INST(minor))) == NULL) return (ENXIO); part = XDF_PART(minor); if (!xdf_isopen(vdp, part)) return (ENXIO); if (cmlb_partinfo(vdp->xdf_vd_lbl, part, &p_blkcnt, NULL, NULL, NULL, NULL)) return (ENXIO); if (uiop->uio_loffset >= XB_DTOB(p_blkcnt)) return (ENOSPC); if (U_INVAL(uiop)) return (EINVAL); return (aphysio(xdf_strategy, anocancel, dev, B_WRITE, xdfmin, aiop)); } static int xdf_dump(dev_t dev, caddr_t addr, daddr_t blkno, int nblk) { struct buf dumpbuf, *dbp = &dumpbuf; xdf_t *vdp; minor_t minor; int err = 0; int part; diskaddr_t p_blkcnt, p_blkst; minor = getminor(dev); if ((vdp = ddi_get_soft_state(xdf_ssp, XDF_INST(minor))) == NULL) return (ENXIO); DPRINTF(IO_DBG, ("xdf@%s: dump addr (0x%p) blk (%ld) nblks (%d)\n", vdp->xdf_addr, (void *)addr, blkno, nblk)); /* We don't allow IO from the oe_change callback thread */ ASSERT(curthread != vdp->xdf_oe_change_thread); part = XDF_PART(minor); if (!xdf_isopen(vdp, part)) return (ENXIO); if (cmlb_partinfo(vdp->xdf_vd_lbl, part, &p_blkcnt, &p_blkst, NULL, NULL, NULL)) return (ENXIO); if ((blkno + nblk) > p_blkcnt) { cmn_err(CE_WARN, "xdf@%s: block %ld exceeds VBD size %"PRIu64, vdp->xdf_addr, blkno + nblk, (uint64_t)p_blkcnt); return (EINVAL); } bioinit(dbp); dbp->b_flags = B_BUSY; dbp->b_un.b_addr = addr; dbp->b_bcount = nblk << DEV_BSHIFT; dbp->b_blkno = blkno; dbp->b_edev = dev; dbp->b_private = (void *)(uintptr_t)p_blkst; mutex_enter(&vdp->xdf_dev_lk); xdf_bp_push(vdp, dbp); mutex_exit(&vdp->xdf_dev_lk); xdf_io_start(vdp); err = xdf_ring_drain(vdp); biofini(dbp); return (err); } /*ARGSUSED*/ static int xdf_close(dev_t dev, int flag, int otyp, struct cred *credp) { minor_t minor; xdf_t *vdp; int part; ulong_t parbit; minor = getminor(dev); if ((vdp = ddi_get_soft_state(xdf_ssp, XDF_INST(minor))) == NULL) return (ENXIO); mutex_enter(&vdp->xdf_dev_lk); part = XDF_PART(minor); if (!xdf_isopen(vdp, part)) { mutex_exit(&vdp->xdf_dev_lk); return (ENXIO); } parbit = 1 << part; ASSERT((vdp->xdf_vd_open[otyp] & parbit) != 0); if (otyp == OTYP_LYR) { ASSERT(vdp->xdf_vd_lyropen[part] > 0); if (--vdp->xdf_vd_lyropen[part] == 0) vdp->xdf_vd_open[otyp] &= ~parbit; } else { vdp->xdf_vd_open[otyp] &= ~parbit; } vdp->xdf_vd_exclopen &= ~parbit; mutex_exit(&vdp->xdf_dev_lk); return (0); } static int xdf_open(dev_t *devp, int flag, int otyp, cred_t *credp) { minor_t minor; xdf_t *vdp; int part; ulong_t parbit; diskaddr_t p_blkct = 0; boolean_t firstopen; boolean_t nodelay; minor = getminor(*devp); if ((vdp = ddi_get_soft_state(xdf_ssp, XDF_INST(minor))) == NULL) return (ENXIO); nodelay = (flag & (FNDELAY | FNONBLOCK)); DPRINTF(DDI_DBG, ("xdf@%s: opening\n", vdp->xdf_addr)); /* do cv_wait until connected or failed */ mutex_enter(&vdp->xdf_cb_lk); mutex_enter(&vdp->xdf_dev_lk); if (!nodelay && (xdf_connect_locked(vdp, B_TRUE) != XD_READY)) { mutex_exit(&vdp->xdf_dev_lk); mutex_exit(&vdp->xdf_cb_lk); return (ENXIO); } mutex_exit(&vdp->xdf_cb_lk); if ((flag & FWRITE) && XD_IS_RO(vdp)) { mutex_exit(&vdp->xdf_dev_lk); return (EROFS); } part = XDF_PART(minor); parbit = 1 << part; if ((vdp->xdf_vd_exclopen & parbit) || ((flag & FEXCL) && xdf_isopen(vdp, part))) { mutex_exit(&vdp->xdf_dev_lk); return (EBUSY); } /* are we the first one to open this node? */ firstopen = !xdf_isopen(vdp, -1); if (otyp == OTYP_LYR) vdp->xdf_vd_lyropen[part]++; vdp->xdf_vd_open[otyp] |= parbit; if (flag & FEXCL) vdp->xdf_vd_exclopen |= parbit; mutex_exit(&vdp->xdf_dev_lk); /* force a re-validation */ if (firstopen) cmlb_invalidate(vdp->xdf_vd_lbl, NULL); /* If this is a non-blocking open then we're done */ if (nodelay) return (0); /* * This is a blocking open, so we require: * - that the disk have a valid label on it * - that the size of the partition that we're opening is non-zero */ if ((cmlb_partinfo(vdp->xdf_vd_lbl, part, &p_blkct, NULL, NULL, NULL, NULL) != 0) || (p_blkct == 0)) { (void) xdf_close(*devp, flag, otyp, credp); return (ENXIO); } return (0); } /*ARGSUSED*/ static void xdf_watch_hp_status_cb(dev_info_t *dip, const char *path, void *arg) { xdf_t *vdp = (xdf_t *)ddi_get_driver_private(dip); cv_broadcast(&vdp->xdf_hp_status_cv); } static int xdf_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int flags, char *name, caddr_t valuep, int *lengthp) { xdf_t *vdp = ddi_get_soft_state(xdf_ssp, ddi_get_instance(dip)); /* * Sanity check that if a dev_t or dip were specified that they * correspond to this device driver. On debug kernels we'll * panic and on non-debug kernels we'll return failure. */ ASSERT(ddi_driver_major(dip) == xdf_major); ASSERT((dev == DDI_DEV_T_ANY) || (getmajor(dev) == xdf_major)); if ((ddi_driver_major(dip) != xdf_major) || ((dev != DDI_DEV_T_ANY) && (getmajor(dev) != xdf_major))) return (DDI_PROP_NOT_FOUND); if (vdp == NULL) return (ddi_prop_op(dev, dip, prop_op, flags, name, valuep, lengthp)); return (cmlb_prop_op(vdp->xdf_vd_lbl, dev, dip, prop_op, flags, name, valuep, lengthp, XDF_PART(getminor(dev)), NULL)); } /*ARGSUSED*/ static int xdf_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **rp) { int instance = XDF_INST(getminor((dev_t)arg)); xdf_t *vbdp; switch (cmd) { case DDI_INFO_DEVT2DEVINFO: if ((vbdp = ddi_get_soft_state(xdf_ssp, instance)) == NULL) { *rp = NULL; return (DDI_FAILURE); } *rp = vbdp->xdf_dip; return (DDI_SUCCESS); case DDI_INFO_DEVT2INSTANCE: *rp = (void *)(uintptr_t)instance; return (DDI_SUCCESS); default: return (DDI_FAILURE); } } /*ARGSUSED*/ static int xdf_resume(dev_info_t *dip) { xdf_t *vdp; char *oename; if ((vdp = ddi_get_soft_state(xdf_ssp, ddi_get_instance(dip))) == NULL) goto err; if (xdf_debug & SUSRES_DBG) xen_printf("xdf@%s: xdf_resume\n", vdp->xdf_addr); mutex_enter(&vdp->xdf_cb_lk); if (xvdi_resume(dip) != DDI_SUCCESS) { mutex_exit(&vdp->xdf_cb_lk); goto err; } if (((oename = xvdi_get_oename(dip)) == NULL) || (xvdi_add_xb_watch_handler(dip, oename, XBP_HP_STATUS, xdf_watch_hp_status_cb, NULL) != DDI_SUCCESS)) { mutex_exit(&vdp->xdf_cb_lk); goto err; } mutex_enter(&vdp->xdf_dev_lk); ASSERT(vdp->xdf_state != XD_READY); xdf_set_state(vdp, XD_UNKNOWN); mutex_exit(&vdp->xdf_dev_lk); if (xdf_setstate_init(vdp) != DDI_SUCCESS) { mutex_exit(&vdp->xdf_cb_lk); goto err; } mutex_exit(&vdp->xdf_cb_lk); if (xdf_debug & SUSRES_DBG) xen_printf("xdf@%s: xdf_resume: done\n", vdp->xdf_addr); return (DDI_SUCCESS); err: if (xdf_debug & SUSRES_DBG) xen_printf("xdf@%s: xdf_resume: fail\n", vdp->xdf_addr); return (DDI_FAILURE); } static int xdf_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) { int n, instance = ddi_get_instance(dip); ddi_iblock_cookie_t ibc, softibc; boolean_t dev_iscd = B_FALSE; xdf_t *vdp; char *oename, *xsname, *str; if ((n = ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_NOTPROM, "xdf_debug", 0)) != 0) xdf_debug = n; switch (cmd) { case DDI_RESUME: return (xdf_resume(dip)); case DDI_ATTACH: break; default: return (DDI_FAILURE); } /* DDI_ATTACH */ if (((xsname = xvdi_get_xsname(dip)) == NULL) || ((oename = xvdi_get_oename(dip)) == NULL)) return (DDI_FAILURE); /* * Disable auto-detach. This is necessary so that we don't get * detached while we're disconnected from the back end. */ if ((ddi_prop_update_int(DDI_DEV_T_NONE, dip, DDI_NO_AUTODETACH, 1) != DDI_PROP_SUCCESS)) return (DDI_FAILURE); /* driver handles kernel-issued IOCTLs */ if (ddi_prop_create(DDI_DEV_T_NONE, dip, DDI_PROP_CANSLEEP, DDI_KERNEL_IOCTL, NULL, 0) != DDI_PROP_SUCCESS) return (DDI_FAILURE); if (ddi_get_iblock_cookie(dip, 0, &ibc) != DDI_SUCCESS) return (DDI_FAILURE); if (ddi_get_soft_iblock_cookie(dip, DDI_SOFTINT_LOW, &softibc) != DDI_SUCCESS) return (DDI_FAILURE); if (xenbus_read_str(xsname, XBP_DEV_TYPE, &str) != 0) { cmn_err(CE_WARN, "xdf@%s: cannot read device-type", ddi_get_name_addr(dip)); return (DDI_FAILURE); } if (strcmp(str, XBV_DEV_TYPE_CD) == 0) dev_iscd = B_TRUE; strfree(str); if (ddi_soft_state_zalloc(xdf_ssp, instance) != DDI_SUCCESS) return (DDI_FAILURE); DPRINTF(DDI_DBG, ("xdf@%s: attaching\n", ddi_get_name_addr(dip))); vdp = ddi_get_soft_state(xdf_ssp, instance); ddi_set_driver_private(dip, vdp); vdp->xdf_dip = dip; vdp->xdf_addr = ddi_get_name_addr(dip); vdp->xdf_suspending = B_FALSE; vdp->xdf_media_req_supported = B_FALSE; vdp->xdf_peer = INVALID_DOMID; vdp->xdf_evtchn = INVALID_EVTCHN; list_create(&vdp->xdf_vreq_act, sizeof (v_req_t), offsetof(v_req_t, v_link)); cv_init(&vdp->xdf_dev_cv, NULL, CV_DEFAULT, NULL); cv_init(&vdp->xdf_hp_status_cv, NULL, CV_DEFAULT, NULL); cv_init(&vdp->xdf_mstate_cv, NULL, CV_DEFAULT, NULL); mutex_init(&vdp->xdf_dev_lk, NULL, MUTEX_DRIVER, (void *)ibc); mutex_init(&vdp->xdf_cb_lk, NULL, MUTEX_DRIVER, (void *)ibc); mutex_init(&vdp->xdf_iostat_lk, NULL, MUTEX_DRIVER, (void *)ibc); vdp->xdf_cmbl_reattach = B_TRUE; if (dev_iscd) { vdp->xdf_dinfo |= VDISK_CDROM; vdp->xdf_mstate = DKIO_EJECTED; } else { vdp->xdf_mstate = DKIO_NONE; } if ((vdp->xdf_ready_tq = ddi_taskq_create(dip, "xdf_ready_tq", 1, TASKQ_DEFAULTPRI, 0)) == NULL) goto errout0; if (xvdi_add_xb_watch_handler(dip, oename, XBP_HP_STATUS, xdf_watch_hp_status_cb, NULL) != DDI_SUCCESS) goto errout0; if (ddi_add_softintr(dip, DDI_SOFTINT_LOW, &vdp->xdf_softintr_id, &softibc, NULL, xdf_iorestart, (caddr_t)vdp) != DDI_SUCCESS) { cmn_err(CE_WARN, "xdf@%s: failed to add softintr", ddi_get_name_addr(dip)); goto errout0; } /* * Initialize the physical geometry stucture. Note that currently * we don't know the size of the backend device so the number * of blocks on the device will be initialized to zero. Once * we connect to the backend device we'll update the physical * geometry to reflect the real size of the device. */ xdf_synthetic_pgeom(dip, &vdp->xdf_pgeom); vdp->xdf_pgeom_fixed = B_FALSE; /* * create default device minor nodes: non-removable disk * we will adjust minor nodes after we are connected w/ backend */ cmlb_alloc_handle(&vdp->xdf_vd_lbl); if (xdf_cmlb_attach(vdp) != 0) { cmn_err(CE_WARN, "xdf@%s: attach failed, cmlb attach failed", ddi_get_name_addr(dip)); goto errout0; } /* * We ship with cache-enabled disks */ vdp->xdf_wce = B_TRUE; mutex_enter(&vdp->xdf_cb_lk); /* Watch backend XenbusState change */ if (xvdi_add_event_handler(dip, XS_OE_STATE, xdf_oe_change, NULL) != DDI_SUCCESS) { mutex_exit(&vdp->xdf_cb_lk); goto errout0; } if (xdf_setstate_init(vdp) != DDI_SUCCESS) { cmn_err(CE_WARN, "xdf@%s: start connection failed", ddi_get_name_addr(dip)); mutex_exit(&vdp->xdf_cb_lk); goto errout1; } mutex_exit(&vdp->xdf_cb_lk); #if defined(XPV_HVM_DRIVER) xdf_hvm_add(dip); /* Report our version to dom0. */ if (xenbus_printf(XBT_NULL, "hvmpv/xdf", "version", "%d", HVMPV_XDF_VERS)) cmn_err(CE_WARN, "xdf: couldn't write version\n"); #else /* !XPV_HVM_DRIVER */ /* create kstat for iostat(1M) */ if (xdf_kstat_create(dip, "xdf", instance) != 0) { cmn_err(CE_WARN, "xdf@%s: failed to create kstat", ddi_get_name_addr(dip)); goto errout1; } #endif /* !XPV_HVM_DRIVER */ ddi_report_dev(dip); DPRINTF(DDI_DBG, ("xdf@%s: attached\n", vdp->xdf_addr)); return (DDI_SUCCESS); errout1: (void) xvdi_switch_state(vdp->xdf_dip, XBT_NULL, XenbusStateClosed); xvdi_remove_event_handler(dip, XS_OE_STATE); errout0: if (vdp->xdf_vd_lbl != NULL) { cmlb_detach(vdp->xdf_vd_lbl, NULL); cmlb_free_handle(&vdp->xdf_vd_lbl); vdp->xdf_vd_lbl = NULL; } if (vdp->xdf_softintr_id != NULL) ddi_remove_softintr(vdp->xdf_softintr_id); xvdi_remove_xb_watch_handlers(dip); if (vdp->xdf_ready_tq != NULL) ddi_taskq_destroy(vdp->xdf_ready_tq); mutex_destroy(&vdp->xdf_cb_lk); mutex_destroy(&vdp->xdf_dev_lk); cv_destroy(&vdp->xdf_dev_cv); cv_destroy(&vdp->xdf_hp_status_cv); ddi_soft_state_free(xdf_ssp, instance); ddi_set_driver_private(dip, NULL); ddi_prop_remove_all(dip); cmn_err(CE_WARN, "xdf@%s: attach failed", ddi_get_name_addr(dip)); return (DDI_FAILURE); } static int xdf_suspend(dev_info_t *dip) { int instance = ddi_get_instance(dip); xdf_t *vdp; if ((vdp = ddi_get_soft_state(xdf_ssp, instance)) == NULL) return (DDI_FAILURE); if (xdf_debug & SUSRES_DBG) xen_printf("xdf@%s: xdf_suspend\n", vdp->xdf_addr); xvdi_suspend(dip); mutex_enter(&vdp->xdf_cb_lk); mutex_enter(&vdp->xdf_dev_lk); vdp->xdf_suspending = B_TRUE; xdf_ring_destroy(vdp); xdf_set_state(vdp, XD_SUSPEND); vdp->xdf_suspending = B_FALSE; mutex_exit(&vdp->xdf_dev_lk); mutex_exit(&vdp->xdf_cb_lk); if (xdf_debug & SUSRES_DBG) xen_printf("xdf@%s: xdf_suspend: done\n", vdp->xdf_addr); return (DDI_SUCCESS); } static int xdf_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) { xdf_t *vdp; int instance; switch (cmd) { case DDI_PM_SUSPEND: break; case DDI_SUSPEND: return (xdf_suspend(dip)); case DDI_DETACH: break; default: return (DDI_FAILURE); } instance = ddi_get_instance(dip); DPRINTF(DDI_DBG, ("xdf@%s: detaching\n", ddi_get_name_addr(dip))); vdp = ddi_get_soft_state(xdf_ssp, instance); if (vdp == NULL) return (DDI_FAILURE); mutex_enter(&vdp->xdf_cb_lk); xdf_disconnect(vdp, XD_CLOSED, B_FALSE); if (vdp->xdf_state != XD_CLOSED) { mutex_exit(&vdp->xdf_cb_lk); return (DDI_FAILURE); } mutex_exit(&vdp->xdf_cb_lk); ASSERT(!ISDMACBON(vdp)); #if defined(XPV_HVM_DRIVER) xdf_hvm_rm(dip); #endif /* XPV_HVM_DRIVER */ if (vdp->xdf_timeout_id != 0) (void) untimeout(vdp->xdf_timeout_id); xvdi_remove_event_handler(dip, XS_OE_STATE); ddi_taskq_destroy(vdp->xdf_ready_tq); cmlb_detach(vdp->xdf_vd_lbl, NULL); cmlb_free_handle(&vdp->xdf_vd_lbl); /* we'll support backend running in domU later */ #ifdef DOMU_BACKEND (void) xvdi_post_event(dip, XEN_HP_REMOVE); #endif list_destroy(&vdp->xdf_vreq_act); ddi_prop_remove_all(dip); xdf_kstat_delete(dip); ddi_remove_softintr(vdp->xdf_softintr_id); xvdi_remove_xb_watch_handlers(dip); ddi_set_driver_private(dip, NULL); cv_destroy(&vdp->xdf_dev_cv); mutex_destroy(&vdp->xdf_cb_lk); mutex_destroy(&vdp->xdf_dev_lk); if (vdp->xdf_cache_flush_block != NULL) kmem_free(vdp->xdf_flush_mem, 2 * DEV_BSIZE); ddi_soft_state_free(xdf_ssp, instance); return (DDI_SUCCESS); } /* * Driver linkage structures. */ static struct cb_ops xdf_cbops = { xdf_open, xdf_close, xdf_strategy, nodev, xdf_dump, xdf_read, xdf_write, xdf_ioctl, nodev, nodev, nodev, nochpoll, xdf_prop_op, NULL, D_MP | D_NEW | D_64BIT, CB_REV, xdf_aread, xdf_awrite }; struct dev_ops xdf_devops = { DEVO_REV, /* devo_rev */ 0, /* devo_refcnt */ xdf_getinfo, /* devo_getinfo */ nulldev, /* devo_identify */ nulldev, /* devo_probe */ xdf_attach, /* devo_attach */ xdf_detach, /* devo_detach */ nodev, /* devo_reset */ &xdf_cbops, /* devo_cb_ops */ NULL, /* devo_bus_ops */ NULL, /* devo_power */ ddi_quiesce_not_supported, /* devo_quiesce */ }; /* * Module linkage structures. */ static struct modldrv modldrv = { &mod_driverops, /* Type of module. This one is a driver */ "virtual block driver", /* short description */ &xdf_devops /* driver specific ops */ }; static struct modlinkage xdf_modlinkage = { MODREV_1, (void *)&modldrv, NULL }; /* * standard module entry points */ int _init(void) { int rc; xdf_major = ddi_name_to_major("xdf"); if (xdf_major == (major_t)-1) return (EINVAL); if ((rc = ddi_soft_state_init(&xdf_ssp, sizeof (xdf_t), 0)) != 0) return (rc); xdf_vreq_cache = kmem_cache_create("xdf_vreq_cache", sizeof (v_req_t), 0, NULL, NULL, NULL, NULL, NULL, 0); xdf_gs_cache = kmem_cache_create("xdf_gs_cache", sizeof (ge_slot_t), 0, NULL, NULL, NULL, NULL, NULL, 0); #if defined(XPV_HVM_DRIVER) xdf_hvm_init(); #endif /* XPV_HVM_DRIVER */ if ((rc = mod_install(&xdf_modlinkage)) != 0) { #if defined(XPV_HVM_DRIVER) xdf_hvm_fini(); #endif /* XPV_HVM_DRIVER */ kmem_cache_destroy(xdf_vreq_cache); kmem_cache_destroy(xdf_gs_cache); ddi_soft_state_fini(&xdf_ssp); return (rc); } return (rc); } int _fini(void) { int err; if ((err = mod_remove(&xdf_modlinkage)) != 0) return (err); #if defined(XPV_HVM_DRIVER) xdf_hvm_fini(); #endif /* XPV_HVM_DRIVER */ kmem_cache_destroy(xdf_vreq_cache); kmem_cache_destroy(xdf_gs_cache); ddi_soft_state_fini(&xdf_ssp); return (0); } int _info(struct modinfo *modinfop) { return (mod_info(&xdf_modlinkage, modinfop)); }