vds.c revision d10e4ef2fabf16c3237c6d6592496df3eac6a1ef
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * CDDL HEADER START
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * The contents of this file are subject to the terms of the
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Common Development and Distribution License (the "License").
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * You may not use this file except in compliance with the License.
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * See the License for the specific language governing permissions
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * and limitations under the License.
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * When distributing Covered Code, include this CDDL HEADER in each
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * If applicable, add the following below this CDDL HEADER, with the
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * fields enclosed by brackets "[]" replaced with your own identifying
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * information: Portions Copyright [yyyy] [name of copyright owner]
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * CDDL HEADER END
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Use is subject to license terms.
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo#pragma ident "%Z%%M% %I% %E% SMI"
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Virtual disk server
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo/* Virtual disk server initialization flags */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo/* Virtual disk server tunable parameters */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo/* Identification parameters for MD, synthetic dkio(7i) structures, etc. */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo/* Virtual disk initialization flags */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo/* Flags for opening/closing backing devices via LDI */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * By Solaris convention, slice/partition 2 represents the entire disk;
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * unfortunately, this convention does not appear to be codified.
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo/* Return a cpp token as a string */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Print a message prefixed with the current function name to the message log
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * (and optionally to the console for verbose boots); these macros use cpp's
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * concatenation of string literals and C99 variable-length-argument-list
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo/* Return a pointer to the "i"th vdisk dring element */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo#define VD_DRING_ELEM(i) ((vd_dring_entry_t *)(void *) \
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo/* Return the virtual disk client's type as a string (for use in messages) */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo (((vd)->xfer_mode == VIO_DESC_MODE) ? "in-band client" : \
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo (((vd)->xfer_mode == VIO_DRING_MODE) ? "dring client" : \
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo "unsupported client")))
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo/* Debugging macros */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("dst:%x op:%x st:%u nb:%lx addr:%lx ncook:%u\n", \
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo#else /* !DEBUG */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo#define PR0(...)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo#define PR1(...)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo#define PR2(...)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo#endif /* DEBUG */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * Soft state structure for a vds instance
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppotypedef struct vds {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo uint_t initialized; /* driver inst initialization flags */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo ldi_ident_t ldi_ident; /* driver's identifier for LDI */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo mod_hash_t *vd_table; /* table of virtual disks served */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * Types of descriptor-processing tasks
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayantypedef enum vd_task_type {
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan VD_NONFINAL_RANGE_TASK, /* task for intermediate descriptor in range */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan VD_FINAL_RANGE_TASK, /* task for last in a range of descriptors */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * Structure describing the task for processing a descriptor
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayantypedef struct vd_task {
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan vd_dring_payload_t *request; /* request task will perform */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * Soft state structure for a virtual disk instance
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppotypedef struct vd {
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan ddi_taskq_t *startq; /* queue for I/O start tasks */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan ddi_taskq_t *completionq; /* queue for completion tasks */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo ldi_handle_t ldi_handle[V_NUMPAR]; /* LDI slice handles */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo struct dk_geom dk_geom; /* synthetic for slice type */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo ldc_dring_handle_t dring_handle; /* handle for dring ops */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan vd_task_t inband_task; /* task for inband descriptor */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan boolean_t reset_state; /* reset connection state? */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppotypedef struct vds_operation {
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lmtypedef struct vd_ioctl {
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* convert input vd_buf to output ioctl_arg */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* convert input ioctl_arg to output vd_buf */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm/* Define trivial copyin/copyout conversion function flag */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppostatic void *vds_state;
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppostatic uint64_t vds_operations; /* see vds_operation[] definition below */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * Supported protocol version pairs, from highest (newest) to lowest (oldest)
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * Each supported major version should appear only once, paired with (and only
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * with) its highest supported minor version number (as the protocol requires
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * supporting all lower minor version numbers as well)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo#endif /* DEBUG */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (EINVAL); /* no service for trivial requests */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan (request->operation == VD_OP_BREAD) ? "Read" : "Write",
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan buf->b_un.b_addr = kmem_alloc(buf->b_bcount, KM_SLEEP);
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Get data to write from client */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan if ((status = ldc_mem_copy(vd->ldc_handle, buf->b_un.b_addr, 0,
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Start the block I/O */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if ((status == 0) &&
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan ((status = ldi_strategy(vd->ldi_handle[request->slice], buf)) == 0))
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan return (EINPROGRESS); /* will complete on completionq */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Clean up after error */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayansend_msg(ldc_handle_t ldc_handle, void *msg, size_t msglen)
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan return (0);
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * Reset the state of the connection with a client, if needed; reset the LDC
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * transport as well, if needed. This function should only be called from the
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * "startq", as it waits for tasks on the "completionq" and will deadlock if
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * called from that queue.
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan PR0("Resetting connection state with %s", VD_CLIENT(vd));
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * Let any asynchronous I/O complete before possibly pulling the rug
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * out from under it; defer checking vd->reset_ldc, as one of the
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * asynchronous tasks might set it
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan ((status = ldc_mem_dring_unmap(vd->dring_handle)) != 0))
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan PRN("ldc_mem_dring_unmap() returned errno %d", status);
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan if (vd->reset_ldc && ((status = ldc_reset(vd->ldc_handle)) != 0))
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan vd->initialized &= ~(VD_SID | VD_SEQ_NUM | VD_DRING);
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan vd->max_msglen = sizeof (vio_msg_t); /* baseline vio message size */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayanvd_mark_elem_done(vd_t *vd, int idx, int elem_status)
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Acquire the element */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan if ((status = ldc_mem_dring_acquire(vd->dring_handle, idx, idx)) != 0) {
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan PRN("ldc_mem_dring_acquire() returned errno %d", status);
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Set the element's status and mark it done */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Perhaps client timed out waiting for I/O... */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Release the element */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan if ((status = ldc_mem_dring_release(vd->dring_handle, idx, idx)) != 0) {
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan PRN("ldc_mem_dring_release() returned errno %d", status);
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Wait for the I/O to complete */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* If data was read, copy it to the client */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan if ((request->status == 0) && (request->operation == VD_OP_BREAD) &&
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan ((status = ldc_mem_copy(vd->ldc_handle, buf->b_un.b_addr, 0,
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan &request->nbytes, request->cookie, request->ncookies,
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan PRN("ldc_mem_copy() returned errno %d copying to client",
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Release I/O buffer */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Update the dring element for a dring client */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan if ((status == 0) && (vd->xfer_mode == VIO_DRING_MODE))
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan status = vd_mark_elem_done(vd, task->index, request->status);
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * If a transport error occurred, arrange to "nack" the message when
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * the final task in the descriptor element range completes
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * Only the final task for a range of elements will respond to and
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * free the message
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * Send the "ack" or "nack" back to the client; if sending the message
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * via LDC fails, arrange to reset both the connection state and LDC
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan (task->msg->tag.vio_subtype == VIO_SUBTYPE_ACK) ? "ACK" : "NACK");
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan if (send_msg(vd->ldc_handle, task->msg, task->msglen) != 0)
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Free the message now that it has been used for the reply */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lmstatic void
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm VD_GEOM2DK_GEOM((vd_geom_t *)vd_buf, (struct dk_geom *)ioctl_arg);
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lmstatic void
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm VD_VTOC2VTOC((vd_vtoc_t *)vd_buf, (struct vtoc *)ioctl_arg);
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lmstatic void
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm DK_GEOM2VD_GEOM((struct dk_geom *)ioctl_arg, (vd_geom_t *)vd_buf);
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lmstatic void
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm VTOC2VD_VTOC((struct vtoc *)ioctl_arg, (vd_vtoc_t *)vd_buf);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo switch (cmd) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (0);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (0);
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lmvd_do_ioctl(vd_t *vd, vd_dring_payload_t *request, void* buf, vd_ioctl_t *ioctl)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo size_t nbytes = request->nbytes; /* modifiable copy */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* Get data from client and convert, if necessary */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if ((status = ldc_mem_copy(vd->ldc_handle, buf, 0, &nbytes,
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* Convert client's data, if necessary */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm if (ioctl->copyin == VD_IDENTITY) /* use client buffer */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm else /* convert client vdisk operation data to ioctl data */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Handle single-slice block devices internally; otherwise, have the
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * real driver perform the ioctl()
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (vd->vdisk_type == VD_DISK_TYPE_SLICE && !vd->pseudo) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo } else if ((status = ldi_ioctl(vd->ldi_handle[request->slice],
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan ioctl->cmd, (intptr_t)ioctl->arg, (vd_open_flags | FKIOCTL),
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PR0("ldi_ioctl(%s) = errno %d", ioctl->cmd_name, status);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (rval != 0) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("%s set rval = %d, which is not being returned to client",
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo#endif /* DEBUG */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* Convert data and send to client, if necessary */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* Convert ioctl data to vdisk operation data, if necessary */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if ((status = ldc_mem_copy(vd->ldc_handle, buf, 0, &nbytes,
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * Open any slices which have become non-empty as a result of performing a
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * set-VTOC operation for the client.
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * When serving a full disk, vds attempts to exclusively open all of the
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * disk's slices to prevent another thread or process in the service domain
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * from "stealing" a slice or from performing I/O to a slice while a vds
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * client is accessing it. Unfortunately, underlying drivers, such as sd(7d)
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * and cmdk(7d), return an error when attempting to open the device file for a
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * slice which is currently empty according to the VTOC. This driver behavior
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * means that vds must skip opening empty slices when initializing a vdisk for
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * full-disk service and try to open slices that become non-empty (via a
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * set-VTOC operation) during use of the full disk in order to begin serving
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * such slices to the client. This approach has an inherent (and therefore
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * unavoidable) race condition; it also means that failure to open a
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * newly-non-empty slice has different semantics than failure to open an
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * initially-non-empty slice: Due to driver bahavior, opening a
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * newly-non-empty slice is a necessary side effect of vds performing a
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * (successful) set-VTOC operation for a client on an in-service (and in-use)
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * disk in order to begin serving the slice; failure of this side-effect
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * operation does not mean that the client's set-VTOC operation failed or that
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * operations on other slices must fail. Therefore, this function prints an
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * error message on failure to open a slice, but does not return an error to
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * its caller--unlike failure to open a slice initially, which results in an
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * error that prevents serving the vdisk (and thereby requires an
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * administrator to resolve the problem). Note that, apart from another
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * thread or process opening a new slice during the race-condition window,
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * failure to open a slice in this function will likely indicate an underlying
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * drive problem, which will also likely become evident in errors returned by
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * operations on other slices, and which will require administrative
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * intervention and possibly servicing the drive.
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lmstatic void
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* Get the (new) VTOC for updated slice sizes */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm if ((status = ldi_ioctl(vd->ldi_handle[0], DKIOCGVTOC, (intptr_t)&vtoc,
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* Open any newly-non-empty slices */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* Skip zero-length slices */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* Skip already-open slices */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo#define RNDSIZE(expr) P2ROUNDUP(sizeof (expr), sizeof (uint64_t))
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Command (no-copy) operations */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* "Get" (copy-out) operations */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm {VD_OP_GET_VTOC, STRINGIZE(VD_OP_GET_VTOC), RNDSIZE(vd_vtoc_t),
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* "Set" (copy-in) operations */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm {VD_OP_SET_VTOC, STRINGIZE(VD_OP_SET_VTOC), RNDSIZE(vd_vtoc_t),
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo size_t nioctls = (sizeof (ioctl))/(sizeof (ioctl[0]));
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Determine ioctl corresponding to caller's "operation" and
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * validate caller's "nbytes"
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo for (i = 0; i < nioctls; i++) {
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* LDC memory operations require 8-byte multiples */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo ASSERT(i < nioctls); /* because "operation" already validated */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Define the supported operations once the functions for performing them have
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * been defined
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * Process a task specifying a client I/O request
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Range-check slice */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Find the requested operation */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo for (i = 0; i < vds_noperations; i++)
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan PRN("Unsupported operation %u", request->operation);
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Start the operation */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan if ((status = vds_operation[i].start(task)) != EINPROGRESS) {
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan request->status = status; /* op succeeded or failed */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan return (0); /* but request completed */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan ASSERT(vds_operation[i].complete != NULL); /* debug case */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan if (vds_operation[i].complete == NULL) { /* non-debug case */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan "with no I/O completion handler");
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan return (0); /* but request completed */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Queue a task to complete the operation */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan status = ddi_taskq_dispatch(vd->completionq, vds_operation[i].complete,
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* ddi_taskq_dispatch(9f) guarantees success with DDI_SLEEP */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan return (EINPROGRESS); /* completion handler will finish request */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * Return true if the "type", "subtype", and "env" fields of the "tag" first
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * argument match the corresponding remaining arguments; otherwise, return false
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppovd_msgtype(vio_msg_tag_t *tag, int type, int subtype, int env)
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * Check whether the major/minor version specified in "ver_msg" is supported
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * by this server.
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm for (int i = 0; i < vds_num_versions; i++) {
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm ASSERT((i == 0) ||
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * If the major versions match, adjust the minor version, if
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * necessary, down to the highest value supported by this
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * server and return true so this message will get "ack"ed;
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * the client should also support all minor versions lower
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * than the value it sent
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * If the message contains a higher major version number, set
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * the message's major/minor versions to the current values
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * and return false, so this message will get "nack"ed with
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * these values, and the client will potentially try again
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * with the same or a lower version
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * Otherwise, the message's major version is less than the
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * current major version, so continue the loop to the next
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * (lower) supported version
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * No common version was found; "ground" the version pair in the
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * message to terminate negotiation
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * Process a version message from a client. vds expects to receive version
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * messages from clients seeking service, but never issues version messages
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * itself; therefore, vds can ACK or NACK client version messages, but does
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * not expect to receive version-message ACKs or NACKs (and will treat such
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * messages as invalid).
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lmvd_process_ver_msg(vd_t *vd, vio_msg_t *msg, size_t msglen)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (!vd_msgtype(&msg->tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO,
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * We're talking to the expected kind of client; set our device class
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * for "ack/nack" back to the client
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * Check whether the (valid) version message specifies a version
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * supported by this server. If the version is not supported, return
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * EBADMSG so the message will get "nack"ed; vds_supported_version()
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * will have updated the message with a supported version for the
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * client to consider
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * A version has been agreed upon; use the client's SID for
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * communication on this channel now
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * When multiple versions are supported, this function should store
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * the negotiated major and minor version values in the "vd" data
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * structure to govern further communication; in particular, note that
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * the client might have specified a lower minor version for the
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * agreed major version than specifed in the vds_version[] array. The
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * following assertions should help remind future maintainers to make
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * the appropriate changes to support multiple versions.
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (0);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppovd_process_attr_msg(vd_t *vd, vio_msg_t *msg, size_t msglen)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (!vd_msgtype(&msg->tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO,
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("Received maximum transfer size of 0 from client");
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Success: valid message and transfer mode */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * The vd_dring_inband_msg_t contains one cookie; need room
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * for up to n-1 more cookies, where "n" is the number of full
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * pages plus possibly one partial page required to cover
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * "max_xfer_sz". Add room for one more cookie if
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * "max_xfer_sz" isn't an integral multiple of the page size.
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Must first get the maximum transfer size in bytes.
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Set the maximum expected message length to
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * accommodate in-band-descriptor messages with all
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * their cookies
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo vd->max_msglen = MAX(vd->max_msglen, max_inband_msglen);
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * Initialize the data structure for processing in-band I/O
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * request descriptors
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan vd->inband_task.type = VD_FINAL_RANGE_TASK; /* range == 1 */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (0);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppovd_process_dring_reg_msg(vd_t *vd, vio_msg_t *msg, size_t msglen)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo vio_dring_reg_msg_t *reg_msg = (vio_dring_reg_msg_t *)msg;
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (!vd_msgtype(&msg->tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO,
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("Expected at least %lu-byte register-dring message; "
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo (reg_msg->ncookies - 1)*(sizeof (reg_msg->cookie[0]));
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("A dring was previously registered; only support one");
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan PRN("reg_msg->num_descriptors = %u; must be <= %u (%s)",
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan reg_msg->ncookies, INT32_MAX, STRINGIZE(INT32_MAX));
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * In addition to fixing the assertion in the success case
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * below, supporting drings which require more than one
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * "cookie" requires increasing the value of vd->max_msglen
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * somewhere in the code path prior to receiving the message
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * which results in calling this function. Note that without
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * making this change, the larger message size required to
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * accommodate multiple cookies cannot be successfully
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * received, so this function will not even get called.
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Gracefully accommodating more dring cookies might
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * reasonably demand exchanging an additional attribute or
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * making a minor protocol adjustment
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("reg_msg->ncookies = %u != 1", reg_msg->ncookies);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo status = ldc_mem_dring_map(vd->ldc_handle, reg_msg->cookie,
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo reg_msg->descriptor_size, LDC_SHADOW_MAP, &vd->dring_handle);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (status != 0) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * To remove the need for this assertion, must call
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * ldc_mem_dring_nextcookie() successfully ncookies-1 times after a
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * successful call to ldc_mem_dring_map()
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo ldc_mem_dring_info(vd->dring_handle, &dring_minfo)) != 0) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("ldc_mem_dring_info() returned errno %d", status);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if ((status = ldc_mem_dring_unmap(vd->dring_handle)) != 0)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("ldc_mem_dring_unmap() returned errno %d", status);
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Initialize for valid message and mapped dring */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * Allocate and initialize a "shadow" array of data structures for
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * tasks to process I/O requests in dring elements
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan kmem_zalloc((sizeof (*vd->dring_task)) * vd->dring_len, KM_SLEEP);
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan vd->dring_task[i].request = &VD_DRING_ELEM(i)->payload;
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (0);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppovd_process_dring_unreg_msg(vd_t *vd, vio_msg_t *msg, size_t msglen)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo vio_dring_unreg_msg_t *unreg_msg = (vio_dring_unreg_msg_t *)msg;
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (!vd_msgtype(&msg->tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO,
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (0);
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan if (!vd_msgtype(&msg->tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO, VIO_RDX)) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("Expected %lu-byte RDX message; received %lu bytes",
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (0);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if ((vd->initialized & VD_SEQ_NUM) && (seq_num != vd->seq_num + 1)) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (1);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo vd->initialized |= VD_SEQ_NUM; /* superfluous after first time... */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (0);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Return the expected size of an inband-descriptor message with all the
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * cookies it claims to include
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return ((sizeof (*msg)) +
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo (msg->payload.ncookies - 1)*(sizeof (msg->payload.cookie[0])));
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Process an in-band descriptor message: used with clients like OBP, with
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * which vds exchanges descriptors within VIO message payloads, rather than
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * operating on them within a descriptor ring
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayanvd_process_desc_msg(vd_t *vd, vio_msg_t *msg, size_t msglen, size_t msgsize)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo vd_dring_inband_msg_t *desc_msg = (vd_dring_inband_msg_t *)msg;
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (!vd_msgtype(&msg->tag, VIO_TYPE_DATA, VIO_SUBTYPE_INFO,
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan PR1("Message is not an in-band-descriptor message");
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (msglen != (expected = expected_inband_size(desc_msg))) {
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan if (vd_check_seq_num(vd, desc_msg->hdr.seq_num) != 0)
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * Valid message: Set up the in-band descriptor task and process the
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * request. Arrange to acknowledge the client's message, unless an
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * error processing the descriptor task results in setting
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * VIO_SUBTYPE_NACK
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayanvd_process_element(vd_t *vd, vd_task_type_t type, uint32_t idx,
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Accept the updated dring element */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan if ((status = ldc_mem_dring_acquire(vd->dring_handle, idx, idx)) != 0) {
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan PRN("ldc_mem_dring_acquire() returned errno %d", status);
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan if ((status = ldc_mem_dring_release(vd->dring_handle, idx, idx)) != 0) {
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan PRN("ldc_mem_dring_release() returned errno %d", status);
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Initialize a task and process the accepted element */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan if ((status = vd_process_task(&vd->dring_task[idx])) != EINPROGRESS)
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan status = vd_mark_elem_done(vd, idx, elem->payload.status);
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayanvd_process_element_range(vd_t *vd, int start, int end,
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * Arrange to acknowledge the client's message, unless an error
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * processing one of the dring elements results in setting
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * VIO_SUBTYPE_NACK
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * Process the dring elements in the range
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan nelem = ((end < start) ? end + vd->dring_len : end) - start + 1;
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan for (i = start, n = nelem; n > 0; i = (i + 1) % vd->dring_len, n--) {
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan type = (n == 1) ? VD_FINAL_RANGE_TASK : VD_NONFINAL_RANGE_TASK;
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan status = vd_process_element(vd, type, i, msg, msglen, msgsize);
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan else if (status != 0)
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * If some, but not all, operations of a multi-element range are in
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * progress, wait for other operations to complete before returning
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * (which will result in "ack" or "nack" of the message). Note that
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * all outstanding operations will need to complete, not just the ones
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * corresponding to the current range of dring elements; howevever, as
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * this situation is an error case, performance is less critical.
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan if ((nelem > 1) && (status != EINPROGRESS) && inprogress)
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayanvd_process_dring_msg(vd_t *vd, vio_msg_t *msg, size_t msglen, size_t msgsize)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (!vd_msgtype(&msg->tag, VIO_TYPE_DATA, VIO_SUBTYPE_INFO,
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("Expected %lu-byte dring message; received %lu bytes",
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan PRN("\"end_idx\" = %u; must be >= 0 and less than %u",
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Valid message; process range of updated dring elements */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan PR1("Processing descriptor range, start = %u, end = %u",
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan return (vd_process_element_range(vd, dring_msg->start_idx,
1ae0874509b6811fdde1dfd46f0d93fd09867a3fhepporecv_msg(ldc_handle_t ldc_handle, void *msg, size_t *nbytes)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (status != 0) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo } else if (*nbytes == 0) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (0);
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayanvd_do_process_msg(vd_t *vd, vio_msg_t *msg, size_t msglen, size_t msgsize)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PR1("Processing (%x/%x/%x) message", msg->tag.vio_msgtype,
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Validate session ID up front, since it applies to all messages
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if ((msg->tag.vio_sid != vd->sid) && (vd->initialized & VD_SID)) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Process the received message based on connection state
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Version negotiated, move to that state */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (0);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if ((status = vd_process_attr_msg(vd, msg, msglen)) != 0)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Attributes exchanged, move to that state */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (0);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Ready to receive in-band descriptors */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (0);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo case VIO_DRING_MODE: /* expect register-dring message */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* One dring negotiated, move to that state */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (0);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo case VD_STATE_DRING: /* expect RDX, register-dring, or unreg-dring */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Ready to receive data */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (0);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * If another register-dring message is received, stay in
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * dring state in case the client sends RDX; although the
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * protocol allows multiple drings, this server does not
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * support using more than one
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Acknowledge an unregister-dring message, but reset the
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * connection anyway: Although the protocol allows
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * unregistering drings, this server cannot serve a vdisk
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * without its only dring
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo case VIO_DESC_MODE: /* expect in-band-descriptor message */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan return (vd_process_desc_msg(vd, msg, msglen, msgsize));
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo case VIO_DRING_MODE: /* expect dring-data or unreg-dring */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Typically expect dring-data messages, so handle
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * them first
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Acknowledge an unregister-dring message, but reset
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * the connection anyway: Although the protocol
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * allows unregistering drings, this server cannot
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * serve a vdisk without its only dring
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayanvd_process_msg(vd_t *vd, vio_msg_t *msg, size_t msglen, size_t msgsize)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Check that the message is at least big enough for a "tag", so that
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * message processing can proceed based on tag-specified message type
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Can't "nack" short message, so drop the big hammer */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Process the message
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan switch (status = vd_do_process_msg(vd, msg, msglen, msgsize)) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* "ack" valid, successfully-processed messages */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* The completion handler will "ack" or "nack" the message */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* "nack" invalid messages */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* "nack" failed messages */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* An LDC error probably occurred, so try resetting it */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Send the "ack" or "nack" to the client */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo (msg->tag.vio_subtype == VIO_SUBTYPE_ACK) ? "ACK" : "NACK");
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Arrange to reset the connection for nack'ed or failed messages */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan * Receive and process a message
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan vd_reset_if_needed(vd); /* can change vd->max_msglen */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan msgsize = vd->max_msglen; /* stable copy for alloc/free */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan msglen = msgsize; /* actual length after recv_msg() */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan if ((status = recv_msg(vd->ldc_handle, vio_msg, &msglen)) ==
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan continue; /* handler will free msg */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Probably an LDC failure; arrange to reset it */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan PR0("LDC channel came up: Resetting client connection state");
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* Queue a task to receive the new data */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan status = ddi_taskq_dispatch(vd->startq, vd_recv_msg, vd,
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* ddi_taskq_dispatch(9f) guarantees success with DDI_SLEEP */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppovds_check_for_vd(mod_hash_key_t key, mod_hash_val_t *val, void *arg)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo switch (cmd) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* the real work happens below */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if ((vds = ddi_get_soft_state(vds_state, instance)) == NULL) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Do no detach when serving any vdisks */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo mod_hash_walk(vds->vd_table, vds_check_for_vd, &vd_present);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo for (parent = ddi_get_parent(dip); (parent != NULL) && (parent != root);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (strcmp(ddi_get_name(parent), DEVI_PSEUDO_NEXNAME) == 0)
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm minor_t minor = getminor(vd->dev[0]) - VD_ENTIRE_DISK_SLICE;
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* Get the VTOC for slice sizes */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm if ((status = ldi_ioctl(vd->ldi_handle[0], DKIOCGVTOC, (intptr_t)&vtoc,
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* Set full-disk parameters */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* Move dev number and LDI handle to entire-disk-slice array elements */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm vd->ldi_handle[VD_ENTIRE_DISK_SLICE] = vd->ldi_handle[0];
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* Initialize device numbers for remaining slices and open them */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * Skip the entire-disk slice, as it's already open and its
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * device known
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * Construct the device number for the current slice
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * At least some underlying drivers refuse to open
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * devices for (currently) zero-length slices, so skip
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * them for now
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * Open all non-empty slices of the disk to serve them to the
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * client. Slices are opened exclusively to prevent other
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * threads or processes in the service domain from performing
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * I/O to slices being accessed by a client. Failure to open
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * a slice results in vds not serving this disk, as the client
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * could attempt (and should be able) to access any non-empty
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * slice immediately. Any slices successfully opened before a
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * failure will get closed by vds_destroy_vd() as a result of
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm * the error returned by this function.
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* vds_destroy_vd() will close any open slices */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm return (0);
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm if ((status = ldi_open_by_name(block_device, vd_open_flags, kcred,
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm PRN("ldi_open_by_name(%s) = errno %d", block_device, status);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Get block device's device number, otyp, and size */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm if ((status = ldi_get_dev(vd->ldi_handle[0], &vd->dev[0])) != 0) {
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm if ((status = ldi_get_otyp(vd->ldi_handle[0], &otyp)) != 0) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("Cannot serve non-block device %s", block_device);
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm if (ldi_get_size(vd->ldi_handle[0], &vd->vdisk_size) != DDI_SUCCESS) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Determine if backing block device is a pseudo device */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if ((dip = ddi_hold_devi_by_instance(getmajor(vd->dev[0]),
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (0); /* ...and we're done */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Get dk_cinfo to determine slice of backing block device */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan (intptr_t)&dk_cinfo, (vd_open_flags | FKIOCTL), kcred,
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* If slice is entire-disk slice, initialize for full disk */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* Otherwise, we have a non-entire slice of a block device */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Initialize dk_geom structure for single-slice block device */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan (intptr_t)&vd->dk_geom, (vd_open_flags | FKIOCTL), kcred,
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("%s geometry claims 0 sectors per track", block_device);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo lbtodb(vd->vdisk_size)/vd->dk_geom.dkg_nsect/vd->dk_geom.dkg_nhead;
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo vd->dk_geom.dkg_pcyl = vd->dk_geom.dkg_ncyl + vd->dk_geom.dkg_acyl;
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Initialize vtoc structure for single-slice block device */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan (intptr_t)&vd->vtoc, (vd_open_flags | FKIOCTL), kcred,
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo MIN(sizeof (VD_VOLUME_NAME), sizeof (vd->vtoc.v_volume)));
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo MIN(sizeof (VD_ASCIILABEL), sizeof (vd->vtoc.v_asciilabel)));
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (0);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppovds_do_init_vd(vds_t *vds, uint64_t id, char *block_device, uint64_t ldc_id,
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if ((vd = kmem_zalloc(sizeof (*vd), KM_NOSLEEP)) == NULL) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo *vdp = vd; /* assign here so vds_destroy_vd() can cleanup later */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* Open vdisk and initialize parameters */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo ((vd->vdisk_type == VD_DISK_TYPE_DISK) ? "disk" : "slice"),
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Initialize locking */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (ddi_get_soft_iblock_cookie(vds->dip, DDI_SOFTINT_MED,
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Create start and completion task queues for the vdisk */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan (void) snprintf(tq_name, sizeof (tq_name), "vd_startq%lu", id);
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan if ((vd->startq = ddi_taskq_create(vds->dip, tq_name, 1,
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan (void) snprintf(tq_name, sizeof (tq_name), "vd_completionq%lu", id);
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan if ((vd->completionq = ddi_taskq_create(vds->dip, tq_name, 1,
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan vd->enabled = 1; /* before callback can dispatch to startq */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Bring up LDC */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if ((status = ldc_init(ldc_id, &ldc_attr, &vd->ldc_handle)) != 0) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if ((status = ldc_reg_callback(vd->ldc_handle, vd_handle_ldc_events,
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Add the successfully-initialized vdisk to the server's table */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (mod_hash_insert(vds->vd_table, (mod_hash_key_t)id, vd) != 0) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (0);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * Destroy the state associated with a virtual disk
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Disable queuing requests for the vdisk */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Drain and destroy start queue (*before* destroying completionq) */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan ddi_taskq_destroy(vd->startq); /* waits for queued tasks */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan /* Drain and destroy completion queue (*before* shutting down LDC) */
d10e4ef2fabf16c3237c6d6592496df3eac6a1efnarayan ddi_taskq_destroy(vd->completionq); /* waits for tasks */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Shut down LDC */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Close any open backing-device slices */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo for (uint_t slice = 0; slice < vd->nslices; slice++) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Free lock */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Finally, free the vdisk structure itself */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppovds_init_vd(vds_t *vds, uint64_t id, char *block_device, uint64_t ldc_id)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo#endif /* lint */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if ((status = vds_do_init_vd(vds, id, block_device, ldc_id, &vd)) != 0)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppovds_do_get_ldc_id(md_t *md, mde_cookie_t vd_node, mde_cookie_t *channel,
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Look for channel endpoint child(ren) of the vdisk MD node */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("No \"%s\" found for virtual disk", VD_CHANNEL_ENDPOINT);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (-1);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Get the "id" value for the first channel endpoint node */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (md_get_prop_val(md, channel[0], VD_ID_PROP, ldc_id) != 0) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (-1);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("Using ID of first of multiple channels for this vdisk");
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (0);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppovds_get_ldc_id(md_t *md, mde_cookie_t vd_node, uint64_t *ldc_id)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("Invalid node count in Machine Description subtree");
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (-1);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo status = vds_do_get_ldc_id(md, vd_node, channel, ldc_id);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (md_get_prop_val(md, vd_node, VD_ID_PROP, &id) != 0) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (md_get_prop_str(md, vd_node, VD_BLOCK_DEVICE_PROP,
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("Error getting vdisk \"%s\"", VD_BLOCK_DEVICE_PROP);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (vds_init_vd(vds, id, block_device, ldc_id) != 0) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppovds_remove_vd(vds_t *vds, md_t *md, mde_cookie_t vd_node)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (md_get_prop_val(md, vd_node, VD_ID_PROP, &id) != 0) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("Unable to get \"%s\" property from vdisk's MD node",
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (mod_hash_destroy(vds->vd_table, (mod_hash_key_t)id) != 0)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppovds_change_vd(vds_t *vds, md_t *prev_md, mde_cookie_t prev_vd_node,
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Validate that vdisk ID has not changed */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (md_get_prop_val(prev_md, prev_vd_node, VD_ID_PROP, &prev_id) != 0) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (md_get_prop_val(curr_md, curr_vd_node, VD_ID_PROP, &curr_id) != 0) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("Error getting current vdisk \"%s\" property", VD_ID_PROP);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Validate that LDC ID has not changed */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (vds_get_ldc_id(prev_md, prev_vd_node, &prev_ldc_id) != 0) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (vds_get_ldc_id(curr_md, curr_vd_node, &curr_ldc_id) != 0) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo "LDC ID changed from %lu to %lu", prev_ldc_id, curr_ldc_id);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Determine whether device path has changed */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (md_get_prop_str(prev_md, prev_vd_node, VD_BLOCK_DEVICE_PROP,
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (md_get_prop_str(curr_md, curr_vd_node, VD_BLOCK_DEVICE_PROP,
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("Error getting current vdisk \"%s\"", VD_BLOCK_DEVICE_PROP);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return; /* no relevant (supported) change */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Remove old state, which will close vdisk and reset */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (mod_hash_destroy(vds->vd_table, (mod_hash_key_t)prev_id) != 0)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Re-initialize vdisk with new state */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (vds_init_vd(vds, curr_id, curr_dev, curr_ldc_id) != 0) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo vds_remove_vd(vds, md->removed.mdp, md->removed.mdep[i]);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo vds_change_vd(vds, md->match_prev.mdp, md->match_prev.mdep[i],
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* MDEG specification for a (particular) vds node */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo static mdeg_node_spec_t vds_spec = {"virtual-device", vds_prop_spec};
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* MDEG specification for matching a vd node */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo static mdeg_node_match_t vd_spec = {"virtual-device-port",
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * The "cfg-handle" property of a vds node in an MD contains the MD's
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * notion of "instance", or unique identifier, for that node; OBP
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * stores the value of the "cfg-handle" MD property as the value of
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * the "reg" property on the node in the device tree it builds from
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * the MD and passes to Solaris. Thus, we look up the devinfo node's
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * "reg" property value to uniquely identify this device instance when
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * registering with the MD event-generation framework. If the "reg"
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * property cannot be found, the device tree state is presumably so
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo * broken that there is no point in continuing.
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, reg_prop)) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Get the MD instance for later MDEG registration */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo cfg_handle = ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (ddi_soft_state_zalloc(vds_state, instance) != DDI_SUCCESS) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("Could not allocate state for instance %u", instance);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if ((vds = ddi_get_soft_state(vds_state, instance)) == NULL) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo vds->vd_table = mod_hash_create_ptrhash("vds_vd_table", VDS_NCHAINS,
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo sizeof (void *));
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if ((status = ldi_ident_from_dip(dip, &vds->ldi_ident)) != 0) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo PRN("ldi_ident_from_dip() returned errno %d", status);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Register for MD updates */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if (mdeg_register(&vds_spec, &vd_spec, vds_process_md, vds,
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm /* Prevent auto-detaching so driver is available whenever MD changes */
0a55fbb79ee31ed09f84a9ae28e9747bc23f4a08lm if (ddi_prop_update_int(DDI_DEV_T_NONE, dip, DDI_NO_AUTODETACH, 1) !=
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo switch (cmd) {
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo 0, /* devo_refcnt */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo "virtual disk server v%I%",
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo if ((status = ddi_soft_state_init(&vds_state, sizeof (vds_t), 1)) != 0)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo /* Fill in the bit-mask of server-supported operations */
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo for (i = 0; i < vds_noperations; i++)
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo vds_operations |= 1 << (vds_operation[i].operation - 1);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (0);
1ae0874509b6811fdde1dfd46f0d93fd09867a3fheppo return (0);