xref: /titanic_50/usr/src/uts/i86pc/i86hvm/io/xdf_shell.c (revision 1a5e258f5471356ca102c7176637cdce45bac147)
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  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #include <io/xdf_shell.h>
27 #include <sys/dkio.h>
28 #include <sys/scsi/scsi_types.h>
29 
30 /*
31  * General Notes
32  *
33  * We don't support disks with bad block mappins.  We have this
34  * limitation because the underlying xdf driver doesn't support
35  * bad block remapping.  If there is a need to support this feature
36  * it should be added directly to the xdf driver and we should just
37  * pass requests strait on through and let it handle the remapping.
38  * Also, it's probably worth pointing out that most modern disks do bad
39  * block remapping internally in the hardware so there's actually less
40  * of a chance of us ever discovering bad blocks.  Also, in most cases
41  * this driver (and the xdf driver) will only be used with virtualized
42  * devices, so one might wonder why a virtual device would ever actually
43  * experience bad blocks.  To wrap this up, you might be wondering how
44  * these bad block mappings get created and how they are managed.  Well,
45  * there are two tools for managing bad block mappings, format(1M) and
46  * addbadsec(1M).  Format(1M) can be used to do a surface scan of a disk
47  * to attempt to find bad block and create mappings for them.  Format(1M)
48  * and addbadsec(1M) can also be used to edit existing mappings that may
49  * be saved on the disk.
50  *
51  * The underlying PV driver that this driver passes on requests to is the
52  * xdf driver.  Since in most cases the xdf driver doesn't deal with
53  * physical disks it has it's own algorithm for assigning a physical
54  * geometry to a virtual disk (ie, cylinder count, head count, etc.)
55  * The default values chosen by the xdf driver may not match those
56  * assigned to a disk by a hardware disk emulator in an HVM environment.
57  * This is a problem since these physical geometry attributes affect
58  * things like the partition table, backup label location, etc.  So
59  * to emulate disk devices correctly we need to know the physical geometry
60  * that was assigned to a disk at the time of it's initalization.
61  * Normally in an HVM environment this information will passed to
62  * the BIOS and operating system from the hardware emulator that is
63  * emulating the disk devices.  In the case of a solaris dom0+xvm
64  * this would be qemu.  So to work around this issue, this driver will
65  * query the emulated hardware to get the assigned physical geometry
66  * and then pass this geometry onto the xdf driver so that it can use it.
67  * But really, this information is essentially metadata about the disk
68  * that should be kept with the disk image itself.  (Assuming or course
69  * that a disk image is the actual backingstore for this emulated device.)
70  * This metadata should also be made available to PV drivers via a common
71  * mechanism, probably the xenstore.  The fact that this metadata isn't
72  * available outside of HVM domains means that it's difficult to move
73  * disks between HVM and PV domains, since a fully PV domain will have no
74  * way of knowing what the correct geometry of the target device is.
75  * (Short of reading the disk, looking for things like partition tables
76  * and labels, and taking a best guess at what the geometry was when
77  * the disk was initialized.  Unsuprisingly, qemu actually does this.)
78  *
79  * This driver has to map xdf shell device instances into their corresponding
80  * xdf device instances.  We have to do this to ensure that when a user
81  * accesses a emulated xdf shell device we map those accesses to the proper
82  * paravirtualized device.  Basically what we need to know is how multiple
83  * 'disk' entries in a domU configuration file get mapped to emulated
84  * xdf shell devices and to xdf devices.  The 'disk' entry to xdf instance
85  * mappings we know because those are done within the Solaris xvdi code
86  * and the xpvd nexus driver.  But the config to emulated devices mappings
87  * are handled entirely within the xen management tool chain and the
88  * hardware emulator.  Since all the tools that establish these mappings
89  * live in dom0, dom0 should really supply us with this information,
90  * probably via the xenstore.  Unfortunatly it doesn't so, since there's
91  * no good way to determine this mapping dynamically, this driver uses
92  * a hard coded set of static mappings.  These mappings are hardware
93  * emulator specific because each different hardware emulator could have
94  * a different device tree with different xdf shell device paths.  This
95  * means that if we want to continue to use this static mapping approach
96  * to allow Solaris to run on different hardware emulators we'll have
97  * to analyze each of those emulators to determine what paths they
98  * use and hard code those paths into this driver.  yech.  This metadata
99  * really needs to be supplied to us by dom0.
100  *
101  * This driver access underlying xdf nodes.  Unfortunatly, devices
102  * must create minor nodes during attach, and for disk devices to create
103  * minor nodes, they have to look at the label on the disk, so this means
104  * that disk drivers must be able to access a disk contents during
105  * attach.  That means that this disk driver must be able to access
106  * underlying xdf nodes during attach.  Unfortunatly, due to device tree
107  * locking restrictions, we cannot have an attach operation occuring on
108  * this device and then attempt to access another device which may
109  * cause another attach to occur in a different device tree branch
110  * since this could result in deadlock.  Hence, this driver can only
111  * access xdf device nodes that we know are attached, and it can't use
112  * any ddi interfaces to access those nodes if those interfaces could
113  * trigger an attach of the xdf device.  So this driver works around
114  * these restrictions by talking directly to xdf devices via
115  * xdf_hvm_hold().  This interface takes a pathname to an xdf device,
116  * and if that device is already attached then it returns the a held dip
117  * pointer for that device node.  This prevents us from getting into
118  * deadlock situations, but now we need a mechanism to ensure that all
119  * the xdf device nodes this driver might access are attached before
120  * this driver tries to access them.  This is accomplished via the
121  * hvmboot_rootconf() callback which is invoked just before root is
122  * mounted.  hvmboot_rootconf() will attach xpvd and tell it to configure
123  * all xdf device visible to the system.  All these xdf device nodes
124  * will also be marked with the "ddi-no-autodetach" property so that
125  * once they are configured, the will not be automatically unconfigured.
126  * The only way that they could be unconfigured is if the administrator
127  * explicitly attempts to unload required modules via rem_drv(1M)
128  * or modunload(1M).
129  */
130 
131 /*
132  * 16 paritions + fdisk (see xdf.h)
133  */
134 #define	XDFS_DEV2UNIT(dev)	XDF_INST((getminor((dev))))
135 #define	XDFS_DEV2PART(dev)	XDF_PART((getminor((dev))))
136 
137 #define	OTYP_VALID(otyp)	((otyp == OTYP_BLK) ||			\
138 					(otyp == OTYP_CHR) ||		\
139 					(otyp == OTYP_LYR))
140 
141 #define	XDFS_NODES		4
142 
143 #define	XDFS_HVM_MODE(sp)	(XDFS_HVM_STATE(sp)->xdfs_hs_mode)
144 #define	XDFS_HVM_DIP(sp)	(XDFS_HVM_STATE(sp)->xdfs_hs_dip)
145 #define	XDFS_HVM_PATH(sp)	(XDFS_HVM_STATE(sp)->xdfs_hs_path)
146 #define	XDFS_HVM_STATE(sp)						\
147 		((xdfs_hvm_state_t *)(&((char *)(sp))[XDFS_HVM_STATE_OFFSET]))
148 #define	XDFS_HVM_STATE_OFFSET	(xdfs_ss_size - sizeof (xdfs_hvm_state_t))
149 #define	XDFS_HVM_SANE(sp)						\
150 		ASSERT(XDFS_HVM_MODE(sp));				\
151 		ASSERT(XDFS_HVM_DIP(sp) != NULL);			\
152 		ASSERT(XDFS_HVM_PATH(sp) != NULL);
153 
154 
155 typedef struct xdfs_hvm_state {
156 	boolean_t	xdfs_hs_mode;
157 	dev_info_t	*xdfs_hs_dip;
158 	char		*xdfs_hs_path;
159 } xdfs_hvm_state_t;
160 
161 /* local function and structure prototypes */
162 static int xdfs_iodone(struct buf *);
163 static boolean_t xdfs_isopen_part(xdfs_state_t *, int);
164 static boolean_t xdfs_isopen(xdfs_state_t *);
165 static cmlb_tg_ops_t xdfs_lb_ops;
166 
167 /*
168  * Globals
169  */
170 major_t			xdfs_major;
171 #define			xdfs_hvm_dev_ops (xdfs_c_hvm_dev_ops)
172 #define			xdfs_hvm_cb_ops (xdfs_hvm_dev_ops->devo_cb_ops)
173 
174 /*
175  * Private globals
176  */
177 volatile boolean_t	xdfs_pv_disable = B_FALSE;
178 static void		*xdfs_ssp;
179 static size_t		xdfs_ss_size;
180 
181 /*
182  * Private helper functions
183  */
184 static boolean_t
185 xdfs_tgt_hold(xdfs_state_t *xsp)
186 {
187 	mutex_enter(&xsp->xdfss_mutex);
188 	ASSERT(xsp->xdfss_tgt_holds >= 0);
189 	if (!xsp->xdfss_tgt_attached) {
190 		mutex_exit(&xsp->xdfss_mutex);
191 		return (B_FALSE);
192 	}
193 	xsp->xdfss_tgt_holds++;
194 	mutex_exit(&xsp->xdfss_mutex);
195 	return (B_TRUE);
196 }
197 
198 static void
199 xdfs_tgt_release(xdfs_state_t *xsp)
200 {
201 	mutex_enter(&xsp->xdfss_mutex);
202 	ASSERT(xsp->xdfss_tgt_attached);
203 	ASSERT(xsp->xdfss_tgt_holds > 0);
204 	if (--xsp->xdfss_tgt_holds == 0)
205 		cv_broadcast(&xsp->xdfss_cv);
206 	mutex_exit(&xsp->xdfss_mutex);
207 }
208 
209 /*ARGSUSED*/
210 static int
211 xdfs_lb_getinfo(dev_info_t *dip, int cmd, void *arg, void *tg_cookie)
212 {
213 	int		instance = ddi_get_instance(dip);
214 	xdfs_state_t	*xsp = ddi_get_soft_state(xdfs_ssp, instance);
215 	int		rv;
216 
217 	if (xsp == NULL)
218 		return (ENXIO);
219 
220 	if (!xdfs_tgt_hold(xsp))
221 		return (ENXIO);
222 
223 	if (cmd == TG_GETVIRTGEOM) {
224 		cmlb_geom_t	pgeom, *vgeomp;
225 		diskaddr_t	capacity;
226 
227 		/*
228 		 * The native xdf driver doesn't support this ioctl.
229 		 * Intead of passing it on, emulate it here so that the
230 		 * results look the same as what we get for a real xdf
231 		 * shell device.
232 		 *
233 		 * Get the real size of the device
234 		 */
235 		if ((rv = xdf_lb_getinfo(xsp->xdfss_tgt_dip,
236 		    TG_GETPHYGEOM, &pgeom, tg_cookie)) != 0)
237 			goto out;
238 		capacity = pgeom.g_capacity;
239 
240 		/*
241 		 * If the controller returned us something that doesn't
242 		 * really fit into an Int 13/function 8 geometry
243 		 * result, just fail the ioctl.  See PSARC 1998/313.
244 		 */
245 		if (capacity >= (63 * 254 * 1024)) {
246 			rv = EINVAL;
247 			goto out;
248 		}
249 
250 		vgeomp = (cmlb_geom_t *)arg;
251 		vgeomp->g_capacity	= capacity;
252 		vgeomp->g_nsect		= 63;
253 		vgeomp->g_nhead		= 254;
254 		vgeomp->g_ncyl		= capacity / (63 * 254);
255 		vgeomp->g_acyl		= 0;
256 		vgeomp->g_secsize	= 512;
257 		vgeomp->g_intrlv	= 1;
258 		vgeomp->g_rpm		= 3600;
259 		rv = 0;
260 		goto out;
261 	}
262 
263 	rv = xdf_lb_getinfo(xsp->xdfss_tgt_dip, cmd, arg, tg_cookie);
264 
265 out:
266 	xdfs_tgt_release(xsp);
267 	return (rv);
268 }
269 
270 static boolean_t
271 xdfs_isopen_part(xdfs_state_t *xsp, int part)
272 {
273 	int otyp;
274 
275 	ASSERT(MUTEX_HELD(&xsp->xdfss_mutex));
276 	for (otyp = 0; (otyp < OTYPCNT); otyp++) {
277 		if (xsp->xdfss_otyp_count[otyp][part] != 0) {
278 			ASSERT(xsp->xdfss_tgt_attached);
279 			ASSERT(xsp->xdfss_tgt_holds >= 0);
280 			return (B_TRUE);
281 		}
282 	}
283 	return (B_FALSE);
284 }
285 
286 static boolean_t
287 xdfs_isopen(xdfs_state_t *xsp)
288 {
289 	int part;
290 
291 	ASSERT(MUTEX_HELD(&xsp->xdfss_mutex));
292 	for (part = 0; part < XDF_PEXT; part++) {
293 		if (xdfs_isopen_part(xsp, part))
294 			return (B_TRUE);
295 	}
296 	return (B_FALSE);
297 }
298 
299 static int
300 xdfs_iodone(struct buf *bp)
301 {
302 	struct buf	*bp_orig = bp->b_chain;
303 
304 	/* Propegate back the io results */
305 	bp_orig->b_resid = bp->b_resid;
306 	bioerror(bp_orig, geterror(bp));
307 	biodone(bp_orig);
308 
309 	freerbuf(bp);
310 	return (0);
311 }
312 
313 static int
314 xdfs_cmlb_attach(xdfs_state_t *xsp)
315 {
316 	return (cmlb_attach(xsp->xdfss_dip, &xdfs_lb_ops,
317 	    xsp->xdfss_tgt_is_cd ? DTYPE_RODIRECT : DTYPE_DIRECT,
318 	    xdf_is_rm(xsp->xdfss_tgt_dip),
319 	    B_TRUE,
320 	    xdfs_c_cmlb_node_type(xsp),
321 	    xdfs_c_cmlb_alter_behavior(xsp),
322 	    xsp->xdfss_cmlbhandle, 0));
323 }
324 
325 static boolean_t
326 xdfs_tgt_probe(xdfs_state_t *xsp, dev_info_t *tgt_dip)
327 {
328 	cmlb_geom_t		pgeom;
329 	int			tgt_instance = ddi_get_instance(tgt_dip);
330 
331 	ASSERT(MUTEX_HELD(&xsp->xdfss_mutex));
332 	ASSERT(!xdfs_isopen(xsp));
333 	ASSERT(!xsp->xdfss_tgt_attached);
334 
335 	xsp->xdfss_tgt_dip = tgt_dip;
336 	xsp->xdfss_tgt_holds = 0;
337 	xsp->xdfss_tgt_dev = makedevice(ddi_driver_major(tgt_dip),
338 	    XDF_MINOR(tgt_instance, 0));
339 	ASSERT((xsp->xdfss_tgt_dev & XDF_PMASK) == 0);
340 	xsp->xdfss_tgt_is_cd = xdf_is_cd(tgt_dip);
341 
342 	/*
343 	 * GROSS HACK ALERT!  GROSS HACK ALERT!
344 	 *
345 	 * Before we can initialize the cmlb layer, we have to tell the
346 	 * underlying xdf device what it's physical geometry should be.
347 	 * See the block comments at the top of this file for more info.
348 	 */
349 	if (!xsp->xdfss_tgt_is_cd &&
350 	    ((xdfs_c_getpgeom(xsp->xdfss_dip, &pgeom) != 0) ||
351 	    (xdf_hvm_setpgeom(xsp->xdfss_tgt_dip, &pgeom) != 0)))
352 		return (B_FALSE);
353 
354 	/*
355 	 * Force the xdf front end driver to connect to the backend.  From
356 	 * the solaris device tree perspective, the xdf driver devinfo node
357 	 * is already in the ATTACHED state.  (Otherwise xdf_hvm_hold()
358 	 * would not have returned a dip.)  But this doesn't mean that the
359 	 * xdf device has actually established a connection to it's back
360 	 * end driver.  For us to be able to access the xdf device it needs
361 	 * to be connected.
362 	 */
363 	if (!xdf_hvm_connect(xsp->xdfss_tgt_dip)) {
364 		cmn_err(CE_WARN, "pv driver failed to connect: %s",
365 		    xsp->xdfss_pv);
366 		return (B_FALSE);
367 	}
368 
369 	if (xsp->xdfss_tgt_is_cd && !xdf_media_req_supported(tgt_dip)) {
370 		/*
371 		 * Unfortunatly, the dom0 backend driver doesn't support
372 		 * important media request operations like eject, so fail
373 		 * the probe (this should cause us to fall back to emulated
374 		 * hvm device access, which does support things like eject).
375 		 */
376 		return (B_FALSE);
377 	}
378 
379 	/* create kstat for iostat(1M) */
380 	if (xdf_kstat_create(xsp->xdfss_tgt_dip, (char *)xdfs_c_name,
381 	    tgt_instance) != 0)
382 		return (B_FALSE);
383 
384 	/*
385 	 * Now we need to mark ourselves as attached and drop xdfss_mutex.
386 	 * We do this because the final steps in the attach process will
387 	 * need to access the underlying disk to read the label and
388 	 * possibly the devid.
389 	 */
390 	xsp->xdfss_tgt_attached = B_TRUE;
391 	mutex_exit(&xsp->xdfss_mutex);
392 
393 	if (!xsp->xdfss_tgt_is_cd && xdfs_c_bb_check(xsp)) {
394 		cmn_err(CE_WARN, "pv disks with bad blocks are unsupported: %s",
395 		    xsp->xdfss_hvm);
396 		mutex_enter(&xsp->xdfss_mutex);
397 		xdf_kstat_delete(xsp->xdfss_tgt_dip);
398 		xsp->xdfss_tgt_attached = B_FALSE;
399 		return (B_FALSE);
400 	}
401 
402 	/*
403 	 * Initalize cmlb.  Note that for partition information cmlb
404 	 * will access the underly xdf disk device directly via
405 	 * xdfs_lb_rdwr() and xdfs_lb_getinfo().  There are no
406 	 * layered driver handles associated with this access because
407 	 * it is a direct disk access that doesn't go through
408 	 * any of the device nodes exported by the xdf device (since
409 	 * all exported device nodes only reflect the portion of
410 	 * the device visible via the partition/slice that the node
411 	 * is associated with.)  So while not observable via the LDI,
412 	 * this direct disk access is ok since we're actually holding
413 	 * the target device.
414 	 */
415 	if (xdfs_cmlb_attach(xsp) != 0) {
416 		mutex_enter(&xsp->xdfss_mutex);
417 		xdf_kstat_delete(xsp->xdfss_tgt_dip);
418 		xsp->xdfss_tgt_attached = B_FALSE;
419 		return (B_FALSE);
420 	}
421 
422 	/* setup devid string */
423 	xsp->xdfss_tgt_devid = NULL;
424 	if (!xsp->xdfss_tgt_is_cd)
425 		xdfs_c_devid_setup(xsp);
426 
427 	(void) cmlb_validate(xsp->xdfss_cmlbhandle, 0, 0);
428 
429 	/* Have the system report any newly created device nodes */
430 	ddi_report_dev(xsp->xdfss_dip);
431 
432 	mutex_enter(&xsp->xdfss_mutex);
433 	return (B_TRUE);
434 }
435 
436 static boolean_t
437 xdfs_tgt_detach(xdfs_state_t *xsp)
438 {
439 	ASSERT(MUTEX_HELD(&xsp->xdfss_mutex));
440 	ASSERT(xsp->xdfss_tgt_attached);
441 	ASSERT(xsp->xdfss_tgt_holds >= 0);
442 
443 	if ((xdfs_isopen(xsp)) || (xsp->xdfss_tgt_holds != 0))
444 		return (B_FALSE);
445 
446 	ddi_devid_unregister(xsp->xdfss_dip);
447 	if (xsp->xdfss_tgt_devid != NULL)
448 		ddi_devid_free(xsp->xdfss_tgt_devid);
449 
450 	xdf_kstat_delete(xsp->xdfss_tgt_dip);
451 	xsp->xdfss_tgt_attached = B_FALSE;
452 	return (B_TRUE);
453 }
454 
455 /*
456  * Xdf_shell interfaces that may be called from outside this file.
457  */
458 void
459 xdfs_minphys(struct buf *bp)
460 {
461 	xdfmin(bp);
462 }
463 
464 /*
465  * Cmlb ops vector, allows the cmlb module to directly access the entire
466  * xdf disk device without going through any partitioning layers.
467  */
468 int
469 xdfs_lb_rdwr(dev_info_t *dip, uchar_t cmd, void *bufaddr,
470     diskaddr_t start, size_t count, void *tg_cookie)
471 {
472 	int		instance = ddi_get_instance(dip);
473 	xdfs_state_t	*xsp = ddi_get_soft_state(xdfs_ssp, instance);
474 	int		rv;
475 
476 	if (xsp == NULL)
477 		return (ENXIO);
478 
479 	if (!xdfs_tgt_hold(xsp))
480 		return (ENXIO);
481 
482 	rv = xdf_lb_rdwr(xsp->xdfss_tgt_dip,
483 	    cmd, bufaddr, start, count, tg_cookie);
484 
485 	xdfs_tgt_release(xsp);
486 	return (rv);
487 }
488 
489 /*
490  * Driver PV and HVM cb_ops entry points
491  */
492 /*ARGSUSED*/
493 static int
494 xdfs_open(dev_t *dev_p, int flag, int otyp, cred_t *credp)
495 {
496 	ldi_ident_t	li;
497 	dev_t		dev = *dev_p;
498 	int		instance = XDFS_DEV2UNIT(dev);
499 	int		part = XDFS_DEV2PART(dev);
500 	xdfs_state_t	*xsp = ddi_get_soft_state(xdfs_ssp, instance);
501 	dev_t		tgt_devt = xsp->xdfss_tgt_dev | part;
502 	int		err = 0;
503 
504 	if ((otyp < 0) || (otyp >= OTYPCNT))
505 		return (EINVAL);
506 
507 	if (XDFS_HVM_MODE(xsp)) {
508 		if ((xdfs_hvm_dev_ops == NULL) || (xdfs_hvm_cb_ops == NULL))
509 			return (ENOTSUP);
510 		return (xdfs_hvm_cb_ops->cb_open(dev_p, flag, otyp, credp));
511 	}
512 
513 	/* allocate an ldi handle */
514 	VERIFY(ldi_ident_from_dev(*dev_p, &li) == 0);
515 
516 	mutex_enter(&xsp->xdfss_mutex);
517 
518 	/*
519 	 * We translate all device opens (chr, blk, and lyr) into
520 	 * block device opens.  Why?  Because for all the opens that
521 	 * come through this driver, we only keep around one LDI handle.
522 	 * So that handle can only be of one open type.  The reason
523 	 * that we choose the block interface for this is that to use
524 	 * the block interfaces for a device the system needs to allocate
525 	 * buf_ts, which are associated with system memory which can act
526 	 * as a cache for device data.  So normally when a block device
527 	 * is closed the system will ensure that all these pages get
528 	 * flushed out of memory.  But if we were to open the device
529 	 * as a character device, then when we went to close the underlying
530 	 * device (even if we had invoked the block interfaces) any data
531 	 * remaining in memory wouldn't necessairly be flushed out
532 	 * before the device was closed.
533 	 */
534 	if (xsp->xdfss_tgt_lh[part] == NULL) {
535 		ASSERT(!xdfs_isopen_part(xsp, part));
536 
537 		err = ldi_open_by_dev(&tgt_devt, OTYP_BLK, flag, credp,
538 		    &xsp->xdfss_tgt_lh[part], li);
539 
540 		if (err != 0) {
541 			mutex_exit(&xsp->xdfss_mutex);
542 			ldi_ident_release(li);
543 			return (err);
544 		}
545 
546 		/* Disk devices really shouldn't clone */
547 		ASSERT(tgt_devt == (xsp->xdfss_tgt_dev | part));
548 	} else {
549 		ldi_handle_t lh_tmp;
550 
551 		ASSERT(xdfs_isopen_part(xsp, part));
552 
553 		/* do ldi open/close to get flags and cred check */
554 		err = ldi_open_by_dev(&tgt_devt, OTYP_BLK, flag, credp,
555 		    &lh_tmp, li);
556 		if (err != 0) {
557 			mutex_exit(&xsp->xdfss_mutex);
558 			ldi_ident_release(li);
559 			return (err);
560 		}
561 
562 		/* Disk devices really shouldn't clone */
563 		ASSERT(tgt_devt == (xsp->xdfss_tgt_dev | part));
564 		(void) ldi_close(lh_tmp, flag, credp);
565 	}
566 	ldi_ident_release(li);
567 
568 	xsp->xdfss_otyp_count[otyp][part]++;
569 
570 	mutex_exit(&xsp->xdfss_mutex);
571 	return (0);
572 }
573 
574 /*ARGSUSED*/
575 static int
576 xdfs_close(dev_t dev, int flag, int otyp, cred_t *credp)
577 {
578 	int		instance = XDFS_DEV2UNIT(dev);
579 	int		part = XDFS_DEV2PART(dev);
580 	xdfs_state_t	*xsp = ddi_get_soft_state(xdfs_ssp, instance);
581 	int		err = 0;
582 
583 	ASSERT((otyp >= 0) && otyp < OTYPCNT);
584 
585 	/* Sanity check the dev_t associated with this request. */
586 	ASSERT(getmajor(dev) == xdfs_major);
587 	if (getmajor(dev) != xdfs_major)
588 		return (ENXIO);
589 
590 	if (XDFS_HVM_MODE(xsp)) {
591 		if ((xdfs_hvm_dev_ops == NULL) || (xdfs_hvm_cb_ops == NULL))
592 			return (ENOTSUP);
593 		return (xdfs_hvm_cb_ops->cb_close(dev, flag, otyp, credp));
594 	}
595 
596 	/*
597 	 * Sanity check that that the device is actually open.  On debug
598 	 * kernels we'll panic and on non-debug kernels we'll return failure.
599 	 */
600 	mutex_enter(&xsp->xdfss_mutex);
601 	ASSERT(xdfs_isopen_part(xsp, part));
602 	if (!xdfs_isopen_part(xsp, part)) {
603 		mutex_exit(&xsp->xdfss_mutex);
604 		return (ENXIO);
605 	}
606 
607 	ASSERT(xsp->xdfss_tgt_lh[part] != NULL);
608 	ASSERT(xsp->xdfss_otyp_count[otyp][part] > 0);
609 	if (otyp == OTYP_LYR) {
610 		xsp->xdfss_otyp_count[otyp][part]--;
611 	} else {
612 		xsp->xdfss_otyp_count[otyp][part] = 0;
613 	}
614 
615 	if (!xdfs_isopen_part(xsp, part)) {
616 		err = ldi_close(xsp->xdfss_tgt_lh[part], flag, credp);
617 		xsp->xdfss_tgt_lh[part] = NULL;
618 	}
619 
620 	mutex_exit(&xsp->xdfss_mutex);
621 
622 	return (err);
623 }
624 
625 int
626 xdfs_strategy(struct buf *bp)
627 {
628 	dev_t		dev = bp->b_edev;
629 	int		instance = XDFS_DEV2UNIT(dev);
630 	int		part = XDFS_DEV2PART(dev);
631 	xdfs_state_t	*xsp = ddi_get_soft_state(xdfs_ssp, instance);
632 	dev_t		tgt_devt;
633 	struct buf	*bp_clone;
634 
635 	/* Sanity check the dev_t associated with this request. */
636 	ASSERT(getmajor(dev) == xdfs_major);
637 	if (getmajor(dev) != xdfs_major)
638 		goto err;
639 
640 	if (XDFS_HVM_MODE(xsp)) {
641 		if ((xdfs_hvm_dev_ops == NULL) || (xdfs_hvm_cb_ops == NULL))
642 			return (ENOTSUP);
643 		return (xdfs_hvm_cb_ops->cb_strategy(bp));
644 	}
645 
646 	/*
647 	 * Sanity checks that the dev_t associated with the buf we were
648 	 * passed corresponds to an open partition.  On debug kernels we'll
649 	 * panic and on non-debug kernels we'll return failure.
650 	 */
651 	mutex_enter(&xsp->xdfss_mutex);
652 	ASSERT(xdfs_isopen_part(xsp, part));
653 	if (!xdfs_isopen_part(xsp, part)) {
654 		mutex_exit(&xsp->xdfss_mutex);
655 		goto err;
656 	}
657 	mutex_exit(&xsp->xdfss_mutex);
658 
659 	/* clone this buffer */
660 	tgt_devt = xsp->xdfss_tgt_dev | part;
661 	bp_clone = bioclone(bp, 0, bp->b_bcount, tgt_devt, bp->b_blkno,
662 	    xdfs_iodone, NULL, KM_SLEEP);
663 	bp_clone->b_chain = bp;
664 
665 	/*
666 	 * If we're being invoked on behalf of the physio() call in
667 	 * xdfs_dioctl_rwcmd() then b_private will be set to
668 	 * XB_SLICE_NONE and we need to propegate this flag into the
669 	 * cloned buffer so that the xdf driver will see it.
670 	 */
671 	if (bp->b_private == (void *)XB_SLICE_NONE)
672 		bp_clone->b_private = (void *)XB_SLICE_NONE;
673 
674 	/*
675 	 * Pass on the cloned buffer.  Note that we don't bother to check
676 	 * for failure because the xdf strategy routine will have to
677 	 * invoke biodone() if it wants to return an error, which means
678 	 * that the xdfs_iodone() callback will get invoked and it
679 	 * will propegate the error back up the stack and free the cloned
680 	 * buffer.
681 	 */
682 	ASSERT(xsp->xdfss_tgt_lh[part] != NULL);
683 	return (ldi_strategy(xsp->xdfss_tgt_lh[part], bp_clone));
684 
685 err:
686 	bioerror(bp, ENXIO);
687 	bp->b_resid = bp->b_bcount;
688 	biodone(bp);
689 	return (0);
690 }
691 
692 static int
693 xdfs_dump(dev_t dev, caddr_t addr, daddr_t blkno, int nblk)
694 {
695 	int		instance = XDFS_DEV2UNIT(dev);
696 	int		part = XDFS_DEV2PART(dev);
697 	xdfs_state_t	*xsp = ddi_get_soft_state(xdfs_ssp, instance);
698 
699 	if (!XDFS_HVM_MODE(xsp))
700 		return (ldi_dump(xsp->xdfss_tgt_lh[part], addr, blkno, nblk));
701 
702 	if ((xdfs_hvm_dev_ops == NULL) || (xdfs_hvm_cb_ops == NULL))
703 		return (ENOTSUP);
704 	return (xdfs_hvm_cb_ops->cb_dump(dev, addr, blkno, nblk));
705 }
706 
707 /*ARGSUSED*/
708 static int
709 xdfs_read(dev_t dev, struct uio *uio, cred_t *credp)
710 {
711 	int		instance = XDFS_DEV2UNIT(dev);
712 	int		part = XDFS_DEV2PART(dev);
713 	xdfs_state_t	*xsp = ddi_get_soft_state(xdfs_ssp, instance);
714 
715 	if (!XDFS_HVM_MODE(xsp))
716 		return (ldi_read(xsp->xdfss_tgt_lh[part], uio, credp));
717 
718 	if ((xdfs_hvm_dev_ops == NULL) || (xdfs_hvm_cb_ops == NULL))
719 		return (ENOTSUP);
720 	return (xdfs_hvm_cb_ops->cb_read(dev, uio, credp));
721 }
722 
723 /*ARGSUSED*/
724 static int
725 xdfs_write(dev_t dev, struct uio *uio, cred_t *credp)
726 {
727 	int		instance = XDFS_DEV2UNIT(dev);
728 	int		part = XDFS_DEV2PART(dev);
729 	xdfs_state_t	*xsp = ddi_get_soft_state(xdfs_ssp, instance);
730 
731 	if (!XDFS_HVM_MODE(xsp))
732 		return (ldi_write(xsp->xdfss_tgt_lh[part], uio, credp));
733 
734 	if ((xdfs_hvm_dev_ops == NULL) || (xdfs_hvm_cb_ops == NULL))
735 		return (ENOTSUP);
736 	return (xdfs_hvm_cb_ops->cb_write(dev, uio, credp));
737 }
738 
739 /*ARGSUSED*/
740 static int
741 xdfs_aread(dev_t dev, struct aio_req *aio, cred_t *credp)
742 {
743 	int		instance = XDFS_DEV2UNIT(dev);
744 	int		part = XDFS_DEV2PART(dev);
745 	xdfs_state_t	*xsp = ddi_get_soft_state(xdfs_ssp, instance);
746 
747 	if (!XDFS_HVM_MODE(xsp))
748 		return (ldi_aread(xsp->xdfss_tgt_lh[part], aio, credp));
749 
750 	if ((xdfs_hvm_dev_ops == NULL) || (xdfs_hvm_cb_ops == NULL) ||
751 	    (xdfs_hvm_cb_ops->cb_strategy == NULL) ||
752 	    (xdfs_hvm_cb_ops->cb_strategy == nodev) ||
753 	    (xdfs_hvm_cb_ops->cb_aread == NULL))
754 		return (ENOTSUP);
755 	return (xdfs_hvm_cb_ops->cb_aread(dev, aio, credp));
756 }
757 
758 /*ARGSUSED*/
759 static int
760 xdfs_awrite(dev_t dev, struct aio_req *aio, cred_t *credp)
761 {
762 	int		instance = XDFS_DEV2UNIT(dev);
763 	int		part = XDFS_DEV2PART(dev);
764 	xdfs_state_t	*xsp = ddi_get_soft_state(xdfs_ssp, instance);
765 
766 	if (!XDFS_HVM_MODE(xsp))
767 		return (ldi_awrite(xsp->xdfss_tgt_lh[part], aio, credp));
768 
769 	if ((xdfs_hvm_dev_ops == NULL) || (xdfs_hvm_cb_ops == NULL) ||
770 	    (xdfs_hvm_cb_ops->cb_strategy == NULL) ||
771 	    (xdfs_hvm_cb_ops->cb_strategy == nodev) ||
772 	    (xdfs_hvm_cb_ops->cb_awrite == NULL))
773 		return (ENOTSUP);
774 	return (xdfs_hvm_cb_ops->cb_awrite(dev, aio, credp));
775 }
776 
777 static int
778 xdfs_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *credp,
779     int *rvalp)
780 {
781 	int		instance = XDFS_DEV2UNIT(dev);
782 	int		part = XDFS_DEV2PART(dev);
783 	xdfs_state_t	*xsp = ddi_get_soft_state(xdfs_ssp, instance);
784 	int		rv;
785 	boolean_t	done;
786 
787 	if (XDFS_HVM_MODE(xsp)) {
788 		if ((xdfs_hvm_dev_ops == NULL) || (xdfs_hvm_cb_ops == NULL))
789 			return (ENOTSUP);
790 		return (xdfs_hvm_cb_ops->cb_ioctl(
791 		    dev, cmd, arg, flag, credp, rvalp));
792 	}
793 
794 	rv = xdfs_c_ioctl(xsp, dev, part, cmd, arg, flag, credp, rvalp, &done);
795 	if (done)
796 		return (rv);
797 	rv = ldi_ioctl(xsp->xdfss_tgt_lh[part], cmd, arg, flag, credp, rvalp);
798 	if (rv == 0) {
799 		/* Force Geometry Validation */
800 		(void) cmlb_invalidate(xsp->xdfss_cmlbhandle, 0);
801 		(void) cmlb_validate(xsp->xdfss_cmlbhandle, 0, 0);
802 	}
803 	return (rv);
804 }
805 
806 static int
807 xdfs_hvm_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
808     int flags, char *name, caddr_t valuep, int *lengthp)
809 {
810 	int		instance = ddi_get_instance(dip);
811 	void		*xsp = ddi_get_soft_state(xdfs_ssp, instance);
812 
813 	ASSERT(XDFS_HVM_MODE(xsp));
814 
815 	if ((xdfs_hvm_dev_ops == NULL) || (xdfs_hvm_cb_ops == NULL) ||
816 	    (xdfs_hvm_cb_ops->cb_prop_op == NULL) ||
817 	    (xdfs_hvm_cb_ops->cb_prop_op == nodev) ||
818 	    (xdfs_hvm_cb_ops->cb_prop_op == nulldev))
819 		return (DDI_PROP_NOT_FOUND);
820 
821 	return (xdfs_hvm_cb_ops->cb_prop_op(dev, dip, prop_op,
822 	    flags, name, valuep, lengthp));
823 }
824 
825 static int
826 xdfs_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
827     int flags, char *name, caddr_t valuep, int *lengthp)
828 {
829 	int		instance = ddi_get_instance(dip);
830 	xdfs_state_t	*xsp = ddi_get_soft_state(xdfs_ssp, instance);
831 	int		rv;
832 	dev_info_t	*tgt_dip;
833 	dev_t		tgt_devt;
834 
835 	/*
836 	 * Sanity check that if a dev_t or dip were specified that they
837 	 * correspond to this device driver.  On debug kernels we'll
838 	 * panic and on non-debug kernels we'll return failure.
839 	 */
840 	ASSERT(ddi_driver_major(dip) == xdfs_major);
841 	ASSERT((dev == DDI_DEV_T_ANY) || (getmajor(dev) == xdfs_major));
842 	if ((ddi_driver_major(dip) != xdfs_major) ||
843 	    ((dev != DDI_DEV_T_ANY) && (getmajor(dev) != xdfs_major)))
844 		return (DDI_PROP_NOT_FOUND);
845 
846 	/*
847 	 * This property lookup might be associated with a device node
848 	 * that is not yet attached, if so pass it onto ddi_prop_op().
849 	 */
850 	if (xsp == NULL)
851 		return (ddi_prop_op(dev, dip, prop_op, flags,
852 		    name, valuep, lengthp));
853 
854 	/* If we're accessing the device in hvm mode, pass this request on */
855 	if (XDFS_HVM_MODE(xsp))
856 		return (xdfs_hvm_prop_op(dev, dip, prop_op,
857 		    flags, name, valuep, lengthp));
858 
859 	/*
860 	 * Make sure we only lookup static properties.
861 	 *
862 	 * If there are static properties of the underlying xdf driver
863 	 * that we want to mirror, then we'll have to explicity look them
864 	 * up and define them during attach.  There are a few reasons
865 	 * for this.  Most importantly, most static properties are typed
866 	 * and all dynamic properties are untyped, ie, for dynamic
867 	 * properties the caller must know the type of the property and
868 	 * how to interpret the value of the property.  the prop_op drivedr
869 	 * entry point is only designed for returning dynamic/untyped
870 	 * properties, so if we were to attempt to lookup and pass back
871 	 * static properties of the underlying device here then we would
872 	 * be losing the type information for those properties.  Another
873 	 * reason we don't want to pass on static property requests is that
874 	 * static properties are enumerable in the device tree, where as
875 	 * dynamic ones are not.
876 	 */
877 	flags |= DDI_PROP_DYNAMIC;
878 
879 	/*
880 	 * We can't use the ldi here to access the underlying device because
881 	 * the ldi actually opens the device, and that open might fail if the
882 	 * device has already been opened with the FEXCL flag.  If we used
883 	 * the ldi here, it would also be possible for some other caller to
884 	 * try open the device with the FEXCL flag and get a failure back
885 	 * because we have it open to do a property query.  Instad we'll
886 	 * grab a hold on the target dip.
887 	 */
888 	if (!xdfs_tgt_hold(xsp))
889 		return (DDI_PROP_NOT_FOUND);
890 
891 	/* figure out dip the dev_t we're going to pass on down */
892 	tgt_dip = xsp->xdfss_tgt_dip;
893 	if (dev == DDI_DEV_T_ANY) {
894 		tgt_devt = DDI_DEV_T_ANY;
895 	} else {
896 		tgt_devt = xsp->xdfss_tgt_dev | XDFS_DEV2PART(dev);
897 	}
898 
899 	/*
900 	 * Cdev_prop_op() is not a public interface, and normally the caller
901 	 * is required to make sure that the target driver actually implements
902 	 * this interface before trying to invoke it.  In this case we know
903 	 * that we're always accessing the xdf driver and it does have this
904 	 * interface defined, so we can skip the check.
905 	 */
906 	rv = cdev_prop_op(tgt_devt, tgt_dip,
907 	    prop_op, flags, name, valuep, lengthp);
908 
909 	xdfs_tgt_release(xsp);
910 	return (rv);
911 }
912 
913 /*
914  * Driver PV and HVM dev_ops entry points
915  */
916 /*ARGSUSED*/
917 static int
918 xdfs_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
919     void **result)
920 {
921 	dev_t		dev = (dev_t)arg;
922 	int		instance = XDFS_DEV2UNIT(dev);
923 	xdfs_state_t	*xsp = ddi_get_soft_state(xdfs_ssp, instance);
924 
925 	switch (infocmd) {
926 		case DDI_INFO_DEVT2DEVINFO:
927 			if (xsp == NULL)
928 				return (DDI_FAILURE);
929 			if (XDFS_HVM_MODE(xsp))
930 				*result = XDFS_HVM_DIP(xsp);
931 			else
932 				*result = (void *)xsp->xdfss_dip;
933 			break;
934 		case DDI_INFO_DEVT2INSTANCE:
935 			*result = (void *)(intptr_t)instance;
936 			break;
937 		default:
938 			return (DDI_FAILURE);
939 	}
940 	return (DDI_SUCCESS);
941 }
942 
943 static int
944 xdfs_hvm_probe(dev_info_t *dip, char *path)
945 {
946 	int		instance = ddi_get_instance(dip);
947 	int		rv = DDI_PROBE_SUCCESS;
948 	void		*xsp;
949 
950 	ASSERT(path != NULL);
951 	cmn_err(CE_WARN, "PV access to device disabled: %s", path);
952 
953 	(void) ddi_soft_state_zalloc(xdfs_ssp, instance);
954 	VERIFY((xsp = ddi_get_soft_state(xdfs_ssp, instance)) != NULL);
955 
956 	if ((xdfs_hvm_dev_ops == NULL) ||
957 	    (xdfs_hvm_dev_ops->devo_probe == NULL) ||
958 	    ((rv = xdfs_hvm_dev_ops->devo_probe(dip)) == DDI_PROBE_FAILURE)) {
959 		ddi_soft_state_free(xdfs_ssp, instance);
960 		cmn_err(CE_WARN, "HVM probe of device failed: %s", path);
961 		kmem_free(path, MAXPATHLEN);
962 		return (DDI_PROBE_FAILURE);
963 	}
964 
965 	XDFS_HVM_MODE(xsp) = B_TRUE;
966 	XDFS_HVM_DIP(xsp) = dip;
967 	XDFS_HVM_PATH(xsp) = path;
968 
969 	return (rv);
970 }
971 
972 static int
973 xdfs_probe(dev_info_t *dip)
974 {
975 	int		instance = ddi_get_instance(dip);
976 	xdfs_state_t	*xsp;
977 	dev_info_t	*tgt_dip;
978 	char		*path;
979 	int		i, pv_disable;
980 
981 	/* if we've already probed the device then there's nothing todo */
982 	if (ddi_get_soft_state(xdfs_ssp, instance))
983 		return (DDI_PROBE_PARTIAL);
984 
985 	/* Figure out our pathname */
986 	path = kmem_alloc(MAXPATHLEN, KM_SLEEP);
987 	(void) ddi_pathname(dip, path);
988 
989 	/* see if we should disable pv access mode */
990 	pv_disable = ddi_prop_get_int(DDI_DEV_T_ANY,
991 	    dip, DDI_PROP_NOTPROM, "pv_disable", 0);
992 
993 	if (xdfs_pv_disable || pv_disable)
994 		return (xdfs_hvm_probe(dip, path));
995 
996 	/*
997 	 * This xdf shell device layers on top of an xdf device.  So the first
998 	 * thing we need to do is determine which xdf device instance this
999 	 * xdf shell instance should be layered on top of.
1000 	 */
1001 	for (i = 0; xdfs_c_h2p_map[i].xdfs_h2p_hvm != NULL; i++) {
1002 		if (strcmp(xdfs_c_h2p_map[i].xdfs_h2p_hvm, path) == 0)
1003 			break;
1004 	}
1005 
1006 	if ((xdfs_c_h2p_map[i].xdfs_h2p_hvm == NULL) ||
1007 	    ((tgt_dip = xdf_hvm_hold(xdfs_c_h2p_map[i].xdfs_h2p_pv)) == NULL)) {
1008 		/*
1009 		 * UhOh.  We either don't know what xdf instance this xdf
1010 		 * shell device should be mapped to or the xdf node assocaited
1011 		 * with this instance isnt' attached.  in either case fall
1012 		 * back to hvm access.
1013 		 */
1014 		return (xdfs_hvm_probe(dip, path));
1015 	}
1016 
1017 	/* allocate and initialize our state structure */
1018 	(void) ddi_soft_state_zalloc(xdfs_ssp, instance);
1019 	xsp = ddi_get_soft_state(xdfs_ssp, instance);
1020 	mutex_init(&xsp->xdfss_mutex, NULL, MUTEX_DRIVER, NULL);
1021 	cv_init(&xsp->xdfss_cv, NULL, CV_DEFAULT, NULL);
1022 	mutex_enter(&xsp->xdfss_mutex);
1023 
1024 	xsp->xdfss_dip = dip;
1025 	xsp->xdfss_pv = xdfs_c_h2p_map[i].xdfs_h2p_pv;
1026 	xsp->xdfss_hvm = xdfs_c_h2p_map[i].xdfs_h2p_hvm;
1027 	xsp->xdfss_tgt_attached = B_FALSE;
1028 	cmlb_alloc_handle((cmlb_handle_t *)&xsp->xdfss_cmlbhandle);
1029 
1030 	if (!xdfs_tgt_probe(xsp, tgt_dip)) {
1031 		mutex_exit(&xsp->xdfss_mutex);
1032 		cmlb_free_handle(&xsp->xdfss_cmlbhandle);
1033 		ddi_soft_state_free(xdfs_ssp, instance);
1034 		ddi_release_devi(tgt_dip);
1035 		return (xdfs_hvm_probe(dip, path));
1036 	}
1037 	mutex_exit(&xsp->xdfss_mutex);
1038 
1039 	/*
1040 	 * Add a zero-length attribute to tell the world we support
1041 	 * kernel ioctls (for layered drivers).
1042 	 */
1043 	(void) ddi_prop_create(DDI_DEV_T_NONE, dip, DDI_PROP_CANSLEEP,
1044 	    DDI_KERNEL_IOCTL, NULL, 0);
1045 
1046 	kmem_free(path, MAXPATHLEN);
1047 	return (DDI_PROBE_SUCCESS);
1048 }
1049 
1050 static int
1051 xdfs_hvm_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
1052 {
1053 	int		instance = ddi_get_instance(dip);
1054 	void		*xsp = ddi_get_soft_state(xdfs_ssp, instance);
1055 	int		rv = DDI_FAILURE;
1056 
1057 	XDFS_HVM_SANE(xsp);
1058 
1059 	if ((xdfs_hvm_dev_ops == NULL) ||
1060 	    (xdfs_hvm_dev_ops->devo_attach == NULL) ||
1061 	    ((rv = xdfs_hvm_dev_ops->devo_attach(dip, cmd)) != DDI_SUCCESS)) {
1062 		cmn_err(CE_WARN, "HVM attach of device failed: %s",
1063 		    XDFS_HVM_PATH(xsp));
1064 		kmem_free(XDFS_HVM_PATH(xsp), MAXPATHLEN);
1065 		ddi_soft_state_free(xdfs_ssp, instance);
1066 		return (rv);
1067 	}
1068 
1069 	return (DDI_SUCCESS);
1070 }
1071 
1072 /*
1073  * Autoconfiguration Routines
1074  */
1075 static int
1076 xdfs_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
1077 {
1078 	int		instance = ddi_get_instance(dip);
1079 	xdfs_state_t	*xsp = ddi_get_soft_state(xdfs_ssp, instance);
1080 
1081 	if (xsp == NULL)
1082 		return (DDI_FAILURE);
1083 	if (XDFS_HVM_MODE(xsp))
1084 		return (xdfs_hvm_attach(dip, cmd));
1085 	if (cmd != DDI_ATTACH)
1086 		return (DDI_FAILURE);
1087 
1088 	xdfs_c_attach(xsp);
1089 	return (DDI_SUCCESS);
1090 }
1091 
1092 static int
1093 xdfs_hvm_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
1094 {
1095 	int		instance = ddi_get_instance(dip);
1096 	void		*xsp = ddi_get_soft_state(xdfs_ssp, instance);
1097 	int		rv;
1098 
1099 	XDFS_HVM_SANE(xsp);
1100 
1101 	if ((xdfs_hvm_dev_ops == NULL) ||
1102 	    (xdfs_hvm_dev_ops->devo_detach == NULL))
1103 		return (DDI_FAILURE);
1104 
1105 	if ((rv = xdfs_hvm_dev_ops->devo_detach(dip, cmd)) != DDI_SUCCESS)
1106 		return (rv);
1107 
1108 	kmem_free(XDFS_HVM_PATH(xsp), MAXPATHLEN);
1109 	ddi_soft_state_free(xdfs_ssp, instance);
1110 	return (DDI_SUCCESS);
1111 }
1112 
1113 static int
1114 xdfs_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
1115 {
1116 	int		instance = ddi_get_instance(dip);
1117 	xdfs_state_t	*xsp = ddi_get_soft_state(xdfs_ssp, instance);
1118 
1119 	if (XDFS_HVM_MODE(xsp))
1120 		return (xdfs_hvm_detach(dip, cmd));
1121 	if (cmd != DDI_DETACH)
1122 		return (DDI_FAILURE);
1123 
1124 	mutex_enter(&xsp->xdfss_mutex);
1125 	if (!xdfs_tgt_detach(xsp)) {
1126 		mutex_exit(&xsp->xdfss_mutex);
1127 		return (DDI_FAILURE);
1128 	}
1129 	mutex_exit(&xsp->xdfss_mutex);
1130 
1131 	cmlb_detach(xsp->xdfss_cmlbhandle, 0);
1132 	cmlb_free_handle(&xsp->xdfss_cmlbhandle);
1133 	ddi_release_devi(xsp->xdfss_tgt_dip);
1134 	ddi_soft_state_free(xdfs_ssp, instance);
1135 	ddi_prop_remove_all(dip);
1136 	return (DDI_SUCCESS);
1137 }
1138 
1139 static int
1140 xdfs_hvm_power(dev_info_t *dip, int component, int level)
1141 {
1142 	int		instance = ddi_get_instance(dip);
1143 	void		*xsp = ddi_get_soft_state(xdfs_ssp, instance);
1144 
1145 	XDFS_HVM_SANE(xsp);
1146 
1147 	if ((xdfs_hvm_dev_ops == NULL) ||
1148 	    (xdfs_hvm_dev_ops->devo_power == NULL))
1149 		return (DDI_FAILURE);
1150 	return (xdfs_hvm_dev_ops->devo_power(dip, component, level));
1151 }
1152 
1153 static int
1154 xdfs_power(dev_info_t *dip, int component, int level)
1155 {
1156 	int		instance = ddi_get_instance(dip);
1157 	xdfs_state_t	*xsp = ddi_get_soft_state(xdfs_ssp, instance);
1158 
1159 	if (XDFS_HVM_MODE(xsp))
1160 		return (xdfs_hvm_power(dip, component, level));
1161 	return (nodev());
1162 }
1163 
1164 /*
1165  * Cmlb ops vector
1166  */
1167 static cmlb_tg_ops_t xdfs_lb_ops = {
1168 	TG_DK_OPS_VERSION_1,
1169 	xdfs_lb_rdwr,
1170 	xdfs_lb_getinfo
1171 };
1172 
1173 /*
1174  * Device driver ops vector
1175  */
1176 static struct cb_ops xdfs_cb_ops = {
1177 	xdfs_open,		/* open */
1178 	xdfs_close,		/* close */
1179 	xdfs_strategy,		/* strategy */
1180 	nodev,			/* print */
1181 	xdfs_dump,		/* dump */
1182 	xdfs_read,		/* read */
1183 	xdfs_write,		/* write */
1184 	xdfs_ioctl,		/* ioctl */
1185 	nodev,			/* devmap */
1186 	nodev,			/* mmap */
1187 	nodev,			/* segmap */
1188 	nochpoll,		/* poll */
1189 	xdfs_prop_op,		/* cb_prop_op */
1190 	0,			/* streamtab  */
1191 	D_64BIT | D_MP | D_NEW,	/* Driver comaptibility flag */
1192 	CB_REV,			/* cb_rev */
1193 	xdfs_aread,		/* async read */
1194 	xdfs_awrite		/* async write */
1195 };
1196 
1197 struct dev_ops xdfs_ops = {
1198 	DEVO_REV,		/* devo_rev, */
1199 	0,			/* refcnt  */
1200 	xdfs_getinfo,		/* info */
1201 	nulldev,		/* identify */
1202 	xdfs_probe,		/* probe */
1203 	xdfs_attach,		/* attach */
1204 	xdfs_detach,		/* detach */
1205 	nodev,			/* reset */
1206 	&xdfs_cb_ops,		/* driver operations */
1207 	NULL,			/* bus operations */
1208 	xdfs_power,		/* power */
1209 	ddi_quiesce_not_supported, /* devo_quiesce */
1210 };
1211 
1212 /*
1213  * Module linkage information for the kernel.
1214  */
1215 static struct modldrv modldrv = {
1216 	&mod_driverops,		/* Type of module.  This one is a driver. */
1217 	NULL,			/* Module description.  Set by _init() */
1218 	&xdfs_ops,		/* Driver ops. */
1219 };
1220 
1221 static struct modlinkage modlinkage = {
1222 	MODREV_1, (void *)&modldrv, NULL
1223 };
1224 
1225 int
1226 _init(void)
1227 {
1228 	int rval;
1229 
1230 	xdfs_major = ddi_name_to_major((char *)xdfs_c_name);
1231 	if (xdfs_major == (major_t)-1)
1232 		return (EINVAL);
1233 
1234 	/*
1235 	 * Determine the size of our soft state structure.  The base
1236 	 * size of the structure is the larger of the hvm clients state
1237 	 * structure, or our shell state structure.  Then we'll align
1238 	 * the end of the structure to a pointer boundry and append
1239 	 * a xdfs_hvm_state_t structure.  This way the xdfs_hvm_state_t
1240 	 * structure is always present and we can use it to determine the
1241 	 * current device access mode (hvm or shell).
1242 	 */
1243 	xdfs_ss_size = MAX(xdfs_c_hvm_ss_size, sizeof (xdfs_state_t));
1244 	xdfs_ss_size = P2ROUNDUP(xdfs_ss_size, sizeof (uintptr_t));
1245 	xdfs_ss_size += sizeof (xdfs_hvm_state_t);
1246 
1247 	/*
1248 	 * In general ide usually supports 4 disk devices, this same
1249 	 * limitation also applies to software emulating ide devices.
1250 	 * so by default we pre-allocate 4 xdf shell soft state structures.
1251 	 */
1252 	if ((rval = ddi_soft_state_init(&xdfs_ssp,
1253 	    xdfs_ss_size, XDFS_NODES)) != 0)
1254 		return (rval);
1255 	*xdfs_c_hvm_ss = xdfs_ssp;
1256 
1257 	/* Install our module */
1258 	if (modldrv.drv_linkinfo == NULL)
1259 		modldrv.drv_linkinfo = (char *)xdfs_c_linkinfo;
1260 	if ((rval = mod_install(&modlinkage)) != 0) {
1261 		ddi_soft_state_fini(&xdfs_ssp);
1262 		return (rval);
1263 	}
1264 
1265 	return (0);
1266 }
1267 
1268 int
1269 _info(struct modinfo *modinfop)
1270 {
1271 	if (modldrv.drv_linkinfo == NULL)
1272 		modldrv.drv_linkinfo = (char *)xdfs_c_linkinfo;
1273 	return (mod_info(&modlinkage, modinfop));
1274 }
1275 
1276 int
1277 _fini(void)
1278 {
1279 	int	rval;
1280 	if ((rval = mod_remove(&modlinkage)) != 0)
1281 		return (rval);
1282 	ddi_soft_state_fini(&xdfs_ssp);
1283 	return (0);
1284 }
1285