vdc.c revision 3af08d828975d7e2581b6829e0eecff14d87a483
/*
* 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 */
/* processing incoming messages from vDisk server */
/* dkio */
/*
* Module variables
*/
/*
* Tunable variables to control how long vdc waits before timing out on
* various operations
*/
static int vdc_retries = 10;
/* calculated from 'vdc_usec_timeout' during attach */
static uint64_t vdc_hz_min_ldc_delay;
static uint64_t vdc_hz_max_ldc_delay;
/* values for dumping - need to run in a tighter loop */
static int vdc_dump_retries = 100;
/* Count of the number of vdc instances attached */
static volatile uint32_t vdc_instance_count = 0;
/* Soft state pointer */
static void *vdc_state;
/*
*
* vdc_msglevel - controls level of messages
* vdc_matchinst - 64-bit variable where each bit corresponds
* to the vdc instance the vdc_msglevel applies.
*/
int vdc_msglevel = 0x0;
/*
* Supported vDisk protocol version pairs.
*
* The first array entry is the latest and preferred version.
*/
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);
vdc_efi_fini();
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);
}
return (DDI_FAILURE);
}
if (vdc->open_count) {
return (DDI_FAILURE);
}
/* mark instance as detaching */
/*
* try and disable callbacks to prevent another handshake
*/
}
/* wake up any thread waiting for connection to come online */
"[%d] write reset - move to resetting state...\n",
instance);
}
/* now wait until state transitions to VDC_STATE_DETACH */
}
}
}
}
return (DDI_SUCCESS);
}
static int
{
int instance;
int status;
instance);
return (DDI_FAILURE);
}
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->open_count = 0;
vdc->session_id = 0;
vdc->threads_pending = 0;
/* init blocking msg read functionality */
/* initialise LDC channel which will be used to communicate with vds */
goto return_status;
}
/* initialize the thread responsible for managing state with server */
instance);
return (DDI_FAILURE);
}
/*
* 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) {
goto return_status;
}
/*
* Now that we have the device info we can create the
* device nodes and properties
*/
if (status) {
instance);
goto return_status;
}
if (status) {
goto return_status;
}
/*
* Setup devid
*/
if (vdc_setup_devid(vdc)) {
}
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 (status);
}
static int
{
int status;
return (status);
}
static int
{
DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
return (EIO);
}
/* if any device node is created we set this flag */
DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
return (EIO);
}
return (0);
}
static int
{
DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
return (EIO);
}
/* if any device node is created we set this flag */
DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
return (EIO);
}
return (0);
}
/*
* 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
{
char name[sizeof ("s,raw")];
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);
}
/*
* Minor nodes are different for EFI disks: EFI disks do not have
* a minor node 'g' for the minor number corresponding to slice
* VD_EFI_WD_SLICE (slice 7) instead they have a minor node 'wd'
* representing the whole disk.
*/
for (i = 0; i < num_slices; i++) {
if (i == VD_EFI_WD_SLICE) {
else
if (status != 0)
return (status);
continue;
}
return (EIO);
}
/* if any device node is created we set this flag */
'a' + i, ",raw");
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));
if (rv != DDI_PROP_SUCCESS) {
return (EIO);
}
if (rv != DDI_PROP_SUCCESS) {
return (EIO);
}
}
return (0);
}
static int
{
int instance;
return (EINVAL);
return (ENXIO);
}
vdc->open_count++;
return (0);
}
static int
{
int instance;
return (EINVAL);
return (ENXIO);
}
if (vdc->dkio_flush_pending) {
"[%d] Cannot detach: %d outstanding DKIO flushes\n",
return (EBUSY);
}
/*
* Should not need the mutex here, since the framework should protect
* against more opens on this device, but just in case.
*/
vdc->open_count--;
return (0);
}
static int
{
}
static int
{
return (0);
}
static int
{
int rv;
return (ENXIO);
}
if (rv) {
return (rv);
}
if (ddi_in_panic())
(void) vdc_drain_response(vdc);
return (0);
}
/* -------------------------------------------------------------------------- */
/*
* 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;
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
{
}
static int
{
}
static int
{
}
static int
{
}
/* -------------------------------------------------------------------------- */
/*
* Handshake support
*/
/*
* 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)
*/
"id(%lx) rv(%d) size(%ld)",
if (msglen != sizeof (vio_ver_msg_t))
}
return (status);
}
/*
* Function:
* vdc_ver_negotiation()
*
* Description:
*
* Arguments:
* vdcp - soft state pointer for this instance of the device driver.
*
* Return Code:
* 0 - Success
*/
static int
{
int status;
return (status);
/* release lock and wait for response */
if (status) {
"[%d] Failed waiting for Ver negotiation response, rv(%d)",
return (status);
}
/* check type and sub_type ... */
return (EPROTO);
}
}
/*
* 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 */
"id(%lx) rv(%d) size(%ld)",
if (msglen != sizeof (vio_ver_msg_t))
}
return (status);
}
/*
* Function:
* vdc_attr_negotiation()
*
* Description:
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
*
* Return Code:
* 0 - Success
*/
static int
{
int status;
return (status);
/* release lock and wait for response */
if (status) {
"[%d] Failed waiting for Attr negotiation response, rv(%d)",
return (status);
}
/* check type and sub_type ... */
return (EPROTO);
}
}
/*
* 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;
int retry;
int nretries = 10;
break;
}
if (status != 0) {
return (status);
}
/* fill in tag */
/* fill in payload */
pkt.dring_ident = 0;
if (status != 0) {
}
return (status);
}
/*
* Function:
* vdc_dring_negotiation()
*
* Description:
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
*
* Return Code:
* 0 - Success
*/
static int
{
int status;
return (status);
/* release lock and wait for response */
if (status) {
"[%d] Failed waiting for Dring negotiation response,"
return (status);
}
/* check type and sub_type ... */
return (EPROTO);
}
return (vdc_handle_dring_reg_msg(vdcp,
(vio_dring_reg_msg_t *)&vio_msg));
}
/*
* Function:
* vdc_send_rdx()
*
* Description:
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
*
* Return Code:
* 0 - Success
*/
static int
{
int status;
/*
* Send an RDX message to vds to indicate we are ready
* to send data
*/
if (status != 0) {
}
return (status);
}
/*
* Function:
* vdc_handle_rdx()
*
* Description:
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
* msgp - received msg
*
* Return Code:
* 0 - Success
*/
static int
{
return (0);
}
/*
* Function:
* vdc_rdx_exchange()
*
* Description:
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
*
* Return Code:
* 0 - Success
*/
static int
{
int status;
return (status);
/* release lock and wait for response */
if (status) {
"[%d] Failed waiting for RDX response,"
return (status);
}
/* check type and sub_type ... */
return (EPROTO);
}
}
/* -------------------------------------------------------------------------- */
/*
* LDC helper routines
*/
static int
{
int status;
int delay_time;
/* detect if the connection has been reset */
status = ECONNRESET;
goto done;
}
}
/*
* Until we get a blocking ldc read we have to retry
* until the entire LDC message has arrived before
* ldc_read() will succeed. Note we also bail out if
* the chanel is reset or goes away.
*/
loop:
switch (status) {
case EAGAIN:
delay_time *= 2;
if (delay_time >= vdc_ldc_read_max_delay)
goto loop;
case 0:
if (len == 0) {
goto loop;
}
/*
* If there are pending messages, leave the
* read state as pending. Otherwise, set the state
* back to idle.
*/
if (status == 0 && !q_has_pkts)
break;
default:
break;
}
done:
return (status);
}
#ifdef DEBUG
void
{
Q(VIO_TYPE_ERR)
#undef Q
default: ms = "unknown"; break;
}
#undef Q
default: ss = "unknown"; break;
}
Q(VIO_VER_INFO)
Q(VIO_RDX)
Q(VIO_PKT_DATA)
#undef Q
default: ses = "unknown"; break;
}
}
#endif
/*
* 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 status = 0;
#ifdef DEBUG
#endif
/*
* Wait indefinitely to send if channel
* is busy, but bail out if we succeed or
* if the channel closes or is reset.
*/
do {
if (status == EWOULDBLOCK) {
/* geometric backoff */
delay_ticks *= 2;
if (delay_ticks > vdc_hz_max_ldc_delay)
}
} while (status == EWOULDBLOCK);
/* if LDC had serious issues --- reset vdc state */
/* LDC had serious issues --- reset vdc state */
/* wake up any waiters in the reset thread */
}
return (ECONNRESET);
}
/* 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;
}
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) {
DMSGX(0, "[%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;
return (EINVAL);
switch (status) {
case ECONNREFUSED: /* listener not ready at other end */
status = 0;
break;
default:
status);
break;
}
}
vdc->seq_num_reply = 0;
}
}
return (status);
}
/*
* Function:
* vdc_terminate_ldc()
*
* Description:
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
*
* Return Code:
* None
*/
static void
{
}
}
}
}
/* -------------------------------------------------------------------------- */
/*
* 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;
/* ensure we have enough room to store max sized block */
/*
* Calculate the maximum block size we can transmit using one
* Descriptor Ring entry from the attributes returned by the
* vDisk server. This is subject to a minimum of 'maxphys'
* as we do not have the capability to split requests over
* multiple DRing entries.
*/
} else {
}
(sizeof (ldc_mem_cookie_t) *
return (status);
}
}
vdc->dring_cookie =
&vdc->dring_cookie[0],
if (status != 0) {
"(%lx) to channel (%lx) status=%d\n",
return (status);
}
}
if (status != 0) {
"[%d] Failed to get info for descriptor ring (%lx)\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.
*/
if (status != 0) {
return (status);
}
}
/* Initialize the starting index */
vdc->dring_curr_idx = 0;
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 */
continue;
"ldc_mem_info returned an error: %d\n",
status);
/*
* This must mean that the mem handle
* is not valid. Clear it out so that
* no one tries to use it.
*/
continue;
}
(void) ldc_mem_unbind_handle(mhdl);
}
(void) ldc_mem_free_handle(mhdl);
}
}
}
if (status == 0) {
} else {
}
}
if (status == 0) {
} else {
}
}
}
/*
* Function:
* vdc_map_to_shared_ring()
*
* Description:
* Copy contents of the local descriptor to the shared
* memory descriptor.
*
* Arguments:
* vdcp - soft state pointer for this instance of the device driver.
* idx - descriptor ring index
*
* Return Code:
* None
*/
static int
{
int rv;
/* for now leave in the old pop_mem_hdl stuff */
if (rv) {
return (rv);
}
}
/*
* fill in the data details into the DRing
*/
return (0);
}
/*
* Function:
* vdc_send_request
*
* 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:
* vdcp - the soft state pointer
* operation - operation we want vds to perform (VD_OP_XXX)
* slice - the disk slice this request is for
* offset - relative disk offset
* cb_type - type of call - STRATEGY or SYNC
* cb_arg - parameter to be sent to server (depends on VD_OP_XXX type)
* . mode for ioctl(9e)
* . LP64 diskaddr_t (block I/O)
*
* Return Codes:
* 0
* EAGAIN
* EFAULT
* ENXIO
* EIO
*/
static int
{
do {
return (0);
}
/*
* 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:
* vdcp - the soft state pointer
* operation - operation we want vds to perform (VD_OP_XXX)
* slice - the disk slice this request is for
* offset - relative disk offset
* cb_type - type of call - STRATEGY or SYNC
* cb_arg - parameter to be sent to server (depends on VD_OP_XXX type)
* . mode for ioctl(9e)
* . LP64 diskaddr_t (block I/O)
*
* Return Codes:
* 0
* EAGAIN
* EFAULT
* ENXIO
* EIO
*/
static int
{
int idx; /* Index of DRing entry used */
int next_idx;
int rv;
vdcp->threads_pending++;
loop:
/* Get next available D-Ring entry */
goto loop;
}
vdcp->threads_pending--;
return (ECONNRESET);
}
next_idx = 0;
if (rv) {
/* free the descriptor */
goto loop;
}
vdcp->threads_pending--;
return (ECONNRESET);
}
/*
* Send a msg with the DRing details to vds
*/
/*
* note we're still holding the lock here to
* make sure the message goes out in order !!!...
*/
switch (rv) {
case ECONNRESET:
/*
* vdc_send initiates the reset on failure.
* Since the transaction has already been put
* on the local dring, it will automatically get
* retried when the channel is reset. Given that,
* it is ok to just return success even though the
* send failed.
*/
rv = 0;
break;
case 0: /* EOK */
break;
default:
goto cleanup_and_exit;
}
vdcp->threads_pending--;
return (rv);
return (ENXIO);
}
/*
* Function:
* vdc_do_sync_op
*
* Description:
* Wrapper around vdc_populate_descriptor that blocks until the
* response to the message is available.
*
* Arguments:
* vdcp - the soft state pointer
* operation - operation we want vds to perform (VD_OP_XXX)
* slice - the disk slice this request is for
* offset - relative disk offset
* cb_type - type of call - STRATEGY or SYNC
* cb_arg - parameter to be sent to server (depends on VD_OP_XXX type)
* . mode for ioctl(9e)
* . LP64 diskaddr_t (block I/O)
*
* Return Codes:
* 0
* EAGAIN
* EFAULT
* ENXIO
* EIO
*/
static int
{
int status;
/*
* Grab the lock, if blocked wait until the server
* response causes us to wake up again.
*/
vdcp->sync_op_cnt++;
vdcp->sync_op_cnt--;
return (ENXIO);
}
/* now block anyone other thread entering after us */
/*
* No need to check return value - will return error only
* in the DETACH case and we can fall through
*/
/*
* block until our transaction completes.
* Also anyone else waiting also gets to go next.
*/
else
vdcp->sync_op_status = 0;
vdcp->sync_op_cnt--;
/* signal the next waiting thread */
return (status);
}
/*
* Function:
* vdc_drain_response()
*
* Description:
* 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.
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
*
* Return Code:
* 0 - Success
*/
static int
{
retries = 0;
for (;;) {
if (rv) {
break;
}
/*
* if there are no packets wait and check again
*/
if (retries++ > vdc_dump_retries) {
break;
}
continue;
}
/*
* DRing requests.
*/
continue;
}
/*
* set the appropriate return value for the current request.
*/
case VIO_SUBTYPE_ACK:
rv = 0;
break;
case VIO_SUBTYPE_NACK:
break;
default:
continue;
}
continue;
}
continue;
}
if (rv) {
"[%d] Entry @ %d - depopulate failed ..\n",
}
/* if this is the last descriptor - break out of loop */
break;
}
return (rv);
}
/*
* 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 FLUSH operation never bind handles so we can return now */
if (operation == VD_OP_FLUSH)
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 rv = 0;
int i;
case VIO_read_dir:
break;
case VIO_write_dir:
break;
case VIO_both_dir:
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 =
kmem_alloc(sizeof (caddr_t) *
"(buf=%p nb=%ld op=%d)\n",
}
if (rv != 0) {
"(mhdl=%p, buf=%p, err=%d)\n",
if (ldep->align_addr) {
}
return (EAGAIN);
}
/*
* Get the other cookies (if any).
*/
if (rv != 0) {
(void) ldc_mem_unbind_handle(mhdl);
"(mhdl=%lx cnum=%d), err=%d",
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;
/*
* Depending on the type of event that triggered this callback,
* we modify the handshake 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) {
return (LDC_SUCCESS);
}
/*
* Need to wake up any readers so they will
* detect that a reset has occurred.
*/
/* wake up any threads waiting for connection to come up */
}
}
return (LDC_SUCCESS);
}
/*
* Function:
* vdc_wait_for_response()
*
* Description:
* Block waiting for a response from the server. If there is
* no data the thread block on the read_cv that is signalled
* by the callback when an EVT_READ occurs.
*
* Arguments:
* vdcp - soft state pointer for this instance of the device driver.
*
* Return Code:
* 0 - Success
*/
static int
{
int status;
if (status) {
return (status);
}
if (nbytes < sizeof (vio_msg_tag_t)) {
return (ENOMSG);
}
/*
* Verify the Session ID of the message
*
* Every message after the Version has been negotiated should
* have the correct session ID set.
*/
"expected 0x%lx [seq num %lx @ %d]",
return (ENOMSG);
}
return (0);
}
/*
* Function:
* vdc_resubmit_backup_dring()
*
* Description:
* Resubmit each descriptor in the backed up dring to
* vDisk server. The Dring was backed up during connection
* reset.
*
* Arguments:
* vdcp - soft state pointer for this instance of the device driver.
*
* Return Code:
* 0 - Success
*/
static int
{
int count;
int b_idx;
int rv;
int dring_size;
int status;
/*
* Walk the backup copy of the local descriptor ring and
* resubmit all the outstanding transactions.
*/
/* only resubmit oustanding transactions */
if (rv) {
return (rv);
}
/* Wait for the response message. */
b_idx);
if (status) {
status);
return (status);
}
if (status) {
status);
return (status);
}
}
/* get the next element to submit */
b_idx = 0;
}
/* all done - now clear up pending dring copy */
sizeof (vdcp->local_dring_backup[0]);
return (0);
}
/*
* Function:
* vdc_backup_local_dring()
*
* Description:
* Backup the current dring in the event of a reset. The Dring
* transactions will be resubmitted to the server when the
* connection is restored.
*
* Arguments:
* vdcp - soft state pointer for this instance of the device driver.
*
* Return Code:
* NONE
*/
static void
{
int dring_size;
/*
* If the backup dring is stil around, it means
* that the last restore did not complete. However,
* since we never got back into the running state,
* the backup copy we have is still valid.
*/
return;
}
}
/* -------------------------------------------------------------------------- */
/*
* The following functions process the incoming messages from vds
*/
/*
* Function:
* vdc_process_msg_thread()
*
* Description:
*
* Main VDC message processing thread. Each vDisk instance
* consists of a copy of this thread. This thread triggers
* all the handshakes and data exchange with the server. It
* also handles all channel resets
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
*
* Return Code:
* None
*/
static void
{
int status;
for (;;) {
"UNKNOWN");
case VDC_STATE_INIT:
/* Check if have re-initializing repeatedly */
break;
}
/* Bring up connection with vds via LDC */
switch (status) {
case EINVAL:
break;
case 0:
break;
default:
break;
}
break;
case VDC_STATE_INIT_WAITING:
/*
* Let the callback event move us on
* when channel is open to server
*/
"state moved to %d out from under us...\n",
break;
}
}
}
break;
case VDC_STATE_NEGOTIATE:
case 0:
break;
default:
status);
goto reset;
}
case 0:
break;
default:
status);
goto reset;
}
case 0:
break;
default:
status);
goto reset;
}
case 0:
goto done;
default:
status);
goto reset;
}
status);
done:
break;
case VDC_STATE_HANDLE_PENDING:
if (status)
else
break;
/* enter running state */
case VDC_STATE_RUNNING:
/*
* Signal anyone waiting for the connection
* to come on line.
*/
vdcp->hshake_cnt = 0;
for (;;) {
if (status) break;
if (status) {
status);
break;
}
}
break;
case VDC_STATE_RESETTING:
if (vdcp->self_reset) {
"[%d] calling stop_ldc_connection.\n",
}
/*
* Wait for all threads currently waiting
* for a free dring entry to use.
*/
while (vdcp->threads_pending) {
/* let them wake up */
}
/* Sanity check that no thread is receiving */
/* cleanup the old d-ring */
/* go and start again */
break;
case VDC_STATE_DETACH:
while (vdcp->sync_op_pending) {
}
thread_exit();
break;
}
}
}
/*
* 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;
int idx;
/*
* Check to see if the message has bogus data
*/
return (EINVAL);
}
/*
* Verify that the sequence number is what vdc expects.
*/
case VDC_SEQ_NUM_TODO:
break; /* keep processing this message */
case VDC_SEQ_NUM_SKIP:
return (0);
case VDC_SEQ_NUM_INVALID:
return (ENXIO);
}
return (EIO);
return (EPROTO);
}
case CB_SYNC:
break;
case CB_STRATEGY:
if (status != 0) {
}
break;
default:
ASSERT(0);
}
}
/* let the arrival signal propogate */
/* probe gives the count of how many entries were processed */
return (0);
}
/*
* 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 */
} 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.
*/
/*
* We don't know at compile time what the vDisk server will
* think are good values but we apply an large (arbitrary)
* upper bound to prevent memory exhaustion in vdc if it was
* allocating a DRing based of huge values sent by the server.
* We probably will never exceed this except if the message
* was garbage.
*/
} else {
}
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;
return (EPROTO);
}
case VIO_SUBTYPE_ACK:
/* save the received dring_ident */
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 the vDisk
* server with the latest message is what is expected (i.e. it is greater
* than the last seq num sent by the vDisk server and less than or equal
* to the last seq num generated by vdc).
*
* It then checks the request ID to see if any requests need processing
* in the DRing.
*
* Arguments:
* vdc - soft state pointer for this instance of the driver.
* dring_msg - pointer to the LDC message sent by vds
*
* Return Code:
* VDC_SEQ_NUM_TODO - Message needs to be processed
* VDC_SEQ_NUM_SKIP - Message has already been processed
* VDC_SEQ_NUM_INVALID - The seq numbers are so out of sync,
* vdc cannot deal with them
*/
static int
{
/*
* Check to see if the messages were responded to in the correct
* order by vds.
*/
"%lu > expected <= %lu (last proc req %lu sent %lu)\n",
return (VDC_SEQ_NUM_INVALID);
}
return (VDC_SEQ_NUM_TODO);
else
return (VDC_SEQ_NUM_SKIP);
}
/*
* 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
*/
DMSGX(0,
"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) {
}
/*
* 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),
{VD_OP_GET_EFI, DKIOCGETEFI, 0,
{VD_OP_SET_EFI, DKIOCSETEFI, 0,
/*
* 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;
instance);
return (ENXIO);
}
/*
* 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;
}
return (ENOTSUP);
}
/* size is not fixed for EFI ioctls, it depends on ioctl arg */
if (rv != 0)
return (EFAULT);
} else {
}
/*
* 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 */
/* clean up if dispatch fails */
}
}
}
/* catch programming error in vdc - should be a VD_OP_XXX ioctl */
/* LDC requires that the memory being mapped is 8-byte aligned */
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) {
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.
*/
if (cmd == DKIOCSVTOC) {
/* update of the VTOC has failed, roll back */
}
return (rv);
}
if (cmd == DKIOCSVTOC) {
/*
* The VTOC has been changed. We need to update the device
* nodes to handle the case where an EFI label has been
* changed to a VTOC label. We also try and update the device
* node properties. Failing to set the properties should
* not cause an error to be return the caller though.
*/
(void) vdc_create_device_nodes_vtoc(vdc);
if (vdc_create_device_nodes_props(vdc)) {
}
} else if (cmd == DKIOCSETEFI) {
/*
* The EFI has been changed. We need to update the device
* nodes to handle the case where a VTOC label has been
* changed to an EFI label. We also try and update the device
* node properties. Failing to set the properties should
* not cause an error to be return the caller though.
*/
(void) vdc_create_device_nodes_efi(vdc);
if (rv == 0) {
}
if (rv) {
}
}
/*
* 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) {
return (rv);
}
return (rv);
}
/*
* Function:
*
* Description:
* This is an empty conversion function used by ioctl calls which
*/
static int
{
return (0);
}
static int
{
return (0); /* nothing to do */
return (EFAULT);
return (0);
}
static int
{
if (dir == VD_COPYOUT)
return (0); /* nothing to do */
return (EFAULT);
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);
}
static int
{
int rv = 0;
void *uaddr;
return (ENXIO);
if (rv != 0)
return (EFAULT);
} else {
if (rv != 0)
return (EFAULT);
mode);
if (rv != 0)
return (EFAULT);
}
return (0);
}
static int
{
void *uaddr;
if (dir == VD_COPYOUT)
return (0); /* nothing to do */
return (ENXIO);
return (EFAULT);
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) {
}
return (rv);
}
/*
* If the device does not support VTOC then we try
* to read an EFI label.
*/
if (rv) {
return (rv);
}
return (0);
}
/*
* FUTURE: This could be default way for reading the VTOC
* from the disk as supposed to sending the VD_OP_GET_VTOC
* to the server. Currently this is a sanity check.
*
* 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
*/
if (rv) {
return (rv);
}
return (rv);
}
/*
* Function:
* vdc_setup_devid()
*
* Description:
* This routine discovers the devid of a vDisk. It requests the devid of
* the underlying device from the vDisk server, builds an encapsulated
* devid based on the retrieved devid and registers that new devid to
* the vDisk.
*
* Arguments:
* vdc - soft state pointer for this instance of the device driver.
*
* Return Code:
* 0 - A devid was succesfully registered for the vDisk
*/
static int
{
int rv;
/*
* At first sight, we don't know the size of the devid that the
* server will return but this size will be encoded into the
* reply. So we do a first request using a default size then we
* check if this size was large enough. If not then we do a second
* request with the correct size returned by the server. Note that
* ldc requires size to be 8-byte aligned.
*/
sizeof (uint64_t));
if (rv) {
return (rv);
}
/*
* The returned devid is larger than the buffer used. Try again
* with a buffer with the right size.
*/
sizeof (uint64_t));
if (rv) {
return (rv);
}
}
/*
* The virtual disk should have the same device id as the one associated
* with the physical disk it is mapped on, otherwise sharing a disk
* between a LDom and a non-LDom may not work (for example for a shared
* SVM disk set).
*
* The DDI framework does not allow creating a device id with any
* type so we first create a device id of type DEVID_ENCAP and then
* we restore the orignal type of the physical device.
*/
/* build an encapsulated devid based on the returned devid */
return (1);
}
return (1);
}
return (0);
}
static void
{
/*
* vd_efi_to_vtoc() will store information about the EFI Sun
* reserved partition (representing the entire disk) into
* partition 7. However single-slice device will only have
* that single partition and the vdc driver expects to find
* information about that partition in slice 0. So we need
* to copy information from slice 7 to slice 0.
*/
}
}