xref: /titanic_51/usr/src/uts/sun4v/io/vdc.c (revision 821da340f9590922ba8761a64fadda18843a0e88)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 /*
30  * LDoms virtual disk client (vdc) device driver
31  *
32  * This driver runs on a guest logical domain and communicates with the virtual
33  * disk server (vds) driver running on the service domain which is exporting
34  * virtualized "disks" to the guest logical domain.
35  *
36  * The driver can be divided into four sections:
37  *
38  * 1) generic device driver housekeeping
39  *	_init, _fini, attach, detach, ops structures, etc.
40  *
41  * 2) communication channel setup
42  *	Setup the communications link over the LDC channel that vdc uses to
43  *	talk to the vDisk server. Initialise the descriptor ring which
44  *	allows the LDC clients to transfer data via memory mappings.
45  *
46  * 3) Support exported to upper layers (filesystems, etc)
47  *	The upper layers call into vdc via strategy(9E) and DKIO(7I)
48  *	ioctl calls. vdc will copy the data to be written to the descriptor
49  *	ring or maps the buffer to store the data read by the vDisk
50  *	server into the descriptor ring. It then sends a message to the
51  *	vDisk server requesting it to complete the operation.
52  *
53  * 4) Handling responses from vDisk server.
54  *	The vDisk server will ACK some or all of the messages vdc sends to it
55  *	(this is configured during the handshake). Upon receipt of an ACK
56  *	vdc will check the descriptor ring and signal to the upper layer
57  *	code waiting on the IO.
58  */
59 
60 #include <sys/atomic.h>
61 #include <sys/conf.h>
62 #include <sys/disp.h>
63 #include <sys/ddi.h>
64 #include <sys/dkio.h>
65 #include <sys/efi_partition.h>
66 #include <sys/fcntl.h>
67 #include <sys/file.h>
68 #include <sys/mach_descrip.h>
69 #include <sys/modctl.h>
70 #include <sys/mdeg.h>
71 #include <sys/note.h>
72 #include <sys/open.h>
73 #include <sys/sdt.h>
74 #include <sys/stat.h>
75 #include <sys/sunddi.h>
76 #include <sys/types.h>
77 #include <sys/promif.h>
78 #include <sys/vtoc.h>
79 #include <sys/archsystm.h>
80 #include <sys/sysmacros.h>
81 
82 #include <sys/cdio.h>
83 #include <sys/dktp/fdisk.h>
84 #include <sys/dktp/dadkio.h>
85 #include <sys/scsi/generic/sense.h>
86 #include <sys/scsi/impl/uscsi.h>	/* Needed for defn of USCSICMD ioctl */
87 
88 #include <sys/ldoms.h>
89 #include <sys/ldc.h>
90 #include <sys/vio_common.h>
91 #include <sys/vio_mailbox.h>
92 #include <sys/vdsk_common.h>
93 #include <sys/vdsk_mailbox.h>
94 #include <sys/vdc.h>
95 
96 /*
97  * function prototypes
98  */
99 
100 /* standard driver functions */
101 static int	vdc_open(dev_t *dev, int flag, int otyp, cred_t *cred);
102 static int	vdc_close(dev_t dev, int flag, int otyp, cred_t *cred);
103 static int	vdc_strategy(struct buf *buf);
104 static int	vdc_print(dev_t dev, char *str);
105 static int	vdc_dump(dev_t dev, caddr_t addr, daddr_t blkno, int nblk);
106 static int	vdc_read(dev_t dev, struct uio *uio, cred_t *cred);
107 static int	vdc_write(dev_t dev, struct uio *uio, cred_t *cred);
108 static int	vdc_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
109 			cred_t *credp, int *rvalp);
110 static int	vdc_aread(dev_t dev, struct aio_req *aio, cred_t *cred);
111 static int	vdc_awrite(dev_t dev, struct aio_req *aio, cred_t *cred);
112 
113 static int	vdc_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd,
114 			void *arg, void **resultp);
115 static int	vdc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
116 static int	vdc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
117 
118 /* setup */
119 static void	vdc_min(struct buf *bufp);
120 static int	vdc_send(vdc_t *vdc, caddr_t pkt, size_t *msglen);
121 static int	vdc_do_ldc_init(vdc_t *vdc);
122 static int	vdc_start_ldc_connection(vdc_t *vdc);
123 static int	vdc_create_device_nodes(vdc_t *vdc);
124 static int	vdc_create_device_nodes_efi(vdc_t *vdc);
125 static int	vdc_create_device_nodes_vtoc(vdc_t *vdc);
126 static int	vdc_create_device_nodes_props(vdc_t *vdc);
127 static int	vdc_get_ldc_id(dev_info_t *dip, uint64_t *ldc_id);
128 static int	vdc_do_ldc_up(vdc_t *vdc);
129 static void	vdc_terminate_ldc(vdc_t *vdc);
130 static int	vdc_init_descriptor_ring(vdc_t *vdc);
131 static void	vdc_destroy_descriptor_ring(vdc_t *vdc);
132 static int	vdc_setup_devid(vdc_t *vdc);
133 static void	vdc_store_efi(vdc_t *vdc, struct dk_gpt *efi);
134 
135 /* handshake with vds */
136 static int		vdc_init_ver_negotiation(vdc_t *vdc, vio_ver_t ver);
137 static int		vdc_ver_negotiation(vdc_t *vdcp);
138 static int		vdc_init_attr_negotiation(vdc_t *vdc);
139 static int		vdc_attr_negotiation(vdc_t *vdcp);
140 static int		vdc_init_dring_negotiate(vdc_t *vdc);
141 static int		vdc_dring_negotiation(vdc_t *vdcp);
142 static int		vdc_send_rdx(vdc_t *vdcp);
143 static int		vdc_rdx_exchange(vdc_t *vdcp);
144 static boolean_t	vdc_is_supported_version(vio_ver_msg_t *ver_msg);
145 
146 /* processing incoming messages from vDisk server */
147 static void	vdc_process_msg_thread(vdc_t *vdc);
148 static int	vdc_recv(vdc_t *vdc, vio_msg_t *msgp, size_t *nbytesp);
149 
150 static uint_t	vdc_handle_cb(uint64_t event, caddr_t arg);
151 static int	vdc_process_data_msg(vdc_t *vdc, vio_msg_t *msg);
152 static int	vdc_process_err_msg(vdc_t *vdc, vio_msg_t msg);
153 static int	vdc_handle_ver_msg(vdc_t *vdc, vio_ver_msg_t *ver_msg);
154 static int	vdc_handle_attr_msg(vdc_t *vdc, vd_attr_msg_t *attr_msg);
155 static int	vdc_handle_dring_reg_msg(vdc_t *vdc, vio_dring_reg_msg_t *msg);
156 static int 	vdc_send_request(vdc_t *vdcp, int operation,
157 		    caddr_t addr, size_t nbytes, int slice, diskaddr_t offset,
158 		    int cb_type, void *cb_arg, vio_desc_direction_t dir);
159 static int	vdc_map_to_shared_dring(vdc_t *vdcp, int idx);
160 static int 	vdc_populate_descriptor(vdc_t *vdcp, int operation,
161 		    caddr_t addr, size_t nbytes, int slice, diskaddr_t offset,
162 		    int cb_type, void *cb_arg, vio_desc_direction_t dir);
163 static int 	vdc_do_sync_op(vdc_t *vdcp, int operation,
164 		    caddr_t addr, size_t nbytes, int slice, diskaddr_t offset,
165 		    int cb_type, void *cb_arg, vio_desc_direction_t dir);
166 
167 static int	vdc_wait_for_response(vdc_t *vdcp, vio_msg_t *msgp);
168 static int	vdc_drain_response(vdc_t *vdcp);
169 static int	vdc_depopulate_descriptor(vdc_t *vdc, uint_t idx);
170 static int	vdc_populate_mem_hdl(vdc_t *vdcp, vdc_local_desc_t *ldep);
171 static int	vdc_verify_seq_num(vdc_t *vdc, vio_dring_msg_t *dring_msg);
172 
173 /* dkio */
174 static int	vd_process_ioctl(dev_t dev, int cmd, caddr_t arg, int mode);
175 static int	vdc_create_fake_geometry(vdc_t *vdc);
176 static int	vdc_setup_disk_layout(vdc_t *vdc);
177 static int	vdc_null_copy_func(vdc_t *vdc, void *from, void *to,
178 		    int mode, int dir);
179 static int	vdc_get_wce_convert(vdc_t *vdc, void *from, void *to,
180 		    int mode, int dir);
181 static int	vdc_set_wce_convert(vdc_t *vdc, void *from, void *to,
182 		    int mode, int dir);
183 static int	vdc_get_vtoc_convert(vdc_t *vdc, void *from, void *to,
184 		    int mode, int dir);
185 static int	vdc_set_vtoc_convert(vdc_t *vdc, void *from, void *to,
186 		    int mode, int dir);
187 static int	vdc_get_geom_convert(vdc_t *vdc, void *from, void *to,
188 		    int mode, int dir);
189 static int	vdc_set_geom_convert(vdc_t *vdc, void *from, void *to,
190 		    int mode, int dir);
191 static int	vdc_uscsicmd_convert(vdc_t *vdc, void *from, void *to,
192 		    int mode, int dir);
193 static int	vdc_get_efi_convert(vdc_t *vdc, void *from, void *to,
194 		    int mode, int dir);
195 static int	vdc_set_efi_convert(vdc_t *vdc, void *from, void *to,
196 		    int mode, int dir);
197 
198 /*
199  * Module variables
200  */
201 
202 /*
203  * Tunable variables to control how long vdc waits before timing out on
204  * various operations
205  */
206 static int	vdc_retries = 10;
207 static int	vdc_hshake_retries = 3;
208 
209 /* calculated from 'vdc_usec_timeout' during attach */
210 static uint64_t	vdc_hz_timeout;				/* units: Hz */
211 static uint64_t	vdc_usec_timeout = 30 * MICROSEC;	/* 30s units: ns */
212 
213 static uint64_t vdc_hz_min_ldc_delay;
214 static uint64_t vdc_min_timeout_ldc = 1 * MILLISEC;
215 static uint64_t vdc_hz_max_ldc_delay;
216 static uint64_t vdc_max_timeout_ldc = 100 * MILLISEC;
217 
218 static uint64_t vdc_ldc_read_init_delay = 1 * MILLISEC;
219 static uint64_t vdc_ldc_read_max_delay = 100 * MILLISEC;
220 
221 /* values for dumping - need to run in a tighter loop */
222 static uint64_t	vdc_usec_timeout_dump = 100 * MILLISEC;	/* 0.1s units: ns */
223 static int	vdc_dump_retries = 100;
224 
225 /* Count of the number of vdc instances attached */
226 static volatile uint32_t	vdc_instance_count = 0;
227 
228 /* Soft state pointer */
229 static void	*vdc_state;
230 
231 /*
232  * Controlling the verbosity of the error/debug messages
233  *
234  * vdc_msglevel - controls level of messages
235  * vdc_matchinst - 64-bit variable where each bit corresponds
236  *                 to the vdc instance the vdc_msglevel applies.
237  */
238 int		vdc_msglevel = 0x0;
239 uint64_t	vdc_matchinst = 0ull;
240 
241 /*
242  * Supported vDisk protocol version pairs.
243  *
244  * The first array entry is the latest and preferred version.
245  */
246 static const vio_ver_t	vdc_version[] = {{1, 0}};
247 
248 static struct cb_ops vdc_cb_ops = {
249 	vdc_open,	/* cb_open */
250 	vdc_close,	/* cb_close */
251 	vdc_strategy,	/* cb_strategy */
252 	vdc_print,	/* cb_print */
253 	vdc_dump,	/* cb_dump */
254 	vdc_read,	/* cb_read */
255 	vdc_write,	/* cb_write */
256 	vdc_ioctl,	/* cb_ioctl */
257 	nodev,		/* cb_devmap */
258 	nodev,		/* cb_mmap */
259 	nodev,		/* cb_segmap */
260 	nochpoll,	/* cb_chpoll */
261 	ddi_prop_op,	/* cb_prop_op */
262 	NULL,		/* cb_str */
263 	D_MP | D_64BIT,	/* cb_flag */
264 	CB_REV,		/* cb_rev */
265 	vdc_aread,	/* cb_aread */
266 	vdc_awrite	/* cb_awrite */
267 };
268 
269 static struct dev_ops vdc_ops = {
270 	DEVO_REV,	/* devo_rev */
271 	0,		/* devo_refcnt */
272 	vdc_getinfo,	/* devo_getinfo */
273 	nulldev,	/* devo_identify */
274 	nulldev,	/* devo_probe */
275 	vdc_attach,	/* devo_attach */
276 	vdc_detach,	/* devo_detach */
277 	nodev,		/* devo_reset */
278 	&vdc_cb_ops,	/* devo_cb_ops */
279 	NULL,		/* devo_bus_ops */
280 	nulldev		/* devo_power */
281 };
282 
283 static struct modldrv modldrv = {
284 	&mod_driverops,
285 	"virtual disk client %I%",
286 	&vdc_ops,
287 };
288 
289 static struct modlinkage modlinkage = {
290 	MODREV_1,
291 	&modldrv,
292 	NULL
293 };
294 
295 /* -------------------------------------------------------------------------- */
296 
297 /*
298  * Device Driver housekeeping and setup
299  */
300 
301 int
302 _init(void)
303 {
304 	int	status;
305 
306 	if ((status = ddi_soft_state_init(&vdc_state, sizeof (vdc_t), 1)) != 0)
307 		return (status);
308 	if ((status = mod_install(&modlinkage)) != 0)
309 		ddi_soft_state_fini(&vdc_state);
310 	vdc_efi_init(vd_process_ioctl);
311 	return (status);
312 }
313 
314 int
315 _info(struct modinfo *modinfop)
316 {
317 	return (mod_info(&modlinkage, modinfop));
318 }
319 
320 int
321 _fini(void)
322 {
323 	int	status;
324 
325 	if ((status = mod_remove(&modlinkage)) != 0)
326 		return (status);
327 	vdc_efi_fini();
328 	ddi_soft_state_fini(&vdc_state);
329 	return (0);
330 }
331 
332 static int
333 vdc_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd,  void *arg, void **resultp)
334 {
335 	_NOTE(ARGUNUSED(dip))
336 
337 	int	instance = VDCUNIT((dev_t)arg);
338 	vdc_t	*vdc = NULL;
339 
340 	switch (cmd) {
341 	case DDI_INFO_DEVT2DEVINFO:
342 		if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
343 			*resultp = NULL;
344 			return (DDI_FAILURE);
345 		}
346 		*resultp = vdc->dip;
347 		return (DDI_SUCCESS);
348 	case DDI_INFO_DEVT2INSTANCE:
349 		*resultp = (void *)(uintptr_t)instance;
350 		return (DDI_SUCCESS);
351 	default:
352 		*resultp = NULL;
353 		return (DDI_FAILURE);
354 	}
355 }
356 
357 static int
358 vdc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
359 {
360 	int	instance;
361 	int	rv;
362 	vdc_t	*vdc = NULL;
363 
364 	switch (cmd) {
365 	case DDI_DETACH:
366 		/* the real work happens below */
367 		break;
368 	case DDI_SUSPEND:
369 		/* nothing to do for this non-device */
370 		return (DDI_SUCCESS);
371 	default:
372 		return (DDI_FAILURE);
373 	}
374 
375 	ASSERT(cmd == DDI_DETACH);
376 	instance = ddi_get_instance(dip);
377 	DMSGX(1, "[%d] Entered\n", instance);
378 
379 	if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
380 		cmn_err(CE_NOTE, "[%d] Couldn't get state structure", instance);
381 		return (DDI_FAILURE);
382 	}
383 
384 	if (vdc->open_count) {
385 		DMSG(vdc, 0, "[%d] Cannot detach: device is open", instance);
386 		return (DDI_FAILURE);
387 	}
388 
389 	DMSG(vdc, 0, "[%d] proceeding...\n", instance);
390 
391 	/* mark instance as detaching */
392 	vdc->lifecycle	= VDC_LC_DETACHING;
393 
394 	/*
395 	 * try and disable callbacks to prevent another handshake
396 	 */
397 	rv = ldc_set_cb_mode(vdc->ldc_handle, LDC_CB_DISABLE);
398 	DMSG(vdc, 0, "callback disabled (rv=%d)\n", rv);
399 
400 	if (vdc->initialized & VDC_THREAD) {
401 		mutex_enter(&vdc->read_lock);
402 		if ((vdc->read_state == VDC_READ_WAITING) ||
403 		    (vdc->read_state == VDC_READ_RESET)) {
404 			vdc->read_state = VDC_READ_RESET;
405 			cv_signal(&vdc->read_cv);
406 		}
407 
408 		mutex_exit(&vdc->read_lock);
409 
410 		/* wake up any thread waiting for connection to come online */
411 		mutex_enter(&vdc->lock);
412 		if (vdc->state == VDC_STATE_INIT_WAITING) {
413 			DMSG(vdc, 0,
414 			    "[%d] write reset - move to resetting state...\n",
415 			    instance);
416 			vdc->state = VDC_STATE_RESETTING;
417 			cv_signal(&vdc->initwait_cv);
418 		}
419 		mutex_exit(&vdc->lock);
420 
421 		/* now wait until state transitions to VDC_STATE_DETACH */
422 		thread_join(vdc->msg_proc_thr->t_did);
423 		ASSERT(vdc->state == VDC_STATE_DETACH);
424 		DMSG(vdc, 0, "[%d] Reset thread exit and join ..\n",
425 		    vdc->instance);
426 	}
427 
428 	mutex_enter(&vdc->lock);
429 
430 	if (vdc->initialized & VDC_DRING)
431 		vdc_destroy_descriptor_ring(vdc);
432 
433 	if (vdc->initialized & VDC_LDC)
434 		vdc_terminate_ldc(vdc);
435 
436 	mutex_exit(&vdc->lock);
437 
438 	if (vdc->initialized & VDC_MINOR) {
439 		ddi_prop_remove_all(dip);
440 		ddi_remove_minor_node(dip, NULL);
441 	}
442 
443 	if (vdc->initialized & VDC_LOCKS) {
444 		mutex_destroy(&vdc->lock);
445 		mutex_destroy(&vdc->read_lock);
446 		cv_destroy(&vdc->initwait_cv);
447 		cv_destroy(&vdc->dring_free_cv);
448 		cv_destroy(&vdc->membind_cv);
449 		cv_destroy(&vdc->sync_pending_cv);
450 		cv_destroy(&vdc->sync_blocked_cv);
451 		cv_destroy(&vdc->read_cv);
452 		cv_destroy(&vdc->running_cv);
453 	}
454 
455 	if (vdc->minfo)
456 		kmem_free(vdc->minfo, sizeof (struct dk_minfo));
457 
458 	if (vdc->cinfo)
459 		kmem_free(vdc->cinfo, sizeof (struct dk_cinfo));
460 
461 	if (vdc->vtoc)
462 		kmem_free(vdc->vtoc, sizeof (struct vtoc));
463 
464 	if (vdc->label)
465 		kmem_free(vdc->label, DK_LABEL_SIZE);
466 
467 	if (vdc->devid) {
468 		ddi_devid_unregister(dip);
469 		ddi_devid_free(vdc->devid);
470 	}
471 
472 	if (vdc->initialized & VDC_SOFT_STATE)
473 		ddi_soft_state_free(vdc_state, instance);
474 
475 	DMSG(vdc, 0, "[%d] End %p\n", instance, (void *)vdc);
476 
477 	return (DDI_SUCCESS);
478 }
479 
480 
481 static int
482 vdc_do_attach(dev_info_t *dip)
483 {
484 	int		instance;
485 	vdc_t		*vdc = NULL;
486 	int		status;
487 
488 	ASSERT(dip != NULL);
489 
490 	instance = ddi_get_instance(dip);
491 	if (ddi_soft_state_zalloc(vdc_state, instance) != DDI_SUCCESS) {
492 		cmn_err(CE_NOTE, "[%d] Couldn't alloc state structure",
493 		    instance);
494 		return (DDI_FAILURE);
495 	}
496 
497 	if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
498 		cmn_err(CE_NOTE, "[%d] Couldn't get state structure", instance);
499 		return (DDI_FAILURE);
500 	}
501 
502 	/*
503 	 * We assign the value to initialized in this case to zero out the
504 	 * variable and then set bits in it to indicate what has been done
505 	 */
506 	vdc->initialized = VDC_SOFT_STATE;
507 
508 	vdc_hz_timeout = drv_usectohz(vdc_usec_timeout);
509 
510 	vdc_hz_min_ldc_delay = drv_usectohz(vdc_min_timeout_ldc);
511 	vdc_hz_max_ldc_delay = drv_usectohz(vdc_max_timeout_ldc);
512 
513 	vdc->dip	= dip;
514 	vdc->instance	= instance;
515 	vdc->open_count	= 0;
516 	vdc->vdisk_type	= VD_DISK_TYPE_UNK;
517 	vdc->vdisk_label = VD_DISK_LABEL_UNK;
518 	vdc->state	= VDC_STATE_INIT;
519 	vdc->lifecycle	= VDC_LC_ATTACHING;
520 	vdc->ldc_state	= 0;
521 	vdc->session_id = 0;
522 	vdc->block_size = DEV_BSIZE;
523 	vdc->max_xfer_sz = maxphys / DEV_BSIZE;
524 
525 	vdc->vtoc = NULL;
526 	vdc->cinfo = NULL;
527 	vdc->minfo = NULL;
528 
529 	mutex_init(&vdc->lock, NULL, MUTEX_DRIVER, NULL);
530 	cv_init(&vdc->initwait_cv, NULL, CV_DRIVER, NULL);
531 	cv_init(&vdc->dring_free_cv, NULL, CV_DRIVER, NULL);
532 	cv_init(&vdc->membind_cv, NULL, CV_DRIVER, NULL);
533 	cv_init(&vdc->running_cv, NULL, CV_DRIVER, NULL);
534 
535 	vdc->threads_pending = 0;
536 	vdc->sync_op_pending = B_FALSE;
537 	vdc->sync_op_blocked = B_FALSE;
538 	cv_init(&vdc->sync_pending_cv, NULL, CV_DRIVER, NULL);
539 	cv_init(&vdc->sync_blocked_cv, NULL, CV_DRIVER, NULL);
540 
541 	/* init blocking msg read functionality */
542 	mutex_init(&vdc->read_lock, NULL, MUTEX_DRIVER, NULL);
543 	cv_init(&vdc->read_cv, NULL, CV_DRIVER, NULL);
544 	vdc->read_state = VDC_READ_IDLE;
545 
546 	vdc->initialized |= VDC_LOCKS;
547 
548 	/* initialise LDC channel which will be used to communicate with vds */
549 	if ((status = vdc_do_ldc_init(vdc)) != 0) {
550 		cmn_err(CE_NOTE, "[%d] Couldn't initialize LDC", instance);
551 		goto return_status;
552 	}
553 
554 	/* initialize the thread responsible for managing state with server */
555 	vdc->msg_proc_thr = thread_create(NULL, 0, vdc_process_msg_thread,
556 	    vdc, 0, &p0, TS_RUN, minclsyspri);
557 	if (vdc->msg_proc_thr == NULL) {
558 		cmn_err(CE_NOTE, "[%d] Failed to create msg processing thread",
559 		    instance);
560 		return (DDI_FAILURE);
561 	}
562 
563 	vdc->initialized |= VDC_THREAD;
564 
565 	atomic_inc_32(&vdc_instance_count);
566 
567 	/*
568 	 * Once the handshake is complete, we can use the DRing to send
569 	 * requests to the vDisk server to calculate the geometry and
570 	 * VTOC of the "disk"
571 	 */
572 	status = vdc_setup_disk_layout(vdc);
573 	if (status != 0) {
574 		DMSG(vdc, 0, "[%d] Failed to discover disk layout (err%d)",
575 		    vdc->instance, status);
576 		goto return_status;
577 	}
578 
579 	/*
580 	 * Now that we have the device info we can create the
581 	 * device nodes and properties
582 	 */
583 	status = vdc_create_device_nodes(vdc);
584 	if (status) {
585 		DMSG(vdc, 0, "[%d] Failed to create device nodes",
586 		    instance);
587 		goto return_status;
588 	}
589 	status = vdc_create_device_nodes_props(vdc);
590 	if (status) {
591 		DMSG(vdc, 0, "[%d] Failed to create device nodes"
592 		    " properties (%d)", instance, status);
593 		goto return_status;
594 	}
595 
596 	/*
597 	 * Setup devid
598 	 */
599 	if (vdc_setup_devid(vdc)) {
600 		DMSG(vdc, 0, "[%d] No device id available\n", instance);
601 	}
602 
603 	ddi_report_dev(dip);
604 	vdc->lifecycle	= VDC_LC_ONLINE;
605 	DMSG(vdc, 0, "[%d] Attach tasks successful\n", instance);
606 
607 return_status:
608 	DMSG(vdc, 0, "[%d] Attach completed\n", instance);
609 	return (status);
610 }
611 
612 static int
613 vdc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
614 {
615 	int	status;
616 
617 	switch (cmd) {
618 	case DDI_ATTACH:
619 		if ((status = vdc_do_attach(dip)) != 0)
620 			(void) vdc_detach(dip, DDI_DETACH);
621 		return (status);
622 	case DDI_RESUME:
623 		/* nothing to do for this non-device */
624 		return (DDI_SUCCESS);
625 	default:
626 		return (DDI_FAILURE);
627 	}
628 }
629 
630 static int
631 vdc_do_ldc_init(vdc_t *vdc)
632 {
633 	int			status = 0;
634 	ldc_status_t		ldc_state;
635 	ldc_attr_t		ldc_attr;
636 	uint64_t		ldc_id = 0;
637 	dev_info_t		*dip = NULL;
638 
639 	ASSERT(vdc != NULL);
640 
641 	dip = vdc->dip;
642 	vdc->initialized |= VDC_LDC;
643 
644 	if ((status = vdc_get_ldc_id(dip, &ldc_id)) != 0) {
645 		DMSG(vdc, 0, "[%d] Failed to get LDC channel ID property",
646 		    vdc->instance);
647 		return (EIO);
648 	}
649 	vdc->ldc_id = ldc_id;
650 
651 	ldc_attr.devclass = LDC_DEV_BLK;
652 	ldc_attr.instance = vdc->instance;
653 	ldc_attr.mode = LDC_MODE_UNRELIABLE;	/* unreliable transport */
654 	ldc_attr.mtu = VD_LDC_MTU;
655 
656 	if ((vdc->initialized & VDC_LDC_INIT) == 0) {
657 		status = ldc_init(ldc_id, &ldc_attr, &vdc->ldc_handle);
658 		if (status != 0) {
659 			DMSG(vdc, 0, "[%d] ldc_init(chan %ld) returned %d",
660 			    vdc->instance, ldc_id, status);
661 			return (status);
662 		}
663 		vdc->initialized |= VDC_LDC_INIT;
664 	}
665 	status = ldc_status(vdc->ldc_handle, &ldc_state);
666 	if (status != 0) {
667 		DMSG(vdc, 0, "[%d] Cannot discover LDC status [err=%d]",
668 		    vdc->instance, status);
669 		return (status);
670 	}
671 	vdc->ldc_state = ldc_state;
672 
673 	if ((vdc->initialized & VDC_LDC_CB) == 0) {
674 		status = ldc_reg_callback(vdc->ldc_handle, vdc_handle_cb,
675 		    (caddr_t)vdc);
676 		if (status != 0) {
677 			DMSG(vdc, 0, "[%d] LDC callback reg. failed (%d)",
678 			    vdc->instance, status);
679 			return (status);
680 		}
681 		vdc->initialized |= VDC_LDC_CB;
682 	}
683 
684 	vdc->initialized |= VDC_LDC;
685 
686 	/*
687 	 * At this stage we have initialised LDC, we will now try and open
688 	 * the connection.
689 	 */
690 	if (vdc->ldc_state == LDC_INIT) {
691 		status = ldc_open(vdc->ldc_handle);
692 		if (status != 0) {
693 			DMSG(vdc, 0, "[%d] ldc_open(chan %ld) returned %d",
694 			    vdc->instance, vdc->ldc_id, status);
695 			return (status);
696 		}
697 		vdc->initialized |= VDC_LDC_OPEN;
698 	}
699 
700 	return (status);
701 }
702 
703 static int
704 vdc_start_ldc_connection(vdc_t *vdc)
705 {
706 	int		status = 0;
707 
708 	ASSERT(vdc != NULL);
709 
710 	ASSERT(MUTEX_HELD(&vdc->lock));
711 
712 	status = vdc_do_ldc_up(vdc);
713 
714 	DMSG(vdc, 0, "[%d] Finished bringing up LDC\n", vdc->instance);
715 
716 	return (status);
717 }
718 
719 static int
720 vdc_stop_ldc_connection(vdc_t *vdcp)
721 {
722 	int	status;
723 
724 	DMSG(vdcp, 0, ": Resetting connection to vDisk server : state %d\n",
725 	    vdcp->state);
726 
727 	status = ldc_down(vdcp->ldc_handle);
728 	DMSG(vdcp, 0, "ldc_down() = %d\n", status);
729 
730 	vdcp->initialized &= ~VDC_HANDSHAKE;
731 	DMSG(vdcp, 0, "initialized=%x\n", vdcp->initialized);
732 
733 	return (status);
734 }
735 
736 static int
737 vdc_create_device_nodes_efi(vdc_t *vdc)
738 {
739 	ddi_remove_minor_node(vdc->dip, "h");
740 	ddi_remove_minor_node(vdc->dip, "h,raw");
741 
742 	if (ddi_create_minor_node(vdc->dip, "wd", S_IFBLK,
743 	    VD_MAKE_DEV(vdc->instance, VD_EFI_WD_SLICE),
744 	    DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
745 		cmn_err(CE_NOTE, "[%d] Couldn't add block node 'wd'",
746 		    vdc->instance);
747 		return (EIO);
748 	}
749 
750 	/* if any device node is created we set this flag */
751 	vdc->initialized |= VDC_MINOR;
752 
753 	if (ddi_create_minor_node(vdc->dip, "wd,raw", S_IFCHR,
754 	    VD_MAKE_DEV(vdc->instance, VD_EFI_WD_SLICE),
755 	    DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
756 		cmn_err(CE_NOTE, "[%d] Couldn't add block node 'wd,raw'",
757 		    vdc->instance);
758 		return (EIO);
759 	}
760 
761 	return (0);
762 }
763 
764 static int
765 vdc_create_device_nodes_vtoc(vdc_t *vdc)
766 {
767 	ddi_remove_minor_node(vdc->dip, "wd");
768 	ddi_remove_minor_node(vdc->dip, "wd,raw");
769 
770 	if (ddi_create_minor_node(vdc->dip, "h", S_IFBLK,
771 	    VD_MAKE_DEV(vdc->instance, VD_EFI_WD_SLICE),
772 	    DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
773 		cmn_err(CE_NOTE, "[%d] Couldn't add block node 'h'",
774 		    vdc->instance);
775 		return (EIO);
776 	}
777 
778 	/* if any device node is created we set this flag */
779 	vdc->initialized |= VDC_MINOR;
780 
781 	if (ddi_create_minor_node(vdc->dip, "h,raw", S_IFCHR,
782 	    VD_MAKE_DEV(vdc->instance, VD_EFI_WD_SLICE),
783 	    DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
784 		cmn_err(CE_NOTE, "[%d] Couldn't add block node 'h,raw'",
785 		    vdc->instance);
786 		return (EIO);
787 	}
788 
789 	return (0);
790 }
791 
792 /*
793  * Function:
794  *	vdc_create_device_nodes
795  *
796  * Description:
797  *	This function creates the block and character device nodes under
798  *	/devices along with the node properties. It is called as part of
799  *	the attach(9E) of the instance during the handshake with vds after
800  *	vds has sent the attributes to vdc.
801  *
802  *	If the device is of type VD_DISK_TYPE_SLICE then the minor node
803  *	of 2 is used in keeping with the Solaris convention that slice 2
804  *	refers to a whole disk. Slices start at 'a'
805  *
806  * Parameters:
807  *	vdc 		- soft state pointer
808  *
809  * Return Values
810  *	0		- Success
811  *	EIO		- Failed to create node
812  *	EINVAL		- Unknown type of disk exported
813  */
814 static int
815 vdc_create_device_nodes(vdc_t *vdc)
816 {
817 	char		name[sizeof ("s,raw")];
818 	dev_info_t	*dip = NULL;
819 	int		instance, status;
820 	int		num_slices = 1;
821 	int		i;
822 
823 	ASSERT(vdc != NULL);
824 
825 	instance = vdc->instance;
826 	dip = vdc->dip;
827 
828 	switch (vdc->vdisk_type) {
829 	case VD_DISK_TYPE_DISK:
830 		num_slices = V_NUMPAR;
831 		break;
832 	case VD_DISK_TYPE_SLICE:
833 		num_slices = 1;
834 		break;
835 	case VD_DISK_TYPE_UNK:
836 	default:
837 		return (EINVAL);
838 	}
839 
840 	/*
841 	 * Minor nodes are different for EFI disks: EFI disks do not have
842 	 * a minor node 'g' for the minor number corresponding to slice
843 	 * VD_EFI_WD_SLICE (slice 7) instead they have a minor node 'wd'
844 	 * representing the whole disk.
845 	 */
846 	for (i = 0; i < num_slices; i++) {
847 
848 		if (i == VD_EFI_WD_SLICE) {
849 			if (vdc->vdisk_label == VD_DISK_LABEL_EFI)
850 				status = vdc_create_device_nodes_efi(vdc);
851 			else
852 				status = vdc_create_device_nodes_vtoc(vdc);
853 			if (status != 0)
854 				return (status);
855 			continue;
856 		}
857 
858 		(void) snprintf(name, sizeof (name), "%c", 'a' + i);
859 		if (ddi_create_minor_node(dip, name, S_IFBLK,
860 		    VD_MAKE_DEV(instance, i), DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
861 			cmn_err(CE_NOTE, "[%d] Couldn't add block node '%s'",
862 			    instance, name);
863 			return (EIO);
864 		}
865 
866 		/* if any device node is created we set this flag */
867 		vdc->initialized |= VDC_MINOR;
868 
869 		(void) snprintf(name, sizeof (name), "%c%s", 'a' + i, ",raw");
870 
871 		if (ddi_create_minor_node(dip, name, S_IFCHR,
872 		    VD_MAKE_DEV(instance, i), DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
873 			cmn_err(CE_NOTE, "[%d] Couldn't add raw node '%s'",
874 			    instance, name);
875 			return (EIO);
876 		}
877 	}
878 
879 	return (0);
880 }
881 
882 /*
883  * Function:
884  *	vdc_create_device_nodes_props
885  *
886  * Description:
887  *	This function creates the block and character device nodes under
888  *	/devices along with the node properties. It is called as part of
889  *	the attach(9E) of the instance during the handshake with vds after
890  *	vds has sent the attributes to vdc.
891  *
892  * Parameters:
893  *	vdc 		- soft state pointer
894  *
895  * Return Values
896  *	0		- Success
897  *	EIO		- Failed to create device node property
898  *	EINVAL		- Unknown type of disk exported
899  */
900 static int
901 vdc_create_device_nodes_props(vdc_t *vdc)
902 {
903 	dev_info_t	*dip = NULL;
904 	int		instance;
905 	int		num_slices = 1;
906 	int64_t		size = 0;
907 	dev_t		dev;
908 	int		rv;
909 	int		i;
910 
911 	ASSERT(vdc != NULL);
912 
913 	instance = vdc->instance;
914 	dip = vdc->dip;
915 
916 	if ((vdc->vtoc == NULL) || (vdc->vtoc->v_sanity != VTOC_SANE)) {
917 		DMSG(vdc, 0, "![%d] Could not create device node property."
918 		    " No VTOC available", instance);
919 		return (ENXIO);
920 	}
921 
922 	switch (vdc->vdisk_type) {
923 	case VD_DISK_TYPE_DISK:
924 		num_slices = V_NUMPAR;
925 		break;
926 	case VD_DISK_TYPE_SLICE:
927 		num_slices = 1;
928 		break;
929 	case VD_DISK_TYPE_UNK:
930 	default:
931 		return (EINVAL);
932 	}
933 
934 	for (i = 0; i < num_slices; i++) {
935 		dev = makedevice(ddi_driver_major(dip),
936 		    VD_MAKE_DEV(instance, i));
937 
938 		size = vdc->vtoc->v_part[i].p_size * vdc->vtoc->v_sectorsz;
939 		DMSG(vdc, 0, "[%d] sz %ld (%ld Mb)  p_size %lx\n",
940 		    instance, size, size / (1024 * 1024),
941 		    vdc->vtoc->v_part[i].p_size);
942 
943 		rv = ddi_prop_update_int64(dev, dip, VDC_SIZE_PROP_NAME, size);
944 		if (rv != DDI_PROP_SUCCESS) {
945 			cmn_err(CE_NOTE, "[%d] Couldn't add '%s' prop of [%ld]",
946 			    instance, VDC_SIZE_PROP_NAME, size);
947 			return (EIO);
948 		}
949 
950 		rv = ddi_prop_update_int64(dev, dip, VDC_NBLOCKS_PROP_NAME,
951 		    lbtodb(size));
952 		if (rv != DDI_PROP_SUCCESS) {
953 			cmn_err(CE_NOTE, "[%d] Couldn't add '%s' prop [%llu]",
954 			    instance, VDC_NBLOCKS_PROP_NAME, lbtodb(size));
955 			return (EIO);
956 		}
957 	}
958 
959 	return (0);
960 }
961 
962 static int
963 vdc_open(dev_t *dev, int flag, int otyp, cred_t *cred)
964 {
965 	_NOTE(ARGUNUSED(cred))
966 
967 	int		instance;
968 	vdc_t		*vdc;
969 
970 	ASSERT(dev != NULL);
971 	instance = VDCUNIT(*dev);
972 
973 	if ((otyp != OTYP_CHR) && (otyp != OTYP_BLK))
974 		return (EINVAL);
975 
976 	if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
977 		cmn_err(CE_NOTE, "[%d] Couldn't get state structure", instance);
978 		return (ENXIO);
979 	}
980 
981 	DMSG(vdc, 0, "minor = %d flag = %x, otyp = %x\n",
982 	    getminor(*dev), flag, otyp);
983 
984 	mutex_enter(&vdc->lock);
985 	vdc->open_count++;
986 	mutex_exit(&vdc->lock);
987 
988 	return (0);
989 }
990 
991 static int
992 vdc_close(dev_t dev, int flag, int otyp, cred_t *cred)
993 {
994 	_NOTE(ARGUNUSED(cred))
995 
996 	int	instance;
997 	vdc_t	*vdc;
998 
999 	instance = VDCUNIT(dev);
1000 
1001 	if ((otyp != OTYP_CHR) && (otyp != OTYP_BLK))
1002 		return (EINVAL);
1003 
1004 	if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
1005 		cmn_err(CE_NOTE, "[%d] Couldn't get state structure", instance);
1006 		return (ENXIO);
1007 	}
1008 
1009 	DMSG(vdc, 0, "[%d] flag = %x, otyp = %x\n", instance, flag, otyp);
1010 	if (vdc->dkio_flush_pending) {
1011 		DMSG(vdc, 0,
1012 		    "[%d] Cannot detach: %d outstanding DKIO flushes\n",
1013 		    instance, vdc->dkio_flush_pending);
1014 		return (EBUSY);
1015 	}
1016 
1017 	/*
1018 	 * Should not need the mutex here, since the framework should protect
1019 	 * against more opens on this device, but just in case.
1020 	 */
1021 	mutex_enter(&vdc->lock);
1022 	vdc->open_count--;
1023 	mutex_exit(&vdc->lock);
1024 
1025 	return (0);
1026 }
1027 
1028 static int
1029 vdc_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, int *rvalp)
1030 {
1031 	_NOTE(ARGUNUSED(credp))
1032 	_NOTE(ARGUNUSED(rvalp))
1033 
1034 	return (vd_process_ioctl(dev, cmd, (caddr_t)arg, mode));
1035 }
1036 
1037 static int
1038 vdc_print(dev_t dev, char *str)
1039 {
1040 	cmn_err(CE_NOTE, "vdc%d:  %s", VDCUNIT(dev), str);
1041 	return (0);
1042 }
1043 
1044 static int
1045 vdc_dump(dev_t dev, caddr_t addr, daddr_t blkno, int nblk)
1046 {
1047 	int	rv;
1048 	size_t	nbytes = nblk * DEV_BSIZE;
1049 	int	instance = VDCUNIT(dev);
1050 	vdc_t	*vdc = NULL;
1051 
1052 	if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
1053 		cmn_err(CE_NOTE, "[%d] Couldn't get state structure", instance);
1054 		return (ENXIO);
1055 	}
1056 
1057 	DMSG(vdc, 2, "[%d] dump %ld bytes at block 0x%lx : addr=0x%p\n",
1058 	    instance, nbytes, blkno, (void *)addr);
1059 	rv = vdc_send_request(vdc, VD_OP_BWRITE, addr, nbytes,
1060 	    VDCPART(dev), blkno, CB_STRATEGY, 0, VIO_write_dir);
1061 	if (rv) {
1062 		DMSG(vdc, 0, "Failed to do a disk dump (err=%d)\n", rv);
1063 		return (rv);
1064 	}
1065 
1066 	if (ddi_in_panic())
1067 		(void) vdc_drain_response(vdc);
1068 
1069 	DMSG(vdc, 0, "[%d] End\n", instance);
1070 
1071 	return (0);
1072 }
1073 
1074 /* -------------------------------------------------------------------------- */
1075 
1076 /*
1077  * Disk access routines
1078  *
1079  */
1080 
1081 /*
1082  * vdc_strategy()
1083  *
1084  * Return Value:
1085  *	0:	As per strategy(9E), the strategy() function must return 0
1086  *		[ bioerror(9f) sets b_flags to the proper error code ]
1087  */
1088 static int
1089 vdc_strategy(struct buf *buf)
1090 {
1091 	int	rv = -1;
1092 	vdc_t	*vdc = NULL;
1093 	int	instance = VDCUNIT(buf->b_edev);
1094 	int	op = (buf->b_flags & B_READ) ? VD_OP_BREAD : VD_OP_BWRITE;
1095 	int	slice;
1096 
1097 	if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
1098 		cmn_err(CE_NOTE, "[%d] Couldn't get state structure", instance);
1099 		bioerror(buf, ENXIO);
1100 		biodone(buf);
1101 		return (0);
1102 	}
1103 
1104 	DMSG(vdc, 2, "[%d] %s %ld bytes at block %llx : b_addr=0x%p\n",
1105 	    instance, (buf->b_flags & B_READ) ? "Read" : "Write",
1106 	    buf->b_bcount, buf->b_lblkno, (void *)buf->b_un.b_addr);
1107 	DTRACE_IO2(vstart, buf_t *, buf, vdc_t *, vdc);
1108 
1109 	bp_mapin(buf);
1110 
1111 	if ((long)buf->b_private == VD_SLICE_NONE) {
1112 		/* I/O using an absolute disk offset */
1113 		slice = VD_SLICE_NONE;
1114 	} else {
1115 		slice = VDCPART(buf->b_edev);
1116 	}
1117 
1118 	rv = vdc_send_request(vdc, op, (caddr_t)buf->b_un.b_addr,
1119 	    buf->b_bcount, slice, buf->b_lblkno,
1120 	    CB_STRATEGY, buf, (op == VD_OP_BREAD) ? VIO_read_dir :
1121 	    VIO_write_dir);
1122 
1123 	/*
1124 	 * If the request was successfully sent, the strategy call returns and
1125 	 * the ACK handler calls the bioxxx functions when the vDisk server is
1126 	 * done.
1127 	 */
1128 	if (rv) {
1129 		DMSG(vdc, 0, "Failed to read/write (err=%d)\n", rv);
1130 		bioerror(buf, rv);
1131 		biodone(buf);
1132 	}
1133 
1134 	return (0);
1135 }
1136 
1137 /*
1138  * Function:
1139  *	vdc_min
1140  *
1141  * Description:
1142  *	Routine to limit the size of a data transfer. Used in
1143  *	conjunction with physio(9F).
1144  *
1145  * Arguments:
1146  *	bp - pointer to the indicated buf(9S) struct.
1147  *
1148  */
1149 static void
1150 vdc_min(struct buf *bufp)
1151 {
1152 	vdc_t	*vdc = NULL;
1153 	int	instance = VDCUNIT(bufp->b_edev);
1154 
1155 	vdc = ddi_get_soft_state(vdc_state, instance);
1156 	VERIFY(vdc != NULL);
1157 
1158 	if (bufp->b_bcount > (vdc->max_xfer_sz * vdc->block_size)) {
1159 		bufp->b_bcount = vdc->max_xfer_sz * vdc->block_size;
1160 	}
1161 }
1162 
1163 static int
1164 vdc_read(dev_t dev, struct uio *uio, cred_t *cred)
1165 {
1166 	_NOTE(ARGUNUSED(cred))
1167 
1168 	DMSGX(1, "[%d] Entered", VDCUNIT(dev));
1169 	return (physio(vdc_strategy, NULL, dev, B_READ, vdc_min, uio));
1170 }
1171 
1172 static int
1173 vdc_write(dev_t dev, struct uio *uio, cred_t *cred)
1174 {
1175 	_NOTE(ARGUNUSED(cred))
1176 
1177 	DMSGX(1, "[%d] Entered", VDCUNIT(dev));
1178 	return (physio(vdc_strategy, NULL, dev, B_WRITE, vdc_min, uio));
1179 }
1180 
1181 static int
1182 vdc_aread(dev_t dev, struct aio_req *aio, cred_t *cred)
1183 {
1184 	_NOTE(ARGUNUSED(cred))
1185 
1186 	DMSGX(1, "[%d] Entered", VDCUNIT(dev));
1187 	return (aphysio(vdc_strategy, anocancel, dev, B_READ, vdc_min, aio));
1188 }
1189 
1190 static int
1191 vdc_awrite(dev_t dev, struct aio_req *aio, cred_t *cred)
1192 {
1193 	_NOTE(ARGUNUSED(cred))
1194 
1195 	DMSGX(1, "[%d] Entered", VDCUNIT(dev));
1196 	return (aphysio(vdc_strategy, anocancel, dev, B_WRITE, vdc_min, aio));
1197 }
1198 
1199 
1200 /* -------------------------------------------------------------------------- */
1201 
1202 /*
1203  * Handshake support
1204  */
1205 
1206 
1207 /*
1208  * Function:
1209  *	vdc_init_ver_negotiation()
1210  *
1211  * Description:
1212  *
1213  * Arguments:
1214  *	vdc	- soft state pointer for this instance of the device driver.
1215  *
1216  * Return Code:
1217  *	0	- Success
1218  */
1219 static int
1220 vdc_init_ver_negotiation(vdc_t *vdc, vio_ver_t ver)
1221 {
1222 	vio_ver_msg_t	pkt;
1223 	size_t		msglen = sizeof (pkt);
1224 	int		status = -1;
1225 
1226 	ASSERT(vdc != NULL);
1227 	ASSERT(mutex_owned(&vdc->lock));
1228 
1229 	DMSG(vdc, 0, "[%d] Entered.\n", vdc->instance);
1230 
1231 	/*
1232 	 * set the Session ID to a unique value
1233 	 * (the lower 32 bits of the clock tick)
1234 	 */
1235 	vdc->session_id = ((uint32_t)gettick() & 0xffffffff);
1236 	DMSG(vdc, 0, "[%d] Set SID to 0x%lx\n", vdc->instance, vdc->session_id);
1237 
1238 	pkt.tag.vio_msgtype = VIO_TYPE_CTRL;
1239 	pkt.tag.vio_subtype = VIO_SUBTYPE_INFO;
1240 	pkt.tag.vio_subtype_env = VIO_VER_INFO;
1241 	pkt.tag.vio_sid = vdc->session_id;
1242 	pkt.dev_class = VDEV_DISK;
1243 	pkt.ver_major = ver.major;
1244 	pkt.ver_minor = ver.minor;
1245 
1246 	status = vdc_send(vdc, (caddr_t)&pkt, &msglen);
1247 	DMSG(vdc, 0, "[%d] Ver info sent (status = %d)\n",
1248 	    vdc->instance, status);
1249 	if ((status != 0) || (msglen != sizeof (vio_ver_msg_t))) {
1250 		DMSG(vdc, 0, "[%d] Failed to send Ver negotiation info: "
1251 		    "id(%lx) rv(%d) size(%ld)", vdc->instance, vdc->ldc_handle,
1252 		    status, msglen);
1253 		if (msglen != sizeof (vio_ver_msg_t))
1254 			status = ENOMSG;
1255 	}
1256 
1257 	return (status);
1258 }
1259 
1260 /*
1261  * Function:
1262  *	vdc_ver_negotiation()
1263  *
1264  * Description:
1265  *
1266  * Arguments:
1267  *	vdcp	- soft state pointer for this instance of the device driver.
1268  *
1269  * Return Code:
1270  *	0	- Success
1271  */
1272 static int
1273 vdc_ver_negotiation(vdc_t *vdcp)
1274 {
1275 	vio_msg_t vio_msg;
1276 	int status;
1277 
1278 	if (status = vdc_init_ver_negotiation(vdcp, vdc_version[0]))
1279 		return (status);
1280 
1281 	/* release lock and wait for response */
1282 	mutex_exit(&vdcp->lock);
1283 	status = vdc_wait_for_response(vdcp, &vio_msg);
1284 	mutex_enter(&vdcp->lock);
1285 	if (status) {
1286 		DMSG(vdcp, 0,
1287 		    "[%d] Failed waiting for Ver negotiation response, rv(%d)",
1288 		    vdcp->instance, status);
1289 		return (status);
1290 	}
1291 
1292 	/* check type and sub_type ... */
1293 	if (vio_msg.tag.vio_msgtype != VIO_TYPE_CTRL ||
1294 	    vio_msg.tag.vio_subtype == VIO_SUBTYPE_INFO) {
1295 		DMSG(vdcp, 0, "[%d] Invalid ver negotiation response\n",
1296 		    vdcp->instance);
1297 		return (EPROTO);
1298 	}
1299 
1300 	return (vdc_handle_ver_msg(vdcp, (vio_ver_msg_t *)&vio_msg));
1301 }
1302 
1303 /*
1304  * Function:
1305  *	vdc_init_attr_negotiation()
1306  *
1307  * Description:
1308  *
1309  * Arguments:
1310  *	vdc	- soft state pointer for this instance of the device driver.
1311  *
1312  * Return Code:
1313  *	0	- Success
1314  */
1315 static int
1316 vdc_init_attr_negotiation(vdc_t *vdc)
1317 {
1318 	vd_attr_msg_t	pkt;
1319 	size_t		msglen = sizeof (pkt);
1320 	int		status;
1321 
1322 	ASSERT(vdc != NULL);
1323 	ASSERT(mutex_owned(&vdc->lock));
1324 
1325 	DMSG(vdc, 0, "[%d] entered\n", vdc->instance);
1326 
1327 	/* fill in tag */
1328 	pkt.tag.vio_msgtype = VIO_TYPE_CTRL;
1329 	pkt.tag.vio_subtype = VIO_SUBTYPE_INFO;
1330 	pkt.tag.vio_subtype_env = VIO_ATTR_INFO;
1331 	pkt.tag.vio_sid = vdc->session_id;
1332 	/* fill in payload */
1333 	pkt.max_xfer_sz = vdc->max_xfer_sz;
1334 	pkt.vdisk_block_size = vdc->block_size;
1335 	pkt.xfer_mode = VIO_DRING_MODE;
1336 	pkt.operations = 0;	/* server will set bits of valid operations */
1337 	pkt.vdisk_type = 0;	/* server will set to valid device type */
1338 	pkt.vdisk_size = 0;	/* server will set to valid size */
1339 
1340 	status = vdc_send(vdc, (caddr_t)&pkt, &msglen);
1341 	DMSG(vdc, 0, "Attr info sent (status = %d)\n", status);
1342 
1343 	if ((status != 0) || (msglen != sizeof (vio_ver_msg_t))) {
1344 		DMSG(vdc, 0, "[%d] Failed to send Attr negotiation info: "
1345 		    "id(%lx) rv(%d) size(%ld)", vdc->instance, vdc->ldc_handle,
1346 		    status, msglen);
1347 		if (msglen != sizeof (vio_ver_msg_t))
1348 			status = ENOMSG;
1349 	}
1350 
1351 	return (status);
1352 }
1353 
1354 /*
1355  * Function:
1356  *	vdc_attr_negotiation()
1357  *
1358  * Description:
1359  *
1360  * Arguments:
1361  *	vdc	- soft state pointer for this instance of the device driver.
1362  *
1363  * Return Code:
1364  *	0	- Success
1365  */
1366 static int
1367 vdc_attr_negotiation(vdc_t *vdcp)
1368 {
1369 	int status;
1370 	vio_msg_t vio_msg;
1371 
1372 	if (status = vdc_init_attr_negotiation(vdcp))
1373 		return (status);
1374 
1375 	/* release lock and wait for response */
1376 	mutex_exit(&vdcp->lock);
1377 	status = vdc_wait_for_response(vdcp, &vio_msg);
1378 	mutex_enter(&vdcp->lock);
1379 	if (status) {
1380 		DMSG(vdcp, 0,
1381 		    "[%d] Failed waiting for Attr negotiation response, rv(%d)",
1382 		    vdcp->instance, status);
1383 		return (status);
1384 	}
1385 
1386 	/* check type and sub_type ... */
1387 	if (vio_msg.tag.vio_msgtype != VIO_TYPE_CTRL ||
1388 	    vio_msg.tag.vio_subtype == VIO_SUBTYPE_INFO) {
1389 		DMSG(vdcp, 0, "[%d] Invalid attr negotiation response\n",
1390 		    vdcp->instance);
1391 		return (EPROTO);
1392 	}
1393 
1394 	return (vdc_handle_attr_msg(vdcp, (vd_attr_msg_t *)&vio_msg));
1395 }
1396 
1397 
1398 /*
1399  * Function:
1400  *	vdc_init_dring_negotiate()
1401  *
1402  * Description:
1403  *
1404  * Arguments:
1405  *	vdc	- soft state pointer for this instance of the device driver.
1406  *
1407  * Return Code:
1408  *	0	- Success
1409  */
1410 static int
1411 vdc_init_dring_negotiate(vdc_t *vdc)
1412 {
1413 	vio_dring_reg_msg_t	pkt;
1414 	size_t			msglen = sizeof (pkt);
1415 	int			status = -1;
1416 	int			retry;
1417 	int			nretries = 10;
1418 
1419 	ASSERT(vdc != NULL);
1420 	ASSERT(mutex_owned(&vdc->lock));
1421 
1422 	for (retry = 0; retry < nretries; retry++) {
1423 		status = vdc_init_descriptor_ring(vdc);
1424 		if (status != EAGAIN)
1425 			break;
1426 		drv_usecwait(vdc_min_timeout_ldc);
1427 	}
1428 
1429 	if (status != 0) {
1430 		DMSG(vdc, 0, "[%d] Failed to init DRing (status = %d)\n",
1431 		    vdc->instance, status);
1432 		return (status);
1433 	}
1434 
1435 	DMSG(vdc, 0, "[%d] Init of descriptor ring completed (status = %d)\n",
1436 	    vdc->instance, status);
1437 
1438 	/* fill in tag */
1439 	pkt.tag.vio_msgtype = VIO_TYPE_CTRL;
1440 	pkt.tag.vio_subtype = VIO_SUBTYPE_INFO;
1441 	pkt.tag.vio_subtype_env = VIO_DRING_REG;
1442 	pkt.tag.vio_sid = vdc->session_id;
1443 	/* fill in payload */
1444 	pkt.dring_ident = 0;
1445 	pkt.num_descriptors = vdc->dring_len;
1446 	pkt.descriptor_size = vdc->dring_entry_size;
1447 	pkt.options = (VIO_TX_DRING | VIO_RX_DRING);
1448 	pkt.ncookies = vdc->dring_cookie_count;
1449 	pkt.cookie[0] = vdc->dring_cookie[0];	/* for now just one cookie */
1450 
1451 	status = vdc_send(vdc, (caddr_t)&pkt, &msglen);
1452 	if (status != 0) {
1453 		DMSG(vdc, 0, "[%d] Failed to register DRing (err = %d)",
1454 		    vdc->instance, status);
1455 	}
1456 
1457 	return (status);
1458 }
1459 
1460 
1461 /*
1462  * Function:
1463  *	vdc_dring_negotiation()
1464  *
1465  * Description:
1466  *
1467  * Arguments:
1468  *	vdc	- soft state pointer for this instance of the device driver.
1469  *
1470  * Return Code:
1471  *	0	- Success
1472  */
1473 static int
1474 vdc_dring_negotiation(vdc_t *vdcp)
1475 {
1476 	int status;
1477 	vio_msg_t vio_msg;
1478 
1479 	if (status = vdc_init_dring_negotiate(vdcp))
1480 		return (status);
1481 
1482 	/* release lock and wait for response */
1483 	mutex_exit(&vdcp->lock);
1484 	status = vdc_wait_for_response(vdcp, &vio_msg);
1485 	mutex_enter(&vdcp->lock);
1486 	if (status) {
1487 		DMSG(vdcp, 0,
1488 		    "[%d] Failed waiting for Dring negotiation response,"
1489 		    " rv(%d)", vdcp->instance, status);
1490 		return (status);
1491 	}
1492 
1493 	/* check type and sub_type ... */
1494 	if (vio_msg.tag.vio_msgtype != VIO_TYPE_CTRL ||
1495 	    vio_msg.tag.vio_subtype == VIO_SUBTYPE_INFO) {
1496 		DMSG(vdcp, 0, "[%d] Invalid Dring negotiation response\n",
1497 		    vdcp->instance);
1498 		return (EPROTO);
1499 	}
1500 
1501 	return (vdc_handle_dring_reg_msg(vdcp,
1502 	    (vio_dring_reg_msg_t *)&vio_msg));
1503 }
1504 
1505 
1506 /*
1507  * Function:
1508  *	vdc_send_rdx()
1509  *
1510  * Description:
1511  *
1512  * Arguments:
1513  *	vdc	- soft state pointer for this instance of the device driver.
1514  *
1515  * Return Code:
1516  *	0	- Success
1517  */
1518 static int
1519 vdc_send_rdx(vdc_t *vdcp)
1520 {
1521 	vio_msg_t	msg;
1522 	size_t		msglen = sizeof (vio_msg_t);
1523 	int		status;
1524 
1525 	/*
1526 	 * Send an RDX message to vds to indicate we are ready
1527 	 * to send data
1528 	 */
1529 	msg.tag.vio_msgtype = VIO_TYPE_CTRL;
1530 	msg.tag.vio_subtype = VIO_SUBTYPE_INFO;
1531 	msg.tag.vio_subtype_env = VIO_RDX;
1532 	msg.tag.vio_sid = vdcp->session_id;
1533 	status = vdc_send(vdcp, (caddr_t)&msg, &msglen);
1534 	if (status != 0) {
1535 		DMSG(vdcp, 0, "[%d] Failed to send RDX message (%d)",
1536 		    vdcp->instance, status);
1537 	}
1538 
1539 	return (status);
1540 }
1541 
1542 /*
1543  * Function:
1544  *	vdc_handle_rdx()
1545  *
1546  * Description:
1547  *
1548  * Arguments:
1549  *	vdc	- soft state pointer for this instance of the device driver.
1550  *	msgp	- received msg
1551  *
1552  * Return Code:
1553  *	0	- Success
1554  */
1555 static int
1556 vdc_handle_rdx(vdc_t *vdcp, vio_rdx_msg_t *msgp)
1557 {
1558 	_NOTE(ARGUNUSED(vdcp))
1559 	_NOTE(ARGUNUSED(msgp))
1560 
1561 	ASSERT(msgp->tag.vio_msgtype == VIO_TYPE_CTRL);
1562 	ASSERT(msgp->tag.vio_subtype == VIO_SUBTYPE_ACK);
1563 	ASSERT(msgp->tag.vio_subtype_env == VIO_RDX);
1564 
1565 	DMSG(vdcp, 1, "[%d] Got an RDX msg", vdcp->instance);
1566 
1567 	return (0);
1568 }
1569 
1570 /*
1571  * Function:
1572  *	vdc_rdx_exchange()
1573  *
1574  * Description:
1575  *
1576  * Arguments:
1577  *	vdc	- soft state pointer for this instance of the device driver.
1578  *
1579  * Return Code:
1580  *	0	- Success
1581  */
1582 static int
1583 vdc_rdx_exchange(vdc_t *vdcp)
1584 {
1585 	int status;
1586 	vio_msg_t vio_msg;
1587 
1588 	if (status = vdc_send_rdx(vdcp))
1589 		return (status);
1590 
1591 	/* release lock and wait for response */
1592 	mutex_exit(&vdcp->lock);
1593 	status = vdc_wait_for_response(vdcp, &vio_msg);
1594 	mutex_enter(&vdcp->lock);
1595 	if (status) {
1596 		DMSG(vdcp, 0, "[%d] Failed waiting for RDX response, rv(%d)",
1597 		    vdcp->instance, status);
1598 		return (status);
1599 	}
1600 
1601 	/* check type and sub_type ... */
1602 	if (vio_msg.tag.vio_msgtype != VIO_TYPE_CTRL ||
1603 	    vio_msg.tag.vio_subtype != VIO_SUBTYPE_ACK) {
1604 		DMSG(vdcp, 0, "[%d] Invalid RDX response\n", vdcp->instance);
1605 		return (EPROTO);
1606 	}
1607 
1608 	return (vdc_handle_rdx(vdcp, (vio_rdx_msg_t *)&vio_msg));
1609 }
1610 
1611 
1612 /* -------------------------------------------------------------------------- */
1613 
1614 /*
1615  * LDC helper routines
1616  */
1617 
1618 static int
1619 vdc_recv(vdc_t *vdc, vio_msg_t *msgp, size_t *nbytesp)
1620 {
1621 	int		status;
1622 	boolean_t	q_has_pkts = B_FALSE;
1623 	int		delay_time;
1624 	size_t		len;
1625 
1626 	mutex_enter(&vdc->read_lock);
1627 
1628 	if (vdc->read_state == VDC_READ_IDLE)
1629 		vdc->read_state = VDC_READ_WAITING;
1630 
1631 	while (vdc->read_state != VDC_READ_PENDING) {
1632 
1633 		/* detect if the connection has been reset */
1634 		if (vdc->read_state == VDC_READ_RESET) {
1635 			status = ECONNRESET;
1636 			goto done;
1637 		}
1638 
1639 		cv_wait(&vdc->read_cv, &vdc->read_lock);
1640 	}
1641 
1642 	/*
1643 	 * Until we get a blocking ldc read we have to retry
1644 	 * until the entire LDC message has arrived before
1645 	 * ldc_read() will succeed. Note we also bail out if
1646 	 * the channel is reset or goes away.
1647 	 */
1648 	delay_time = vdc_ldc_read_init_delay;
1649 loop:
1650 	len = *nbytesp;
1651 	status = ldc_read(vdc->ldc_handle, (caddr_t)msgp, &len);
1652 	switch (status) {
1653 	case EAGAIN:
1654 		delay_time *= 2;
1655 		if (delay_time >= vdc_ldc_read_max_delay)
1656 			delay_time = vdc_ldc_read_max_delay;
1657 		delay(delay_time);
1658 		goto loop;
1659 
1660 	case 0:
1661 		if (len == 0) {
1662 			DMSG(vdc, 0, "[%d] ldc_read returned 0 bytes with "
1663 			    "no error!\n", vdc->instance);
1664 			goto loop;
1665 		}
1666 
1667 		*nbytesp = len;
1668 
1669 		/*
1670 		 * If there are pending messages, leave the
1671 		 * read state as pending. Otherwise, set the state
1672 		 * back to idle.
1673 		 */
1674 		status = ldc_chkq(vdc->ldc_handle, &q_has_pkts);
1675 		if (status == 0 && !q_has_pkts)
1676 			vdc->read_state = VDC_READ_IDLE;
1677 
1678 		break;
1679 	default:
1680 		DMSG(vdc, 0, "ldc_read returned %d\n", status);
1681 		break;
1682 	}
1683 
1684 done:
1685 	mutex_exit(&vdc->read_lock);
1686 
1687 	return (status);
1688 }
1689 
1690 
1691 
1692 #ifdef DEBUG
1693 void
1694 vdc_decode_tag(vdc_t *vdcp, vio_msg_t *msg)
1695 {
1696 	char *ms, *ss, *ses;
1697 	switch (msg->tag.vio_msgtype) {
1698 #define	Q(_s)	case _s : ms = #_s; break;
1699 	Q(VIO_TYPE_CTRL)
1700 	Q(VIO_TYPE_DATA)
1701 	Q(VIO_TYPE_ERR)
1702 #undef Q
1703 	default: ms = "unknown"; break;
1704 	}
1705 
1706 	switch (msg->tag.vio_subtype) {
1707 #define	Q(_s)	case _s : ss = #_s; break;
1708 	Q(VIO_SUBTYPE_INFO)
1709 	Q(VIO_SUBTYPE_ACK)
1710 	Q(VIO_SUBTYPE_NACK)
1711 #undef Q
1712 	default: ss = "unknown"; break;
1713 	}
1714 
1715 	switch (msg->tag.vio_subtype_env) {
1716 #define	Q(_s)	case _s : ses = #_s; break;
1717 	Q(VIO_VER_INFO)
1718 	Q(VIO_ATTR_INFO)
1719 	Q(VIO_DRING_REG)
1720 	Q(VIO_DRING_UNREG)
1721 	Q(VIO_RDX)
1722 	Q(VIO_PKT_DATA)
1723 	Q(VIO_DESC_DATA)
1724 	Q(VIO_DRING_DATA)
1725 #undef Q
1726 	default: ses = "unknown"; break;
1727 	}
1728 
1729 	DMSG(vdcp, 3, "(%x/%x/%x) message : (%s/%s/%s)\n",
1730 	    msg->tag.vio_msgtype, msg->tag.vio_subtype,
1731 	    msg->tag.vio_subtype_env, ms, ss, ses);
1732 }
1733 #endif
1734 
1735 /*
1736  * Function:
1737  *	vdc_send()
1738  *
1739  * Description:
1740  *	The function encapsulates the call to write a message using LDC.
1741  *	If LDC indicates that the call failed due to the queue being full,
1742  *	we retry the ldc_write() [ up to 'vdc_retries' time ], otherwise
1743  *	we return the error returned by LDC.
1744  *
1745  * Arguments:
1746  *	ldc_handle	- LDC handle for the channel this instance of vdc uses
1747  *	pkt		- address of LDC message to be sent
1748  *	msglen		- the size of the message being sent. When the function
1749  *			  returns, this contains the number of bytes written.
1750  *
1751  * Return Code:
1752  *	0		- Success.
1753  *	EINVAL		- pkt or msglen were NULL
1754  *	ECONNRESET	- The connection was not up.
1755  *	EWOULDBLOCK	- LDC queue is full
1756  *	xxx		- other error codes returned by ldc_write
1757  */
1758 static int
1759 vdc_send(vdc_t *vdc, caddr_t pkt, size_t *msglen)
1760 {
1761 	size_t	size = 0;
1762 	int	status = 0;
1763 	clock_t delay_ticks;
1764 
1765 	ASSERT(vdc != NULL);
1766 	ASSERT(mutex_owned(&vdc->lock));
1767 	ASSERT(msglen != NULL);
1768 	ASSERT(*msglen != 0);
1769 
1770 #ifdef DEBUG
1771 	vdc_decode_tag(vdc, (vio_msg_t *)pkt);
1772 #endif
1773 	/*
1774 	 * Wait indefinitely to send if channel
1775 	 * is busy, but bail out if we succeed or
1776 	 * if the channel closes or is reset.
1777 	 */
1778 	delay_ticks = vdc_hz_min_ldc_delay;
1779 	do {
1780 		size = *msglen;
1781 		status = ldc_write(vdc->ldc_handle, pkt, &size);
1782 		if (status == EWOULDBLOCK) {
1783 			delay(delay_ticks);
1784 			/* geometric backoff */
1785 			delay_ticks *= 2;
1786 			if (delay_ticks > vdc_hz_max_ldc_delay)
1787 				delay_ticks = vdc_hz_max_ldc_delay;
1788 		}
1789 	} while (status == EWOULDBLOCK);
1790 
1791 	/* if LDC had serious issues --- reset vdc state */
1792 	if (status == EIO || status == ECONNRESET) {
1793 		/* LDC had serious issues --- reset vdc state */
1794 		mutex_enter(&vdc->read_lock);
1795 		if ((vdc->read_state == VDC_READ_WAITING) ||
1796 		    (vdc->read_state == VDC_READ_RESET))
1797 			cv_signal(&vdc->read_cv);
1798 		vdc->read_state = VDC_READ_RESET;
1799 		mutex_exit(&vdc->read_lock);
1800 
1801 		/* wake up any waiters in the reset thread */
1802 		if (vdc->state == VDC_STATE_INIT_WAITING) {
1803 			DMSG(vdc, 0, "[%d] write reset - "
1804 			    "vdc is resetting ..\n", vdc->instance);
1805 			vdc->state = VDC_STATE_RESETTING;
1806 			cv_signal(&vdc->initwait_cv);
1807 		}
1808 
1809 		return (ECONNRESET);
1810 	}
1811 
1812 	/* return the last size written */
1813 	*msglen = size;
1814 
1815 	return (status);
1816 }
1817 
1818 /*
1819  * Function:
1820  *	vdc_get_ldc_id()
1821  *
1822  * Description:
1823  *	This function gets the 'ldc-id' for this particular instance of vdc.
1824  *	The id returned is the guest domain channel endpoint LDC uses for
1825  *	communication with vds.
1826  *
1827  * Arguments:
1828  *	dip	- dev info pointer for this instance of the device driver.
1829  *	ldc_id	- pointer to variable used to return the 'ldc-id' found.
1830  *
1831  * Return Code:
1832  *	0	- Success.
1833  *	ENOENT	- Expected node or property did not exist.
1834  *	ENXIO	- Unexpected error communicating with MD framework
1835  */
1836 static int
1837 vdc_get_ldc_id(dev_info_t *dip, uint64_t *ldc_id)
1838 {
1839 	int		status = ENOENT;
1840 	char		*node_name = NULL;
1841 	md_t		*mdp = NULL;
1842 	int		num_nodes;
1843 	int		num_vdevs;
1844 	int		num_chans;
1845 	mde_cookie_t	rootnode;
1846 	mde_cookie_t	*listp = NULL;
1847 	mde_cookie_t	*chanp = NULL;
1848 	boolean_t	found_inst = B_FALSE;
1849 	int		listsz;
1850 	int		idx;
1851 	uint64_t	md_inst;
1852 	int		obp_inst;
1853 	int		instance = ddi_get_instance(dip);
1854 
1855 	ASSERT(ldc_id != NULL);
1856 	*ldc_id = 0;
1857 
1858 	/*
1859 	 * Get the OBP instance number for comparison with the MD instance
1860 	 *
1861 	 * The "cfg-handle" property of a vdc node in an MD contains the MD's
1862 	 * notion of "instance", or unique identifier, for that node; OBP
1863 	 * stores the value of the "cfg-handle" MD property as the value of
1864 	 * the "reg" property on the node in the device tree it builds from
1865 	 * the MD and passes to Solaris.  Thus, we look up the devinfo node's
1866 	 * "reg" property value to uniquely identify this device instance.
1867 	 * If the "reg" property cannot be found, the device tree state is
1868 	 * presumably so broken that there is no point in continuing.
1869 	 */
1870 	if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, OBP_REG)) {
1871 		cmn_err(CE_WARN, "'%s' property does not exist", OBP_REG);
1872 		return (ENOENT);
1873 	}
1874 	obp_inst = ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
1875 	    OBP_REG, -1);
1876 	DMSGX(1, "[%d] OBP inst=%d\n", instance, obp_inst);
1877 
1878 	/*
1879 	 * We now walk the MD nodes and if an instance of a vdc node matches
1880 	 * the instance got from OBP we get the ldc-id property.
1881 	 */
1882 	if ((mdp = md_get_handle()) == NULL) {
1883 		cmn_err(CE_WARN, "unable to init machine description");
1884 		return (ENXIO);
1885 	}
1886 
1887 	num_nodes = md_node_count(mdp);
1888 	ASSERT(num_nodes > 0);
1889 
1890 	listsz = num_nodes * sizeof (mde_cookie_t);
1891 
1892 	/* allocate memory for nodes */
1893 	listp = kmem_zalloc(listsz, KM_SLEEP);
1894 	chanp = kmem_zalloc(listsz, KM_SLEEP);
1895 
1896 	rootnode = md_root_node(mdp);
1897 	ASSERT(rootnode != MDE_INVAL_ELEM_COOKIE);
1898 
1899 	/*
1900 	 * Search for all the virtual devices, we will then check to see which
1901 	 * ones are disk nodes.
1902 	 */
1903 	num_vdevs = md_scan_dag(mdp, rootnode,
1904 	    md_find_name(mdp, VDC_MD_VDEV_NAME),
1905 	    md_find_name(mdp, "fwd"), listp);
1906 
1907 	if (num_vdevs <= 0) {
1908 		cmn_err(CE_NOTE, "No '%s' node found", VDC_MD_VDEV_NAME);
1909 		status = ENOENT;
1910 		goto done;
1911 	}
1912 
1913 	DMSGX(1, "[%d] num_vdevs=%d\n", instance, num_vdevs);
1914 	for (idx = 0; idx < num_vdevs; idx++) {
1915 		status = md_get_prop_str(mdp, listp[idx], "name", &node_name);
1916 		if ((status != 0) || (node_name == NULL)) {
1917 			cmn_err(CE_NOTE, "Unable to get name of node type '%s'"
1918 			    ": err %d", VDC_MD_VDEV_NAME, status);
1919 			continue;
1920 		}
1921 
1922 		DMSGX(1, "[%d] Found node '%s'\n", instance, node_name);
1923 		if (strcmp(VDC_MD_DISK_NAME, node_name) == 0) {
1924 			status = md_get_prop_val(mdp, listp[idx],
1925 			    VDC_MD_CFG_HDL, &md_inst);
1926 			DMSGX(1, "[%d] vdc inst in MD=%lx\n",
1927 			    instance, md_inst);
1928 			if ((status == 0) && (md_inst == obp_inst)) {
1929 				found_inst = B_TRUE;
1930 				break;
1931 			}
1932 		}
1933 	}
1934 
1935 	if (!found_inst) {
1936 		DMSGX(0, "Unable to find correct '%s' node", VDC_MD_DISK_NAME);
1937 		status = ENOENT;
1938 		goto done;
1939 	}
1940 	DMSGX(0, "[%d] MD inst=%lx\n", instance, md_inst);
1941 
1942 	/* get the channels for this node */
1943 	num_chans = md_scan_dag(mdp, listp[idx],
1944 	    md_find_name(mdp, VDC_MD_CHAN_NAME),
1945 	    md_find_name(mdp, "fwd"), chanp);
1946 
1947 	/* expecting at least one channel */
1948 	if (num_chans <= 0) {
1949 		cmn_err(CE_NOTE, "No '%s' node for '%s' port",
1950 		    VDC_MD_CHAN_NAME, VDC_MD_VDEV_NAME);
1951 		status = ENOENT;
1952 		goto done;
1953 
1954 	} else if (num_chans != 1) {
1955 		DMSGX(0, "[%d] Expected 1 '%s' node for '%s' port, found %d\n",
1956 		    instance, VDC_MD_CHAN_NAME, VDC_MD_VDEV_NAME,
1957 		    num_chans);
1958 	}
1959 
1960 	/*
1961 	 * We use the first channel found (index 0), irrespective of how
1962 	 * many are there in total.
1963 	 */
1964 	if (md_get_prop_val(mdp, chanp[0], VDC_ID_PROP, ldc_id) != 0) {
1965 		cmn_err(CE_NOTE, "Channel '%s' property not found",
1966 		    VDC_ID_PROP);
1967 		status = ENOENT;
1968 	}
1969 
1970 	DMSGX(0, "[%d] LDC id is 0x%lx\n", instance, *ldc_id);
1971 
1972 done:
1973 	if (chanp)
1974 		kmem_free(chanp, listsz);
1975 	if (listp)
1976 		kmem_free(listp, listsz);
1977 
1978 	(void) md_fini_handle(mdp);
1979 
1980 	return (status);
1981 }
1982 
1983 static int
1984 vdc_do_ldc_up(vdc_t *vdc)
1985 {
1986 	int		status;
1987 	ldc_status_t	ldc_state;
1988 
1989 	DMSG(vdc, 0, "[%d] Bringing up channel %lx\n",
1990 	    vdc->instance, vdc->ldc_id);
1991 
1992 	if (vdc->lifecycle == VDC_LC_DETACHING)
1993 		return (EINVAL);
1994 
1995 	if ((status = ldc_up(vdc->ldc_handle)) != 0) {
1996 		switch (status) {
1997 		case ECONNREFUSED:	/* listener not ready at other end */
1998 			DMSG(vdc, 0, "[%d] ldc_up(%lx,...) return %d\n",
1999 			    vdc->instance, vdc->ldc_id, status);
2000 			status = 0;
2001 			break;
2002 		default:
2003 			DMSG(vdc, 0, "[%d] Failed to bring up LDC: "
2004 			    "channel=%ld, err=%d", vdc->instance, vdc->ldc_id,
2005 			    status);
2006 			break;
2007 		}
2008 	}
2009 
2010 	if (ldc_status(vdc->ldc_handle, &ldc_state) == 0) {
2011 		vdc->ldc_state = ldc_state;
2012 		if (ldc_state == LDC_UP) {
2013 			DMSG(vdc, 0, "[%d] LDC channel already up\n",
2014 			    vdc->instance);
2015 			vdc->seq_num = 1;
2016 			vdc->seq_num_reply = 0;
2017 		}
2018 	}
2019 
2020 	return (status);
2021 }
2022 
2023 /*
2024  * Function:
2025  *	vdc_terminate_ldc()
2026  *
2027  * Description:
2028  *
2029  * Arguments:
2030  *	vdc	- soft state pointer for this instance of the device driver.
2031  *
2032  * Return Code:
2033  *	None
2034  */
2035 static void
2036 vdc_terminate_ldc(vdc_t *vdc)
2037 {
2038 	int	instance = ddi_get_instance(vdc->dip);
2039 
2040 	ASSERT(vdc != NULL);
2041 	ASSERT(mutex_owned(&vdc->lock));
2042 
2043 	DMSG(vdc, 0, "[%d] initialized=%x\n", instance, vdc->initialized);
2044 
2045 	if (vdc->initialized & VDC_LDC_OPEN) {
2046 		DMSG(vdc, 0, "[%d] ldc_close()\n", instance);
2047 		(void) ldc_close(vdc->ldc_handle);
2048 	}
2049 	if (vdc->initialized & VDC_LDC_CB) {
2050 		DMSG(vdc, 0, "[%d] ldc_unreg_callback()\n", instance);
2051 		(void) ldc_unreg_callback(vdc->ldc_handle);
2052 	}
2053 	if (vdc->initialized & VDC_LDC) {
2054 		DMSG(vdc, 0, "[%d] ldc_fini()\n", instance);
2055 		(void) ldc_fini(vdc->ldc_handle);
2056 		vdc->ldc_handle = NULL;
2057 	}
2058 
2059 	vdc->initialized &= ~(VDC_LDC | VDC_LDC_CB | VDC_LDC_OPEN);
2060 }
2061 
2062 /* -------------------------------------------------------------------------- */
2063 
2064 /*
2065  * Descriptor Ring helper routines
2066  */
2067 
2068 /*
2069  * Function:
2070  *	vdc_init_descriptor_ring()
2071  *
2072  * Description:
2073  *
2074  * Arguments:
2075  *	vdc	- soft state pointer for this instance of the device driver.
2076  *
2077  * Return Code:
2078  *	0	- Success
2079  */
2080 static int
2081 vdc_init_descriptor_ring(vdc_t *vdc)
2082 {
2083 	vd_dring_entry_t	*dep = NULL;	/* DRing Entry pointer */
2084 	int	status = 0;
2085 	int	i;
2086 
2087 	DMSG(vdc, 0, "[%d] initialized=%x\n", vdc->instance, vdc->initialized);
2088 
2089 	ASSERT(vdc != NULL);
2090 	ASSERT(mutex_owned(&vdc->lock));
2091 	ASSERT(vdc->ldc_handle != NULL);
2092 
2093 	/* ensure we have enough room to store max sized block */
2094 	ASSERT(maxphys <= VD_MAX_BLOCK_SIZE);
2095 
2096 	if ((vdc->initialized & VDC_DRING_INIT) == 0) {
2097 		DMSG(vdc, 0, "[%d] ldc_mem_dring_create\n", vdc->instance);
2098 		/*
2099 		 * Calculate the maximum block size we can transmit using one
2100 		 * Descriptor Ring entry from the attributes returned by the
2101 		 * vDisk server. This is subject to a minimum of 'maxphys'
2102 		 * as we do not have the capability to split requests over
2103 		 * multiple DRing entries.
2104 		 */
2105 		if ((vdc->max_xfer_sz * vdc->block_size) < maxphys) {
2106 			DMSG(vdc, 0, "[%d] using minimum DRing size\n",
2107 			    vdc->instance);
2108 			vdc->dring_max_cookies = maxphys / PAGESIZE;
2109 		} else {
2110 			vdc->dring_max_cookies =
2111 			    (vdc->max_xfer_sz * vdc->block_size) / PAGESIZE;
2112 		}
2113 		vdc->dring_entry_size = (sizeof (vd_dring_entry_t) +
2114 		    (sizeof (ldc_mem_cookie_t) *
2115 		    (vdc->dring_max_cookies - 1)));
2116 		vdc->dring_len = VD_DRING_LEN;
2117 
2118 		status = ldc_mem_dring_create(vdc->dring_len,
2119 		    vdc->dring_entry_size, &vdc->ldc_dring_hdl);
2120 		if ((vdc->ldc_dring_hdl == NULL) || (status != 0)) {
2121 			DMSG(vdc, 0, "[%d] Descriptor ring creation failed",
2122 			    vdc->instance);
2123 			return (status);
2124 		}
2125 		vdc->initialized |= VDC_DRING_INIT;
2126 	}
2127 
2128 	if ((vdc->initialized & VDC_DRING_BOUND) == 0) {
2129 		DMSG(vdc, 0, "[%d] ldc_mem_dring_bind\n", vdc->instance);
2130 		vdc->dring_cookie =
2131 		    kmem_zalloc(sizeof (ldc_mem_cookie_t), KM_SLEEP);
2132 
2133 		status = ldc_mem_dring_bind(vdc->ldc_handle, vdc->ldc_dring_hdl,
2134 		    LDC_SHADOW_MAP|LDC_DIRECT_MAP, LDC_MEM_RW,
2135 		    &vdc->dring_cookie[0],
2136 		    &vdc->dring_cookie_count);
2137 		if (status != 0) {
2138 			DMSG(vdc, 0, "[%d] Failed to bind descriptor ring "
2139 			    "(%lx) to channel (%lx) status=%d\n",
2140 			    vdc->instance, vdc->ldc_dring_hdl,
2141 			    vdc->ldc_handle, status);
2142 			return (status);
2143 		}
2144 		ASSERT(vdc->dring_cookie_count == 1);
2145 		vdc->initialized |= VDC_DRING_BOUND;
2146 	}
2147 
2148 	status = ldc_mem_dring_info(vdc->ldc_dring_hdl, &vdc->dring_mem_info);
2149 	if (status != 0) {
2150 		DMSG(vdc, 0,
2151 		    "[%d] Failed to get info for descriptor ring (%lx)\n",
2152 		    vdc->instance, vdc->ldc_dring_hdl);
2153 		return (status);
2154 	}
2155 
2156 	if ((vdc->initialized & VDC_DRING_LOCAL) == 0) {
2157 		DMSG(vdc, 0, "[%d] local dring\n", vdc->instance);
2158 
2159 		/* Allocate the local copy of this dring */
2160 		vdc->local_dring =
2161 		    kmem_zalloc(vdc->dring_len * sizeof (vdc_local_desc_t),
2162 		    KM_SLEEP);
2163 		vdc->initialized |= VDC_DRING_LOCAL;
2164 	}
2165 
2166 	/*
2167 	 * Mark all DRing entries as free and initialize the private
2168 	 * descriptor's memory handles. If any entry is initialized,
2169 	 * we need to free it later so we set the bit in 'initialized'
2170 	 * at the start.
2171 	 */
2172 	vdc->initialized |= VDC_DRING_ENTRY;
2173 	for (i = 0; i < vdc->dring_len; i++) {
2174 		dep = VDC_GET_DRING_ENTRY_PTR(vdc, i);
2175 		dep->hdr.dstate = VIO_DESC_FREE;
2176 
2177 		status = ldc_mem_alloc_handle(vdc->ldc_handle,
2178 		    &vdc->local_dring[i].desc_mhdl);
2179 		if (status != 0) {
2180 			DMSG(vdc, 0, "![%d] Failed to alloc mem handle for"
2181 			    " descriptor %d", vdc->instance, i);
2182 			return (status);
2183 		}
2184 		vdc->local_dring[i].is_free = B_TRUE;
2185 		vdc->local_dring[i].dep = dep;
2186 	}
2187 
2188 	/* Initialize the starting index */
2189 	vdc->dring_curr_idx = 0;
2190 
2191 	return (status);
2192 }
2193 
2194 /*
2195  * Function:
2196  *	vdc_destroy_descriptor_ring()
2197  *
2198  * Description:
2199  *
2200  * Arguments:
2201  *	vdc	- soft state pointer for this instance of the device driver.
2202  *
2203  * Return Code:
2204  *	None
2205  */
2206 static void
2207 vdc_destroy_descriptor_ring(vdc_t *vdc)
2208 {
2209 	vdc_local_desc_t	*ldep = NULL;	/* Local Dring Entry Pointer */
2210 	ldc_mem_handle_t	mhdl = NULL;
2211 	ldc_mem_info_t		minfo;
2212 	int			status = -1;
2213 	int			i;	/* loop */
2214 
2215 	ASSERT(vdc != NULL);
2216 	ASSERT(mutex_owned(&vdc->lock));
2217 
2218 	DMSG(vdc, 0, "[%d] Entered\n", vdc->instance);
2219 
2220 	if (vdc->initialized & VDC_DRING_ENTRY) {
2221 		DMSG(vdc, 0,
2222 		    "[%d] Removing Local DRing entries\n", vdc->instance);
2223 		for (i = 0; i < vdc->dring_len; i++) {
2224 			ldep = &vdc->local_dring[i];
2225 			mhdl = ldep->desc_mhdl;
2226 
2227 			if (mhdl == NULL)
2228 				continue;
2229 
2230 			if ((status = ldc_mem_info(mhdl, &minfo)) != 0) {
2231 				DMSG(vdc, 0,
2232 				    "ldc_mem_info returned an error: %d\n",
2233 				    status);
2234 
2235 				/*
2236 				 * This must mean that the mem handle
2237 				 * is not valid. Clear it out so that
2238 				 * no one tries to use it.
2239 				 */
2240 				ldep->desc_mhdl = NULL;
2241 				continue;
2242 			}
2243 
2244 			if (minfo.status == LDC_BOUND) {
2245 				(void) ldc_mem_unbind_handle(mhdl);
2246 			}
2247 
2248 			(void) ldc_mem_free_handle(mhdl);
2249 
2250 			ldep->desc_mhdl = NULL;
2251 		}
2252 		vdc->initialized &= ~VDC_DRING_ENTRY;
2253 	}
2254 
2255 	if (vdc->initialized & VDC_DRING_LOCAL) {
2256 		DMSG(vdc, 0, "[%d] Freeing Local DRing\n", vdc->instance);
2257 		kmem_free(vdc->local_dring,
2258 		    vdc->dring_len * sizeof (vdc_local_desc_t));
2259 		vdc->initialized &= ~VDC_DRING_LOCAL;
2260 	}
2261 
2262 	if (vdc->initialized & VDC_DRING_BOUND) {
2263 		DMSG(vdc, 0, "[%d] Unbinding DRing\n", vdc->instance);
2264 		status = ldc_mem_dring_unbind(vdc->ldc_dring_hdl);
2265 		if (status == 0) {
2266 			vdc->initialized &= ~VDC_DRING_BOUND;
2267 		} else {
2268 			DMSG(vdc, 0, "[%d] Error %d unbinding DRing %lx",
2269 			    vdc->instance, status, vdc->ldc_dring_hdl);
2270 		}
2271 		kmem_free(vdc->dring_cookie, sizeof (ldc_mem_cookie_t));
2272 	}
2273 
2274 	if (vdc->initialized & VDC_DRING_INIT) {
2275 		DMSG(vdc, 0, "[%d] Destroying DRing\n", vdc->instance);
2276 		status = ldc_mem_dring_destroy(vdc->ldc_dring_hdl);
2277 		if (status == 0) {
2278 			vdc->ldc_dring_hdl = NULL;
2279 			bzero(&vdc->dring_mem_info, sizeof (ldc_mem_info_t));
2280 			vdc->initialized &= ~VDC_DRING_INIT;
2281 		} else {
2282 			DMSG(vdc, 0, "[%d] Error %d destroying DRing (%lx)",
2283 			    vdc->instance, status, vdc->ldc_dring_hdl);
2284 		}
2285 	}
2286 }
2287 
2288 /*
2289  * Function:
2290  *	vdc_map_to_shared_ring()
2291  *
2292  * Description:
2293  *	Copy contents of the local descriptor to the shared
2294  *	memory descriptor.
2295  *
2296  * Arguments:
2297  *	vdcp	- soft state pointer for this instance of the device driver.
2298  *	idx	- descriptor ring index
2299  *
2300  * Return Code:
2301  *	None
2302  */
2303 static int
2304 vdc_map_to_shared_dring(vdc_t *vdcp, int idx)
2305 {
2306 	vdc_local_desc_t	*ldep;
2307 	vd_dring_entry_t	*dep;
2308 	int			rv;
2309 
2310 	ldep = &(vdcp->local_dring[idx]);
2311 
2312 	/* for now leave in the old pop_mem_hdl stuff */
2313 	if (ldep->nbytes > 0) {
2314 		rv = vdc_populate_mem_hdl(vdcp, ldep);
2315 		if (rv) {
2316 			DMSG(vdcp, 0, "[%d] Cannot populate mem handle\n",
2317 			    vdcp->instance);
2318 			return (rv);
2319 		}
2320 	}
2321 
2322 	/*
2323 	 * fill in the data details into the DRing
2324 	 */
2325 	dep = ldep->dep;
2326 	ASSERT(dep != NULL);
2327 
2328 	dep->payload.req_id = VDC_GET_NEXT_REQ_ID(vdcp);
2329 	dep->payload.operation = ldep->operation;
2330 	dep->payload.addr = ldep->offset;
2331 	dep->payload.nbytes = ldep->nbytes;
2332 	dep->payload.status = (uint32_t)-1;	/* vds will set valid value */
2333 	dep->payload.slice = ldep->slice;
2334 	dep->hdr.dstate = VIO_DESC_READY;
2335 	dep->hdr.ack = 1;		/* request an ACK for every message */
2336 
2337 	return (0);
2338 }
2339 
2340 /*
2341  * Function:
2342  *	vdc_send_request
2343  *
2344  * Description:
2345  *	This routine writes the data to be transmitted to vds into the
2346  *	descriptor, notifies vds that the ring has been updated and
2347  *	then waits for the request to be processed.
2348  *
2349  * Arguments:
2350  *	vdcp	  - the soft state pointer
2351  *	operation - operation we want vds to perform (VD_OP_XXX)
2352  *	addr	  - address of data buf to be read/written.
2353  *	nbytes	  - number of bytes to read/write
2354  *	slice	  - the disk slice this request is for
2355  *	offset	  - relative disk offset
2356  *	cb_type   - type of call - STRATEGY or SYNC
2357  *	cb_arg	  - parameter to be sent to server (depends on VD_OP_XXX type)
2358  *			. mode for ioctl(9e)
2359  *			. LP64 diskaddr_t (block I/O)
2360  *	dir	  - direction of operation (READ/WRITE/BOTH)
2361  *
2362  * Return Codes:
2363  *	0
2364  *	ENXIO
2365  */
2366 static int
2367 vdc_send_request(vdc_t *vdcp, int operation, caddr_t addr,
2368     size_t nbytes, int slice, diskaddr_t offset, int cb_type,
2369     void *cb_arg, vio_desc_direction_t dir)
2370 {
2371 	ASSERT(vdcp != NULL);
2372 	ASSERT(slice == VD_SLICE_NONE || slice < V_NUMPAR);
2373 
2374 	mutex_enter(&vdcp->lock);
2375 
2376 	do {
2377 		while (vdcp->state != VDC_STATE_RUNNING) {
2378 			cv_wait(&vdcp->running_cv, &vdcp->lock);
2379 
2380 			/* return error if detaching */
2381 			if (vdcp->state == VDC_STATE_DETACH) {
2382 				mutex_exit(&vdcp->lock);
2383 				return (ENXIO);
2384 			}
2385 		}
2386 
2387 	} while (vdc_populate_descriptor(vdcp, operation, addr,
2388 	    nbytes, slice, offset, cb_type, cb_arg, dir));
2389 
2390 	mutex_exit(&vdcp->lock);
2391 	return (0);
2392 }
2393 
2394 
2395 /*
2396  * Function:
2397  *	vdc_populate_descriptor
2398  *
2399  * Description:
2400  *	This routine writes the data to be transmitted to vds into the
2401  *	descriptor, notifies vds that the ring has been updated and
2402  *	then waits for the request to be processed.
2403  *
2404  * Arguments:
2405  *	vdcp	  - the soft state pointer
2406  *	operation - operation we want vds to perform (VD_OP_XXX)
2407  *	addr	  - address of data buf to be read/written.
2408  *	nbytes	  - number of bytes to read/write
2409  *	slice	  - the disk slice this request is for
2410  *	offset	  - relative disk offset
2411  *	cb_type   - type of call - STRATEGY or SYNC
2412  *	cb_arg	  - parameter to be sent to server (depends on VD_OP_XXX type)
2413  *			. mode for ioctl(9e)
2414  *			. LP64 diskaddr_t (block I/O)
2415  *	dir	  - direction of operation (READ/WRITE/BOTH)
2416  *
2417  * Return Codes:
2418  *	0
2419  *	EAGAIN
2420  *		EFAULT
2421  *		ENXIO
2422  *		EIO
2423  */
2424 static int
2425 vdc_populate_descriptor(vdc_t *vdcp, int operation, caddr_t addr,
2426     size_t nbytes, int slice, diskaddr_t offset, int cb_type,
2427     void *cb_arg, vio_desc_direction_t dir)
2428 {
2429 	vdc_local_desc_t	*local_dep = NULL; /* Local Dring Pointer */
2430 	int			idx;		/* Index of DRing entry used */
2431 	int			next_idx;
2432 	vio_dring_msg_t		dmsg;
2433 	size_t			msglen;
2434 	int			rv;
2435 
2436 	ASSERT(MUTEX_HELD(&vdcp->lock));
2437 	vdcp->threads_pending++;
2438 loop:
2439 	DMSG(vdcp, 2, ": dring_curr_idx = %d\n", vdcp->dring_curr_idx);
2440 
2441 	/* Get next available D-Ring entry */
2442 	idx = vdcp->dring_curr_idx;
2443 	local_dep = &(vdcp->local_dring[idx]);
2444 
2445 	if (!local_dep->is_free) {
2446 		DMSG(vdcp, 2, "[%d]: dring full - waiting for space\n",
2447 		    vdcp->instance);
2448 		cv_wait(&vdcp->dring_free_cv, &vdcp->lock);
2449 		if (vdcp->state == VDC_STATE_RUNNING ||
2450 		    vdcp->state == VDC_STATE_HANDLE_PENDING) {
2451 			goto loop;
2452 		}
2453 		vdcp->threads_pending--;
2454 		return (ECONNRESET);
2455 	}
2456 
2457 	next_idx = idx + 1;
2458 	if (next_idx >= vdcp->dring_len)
2459 		next_idx = 0;
2460 	vdcp->dring_curr_idx = next_idx;
2461 
2462 	ASSERT(local_dep->is_free);
2463 
2464 	local_dep->operation = operation;
2465 	local_dep->addr = addr;
2466 	local_dep->nbytes = nbytes;
2467 	local_dep->slice = slice;
2468 	local_dep->offset = offset;
2469 	local_dep->cb_type = cb_type;
2470 	local_dep->cb_arg = cb_arg;
2471 	local_dep->dir = dir;
2472 
2473 	local_dep->is_free = B_FALSE;
2474 
2475 	rv = vdc_map_to_shared_dring(vdcp, idx);
2476 	if (rv) {
2477 		DMSG(vdcp, 0, "[%d]: cannot bind memory - waiting ..\n",
2478 		    vdcp->instance);
2479 		/* free the descriptor */
2480 		local_dep->is_free = B_TRUE;
2481 		vdcp->dring_curr_idx = idx;
2482 		cv_wait(&vdcp->membind_cv, &vdcp->lock);
2483 		if (vdcp->state == VDC_STATE_RUNNING ||
2484 		    vdcp->state == VDC_STATE_HANDLE_PENDING) {
2485 			goto loop;
2486 		}
2487 		vdcp->threads_pending--;
2488 		return (ECONNRESET);
2489 	}
2490 
2491 	/*
2492 	 * Send a msg with the DRing details to vds
2493 	 */
2494 	VIO_INIT_DRING_DATA_TAG(dmsg);
2495 	VDC_INIT_DRING_DATA_MSG_IDS(dmsg, vdcp);
2496 	dmsg.dring_ident = vdcp->dring_ident;
2497 	dmsg.start_idx = idx;
2498 	dmsg.end_idx = idx;
2499 	vdcp->seq_num++;
2500 
2501 	DTRACE_IO2(send, vio_dring_msg_t *, &dmsg, vdc_t *, vdcp);
2502 
2503 	DMSG(vdcp, 2, "ident=0x%lx, st=%u, end=%u, seq=%ld\n",
2504 	    vdcp->dring_ident, dmsg.start_idx, dmsg.end_idx, dmsg.seq_num);
2505 
2506 	/*
2507 	 * note we're still holding the lock here to
2508 	 * make sure the message goes out in order !!!...
2509 	 */
2510 	msglen = sizeof (dmsg);
2511 	rv = vdc_send(vdcp, (caddr_t)&dmsg, &msglen);
2512 	switch (rv) {
2513 	case ECONNRESET:
2514 		/*
2515 		 * vdc_send initiates the reset on failure.
2516 		 * Since the transaction has already been put
2517 		 * on the local dring, it will automatically get
2518 		 * retried when the channel is reset. Given that,
2519 		 * it is ok to just return success even though the
2520 		 * send failed.
2521 		 */
2522 		rv = 0;
2523 		break;
2524 
2525 	case 0: /* EOK */
2526 		DMSG(vdcp, 1, "sent via LDC: rv=%d\n", rv);
2527 		break;
2528 
2529 	default:
2530 		goto cleanup_and_exit;
2531 	}
2532 
2533 	vdcp->threads_pending--;
2534 	return (rv);
2535 
2536 cleanup_and_exit:
2537 	DMSG(vdcp, 0, "unexpected error, rv=%d\n", rv);
2538 	return (ENXIO);
2539 }
2540 
2541 /*
2542  * Function:
2543  *	vdc_do_sync_op
2544  *
2545  * Description:
2546  * 	Wrapper around vdc_populate_descriptor that blocks until the
2547  * 	response to the message is available.
2548  *
2549  * Arguments:
2550  *	vdcp	  - the soft state pointer
2551  *	operation - operation we want vds to perform (VD_OP_XXX)
2552  *	addr	  - address of data buf to be read/written.
2553  *	nbytes	  - number of bytes to read/write
2554  *	slice	  - the disk slice this request is for
2555  *	offset	  - relative disk offset
2556  *	cb_type   - type of call - STRATEGY or SYNC
2557  *	cb_arg	  - parameter to be sent to server (depends on VD_OP_XXX type)
2558  *			. mode for ioctl(9e)
2559  *			. LP64 diskaddr_t (block I/O)
2560  *	dir	  - direction of operation (READ/WRITE/BOTH)
2561  *
2562  * Return Codes:
2563  *	0
2564  *	EAGAIN
2565  *		EFAULT
2566  *		ENXIO
2567  *		EIO
2568  */
2569 static int
2570 vdc_do_sync_op(vdc_t *vdcp, int operation, caddr_t addr, size_t nbytes,
2571     int slice, diskaddr_t offset, int cb_type, void *cb_arg,
2572     vio_desc_direction_t dir)
2573 {
2574 	int status;
2575 
2576 	ASSERT(cb_type == CB_SYNC);
2577 
2578 	/*
2579 	 * Grab the lock, if blocked wait until the server
2580 	 * response causes us to wake up again.
2581 	 */
2582 	mutex_enter(&vdcp->lock);
2583 	vdcp->sync_op_cnt++;
2584 	while (vdcp->sync_op_blocked && vdcp->state != VDC_STATE_DETACH)
2585 		cv_wait(&vdcp->sync_blocked_cv, &vdcp->lock);
2586 
2587 	if (vdcp->state == VDC_STATE_DETACH) {
2588 		cv_broadcast(&vdcp->sync_blocked_cv);
2589 		vdcp->sync_op_cnt--;
2590 		mutex_exit(&vdcp->lock);
2591 		return (ENXIO);
2592 	}
2593 
2594 	/* now block anyone other thread entering after us */
2595 	vdcp->sync_op_blocked = B_TRUE;
2596 	vdcp->sync_op_pending = B_TRUE;
2597 	mutex_exit(&vdcp->lock);
2598 
2599 	/*
2600 	 * No need to check return value - will return error only
2601 	 * in the DETACH case and we can fall through
2602 	 */
2603 	(void) vdc_send_request(vdcp, operation, addr,
2604 	    nbytes, slice, offset, cb_type, cb_arg, dir);
2605 
2606 	/*
2607 	 * block until our transaction completes.
2608 	 * Also anyone else waiting also gets to go next.
2609 	 */
2610 	mutex_enter(&vdcp->lock);
2611 	while (vdcp->sync_op_pending && vdcp->state != VDC_STATE_DETACH)
2612 		cv_wait(&vdcp->sync_pending_cv, &vdcp->lock);
2613 
2614 	DMSG(vdcp, 2, ": operation returned %d\n", vdcp->sync_op_status);
2615 	if (vdcp->state == VDC_STATE_DETACH) {
2616 		vdcp->sync_op_pending = B_FALSE;
2617 		status = ENXIO;
2618 	} else {
2619 		status = vdcp->sync_op_status;
2620 	}
2621 
2622 	vdcp->sync_op_status = 0;
2623 	vdcp->sync_op_blocked = B_FALSE;
2624 	vdcp->sync_op_cnt--;
2625 
2626 	/* signal the next waiting thread */
2627 	cv_signal(&vdcp->sync_blocked_cv);
2628 	mutex_exit(&vdcp->lock);
2629 
2630 	return (status);
2631 }
2632 
2633 
2634 /*
2635  * Function:
2636  *	vdc_drain_response()
2637  *
2638  * Description:
2639  * 	When a guest is panicking, the completion of requests needs to be
2640  * 	handled differently because interrupts are disabled and vdc
2641  * 	will not get messages. We have to poll for the messages instead.
2642  *
2643  * Arguments:
2644  *	vdc	- soft state pointer for this instance of the device driver.
2645  *
2646  * Return Code:
2647  *	0	- Success
2648  */
2649 static int
2650 vdc_drain_response(vdc_t *vdc)
2651 {
2652 	int 			rv, idx, retries;
2653 	size_t			msglen;
2654 	vdc_local_desc_t 	*ldep = NULL;	/* Local Dring Entry Pointer */
2655 	vio_dring_msg_t		dmsg;
2656 
2657 	mutex_enter(&vdc->lock);
2658 
2659 	retries = 0;
2660 	for (;;) {
2661 		msglen = sizeof (dmsg);
2662 		rv = ldc_read(vdc->ldc_handle, (caddr_t)&dmsg, &msglen);
2663 		if (rv) {
2664 			rv = EINVAL;
2665 			break;
2666 		}
2667 
2668 		/*
2669 		 * if there are no packets wait and check again
2670 		 */
2671 		if ((rv == 0) && (msglen == 0)) {
2672 			if (retries++ > vdc_dump_retries) {
2673 				rv = EAGAIN;
2674 				break;
2675 			}
2676 
2677 			drv_usecwait(vdc_usec_timeout_dump);
2678 			continue;
2679 		}
2680 
2681 		/*
2682 		 * Ignore all messages that are not ACKs/NACKs to
2683 		 * DRing requests.
2684 		 */
2685 		if ((dmsg.tag.vio_msgtype != VIO_TYPE_DATA) ||
2686 		    (dmsg.tag.vio_subtype_env != VIO_DRING_DATA)) {
2687 			DMSG(vdc, 0, "discard pkt: type=%d sub=%d env=%d\n",
2688 			    dmsg.tag.vio_msgtype,
2689 			    dmsg.tag.vio_subtype,
2690 			    dmsg.tag.vio_subtype_env);
2691 			continue;
2692 		}
2693 
2694 		/*
2695 		 * set the appropriate return value for the current request.
2696 		 */
2697 		switch (dmsg.tag.vio_subtype) {
2698 		case VIO_SUBTYPE_ACK:
2699 			rv = 0;
2700 			break;
2701 		case VIO_SUBTYPE_NACK:
2702 			rv = EAGAIN;
2703 			break;
2704 		default:
2705 			continue;
2706 		}
2707 
2708 		idx = dmsg.start_idx;
2709 		if (idx >= vdc->dring_len) {
2710 			DMSG(vdc, 0, "[%d] Bogus ack data : start %d\n",
2711 			    vdc->instance, idx);
2712 			continue;
2713 		}
2714 		ldep = &vdc->local_dring[idx];
2715 		if (ldep->dep->hdr.dstate != VIO_DESC_DONE) {
2716 			DMSG(vdc, 0, "[%d] Entry @ %d - state !DONE %d\n",
2717 			    vdc->instance, idx, ldep->dep->hdr.dstate);
2718 			continue;
2719 		}
2720 
2721 		DMSG(vdc, 1, "[%d] Depopulating idx=%d state=%d\n",
2722 		    vdc->instance, idx, ldep->dep->hdr.dstate);
2723 		rv = vdc_depopulate_descriptor(vdc, idx);
2724 		if (rv) {
2725 			DMSG(vdc, 0,
2726 			    "[%d] Entry @ %d - depopulate failed ..\n",
2727 			    vdc->instance, idx);
2728 		}
2729 
2730 		/* if this is the last descriptor - break out of loop */
2731 		if ((idx + 1) % vdc->dring_len == vdc->dring_curr_idx)
2732 			break;
2733 	}
2734 
2735 	mutex_exit(&vdc->lock);
2736 	DMSG(vdc, 0, "End idx=%d\n", idx);
2737 
2738 	return (rv);
2739 }
2740 
2741 
2742 /*
2743  * Function:
2744  *	vdc_depopulate_descriptor()
2745  *
2746  * Description:
2747  *
2748  * Arguments:
2749  *	vdc	- soft state pointer for this instance of the device driver.
2750  *	idx	- Index of the Descriptor Ring entry being modified
2751  *
2752  * Return Code:
2753  *	0	- Success
2754  */
2755 static int
2756 vdc_depopulate_descriptor(vdc_t *vdc, uint_t idx)
2757 {
2758 	vd_dring_entry_t *dep = NULL;		/* Dring Entry Pointer */
2759 	vdc_local_desc_t *ldep = NULL;		/* Local Dring Entry Pointer */
2760 	int		status = ENXIO;
2761 	int		rv = 0;
2762 
2763 	ASSERT(vdc != NULL);
2764 	ASSERT(idx < vdc->dring_len);
2765 	ldep = &vdc->local_dring[idx];
2766 	ASSERT(ldep != NULL);
2767 	ASSERT(MUTEX_HELD(&vdc->lock));
2768 
2769 	DMSG(vdc, 2, ": idx = %d\n", idx);
2770 	dep = ldep->dep;
2771 	ASSERT(dep != NULL);
2772 	ASSERT((dep->hdr.dstate == VIO_DESC_DONE) ||
2773 	    (dep->payload.status == ECANCELED));
2774 
2775 	VDC_MARK_DRING_ENTRY_FREE(vdc, idx);
2776 
2777 	ldep->is_free = B_TRUE;
2778 	DMSG(vdc, 2, ": is_free = %d\n", ldep->is_free);
2779 	status = dep->payload.status;
2780 
2781 	/*
2782 	 * If no buffers were used to transfer information to the server when
2783 	 * populating the descriptor then no memory handles need to be unbound
2784 	 * and we can return now.
2785 	 */
2786 	if (ldep->nbytes == 0) {
2787 		cv_signal(&vdc->dring_free_cv);
2788 		return (status);
2789 	}
2790 
2791 	/*
2792 	 * If the upper layer passed in a misaligned address we copied the
2793 	 * data into an aligned buffer before sending it to LDC - we now
2794 	 * copy it back to the original buffer.
2795 	 */
2796 	if (ldep->align_addr) {
2797 		ASSERT(ldep->addr != NULL);
2798 
2799 		if (dep->payload.nbytes > 0)
2800 			bcopy(ldep->align_addr, ldep->addr,
2801 			    dep->payload.nbytes);
2802 		kmem_free(ldep->align_addr,
2803 		    sizeof (caddr_t) * P2ROUNDUP(ldep->nbytes, 8));
2804 		ldep->align_addr = NULL;
2805 	}
2806 
2807 	rv = ldc_mem_unbind_handle(ldep->desc_mhdl);
2808 	if (rv != 0) {
2809 		DMSG(vdc, 0, "?[%d] unbind mhdl 0x%lx @ idx %d failed (%d)",
2810 		    vdc->instance, ldep->desc_mhdl, idx, rv);
2811 		/*
2812 		 * The error returned by the vDisk server is more informative
2813 		 * and thus has a higher priority but if it isn't set we ensure
2814 		 * that this function returns an error.
2815 		 */
2816 		if (status == 0)
2817 			status = EINVAL;
2818 	}
2819 
2820 	cv_signal(&vdc->membind_cv);
2821 	cv_signal(&vdc->dring_free_cv);
2822 
2823 	return (status);
2824 }
2825 
2826 /*
2827  * Function:
2828  *	vdc_populate_mem_hdl()
2829  *
2830  * Description:
2831  *
2832  * Arguments:
2833  *	vdc	- soft state pointer for this instance of the device driver.
2834  *	idx	- Index of the Descriptor Ring entry being modified
2835  *	addr	- virtual address being mapped in
2836  *	nybtes	- number of bytes in 'addr'
2837  *	operation - the vDisk operation being performed (VD_OP_xxx)
2838  *
2839  * Return Code:
2840  *	0	- Success
2841  */
2842 static int
2843 vdc_populate_mem_hdl(vdc_t *vdcp, vdc_local_desc_t *ldep)
2844 {
2845 	vd_dring_entry_t	*dep = NULL;
2846 	ldc_mem_handle_t	mhdl;
2847 	caddr_t			vaddr;
2848 	size_t			nbytes;
2849 	uint8_t			perm = LDC_MEM_RW;
2850 	uint8_t			maptype;
2851 	int			rv = 0;
2852 	int			i;
2853 
2854 	ASSERT(vdcp != NULL);
2855 
2856 	dep = ldep->dep;
2857 	mhdl = ldep->desc_mhdl;
2858 
2859 	switch (ldep->dir) {
2860 	case VIO_read_dir:
2861 		perm = LDC_MEM_W;
2862 		break;
2863 
2864 	case VIO_write_dir:
2865 		perm = LDC_MEM_R;
2866 		break;
2867 
2868 	case VIO_both_dir:
2869 		perm = LDC_MEM_RW;
2870 		break;
2871 
2872 	default:
2873 		ASSERT(0);	/* catch bad programming in vdc */
2874 	}
2875 
2876 	/*
2877 	 * LDC expects any addresses passed in to be 8-byte aligned. We need
2878 	 * to copy the contents of any misaligned buffers to a newly allocated
2879 	 * buffer and bind it instead (and copy the the contents back to the
2880 	 * original buffer passed in when depopulating the descriptor)
2881 	 */
2882 	vaddr = ldep->addr;
2883 	nbytes = ldep->nbytes;
2884 	if (((uint64_t)vaddr & 0x7) != 0) {
2885 		ASSERT(ldep->align_addr == NULL);
2886 		ldep->align_addr =
2887 		    kmem_alloc(sizeof (caddr_t) *
2888 		    P2ROUNDUP(nbytes, 8), KM_SLEEP);
2889 		DMSG(vdcp, 0, "[%d] Misaligned address %p reallocating "
2890 		    "(buf=%p nb=%ld op=%d)\n",
2891 		    vdcp->instance, (void *)vaddr, (void *)ldep->align_addr,
2892 		    nbytes, ldep->operation);
2893 		if (perm != LDC_MEM_W)
2894 			bcopy(vaddr, ldep->align_addr, nbytes);
2895 		vaddr = ldep->align_addr;
2896 	}
2897 
2898 	maptype = LDC_IO_MAP|LDC_SHADOW_MAP|LDC_DIRECT_MAP;
2899 	rv = ldc_mem_bind_handle(mhdl, vaddr, P2ROUNDUP(nbytes, 8),
2900 	    maptype, perm, &dep->payload.cookie[0], &dep->payload.ncookies);
2901 	DMSG(vdcp, 2, "[%d] bound mem handle; ncookies=%d\n",
2902 	    vdcp->instance, dep->payload.ncookies);
2903 	if (rv != 0) {
2904 		DMSG(vdcp, 0, "[%d] Failed to bind LDC memory handle "
2905 		    "(mhdl=%p, buf=%p, err=%d)\n",
2906 		    vdcp->instance, (void *)mhdl, (void *)vaddr, rv);
2907 		if (ldep->align_addr) {
2908 			kmem_free(ldep->align_addr,
2909 			    sizeof (caddr_t) * P2ROUNDUP(nbytes, 8));
2910 			ldep->align_addr = NULL;
2911 		}
2912 		return (EAGAIN);
2913 	}
2914 
2915 	/*
2916 	 * Get the other cookies (if any).
2917 	 */
2918 	for (i = 1; i < dep->payload.ncookies; i++) {
2919 		rv = ldc_mem_nextcookie(mhdl, &dep->payload.cookie[i]);
2920 		if (rv != 0) {
2921 			(void) ldc_mem_unbind_handle(mhdl);
2922 			DMSG(vdcp, 0, "?[%d] Failed to get next cookie "
2923 			    "(mhdl=%lx cnum=%d), err=%d",
2924 			    vdcp->instance, mhdl, i, rv);
2925 			if (ldep->align_addr) {
2926 				kmem_free(ldep->align_addr,
2927 				    sizeof (caddr_t) * ldep->nbytes);
2928 				ldep->align_addr = NULL;
2929 			}
2930 			return (EAGAIN);
2931 		}
2932 	}
2933 
2934 	return (rv);
2935 }
2936 
2937 /*
2938  * Interrupt handlers for messages from LDC
2939  */
2940 
2941 /*
2942  * Function:
2943  *	vdc_handle_cb()
2944  *
2945  * Description:
2946  *
2947  * Arguments:
2948  *	event	- Type of event (LDC_EVT_xxx) that triggered the callback
2949  *	arg	- soft state pointer for this instance of the device driver.
2950  *
2951  * Return Code:
2952  *	0	- Success
2953  */
2954 static uint_t
2955 vdc_handle_cb(uint64_t event, caddr_t arg)
2956 {
2957 	ldc_status_t	ldc_state;
2958 	int		rv = 0;
2959 
2960 	vdc_t	*vdc = (vdc_t *)(void *)arg;
2961 
2962 	ASSERT(vdc != NULL);
2963 
2964 	DMSG(vdc, 1, "evt=%lx seqID=%ld\n", event, vdc->seq_num);
2965 
2966 	/*
2967 	 * Depending on the type of event that triggered this callback,
2968 	 * we modify the handshake state or read the data.
2969 	 *
2970 	 * NOTE: not done as a switch() as event could be triggered by
2971 	 * a state change and a read request. Also the ordering	of the
2972 	 * check for the event types is deliberate.
2973 	 */
2974 	if (event & LDC_EVT_UP) {
2975 		DMSG(vdc, 0, "[%d] Received LDC_EVT_UP\n", vdc->instance);
2976 
2977 		mutex_enter(&vdc->lock);
2978 
2979 		/* get LDC state */
2980 		rv = ldc_status(vdc->ldc_handle, &ldc_state);
2981 		if (rv != 0) {
2982 			DMSG(vdc, 0, "[%d] Couldn't get LDC status %d",
2983 			    vdc->instance, rv);
2984 			return (LDC_SUCCESS);
2985 		}
2986 		if (vdc->ldc_state != LDC_UP && ldc_state == LDC_UP) {
2987 			/*
2988 			 * Reset the transaction sequence numbers when
2989 			 * LDC comes up. We then kick off the handshake
2990 			 * negotiation with the vDisk server.
2991 			 */
2992 			vdc->seq_num = 1;
2993 			vdc->seq_num_reply = 0;
2994 			vdc->ldc_state = ldc_state;
2995 			cv_signal(&vdc->initwait_cv);
2996 		}
2997 
2998 		mutex_exit(&vdc->lock);
2999 	}
3000 
3001 	if (event & LDC_EVT_READ) {
3002 		DMSG(vdc, 0, "[%d] Received LDC_EVT_READ\n", vdc->instance);
3003 		mutex_enter(&vdc->read_lock);
3004 		cv_signal(&vdc->read_cv);
3005 		vdc->read_state = VDC_READ_PENDING;
3006 		mutex_exit(&vdc->read_lock);
3007 
3008 		/* that's all we have to do - no need to handle DOWN/RESET */
3009 		return (LDC_SUCCESS);
3010 	}
3011 
3012 	if (event & (LDC_EVT_RESET|LDC_EVT_DOWN)) {
3013 
3014 		DMSG(vdc, 0, "[%d] Received LDC RESET event\n", vdc->instance);
3015 
3016 		mutex_enter(&vdc->lock);
3017 		/*
3018 		 * Need to wake up any readers so they will
3019 		 * detect that a reset has occurred.
3020 		 */
3021 		mutex_enter(&vdc->read_lock);
3022 		if ((vdc->read_state == VDC_READ_WAITING) ||
3023 		    (vdc->read_state == VDC_READ_RESET))
3024 			cv_signal(&vdc->read_cv);
3025 		vdc->read_state = VDC_READ_RESET;
3026 		mutex_exit(&vdc->read_lock);
3027 
3028 		/* wake up any threads waiting for connection to come up */
3029 		if (vdc->state == VDC_STATE_INIT_WAITING) {
3030 			vdc->state = VDC_STATE_RESETTING;
3031 			cv_signal(&vdc->initwait_cv);
3032 		}
3033 
3034 		mutex_exit(&vdc->lock);
3035 	}
3036 
3037 	if (event & ~(LDC_EVT_UP | LDC_EVT_RESET | LDC_EVT_DOWN | LDC_EVT_READ))
3038 		DMSG(vdc, 0, "![%d] Unexpected LDC event (%lx) received",
3039 		    vdc->instance, event);
3040 
3041 	return (LDC_SUCCESS);
3042 }
3043 
3044 /*
3045  * Function:
3046  *	vdc_wait_for_response()
3047  *
3048  * Description:
3049  *	Block waiting for a response from the server. If there is
3050  *	no data the thread block on the read_cv that is signalled
3051  *	by the callback when an EVT_READ occurs.
3052  *
3053  * Arguments:
3054  *	vdcp	- soft state pointer for this instance of the device driver.
3055  *
3056  * Return Code:
3057  *	0	- Success
3058  */
3059 static int
3060 vdc_wait_for_response(vdc_t *vdcp, vio_msg_t *msgp)
3061 {
3062 	size_t		nbytes = sizeof (*msgp);
3063 	int		status;
3064 
3065 	ASSERT(vdcp != NULL);
3066 
3067 	DMSG(vdcp, 1, "[%d] Entered\n", vdcp->instance);
3068 
3069 	status = vdc_recv(vdcp, msgp, &nbytes);
3070 	DMSG(vdcp, 3, "vdc_read() done.. status=0x%x size=0x%x\n",
3071 	    status, (int)nbytes);
3072 	if (status) {
3073 		DMSG(vdcp, 0, "?[%d] Error %d reading LDC msg\n",
3074 		    vdcp->instance, status);
3075 		return (status);
3076 	}
3077 
3078 	if (nbytes < sizeof (vio_msg_tag_t)) {
3079 		DMSG(vdcp, 0, "?[%d] Expect %lu bytes; recv'd %lu\n",
3080 		    vdcp->instance, sizeof (vio_msg_tag_t), nbytes);
3081 		return (ENOMSG);
3082 	}
3083 
3084 	DMSG(vdcp, 2, "[%d] (%x/%x/%x)\n", vdcp->instance,
3085 	    msgp->tag.vio_msgtype,
3086 	    msgp->tag.vio_subtype,
3087 	    msgp->tag.vio_subtype_env);
3088 
3089 	/*
3090 	 * Verify the Session ID of the message
3091 	 *
3092 	 * Every message after the Version has been negotiated should
3093 	 * have the correct session ID set.
3094 	 */
3095 	if ((msgp->tag.vio_sid != vdcp->session_id) &&
3096 	    (msgp->tag.vio_subtype_env != VIO_VER_INFO)) {
3097 		DMSG(vdcp, 0, "[%d] Invalid SID: received 0x%x, "
3098 		    "expected 0x%lx [seq num %lx @ %d]",
3099 		    vdcp->instance, msgp->tag.vio_sid,
3100 		    vdcp->session_id,
3101 		    ((vio_dring_msg_t *)msgp)->seq_num,
3102 		    ((vio_dring_msg_t *)msgp)->start_idx);
3103 		return (ENOMSG);
3104 	}
3105 	return (0);
3106 }
3107 
3108 
3109 /*
3110  * Function:
3111  *	vdc_resubmit_backup_dring()
3112  *
3113  * Description:
3114  *	Resubmit each descriptor in the backed up dring to
3115  * 	vDisk server. The Dring was backed up during connection
3116  *	reset.
3117  *
3118  * Arguments:
3119  *	vdcp	- soft state pointer for this instance of the device driver.
3120  *
3121  * Return Code:
3122  *	0	- Success
3123  */
3124 static int
3125 vdc_resubmit_backup_dring(vdc_t *vdcp)
3126 {
3127 	int		count;
3128 	int		b_idx;
3129 	int		rv;
3130 	int		dring_size;
3131 	int		status;
3132 	vio_msg_t	vio_msg;
3133 	vdc_local_desc_t	*curr_ldep;
3134 
3135 	ASSERT(MUTEX_NOT_HELD(&vdcp->lock));
3136 	ASSERT(vdcp->state == VDC_STATE_HANDLE_PENDING);
3137 
3138 	DMSG(vdcp, 1, "restoring pending dring entries (len=%d, tail=%d)\n",
3139 	    vdcp->local_dring_backup_len, vdcp->local_dring_backup_tail);
3140 
3141 	/*
3142 	 * Walk the backup copy of the local descriptor ring and
3143 	 * resubmit all the outstanding transactions.
3144 	 */
3145 	b_idx = vdcp->local_dring_backup_tail;
3146 	for (count = 0; count < vdcp->local_dring_backup_len; count++) {
3147 
3148 		curr_ldep = &(vdcp->local_dring_backup[b_idx]);
3149 
3150 		/* only resubmit outstanding transactions */
3151 		if (!curr_ldep->is_free) {
3152 
3153 			DMSG(vdcp, 1, "resubmitting entry idx=%x\n", b_idx);
3154 			mutex_enter(&vdcp->lock);
3155 			rv = vdc_populate_descriptor(vdcp, curr_ldep->operation,
3156 			    curr_ldep->addr, curr_ldep->nbytes,
3157 			    curr_ldep->slice, curr_ldep->offset,
3158 			    curr_ldep->cb_type, curr_ldep->cb_arg,
3159 			    curr_ldep->dir);
3160 			mutex_exit(&vdcp->lock);
3161 			if (rv) {
3162 				DMSG(vdcp, 1, "[%d] cannot resubmit entry %d\n",
3163 				    vdcp->instance, b_idx);
3164 				return (rv);
3165 			}
3166 
3167 			/* Wait for the response message. */
3168 			DMSG(vdcp, 1, "waiting for response to idx=%x\n",
3169 			    b_idx);
3170 			status = vdc_wait_for_response(vdcp, &vio_msg);
3171 			if (status) {
3172 				DMSG(vdcp, 1, "[%d] wait_for_response "
3173 				    "returned err=%d\n", vdcp->instance,
3174 				    status);
3175 				return (status);
3176 			}
3177 
3178 			DMSG(vdcp, 1, "processing msg for idx=%x\n", b_idx);
3179 			status = vdc_process_data_msg(vdcp, &vio_msg);
3180 			if (status) {
3181 				DMSG(vdcp, 1, "[%d] process_data_msg "
3182 				    "returned err=%d\n", vdcp->instance,
3183 				    status);
3184 				return (status);
3185 			}
3186 		}
3187 
3188 		/* get the next element to submit */
3189 		if (++b_idx >= vdcp->local_dring_backup_len)
3190 			b_idx = 0;
3191 	}
3192 
3193 	/* all done - now clear up pending dring copy */
3194 	dring_size = vdcp->local_dring_backup_len *
3195 	    sizeof (vdcp->local_dring_backup[0]);
3196 
3197 	(void) kmem_free(vdcp->local_dring_backup, dring_size);
3198 
3199 	vdcp->local_dring_backup = NULL;
3200 
3201 	return (0);
3202 }
3203 
3204 /*
3205  * Function:
3206  *	vdc_backup_local_dring()
3207  *
3208  * Description:
3209  *	Backup the current dring in the event of a reset. The Dring
3210  *	transactions will be resubmitted to the server when the
3211  *	connection is restored.
3212  *
3213  * Arguments:
3214  *	vdcp	- soft state pointer for this instance of the device driver.
3215  *
3216  * Return Code:
3217  *	NONE
3218  */
3219 static void
3220 vdc_backup_local_dring(vdc_t *vdcp)
3221 {
3222 	int dring_size;
3223 
3224 	ASSERT(vdcp->state == VDC_STATE_RESETTING);
3225 
3226 	/*
3227 	 * If the backup dring is stil around, it means
3228 	 * that the last restore did not complete. However,
3229 	 * since we never got back into the running state,
3230 	 * the backup copy we have is still valid.
3231 	 */
3232 	if (vdcp->local_dring_backup != NULL) {
3233 		DMSG(vdcp, 1, "reusing local descriptor ring backup "
3234 		    "(len=%d, tail=%d)\n", vdcp->local_dring_backup_len,
3235 		    vdcp->local_dring_backup_tail);
3236 		return;
3237 	}
3238 
3239 	DMSG(vdcp, 1, "backing up the local descriptor ring (len=%d, "
3240 	    "tail=%d)\n", vdcp->dring_len, vdcp->dring_curr_idx);
3241 
3242 	dring_size = vdcp->dring_len * sizeof (vdcp->local_dring[0]);
3243 
3244 	vdcp->local_dring_backup = kmem_alloc(dring_size, KM_SLEEP);
3245 	bcopy(vdcp->local_dring, vdcp->local_dring_backup, dring_size);
3246 
3247 	vdcp->local_dring_backup_tail = vdcp->dring_curr_idx;
3248 	vdcp->local_dring_backup_len = vdcp->dring_len;
3249 }
3250 
3251 /* -------------------------------------------------------------------------- */
3252 
3253 /*
3254  * The following functions process the incoming messages from vds
3255  */
3256 
3257 /*
3258  * Function:
3259  *      vdc_process_msg_thread()
3260  *
3261  * Description:
3262  *
3263  *	Main VDC message processing thread. Each vDisk instance
3264  * 	consists of a copy of this thread. This thread triggers
3265  * 	all the handshakes and data exchange with the server. It
3266  * 	also handles all channel resets
3267  *
3268  * Arguments:
3269  *      vdc     - soft state pointer for this instance of the device driver.
3270  *
3271  * Return Code:
3272  *      None
3273  */
3274 static void
3275 vdc_process_msg_thread(vdc_t *vdcp)
3276 {
3277 	int	status;
3278 
3279 	mutex_enter(&vdcp->lock);
3280 
3281 	for (;;) {
3282 
3283 #define	Q(_s)	(vdcp->state == _s) ? #_s :
3284 		DMSG(vdcp, 3, "state = %d (%s)\n", vdcp->state,
3285 		    Q(VDC_STATE_INIT)
3286 		    Q(VDC_STATE_INIT_WAITING)
3287 		    Q(VDC_STATE_NEGOTIATE)
3288 		    Q(VDC_STATE_HANDLE_PENDING)
3289 		    Q(VDC_STATE_RUNNING)
3290 		    Q(VDC_STATE_RESETTING)
3291 		    Q(VDC_STATE_DETACH)
3292 		    "UNKNOWN");
3293 
3294 		switch (vdcp->state) {
3295 		case VDC_STATE_INIT:
3296 
3297 			/* Check if have re-initializing repeatedly */
3298 			if (vdcp->hshake_cnt++ > vdc_hshake_retries) {
3299 				cmn_err(CE_NOTE, "[%d] disk access failed.\n",
3300 				    vdcp->instance);
3301 				vdcp->state = VDC_STATE_DETACH;
3302 				break;
3303 			}
3304 
3305 			/* Bring up connection with vds via LDC */
3306 			status = vdc_start_ldc_connection(vdcp);
3307 			switch (status) {
3308 			case EINVAL:
3309 				DMSG(vdcp, 0, "[%d] Could not start LDC",
3310 				    vdcp->instance);
3311 				vdcp->state = VDC_STATE_DETACH;
3312 				break;
3313 			case 0:
3314 				vdcp->state = VDC_STATE_INIT_WAITING;
3315 				break;
3316 			default:
3317 				vdcp->state = VDC_STATE_INIT_WAITING;
3318 				break;
3319 			}
3320 			break;
3321 
3322 		case VDC_STATE_INIT_WAITING:
3323 
3324 			/*
3325 			 * Let the callback event move us on
3326 			 * when channel is open to server
3327 			 */
3328 			while (vdcp->ldc_state != LDC_UP) {
3329 				cv_wait(&vdcp->initwait_cv, &vdcp->lock);
3330 				if (vdcp->state != VDC_STATE_INIT_WAITING) {
3331 					DMSG(vdcp, 0,
3332 				"state moved to %d out from under us...\n",
3333 					    vdcp->state);
3334 
3335 					break;
3336 				}
3337 			}
3338 			if (vdcp->state == VDC_STATE_INIT_WAITING &&
3339 			    vdcp->ldc_state == LDC_UP) {
3340 				vdcp->state = VDC_STATE_NEGOTIATE;
3341 			}
3342 			break;
3343 
3344 		case VDC_STATE_NEGOTIATE:
3345 			switch (status = vdc_ver_negotiation(vdcp)) {
3346 			case 0:
3347 				break;
3348 			default:
3349 				DMSG(vdcp, 0, "ver negotiate failed (%d)..\n",
3350 				    status);
3351 				goto reset;
3352 			}
3353 
3354 			switch (status = vdc_attr_negotiation(vdcp)) {
3355 			case 0:
3356 				break;
3357 			default:
3358 				DMSG(vdcp, 0, "attr negotiate failed (%d)..\n",
3359 				    status);
3360 				goto reset;
3361 			}
3362 
3363 			switch (status = vdc_dring_negotiation(vdcp)) {
3364 			case 0:
3365 				break;
3366 			default:
3367 				DMSG(vdcp, 0, "dring negotiate failed (%d)..\n",
3368 				    status);
3369 				goto reset;
3370 			}
3371 
3372 			switch (status = vdc_rdx_exchange(vdcp)) {
3373 			case 0:
3374 				vdcp->state = VDC_STATE_HANDLE_PENDING;
3375 				goto done;
3376 			default:
3377 				DMSG(vdcp, 0, "RDX xchg failed ..(%d)\n",
3378 				    status);
3379 				goto reset;
3380 			}
3381 reset:
3382 			DMSG(vdcp, 0, "negotiation failed: resetting (%d)\n",
3383 			    status);
3384 			vdcp->state = VDC_STATE_RESETTING;
3385 done:
3386 			DMSG(vdcp, 0, "negotiation complete (state=0x%x)...\n",
3387 			    vdcp->state);
3388 			break;
3389 
3390 		case VDC_STATE_HANDLE_PENDING:
3391 
3392 			mutex_exit(&vdcp->lock);
3393 			status = vdc_resubmit_backup_dring(vdcp);
3394 			mutex_enter(&vdcp->lock);
3395 
3396 			if (status)
3397 				vdcp->state = VDC_STATE_RESETTING;
3398 			else
3399 				vdcp->state = VDC_STATE_RUNNING;
3400 
3401 			break;
3402 
3403 		/* enter running state */
3404 		case VDC_STATE_RUNNING:
3405 			/*
3406 			 * Signal anyone waiting for the connection
3407 			 * to come on line.
3408 			 */
3409 			vdcp->hshake_cnt = 0;
3410 			cv_broadcast(&vdcp->running_cv);
3411 			mutex_exit(&vdcp->lock);
3412 
3413 			for (;;) {
3414 				vio_msg_t msg;
3415 				status = vdc_wait_for_response(vdcp, &msg);
3416 				if (status) break;
3417 
3418 				DMSG(vdcp, 1, "[%d] new pkt(s) available\n",
3419 				    vdcp->instance);
3420 				status = vdc_process_data_msg(vdcp, &msg);
3421 				if (status) {
3422 					DMSG(vdcp, 1, "[%d] process_data_msg "
3423 					    "returned err=%d\n", vdcp->instance,
3424 					    status);
3425 					break;
3426 				}
3427 
3428 			}
3429 
3430 			mutex_enter(&vdcp->lock);
3431 
3432 			vdcp->state = VDC_STATE_RESETTING;
3433 			vdcp->self_reset = B_TRUE;
3434 			break;
3435 
3436 		case VDC_STATE_RESETTING:
3437 			DMSG(vdcp, 0, "Initiating channel reset "
3438 			    "(pending = %d)\n", (int)vdcp->threads_pending);
3439 
3440 			if (vdcp->self_reset) {
3441 				DMSG(vdcp, 0,
3442 				    "[%d] calling stop_ldc_connection.\n",
3443 				    vdcp->instance);
3444 				status = vdc_stop_ldc_connection(vdcp);
3445 				vdcp->self_reset = B_FALSE;
3446 			}
3447 
3448 			/*
3449 			 * Wait for all threads currently waiting
3450 			 * for a free dring entry to use.
3451 			 */
3452 			while (vdcp->threads_pending) {
3453 				cv_broadcast(&vdcp->membind_cv);
3454 				cv_broadcast(&vdcp->dring_free_cv);
3455 				mutex_exit(&vdcp->lock);
3456 				/* let them wake up */
3457 				drv_usecwait(vdc_min_timeout_ldc);
3458 				mutex_enter(&vdcp->lock);
3459 			}
3460 
3461 			ASSERT(vdcp->threads_pending == 0);
3462 
3463 			/* Sanity check that no thread is receiving */
3464 			ASSERT(vdcp->read_state != VDC_READ_WAITING);
3465 
3466 			vdcp->read_state = VDC_READ_IDLE;
3467 
3468 			vdc_backup_local_dring(vdcp);
3469 
3470 			/* cleanup the old d-ring */
3471 			vdc_destroy_descriptor_ring(vdcp);
3472 
3473 			/* go and start again */
3474 			vdcp->state = VDC_STATE_INIT;
3475 
3476 			break;
3477 
3478 		case VDC_STATE_DETACH:
3479 			DMSG(vdcp, 0, "[%d] Reset thread exit cleanup ..\n",
3480 			    vdcp->instance);
3481 
3482 			/*
3483 			 * Signal anyone waiting for connection
3484 			 * to come online
3485 			 */
3486 			cv_broadcast(&vdcp->running_cv);
3487 
3488 			while (vdcp->sync_op_pending) {
3489 				cv_signal(&vdcp->sync_pending_cv);
3490 				cv_signal(&vdcp->sync_blocked_cv);
3491 				mutex_exit(&vdcp->lock);
3492 				drv_usecwait(vdc_min_timeout_ldc);
3493 				mutex_enter(&vdcp->lock);
3494 			}
3495 
3496 			mutex_exit(&vdcp->lock);
3497 
3498 			DMSG(vdcp, 0, "[%d] Msg processing thread exiting ..\n",
3499 			    vdcp->instance);
3500 			thread_exit();
3501 			break;
3502 		}
3503 	}
3504 }
3505 
3506 
3507 /*
3508  * Function:
3509  *	vdc_process_data_msg()
3510  *
3511  * Description:
3512  *	This function is called by the message processing thread each time
3513  *	a message with a msgtype of VIO_TYPE_DATA is received. It will either
3514  *	be an ACK or NACK from vds[1] which vdc handles as follows.
3515  *		ACK	- wake up the waiting thread
3516  *		NACK	- resend any messages necessary
3517  *
3518  *	[1] Although the message format allows it, vds should not send a
3519  *	    VIO_SUBTYPE_INFO message to vdc asking it to read data; if for
3520  *	    some bizarre reason it does, vdc will reset the connection.
3521  *
3522  * Arguments:
3523  *	vdc	- soft state pointer for this instance of the device driver.
3524  *	msg	- the LDC message sent by vds
3525  *
3526  * Return Code:
3527  *	0	- Success.
3528  *	> 0	- error value returned by LDC
3529  */
3530 static int
3531 vdc_process_data_msg(vdc_t *vdcp, vio_msg_t *msg)
3532 {
3533 	int			status = 0;
3534 	vio_dring_msg_t		*dring_msg;
3535 	vdc_local_desc_t	*ldep = NULL;
3536 	int			start, end;
3537 	int			idx;
3538 
3539 	dring_msg = (vio_dring_msg_t *)msg;
3540 
3541 	ASSERT(msg->tag.vio_msgtype == VIO_TYPE_DATA);
3542 	ASSERT(vdcp != NULL);
3543 
3544 	mutex_enter(&vdcp->lock);
3545 
3546 	/*
3547 	 * Check to see if the message has bogus data
3548 	 */
3549 	idx = start = dring_msg->start_idx;
3550 	end = dring_msg->end_idx;
3551 	if ((start >= vdcp->dring_len) ||
3552 	    (end >= vdcp->dring_len) || (end < -1)) {
3553 		DMSG(vdcp, 0, "[%d] Bogus ACK data : start %d, end %d\n",
3554 		    vdcp->instance, start, end);
3555 		mutex_exit(&vdcp->lock);
3556 		return (EINVAL);
3557 	}
3558 
3559 	/*
3560 	 * Verify that the sequence number is what vdc expects.
3561 	 */
3562 	switch (vdc_verify_seq_num(vdcp, dring_msg)) {
3563 	case VDC_SEQ_NUM_TODO:
3564 		break;	/* keep processing this message */
3565 	case VDC_SEQ_NUM_SKIP:
3566 		mutex_exit(&vdcp->lock);
3567 		return (0);
3568 	case VDC_SEQ_NUM_INVALID:
3569 		mutex_exit(&vdcp->lock);
3570 		DMSG(vdcp, 0, "[%d] invalid seqno\n", vdcp->instance);
3571 		return (ENXIO);
3572 	}
3573 
3574 	if (msg->tag.vio_subtype == VIO_SUBTYPE_NACK) {
3575 		DMSG(vdcp, 0, "[%d] DATA NACK\n", vdcp->instance);
3576 		VDC_DUMP_DRING_MSG(dring_msg);
3577 		mutex_exit(&vdcp->lock);
3578 		return (EIO);
3579 
3580 	} else if (msg->tag.vio_subtype == VIO_SUBTYPE_INFO) {
3581 		mutex_exit(&vdcp->lock);
3582 		return (EPROTO);
3583 	}
3584 
3585 	DTRACE_IO2(recv, vio_dring_msg_t, dring_msg, vdc_t *, vdcp);
3586 	DMSG(vdcp, 1, ": start %d end %d\n", start, end);
3587 	ASSERT(start == end);
3588 
3589 	ldep = &vdcp->local_dring[idx];
3590 
3591 	DMSG(vdcp, 1, ": state 0x%x - cb_type 0x%x\n",
3592 	    ldep->dep->hdr.dstate, ldep->cb_type);
3593 
3594 	if (ldep->dep->hdr.dstate == VIO_DESC_DONE) {
3595 		struct buf *bufp;
3596 
3597 		switch (ldep->cb_type) {
3598 		case CB_SYNC:
3599 			ASSERT(vdcp->sync_op_pending);
3600 
3601 			status = vdc_depopulate_descriptor(vdcp, idx);
3602 			vdcp->sync_op_status = status;
3603 			vdcp->sync_op_pending = B_FALSE;
3604 			cv_signal(&vdcp->sync_pending_cv);
3605 			break;
3606 
3607 		case CB_STRATEGY:
3608 			bufp = ldep->cb_arg;
3609 			ASSERT(bufp != NULL);
3610 			bufp->b_resid =
3611 			    bufp->b_bcount - ldep->dep->payload.nbytes;
3612 			status = ldep->dep->payload.status; /* Future:ntoh */
3613 			if (status != 0) {
3614 				DMSG(vdcp, 1, "strategy status=%d\n", status);
3615 				bioerror(bufp, status);
3616 			}
3617 			status = vdc_depopulate_descriptor(vdcp, idx);
3618 			biodone(bufp);
3619 
3620 			DMSG(vdcp, 1,
3621 			    "strategy complete req=%ld bytes resp=%ld bytes\n",
3622 			    bufp->b_bcount, ldep->dep->payload.nbytes);
3623 			break;
3624 
3625 		default:
3626 			ASSERT(0);
3627 		}
3628 	}
3629 
3630 	/* let the arrival signal propogate */
3631 	mutex_exit(&vdcp->lock);
3632 
3633 	/* probe gives the count of how many entries were processed */
3634 	DTRACE_IO2(processed, int, 1, vdc_t *, vdcp);
3635 
3636 	return (0);
3637 }
3638 
3639 /*
3640  * Function:
3641  *	vdc_process_err_msg()
3642  *
3643  * NOTE: No error messages are used as part of the vDisk protocol
3644  */
3645 static int
3646 vdc_process_err_msg(vdc_t *vdc, vio_msg_t msg)
3647 {
3648 	_NOTE(ARGUNUSED(vdc))
3649 	_NOTE(ARGUNUSED(msg))
3650 
3651 	ASSERT(msg.tag.vio_msgtype == VIO_TYPE_ERR);
3652 	DMSG(vdc, 1, "[%d] Got an ERR msg", vdc->instance);
3653 
3654 	return (ENOTSUP);
3655 }
3656 
3657 /*
3658  * Function:
3659  *	vdc_handle_ver_msg()
3660  *
3661  * Description:
3662  *
3663  * Arguments:
3664  *	vdc	- soft state pointer for this instance of the device driver.
3665  *	ver_msg	- LDC message sent by vDisk server
3666  *
3667  * Return Code:
3668  *	0	- Success
3669  */
3670 static int
3671 vdc_handle_ver_msg(vdc_t *vdc, vio_ver_msg_t *ver_msg)
3672 {
3673 	int status = 0;
3674 
3675 	ASSERT(vdc != NULL);
3676 	ASSERT(mutex_owned(&vdc->lock));
3677 
3678 	if (ver_msg->tag.vio_subtype_env != VIO_VER_INFO) {
3679 		return (EPROTO);
3680 	}
3681 
3682 	if (ver_msg->dev_class != VDEV_DISK_SERVER) {
3683 		return (EINVAL);
3684 	}
3685 
3686 	switch (ver_msg->tag.vio_subtype) {
3687 	case VIO_SUBTYPE_ACK:
3688 		/*
3689 		 * We check to see if the version returned is indeed supported
3690 		 * (The server may have also adjusted the minor number downwards
3691 		 * and if so 'ver_msg' will contain the actual version agreed)
3692 		 */
3693 		if (vdc_is_supported_version(ver_msg)) {
3694 			vdc->ver.major = ver_msg->ver_major;
3695 			vdc->ver.minor = ver_msg->ver_minor;
3696 			ASSERT(vdc->ver.major > 0);
3697 		} else {
3698 			status = EPROTO;
3699 		}
3700 		break;
3701 
3702 	case VIO_SUBTYPE_NACK:
3703 		/*
3704 		 * call vdc_is_supported_version() which will return the next
3705 		 * supported version (if any) in 'ver_msg'
3706 		 */
3707 		(void) vdc_is_supported_version(ver_msg);
3708 		if (ver_msg->ver_major > 0) {
3709 			size_t len = sizeof (*ver_msg);
3710 
3711 			ASSERT(vdc->ver.major > 0);
3712 
3713 			/* reset the necessary fields and resend */
3714 			ver_msg->tag.vio_subtype = VIO_SUBTYPE_INFO;
3715 			ver_msg->dev_class = VDEV_DISK;
3716 
3717 			status = vdc_send(vdc, (caddr_t)ver_msg, &len);
3718 			DMSG(vdc, 0, "[%d] Resend VER info (LDC status = %d)\n",
3719 			    vdc->instance, status);
3720 			if (len != sizeof (*ver_msg))
3721 				status = EBADMSG;
3722 		} else {
3723 			DMSG(vdc, 0, "[%d] No common version with vDisk server",
3724 			    vdc->instance);
3725 			status = ENOTSUP;
3726 		}
3727 
3728 		break;
3729 	case VIO_SUBTYPE_INFO:
3730 		/*
3731 		 * Handle the case where vds starts handshake
3732 		 * (for now only vdc is the instigator)
3733 		 */
3734 		status = ENOTSUP;
3735 		break;
3736 
3737 	default:
3738 		status = EINVAL;
3739 		break;
3740 	}
3741 
3742 	return (status);
3743 }
3744 
3745 /*
3746  * Function:
3747  *	vdc_handle_attr_msg()
3748  *
3749  * Description:
3750  *
3751  * Arguments:
3752  *	vdc	- soft state pointer for this instance of the device driver.
3753  *	attr_msg	- LDC message sent by vDisk server
3754  *
3755  * Return Code:
3756  *	0	- Success
3757  */
3758 static int
3759 vdc_handle_attr_msg(vdc_t *vdc, vd_attr_msg_t *attr_msg)
3760 {
3761 	int status = 0;
3762 
3763 	ASSERT(vdc != NULL);
3764 	ASSERT(mutex_owned(&vdc->lock));
3765 
3766 	if (attr_msg->tag.vio_subtype_env != VIO_ATTR_INFO) {
3767 		return (EPROTO);
3768 	}
3769 
3770 	switch (attr_msg->tag.vio_subtype) {
3771 	case VIO_SUBTYPE_ACK:
3772 		/*
3773 		 * We now verify the attributes sent by vds.
3774 		 */
3775 		vdc->vdisk_size = attr_msg->vdisk_size;
3776 		vdc->vdisk_type = attr_msg->vdisk_type;
3777 
3778 		DMSG(vdc, 0, "[%d] max_xfer_sz: sent %lx acked %lx\n",
3779 		    vdc->instance, vdc->max_xfer_sz, attr_msg->max_xfer_sz);
3780 		DMSG(vdc, 0, "[%d] vdisk_block_size: sent %lx acked %x\n",
3781 		    vdc->instance, vdc->block_size,
3782 		    attr_msg->vdisk_block_size);
3783 
3784 		/*
3785 		 * We don't know at compile time what the vDisk server will
3786 		 * think are good values but we apply an large (arbitrary)
3787 		 * upper bound to prevent memory exhaustion in vdc if it was
3788 		 * allocating a DRing based of huge values sent by the server.
3789 		 * We probably will never exceed this except if the message
3790 		 * was garbage.
3791 		 */
3792 		if ((attr_msg->max_xfer_sz * attr_msg->vdisk_block_size) <=
3793 		    (PAGESIZE * DEV_BSIZE)) {
3794 			vdc->max_xfer_sz = attr_msg->max_xfer_sz;
3795 			vdc->block_size = attr_msg->vdisk_block_size;
3796 		} else {
3797 			DMSG(vdc, 0, "[%d] vds block transfer size too big;"
3798 			    " using max supported by vdc", vdc->instance);
3799 		}
3800 
3801 		if ((attr_msg->xfer_mode != VIO_DRING_MODE) ||
3802 		    (attr_msg->vdisk_size > INT64_MAX) ||
3803 		    (attr_msg->vdisk_type > VD_DISK_TYPE_DISK)) {
3804 			DMSG(vdc, 0, "[%d] Invalid attributes from vds",
3805 			    vdc->instance);
3806 			status = EINVAL;
3807 			break;
3808 		}
3809 
3810 		break;
3811 
3812 	case VIO_SUBTYPE_NACK:
3813 		/*
3814 		 * vds could not handle the attributes we sent so we
3815 		 * stop negotiating.
3816 		 */
3817 		status = EPROTO;
3818 		break;
3819 
3820 	case VIO_SUBTYPE_INFO:
3821 		/*
3822 		 * Handle the case where vds starts the handshake
3823 		 * (for now; vdc is the only supported instigatior)
3824 		 */
3825 		status = ENOTSUP;
3826 		break;
3827 
3828 	default:
3829 		status = ENOTSUP;
3830 		break;
3831 	}
3832 
3833 	return (status);
3834 }
3835 
3836 /*
3837  * Function:
3838  *	vdc_handle_dring_reg_msg()
3839  *
3840  * Description:
3841  *
3842  * Arguments:
3843  *	vdc		- soft state pointer for this instance of the driver.
3844  *	dring_msg	- LDC message sent by vDisk server
3845  *
3846  * Return Code:
3847  *	0	- Success
3848  */
3849 static int
3850 vdc_handle_dring_reg_msg(vdc_t *vdc, vio_dring_reg_msg_t *dring_msg)
3851 {
3852 	int		status = 0;
3853 
3854 	ASSERT(vdc != NULL);
3855 	ASSERT(mutex_owned(&vdc->lock));
3856 
3857 	if (dring_msg->tag.vio_subtype_env != VIO_DRING_REG) {
3858 		return (EPROTO);
3859 	}
3860 
3861 	switch (dring_msg->tag.vio_subtype) {
3862 	case VIO_SUBTYPE_ACK:
3863 		/* save the received dring_ident */
3864 		vdc->dring_ident = dring_msg->dring_ident;
3865 		DMSG(vdc, 0, "[%d] Received dring ident=0x%lx\n",
3866 		    vdc->instance, vdc->dring_ident);
3867 		break;
3868 
3869 	case VIO_SUBTYPE_NACK:
3870 		/*
3871 		 * vds could not handle the DRing info we sent so we
3872 		 * stop negotiating.
3873 		 */
3874 		DMSG(vdc, 0, "[%d] server could not register DRing\n",
3875 		    vdc->instance);
3876 		status = EPROTO;
3877 		break;
3878 
3879 	case VIO_SUBTYPE_INFO:
3880 		/*
3881 		 * Handle the case where vds starts handshake
3882 		 * (for now only vdc is the instigatior)
3883 		 */
3884 		status = ENOTSUP;
3885 		break;
3886 	default:
3887 		status = ENOTSUP;
3888 	}
3889 
3890 	return (status);
3891 }
3892 
3893 /*
3894  * Function:
3895  *	vdc_verify_seq_num()
3896  *
3897  * Description:
3898  *	This functions verifies that the sequence number sent back by the vDisk
3899  *	server with the latest message is what is expected (i.e. it is greater
3900  *	than the last seq num sent by the vDisk server and less than or equal
3901  *	to the last seq num generated by vdc).
3902  *
3903  *	It then checks the request ID to see if any requests need processing
3904  *	in the DRing.
3905  *
3906  * Arguments:
3907  *	vdc		- soft state pointer for this instance of the driver.
3908  *	dring_msg	- pointer to the LDC message sent by vds
3909  *
3910  * Return Code:
3911  *	VDC_SEQ_NUM_TODO	- Message needs to be processed
3912  *	VDC_SEQ_NUM_SKIP	- Message has already been processed
3913  *	VDC_SEQ_NUM_INVALID	- The seq numbers are so out of sync,
3914  *				  vdc cannot deal with them
3915  */
3916 static int
3917 vdc_verify_seq_num(vdc_t *vdc, vio_dring_msg_t *dring_msg)
3918 {
3919 	ASSERT(vdc != NULL);
3920 	ASSERT(dring_msg != NULL);
3921 	ASSERT(mutex_owned(&vdc->lock));
3922 
3923 	/*
3924 	 * Check to see if the messages were responded to in the correct
3925 	 * order by vds.
3926 	 */
3927 	if ((dring_msg->seq_num <= vdc->seq_num_reply) ||
3928 	    (dring_msg->seq_num > vdc->seq_num)) {
3929 		DMSG(vdc, 0, "?[%d] Bogus sequence_number %lu: "
3930 		    "%lu > expected <= %lu (last proc req %lu sent %lu)\n",
3931 		    vdc->instance, dring_msg->seq_num,
3932 		    vdc->seq_num_reply, vdc->seq_num,
3933 		    vdc->req_id_proc, vdc->req_id);
3934 		return (VDC_SEQ_NUM_INVALID);
3935 	}
3936 	vdc->seq_num_reply = dring_msg->seq_num;
3937 
3938 	if (vdc->req_id_proc < vdc->req_id)
3939 		return (VDC_SEQ_NUM_TODO);
3940 	else
3941 		return (VDC_SEQ_NUM_SKIP);
3942 }
3943 
3944 
3945 /*
3946  * Function:
3947  *	vdc_is_supported_version()
3948  *
3949  * Description:
3950  *	This routine checks if the major/minor version numbers specified in
3951  *	'ver_msg' are supported. If not it finds the next version that is
3952  *	in the supported version list 'vdc_version[]' and sets the fields in
3953  *	'ver_msg' to those values
3954  *
3955  * Arguments:
3956  *	ver_msg	- LDC message sent by vDisk server
3957  *
3958  * Return Code:
3959  *	B_TRUE	- Success
3960  *	B_FALSE	- Version not supported
3961  */
3962 static boolean_t
3963 vdc_is_supported_version(vio_ver_msg_t *ver_msg)
3964 {
3965 	int vdc_num_versions = sizeof (vdc_version) / sizeof (vdc_version[0]);
3966 
3967 	for (int i = 0; i < vdc_num_versions; i++) {
3968 		ASSERT(vdc_version[i].major > 0);
3969 		ASSERT((i == 0) ||
3970 		    (vdc_version[i].major < vdc_version[i-1].major));
3971 
3972 		/*
3973 		 * If the major versions match, adjust the minor version, if
3974 		 * necessary, down to the highest value supported by this
3975 		 * client. The server should support all minor versions lower
3976 		 * than the value it sent
3977 		 */
3978 		if (ver_msg->ver_major == vdc_version[i].major) {
3979 			if (ver_msg->ver_minor > vdc_version[i].minor) {
3980 				DMSGX(0,
3981 				    "Adjusting minor version from %u to %u",
3982 				    ver_msg->ver_minor, vdc_version[i].minor);
3983 				ver_msg->ver_minor = vdc_version[i].minor;
3984 			}
3985 			return (B_TRUE);
3986 		}
3987 
3988 		/*
3989 		 * If the message contains a higher major version number, set
3990 		 * the message's major/minor versions to the current values
3991 		 * and return false, so this message will get resent with
3992 		 * these values, and the server will potentially try again
3993 		 * with the same or a lower version
3994 		 */
3995 		if (ver_msg->ver_major > vdc_version[i].major) {
3996 			ver_msg->ver_major = vdc_version[i].major;
3997 			ver_msg->ver_minor = vdc_version[i].minor;
3998 			DMSGX(0, "Suggesting major/minor (0x%x/0x%x)\n",
3999 			    ver_msg->ver_major, ver_msg->ver_minor);
4000 
4001 			return (B_FALSE);
4002 		}
4003 
4004 		/*
4005 		 * Otherwise, the message's major version is less than the
4006 		 * current major version, so continue the loop to the next
4007 		 * (lower) supported version
4008 		 */
4009 	}
4010 
4011 	/*
4012 	 * No common version was found; "ground" the version pair in the
4013 	 * message to terminate negotiation
4014 	 */
4015 	ver_msg->ver_major = 0;
4016 	ver_msg->ver_minor = 0;
4017 
4018 	return (B_FALSE);
4019 }
4020 /* -------------------------------------------------------------------------- */
4021 
4022 /*
4023  * DKIO(7) support
4024  */
4025 
4026 typedef struct vdc_dk_arg {
4027 	struct dk_callback	dkc;
4028 	int			mode;
4029 	dev_t			dev;
4030 	vdc_t			*vdc;
4031 } vdc_dk_arg_t;
4032 
4033 /*
4034  * Function:
4035  * 	vdc_dkio_flush_cb()
4036  *
4037  * Description:
4038  *	This routine is a callback for DKIOCFLUSHWRITECACHE which can be called
4039  *	by kernel code.
4040  *
4041  * Arguments:
4042  *	arg	- a pointer to a vdc_dk_arg_t structure.
4043  */
4044 void
4045 vdc_dkio_flush_cb(void *arg)
4046 {
4047 	struct vdc_dk_arg	*dk_arg = (struct vdc_dk_arg *)arg;
4048 	struct dk_callback	*dkc = NULL;
4049 	vdc_t			*vdc = NULL;
4050 	int			rv;
4051 
4052 	if (dk_arg == NULL) {
4053 		cmn_err(CE_NOTE, "?[Unk] DKIOCFLUSHWRITECACHE arg is NULL\n");
4054 		return;
4055 	}
4056 	dkc = &dk_arg->dkc;
4057 	vdc = dk_arg->vdc;
4058 	ASSERT(vdc != NULL);
4059 
4060 	rv = vdc_do_sync_op(vdc, VD_OP_FLUSH, NULL, 0,
4061 	    VDCPART(dk_arg->dev), 0, CB_SYNC, 0, VIO_both_dir);
4062 	if (rv != 0) {
4063 		DMSG(vdc, 0, "[%d] DKIOCFLUSHWRITECACHE failed %d : model %x\n",
4064 		    vdc->instance, rv,
4065 		    ddi_model_convert_from(dk_arg->mode & FMODELS));
4066 	}
4067 
4068 	/*
4069 	 * Trigger the call back to notify the caller the the ioctl call has
4070 	 * been completed.
4071 	 */
4072 	if ((dk_arg->mode & FKIOCTL) &&
4073 	    (dkc != NULL) &&
4074 	    (dkc->dkc_callback != NULL)) {
4075 		ASSERT(dkc->dkc_cookie != NULL);
4076 		(*dkc->dkc_callback)(dkc->dkc_cookie, rv);
4077 	}
4078 
4079 	/* Indicate that one less DKIO write flush is outstanding */
4080 	mutex_enter(&vdc->lock);
4081 	vdc->dkio_flush_pending--;
4082 	ASSERT(vdc->dkio_flush_pending >= 0);
4083 	mutex_exit(&vdc->lock);
4084 
4085 	/* free the mem that was allocated when the callback was dispatched */
4086 	kmem_free(arg, sizeof (vdc_dk_arg_t));
4087 }
4088 
4089 /*
4090  * Function:
4091  * 	vdc_dkio_get_partition()
4092  *
4093  * Description:
4094  *	This function implements the DKIOCGAPART ioctl.
4095  *
4096  * Arguments:
4097  *	dev	- device
4098  *	arg	- a pointer to a dk_map[NDKMAP] or dk_map32[NDKMAP] structure
4099  *	flag	- ioctl flags
4100  */
4101 static int
4102 vdc_dkio_get_partition(dev_t dev, caddr_t arg, int flag)
4103 {
4104 	struct dk_geom geom;
4105 	struct vtoc vtoc;
4106 	union {
4107 		struct dk_map map[NDKMAP];
4108 		struct dk_map32 map32[NDKMAP];
4109 	} data;
4110 	int i, rv, size;
4111 
4112 	rv = vd_process_ioctl(dev, DKIOCGGEOM, (caddr_t)&geom, FKIOCTL);
4113 	if (rv != 0)
4114 		return (rv);
4115 
4116 	rv = vd_process_ioctl(dev, DKIOCGVTOC, (caddr_t)&vtoc, FKIOCTL);
4117 	if (rv != 0)
4118 		return (rv);
4119 
4120 	if (vtoc.v_nparts != NDKMAP ||
4121 	    geom.dkg_nhead == 0 || geom.dkg_nsect == 0)
4122 		return (EINVAL);
4123 
4124 	if (ddi_model_convert_from(flag & FMODELS) == DDI_MODEL_ILP32) {
4125 
4126 		for (i = 0; i < NDKMAP; i++) {
4127 			data.map32[i].dkl_cylno = vtoc.v_part[i].p_start /
4128 			    (geom.dkg_nhead * geom.dkg_nsect);
4129 			data.map32[i].dkl_nblk = vtoc.v_part[i].p_size;
4130 		}
4131 		size = NDKMAP * sizeof (struct dk_map32);
4132 
4133 	} else {
4134 
4135 		for (i = 0; i < NDKMAP; i++) {
4136 			data.map[i].dkl_cylno = vtoc.v_part[i].p_start /
4137 			    (geom.dkg_nhead * geom.dkg_nsect);
4138 			data.map[i].dkl_nblk = vtoc.v_part[i].p_size;
4139 		}
4140 		size = NDKMAP * sizeof (struct dk_map);
4141 
4142 	}
4143 
4144 	if (ddi_copyout(&data, arg, size, flag) != 0)
4145 		return (EFAULT);
4146 
4147 	return (0);
4148 }
4149 
4150 /*
4151  * Function:
4152  * 	vdc_dioctl_rwcmd()
4153  *
4154  * Description:
4155  *	This function implements the DIOCTL_RWCMD ioctl. This ioctl is used
4156  *	for DKC_DIRECT disks to read or write at an absolute disk offset.
4157  *
4158  * Arguments:
4159  *	dev	- device
4160  *	arg	- a pointer to a dadkio_rwcmd or dadkio_rwcmd32 structure
4161  *	flag	- ioctl flags
4162  */
4163 static int
4164 vdc_dioctl_rwcmd(dev_t dev, caddr_t arg, int flag)
4165 {
4166 	struct dadkio_rwcmd32 rwcmd32;
4167 	struct dadkio_rwcmd rwcmd;
4168 	struct iovec aiov;
4169 	struct uio auio;
4170 	int rw, status;
4171 	struct buf *buf;
4172 
4173 	if (ddi_model_convert_from(flag & FMODELS) == DDI_MODEL_ILP32) {
4174 		if (ddi_copyin((caddr_t)arg, (caddr_t)&rwcmd32,
4175 		    sizeof (struct dadkio_rwcmd32), flag)) {
4176 			return (EFAULT);
4177 		}
4178 		rwcmd.cmd = rwcmd32.cmd;
4179 		rwcmd.flags = rwcmd32.flags;
4180 		rwcmd.blkaddr = (daddr_t)rwcmd32.blkaddr;
4181 		rwcmd.buflen = rwcmd32.buflen;
4182 		rwcmd.bufaddr = (caddr_t)(uintptr_t)rwcmd32.bufaddr;
4183 	} else {
4184 		if (ddi_copyin((caddr_t)arg, (caddr_t)&rwcmd,
4185 		    sizeof (struct dadkio_rwcmd), flag)) {
4186 			return (EFAULT);
4187 		}
4188 	}
4189 
4190 	switch (rwcmd.cmd) {
4191 	case DADKIO_RWCMD_READ:
4192 		rw = B_READ;
4193 		break;
4194 	case DADKIO_RWCMD_WRITE:
4195 		rw = B_WRITE;
4196 		break;
4197 	default:
4198 		return (EINVAL);
4199 	}
4200 
4201 	bzero((caddr_t)&aiov, sizeof (struct iovec));
4202 	aiov.iov_base   = rwcmd.bufaddr;
4203 	aiov.iov_len    = rwcmd.buflen;
4204 
4205 	bzero((caddr_t)&auio, sizeof (struct uio));
4206 	auio.uio_iov    = &aiov;
4207 	auio.uio_iovcnt = 1;
4208 	auio.uio_loffset = rwcmd.blkaddr * DEV_BSIZE;
4209 	auio.uio_resid  = rwcmd.buflen;
4210 	auio.uio_segflg = flag & FKIOCTL ? UIO_SYSSPACE : UIO_USERSPACE;
4211 
4212 	buf = kmem_alloc(sizeof (buf_t), KM_SLEEP);
4213 	bioinit(buf);
4214 	/*
4215 	 * We use the private field of buf to specify that this is an
4216 	 * I/O using an absolute offset.
4217 	 */
4218 	buf->b_private = (void *)VD_SLICE_NONE;
4219 
4220 	status = physio(vdc_strategy, buf, dev, rw, vdc_min, &auio);
4221 
4222 	biofini(buf);
4223 	kmem_free(buf, sizeof (buf_t));
4224 
4225 	return (status);
4226 }
4227 
4228 /*
4229  * This structure is used in the DKIO(7I) array below.
4230  */
4231 typedef struct vdc_dk_ioctl {
4232 	uint8_t		op;		/* VD_OP_XXX value */
4233 	int		cmd;		/* Solaris ioctl operation number */
4234 	size_t		nbytes;		/* size of structure to be copied */
4235 
4236 	/* function to convert between vDisk and Solaris structure formats */
4237 	int	(*convert)(vdc_t *vdc, void *vd_buf, void *ioctl_arg,
4238 	    int mode, int dir);
4239 } vdc_dk_ioctl_t;
4240 
4241 /*
4242  * Subset of DKIO(7I) operations currently supported
4243  */
4244 static vdc_dk_ioctl_t	dk_ioctl[] = {
4245 	{VD_OP_FLUSH,		DKIOCFLUSHWRITECACHE,	0,
4246 		vdc_null_copy_func},
4247 	{VD_OP_GET_WCE,		DKIOCGETWCE,		sizeof (int),
4248 		vdc_get_wce_convert},
4249 	{VD_OP_SET_WCE,		DKIOCSETWCE,		sizeof (int),
4250 		vdc_set_wce_convert},
4251 	{VD_OP_GET_VTOC,	DKIOCGVTOC,		sizeof (vd_vtoc_t),
4252 		vdc_get_vtoc_convert},
4253 	{VD_OP_SET_VTOC,	DKIOCSVTOC,		sizeof (vd_vtoc_t),
4254 		vdc_set_vtoc_convert},
4255 	{VD_OP_GET_DISKGEOM,	DKIOCGGEOM,		sizeof (vd_geom_t),
4256 		vdc_get_geom_convert},
4257 	{VD_OP_GET_DISKGEOM,	DKIOCG_PHYGEOM,		sizeof (vd_geom_t),
4258 		vdc_get_geom_convert},
4259 	{VD_OP_GET_DISKGEOM, 	DKIOCG_VIRTGEOM,	sizeof (vd_geom_t),
4260 		vdc_get_geom_convert},
4261 	{VD_OP_SET_DISKGEOM,	DKIOCSGEOM,		sizeof (vd_geom_t),
4262 		vdc_set_geom_convert},
4263 	{VD_OP_GET_EFI,		DKIOCGETEFI,		0,
4264 		vdc_get_efi_convert},
4265 	{VD_OP_SET_EFI,		DKIOCSETEFI,		0,
4266 		vdc_set_efi_convert},
4267 
4268 	/* DIOCTL_RWCMD is converted to a read or a write */
4269 	{0, DIOCTL_RWCMD,  sizeof (struct dadkio_rwcmd), NULL},
4270 
4271 	/*
4272 	 * These particular ioctls are not sent to the server - vdc fakes up
4273 	 * the necessary info.
4274 	 */
4275 	{0, DKIOCINFO, sizeof (struct dk_cinfo), vdc_null_copy_func},
4276 	{0, DKIOCGMEDIAINFO, sizeof (struct dk_minfo), vdc_null_copy_func},
4277 	{0, USCSICMD,	sizeof (struct uscsi_cmd), vdc_null_copy_func},
4278 	{0, DKIOCGAPART, 0, vdc_null_copy_func },
4279 	{0, DKIOCREMOVABLE, 0, vdc_null_copy_func},
4280 	{0, CDROMREADOFFSET, 0, vdc_null_copy_func}
4281 };
4282 
4283 /*
4284  * Function:
4285  *	vd_process_ioctl()
4286  *
4287  * Description:
4288  *	This routine processes disk specific ioctl calls
4289  *
4290  * Arguments:
4291  *	dev	- the device number
4292  *	cmd	- the operation [dkio(7I)] to be processed
4293  *	arg	- pointer to user provided structure
4294  *		  (contains data to be set or reference parameter for get)
4295  *	mode	- bit flag, indicating open settings, 32/64 bit type, etc
4296  *
4297  * Return Code:
4298  *	0
4299  *	EFAULT
4300  *	ENXIO
4301  *	EIO
4302  *	ENOTSUP
4303  */
4304 static int
4305 vd_process_ioctl(dev_t dev, int cmd, caddr_t arg, int mode)
4306 {
4307 	int		instance = VDCUNIT(dev);
4308 	vdc_t		*vdc = NULL;
4309 	int		rv = -1;
4310 	int		idx = 0;		/* index into dk_ioctl[] */
4311 	size_t		len = 0;		/* #bytes to send to vds */
4312 	size_t		alloc_len = 0;		/* #bytes to allocate mem for */
4313 	caddr_t		mem_p = NULL;
4314 	size_t		nioctls = (sizeof (dk_ioctl)) / (sizeof (dk_ioctl[0]));
4315 	struct vtoc	vtoc_saved;
4316 	vdc_dk_ioctl_t	*iop;
4317 
4318 	vdc = ddi_get_soft_state(vdc_state, instance);
4319 	if (vdc == NULL) {
4320 		cmn_err(CE_NOTE, "![%d] Could not get soft state structure",
4321 		    instance);
4322 		return (ENXIO);
4323 	}
4324 
4325 	DMSG(vdc, 0, "[%d] Processing ioctl(%x) for dev %lx : model %x\n",
4326 	    instance, cmd, dev, ddi_model_convert_from(mode & FMODELS));
4327 
4328 	/*
4329 	 * Validate the ioctl operation to be performed.
4330 	 *
4331 	 * If we have looped through the array without finding a match then we
4332 	 * don't support this ioctl.
4333 	 */
4334 	for (idx = 0; idx < nioctls; idx++) {
4335 		if (cmd == dk_ioctl[idx].cmd)
4336 			break;
4337 	}
4338 
4339 	if (idx >= nioctls) {
4340 		DMSG(vdc, 0, "[%d] Unsupported ioctl (0x%x)\n",
4341 		    vdc->instance, cmd);
4342 		return (ENOTSUP);
4343 	}
4344 
4345 	iop = &(dk_ioctl[idx]);
4346 
4347 	if (cmd == DKIOCGETEFI || cmd == DKIOCSETEFI) {
4348 		/* size is not fixed for EFI ioctls, it depends on ioctl arg */
4349 		dk_efi_t	dk_efi;
4350 
4351 		rv = ddi_copyin(arg, &dk_efi, sizeof (dk_efi_t), mode);
4352 		if (rv != 0)
4353 			return (EFAULT);
4354 
4355 		len = sizeof (vd_efi_t) - 1 + dk_efi.dki_length;
4356 	} else {
4357 		len = iop->nbytes;
4358 	}
4359 
4360 	/*
4361 	 * Deal with the ioctls which the server does not provide. vdc can
4362 	 * fake these up and return immediately
4363 	 */
4364 	switch (cmd) {
4365 	case CDROMREADOFFSET:
4366 	case DKIOCREMOVABLE:
4367 	case USCSICMD:
4368 		return (ENOTTY);
4369 
4370 	case DIOCTL_RWCMD:
4371 		{
4372 			if (vdc->cinfo->dki_ctype != DKC_DIRECT)
4373 				return (ENOTTY);
4374 
4375 			return (vdc_dioctl_rwcmd(dev, arg, mode));
4376 		}
4377 
4378 	case DKIOCGAPART:
4379 		{
4380 			if (vdc->vdisk_label != VD_DISK_LABEL_VTOC)
4381 				return (ENOTSUP);
4382 
4383 			return (vdc_dkio_get_partition(dev, arg, mode));
4384 		}
4385 
4386 	case DKIOCINFO:
4387 		{
4388 			struct dk_cinfo	cinfo;
4389 			if (vdc->cinfo == NULL)
4390 				return (ENXIO);
4391 
4392 			bcopy(vdc->cinfo, &cinfo, sizeof (struct dk_cinfo));
4393 			cinfo.dki_partition = VDCPART(dev);
4394 
4395 			rv = ddi_copyout(&cinfo, (void *)arg,
4396 			    sizeof (struct dk_cinfo), mode);
4397 			if (rv != 0)
4398 				return (EFAULT);
4399 
4400 			return (0);
4401 		}
4402 
4403 	case DKIOCGMEDIAINFO:
4404 		{
4405 			if (vdc->minfo == NULL)
4406 				return (ENXIO);
4407 
4408 			rv = ddi_copyout(vdc->minfo, (void *)arg,
4409 			    sizeof (struct dk_minfo), mode);
4410 			if (rv != 0)
4411 				return (EFAULT);
4412 
4413 			return (0);
4414 		}
4415 
4416 	case DKIOCFLUSHWRITECACHE:
4417 		{
4418 			struct dk_callback *dkc = (struct dk_callback *)arg;
4419 			vdc_dk_arg_t	*dkarg = NULL;
4420 
4421 			DMSG(vdc, 1, "[%d] Flush W$: mode %x\n",
4422 			    instance, mode);
4423 
4424 			/*
4425 			 * If the backing device is not a 'real' disk then the
4426 			 * W$ operation request to the vDisk server will fail
4427 			 * so we might as well save the cycles and return now.
4428 			 */
4429 			if (vdc->vdisk_type != VD_DISK_TYPE_DISK)
4430 				return (ENOTTY);
4431 
4432 			/*
4433 			 * If arg is NULL, then there is no callback function
4434 			 * registered and the call operates synchronously; we
4435 			 * break and continue with the rest of the function and
4436 			 * wait for vds to return (i.e. after the request to
4437 			 * vds returns successfully, all writes completed prior
4438 			 * to the ioctl will have been flushed from the disk
4439 			 * write cache to persistent media.
4440 			 *
4441 			 * If a callback function is registered, we dispatch
4442 			 * the request on a task queue and return immediately.
4443 			 * The callback will deal with informing the calling
4444 			 * thread that the flush request is completed.
4445 			 */
4446 			if (dkc == NULL)
4447 				break;
4448 
4449 			/*
4450 			 * the asynchronous callback is only supported if
4451 			 * invoked from within the kernel
4452 			 */
4453 			if ((mode & FKIOCTL) == 0)
4454 				return (ENOTSUP);
4455 
4456 			dkarg = kmem_zalloc(sizeof (vdc_dk_arg_t), KM_SLEEP);
4457 
4458 			dkarg->mode = mode;
4459 			dkarg->dev = dev;
4460 			bcopy(dkc, &dkarg->dkc, sizeof (*dkc));
4461 
4462 			mutex_enter(&vdc->lock);
4463 			vdc->dkio_flush_pending++;
4464 			dkarg->vdc = vdc;
4465 			mutex_exit(&vdc->lock);
4466 
4467 			/* put the request on a task queue */
4468 			rv = taskq_dispatch(system_taskq, vdc_dkio_flush_cb,
4469 			    (void *)dkarg, DDI_SLEEP);
4470 			if (rv == NULL) {
4471 				/* clean up if dispatch fails */
4472 				mutex_enter(&vdc->lock);
4473 				vdc->dkio_flush_pending--;
4474 				kmem_free(dkarg, sizeof (vdc_dk_arg_t));
4475 			}
4476 
4477 			return (rv == NULL ? ENOMEM : 0);
4478 		}
4479 	}
4480 
4481 	/* catch programming error in vdc - should be a VD_OP_XXX ioctl */
4482 	ASSERT(iop->op != 0);
4483 
4484 	/* LDC requires that the memory being mapped is 8-byte aligned */
4485 	alloc_len = P2ROUNDUP(len, sizeof (uint64_t));
4486 	DMSG(vdc, 1, "[%d] struct size %ld alloc %ld\n",
4487 	    instance, len, alloc_len);
4488 
4489 	ASSERT(alloc_len >= 0); /* sanity check */
4490 	if (alloc_len > 0)
4491 		mem_p = kmem_zalloc(alloc_len, KM_SLEEP);
4492 
4493 	if (cmd == DKIOCSVTOC) {
4494 		/*
4495 		 * Save a copy of the current VTOC so that we can roll back
4496 		 * if the setting of the new VTOC fails.
4497 		 */
4498 		bcopy(vdc->vtoc, &vtoc_saved, sizeof (struct vtoc));
4499 	}
4500 
4501 	/*
4502 	 * Call the conversion function for this ioctl which, if necessary,
4503 	 * converts from the Solaris format to the format ARC'ed
4504 	 * as part of the vDisk protocol (FWARC 2006/195)
4505 	 */
4506 	ASSERT(iop->convert != NULL);
4507 	rv = (iop->convert)(vdc, arg, mem_p, mode, VD_COPYIN);
4508 	if (rv != 0) {
4509 		DMSG(vdc, 0, "[%d] convert func returned %d for ioctl 0x%x\n",
4510 		    instance, rv, cmd);
4511 		if (mem_p != NULL)
4512 			kmem_free(mem_p, alloc_len);
4513 		return (rv);
4514 	}
4515 
4516 	/*
4517 	 * send request to vds to service the ioctl.
4518 	 */
4519 	rv = vdc_do_sync_op(vdc, iop->op, mem_p, alloc_len,
4520 	    VDCPART(dev), 0, CB_SYNC, (void *)(uint64_t)mode,
4521 	    VIO_both_dir);
4522 
4523 	if (rv != 0) {
4524 		/*
4525 		 * This is not necessarily an error. The ioctl could
4526 		 * be returning a value such as ENOTTY to indicate
4527 		 * that the ioctl is not applicable.
4528 		 */
4529 		DMSG(vdc, 0, "[%d] vds returned %d for ioctl 0x%x\n",
4530 		    instance, rv, cmd);
4531 		if (mem_p != NULL)
4532 			kmem_free(mem_p, alloc_len);
4533 
4534 		if (cmd == DKIOCSVTOC) {
4535 			/* update of the VTOC has failed, roll back */
4536 			bcopy(&vtoc_saved, vdc->vtoc, sizeof (struct vtoc));
4537 		}
4538 
4539 		return (rv);
4540 	}
4541 
4542 	if (cmd == DKIOCSVTOC) {
4543 		/*
4544 		 * The VTOC has been changed. We need to update the device
4545 		 * nodes to handle the case where an EFI label has been
4546 		 * changed to a VTOC label. We also try and update the device
4547 		 * node properties. Failing to set the properties should
4548 		 * not cause an error to be return the caller though.
4549 		 */
4550 		vdc->vdisk_label = VD_DISK_LABEL_VTOC;
4551 		(void) vdc_create_device_nodes_vtoc(vdc);
4552 
4553 		if (vdc_create_device_nodes_props(vdc)) {
4554 			DMSG(vdc, 0, "![%d] Failed to update device nodes"
4555 			    " properties", vdc->instance);
4556 		}
4557 
4558 	} else if (cmd == DKIOCSETEFI) {
4559 		/*
4560 		 * The EFI has been changed. We need to update the device
4561 		 * nodes to handle the case where a VTOC label has been
4562 		 * changed to an EFI label. We also try and update the device
4563 		 * node properties. Failing to set the properties should
4564 		 * not cause an error to be return the caller though.
4565 		 */
4566 		struct dk_gpt *efi;
4567 		size_t efi_len;
4568 
4569 		vdc->vdisk_label = VD_DISK_LABEL_EFI;
4570 		(void) vdc_create_device_nodes_efi(vdc);
4571 
4572 		rv = vdc_efi_alloc_and_read(dev, &efi, &efi_len);
4573 
4574 		if (rv == 0) {
4575 			vdc_store_efi(vdc, efi);
4576 			rv = vdc_create_device_nodes_props(vdc);
4577 			vd_efi_free(efi, efi_len);
4578 		}
4579 
4580 		if (rv) {
4581 			DMSG(vdc, 0, "![%d] Failed to update device nodes"
4582 			    " properties", vdc->instance);
4583 		}
4584 	}
4585 
4586 	/*
4587 	 * Call the conversion function (if it exists) for this ioctl
4588 	 * which converts from the format ARC'ed as part of the vDisk
4589 	 * protocol (FWARC 2006/195) back to a format understood by
4590 	 * the rest of Solaris.
4591 	 */
4592 	rv = (iop->convert)(vdc, mem_p, arg, mode, VD_COPYOUT);
4593 	if (rv != 0) {
4594 		DMSG(vdc, 0, "[%d] convert func returned %d for ioctl 0x%x\n",
4595 		    instance, rv, cmd);
4596 		if (mem_p != NULL)
4597 			kmem_free(mem_p, alloc_len);
4598 		return (rv);
4599 	}
4600 
4601 	if (mem_p != NULL)
4602 		kmem_free(mem_p, alloc_len);
4603 
4604 	return (rv);
4605 }
4606 
4607 /*
4608  * Function:
4609  *
4610  * Description:
4611  *	This is an empty conversion function used by ioctl calls which
4612  *	do not need to convert the data being passed in/out to userland
4613  */
4614 static int
4615 vdc_null_copy_func(vdc_t *vdc, void *from, void *to, int mode, int dir)
4616 {
4617 	_NOTE(ARGUNUSED(vdc))
4618 	_NOTE(ARGUNUSED(from))
4619 	_NOTE(ARGUNUSED(to))
4620 	_NOTE(ARGUNUSED(mode))
4621 	_NOTE(ARGUNUSED(dir))
4622 
4623 	return (0);
4624 }
4625 
4626 static int
4627 vdc_get_wce_convert(vdc_t *vdc, void *from, void *to,
4628     int mode, int dir)
4629 {
4630 	_NOTE(ARGUNUSED(vdc))
4631 
4632 	if (dir == VD_COPYIN)
4633 		return (0);		/* nothing to do */
4634 
4635 	if (ddi_copyout(from, to, sizeof (int), mode) != 0)
4636 		return (EFAULT);
4637 
4638 	return (0);
4639 }
4640 
4641 static int
4642 vdc_set_wce_convert(vdc_t *vdc, void *from, void *to,
4643     int mode, int dir)
4644 {
4645 	_NOTE(ARGUNUSED(vdc))
4646 
4647 	if (dir == VD_COPYOUT)
4648 		return (0);		/* nothing to do */
4649 
4650 	if (ddi_copyin(from, to, sizeof (int), mode) != 0)
4651 		return (EFAULT);
4652 
4653 	return (0);
4654 }
4655 
4656 /*
4657  * Function:
4658  *	vdc_get_vtoc_convert()
4659  *
4660  * Description:
4661  *	This routine performs the necessary convertions from the DKIOCGVTOC
4662  *	Solaris structure to the format defined in FWARC 2006/195.
4663  *
4664  *	In the struct vtoc definition, the timestamp field is marked as not
4665  *	supported so it is not part of vDisk protocol (FWARC 2006/195).
4666  *	However SVM uses that field to check it can write into the VTOC,
4667  *	so we fake up the info of that field.
4668  *
4669  * Arguments:
4670  *	vdc	- the vDisk client
4671  *	from	- the buffer containing the data to be copied from
4672  *	to	- the buffer to be copied to
4673  *	mode	- flags passed to ioctl() call
4674  *	dir	- the "direction" of the copy - VD_COPYIN or VD_COPYOUT
4675  *
4676  * Return Code:
4677  *	0	- Success
4678  *	ENXIO	- incorrect buffer passed in.
4679  *	EFAULT	- ddi_copyout routine encountered an error.
4680  */
4681 static int
4682 vdc_get_vtoc_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
4683 {
4684 	int		i;
4685 	void		*tmp_mem = NULL;
4686 	void		*tmp_memp;
4687 	struct vtoc	vt;
4688 	struct vtoc32	vt32;
4689 	int		copy_len = 0;
4690 	int		rv = 0;
4691 
4692 	if (dir != VD_COPYOUT)
4693 		return (0);	/* nothing to do */
4694 
4695 	if ((from == NULL) || (to == NULL))
4696 		return (ENXIO);
4697 
4698 	if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32)
4699 		copy_len = sizeof (struct vtoc32);
4700 	else
4701 		copy_len = sizeof (struct vtoc);
4702 
4703 	tmp_mem = kmem_alloc(copy_len, KM_SLEEP);
4704 
4705 	VD_VTOC2VTOC((vd_vtoc_t *)from, &vt);
4706 
4707 	/* fake the VTOC timestamp field */
4708 	for (i = 0; i < V_NUMPAR; i++) {
4709 		vt.timestamp[i] = vdc->vtoc->timestamp[i];
4710 	}
4711 
4712 	if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
4713 		vtoctovtoc32(vt, vt32);
4714 		tmp_memp = &vt32;
4715 	} else {
4716 		tmp_memp = &vt;
4717 	}
4718 	rv = ddi_copyout(tmp_memp, to, copy_len, mode);
4719 	if (rv != 0)
4720 		rv = EFAULT;
4721 
4722 	kmem_free(tmp_mem, copy_len);
4723 	return (rv);
4724 }
4725 
4726 /*
4727  * Function:
4728  *	vdc_set_vtoc_convert()
4729  *
4730  * Description:
4731  *	This routine performs the necessary convertions from the DKIOCSVTOC
4732  *	Solaris structure to the format defined in FWARC 2006/195.
4733  *
4734  * Arguments:
4735  *	vdc	- the vDisk client
4736  *	from	- Buffer with data
4737  *	to	- Buffer where data is to be copied to
4738  *	mode	- flags passed to ioctl
4739  *	dir	- direction of copy (in or out)
4740  *
4741  * Return Code:
4742  *	0	- Success
4743  *	ENXIO	- Invalid buffer passed in
4744  *	EFAULT	- ddi_copyin of data failed
4745  */
4746 static int
4747 vdc_set_vtoc_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
4748 {
4749 	void		*tmp_mem = NULL;
4750 	struct vtoc	vt;
4751 	struct vtoc	*vtp = &vt;
4752 	vd_vtoc_t	vtvd;
4753 	int		copy_len = 0;
4754 	int		rv = 0;
4755 
4756 	if (dir != VD_COPYIN)
4757 		return (0);	/* nothing to do */
4758 
4759 	if ((from == NULL) || (to == NULL))
4760 		return (ENXIO);
4761 
4762 	if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32)
4763 		copy_len = sizeof (struct vtoc32);
4764 	else
4765 		copy_len = sizeof (struct vtoc);
4766 
4767 	tmp_mem = kmem_alloc(copy_len, KM_SLEEP);
4768 
4769 	rv = ddi_copyin(from, tmp_mem, copy_len, mode);
4770 	if (rv != 0) {
4771 		kmem_free(tmp_mem, copy_len);
4772 		return (EFAULT);
4773 	}
4774 
4775 	if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
4776 		vtoc32tovtoc((*(struct vtoc32 *)tmp_mem), vt);
4777 	} else {
4778 		vtp = tmp_mem;
4779 	}
4780 
4781 	/*
4782 	 * The VTOC is being changed, then vdc needs to update the copy
4783 	 * it saved in the soft state structure.
4784 	 */
4785 	bcopy(vtp, vdc->vtoc, sizeof (struct vtoc));
4786 
4787 	VTOC2VD_VTOC(vtp, &vtvd);
4788 	bcopy(&vtvd, to, sizeof (vd_vtoc_t));
4789 	kmem_free(tmp_mem, copy_len);
4790 
4791 	return (0);
4792 }
4793 
4794 /*
4795  * Function:
4796  *	vdc_get_geom_convert()
4797  *
4798  * Description:
4799  *	This routine performs the necessary convertions from the DKIOCGGEOM,
4800  *	DKIOCG_PHYSGEOM and DKIOG_VIRTGEOM Solaris structures to the format
4801  *	defined in FWARC 2006/195
4802  *
4803  * Arguments:
4804  *	vdc	- the vDisk client
4805  *	from	- Buffer with data
4806  *	to	- Buffer where data is to be copied to
4807  *	mode	- flags passed to ioctl
4808  *	dir	- direction of copy (in or out)
4809  *
4810  * Return Code:
4811  *	0	- Success
4812  *	ENXIO	- Invalid buffer passed in
4813  *	EFAULT	- ddi_copyout of data failed
4814  */
4815 static int
4816 vdc_get_geom_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
4817 {
4818 	_NOTE(ARGUNUSED(vdc))
4819 
4820 	struct dk_geom	geom;
4821 	int	copy_len = sizeof (struct dk_geom);
4822 	int	rv = 0;
4823 
4824 	if (dir != VD_COPYOUT)
4825 		return (0);	/* nothing to do */
4826 
4827 	if ((from == NULL) || (to == NULL))
4828 		return (ENXIO);
4829 
4830 	VD_GEOM2DK_GEOM((vd_geom_t *)from, &geom);
4831 	rv = ddi_copyout(&geom, to, copy_len, mode);
4832 	if (rv != 0)
4833 		rv = EFAULT;
4834 
4835 	return (rv);
4836 }
4837 
4838 /*
4839  * Function:
4840  *	vdc_set_geom_convert()
4841  *
4842  * Description:
4843  *	This routine performs the necessary convertions from the DKIOCSGEOM
4844  *	Solaris structure to the format defined in FWARC 2006/195.
4845  *
4846  * Arguments:
4847  *	vdc	- the vDisk client
4848  *	from	- Buffer with data
4849  *	to	- Buffer where data is to be copied to
4850  *	mode	- flags passed to ioctl
4851  *	dir	- direction of copy (in or out)
4852  *
4853  * Return Code:
4854  *	0	- Success
4855  *	ENXIO	- Invalid buffer passed in
4856  *	EFAULT	- ddi_copyin of data failed
4857  */
4858 static int
4859 vdc_set_geom_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
4860 {
4861 	_NOTE(ARGUNUSED(vdc))
4862 
4863 	vd_geom_t	vdgeom;
4864 	void		*tmp_mem = NULL;
4865 	int		copy_len = sizeof (struct dk_geom);
4866 	int		rv = 0;
4867 
4868 	if (dir != VD_COPYIN)
4869 		return (0);	/* nothing to do */
4870 
4871 	if ((from == NULL) || (to == NULL))
4872 		return (ENXIO);
4873 
4874 	tmp_mem = kmem_alloc(copy_len, KM_SLEEP);
4875 
4876 	rv = ddi_copyin(from, tmp_mem, copy_len, mode);
4877 	if (rv != 0) {
4878 		kmem_free(tmp_mem, copy_len);
4879 		return (EFAULT);
4880 	}
4881 	DK_GEOM2VD_GEOM((struct dk_geom *)tmp_mem, &vdgeom);
4882 	bcopy(&vdgeom, to, sizeof (vdgeom));
4883 	kmem_free(tmp_mem, copy_len);
4884 
4885 	return (0);
4886 }
4887 
4888 static int
4889 vdc_get_efi_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
4890 {
4891 	_NOTE(ARGUNUSED(vdc))
4892 
4893 	vd_efi_t	*vd_efi;
4894 	dk_efi_t	dk_efi;
4895 	int		rv = 0;
4896 	void		*uaddr;
4897 
4898 	if ((from == NULL) || (to == NULL))
4899 		return (ENXIO);
4900 
4901 	if (dir == VD_COPYIN) {
4902 
4903 		vd_efi = (vd_efi_t *)to;
4904 
4905 		rv = ddi_copyin(from, &dk_efi, sizeof (dk_efi_t), mode);
4906 		if (rv != 0)
4907 			return (EFAULT);
4908 
4909 		vd_efi->lba = dk_efi.dki_lba;
4910 		vd_efi->length = dk_efi.dki_length;
4911 		bzero(vd_efi->data, vd_efi->length);
4912 
4913 	} else {
4914 
4915 		rv = ddi_copyin(to, &dk_efi, sizeof (dk_efi_t), mode);
4916 		if (rv != 0)
4917 			return (EFAULT);
4918 
4919 		uaddr = dk_efi.dki_data;
4920 
4921 		dk_efi.dki_data = kmem_alloc(dk_efi.dki_length, KM_SLEEP);
4922 
4923 		VD_EFI2DK_EFI((vd_efi_t *)from, &dk_efi);
4924 
4925 		rv = ddi_copyout(dk_efi.dki_data, uaddr, dk_efi.dki_length,
4926 		    mode);
4927 		if (rv != 0)
4928 			return (EFAULT);
4929 
4930 		kmem_free(dk_efi.dki_data, dk_efi.dki_length);
4931 	}
4932 
4933 	return (0);
4934 }
4935 
4936 static int
4937 vdc_set_efi_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
4938 {
4939 	_NOTE(ARGUNUSED(vdc))
4940 
4941 	dk_efi_t	dk_efi;
4942 	void		*uaddr;
4943 
4944 	if (dir == VD_COPYOUT)
4945 		return (0);	/* nothing to do */
4946 
4947 	if ((from == NULL) || (to == NULL))
4948 		return (ENXIO);
4949 
4950 	if (ddi_copyin(from, &dk_efi, sizeof (dk_efi_t), mode) != 0)
4951 		return (EFAULT);
4952 
4953 	uaddr = dk_efi.dki_data;
4954 
4955 	dk_efi.dki_data = kmem_alloc(dk_efi.dki_length, KM_SLEEP);
4956 
4957 	if (ddi_copyin(uaddr, dk_efi.dki_data, dk_efi.dki_length, mode) != 0)
4958 		return (EFAULT);
4959 
4960 	DK_EFI2VD_EFI(&dk_efi, (vd_efi_t *)to);
4961 
4962 	kmem_free(dk_efi.dki_data, dk_efi.dki_length);
4963 
4964 	return (0);
4965 }
4966 
4967 /*
4968  * Function:
4969  *	vdc_create_fake_geometry()
4970  *
4971  * Description:
4972  *	This routine fakes up the disk info needed for some DKIO ioctls.
4973  *		- DKIOCINFO
4974  *		- DKIOCGMEDIAINFO
4975  *
4976  *	[ just like lofi(7D) and ramdisk(7D) ]
4977  *
4978  * Arguments:
4979  *	vdc	- soft state pointer for this instance of the device driver.
4980  *
4981  * Return Code:
4982  *	0	- Success
4983  */
4984 static int
4985 vdc_create_fake_geometry(vdc_t *vdc)
4986 {
4987 	ASSERT(vdc != NULL);
4988 
4989 	/*
4990 	 * Check if max_xfer_sz and vdisk_size are valid
4991 	 */
4992 	if (vdc->vdisk_size == 0 || vdc->max_xfer_sz == 0)
4993 		return (EIO);
4994 
4995 	/*
4996 	 * DKIOCINFO support
4997 	 */
4998 	vdc->cinfo = kmem_zalloc(sizeof (struct dk_cinfo), KM_SLEEP);
4999 
5000 	(void) strcpy(vdc->cinfo->dki_cname, VDC_DRIVER_NAME);
5001 	(void) strcpy(vdc->cinfo->dki_dname, VDC_DRIVER_NAME);
5002 	/* max_xfer_sz is #blocks so we don't need to divide by DEV_BSIZE */
5003 	vdc->cinfo->dki_maxtransfer = vdc->max_xfer_sz;
5004 	/*
5005 	 * We currently set the controller type to DKC_DIRECT for any disk.
5006 	 * When SCSI support is implemented, we will eventually change this
5007 	 * type to DKC_SCSI_CCS for disks supporting the SCSI protocol.
5008 	 */
5009 	vdc->cinfo->dki_ctype = DKC_DIRECT;
5010 	vdc->cinfo->dki_flags = DKI_FMTVOL;
5011 	vdc->cinfo->dki_cnum = 0;
5012 	vdc->cinfo->dki_addr = 0;
5013 	vdc->cinfo->dki_space = 0;
5014 	vdc->cinfo->dki_prio = 0;
5015 	vdc->cinfo->dki_vec = 0;
5016 	vdc->cinfo->dki_unit = vdc->instance;
5017 	vdc->cinfo->dki_slave = 0;
5018 	/*
5019 	 * The partition number will be created on the fly depending on the
5020 	 * actual slice (i.e. minor node) that is used to request the data.
5021 	 */
5022 	vdc->cinfo->dki_partition = 0;
5023 
5024 	/*
5025 	 * DKIOCGMEDIAINFO support
5026 	 */
5027 	if (vdc->minfo == NULL)
5028 		vdc->minfo = kmem_zalloc(sizeof (struct dk_minfo), KM_SLEEP);
5029 	vdc->minfo->dki_media_type = DK_FIXED_DISK;
5030 	vdc->minfo->dki_capacity = vdc->vdisk_size;
5031 	vdc->minfo->dki_lbsize = DEV_BSIZE;
5032 
5033 	return (0);
5034 }
5035 
5036 /*
5037  * Function:
5038  *	vdc_setup_disk_layout()
5039  *
5040  * Description:
5041  *	This routine discovers all the necessary details about the "disk"
5042  *	by requesting the data that is available from the vDisk server and by
5043  *	faking up the rest of the data.
5044  *
5045  * Arguments:
5046  *	vdc	- soft state pointer for this instance of the device driver.
5047  *
5048  * Return Code:
5049  *	0	- Success
5050  */
5051 static int
5052 vdc_setup_disk_layout(vdc_t *vdc)
5053 {
5054 	buf_t	*buf;	/* BREAD requests need to be in a buf_t structure */
5055 	dev_t	dev;
5056 	int	slice = 0;
5057 	int	rv, error;
5058 
5059 	ASSERT(vdc != NULL);
5060 
5061 	if (vdc->vtoc == NULL)
5062 		vdc->vtoc = kmem_zalloc(sizeof (struct vtoc), KM_SLEEP);
5063 
5064 	dev = makedevice(ddi_driver_major(vdc->dip),
5065 	    VD_MAKE_DEV(vdc->instance, 0));
5066 	rv = vd_process_ioctl(dev, DKIOCGVTOC, (caddr_t)vdc->vtoc, FKIOCTL);
5067 
5068 	if (rv && rv != ENOTSUP) {
5069 		DMSG(vdc, 0, "[%d] Failed to get VTOC (err=%d)",
5070 		    vdc->instance, rv);
5071 		return (rv);
5072 	}
5073 
5074 	/*
5075 	 * The process of attempting to read VTOC will initiate
5076 	 * the handshake and establish a connection. Following
5077 	 * handshake, go ahead and create geometry.
5078 	 */
5079 	error = vdc_create_fake_geometry(vdc);
5080 	if (error != 0) {
5081 		DMSG(vdc, 0, "[%d] Failed to create disk geometry (err%d)",
5082 		    vdc->instance, error);
5083 		return (error);
5084 	}
5085 
5086 	if (rv == ENOTSUP) {
5087 		/*
5088 		 * If the device does not support VTOC then we try
5089 		 * to read an EFI label.
5090 		 */
5091 		struct dk_gpt *efi;
5092 		size_t efi_len;
5093 
5094 		rv = vdc_efi_alloc_and_read(dev, &efi, &efi_len);
5095 
5096 		if (rv) {
5097 			DMSG(vdc, 0, "[%d] Failed to get EFI (err=%d)",
5098 			    vdc->instance, rv);
5099 			return (rv);
5100 		}
5101 
5102 		vdc->vdisk_label = VD_DISK_LABEL_EFI;
5103 		vdc_store_efi(vdc, efi);
5104 		vd_efi_free(efi, efi_len);
5105 
5106 		return (0);
5107 	}
5108 
5109 	vdc->vdisk_label = VD_DISK_LABEL_VTOC;
5110 
5111 	/*
5112 	 * FUTURE: This could be default way for reading the VTOC
5113 	 * from the disk as supposed to sending the VD_OP_GET_VTOC
5114 	 * to the server. Currently this is a sanity check.
5115 	 *
5116 	 * find the slice that represents the entire "disk" and use that to
5117 	 * read the disk label. The convention in Solaris is that slice 2
5118 	 * represents the whole disk so we check that it is, otherwise we
5119 	 * default to slice 0
5120 	 */
5121 	if ((vdc->vdisk_type == VD_DISK_TYPE_DISK) &&
5122 	    (vdc->vtoc->v_part[2].p_tag == V_BACKUP)) {
5123 		slice = 2;
5124 	} else {
5125 		slice = 0;
5126 	}
5127 
5128 	/*
5129 	 * Read disk label from start of disk
5130 	 */
5131 	vdc->label = kmem_zalloc(DK_LABEL_SIZE, KM_SLEEP);
5132 	buf = kmem_alloc(sizeof (buf_t), KM_SLEEP);
5133 	bioinit(buf);
5134 	buf->b_un.b_addr = (caddr_t)vdc->label;
5135 	buf->b_bcount = DK_LABEL_SIZE;
5136 	buf->b_flags = B_BUSY | B_READ;
5137 	buf->b_dev = dev;
5138 	rv = vdc_send_request(vdc, VD_OP_BREAD, (caddr_t)vdc->label,
5139 	    DK_LABEL_SIZE, slice, 0, CB_STRATEGY, buf, VIO_read_dir);
5140 	if (rv) {
5141 		DMSG(vdc, 1, "[%d] Failed to read disk block 0\n",
5142 		    vdc->instance);
5143 		kmem_free(buf, sizeof (buf_t));
5144 		return (rv);
5145 	}
5146 	rv = biowait(buf);
5147 	biofini(buf);
5148 	kmem_free(buf, sizeof (buf_t));
5149 
5150 	return (rv);
5151 }
5152 
5153 /*
5154  * Function:
5155  *	vdc_setup_devid()
5156  *
5157  * Description:
5158  *	This routine discovers the devid of a vDisk. It requests the devid of
5159  *	the underlying device from the vDisk server, builds an encapsulated
5160  *	devid based on the retrieved devid and registers that new devid to
5161  *	the vDisk.
5162  *
5163  * Arguments:
5164  *	vdc	- soft state pointer for this instance of the device driver.
5165  *
5166  * Return Code:
5167  *	0	- A devid was succesfully registered for the vDisk
5168  */
5169 static int
5170 vdc_setup_devid(vdc_t *vdc)
5171 {
5172 	int rv;
5173 	vd_devid_t *vd_devid;
5174 	size_t bufsize, bufid_len;
5175 
5176 	/*
5177 	 * At first sight, we don't know the size of the devid that the
5178 	 * server will return but this size will be encoded into the
5179 	 * reply. So we do a first request using a default size then we
5180 	 * check if this size was large enough. If not then we do a second
5181 	 * request with the correct size returned by the server. Note that
5182 	 * ldc requires size to be 8-byte aligned.
5183 	 */
5184 	bufsize = P2ROUNDUP(VD_DEVID_SIZE(VD_DEVID_DEFAULT_LEN),
5185 	    sizeof (uint64_t));
5186 	vd_devid = kmem_zalloc(bufsize, KM_SLEEP);
5187 	bufid_len = bufsize - sizeof (vd_efi_t) - 1;
5188 
5189 	rv = vdc_do_sync_op(vdc, VD_OP_GET_DEVID, (caddr_t)vd_devid,
5190 	    bufsize, 0, 0, CB_SYNC, 0, VIO_both_dir);
5191 
5192 	DMSG(vdc, 2, "sync_op returned %d\n", rv);
5193 
5194 	if (rv) {
5195 		kmem_free(vd_devid, bufsize);
5196 		return (rv);
5197 	}
5198 
5199 	if (vd_devid->length > bufid_len) {
5200 		/*
5201 		 * The returned devid is larger than the buffer used. Try again
5202 		 * with a buffer with the right size.
5203 		 */
5204 		kmem_free(vd_devid, bufsize);
5205 		bufsize = P2ROUNDUP(VD_DEVID_SIZE(vd_devid->length),
5206 		    sizeof (uint64_t));
5207 		vd_devid = kmem_zalloc(bufsize, KM_SLEEP);
5208 		bufid_len = bufsize - sizeof (vd_efi_t) - 1;
5209 
5210 		rv = vdc_do_sync_op(vdc, VD_OP_GET_DEVID,
5211 		    (caddr_t)vd_devid, bufsize, 0, 0, CB_SYNC, 0,
5212 		    VIO_both_dir);
5213 
5214 		if (rv) {
5215 			kmem_free(vd_devid, bufsize);
5216 			return (rv);
5217 		}
5218 	}
5219 
5220 	/*
5221 	 * The virtual disk should have the same device id as the one associated
5222 	 * with the physical disk it is mapped on, otherwise sharing a disk
5223 	 * between a LDom and a non-LDom may not work (for example for a shared
5224 	 * SVM disk set).
5225 	 *
5226 	 * The DDI framework does not allow creating a device id with any
5227 	 * type so we first create a device id of type DEVID_ENCAP and then
5228 	 * we restore the orignal type of the physical device.
5229 	 */
5230 
5231 	DMSG(vdc, 2, ": devid length = %d\n", vd_devid->length);
5232 
5233 	/* build an encapsulated devid based on the returned devid */
5234 	if (ddi_devid_init(vdc->dip, DEVID_ENCAP, vd_devid->length,
5235 	    vd_devid->id, &vdc->devid) != DDI_SUCCESS) {
5236 		DMSG(vdc, 1, "[%d] Fail to created devid\n", vdc->instance);
5237 		kmem_free(vd_devid, bufsize);
5238 		return (1);
5239 	}
5240 
5241 	DEVID_FORMTYPE((impl_devid_t *)vdc->devid, vd_devid->type);
5242 
5243 	ASSERT(ddi_devid_valid(vdc->devid) == DDI_SUCCESS);
5244 
5245 	kmem_free(vd_devid, bufsize);
5246 
5247 	if (ddi_devid_register(vdc->dip, vdc->devid) != DDI_SUCCESS) {
5248 		DMSG(vdc, 1, "[%d] Fail to register devid\n", vdc->instance);
5249 		return (1);
5250 	}
5251 
5252 	return (0);
5253 }
5254 
5255 static void
5256 vdc_store_efi(vdc_t *vdc, struct dk_gpt *efi)
5257 {
5258 	struct vtoc *vtoc = vdc->vtoc;
5259 
5260 	vd_efi_to_vtoc(efi, vtoc);
5261 	if (vdc->vdisk_type == VD_DISK_TYPE_SLICE) {
5262 		/*
5263 		 * vd_efi_to_vtoc() will store information about the EFI Sun
5264 		 * reserved partition (representing the entire disk) into
5265 		 * partition 7. However single-slice device will only have
5266 		 * that single partition and the vdc driver expects to find
5267 		 * information about that partition in slice 0. So we need
5268 		 * to copy information from slice 7 to slice 0.
5269 		 */
5270 		vtoc->v_part[0].p_tag = vtoc->v_part[VD_EFI_WD_SLICE].p_tag;
5271 		vtoc->v_part[0].p_flag = vtoc->v_part[VD_EFI_WD_SLICE].p_flag;
5272 		vtoc->v_part[0].p_start = vtoc->v_part[VD_EFI_WD_SLICE].p_start;
5273 		vtoc->v_part[0].p_size =  vtoc->v_part[VD_EFI_WD_SLICE].p_size;
5274 	}
5275 }
5276