vdc.c revision d10e4ef2fabf16c3237c6d6592496df3eac6a1ef
/*
* 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
* 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 2006 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* LDoms virtual disk client (vdc) device driver
*
* This driver runs on a guest logical domain and communicates with the virtual
* disk server (vds) driver running on the service domain which is exporting
* virtualized "disks" to the guest logical domain.
*
* The driver can be divided into four sections:
*
* 1) generic device driver housekeeping
* _init, _fini, attach, detach, ops structures, etc.
*
* 2) communication channel setup
* Setup the communications link over the LDC channel that vdc uses to
* talk to the vDisk server. Initialise the descriptor ring which
* allows the LDC clients to transfer data via memory mappings.
*
* 3) Support exported to upper layers (filesystems, etc)
* The upper layers call into vdc via strategy(9E) and DKIO(7I)
* ioctl calls. vdc will copy the data to be written to the descriptor
* ring or maps the buffer to store the data read by the vDisk
* server into the descriptor ring. It then sends a message to the
* vDisk server requesting it to complete the operation.
*
* 4) Handling responses from vDisk server.
* The vDisk server will ACK some or all of the messages vdc sends to it
* (this is configured during the handshake). Upon receipt of an ACK
* vdc will check the descriptor ring and signal to the upper layer
* code waiting on the IO.
*/
#include <sys/efi_partition.h>
#include <sys/mach_descrip.h>
#include <sys/archsystm.h>
#include <sys/sysmacros.h>
#include <sys/vio_common.h>
#include <sys/vio_mailbox.h>
#include <sys/vdsk_common.h>
#include <sys/vdsk_mailbox.h>
/*
* function prototypes
*/
/* standard driver functions */
/* setup */
/* handshake with vds */
static void vdc_init_handshake_negotiation(void *arg);
/* processing incoming messages from vDisk server */
static void vdc_process_msg(void *arg);
num_msgs);
/* dkio */
/*
* Module variables
*/
static int vdc_retries = VDC_RETRIES;
/* Soft state pointer */
static void *vdc_state;
int vdc_msglevel = 0;
/*
* Supported vDisk protocol version pairs.
*
* The first array entry is the latest and preferred version.
*/
static void
{
}
static struct cb_ops vdc_cb_ops = {
vdc_open, /* cb_open */
vdc_close, /* cb_close */
vdc_strategy, /* cb_strategy */
vdc_print, /* cb_print */
vdc_dump, /* cb_dump */
vdc_read, /* cb_read */
vdc_write, /* cb_write */
vdc_ioctl, /* cb_ioctl */
nodev, /* cb_devmap */
nodev, /* cb_mmap */
nodev, /* cb_segmap */
nochpoll, /* cb_chpoll */
ddi_prop_op, /* cb_prop_op */
NULL, /* cb_str */
CB_REV, /* cb_rev */
vdc_aread, /* cb_aread */
vdc_awrite /* cb_awrite */
};
DEVO_REV, /* devo_rev */
0, /* devo_refcnt */
vdc_getinfo, /* devo_getinfo */
nulldev, /* devo_identify */
nulldev, /* devo_probe */
vdc_attach, /* devo_attach */
vdc_detach, /* devo_detach */
nodev, /* devo_reset */
&vdc_cb_ops, /* devo_cb_ops */
NULL, /* devo_bus_ops */
nulldev /* devo_power */
};
"virtual disk client %I%",
&vdc_ops,
};
static struct modlinkage modlinkage = {
&modldrv,
};
/* -------------------------------------------------------------------------- */
/*
* Device Driver housekeeping and setup
*/
int
_init(void)
{
int status;
return (status);
return (status);
}
int
{
}
int
_fini(void)
{
int status;
return (status);
return (0);
}
static int
{
switch (cmd) {
case DDI_INFO_DEVT2DEVINFO:
return (DDI_FAILURE);
}
return (DDI_SUCCESS);
case DDI_INFO_DEVT2INSTANCE:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
}
static int
{
int instance;
int rv;
switch (cmd) {
case DDI_DETACH:
/* the real work happens below */
break;
case DDI_SUSPEND:
/* nothing to do for this non-device */
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
vdc_msg("%s[%d]: Could not get state structure.",
return (DDI_FAILURE);
}
PR0("%s[%d]: Cannot detach: device is open",
return (DDI_FAILURE);
}
/*
* try and disable callbacks to prevent another handshake
*/
/*
* Prevent any more attempts to start a handshake with the vdisk
* server and tear down the existing connection.
*/
PR0("%s[%d]: Waiting for thread to exit\n",
break;
}
}
}
}
return (DDI_SUCCESS);
}
static int
{
int instance;
int status;
vdc_msg("%s:(%d): Couldn't alloc state structure",
return (DDI_FAILURE);
}
vdc_msg("%s:(%d): Could not get state structure.",
return (DDI_FAILURE);
}
/*
* We assign the value to initialized in this case to zero out the
* variable and then set bits in it to indicate what has been done
*/
vdc->session_id = 0;
instance);
return (DDI_FAILURE);
}
/* initialise LDC channel which will be used to communicate with vds */
if (vdc_do_ldc_init(vdc) != 0) {
return (DDI_FAILURE);
}
/* Bring up connection with vds via LDC */
if (status != 0) {
return (DDI_FAILURE);
}
/*
* We need to wait until the handshake has completed before leaving
* the attach(). This is to allow the device node(s) to be created
* and the first usage of the filesystem to succeed.
*/
PR0("%s[%d] handshake in progress [VD %d (LDC %d)]\n",
VD_GET_TIMEOUT_HZ(1));
if (status == -1) {
if (retries >= vdc_retries) {
PR0("%s[%d] Give up handshake wait.\n",
return (DDI_FAILURE);
} else {
PR0("%s[%d] Retry #%d for handshake.\n",
retries++;
}
}
}
/*
* Once the handshake is complete, we can use the DRing to send
* requests to the vDisk server to calculate the geometry and
* VTOC of the "disk"
*/
if (status != 0) {
}
/*
* Now that we have the device info we can create the
* device nodes and properties
*/
if (status) {
instance);
return (status);
}
if (status) {
return (status);
}
return (status);
}
static int
{
int status;
switch (cmd) {
case DDI_ATTACH:
return (status);
case DDI_RESUME:
/* nothing to do for this non-device */
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
}
static int
{
int status = 0;
return (EIO);
}
if (status != 0) {
return (status);
}
}
if (status != 0) {
return (status);
}
if (status != 0) {
return (status);
}
}
/*
* At this stage we have initialised LDC, we will now try and open
* the connection.
*/
if (status != 0) {
return (status);
}
}
return (status);
}
static int
{
int status = 0;
return (0);
}
return (status);
}
/*
* Function:
* vdc_create_device_nodes
*
* Description:
* This function creates the block and character device nodes under
* /devices along with the node properties. It is called as part of
* the attach(9E) of the instance during the handshake with vds after
* vds has sent the attributes to vdc.
*
* If the device is of type VD_DISK_TYPE_SLICE then the minor node
* of 2 is used in keeping with the Solaris convention that slice 2
* refers to a whole disk. Slices start at 'a'
*
* Parameters:
* vdc - soft state pointer
*
* Return Values
* 0 - Success
* EIO - Failed to create node
* EINVAL - Unknown type of disk exported
*/
static int
{
/* uses NNNN which is OK as long as # of disks <= 10000 */
char name[sizeof ("disk@NNNN:s,raw")];
int instance;
int num_slices = 1;
int i;
switch (vdc->vdisk_type) {
case VD_DISK_TYPE_DISK:
break;
case VD_DISK_TYPE_SLICE:
num_slices = 1;
break;
case VD_DISK_TYPE_UNK:
default:
return (EINVAL);
}
for (i = 0; i < num_slices; i++) {
vdc_msg("%s[%d]: Couldn't add block node %s.",
return (EIO);
}
/* if any device node is created we set this flag */
'a' + i, ",raw");
vdc_msg("%s[%d]: Could not add raw node %s.",
return (EIO);
}
}
return (0);
}
/*
* Function:
* vdc_create_device_nodes_props
*
* Description:
* This function creates the block and character device nodes under
* /devices along with the node properties. It is called as part of
* the attach(9E) of the instance during the handshake with vds after
* vds has sent the attributes to vdc.
*
* Parameters:
* vdc - soft state pointer
*
* Return Values
* 0 - Success
* EIO - Failed to create device node property
* EINVAL - Unknown type of disk exported
*/
static int
{
int instance;
int num_slices = 1;
int rv;
int i;
" No VTOC available", instance);
return (ENXIO);
}
switch (vdc->vdisk_type) {
case VD_DISK_TYPE_DISK:
break;
case VD_DISK_TYPE_SLICE:
num_slices = 1;
break;
case VD_DISK_TYPE_UNK:
default:
return (EINVAL);
}
for (i = 0; i < num_slices; i++) {
VD_MAKE_DEV(instance, i));
PR0("%s[%d] sz %ld (%ld Mb) p_size %lx\n",
if (rv != DDI_PROP_SUCCESS) {
vdc_msg("%s:(%d): Couldn't add \"%s\" [%d]\n",
return (EIO);
}
if (rv != DDI_PROP_SUCCESS) {
return (EIO);
}
}
return (0);
}
static int
{
int instance;
return (EINVAL);
return (ENXIO);
}
/*
* Check to see if we can communicate with vds
*/
return (ENOLINK);
}
return (0);
}
static int
{
int instance;
return (EINVAL);
return (ENXIO);
}
/*
* Check to see if we can communicate with vds
*/
if (!vdc_is_able_to_tx_data(vdc, 0)) {
return (ETIMEDOUT);
}
if (vdc->dkio_flush_pending) {
PR0("%s[%d]: Cannot detach: %d outstanding DKIO flushes",
return (EBUSY);
}
/*
* Should not need the mutex here, since the framework should protect
* against more opens on this device, but just in case.
*/
return (0);
}
static int
{
}
static int
{
return (0);
}
static int
{
int rv;
return (ENXIO);
}
/*
* If the OS instance is panicking, the call above will ensure that
* the descriptor is done before returning. This should always be
* case when coming through this function but we check just in case
* and wait if necessary for the vDisk server to ACK and trigger
* the biodone.
*/
if (!ddi_in_panic())
return (rv);
}
/* -------------------------------------------------------------------------- */
/*
* Disk access routines
*
*/
/*
* vdc_strategy()
*
* Return Value:
* 0: As per strategy(9E), the strategy() function must return 0
* [ bioerror(9f) sets b_flags to the proper error code ]
*/
static int
{
int rv = -1;
PR1("%s: %s %ld bytes at block %ld : b_addr=0x%p",
return (0);
}
return (0);
}
/*
* If the request was successfully sent, the strategy call returns and
* the ACK handler calls the bioxxx functions when the vDisk server is
* done.
*/
if (rv) {
}
return (0);
}
static int
{
PR1("vdc_read(): Entered");
}
static int
{
PR1("vdc_write(): Entered");
}
static int
{
PR1("vdc_aread(): Entered");
}
static int
{
PR1("vdc_awrite(): Entered");
}
/* -------------------------------------------------------------------------- */
/*
* Handshake support
*/
/*
* vdc_init_handshake_negotiation
*
* Description:
* This function is called to trigger the handshake negotiations between
* the client (vdc) and the server (vds). It may be called multiple times.
*
* Parameters:
* vdc - soft state pointer
*/
static void
{
int status;
/* get LDC state */
if (status != 0) {
return;
}
/*
* If the LDC connection is not UP we bring it up now and return.
* The handshake will be started again when the callback is
* triggered due to the UP event.
*/
(void) vdc_do_ldc_up(vdc);
return;
}
/*
* Do not continue if another thread has triggered a handshake which
* has not been reset or detach() has stopped further handshakes.
*/
PR0("%s[%d] Negotiation not triggered. [init=%x]\n",
return;
}
return;
}
if (state == VD_STATE_INIT) {
/*
* Set the desired version parameter to the first entry in the
* version array. If this specific version is not supported,
* the response handling code will step down the version number
* to the next array entry and deal with it accordingly.
*/
} else if (state == VD_STATE_VER) {
(void) vdc_init_attr_negotiation(vdc);
} else if (state == VD_STATE_ATTR) {
(void) vdc_init_dring_negotiate(vdc);
} else if (state == VD_STATE_DATA) {
/*
* nothing to do - we have already completed the negotiation
* and we can transmit data when ready.
*/
PR0("%s[%d] Negotiation triggered after handshake completed",
}
}
/*
* Function:
* vdc_init_ver_negotiation()
*
* Description:
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
*
* Return Code:
* 0 - Success
*/
static int
{
int status = -1;
/*
* set the Session ID to a unique value
* (the lower 32 bits of the clock tick)
*/
PR0("%s[%d] vdc_send failed: id(%lx) rv(%d) size(%d)\n",
if (msglen != sizeof (vio_ver_msg_t))
}
return (status);
}
/*
* Function:
* vdc_init_attr_negotiation()
*
* Description:
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
*
* Return Code:
* 0 - Success
*/
static int
{
int status;
/* fill in tag */
/* fill in payload */
PR0("%s[%d] ldc_write failed: id(%lx) rv(%d) size (%d)\n",
if (msglen != sizeof (vio_ver_msg_t))
}
return (status);
}
/*
* Function:
* vdc_init_dring_negotiate()
*
* Description:
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
*
* Return Code:
* 0 - Success
*/
static int
{
int status = -1;
if (status != 0) {
return (status);
}
PR0("%s[%d] Init of descriptor ring completed (status = %d)\n",
/* fill in tag */
/* fill in payload */
pkt.dring_ident = 0;
if (status != 0) {
PR0("%s[%d] Failed to register DRing (status = %d)\n",
}
return (status);
}
/* -------------------------------------------------------------------------- */
/*
* LDC helper routines
*/
/*
* Function:
* vdc_send()
*
* Description:
* The function encapsulates the call to write a message using LDC.
* If LDC indicates that the call failed due to the queue being full,
* we retry the ldc_write() [ up to 'vdc_retries' time ], otherwise
* we return the error returned by LDC.
*
* Arguments:
* ldc_handle - LDC handle for the channel this instance of vdc uses
* pkt - address of LDC message to be sent
* msglen - the size of the message being sent. When the function
* returns, this contains the number of bytes written.
*
* Return Code:
* 0 - Success.
* EINVAL - pkt or msglen were NULL
* ECONNRESET - The connection was not up.
* EWOULDBLOCK - LDC queue is full
* xxx - other error codes returned by ldc_write
*/
static int
{
int retries = 0;
int status = 0;
do {
/* if LDC had serious issues --- reset vdc state */
}
/* return the last size written */
return (status);
}
/*
* Function:
* vdc_get_ldc_id()
*
* Description:
* This function gets the 'ldc-id' for this particular instance of vdc.
* The id returned is the guest domain channel endpoint LDC uses for
* communication with vds.
*
* Arguments:
* dip - dev info pointer for this instance of the device driver.
* ldc_id - pointer to variable used to return the 'ldc-id' found.
*
* Return Code:
* 0 - Success.
* ENOENT - Expected node or property did not exist.
* ENXIO - Unexpected error communicating with MD framework
*/
static int
{
int num_nodes;
int num_vdevs;
int num_chans;
int listsz;
int idx;
int obp_inst;
*ldc_id = 0;
/*
* Get the OBP instance number for comparison with the MD instance
*
* The "cfg-handle" property of a vdc node in an MD contains the MD's
* notion of "instance", or unique identifier, for that node; OBP
* stores the value of the "cfg-handle" MD property as the value of
* the "reg" property on the node in the device tree it builds from
* the MD and passes to Solaris. Thus, we look up the devinfo node's
* "reg" property value to uniquely identify this device instance.
* If the "reg" property cannot be found, the device tree state is
* presumably so broken that there is no point in continuing.
*/
return (ENOENT);
}
OBP_REG, -1);
/*
* We now walk the MD nodes and if an instance of a vdc node matches
* the instance got from OBP we get the ldc-id property.
*/
return (ENXIO);
}
/* allocate memory for nodes */
/*
* Search for all the virtual devices, we will then check to see which
* ones are disk nodes.
*/
if (num_vdevs <= 0) {
goto done;
}
continue;
}
PR1("%s[%d] vdc inst# in MD=%d\n",
found_inst = B_TRUE;
break;
}
}
}
if (!found_inst) {
goto done;
}
/* get the channels for this node */
/* expecting at least one channel */
if (num_chans <= 0) {
goto done;
} else if (num_chans != 1) {
PR0("%s[%d] Expected 1 '%s' node for '%s' port, found %d\n",
}
/*
* We use the first channel found (index 0), irrespective of how
* many are there in total.
*/
}
done:
if (chanp)
if (listp)
(void) md_fini_handle(mdp);
return (status);
}
static int
{
int status;
switch (status) {
case ECONNREFUSED: /* listener not ready at other end */
PR0("%s: ldc_up(%d,...) return %d\n",
status = 0;
break;
default:
"channel=%ld, err=%d",
}
}
return (status);
}
/*
* vdc_is_able_to_tx_data()
*
* Description:
* This function checks if we are able to send data to the
* vDisk server (vds). The LDC connection needs to be up and
* vdc & vds need to have completed the handshake negotiation.
*
* Parameters:
* vdc - soft state pointer
* flag - flag to indicate if we can block or not
* [ If O_NONBLOCK or O_NDELAY (which are defined in
* open(2)) are set then do not block)
*
* Return Values
* B_TRUE - can talk to vds
* B_FALSE - unable to talk to vds
*/
static boolean_t
{
int rv = -1;
return (B_TRUE);
PR0("%s[%d] Not ready to tx - state %d LDC state %d\n",
return (B_FALSE);
}
/*
* We want to check and see if any negotiations triggered earlier
* have succeeded. We are prepared to wait a little while in case
* they are still in progress.
*/
PR0("%s: Waiting for connection at state %d (LDC state %d)\n",
/*
* An rv of -1 indicates that we timed out without the LDC
* state changing so it looks like the other side (vdc) is
* not yet ready/responding.
*
* Any other value of rv indicates that the LDC triggered an
* interrupt so we just loop again, check the handshake state
* and keep waiting if necessary.
*/
if (rv == -1) {
if (retries >= vdc_retries) {
PR0("%s[%d] handshake wait timed out.\n",
return (B_FALSE);
} else {
PR1("%s[%d] Retry #%d for handshake timedout\n",
retries++;
}
}
}
return (B_TRUE);
}
/*
* Function:
* vdc_terminate_ldc()
*
* Description:
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
*
* Return Code:
* None
*/
static void
{
}
}
}
}
/*
* Function:
* vdc_reset_connection()
*
* Description:
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
* reset_ldc - Flag whether or not to reset the LDC connection also.
*
* Return Code:
* None
*/
static void
{
int status;
if (reset_ldc) {
PR0("%s[%d] ldc_reset() = %d\n",
}
}
/* -------------------------------------------------------------------------- */
/*
* Descriptor Ring helper routines
*/
/*
* Function:
* vdc_init_descriptor_ring()
*
* Description:
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
*
* Return Code:
* 0 - Success
*/
static int
{
int status = 0;
int i;
PR0("%s[%d] initialized=%x\n",
&vdc->ldc_dring_hdl);
return (status);
}
}
vdc->dring_cookie =
&vdc->dring_cookie[0],
if (status != 0) {
PR0("%s: Failed to bind descriptor ring (%p) "
"to channel (%p)\n",
return (status);
}
}
if (status != 0) {
PR0("%s: Failed to get info for descriptor ring (%p)\n",
return (status);
}
/* Allocate the local copy of this dring */
vdc->local_dring =
KM_SLEEP);
}
/*
* Mark all DRing entries as free and initialize the private
* descriptor's memory handles. If any entry is initialized,
* we need to free it later so we set the bit in 'initialized'
* at the start.
*/
for (i = 0; i < VD_DRING_LEN; i++) {
if (status != 0) {
return (status);
}
}
/*
* We init the index of the last DRing entry used. Since the code to
* get the next available entry increments it before selecting one,
* we set it to the last DRing entry so that it wraps around to zero
* for the 1st entry to be used.
*/
return (status);
}
/*
* Function:
* vdc_destroy_descriptor_ring()
*
* Description:
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
*
* Return Code:
* None
*/
static void
{
int status = -1;
int i; /* loop */
for (i = 0; i < VD_DRING_LEN; i++) {
continue;
(void) ldc_mem_free_handle(mhdl);
}
}
VD_DRING_LEN * sizeof (vdc_local_desc_t));
}
if (status == 0) {
} else {
vdc_msg("%s: Failed to unbind Descriptor Ring (%lx)\n",
vdc->ldc_dring_hdl);
}
}
if (status == 0) {
} else {
vdc_msg("%s: Failed to destroy Descriptor Ring (%lx)\n",
vdc->ldc_dring_hdl);
}
}
}
/*
* vdc_get_next_dring_entry_idx()
*
* Description:
* This function gets the index of the next Descriptor Ring entry available
* If the ring is full, it will back off and wait for the next entry to be
* freed (the ACK handler will signal).
*
* Return Value:
* 0 <= rv < VD_DRING_LEN Next available slot
* -1 DRing is full
*/
static int
{
int idx = -1;
/* pick the next descriptor after the last one used */
} else {
VD_GET_TIMEOUT_HZ(1));
} else {
PR0("[%d] Entry %d unavailable still in state %d\n",
}
}
return (idx);
}
/*
* Function:
* vdc_populate_descriptor
*
* Description:
* This routine writes the data to be transmitted to vds into the
* descriptor, notifies vds that the ring has been updated and
* then waits for the request to be processed.
*
* Arguments:
* vdc - the soft state pointer
* addr - address of structure to be written. In the case of block
* reads and writes this structure will be a buf_t and the
* address of the data to be written will be in the b_un.b_addr
* field. Otherwise the value of addr will be the address
* to be written.
* operation - operation we want vds to perform (VD_OP_XXX)
* arg - parameter to be sent to server (depends on VD_OP_XXX type)
* . mode for ioctl(9e)
* . LP64 diskaddr_t (block I/O)
* slice - the disk slice this request is for
*
* Return Codes:
* 0
* EAGAIN
* EFAULT
* ENXIO
* EIO
*/
static int
{
int idx = 0; /* Index of DRing entry used */
int retries = 0;
int rv;
/*
* Get next available DRing entry.
*/
if (idx == -1) {
PR0("[%d] no descriptor ring entry avail, last seq=%d\n",
/*
* Since strategy should not block we don't wait for the DRing
* to empty and instead return
*/
return (EAGAIN);
}
/*
* We now get the lock for this descriptor before dropping the overall
* DRing lock. This prevents a race condition where another vdc thread
* could grab the descriptor we selected.
*/
switch (operation) {
case VD_OP_BREAD:
case VD_OP_BWRITE:
break;
case VD_OP_GET_VTOC:
case VD_OP_SET_VTOC:
case VD_OP_GET_DISKGEOM:
case VD_OP_SET_DISKGEOM:
case VD_OP_SCSICMD:
if (nbytes > 0) {
}
break;
case VD_OP_FLUSH:
case VD_OP_GET_WCE:
case VD_OP_SET_WCE:
rv = 0; /* nothing to bind */
break;
default:
}
if (rv != 0) {
return (rv);
}
/*
* fill in the data details into the DRing
*/
/*
* Send a msg with the DRing details to vds
*/
PR1("ident=0x%llx, st=%d, end=%d, seq=%d req=%d dep=%p\n",
if (rv != 0) {
/* Clear the DRing entry */
}
/*
* If the message was successfully sent, we increment the sequence
* number to be used by the next message
*/
/*
* When a guest is panicking, the completion of requests needs to be
* handled differently because interrupts are disabled and vdc
* will not get messages. We have to poll for the messages instead.
*/
if (ddi_in_panic()) {
int start = 0;
retries = 0;
for (;;) {
&msglen);
if (rv) {
break;
}
/*
* if there are no packets wait and check again
*/
if (retries++ > vdc_dump_retries) {
PR0("[%d] Giving up waiting, idx %d\n",
break;
}
continue;
}
/*
* DRing requests.
*/
PR0("discarding pkt: type=%d sub=%d env=%d\n",
continue;
}
/*
* set the appropriate return value for the
* current request.
*/
case VIO_SUBTYPE_ACK:
rv = 0;
break;
case VIO_SUBTYPE_NACK:
break;
default:
continue;
}
if (start >= VD_DRING_LEN) {
PR0("[%d] Bogus ack data : start %d\n",
continue;
}
PR1("[%d] Dumping start=%d idx=%d state=%d\n",
PR0("[%d] Entry @ %d - state !DONE %d\n",
continue;
}
/*
* We want to process all Dring entries up to
* the current one so that we can return an
* error with the correct request.
*/
PR0("[%d] Looping: start %d, idx %d\n",
continue;
}
/* exit - all outstanding requests are completed */
break;
}
return (rv);
}
/*
* In the case of calls from strategy and dump (in the non-panic case),
* instead of waiting for a response from the vDisk server return now.
* They will be processed asynchronously and the vdc ACK handling code
* will trigger the biodone(9F)
*/
return (rv);
}
/*
* In the case of synchronous calls we watch the DRing entries we
* modified and await the response from vds.
*/
/* debug info when dumping state on vds side */
}
return (rv);
}
/*
* Function:
* vdc_wait_for_descriptor_update()
*
* Description:
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
* idx - Index of the Descriptor Ring entry being modified
* dmsg - LDC message sent by vDisk server
*
* Return Code:
* 0 - Success
*/
static int
{
int retries = 0;
int status = 0;
int rv = 0;
if (rv == -1) {
/*
* If they persist in ignoring us we'll storm off in a
* huff and return ETIMEDOUT to the upper layers.
*/
if (retries >= vdc_retries) {
PR0("%s: Finished waiting on entry %d\n",
break;
} else {
retries++;
PR0("%s[%d]: Timeout #%d on entry %d "
"[seq %d][req %d]\n", __func__,
}
PR0("%s[%d]: vds has accessed entry %d [seq %d]"
"[req %d] but not ack'ed it yet\n",
continue;
}
/*
* we resend the message as it may have been dropped
* and have never made it to the other side (vds).
* (We reuse the original message but update seq ID)
*/
retries = 0;
if (status != 0) {
vdc_msg("%s: Error (%d) while resending after "
break;
}
/*
* If the message was successfully sent, we increment
* the sequence number to be used by the next message.
*/
}
}
return (status);
}
/*
* Function:
* vdc_depopulate_descriptor()
*
* Description:
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
* idx - Index of the Descriptor Ring entry being modified
*
* Return Code:
* 0 - Success
*/
static int
{
int operation;
int rv = 0;
/* the DKIO W$ operations never bind handles so we can return now */
if ((operation == VD_OP_FLUSH) ||
(operation == VD_OP_GET_WCE) ||
(operation == VD_OP_SET_WCE))
return (status);
/*
* If the upper layer passed in a misaligned address we copied the
* data into an aligned buffer before sending it to LDC - we now
* copy it back to the original buffer.
*/
if (ldep->align_addr) {
}
if (rv != 0) {
/*
* The error returned by the vDisk server is more informative
* and thus has a higher priority but if it isn't set we ensure
* that this function returns an error.
*/
if (status == 0)
}
return (status);
}
/*
* Function:
* vdc_populate_mem_hdl()
*
* Description:
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
* idx - Index of the Descriptor Ring entry being modified
* addr - virtual address being mapped in
* nybtes - number of bytes in 'addr'
* operation - the vDisk operation being performed (VD_OP_xxx)
*
* Return Code:
* 0 - Success
*/
static int
int operation)
{
int perm = LDC_MEM_RW;
int rv = 0;
int i;
switch (operation) {
case VD_OP_BREAD:
break;
case VD_OP_BWRITE:
break;
case VD_OP_GET_VTOC:
case VD_OP_SET_VTOC:
case VD_OP_GET_DISKGEOM:
case VD_OP_SET_DISKGEOM:
case VD_OP_SCSICMD:
perm = LDC_MEM_RW;
break;
default:
ASSERT(0); /* catch bad programming in vdc */
}
/*
* LDC expects any addresses passed in to be 8-byte aligned. We need
* to copy the contents of any misaligned buffers to a newly allocated
* buffer and bind it instead (and copy the the contents back to the
* original buffer passed in when depopulating the descriptor)
*/
ldep->align_addr =
KM_SLEEP);
PR0("%s[%d] Misaligned address %lx reallocating "
"(buf=%lx nb=%d op=%d entry=%d)\n",
}
PR1("%s[%d] bound mem handle; ncookies=%d\n",
if (rv != 0) {
vdc_msg("%s[%d] failed to ldc_mem_bind_handle "
"(mhdl=%lx, buf=%lx entry=%d err=%d)\n",
if (ldep->align_addr) {
}
return (EAGAIN);
}
/*
* Get the other cookies (if any).
*/
if (rv != 0) {
(void) ldc_mem_unbind_handle(mhdl);
vdc_msg("%s: failed to get next cookie(mhdl=%lx "
if (ldep->align_addr) {
}
return (EAGAIN);
}
}
return (rv);
}
/*
* Interrupt handlers for messages from LDC
*/
/*
* Function:
* vdc_handle_cb()
*
* Description:
*
* Arguments:
* event - Type of event (LDC_EVT_xxx) that triggered the callback
* arg - soft state pointer for this instance of the device driver.
*
* Return Code:
* 0 - Success
*/
static uint_t
{
int rv = 0;
PR1("%s[%d] event=%x seqID=%d\n",
/*
* Depending on the type of event that triggered this callback,
* we modify the handhske state or read the data.
*
* NOTE: not done as a switch() as event could be triggered by
* a state change and a read request. Also the ordering of the
* check for the event types is deliberate.
*/
if (event & LDC_EVT_UP) {
/* get LDC state */
if (rv != 0) {
return (LDC_SUCCESS);
}
/*
* Reset the transaction sequence numbers when LDC comes up.
* We then kick off the handshake negotiation with the vDisk
* server.
*/
vdc->seq_num_reply = 0;
}
if (event & LDC_EVT_READ) {
/*
* Wake up the worker thread to process the message
*/
return (LDC_SUCCESS);
}
if (event & LDC_EVT_RESET) {
/* get LDC state */
if (rv != 0) {
}
}
if (event & LDC_EVT_DOWN) {
/* get LDC state */
if (rv != 0) {
}
}
return (LDC_SUCCESS);
}
/* -------------------------------------------------------------------------- */
/*
* The following functions process the incoming messages from vds
*/
/*
* Function:
* vdc_process_msg_thread()
*
* Description:
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
*
* Return Code:
* None
*/
static void
{
int status = 0;
while (!vdc->msg_pending)
/* check if there is data */
if ((status != 0) &&
" server. Cannot check LDC queue: %d",
continue;
}
if (!q_is_empty) {
}
}
PR0("Message processing thread stopped\n");
thread_exit();
}
/*
* Function:
* vdc_process_msg()
*
* Description:
* This function is called by the message processing thread each time it
* is triggered when LDC sends an interrupt to indicate that there are
* more packets on the queue. When it is called it will continue to loop
* and read the messages until there are no more left of the queue. If it
* encounters an invalid sized message it will drop it and check the next
* message.
*
* Arguments:
* arg - soft state pointer for this instance of the device driver.
*
* Return Code:
* None.
*/
static void
vdc_process_msg(void *arg)
{
int status;
for (;;) {
/* read all messages - until no more left */
if (status) {
/* if status is ECONNRESET --- reset vdc state */
}
return;
}
return;
}
if (nbytes == 0) {
PR2("%s[%d]: ldc_read() done..\n",
return;
}
/*
* Verify the Session ID of the message
*
* Every message after the Version has been negotiated should
* have the correct session ID set.
*/
vdc->session_id);
return;
}
case VIO_TYPE_CTRL:
break;
case VIO_TYPE_DATA:
break;
case VIO_TYPE_ERR:
break;
default:
break;
}
if (status != 0) {
PR0("%s[%d] Error (%d) occcurred processing msg\n",
}
}
}
/*
* Function:
* vdc_process_ctrl_msg()
*
* Description:
* This function is called by the message processing thread each time
* an LDC message with a msgtype of VIO_TYPE_CTRL is received.
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
* msg - the LDC message sent by vds
*
* Return Codes:
* 0 - Success.
* EPROTO - A message was received which shouldn't have happened according
* to the protocol
* ENOTSUP - An action which is allowed according to the protocol but which
* isn't (or doesn't need to be) implemented yet.
* EINVAL - An invalid value was returned as part of a message.
*/
static int
{
int status = -1;
/* Depending on which state we are in; process the message */
case VD_STATE_INIT:
break;
case VD_STATE_VER:
break;
case VD_STATE_ATTR:
(vio_dring_reg_msg_t *)&msg);
break;
case VD_STATE_RDX:
break;
}
status = 0;
break;
case VD_STATE_DATA:
default:
break;
}
return (status);
}
/*
* Function:
* vdc_process_data_msg()
*
* Description:
* This function is called by the message processing thread each time
* a message with a msgtype of VIO_TYPE_DATA is received. It will either
* be an ACK or NACK from vds[1] which vdc handles as follows.
* ACK - wake up the waiting thread
* NACK - resend any messages necessary
*
* [1] Although the message format allows it, vds should not send a
* VIO_SUBTYPE_INFO message to vdc asking it to read data; if for
* some bizarre reason it does, vdc will reset the connection.
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
* msg - the LDC message sent by vds
*
* Return Code:
* 0 - Success.
* > 0 - error value returned by LDC
*/
static int
{
int status = 0;
uint_t i;
/*
* Check to see if the message has bogus data
*/
vdc_msg("%s: Bogus ACK data : start %d, end %d\n",
return (EPROTO);
}
/*
* calculate the number of messages that vds ACK'ed
*
* Assumes, (like the rest of vdc) that there is a 1:1 mapping
* between requests and Dring entries.
*/
/*
* Verify that the sequence number is what vdc expects.
*/
return (ENXIO);
}
/*
* Wake the thread waiting for each DRing entry ACK'ed
*/
for (i = 0; i < num_msgs; i++) {
int operation;
/*
* The vDisk server responds when it accepts a
* descriptor so we continue looping and process
* it when it sends the message that it is done.
*/
continue;
}
/* Clear the DRing entry */
}
}
/* we need to drop the lock to trigger the handshake */
}
return (status);
}
/*
* Function:
* vdc_process_err_msg()
*
* NOTE: No error messages are used as part of the vDisk protocol
*/
static int
{
return (ENOTSUP);
}
/*
* Function:
* vdc_handle_ver_msg()
*
* Description:
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
* ver_msg - LDC message sent by vDisk server
*
* Return Code:
* 0 - Success
*/
static int
{
int status = 0;
return (EPROTO);
}
return (EINVAL);
}
case VIO_SUBTYPE_ACK:
/*
* We check to see if the version returned is indeed supported
* (The server may have also adjusted the minor number downwards
* and if so 'ver_msg' will contain the actual version agreed)
*/
if (vdc_is_supported_version(ver_msg)) {
} else {
}
break;
case VIO_SUBTYPE_NACK:
/*
* call vdc_is_supported_version() which will return the next
* supported version (if any) in 'ver_msg'
*/
(void) vdc_is_supported_version(ver_msg);
/* reset the necessary fields and resend */
PR0("[%d] Resend VER info (LDC status = %d)\n",
} else {
}
break;
case VIO_SUBTYPE_INFO:
/*
* Handle the case where vds starts handshake
* (for now only vdc is the instigatior)
*/
break;
default:
break;
}
return (status);
}
/*
* Function:
* vdc_handle_attr_msg()
*
* Description:
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
* attr_msg - LDC message sent by vDisk server
*
* Return Code:
* 0 - Success
*/
static int
{
int status = 0;
return (EPROTO);
}
case VIO_SUBTYPE_ACK:
/*
* We now verify the attributes sent by vds.
*/
/*
* Future support: step down to the block size
* and max transfer size suggested by the
* server. (If this value is less than 128K
* then multiple Dring entries per request
* would need to be implemented)
*/
break;
}
vdc_msg("%s[%d] Couldn't process attrs "
break;
}
break;
case VIO_SUBTYPE_NACK:
/*
* vds could not handle the attributes we sent so we
* stop negotiating.
*/
break;
case VIO_SUBTYPE_INFO:
/*
* Handle the case where vds starts the handshake
* (for now; vdc is the only supported instigatior)
*/
break;
default:
break;
}
return (status);
}
/*
* Function:
* vdc_handle_dring_reg_msg()
*
* Description:
*
* Arguments:
* vdc - soft state pointer for this instance of the driver.
* dring_msg - LDC message sent by vDisk server
*
* Return Code:
* 0 - Success
*/
static int
{
int status = 0;
vio_rdx_msg_t msg = {0};
return (EPROTO);
}
case VIO_SUBTYPE_ACK:
/* save the received dring_ident */
PR0("%s[%d] Received dring ident=0x%lx\n",
/*
* Send an RDX message to vds to indicate we are ready
* to send data
*/
if (status != 0) {
break;
}
break;
case VIO_SUBTYPE_NACK:
/*
* vds could not handle the DRing info we sent so we
* stop negotiating.
*/
break;
case VIO_SUBTYPE_INFO:
/*
* Handle the case where vds starts handshake
* (for now only vdc is the instigatior)
*/
break;
default:
}
return (status);
}
/*
* Function:
* vdc_verify_seq_num()
*
* Description:
* This functions verifies that the sequence number sent back by vds with
* the latest message correctly follows the last request processed.
*
* Arguments:
* vdc - soft state pointer for this instance of the driver.
* dring_msg - pointer to the LDC message sent by vds
* num_msgs - the number of requests being acknowledged
*
* Return Code:
* B_TRUE - Success.
* B_FALSE - The seq numbers are so out of sync, vdc cannot deal with them
*/
static boolean_t
{
/*
* Check to see if the messages were responded to in the correct
* order by vds. There are 3 possible scenarios:
* - the seq_num we expected is returned (everything is OK)
* - a seq_num earlier than the last one acknowledged is returned,
* if so something is seriously wrong so we reset the connection
* - a seq_num greater than what we expected is returned.
*/
vdc_msg("%s[%d]: Bogus seq_num %d, expected %d\n",
return (B_FALSE);
} else {
/*
* vds has responded with a seq_num greater than what we
* expected
*/
return (B_FALSE);
}
}
return (B_TRUE);
}
/*
* Function:
* vdc_is_supported_version()
*
* Description:
* 'ver_msg' are supported. If not it finds the next version that is
* in the supported version list 'vdc_version[]' and sets the fields in
* 'ver_msg' to those values
*
* Arguments:
* ver_msg - LDC message sent by vDisk server
*
* Return Code:
* B_TRUE - Success
* B_FALSE - Version not supported
*/
static boolean_t
{
for (int i = 0; i < vdc_num_versions; i++) {
ASSERT((i == 0) ||
/*
* If the major versions match, adjust the minor version, if
* necessary, down to the highest value supported by this
* client. The server should support all minor versions lower
* than the value it sent
*/
PR0("Adjusting minor version from %u to %u",
}
return (B_TRUE);
}
/*
* If the message contains a higher major version number, set
* and return false, so this message will get resent with
* these values, and the server will potentially try again
* with the same or a lower version
*/
return (B_FALSE);
}
/*
* Otherwise, the message's major version is less than the
* current major version, so continue the loop to the next
* (lower) supported version
*/
}
/*
* No common version was found; "ground" the version pair in the
* message to terminate negotiation
*/
return (B_FALSE);
}
/* -------------------------------------------------------------------------- */
/*
* DKIO(7) support
*/
typedef struct vdc_dk_arg {
struct dk_callback dkc;
int mode;
} vdc_dk_arg_t;
/*
* Function:
* vdc_dkio_flush_cb()
*
* Description:
* This routine is a callback for DKIOCFLUSHWRITECACHE which can be called
* by kernel code.
*
* Arguments:
* arg - a pointer to a vdc_dk_arg_t structure.
*/
void
vdc_dkio_flush_cb(void *arg)
{
int rv;
return;
}
if (rv != 0) {
PR0("%s[%d] DKIOCFLUSHWRITECACHE failed %d : model %x\n",
}
/*
* Trigger the call back to notify the caller the the ioctl call has
* been completed.
*/
}
/* Indicate that one less DKIO write flush is outstanding */
/* free the mem that was allocated when the callback was dispatched */
}
/*
* This structure is used in the DKIO(7I) array below.
*/
typedef struct vdc_dk_ioctl {
int cmd; /* Solaris ioctl operation number */
/* function to convert between vDisk and Solaris structure formats */
/*
* Subset of DKIO(7I) operations currently supported
*/
static vdc_dk_ioctl_t dk_ioctl[] = {
{VD_OP_FLUSH, DKIOCFLUSHWRITECACHE, sizeof (int),
{VD_OP_GET_WCE, DKIOCGETWCE, sizeof (int),
{VD_OP_SET_WCE, DKIOCSETWCE, sizeof (int),
/*
* These particular ioctls are not sent to the server - vdc fakes up
* the necessary info.
*/
{0, DKIOCREMOVABLE, 0, vdc_null_copy_func},
{0, CDROMREADOFFSET, 0, vdc_null_copy_func}
};
/*
* Function:
* vd_process_ioctl()
*
* Description:
* This routine processes disk specific ioctl calls
*
* Arguments:
* dev - the device number
* cmd - the operation [dkio(7I)] to be processed
* arg - pointer to user provided structure
* (contains data to be set or reference parameter for get)
* mode - bit flag, indicating open settings, 32/64 bit type, etc
*
* Return Code:
* 0
* EFAULT
* ENXIO
* EIO
* ENOTSUP
*/
static int
{
int rv = -1;
int idx = 0; /* index into dk_ioctl[] */
struct vtoc vtoc_saved;
PR0("%s: Processing ioctl(%x) for dev %x : model %x\n",
instance);
return (ENXIO);
}
/*
* Check to see if we can communicate with the vDisk server
*/
return (ENOLINK);
}
/*
* Validate the ioctl operation to be performed.
*
* If we have looped through the array without finding a match then we
* don't support this ioctl.
*/
break;
}
PR0("%s[%d] Unsupported ioctl(%x)\n",
return (ENOTSUP);
}
/*
* Deal with the ioctls which the server does not provide. vdc can
* fake these up and return immediately
*/
switch (cmd) {
case CDROMREADOFFSET:
case DKIOCREMOVABLE:
case USCSICMD:
return (ENOTTY);
case DKIOCINFO:
{
return (ENXIO);
if (rv != 0)
return (EFAULT);
return (0);
}
case DKIOCGMEDIAINFO:
{
return (ENXIO);
if (rv != 0)
return (EFAULT);
return (0);
}
case DKIOCFLUSHWRITECACHE:
{
/*
* If the backing device is not a 'real' disk then the
* W$ operation request to the vDisk server will fail
* so we might as well save the cycles and return now.
*/
return (ENOTTY);
/*
* If arg is NULL, then there is no callback function
* registered and the call operates synchronously; we
* break and continue with the rest of the function and
* wait for vds to return (i.e. after the request to
* vds returns successfully, all writes completed prior
* to the ioctl will have been flushed from the disk
* write cache to persistent media.
*
* If a callback function is registered, we dispatch
* the request on a task queue and return immediately.
* The callback will deal with informing the calling
* thread that the flush request is completed.
*/
break;
/* put the request on a task queue */
}
}
/* catch programming error in vdc - should be a VD_OP_XXX ioctl */
/* LDC requires that the memory being mapped is 8-byte aligned */
PR1("%s[%d]: struct size %d alloc %d\n",
if (cmd == DKIOCSVTOC) {
/*
* Save a copy of the current VTOC so that we can roll back
* if the setting of the new VTOC fails.
*/
}
/*
* Call the conversion function for this ioctl whhich if necessary
* converts from the Solaris format to the format ARC'ed
* as part of the vDisk protocol (FWARC 2006/195)
*/
if (rv != 0) {
PR0("%s[%d]: convert returned %d for ioctl 0x%x\n",
return (rv);
}
/*
* send request to vds to service the ioctl.
*/
if (rv != 0) {
/*
* This is not necessarily an error. The ioctl could
* be returning a value such as ENOTTY to indicate
* that the ioctl is not applicable.
*/
PR0("%s[%d]: vds returned %d for ioctl 0x%x\n",
if (cmd == DKIOCSVTOC) {
/* update of the VTOC has failed, roll back */
}
return (rv);
}
if (cmd == DKIOCSVTOC) {
/*
* The VTOC has been changed, try and update the device
* node properties. Failing to set the properties should
* not cause an error to be return the caller though.
*/
if (vdc_create_device_nodes_props(vdc)) {
}
}
/*
* Call the conversion function (if it exists) for this ioctl
* which converts from the format ARC'ed as part of the vDisk
* protocol (FWARC 2006/195) back to a format understood by
* the rest of Solaris.
*/
if (rv != 0) {
PR0("%s[%d]: convert returned %d for ioctl 0x%x\n",
return (rv);
}
return (rv);
}
/*
* Function:
*
* Description:
* This is an empty conversion function used by ioctl calls which
*/
static int
{
return (0);
}
/*
* Function:
* vdc_get_vtoc_convert()
*
* Description:
* This routine performs the necessary convertions from the DKIOCGVTOC
* Solaris structure to the format defined in FWARC 2006/195.
*
* In the struct vtoc definition, the timestamp field is marked as not
* supported so it is not part of vDisk protocol (FWARC 2006/195).
* However SVM uses that field to check it can write into the VTOC,
* so we fake up the info of that field.
*
* Arguments:
* vdc - the vDisk client
* from - the buffer containing the data to be copied from
* to - the buffer to be copied to
* mode - flags passed to ioctl() call
* dir - the "direction" of the copy - VD_COPYIN or VD_COPYOUT
*
* Return Code:
* 0 - Success
* ENXIO - incorrect buffer passed in.
* EFAULT - ddi_copyout routine encountered an error.
*/
static int
{
int i;
void *tmp_memp;
int copy_len = 0;
int rv = 0;
if (dir != VD_COPYOUT)
return (0); /* nothing to do */
return (ENXIO);
else
/* fake the VTOC timestamp field */
for (i = 0; i < V_NUMPAR; i++) {
}
} else {
}
if (rv != 0)
return (rv);
}
/*
* Function:
* vdc_set_vtoc_convert()
*
* Description:
* This routine performs the necessary convertions from the DKIOCSVTOC
* Solaris structure to the format defined in FWARC 2006/195.
*
* Arguments:
* vdc - the vDisk client
* from - Buffer with data
* to - Buffer where data is to be copied to
* mode - flags passed to ioctl
* dir - direction of copy (in or out)
*
* Return Code:
* 0 - Success
* ENXIO - Invalid buffer passed in
* EFAULT - ddi_copyin of data failed
*/
static int
{
int copy_len = 0;
int rv = 0;
return (0); /* nothing to do */
return (ENXIO);
else
if (rv != 0) {
return (EFAULT);
}
} else {
}
/*
* The VTOC is being changed, then vdc needs to update the copy
* it saved in the soft state structure.
*/
return (0);
}
/*
* Function:
* vdc_get_geom_convert()
*
* Description:
* This routine performs the necessary convertions from the DKIOCGGEOM,
* DKIOCG_PHYSGEOM and DKIOG_VIRTGEOM Solaris structures to the format
* defined in FWARC 2006/195
*
* Arguments:
* vdc - the vDisk client
* from - Buffer with data
* to - Buffer where data is to be copied to
* mode - flags passed to ioctl
* dir - direction of copy (in or out)
*
* Return Code:
* 0 - Success
* ENXIO - Invalid buffer passed in
* EFAULT - ddi_copyout of data failed
*/
static int
{
int rv = 0;
if (dir != VD_COPYOUT)
return (0); /* nothing to do */
return (ENXIO);
if (rv != 0)
return (rv);
}
/*
* Function:
* vdc_set_geom_convert()
*
* Description:
* This routine performs the necessary convertions from the DKIOCSGEOM
* Solaris structure to the format defined in FWARC 2006/195.
*
* Arguments:
* vdc - the vDisk client
* from - Buffer with data
* to - Buffer where data is to be copied to
* mode - flags passed to ioctl
* dir - direction of copy (in or out)
*
* Return Code:
* 0 - Success
* ENXIO - Invalid buffer passed in
* EFAULT - ddi_copyin of data failed
*/
static int
{
int rv = 0;
return (0); /* nothing to do */
return (ENXIO);
if (rv != 0) {
return (EFAULT);
}
return (0);
}
/*
* Function:
* vdc_create_fake_geometry()
*
* Description:
* This routine fakes up the disk info needed for some DKIO ioctls.
* - DKIOCINFO
* - DKIOCGMEDIAINFO
*
* [ just like lofi(7D) and ramdisk(7D) ]
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
*
* Return Code:
* 0 - Success
*/
static int
{
int rv = 0;
/*
* DKIOCINFO support
*/
/* max_xfer_sz is #blocks so we don't need to divide by DEV_BSIZE */
/*
* The partition number will be created on the fly depending on the
* actual slice (i.e. minor node) that is used to request the data.
*/
/*
* DKIOCGMEDIAINFO support
*/
return (rv);
}
/*
* Function:
* vdc_setup_disk_layout()
*
* Description:
* This routine discovers all the necessary details about the "disk"
* by requesting the data that is available from the vDisk server and by
* faking up the rest of the data.
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
*
* Return Code:
* 0 - Success
*/
static int
{
int slice = 0;
int rv;
if (rv != 0) {
}
if (rv) {
return (rv);
}
/*
* find the slice that represents the entire "disk" and use that to
* read the disk label. The convention in Solaris is that slice 2
* represents the whole disk so we check that it is, otherwise we
* default to slice 0
*/
slice = 2;
} else {
slice = 0;
}
/*
* Read disk label from start of disk
*/
VD_OP_BREAD, 0, slice);
return (rv);
}