xref: /titanic_41/usr/src/uts/sun4v/io/vds.c (revision 6a634c9dca3093f3922e4b7ab826d7bdf17bf78e)
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 (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
24  */
25 
26 /*
27  * Virtual disk server
28  */
29 
30 
31 #include <sys/types.h>
32 #include <sys/conf.h>
33 #include <sys/crc32.h>
34 #include <sys/ddi.h>
35 #include <sys/dkio.h>
36 #include <sys/file.h>
37 #include <sys/fs/hsfs_isospec.h>
38 #include <sys/mdeg.h>
39 #include <sys/mhd.h>
40 #include <sys/modhash.h>
41 #include <sys/note.h>
42 #include <sys/pathname.h>
43 #include <sys/sdt.h>
44 #include <sys/sunddi.h>
45 #include <sys/sunldi.h>
46 #include <sys/sysmacros.h>
47 #include <sys/vio_common.h>
48 #include <sys/vio_util.h>
49 #include <sys/vdsk_mailbox.h>
50 #include <sys/vdsk_common.h>
51 #include <sys/vtoc.h>
52 #include <sys/vfs.h>
53 #include <sys/stat.h>
54 #include <sys/scsi/impl/uscsi.h>
55 #include <sys/ontrap.h>
56 #include <vm/seg_map.h>
57 
58 #define	ONE_MEGABYTE	(1ULL << 20)
59 #define	ONE_GIGABYTE	(1ULL << 30)
60 #define	ONE_TERABYTE	(1ULL << 40)
61 
62 /* Virtual disk server initialization flags */
63 #define	VDS_LDI			0x01
64 #define	VDS_MDEG		0x02
65 
66 /* Virtual disk server tunable parameters */
67 #define	VDS_RETRIES		5
68 #define	VDS_LDC_DELAY		1000 /* 1 msecs */
69 #define	VDS_DEV_DELAY		10000000 /* 10 secs */
70 #define	VDS_NCHAINS		32
71 
72 /* Identification parameters for MD, synthetic dkio(7i) structures, etc. */
73 #define	VDS_NAME		"virtual-disk-server"
74 
75 #define	VD_NAME			"vd"
76 #define	VD_VOLUME_NAME		"vdisk"
77 #define	VD_ASCIILABEL		"Virtual Disk"
78 
79 #define	VD_CHANNEL_ENDPOINT	"channel-endpoint"
80 #define	VD_ID_PROP		"id"
81 #define	VD_BLOCK_DEVICE_PROP	"vds-block-device"
82 #define	VD_BLOCK_DEVICE_OPTS	"vds-block-device-opts"
83 #define	VD_REG_PROP		"reg"
84 
85 /* Virtual disk initialization flags */
86 #define	VD_DISK_READY		0x01
87 #define	VD_LOCKING		0x02
88 #define	VD_LDC			0x04
89 #define	VD_DRING		0x08
90 #define	VD_SID			0x10
91 #define	VD_SEQ_NUM		0x20
92 #define	VD_SETUP_ERROR		0x40
93 
94 /* Number of backup labels */
95 #define	VD_DSKIMG_NUM_BACKUP	5
96 
97 /* Timeout for SCSI I/O */
98 #define	VD_SCSI_RDWR_TIMEOUT	30	/* 30 secs */
99 
100 /*
101  * Default number of threads for the I/O queue. In many cases, we will not
102  * receive more than 8 I/O requests at the same time. However there are
103  * cases (for example during the OS installation) where we can have a lot
104  * more (up to the limit of the DRing size).
105  */
106 #define	VD_IOQ_NTHREADS		8
107 
108 /* Maximum number of logical partitions */
109 #define	VD_MAXPART	(NDKMAP + 1)
110 
111 /*
112  * By Solaris convention, slice/partition 2 represents the entire disk;
113  * unfortunately, this convention does not appear to be codified.
114  */
115 #define	VD_ENTIRE_DISK_SLICE	2
116 
117 /* Logical block address for EFI */
118 #define	VD_EFI_LBA_GPT		1	/* LBA of the GPT */
119 #define	VD_EFI_LBA_GPE		2	/* LBA of the GPE */
120 
121 #define	VD_EFI_DEV_SET(dev, vdsk, ioctl)	\
122 	VDSK_EFI_DEV_SET(dev, vdsk, ioctl,	\
123 	    (vdsk)->vdisk_bsize, (vdsk)->vdisk_size)
124 
125 /*
126  * Flags defining the behavior for flushing asynchronous writes used to
127  * performed some write I/O requests.
128  *
129  * The VD_AWFLUSH_IMMEDIATE enables immediate flushing of asynchronous
130  * writes. This ensures that data are committed to the backend when the I/O
131  * request reply is sent to the guest domain so this prevents any data to
132  * be lost in case a service domain unexpectedly crashes.
133  *
134  * The flag VD_AWFLUSH_DEFER indicates that flushing is deferred to another
135  * thread while the request is immediatly marked as completed. In that case,
136  * a guest domain can a receive a reply that its write request is completed
137  * while data haven't been flushed to disk yet.
138  *
139  * Flags VD_AWFLUSH_IMMEDIATE and VD_AWFLUSH_DEFER are mutually exclusive.
140  */
141 #define	VD_AWFLUSH_IMMEDIATE	0x01	/* immediate flushing */
142 #define	VD_AWFLUSH_DEFER	0x02	/* defer flushing */
143 #define	VD_AWFLUSH_GROUP	0x04	/* group requests before flushing */
144 
145 /* Driver types */
146 typedef enum vd_driver {
147 	VD_DRIVER_UNKNOWN = 0,	/* driver type unknown  */
148 	VD_DRIVER_DISK,		/* disk driver */
149 	VD_DRIVER_VOLUME	/* volume driver */
150 } vd_driver_t;
151 
152 #define	VD_DRIVER_NAME_LEN	64
153 
154 #define	VDS_NUM_DRIVERS	(sizeof (vds_driver_types) / sizeof (vd_driver_type_t))
155 
156 typedef struct vd_driver_type {
157 	char name[VD_DRIVER_NAME_LEN];	/* driver name */
158 	vd_driver_t type;		/* driver type (disk or volume) */
159 } vd_driver_type_t;
160 
161 /*
162  * There is no reliable way to determine if a device is representing a disk
163  * or a volume, especially with pseudo devices. So we maintain a list of well
164  * known drivers and the type of device they represent (either a disk or a
165  * volume).
166  *
167  * The list can be extended by adding a "driver-type-list" entry in vds.conf
168  * with the following syntax:
169  *
170  * 	driver-type-list="<driver>:<type>", ... ,"<driver>:<type>";
171  *
172  * Where:
173  *	<driver> is the name of a driver (limited to 64 characters)
174  *	<type> is either the string "disk" or "volume"
175  *
176  * Invalid entries in "driver-type-list" will be ignored.
177  *
178  * For example, the following line in vds.conf:
179  *
180  * 	driver-type-list="foo:disk","bar:volume";
181  *
182  * defines that "foo" is a disk driver, and driver "bar" is a volume driver.
183  *
184  * When a list is defined in vds.conf, it is checked before the built-in list
185  * (vds_driver_types[]) so that any definition from this list can be overriden
186  * using vds.conf.
187  */
188 vd_driver_type_t vds_driver_types[] = {
189 	{ "dad",	VD_DRIVER_DISK },	/* Solaris */
190 	{ "did",	VD_DRIVER_DISK },	/* Sun Cluster */
191 	{ "dlmfdrv",	VD_DRIVER_DISK },	/* Hitachi HDLM */
192 	{ "emcp",	VD_DRIVER_DISK },	/* EMC Powerpath */
193 	{ "lofi",	VD_DRIVER_VOLUME },	/* Solaris */
194 	{ "md",		VD_DRIVER_VOLUME },	/* Solaris - SVM */
195 	{ "sd",		VD_DRIVER_DISK },	/* Solaris */
196 	{ "ssd",	VD_DRIVER_DISK },	/* Solaris */
197 	{ "vdc",	VD_DRIVER_DISK },	/* Solaris */
198 	{ "vxdmp",	VD_DRIVER_DISK },	/* Veritas */
199 	{ "vxio",	VD_DRIVER_VOLUME },	/* Veritas - VxVM */
200 	{ "zfs",	VD_DRIVER_VOLUME }	/* Solaris */
201 };
202 
203 /* Return a cpp token as a string */
204 #define	STRINGIZE(token)	#token
205 
206 /*
207  * Print a message prefixed with the current function name to the message log
208  * (and optionally to the console for verbose boots); these macros use cpp's
209  * concatenation of string literals and C99 variable-length-argument-list
210  * macros
211  */
212 #define	PRN(...)	_PRN("?%s():  "__VA_ARGS__, "")
213 #define	_PRN(format, ...)					\
214 	cmn_err(CE_CONT, format"%s", __func__, __VA_ARGS__)
215 
216 /* Return a pointer to the "i"th vdisk dring element */
217 #define	VD_DRING_ELEM(i)	((vd_dring_entry_t *)(void *)	\
218 	    (vd->dring + (i)*vd->descriptor_size))
219 
220 /* Return the virtual disk client's type as a string (for use in messages) */
221 #define	VD_CLIENT(vd)							\
222 	(((vd)->xfer_mode == VIO_DESC_MODE) ? "in-band client" :	\
223 	    (((vd)->xfer_mode == VIO_DRING_MODE_V1_0) ? "dring client" :    \
224 		(((vd)->xfer_mode == 0) ? "null client" :		\
225 		    "unsupported client")))
226 
227 /* Read disk label from a disk image */
228 #define	VD_DSKIMG_LABEL_READ(vd, labelp) \
229 	vd_dskimg_rw(vd, VD_SLICE_NONE, VD_OP_BREAD, (caddr_t)labelp, \
230 	    0, sizeof (struct dk_label))
231 
232 /* Write disk label to a disk image */
233 #define	VD_DSKIMG_LABEL_WRITE(vd, labelp)	\
234 	vd_dskimg_rw(vd, VD_SLICE_NONE, VD_OP_BWRITE, (caddr_t)labelp, \
235 	    0, sizeof (struct dk_label))
236 
237 /* Identify if a backend is a disk image */
238 #define	VD_DSKIMG(vd)	((vd)->vdisk_type == VD_DISK_TYPE_DISK &&	\
239 	((vd)->file || (vd)->volume))
240 
241 /* Next index in a write queue */
242 #define	VD_WRITE_INDEX_NEXT(vd, id)		\
243 	((((id) + 1) >= vd->dring_len)? 0 : (id) + 1)
244 
245 /* Message for disk access rights reset failure */
246 #define	VD_RESET_ACCESS_FAILURE_MSG \
247 	"Fail to reset disk access rights for disk %s"
248 
249 /*
250  * Specification of an MD node passed to the MDEG to filter any
251  * 'vport' nodes that do not belong to the specified node. This
252  * template is copied for each vds instance and filled in with
253  * the appropriate 'cfg-handle' value before being passed to the MDEG.
254  */
255 static mdeg_prop_spec_t	vds_prop_template[] = {
256 	{ MDET_PROP_STR,	"name",		VDS_NAME },
257 	{ MDET_PROP_VAL,	"cfg-handle",	NULL },
258 	{ MDET_LIST_END,	NULL, 		NULL }
259 };
260 
261 #define	VDS_SET_MDEG_PROP_INST(specp, val) (specp)[1].ps_val = (val);
262 
263 /*
264  * Matching criteria passed to the MDEG to register interest
265  * in changes to 'virtual-device-port' nodes identified by their
266  * 'id' property.
267  */
268 static md_prop_match_t	vd_prop_match[] = {
269 	{ MDET_PROP_VAL,	VD_ID_PROP },
270 	{ MDET_LIST_END,	NULL }
271 };
272 
273 static mdeg_node_match_t vd_match = {"virtual-device-port",
274 				    vd_prop_match};
275 
276 /*
277  * Options for the VD_BLOCK_DEVICE_OPTS property.
278  */
279 #define	VD_OPT_RDONLY		0x1	/* read-only  */
280 #define	VD_OPT_SLICE		0x2	/* single slice */
281 #define	VD_OPT_EXCLUSIVE	0x4	/* exclusive access */
282 
283 #define	VD_OPTION_NLEN	128
284 
285 typedef struct vd_option {
286 	char vdo_name[VD_OPTION_NLEN];
287 	uint64_t vdo_value;
288 } vd_option_t;
289 
290 vd_option_t vd_bdev_options[] = {
291 	{ "ro",		VD_OPT_RDONLY },
292 	{ "slice", 	VD_OPT_SLICE },
293 	{ "excl",	VD_OPT_EXCLUSIVE }
294 };
295 
296 /* Debugging macros */
297 #ifdef DEBUG
298 
299 static int	vd_msglevel = 0;
300 
301 #define	PR0 if (vd_msglevel > 0)	PRN
302 #define	PR1 if (vd_msglevel > 1)	PRN
303 #define	PR2 if (vd_msglevel > 2)	PRN
304 
305 #define	VD_DUMP_DRING_ELEM(elem)					\
306 	PR0("dst:%x op:%x st:%u nb:%lx addr:%lx ncook:%u\n",		\
307 	    elem->hdr.dstate,						\
308 	    elem->payload.operation,					\
309 	    elem->payload.status,					\
310 	    elem->payload.nbytes,					\
311 	    elem->payload.addr,						\
312 	    elem->payload.ncookies);
313 
314 char *
vd_decode_state(int state)315 vd_decode_state(int state)
316 {
317 	char *str;
318 
319 #define	CASE_STATE(_s)	case _s: str = #_s; break;
320 
321 	switch (state) {
322 	CASE_STATE(VD_STATE_INIT)
323 	CASE_STATE(VD_STATE_VER)
324 	CASE_STATE(VD_STATE_ATTR)
325 	CASE_STATE(VD_STATE_DRING)
326 	CASE_STATE(VD_STATE_RDX)
327 	CASE_STATE(VD_STATE_DATA)
328 	default: str = "unknown"; break;
329 	}
330 
331 #undef CASE_STATE
332 
333 	return (str);
334 }
335 
336 void
vd_decode_tag(vio_msg_t * msg)337 vd_decode_tag(vio_msg_t *msg)
338 {
339 	char *tstr, *sstr, *estr;
340 
341 #define	CASE_TYPE(_s)	case _s: tstr = #_s; break;
342 
343 	switch (msg->tag.vio_msgtype) {
344 	CASE_TYPE(VIO_TYPE_CTRL)
345 	CASE_TYPE(VIO_TYPE_DATA)
346 	CASE_TYPE(VIO_TYPE_ERR)
347 	default: tstr = "unknown"; break;
348 	}
349 
350 #undef CASE_TYPE
351 
352 #define	CASE_SUBTYPE(_s) case _s: sstr = #_s; break;
353 
354 	switch (msg->tag.vio_subtype) {
355 	CASE_SUBTYPE(VIO_SUBTYPE_INFO)
356 	CASE_SUBTYPE(VIO_SUBTYPE_ACK)
357 	CASE_SUBTYPE(VIO_SUBTYPE_NACK)
358 	default: sstr = "unknown"; break;
359 	}
360 
361 #undef CASE_SUBTYPE
362 
363 #define	CASE_ENV(_s)	case _s: estr = #_s; break;
364 
365 	switch (msg->tag.vio_subtype_env) {
366 	CASE_ENV(VIO_VER_INFO)
367 	CASE_ENV(VIO_ATTR_INFO)
368 	CASE_ENV(VIO_DRING_REG)
369 	CASE_ENV(VIO_DRING_UNREG)
370 	CASE_ENV(VIO_RDX)
371 	CASE_ENV(VIO_PKT_DATA)
372 	CASE_ENV(VIO_DESC_DATA)
373 	CASE_ENV(VIO_DRING_DATA)
374 	default: estr = "unknown"; break;
375 	}
376 
377 #undef CASE_ENV
378 
379 	PR1("(%x/%x/%x) message : (%s/%s/%s)",
380 	    msg->tag.vio_msgtype, msg->tag.vio_subtype,
381 	    msg->tag.vio_subtype_env, tstr, sstr, estr);
382 }
383 
384 #else	/* !DEBUG */
385 
386 #define	PR0(...)
387 #define	PR1(...)
388 #define	PR2(...)
389 
390 #define	VD_DUMP_DRING_ELEM(elem)
391 
392 #define	vd_decode_state(_s)	(NULL)
393 #define	vd_decode_tag(_s)	(NULL)
394 
395 #endif	/* DEBUG */
396 
397 
398 /*
399  * Soft state structure for a vds instance
400  */
401 typedef struct vds {
402 	uint_t		initialized;	/* driver inst initialization flags */
403 	dev_info_t	*dip;		/* driver inst devinfo pointer */
404 	ldi_ident_t	ldi_ident;	/* driver's identifier for LDI */
405 	mod_hash_t	*vd_table;	/* table of virtual disks served */
406 	mdeg_node_spec_t *ispecp;	/* mdeg node specification */
407 	mdeg_handle_t	mdeg;		/* handle for MDEG operations  */
408 	vd_driver_type_t *driver_types;	/* extra driver types (from vds.conf) */
409 	int 		num_drivers;	/* num of extra driver types */
410 } vds_t;
411 
412 /*
413  * Types of descriptor-processing tasks
414  */
415 typedef enum vd_task_type {
416 	VD_NONFINAL_RANGE_TASK,	/* task for intermediate descriptor in range */
417 	VD_FINAL_RANGE_TASK,	/* task for last in a range of descriptors */
418 } vd_task_type_t;
419 
420 /*
421  * Structure describing the task for processing a descriptor
422  */
423 typedef struct vd_task {
424 	struct vd		*vd;		/* vd instance task is for */
425 	vd_task_type_t		type;		/* type of descriptor task */
426 	int			index;		/* dring elem index for task */
427 	vio_msg_t		*msg;		/* VIO message task is for */
428 	size_t			msglen;		/* length of message content */
429 	vd_dring_payload_t	*request;	/* request task will perform */
430 	struct buf		buf;		/* buf(9s) for I/O request */
431 	ldc_mem_handle_t	mhdl;		/* task memory handle */
432 	int			status;		/* status of processing task */
433 	int	(*completef)(struct vd_task *task); /* completion func ptr */
434 	uint32_t		write_index;	/* index in the write_queue */
435 } vd_task_t;
436 
437 /*
438  * Soft state structure for a virtual disk instance
439  */
440 typedef struct vd {
441 	uint64_t		id;		/* vdisk id */
442 	uint_t			initialized;	/* vdisk initialization flags */
443 	uint64_t		operations;	/* bitmask of VD_OPs exported */
444 	vio_ver_t		version;	/* ver negotiated with client */
445 	vds_t			*vds;		/* server for this vdisk */
446 	ddi_taskq_t		*startq;	/* queue for I/O start tasks */
447 	ddi_taskq_t		*completionq;	/* queue for completion tasks */
448 	ddi_taskq_t		*ioq;		/* queue for I/O */
449 	uint32_t		write_index;	/* next write index */
450 	buf_t			**write_queue;	/* queue for async writes */
451 	ldi_handle_t		ldi_handle[V_NUMPAR];	/* LDI slice handles */
452 	char			device_path[MAXPATHLEN + 1]; /* vdisk device */
453 	dev_t			dev[V_NUMPAR];	/* dev numbers for slices */
454 	int			open_flags;	/* open flags */
455 	uint_t			nslices;	/* number of slices we export */
456 	size_t			vdisk_size;	/* number of blocks in vdisk */
457 	size_t			vdisk_bsize;	/* blk size of the vdisk */
458 	vd_disk_type_t		vdisk_type;	/* slice or entire disk */
459 	vd_disk_label_t		vdisk_label;	/* EFI or VTOC label */
460 	vd_media_t		vdisk_media;	/* media type of backing dev. */
461 	boolean_t		is_atapi_dev;	/* Is this an IDE CD-ROM dev? */
462 	ushort_t		max_xfer_sz;	/* max xfer size in DEV_BSIZE */
463 	size_t			backend_bsize;	/* blk size of backend device */
464 	int			vio_bshift;	/* shift for blk convertion */
465 	boolean_t		volume;		/* is vDisk backed by volume */
466 	boolean_t		zvol;		/* is vDisk backed by a zvol */
467 	boolean_t		file;		/* is vDisk backed by a file? */
468 	boolean_t		scsi;		/* is vDisk backed by scsi? */
469 	vnode_t			*file_vnode;	/* file vnode */
470 	size_t			dskimg_size;	/* size of disk image */
471 	ddi_devid_t		dskimg_devid;	/* devid for disk image */
472 	int			efi_reserved;	/* EFI reserved slice */
473 	caddr_t			flabel;		/* fake label for slice type */
474 	uint_t			flabel_size;	/* fake label size */
475 	uint_t			flabel_limit;	/* limit of the fake label */
476 	struct dk_geom		dk_geom;	/* synthetic for slice type */
477 	struct extvtoc		vtoc;		/* synthetic for slice type */
478 	vd_slice_t		slices[VD_MAXPART]; /* logical partitions */
479 	boolean_t		ownership;	/* disk ownership status */
480 	ldc_status_t		ldc_state;	/* LDC connection state */
481 	ldc_handle_t		ldc_handle;	/* handle for LDC comm */
482 	size_t			max_msglen;	/* largest LDC message len */
483 	vd_state_t		state;		/* client handshake state */
484 	uint8_t			xfer_mode;	/* transfer mode with client */
485 	uint32_t		sid;		/* client's session ID */
486 	uint64_t		seq_num;	/* message sequence number */
487 	uint64_t		dring_ident;	/* identifier of dring */
488 	ldc_dring_handle_t	dring_handle;	/* handle for dring ops */
489 	uint32_t		descriptor_size;	/* num bytes in desc */
490 	uint32_t		dring_len;	/* number of dring elements */
491 	uint8_t			dring_mtype;	/* dring mem map type */
492 	caddr_t			dring;		/* address of dring */
493 	caddr_t			vio_msgp;	/* vio msg staging buffer */
494 	vd_task_t		inband_task;	/* task for inband descriptor */
495 	vd_task_t		*dring_task;	/* tasks dring elements */
496 
497 	kmutex_t		lock;		/* protects variables below */
498 	boolean_t		enabled;	/* is vdisk enabled? */
499 	boolean_t		reset_state;	/* reset connection state? */
500 	boolean_t		reset_ldc;	/* reset LDC channel? */
501 } vd_t;
502 
503 /*
504  * Macros to manipulate the fake label (flabel) for single slice disks.
505  *
506  * If we fake a VTOC label then the fake label consists of only one block
507  * containing the VTOC label (struct dk_label).
508  *
509  * If we fake an EFI label then the fake label consists of a blank block
510  * followed by a GPT (efi_gpt_t) and a GPE (efi_gpe_t).
511  *
512  */
513 #define	VD_LABEL_VTOC_SIZE(lba)					\
514 	P2ROUNDUP(sizeof (struct dk_label), (lba))
515 
516 #define	VD_LABEL_EFI_SIZE(lba)					\
517 	P2ROUNDUP(2 * (lba) + sizeof (efi_gpe_t) * VD_MAXPART,	\
518 	    (lba))
519 
520 #define	VD_LABEL_VTOC(vd)	\
521 		((struct dk_label *)(void *)((vd)->flabel))
522 
523 #define	VD_LABEL_EFI_GPT(vd, lba)	\
524 		((efi_gpt_t *)(void *)((vd)->flabel + (lba)))
525 #define	VD_LABEL_EFI_GPE(vd, lba)	\
526 		((efi_gpe_t *)(void *)((vd)->flabel + 2 * (lba)))
527 
528 
529 typedef struct vds_operation {
530 	char	*namep;
531 	uint8_t	operation;
532 	int	(*start)(vd_task_t *task);
533 	int	(*complete)(vd_task_t *task);
534 } vds_operation_t;
535 
536 typedef struct vd_ioctl {
537 	uint8_t		operation;		/* vdisk operation */
538 	const char	*operation_name;	/* vdisk operation name */
539 	size_t		nbytes;			/* size of operation buffer */
540 	int		cmd;			/* corresponding ioctl cmd */
541 	const char	*cmd_name;		/* ioctl cmd name */
542 	void		*arg;			/* ioctl cmd argument */
543 	/* convert input vd_buf to output ioctl_arg */
544 	int		(*copyin)(void *vd_buf, size_t, void *ioctl_arg);
545 	/* convert input ioctl_arg to output vd_buf */
546 	void		(*copyout)(void *ioctl_arg, void *vd_buf);
547 	/* write is true if the operation writes any data to the backend */
548 	boolean_t	write;
549 } vd_ioctl_t;
550 
551 /* Define trivial copyin/copyout conversion function flag */
552 #define	VD_IDENTITY_IN	((int (*)(void *, size_t, void *))-1)
553 #define	VD_IDENTITY_OUT	((void (*)(void *, void *))-1)
554 
555 
556 static int	vds_ldc_retries = VDS_RETRIES;
557 static int	vds_ldc_delay = VDS_LDC_DELAY;
558 static int	vds_dev_retries = VDS_RETRIES;
559 static int	vds_dev_delay = VDS_DEV_DELAY;
560 static void	*vds_state;
561 
562 static short	vd_scsi_rdwr_timeout = VD_SCSI_RDWR_TIMEOUT;
563 static int	vd_scsi_debug = USCSI_SILENT;
564 
565 /*
566  * Number of threads in the taskq handling vdisk I/O. This can be set up to
567  * the size of the DRing which is the maximum number of I/O we can receive
568  * in parallel. Note that using a high number of threads can improve performance
569  * but this is going to consume a lot of resources if there are many vdisks.
570  */
571 static int	vd_ioq_nthreads = VD_IOQ_NTHREADS;
572 
573 /*
574  * Tunable to define the behavior for flushing asynchronous writes used to
575  * performed some write I/O requests. The default behavior is to group as
576  * much asynchronous writes as possible and to flush them immediatly.
577  *
578  * If the tunable is set to 0 then explicit flushing is disabled. In that
579  * case, data will be flushed by traditional mechanism (like fsflush) but
580  * this might not happen immediatly.
581  *
582  */
583 static int	vd_awflush = VD_AWFLUSH_IMMEDIATE | VD_AWFLUSH_GROUP;
584 
585 /*
586  * Tunable to define the behavior of the service domain if the vdisk server
587  * fails to reset disk exclusive access when a LDC channel is reset. When a
588  * LDC channel is reset the vdisk server will try to reset disk exclusive
589  * access by releasing any SCSI-2 reservation or resetting the disk. If these
590  * actions fail then the default behavior (vd_reset_access_failure = 0) is to
591  * print a warning message. This default behavior can be changed by setting
592  * the vd_reset_access_failure variable to A_REBOOT (= 0x1) and that will
593  * cause the service domain to reboot, or A_DUMP (= 0x5) and that will cause
594  * the service domain to panic. In both cases, the reset of the service domain
595  * should trigger a reset SCSI buses and hopefully clear any SCSI-2 reservation.
596  */
597 static int 	vd_reset_access_failure = 0;
598 
599 /*
600  * Tunable for backward compatibility. When this variable is set to B_TRUE,
601  * all disk volumes (ZFS, SVM, VxvM volumes) will be exported as single
602  * slice disks whether or not they have the "slice" option set. This is
603  * to provide a simple backward compatibility mechanism when upgrading
604  * the vds driver and using a domain configuration created before the
605  * "slice" option was available.
606  */
607 static boolean_t vd_volume_force_slice = B_FALSE;
608 
609 /*
610  * The label of disk images created with some earlier versions of the virtual
611  * disk software is not entirely correct and have an incorrect v_sanity field
612  * (usually 0) instead of VTOC_SANE. This creates a compatibility problem with
613  * these images because we are now validating that the disk label (and the
614  * sanity) is correct when a disk image is opened.
615  *
616  * This tunable is set to false to not validate the sanity field and ensure
617  * compatibility. If the tunable is set to true, we will do a strict checking
618  * of the sanity but this can create compatibility problems with old disk
619  * images.
620  */
621 static boolean_t vd_dskimg_validate_sanity = B_FALSE;
622 
623 /*
624  * Enables the use of LDC_DIRECT_MAP when mapping in imported descriptor rings.
625  */
626 static boolean_t vd_direct_mapped_drings = B_TRUE;
627 
628 /*
629  * When a backend is exported as a single-slice disk then we entirely fake
630  * its disk label. So it can be exported either with a VTOC label or with
631  * an EFI label. If vd_slice_label is set to VD_DISK_LABEL_VTOC then all
632  * single-slice disks will be exported with a VTOC label; and if it is set
633  * to VD_DISK_LABEL_EFI then all single-slice disks will be exported with
634  * an EFI label.
635  *
636  * If vd_slice_label is set to VD_DISK_LABEL_UNK and the backend is a disk
637  * or volume device then it will be exported with the same type of label as
638  * defined on the device. Otherwise if the backend is a file then it will
639  * exported with the disk label type set in the vd_file_slice_label variable.
640  *
641  * Note that if the backend size is greater than 1TB then it will always be
642  * exported with an EFI label no matter what the setting is.
643  */
644 static vd_disk_label_t vd_slice_label = VD_DISK_LABEL_UNK;
645 
646 static vd_disk_label_t vd_file_slice_label = VD_DISK_LABEL_VTOC;
647 
648 /*
649  * Tunable for backward compatibility. If this variable is set to B_TRUE then
650  * single-slice disks are exported as disks with only one slice instead of
651  * faking a complete disk partitioning.
652  */
653 static boolean_t vd_slice_single_slice = B_FALSE;
654 
655 /*
656  * Supported protocol version pairs, from highest (newest) to lowest (oldest)
657  *
658  * Each supported major version should appear only once, paired with (and only
659  * with) its highest supported minor version number (as the protocol requires
660  * supporting all lower minor version numbers as well)
661  */
662 static const vio_ver_t	vds_version[] = {{1, 1}};
663 static const size_t	vds_num_versions =
664     sizeof (vds_version)/sizeof (vds_version[0]);
665 
666 static void vd_free_dring_task(vd_t *vdp);
667 static int vd_setup_vd(vd_t *vd);
668 static int vd_setup_single_slice_disk(vd_t *vd);
669 static int vd_setup_slice_image(vd_t *vd);
670 static int vd_setup_disk_image(vd_t *vd);
671 static int vd_backend_check_size(vd_t *vd);
672 static boolean_t vd_enabled(vd_t *vd);
673 static ushort_t vd_lbl2cksum(struct dk_label *label);
674 static int vd_dskimg_validate_geometry(vd_t *vd);
675 static boolean_t vd_dskimg_is_iso_image(vd_t *vd);
676 static void vd_set_exported_operations(vd_t *vd);
677 static void vd_reset_access(vd_t *vd);
678 static int vd_backend_ioctl(vd_t *vd, int cmd, caddr_t arg);
679 static int vds_efi_alloc_and_read(vd_t *, efi_gpt_t **, efi_gpe_t **);
680 static void vds_efi_free(vd_t *, efi_gpt_t *, efi_gpe_t *);
681 static void vds_driver_types_free(vds_t *vds);
682 static void vd_vtocgeom_to_label(struct extvtoc *vtoc, struct dk_geom *geom,
683     struct dk_label *label);
684 static void vd_label_to_vtocgeom(struct dk_label *label, struct extvtoc *vtoc,
685     struct dk_geom *geom);
686 static boolean_t vd_slice_geom_isvalid(vd_t *vd, struct dk_geom *geom);
687 static boolean_t vd_slice_vtoc_isvalid(vd_t *vd, struct extvtoc *vtoc);
688 
689 extern int is_pseudo_device(dev_info_t *);
690 
691 /*
692  * Function:
693  *	vd_get_readable_size
694  *
695  * Description:
696  * 	Convert a given size in bytes to a human readable format in
697  * 	kilobytes, megabytes, gigabytes or terabytes.
698  *
699  * Parameters:
700  *	full_size	- the size to convert in bytes.
701  *	size		- the converted size.
702  *	unit		- the unit of the converted size: 'K' (kilobyte),
703  *			  'M' (Megabyte), 'G' (Gigabyte), 'T' (Terabyte).
704  *
705  * Return Code:
706  *	none
707  */
708 static void
vd_get_readable_size(size_t full_size,size_t * size,char * unit)709 vd_get_readable_size(size_t full_size, size_t *size, char *unit)
710 {
711 	if (full_size < (1ULL << 20)) {
712 		*size = full_size >> 10;
713 		*unit = 'K'; /* Kilobyte */
714 	} else if (full_size < (1ULL << 30)) {
715 		*size = full_size >> 20;
716 		*unit = 'M'; /* Megabyte */
717 	} else if (full_size < (1ULL << 40)) {
718 		*size = full_size >> 30;
719 		*unit = 'G'; /* Gigabyte */
720 	} else {
721 		*size = full_size >> 40;
722 		*unit = 'T'; /* Terabyte */
723 	}
724 }
725 
726 /*
727  * Function:
728  *	vd_dskimg_io_params
729  *
730  * Description:
731  * 	Convert virtual disk I/O parameters (slice, block, length) to
732  *	(offset, length) relative to the disk image and according to
733  *	the virtual disk partitioning.
734  *
735  * Parameters:
736  *	vd		- disk on which the operation is performed.
737  *	slice		- slice to which is the I/O parameters apply.
738  *			  VD_SLICE_NONE indicates that parameters are
739  *			  are relative to the entire virtual disk.
740  *	blkp		- pointer to the starting block relative to the
741  *			  slice; return the starting block relative to
742  *			  the disk image.
743  *	lenp		- pointer to the number of bytes requested; return
744  *			  the number of bytes that can effectively be used.
745  *
746  * Return Code:
747  *	0		- I/O parameters have been successfully converted;
748  *			  blkp and lenp point to the converted values.
749  *	ENODATA		- no data are available for the given I/O parameters;
750  *			  This occurs if the starting block is past the limit
751  *			  of the slice.
752  *	EINVAL		- I/O parameters are invalid.
753  */
754 static int
vd_dskimg_io_params(vd_t * vd,int slice,size_t * blkp,size_t * lenp)755 vd_dskimg_io_params(vd_t *vd, int slice, size_t *blkp, size_t *lenp)
756 {
757 	size_t blk = *blkp;
758 	size_t len = *lenp;
759 	size_t offset, maxlen;
760 
761 	ASSERT(vd->file || VD_DSKIMG(vd));
762 	ASSERT(len > 0);
763 	ASSERT(vd->vdisk_bsize == DEV_BSIZE);
764 
765 	/*
766 	 * If a file is exported as a slice then we don't care about the vtoc.
767 	 * In that case, the vtoc is a fake mainly to make newfs happy and we
768 	 * handle any I/O as a raw disk access so that we can have access to the
769 	 * entire backend.
770 	 */
771 	if (vd->vdisk_type == VD_DISK_TYPE_SLICE || slice == VD_SLICE_NONE) {
772 		/* raw disk access */
773 		offset = blk * DEV_BSIZE;
774 		if (offset >= vd->dskimg_size) {
775 			/* offset past the end of the disk */
776 			PR0("offset (0x%lx) >= size (0x%lx)",
777 			    offset, vd->dskimg_size);
778 			return (ENODATA);
779 		}
780 		maxlen = vd->dskimg_size - offset;
781 	} else {
782 		ASSERT(slice >= 0 && slice < V_NUMPAR);
783 
784 		/*
785 		 * v1.0 vDisk clients depended on the server not verifying
786 		 * the label of a unformatted disk.  This "feature" is
787 		 * maintained for backward compatibility but all versions
788 		 * from v1.1 onwards must do the right thing.
789 		 */
790 		if (vd->vdisk_label == VD_DISK_LABEL_UNK &&
791 		    vio_ver_is_supported(vd->version, 1, 1)) {
792 			(void) vd_dskimg_validate_geometry(vd);
793 			if (vd->vdisk_label == VD_DISK_LABEL_UNK) {
794 				PR0("Unknown disk label, can't do I/O "
795 				    "from slice %d", slice);
796 				return (EINVAL);
797 			}
798 		}
799 
800 		if (vd->vdisk_label == VD_DISK_LABEL_VTOC) {
801 			ASSERT(vd->vtoc.v_sectorsz == DEV_BSIZE);
802 		} else {
803 			ASSERT(vd->vdisk_label == VD_DISK_LABEL_EFI);
804 		}
805 
806 		if (blk >= vd->slices[slice].nblocks) {
807 			/* address past the end of the slice */
808 			PR0("req_addr (0x%lx) >= psize (0x%lx)",
809 			    blk, vd->slices[slice].nblocks);
810 			return (ENODATA);
811 		}
812 
813 		offset = (vd->slices[slice].start + blk) * DEV_BSIZE;
814 		maxlen = (vd->slices[slice].nblocks - blk) * DEV_BSIZE;
815 	}
816 
817 	/*
818 	 * If the requested size is greater than the size
819 	 * of the partition, truncate the read/write.
820 	 */
821 	if (len > maxlen) {
822 		PR0("I/O size truncated to %lu bytes from %lu bytes",
823 		    maxlen, len);
824 		len = maxlen;
825 	}
826 
827 	/*
828 	 * We have to ensure that we are reading/writing into the mmap
829 	 * range. If we have a partial disk image (e.g. an image of
830 	 * s0 instead s2) the system can try to access slices that
831 	 * are not included into the disk image.
832 	 */
833 	if ((offset + len) > vd->dskimg_size) {
834 		PR0("offset + nbytes (0x%lx + 0x%lx) > "
835 		    "dskimg_size (0x%lx)", offset, len, vd->dskimg_size);
836 		return (EINVAL);
837 	}
838 
839 	*blkp = offset / DEV_BSIZE;
840 	*lenp = len;
841 
842 	return (0);
843 }
844 
845 /*
846  * Function:
847  *	vd_dskimg_rw
848  *
849  * Description:
850  * 	Read or write to a disk image. It handles the case where the disk
851  *	image is a file or a volume exported as a full disk or a file
852  *	exported as single-slice disk. Read or write to volumes exported as
853  *	single slice disks are done by directly using the ldi interface.
854  *
855  * Parameters:
856  *	vd		- disk on which the operation is performed.
857  *	slice		- slice on which the operation is performed,
858  *			  VD_SLICE_NONE indicates that the operation
859  *			  is done using an absolute disk offset.
860  *	operation	- operation to execute: read (VD_OP_BREAD) or
861  *			  write (VD_OP_BWRITE).
862  *	data		- buffer where data are read to or written from.
863  *	blk		- starting block for the operation.
864  *	len		- number of bytes to read or write.
865  *
866  * Return Code:
867  *	n >= 0		- success, n indicates the number of bytes read
868  *			  or written.
869  *	-1		- error.
870  */
871 static ssize_t
vd_dskimg_rw(vd_t * vd,int slice,int operation,caddr_t data,size_t offset,size_t len)872 vd_dskimg_rw(vd_t *vd, int slice, int operation, caddr_t data, size_t offset,
873     size_t len)
874 {
875 	ssize_t resid;
876 	struct buf buf;
877 	int status;
878 
879 	ASSERT(vd->file || VD_DSKIMG(vd));
880 	ASSERT(len > 0);
881 	ASSERT(vd->vdisk_bsize == DEV_BSIZE);
882 
883 	if ((status = vd_dskimg_io_params(vd, slice, &offset, &len)) != 0)
884 		return ((status == ENODATA)? 0: -1);
885 
886 	if (vd->volume) {
887 
888 		bioinit(&buf);
889 		buf.b_flags	= B_BUSY |
890 		    ((operation == VD_OP_BREAD)? B_READ : B_WRITE);
891 		buf.b_bcount	= len;
892 		buf.b_lblkno	= offset;
893 		buf.b_edev 	= vd->dev[0];
894 		buf.b_un.b_addr = data;
895 
896 		/*
897 		 * We use ldi_strategy() and not ldi_read()/ldi_write() because
898 		 * the read/write functions of the underlying driver may try to
899 		 * lock pages of the data buffer, and this requires the data
900 		 * buffer to be kmem_alloc'ed (and not allocated on the stack).
901 		 *
902 		 * Also using ldi_strategy() ensures that writes are immediatly
903 		 * commited and not cached as this may be the case with
904 		 * ldi_write() (for example with a ZFS volume).
905 		 */
906 		if (ldi_strategy(vd->ldi_handle[0], &buf) != 0) {
907 			biofini(&buf);
908 			return (-1);
909 		}
910 
911 		if (biowait(&buf) != 0) {
912 			biofini(&buf);
913 			return (-1);
914 		}
915 
916 		resid = buf.b_resid;
917 		biofini(&buf);
918 
919 		ASSERT(resid <= len);
920 		return (len - resid);
921 	}
922 
923 	ASSERT(vd->file);
924 
925 	status = vn_rdwr((operation == VD_OP_BREAD)? UIO_READ : UIO_WRITE,
926 	    vd->file_vnode, data, len, offset * DEV_BSIZE, UIO_SYSSPACE, FSYNC,
927 	    RLIM64_INFINITY, kcred, &resid);
928 
929 	if (status != 0)
930 		return (-1);
931 
932 	return (len);
933 }
934 
935 /*
936  * Function:
937  *	vd_build_default_label
938  *
939  * Description:
940  *	Return a default label for a given disk size. This is used when the disk
941  *	does not have a valid VTOC so that the user can get a valid default
942  *	configuration. The default label has all slice sizes set to 0 (except
943  *	slice 2 which is the entire disk) to force the user to write a valid
944  *	label onto the disk image.
945  *
946  * Parameters:
947  *	disk_size	- the disk size in bytes
948  *	bsize		- the disk block size in bytes
949  *	label		- the returned default label.
950  *
951  * Return Code:
952  *	none.
953  */
954 static void
vd_build_default_label(size_t disk_size,size_t bsize,struct dk_label * label)955 vd_build_default_label(size_t disk_size, size_t bsize, struct dk_label *label)
956 {
957 	size_t size;
958 	char unit;
959 
960 	ASSERT(bsize > 0);
961 
962 	bzero(label, sizeof (struct dk_label));
963 
964 	/*
965 	 * Ideally we would like the cylinder size (nsect * nhead) to be the
966 	 * same whatever the disk size is. That way the VTOC label could be
967 	 * easily updated in case the disk size is increased (keeping the
968 	 * same cylinder size allows to preserve the existing partitioning
969 	 * when updating the VTOC label). But it is not possible to have
970 	 * a fixed cylinder size and to cover all disk size.
971 	 *
972 	 * So we define different cylinder sizes depending on the disk size.
973 	 * The cylinder size is chosen so that we don't have too few cylinders
974 	 * for a small disk image, or so many on a big disk image that you
975 	 * waste space for backup superblocks or cylinder group structures.
976 	 * Also we must have a resonable number of cylinders and sectors so
977 	 * that newfs can run using default values.
978 	 *
979 	 *	+-----------+--------+---------+--------+
980 	 *	| disk_size |  < 2MB | 2MB-4GB | >= 8GB |
981 	 *	+-----------+--------+---------+--------+
982 	 *	| nhead	    |	 1   |	   1   |    96  |
983 	 *	| nsect	    |  200   |   600   |   768  |
984 	 *	+-----------+--------+---------+--------+
985 	 *
986 	 * Other parameters are computed from these values:
987 	 *
988 	 * 	pcyl = disk_size / (nhead * nsect * 512)
989 	 * 	acyl = (pcyl > 2)? 2 : 0
990 	 * 	ncyl = pcyl - acyl
991 	 *
992 	 * The maximum number of cylinder is 65535 so this allows to define a
993 	 * geometry for a disk size up to 65535 * 96 * 768 * 512 = 2.24 TB
994 	 * which is more than enough to cover the maximum size allowed by the
995 	 * extended VTOC format (2TB).
996 	 */
997 
998 	if (disk_size >= 8 * ONE_GIGABYTE) {
999 
1000 		label->dkl_nhead = 96;
1001 		label->dkl_nsect = 768;
1002 
1003 	} else if (disk_size >= 2 * ONE_MEGABYTE) {
1004 
1005 		label->dkl_nhead = 1;
1006 		label->dkl_nsect = 600;
1007 
1008 	} else {
1009 
1010 		label->dkl_nhead = 1;
1011 		label->dkl_nsect = 200;
1012 	}
1013 
1014 	label->dkl_pcyl = disk_size /
1015 	    (label->dkl_nsect * label->dkl_nhead * bsize);
1016 
1017 	if (label->dkl_pcyl == 0)
1018 		label->dkl_pcyl = 1;
1019 
1020 	label->dkl_acyl = 0;
1021 
1022 	if (label->dkl_pcyl > 2)
1023 		label->dkl_acyl = 2;
1024 
1025 	label->dkl_ncyl = label->dkl_pcyl - label->dkl_acyl;
1026 	label->dkl_write_reinstruct = 0;
1027 	label->dkl_read_reinstruct = 0;
1028 	label->dkl_rpm = 7200;
1029 	label->dkl_apc = 0;
1030 	label->dkl_intrlv = 0;
1031 
1032 	PR0("requested disk size: %ld bytes\n", disk_size);
1033 	PR0("setup: ncyl=%d nhead=%d nsec=%d\n", label->dkl_pcyl,
1034 	    label->dkl_nhead, label->dkl_nsect);
1035 	PR0("provided disk size: %ld bytes\n", (uint64_t)
1036 	    (label->dkl_pcyl * label->dkl_nhead *
1037 	    label->dkl_nsect * bsize));
1038 
1039 	vd_get_readable_size(disk_size, &size, &unit);
1040 
1041 	/*
1042 	 * We must have a correct label name otherwise format(1m) will
1043 	 * not recognized the disk as labeled.
1044 	 */
1045 	(void) snprintf(label->dkl_asciilabel, LEN_DKL_ASCII,
1046 	    "SUN-DiskImage-%ld%cB cyl %d alt %d hd %d sec %d",
1047 	    size, unit,
1048 	    label->dkl_ncyl, label->dkl_acyl, label->dkl_nhead,
1049 	    label->dkl_nsect);
1050 
1051 	/* default VTOC */
1052 	label->dkl_vtoc.v_version = V_EXTVERSION;
1053 	label->dkl_vtoc.v_nparts = V_NUMPAR;
1054 	label->dkl_vtoc.v_sanity = VTOC_SANE;
1055 	label->dkl_vtoc.v_part[VD_ENTIRE_DISK_SLICE].p_tag = V_BACKUP;
1056 	label->dkl_map[VD_ENTIRE_DISK_SLICE].dkl_cylno = 0;
1057 	label->dkl_map[VD_ENTIRE_DISK_SLICE].dkl_nblk = label->dkl_ncyl *
1058 	    label->dkl_nhead * label->dkl_nsect;
1059 	label->dkl_magic = DKL_MAGIC;
1060 	label->dkl_cksum = vd_lbl2cksum(label);
1061 }
1062 
1063 /*
1064  * Function:
1065  *	vd_dskimg_set_vtoc
1066  *
1067  * Description:
1068  *	Set the vtoc of a disk image by writing the label and backup
1069  *	labels into the disk image backend.
1070  *
1071  * Parameters:
1072  *	vd		- disk on which the operation is performed.
1073  *	label		- the data to be written.
1074  *
1075  * Return Code:
1076  *	0		- success.
1077  *	n > 0		- error, n indicates the errno code.
1078  */
1079 static int
vd_dskimg_set_vtoc(vd_t * vd,struct dk_label * label)1080 vd_dskimg_set_vtoc(vd_t *vd, struct dk_label *label)
1081 {
1082 	size_t blk, sec, cyl, head, cnt;
1083 
1084 	ASSERT(VD_DSKIMG(vd));
1085 
1086 	if (VD_DSKIMG_LABEL_WRITE(vd, label) < 0) {
1087 		PR0("fail to write disk label");
1088 		return (EIO);
1089 	}
1090 
1091 	/*
1092 	 * Backup labels are on the last alternate cylinder's
1093 	 * first five odd sectors.
1094 	 */
1095 	if (label->dkl_acyl == 0) {
1096 		PR0("no alternate cylinder, can not store backup labels");
1097 		return (0);
1098 	}
1099 
1100 	cyl = label->dkl_ncyl  + label->dkl_acyl - 1;
1101 	head = label->dkl_nhead - 1;
1102 
1103 	blk = (cyl * ((label->dkl_nhead * label->dkl_nsect) - label->dkl_apc)) +
1104 	    (head * label->dkl_nsect);
1105 
1106 	/*
1107 	 * Write the backup labels. Make sure we don't try to write past
1108 	 * the last cylinder.
1109 	 */
1110 	sec = 1;
1111 
1112 	for (cnt = 0; cnt < VD_DSKIMG_NUM_BACKUP; cnt++) {
1113 
1114 		if (sec >= label->dkl_nsect) {
1115 			PR0("not enough sector to store all backup labels");
1116 			return (0);
1117 		}
1118 
1119 		if (vd_dskimg_rw(vd, VD_SLICE_NONE, VD_OP_BWRITE,
1120 		    (caddr_t)label, blk + sec, sizeof (struct dk_label)) < 0) {
1121 			PR0("error writing backup label at block %lu\n",
1122 			    blk + sec);
1123 			return (EIO);
1124 		}
1125 
1126 		PR1("wrote backup label at block %lu\n", blk + sec);
1127 
1128 		sec += 2;
1129 	}
1130 
1131 	return (0);
1132 }
1133 
1134 /*
1135  * Function:
1136  *	vd_dskimg_get_devid_block
1137  *
1138  * Description:
1139  *	Return the block number where the device id is stored.
1140  *
1141  * Parameters:
1142  *	vd		- disk on which the operation is performed.
1143  *	blkp		- pointer to the block number
1144  *
1145  * Return Code:
1146  *	0		- success
1147  *	ENOSPC		- disk has no space to store a device id
1148  */
1149 static int
vd_dskimg_get_devid_block(vd_t * vd,size_t * blkp)1150 vd_dskimg_get_devid_block(vd_t *vd, size_t *blkp)
1151 {
1152 	diskaddr_t spc, head, cyl;
1153 
1154 	ASSERT(VD_DSKIMG(vd));
1155 
1156 	if (vd->vdisk_label == VD_DISK_LABEL_UNK) {
1157 		/*
1158 		 * If no label is defined we don't know where to find
1159 		 * a device id.
1160 		 */
1161 		return (ENOSPC);
1162 	}
1163 
1164 	if (vd->vdisk_label == VD_DISK_LABEL_EFI) {
1165 		/*
1166 		 * For an EFI disk, the devid is at the beginning of
1167 		 * the reserved slice
1168 		 */
1169 		if (vd->efi_reserved == -1) {
1170 			PR0("EFI disk has no reserved slice");
1171 			return (ENOSPC);
1172 		}
1173 
1174 		*blkp = vd->slices[vd->efi_reserved].start;
1175 		return (0);
1176 	}
1177 
1178 	ASSERT(vd->vdisk_label == VD_DISK_LABEL_VTOC);
1179 
1180 	/* this geometry doesn't allow us to have a devid */
1181 	if (vd->dk_geom.dkg_acyl < 2) {
1182 		PR0("not enough alternate cylinder available for devid "
1183 		    "(acyl=%u)", vd->dk_geom.dkg_acyl);
1184 		return (ENOSPC);
1185 	}
1186 
1187 	/* the devid is in on the track next to the last cylinder */
1188 	cyl = vd->dk_geom.dkg_ncyl + vd->dk_geom.dkg_acyl - 2;
1189 	spc = vd->dk_geom.dkg_nhead * vd->dk_geom.dkg_nsect;
1190 	head = vd->dk_geom.dkg_nhead - 1;
1191 
1192 	*blkp = (cyl * (spc - vd->dk_geom.dkg_apc)) +
1193 	    (head * vd->dk_geom.dkg_nsect) + 1;
1194 
1195 	return (0);
1196 }
1197 
1198 /*
1199  * Return the checksum of a disk block containing an on-disk devid.
1200  */
1201 static uint_t
vd_dkdevid2cksum(struct dk_devid * dkdevid)1202 vd_dkdevid2cksum(struct dk_devid *dkdevid)
1203 {
1204 	uint_t chksum, *ip;
1205 	int i;
1206 
1207 	chksum = 0;
1208 	ip = (void *)dkdevid;
1209 	for (i = 0; i < ((DEV_BSIZE - sizeof (int)) / sizeof (int)); i++)
1210 		chksum ^= ip[i];
1211 
1212 	return (chksum);
1213 }
1214 
1215 /*
1216  * Function:
1217  *	vd_dskimg_read_devid
1218  *
1219  * Description:
1220  *	Read the device id stored on a disk image.
1221  *
1222  * Parameters:
1223  *	vd		- disk on which the operation is performed.
1224  *	devid		- the return address of the device ID.
1225  *
1226  * Return Code:
1227  *	0		- success
1228  *	EIO		- I/O error while trying to access the disk image
1229  *	EINVAL		- no valid device id was found
1230  *	ENOSPC		- disk has no space to store a device id
1231  */
1232 static int
vd_dskimg_read_devid(vd_t * vd,ddi_devid_t * devid)1233 vd_dskimg_read_devid(vd_t *vd, ddi_devid_t *devid)
1234 {
1235 	struct dk_devid *dkdevid;
1236 	size_t blk;
1237 	uint_t chksum;
1238 	int status, sz;
1239 
1240 	ASSERT(vd->vdisk_bsize == DEV_BSIZE);
1241 
1242 	if ((status = vd_dskimg_get_devid_block(vd, &blk)) != 0)
1243 		return (status);
1244 
1245 	dkdevid = kmem_zalloc(DEV_BSIZE, KM_SLEEP);
1246 
1247 	/* get the devid */
1248 	if ((vd_dskimg_rw(vd, VD_SLICE_NONE, VD_OP_BREAD, (caddr_t)dkdevid, blk,
1249 	    DEV_BSIZE)) < 0) {
1250 		PR0("error reading devid block at %lu", blk);
1251 		status = EIO;
1252 		goto done;
1253 	}
1254 
1255 	/* validate the revision */
1256 	if ((dkdevid->dkd_rev_hi != DK_DEVID_REV_MSB) ||
1257 	    (dkdevid->dkd_rev_lo != DK_DEVID_REV_LSB)) {
1258 		PR0("invalid devid found at block %lu (bad revision)", blk);
1259 		status = EINVAL;
1260 		goto done;
1261 	}
1262 
1263 	/* compute checksum */
1264 	chksum = vd_dkdevid2cksum(dkdevid);
1265 
1266 	/* compare the checksums */
1267 	if (DKD_GETCHKSUM(dkdevid) != chksum) {
1268 		PR0("invalid devid found at block %lu (bad checksum)", blk);
1269 		status = EINVAL;
1270 		goto done;
1271 	}
1272 
1273 	/* validate the device id */
1274 	if (ddi_devid_valid((ddi_devid_t)&dkdevid->dkd_devid) != DDI_SUCCESS) {
1275 		PR0("invalid devid found at block %lu", blk);
1276 		status = EINVAL;
1277 		goto done;
1278 	}
1279 
1280 	PR1("devid read at block %lu", blk);
1281 
1282 	sz = ddi_devid_sizeof((ddi_devid_t)&dkdevid->dkd_devid);
1283 	*devid = kmem_alloc(sz, KM_SLEEP);
1284 	bcopy(&dkdevid->dkd_devid, *devid, sz);
1285 
1286 done:
1287 	kmem_free(dkdevid, DEV_BSIZE);
1288 	return (status);
1289 
1290 }
1291 
1292 /*
1293  * Function:
1294  *	vd_dskimg_write_devid
1295  *
1296  * Description:
1297  *	Write a device id into disk image.
1298  *
1299  * Parameters:
1300  *	vd		- disk on which the operation is performed.
1301  *	devid		- the device ID to store.
1302  *
1303  * Return Code:
1304  *	0		- success
1305  *	EIO		- I/O error while trying to access the disk image
1306  *	ENOSPC		- disk has no space to store a device id
1307  */
1308 static int
vd_dskimg_write_devid(vd_t * vd,ddi_devid_t devid)1309 vd_dskimg_write_devid(vd_t *vd, ddi_devid_t devid)
1310 {
1311 	struct dk_devid *dkdevid;
1312 	uint_t chksum;
1313 	size_t blk;
1314 	int status;
1315 
1316 	ASSERT(vd->vdisk_bsize == DEV_BSIZE);
1317 
1318 	if (devid == NULL) {
1319 		/* nothing to write */
1320 		return (0);
1321 	}
1322 
1323 	if ((status = vd_dskimg_get_devid_block(vd, &blk)) != 0)
1324 		return (status);
1325 
1326 	dkdevid = kmem_zalloc(DEV_BSIZE, KM_SLEEP);
1327 
1328 	/* set revision */
1329 	dkdevid->dkd_rev_hi = DK_DEVID_REV_MSB;
1330 	dkdevid->dkd_rev_lo = DK_DEVID_REV_LSB;
1331 
1332 	/* copy devid */
1333 	bcopy(devid, &dkdevid->dkd_devid, ddi_devid_sizeof(devid));
1334 
1335 	/* compute checksum */
1336 	chksum = vd_dkdevid2cksum(dkdevid);
1337 
1338 	/* set checksum */
1339 	DKD_FORMCHKSUM(chksum, dkdevid);
1340 
1341 	/* store the devid */
1342 	if ((status = vd_dskimg_rw(vd, VD_SLICE_NONE, VD_OP_BWRITE,
1343 	    (caddr_t)dkdevid, blk, DEV_BSIZE)) < 0) {
1344 		PR0("Error writing devid block at %lu", blk);
1345 		status = EIO;
1346 	} else {
1347 		PR1("devid written at block %lu", blk);
1348 		status = 0;
1349 	}
1350 
1351 	kmem_free(dkdevid, DEV_BSIZE);
1352 	return (status);
1353 }
1354 
1355 /*
1356  * Function:
1357  *	vd_do_scsi_rdwr
1358  *
1359  * Description:
1360  * 	Read or write to a SCSI disk using an absolute disk offset.
1361  *
1362  * Parameters:
1363  *	vd		- disk on which the operation is performed.
1364  *	operation	- operation to execute: read (VD_OP_BREAD) or
1365  *			  write (VD_OP_BWRITE).
1366  *	data		- buffer where data are read to or written from.
1367  *	blk		- starting block for the operation.
1368  *	len		- number of bytes to read or write.
1369  *
1370  * Return Code:
1371  *	0		- success
1372  *	n != 0		- error.
1373  */
1374 static int
vd_do_scsi_rdwr(vd_t * vd,int operation,caddr_t data,size_t blk,size_t len)1375 vd_do_scsi_rdwr(vd_t *vd, int operation, caddr_t data, size_t blk, size_t len)
1376 {
1377 	struct uscsi_cmd ucmd;
1378 	union scsi_cdb cdb;
1379 	int nsectors, nblk;
1380 	int max_sectors;
1381 	int status, rval;
1382 
1383 	ASSERT(!vd->file);
1384 	ASSERT(!vd->volume);
1385 	ASSERT(vd->vdisk_bsize > 0);
1386 
1387 	max_sectors = vd->max_xfer_sz;
1388 	nblk = (len / vd->vdisk_bsize);
1389 
1390 	if (len % vd->vdisk_bsize != 0)
1391 		return (EINVAL);
1392 
1393 	/*
1394 	 * Build and execute the uscsi ioctl.  We build a group0, group1
1395 	 * or group4 command as necessary, since some targets
1396 	 * do not support group1 commands.
1397 	 */
1398 	while (nblk) {
1399 
1400 		bzero(&ucmd, sizeof (ucmd));
1401 		bzero(&cdb, sizeof (cdb));
1402 
1403 		nsectors = (max_sectors < nblk) ? max_sectors : nblk;
1404 
1405 		/*
1406 		 * Some of the optical drives on sun4v machines are ATAPI
1407 		 * devices which use Group 1 Read/Write commands so we need
1408 		 * to explicitly check a flag which is set when a domain
1409 		 * is bound.
1410 		 */
1411 		if (blk < (2 << 20) && nsectors <= 0xff && !vd->is_atapi_dev) {
1412 			FORMG0ADDR(&cdb, blk);
1413 			FORMG0COUNT(&cdb, (uchar_t)nsectors);
1414 			ucmd.uscsi_cdblen = CDB_GROUP0;
1415 		} else if (blk > 0xffffffff) {
1416 			FORMG4LONGADDR(&cdb, blk);
1417 			FORMG4COUNT(&cdb, nsectors);
1418 			ucmd.uscsi_cdblen = CDB_GROUP4;
1419 			cdb.scc_cmd |= SCMD_GROUP4;
1420 		} else {
1421 			FORMG1ADDR(&cdb, blk);
1422 			FORMG1COUNT(&cdb, nsectors);
1423 			ucmd.uscsi_cdblen = CDB_GROUP1;
1424 			cdb.scc_cmd |= SCMD_GROUP1;
1425 		}
1426 		ucmd.uscsi_cdb = (caddr_t)&cdb;
1427 		ucmd.uscsi_bufaddr = data;
1428 		ucmd.uscsi_buflen = nsectors * vd->backend_bsize;
1429 		ucmd.uscsi_timeout = vd_scsi_rdwr_timeout;
1430 		/*
1431 		 * Set flags so that the command is isolated from normal
1432 		 * commands and no error message is printed.
1433 		 */
1434 		ucmd.uscsi_flags = USCSI_ISOLATE | USCSI_SILENT;
1435 
1436 		if (operation == VD_OP_BREAD) {
1437 			cdb.scc_cmd |= SCMD_READ;
1438 			ucmd.uscsi_flags |= USCSI_READ;
1439 		} else {
1440 			cdb.scc_cmd |= SCMD_WRITE;
1441 		}
1442 
1443 		status = ldi_ioctl(vd->ldi_handle[VD_ENTIRE_DISK_SLICE],
1444 		    USCSICMD, (intptr_t)&ucmd, (vd->open_flags | FKIOCTL),
1445 		    kcred, &rval);
1446 
1447 		if (status == 0)
1448 			status = ucmd.uscsi_status;
1449 
1450 		if (status != 0)
1451 			break;
1452 
1453 		/*
1454 		 * Check if partial DMA breakup is required. If so, reduce
1455 		 * the request size by half and retry the last request.
1456 		 */
1457 		if (ucmd.uscsi_resid == ucmd.uscsi_buflen) {
1458 			max_sectors >>= 1;
1459 			if (max_sectors <= 0) {
1460 				status = EIO;
1461 				break;
1462 			}
1463 			continue;
1464 		}
1465 
1466 		if (ucmd.uscsi_resid != 0) {
1467 			status = EIO;
1468 			break;
1469 		}
1470 
1471 		blk += nsectors;
1472 		nblk -= nsectors;
1473 		data += nsectors * vd->vdisk_bsize;
1474 	}
1475 
1476 	return (status);
1477 }
1478 
1479 /*
1480  * Function:
1481  *	vd_scsi_rdwr
1482  *
1483  * Description:
1484  * 	Wrapper function to read or write to a SCSI disk using an absolute
1485  *	disk offset. It checks the blocksize of the underlying device and,
1486  *	if necessary, adjusts the buffers accordingly before calling
1487  *	vd_do_scsi_rdwr() to do the actual read or write.
1488  *
1489  * Parameters:
1490  *	vd		- disk on which the operation is performed.
1491  *	operation	- operation to execute: read (VD_OP_BREAD) or
1492  *			  write (VD_OP_BWRITE).
1493  *	data		- buffer where data are read to or written from.
1494  *	blk		- starting block for the operation.
1495  *	len		- number of bytes to read or write.
1496  *
1497  * Return Code:
1498  *	0		- success
1499  *	n != 0		- error.
1500  */
1501 static int
vd_scsi_rdwr(vd_t * vd,int operation,caddr_t data,size_t vblk,size_t vlen)1502 vd_scsi_rdwr(vd_t *vd, int operation, caddr_t data, size_t vblk, size_t vlen)
1503 {
1504 	int	rv;
1505 
1506 	size_t	pblk;	/* physical device block number of data on device */
1507 	size_t	delta;	/* relative offset between pblk and vblk */
1508 	size_t	pnblk;	/* number of physical blocks to be read from device */
1509 	size_t	plen;	/* length of data to be read from physical device */
1510 	char	*buf;	/* buffer area to fit physical device's block size */
1511 
1512 	if (vd->backend_bsize == 0) {
1513 		/*
1514 		 * The block size was not available during the attach,
1515 		 * try to update it now.
1516 		 */
1517 		if (vd_backend_check_size(vd) != 0)
1518 			return (EIO);
1519 	}
1520 
1521 	/*
1522 	 * If the vdisk block size and the block size of the underlying device
1523 	 * match we can skip straight to vd_do_scsi_rdwr(), otherwise we need
1524 	 * to create a buffer large enough to handle the device's block size
1525 	 * and adjust the block to be read from and the amount of data to
1526 	 * read to correspond with the device's block size.
1527 	 */
1528 	if (vd->vdisk_bsize == vd->backend_bsize)
1529 		return (vd_do_scsi_rdwr(vd, operation, data, vblk, vlen));
1530 
1531 	if (vd->vdisk_bsize > vd->backend_bsize)
1532 		return (EINVAL);
1533 
1534 	/*
1535 	 * Writing of physical block sizes larger than the virtual block size
1536 	 * is not supported. This would be added if/when support for guests
1537 	 * writing to DVDs is implemented.
1538 	 */
1539 	if (operation == VD_OP_BWRITE)
1540 		return (ENOTSUP);
1541 
1542 	/* BEGIN CSTYLED */
1543 	/*
1544 	 * Below is a diagram showing the relationship between the physical
1545 	 * and virtual blocks. If the virtual blocks marked by 'X' below are
1546 	 * requested, then the physical blocks denoted by 'Y' are read.
1547 	 *
1548 	 *           vblk
1549 	 *             |      vlen
1550 	 *             |<--------------->|
1551 	 *             v                 v
1552 	 *  --+--+--+--+--+--+--+--+--+--+--+--+--+--+--+-   virtual disk:
1553 	 *    |  |  |  |XX|XX|XX|XX|XX|XX|  |  |  |  |  |  } block size is
1554 	 *  --+--+--+--+--+--+--+--+--+--+--+--+--+--+--+-   vd->vdisk_bsize
1555 	 *          :  :                 :  :
1556 	 *         >:==:< delta          :  :
1557 	 *          :  :                 :  :
1558 	 *  --+-----+-----+-----+-----+-----+-----+-----+--   physical disk:
1559 	 *    |     |YY:YY|YYYYY|YYYYY|YY:YY|     |     |   } block size is
1560 	 *  --+-----+-----+-----+-----+-----+-----+-----+--   vd->backend_bsize
1561 	 *          ^                       ^
1562 	 *          |<--------------------->|
1563 	 *          |         plen
1564 	 *         pblk
1565 	 */
1566 	/* END CSTYLED */
1567 	pblk = (vblk * vd->vdisk_bsize) / vd->backend_bsize;
1568 	delta = (vblk * vd->vdisk_bsize) - (pblk * vd->backend_bsize);
1569 	pnblk = ((delta + vlen - 1) / vd->backend_bsize) + 1;
1570 	plen = pnblk * vd->backend_bsize;
1571 
1572 	PR2("vblk %lx:pblk %lx: vlen %ld:plen %ld", vblk, pblk, vlen, plen);
1573 
1574 	buf = kmem_zalloc(sizeof (caddr_t) * plen, KM_SLEEP);
1575 	rv = vd_do_scsi_rdwr(vd, operation, (caddr_t)buf, pblk, plen);
1576 	bcopy(buf + delta, data, vlen);
1577 
1578 	kmem_free(buf, sizeof (caddr_t) * plen);
1579 
1580 	return (rv);
1581 }
1582 
1583 /*
1584  * Function:
1585  *	vd_slice_flabel_read
1586  *
1587  * Description:
1588  *	This function simulates a read operation from the fake label of
1589  *	a single-slice disk.
1590  *
1591  * Parameters:
1592  *	vd		- single-slice disk to read from
1593  *	data		- buffer where data should be read to
1594  *	offset		- offset in byte where the read should start
1595  *	length		- number of bytes to read
1596  *
1597  * Return Code:
1598  *	n >= 0		- success, n indicates the number of bytes read
1599  *	-1		- error
1600  */
1601 static ssize_t
vd_slice_flabel_read(vd_t * vd,caddr_t data,size_t offset,size_t length)1602 vd_slice_flabel_read(vd_t *vd, caddr_t data, size_t offset, size_t length)
1603 {
1604 	size_t n = 0;
1605 	uint_t limit = vd->flabel_limit * vd->vdisk_bsize;
1606 
1607 	ASSERT(vd->vdisk_type == VD_DISK_TYPE_SLICE);
1608 	ASSERT(vd->flabel != NULL);
1609 
1610 	/* if offset is past the fake label limit there's nothing to read */
1611 	if (offset >= limit)
1612 		return (0);
1613 
1614 	/* data with offset 0 to flabel_size are read from flabel */
1615 	if (offset < vd->flabel_size) {
1616 
1617 		if (offset + length <= vd->flabel_size) {
1618 			bcopy(vd->flabel + offset, data, length);
1619 			return (length);
1620 		}
1621 
1622 		n = vd->flabel_size - offset;
1623 		bcopy(vd->flabel + offset, data, n);
1624 		data += n;
1625 	}
1626 
1627 	/* data with offset from flabel_size to flabel_limit are all zeros */
1628 	if (offset + length <= limit) {
1629 		bzero(data, length - n);
1630 		return (length);
1631 	}
1632 
1633 	bzero(data, limit - offset - n);
1634 	return (limit - offset);
1635 }
1636 
1637 /*
1638  * Function:
1639  *	vd_slice_flabel_write
1640  *
1641  * Description:
1642  *	This function simulates a write operation to the fake label of
1643  *	a single-slice disk. Write operations are actually faked and return
1644  *	success although the label is never changed. This is mostly to
1645  *	simulate a successful label update.
1646  *
1647  * Parameters:
1648  *	vd		- single-slice disk to write to
1649  *	data		- buffer where data should be written from
1650  *	offset		- offset in byte where the write should start
1651  *	length		- number of bytes to written
1652  *
1653  * Return Code:
1654  *	n >= 0		- success, n indicates the number of bytes written
1655  *	-1		- error
1656  */
1657 static ssize_t
vd_slice_flabel_write(vd_t * vd,caddr_t data,size_t offset,size_t length)1658 vd_slice_flabel_write(vd_t *vd, caddr_t data, size_t offset, size_t length)
1659 {
1660 	uint_t limit = vd->flabel_limit * vd->vdisk_bsize;
1661 	struct dk_label *label;
1662 	struct dk_geom geom;
1663 	struct extvtoc vtoc;
1664 
1665 	ASSERT(vd->vdisk_type == VD_DISK_TYPE_SLICE);
1666 	ASSERT(vd->flabel != NULL);
1667 
1668 	if (offset >= limit)
1669 		return (0);
1670 
1671 	/*
1672 	 * If this is a request to overwrite the VTOC disk label, check that
1673 	 * the new label is similar to the previous one and return that the
1674 	 * write was successful, but note that nothing is actually overwritten.
1675 	 */
1676 	if (vd->vdisk_label == VD_DISK_LABEL_VTOC &&
1677 	    offset == 0 && length == vd->vdisk_bsize) {
1678 		label = (void *)data;
1679 
1680 		/* check that this is a valid label */
1681 		if (label->dkl_magic != DKL_MAGIC ||
1682 		    label->dkl_cksum != vd_lbl2cksum(label))
1683 			return (-1);
1684 
1685 		/* check the vtoc and geometry */
1686 		vd_label_to_vtocgeom(label, &vtoc, &geom);
1687 		if (vd_slice_geom_isvalid(vd, &geom) &&
1688 		    vd_slice_vtoc_isvalid(vd, &vtoc))
1689 			return (length);
1690 	}
1691 
1692 	/* fail any other write */
1693 	return (-1);
1694 }
1695 
1696 /*
1697  * Function:
1698  *	vd_slice_fake_rdwr
1699  *
1700  * Description:
1701  *	This function simulates a raw read or write operation to a single-slice
1702  *	disk. It only handles the faked part of the operation i.e. I/Os to
1703  *	blocks which have no mapping with the vdisk backend (I/Os to the
1704  *	beginning and to the end of the vdisk).
1705  *
1706  *	The function returns 0 is the operation	is completed and it has been
1707  *	entirely handled as a fake read or write. In that case, lengthp points
1708  *	to the number of bytes not read or written. Values returned by datap
1709  *	and blkp are undefined.
1710  *
1711  *	If the fake operation has succeeded but the read or write is not
1712  *	complete (i.e. the read/write operation extends beyond the blocks
1713  *	we fake) then the function returns EAGAIN and datap, blkp and lengthp
1714  *	pointers points to the parameters for completing the operation.
1715  *
1716  *	In case of an error, for example if the slice is empty or parameters
1717  *	are invalid, then the function returns a non-zero value different
1718  *	from EAGAIN. In that case, the returned values of datap, blkp and
1719  *	lengthp are undefined.
1720  *
1721  * Parameters:
1722  *	vd		- single-slice disk on which the operation is performed
1723  *	slice		- slice on which the operation is performed,
1724  *			  VD_SLICE_NONE indicates that the operation
1725  *			  is done using an absolute disk offset.
1726  *	operation	- operation to execute: read (VD_OP_BREAD) or
1727  *			  write (VD_OP_BWRITE).
1728  *	datap		- pointer to the buffer where data are read to
1729  *			  or written from. Return the pointer where remaining
1730  *			  data have to be read to or written from.
1731  *	blkp		- pointer to the starting block for the operation.
1732  *			  Return the starting block relative to the vdisk
1733  *			  backend for the remaining operation.
1734  *	lengthp		- pointer to the number of bytes to read or write.
1735  *			  This should be a multiple of vdisk_bsize. Return the
1736  *			  remaining number of bytes to read or write.
1737  *
1738  * Return Code:
1739  *	0		- read/write operation is completed
1740  *	EAGAIN		- read/write operation is not completed
1741  *	other values	- error
1742  */
1743 static int
vd_slice_fake_rdwr(vd_t * vd,int slice,int operation,caddr_t * datap,size_t * blkp,size_t * lengthp)1744 vd_slice_fake_rdwr(vd_t *vd, int slice, int operation, caddr_t *datap,
1745     size_t *blkp, size_t *lengthp)
1746 {
1747 	struct dk_label *label;
1748 	caddr_t data;
1749 	size_t blk, length, csize;
1750 	size_t ablk, asize, aoff, alen;
1751 	ssize_t n;
1752 	int sec, status;
1753 	size_t bsize = vd->vdisk_bsize;
1754 
1755 	ASSERT(vd->vdisk_type == VD_DISK_TYPE_SLICE);
1756 	ASSERT(slice != 0);
1757 
1758 	data = *datap;
1759 	blk = *blkp;
1760 	length = *lengthp;
1761 
1762 	/*
1763 	 * If this is not a raw I/O or an I/O from a full disk slice then
1764 	 * this is an I/O to/from an empty slice.
1765 	 */
1766 	if (slice != VD_SLICE_NONE &&
1767 	    (slice != VD_ENTIRE_DISK_SLICE ||
1768 	    vd->vdisk_label != VD_DISK_LABEL_VTOC) &&
1769 	    (slice != VD_EFI_WD_SLICE ||
1770 	    vd->vdisk_label != VD_DISK_LABEL_EFI)) {
1771 		return (EIO);
1772 	}
1773 
1774 	if (length % bsize != 0)
1775 		return (EINVAL);
1776 
1777 	/* handle any I/O with the fake label */
1778 	if (operation == VD_OP_BWRITE)
1779 		n = vd_slice_flabel_write(vd, data, blk * bsize, length);
1780 	else
1781 		n = vd_slice_flabel_read(vd, data, blk * bsize, length);
1782 
1783 	if (n == -1)
1784 		return (EINVAL);
1785 
1786 	ASSERT(n % bsize == 0);
1787 
1788 	/* adjust I/O arguments */
1789 	data += n;
1790 	blk += n / bsize;
1791 	length -= n;
1792 
1793 	/* check if there's something else to process */
1794 	if (length == 0) {
1795 		status = 0;
1796 		goto done;
1797 	}
1798 
1799 	if (vd->vdisk_label == VD_DISK_LABEL_VTOC &&
1800 	    slice == VD_ENTIRE_DISK_SLICE) {
1801 		status = EAGAIN;
1802 		goto done;
1803 	}
1804 
1805 	if (vd->vdisk_label == VD_DISK_LABEL_EFI) {
1806 		asize = EFI_MIN_RESV_SIZE + (EFI_MIN_ARRAY_SIZE / bsize) + 1;
1807 		ablk = vd->vdisk_size - asize;
1808 	} else {
1809 		ASSERT(vd->vdisk_label == VD_DISK_LABEL_VTOC);
1810 		ASSERT(vd->dk_geom.dkg_apc == 0);
1811 
1812 		csize = vd->dk_geom.dkg_nhead * vd->dk_geom.dkg_nsect;
1813 		ablk = vd->dk_geom.dkg_ncyl * csize;
1814 		asize = vd->dk_geom.dkg_acyl * csize;
1815 	}
1816 
1817 	alen = length / bsize;
1818 	aoff = blk;
1819 
1820 	/* if we have reached the last block then the I/O is completed */
1821 	if (aoff == ablk + asize) {
1822 		status = 0;
1823 		goto done;
1824 	}
1825 
1826 	/* if we are past the last block then return an error */
1827 	if (aoff > ablk + asize)
1828 		return (EIO);
1829 
1830 	/* check if there is any I/O to end of the disk */
1831 	if (aoff + alen < ablk) {
1832 		status = EAGAIN;
1833 		goto done;
1834 	}
1835 
1836 	/* we don't allow any write to the end of the disk */
1837 	if (operation == VD_OP_BWRITE)
1838 		return (EIO);
1839 
1840 	if (aoff < ablk) {
1841 		alen -= (ablk - aoff);
1842 		aoff = ablk;
1843 	}
1844 
1845 	if (aoff + alen > ablk + asize) {
1846 		alen = ablk + asize - aoff;
1847 	}
1848 
1849 	alen *= bsize;
1850 
1851 	if (operation == VD_OP_BREAD) {
1852 		bzero(data + (aoff - blk) * bsize, alen);
1853 
1854 		if (vd->vdisk_label == VD_DISK_LABEL_VTOC) {
1855 			/* check if we read backup labels */
1856 			label = VD_LABEL_VTOC(vd);
1857 			ablk += (label->dkl_acyl - 1) * csize +
1858 			    (label->dkl_nhead - 1) * label->dkl_nsect;
1859 
1860 			for (sec = 1; (sec < 5 * 2 + 1); sec += 2) {
1861 
1862 				if (ablk + sec >= blk &&
1863 				    ablk + sec < blk + (length / bsize)) {
1864 					bcopy(label, data +
1865 					    (ablk + sec - blk) * bsize,
1866 					    sizeof (struct dk_label));
1867 				}
1868 			}
1869 		}
1870 	}
1871 
1872 	length -= alen;
1873 
1874 	status = (length == 0)? 0: EAGAIN;
1875 
1876 done:
1877 	ASSERT(length == 0 || blk >= vd->flabel_limit);
1878 
1879 	/*
1880 	 * Return the parameters for the remaining I/O. The starting block is
1881 	 * adjusted so that it is relative to the vdisk backend.
1882 	 */
1883 	*datap = data;
1884 	*blkp = blk - vd->flabel_limit;
1885 	*lengthp = length;
1886 
1887 	return (status);
1888 }
1889 
1890 static int
vd_flush_write(vd_t * vd)1891 vd_flush_write(vd_t *vd)
1892 {
1893 	int status, rval;
1894 
1895 	if (vd->file) {
1896 		status = VOP_FSYNC(vd->file_vnode, FSYNC, kcred, NULL);
1897 	} else {
1898 		status = ldi_ioctl(vd->ldi_handle[0], DKIOCFLUSHWRITECACHE,
1899 		    NULL, vd->open_flags | FKIOCTL, kcred, &rval);
1900 	}
1901 
1902 	return (status);
1903 }
1904 
1905 static void
vd_bio_task(void * arg)1906 vd_bio_task(void *arg)
1907 {
1908 	struct buf *buf = (struct buf *)arg;
1909 	vd_task_t *task = (vd_task_t *)buf->b_private;
1910 	vd_t *vd = task->vd;
1911 	ssize_t resid;
1912 	int status;
1913 
1914 	ASSERT(vd->vdisk_bsize == DEV_BSIZE);
1915 
1916 	if (vd->zvol) {
1917 
1918 		status = ldi_strategy(vd->ldi_handle[0], buf);
1919 
1920 	} else {
1921 
1922 		ASSERT(vd->file);
1923 
1924 		status = vn_rdwr((buf->b_flags & B_READ)? UIO_READ : UIO_WRITE,
1925 		    vd->file_vnode, buf->b_un.b_addr, buf->b_bcount,
1926 		    buf->b_lblkno * DEV_BSIZE, UIO_SYSSPACE, 0,
1927 		    RLIM64_INFINITY, kcred, &resid);
1928 
1929 		if (status == 0) {
1930 			buf->b_resid = resid;
1931 			biodone(buf);
1932 			return;
1933 		}
1934 	}
1935 
1936 	if (status != 0) {
1937 		bioerror(buf, status);
1938 		biodone(buf);
1939 	}
1940 }
1941 
1942 /*
1943  * We define our own biodone function so that buffers used for
1944  * asynchronous writes are not released when biodone() is called.
1945  */
1946 static int
vd_biodone(struct buf * bp)1947 vd_biodone(struct buf *bp)
1948 {
1949 	ASSERT((bp->b_flags & B_DONE) == 0);
1950 	ASSERT(SEMA_HELD(&bp->b_sem));
1951 
1952 	bp->b_flags |= B_DONE;
1953 	sema_v(&bp->b_io);
1954 
1955 	return (0);
1956 }
1957 
1958 /*
1959  * Return Values
1960  *	EINPROGRESS	- operation was successfully started
1961  *	EIO		- encountered LDC (aka. task error)
1962  *	0		- operation completed successfully
1963  *
1964  * Side Effect
1965  *     sets request->status = <disk operation status>
1966  */
1967 static int
vd_start_bio(vd_task_t * task)1968 vd_start_bio(vd_task_t *task)
1969 {
1970 	int			rv, status = 0;
1971 	vd_t			*vd		= task->vd;
1972 	vd_dring_payload_t	*request	= task->request;
1973 	struct buf		*buf		= &task->buf;
1974 	uint8_t			mtype;
1975 	int 			slice;
1976 	char			*bufaddr = 0;
1977 	size_t			buflen;
1978 	size_t			offset, length, nbytes;
1979 
1980 	ASSERT(vd != NULL);
1981 	ASSERT(request != NULL);
1982 
1983 	slice = request->slice;
1984 
1985 	ASSERT(slice == VD_SLICE_NONE || slice < vd->nslices);
1986 	ASSERT((request->operation == VD_OP_BREAD) ||
1987 	    (request->operation == VD_OP_BWRITE));
1988 
1989 	if (request->nbytes == 0) {
1990 		/* no service for trivial requests */
1991 		request->status = EINVAL;
1992 		return (0);
1993 	}
1994 
1995 	PR1("%s %lu bytes at block %lu",
1996 	    (request->operation == VD_OP_BREAD) ? "Read" : "Write",
1997 	    request->nbytes, request->addr);
1998 
1999 	/*
2000 	 * We have to check the open flags because the functions processing
2001 	 * the read/write request will not do it.
2002 	 */
2003 	if (request->operation == VD_OP_BWRITE && !(vd->open_flags & FWRITE)) {
2004 		PR0("write fails because backend is opened read-only");
2005 		request->nbytes = 0;
2006 		request->status = EROFS;
2007 		return (0);
2008 	}
2009 
2010 	mtype = LDC_SHADOW_MAP;
2011 
2012 	/* Map memory exported by client */
2013 	status = ldc_mem_map(task->mhdl, request->cookie, request->ncookies,
2014 	    mtype, (request->operation == VD_OP_BREAD) ? LDC_MEM_W : LDC_MEM_R,
2015 	    &bufaddr, NULL);
2016 	if (status != 0) {
2017 		PR0("ldc_mem_map() returned err %d ", status);
2018 		return (EIO);
2019 	}
2020 
2021 	/*
2022 	 * The buffer size has to be 8-byte aligned, so the client should have
2023 	 * sent a buffer which size is roundup to the next 8-byte aligned value.
2024 	 */
2025 	buflen = P2ROUNDUP(request->nbytes, 8);
2026 
2027 	status = ldc_mem_acquire(task->mhdl, 0, buflen);
2028 	if (status != 0) {
2029 		(void) ldc_mem_unmap(task->mhdl);
2030 		PR0("ldc_mem_acquire() returned err %d ", status);
2031 		return (EIO);
2032 	}
2033 
2034 	offset = request->addr;
2035 	nbytes = request->nbytes;
2036 	length = nbytes;
2037 
2038 	/* default number of byte returned by the I/O */
2039 	request->nbytes = 0;
2040 
2041 	if (vd->vdisk_type == VD_DISK_TYPE_SLICE) {
2042 
2043 		if (slice != 0) {
2044 			/* handle any fake I/O */
2045 			rv = vd_slice_fake_rdwr(vd, slice, request->operation,
2046 			    &bufaddr, &offset, &length);
2047 
2048 			/* record the number of bytes from the fake I/O */
2049 			request->nbytes = nbytes - length;
2050 
2051 			if (rv == 0) {
2052 				request->status = 0;
2053 				goto io_done;
2054 			}
2055 
2056 			if (rv != EAGAIN) {
2057 				request->nbytes = 0;
2058 				request->status = EIO;
2059 				goto io_done;
2060 			}
2061 
2062 			/*
2063 			 * If we return with EAGAIN then this means that there
2064 			 * are still data to read or write.
2065 			 */
2066 			ASSERT(length != 0);
2067 
2068 			/*
2069 			 * We need to continue the I/O from the slice backend to
2070 			 * complete the request. The variables bufaddr, offset
2071 			 * and length have been adjusted to have the right
2072 			 * information to do the remaining I/O from the backend.
2073 			 * The backend is entirely mapped to slice 0 so we just
2074 			 * have to complete the I/O from that slice.
2075 			 */
2076 			slice = 0;
2077 		}
2078 
2079 	} else if (vd->volume || vd->file) {
2080 
2081 		rv = vd_dskimg_io_params(vd, slice, &offset, &length);
2082 		if (rv != 0) {
2083 			request->status = (rv == ENODATA)? 0: EIO;
2084 			goto io_done;
2085 		}
2086 		slice = 0;
2087 
2088 	} else if (slice == VD_SLICE_NONE) {
2089 
2090 		/*
2091 		 * This is not a disk image so it is a real disk. We
2092 		 * assume that the underlying device driver supports
2093 		 * USCSICMD ioctls. This is the case of all SCSI devices
2094 		 * (sd, ssd...).
2095 		 *
2096 		 * In the future if we have non-SCSI disks we would need
2097 		 * to invoke the appropriate function to do I/O using an
2098 		 * absolute disk offset (for example using DIOCTL_RWCMD
2099 		 * for IDE disks).
2100 		 */
2101 		rv = vd_scsi_rdwr(vd, request->operation, bufaddr, offset,
2102 		    length);
2103 		if (rv != 0) {
2104 			request->status = EIO;
2105 		} else {
2106 			request->nbytes = length;
2107 			request->status = 0;
2108 		}
2109 		goto io_done;
2110 	}
2111 
2112 	/* Start the block I/O */
2113 	bioinit(buf);
2114 	buf->b_flags	= B_BUSY;
2115 	buf->b_bcount	= length;
2116 	buf->b_lblkno	= offset;
2117 	buf->b_bufsize	= buflen;
2118 	buf->b_edev 	= vd->dev[slice];
2119 	buf->b_un.b_addr = bufaddr;
2120 	buf->b_iodone	= vd_biodone;
2121 
2122 	if (vd->file || vd->zvol) {
2123 		/*
2124 		 * I/O to a file are dispatched to an I/O queue, so that several
2125 		 * I/Os can be processed in parallel. We also do that for ZFS
2126 		 * volumes because the ZFS volume strategy() function will only
2127 		 * return after the I/O is completed (instead of just starting
2128 		 * the I/O).
2129 		 */
2130 
2131 		if (request->operation == VD_OP_BREAD) {
2132 			buf->b_flags |= B_READ;
2133 		} else {
2134 			/*
2135 			 * For ZFS volumes and files, we do an asynchronous
2136 			 * write and we will wait for the completion of the
2137 			 * write in vd_complete_bio() by flushing the volume
2138 			 * or file.
2139 			 *
2140 			 * This done for performance reasons, so that we can
2141 			 * group together several write requests into a single
2142 			 * flush operation.
2143 			 */
2144 			buf->b_flags |= B_WRITE | B_ASYNC;
2145 
2146 			/*
2147 			 * We keep track of the write so that we can group
2148 			 * requests when flushing. The write queue has the
2149 			 * same number of slots as the dring so this prevents
2150 			 * the write queue from wrapping and overwriting
2151 			 * existing entries: if the write queue gets full
2152 			 * then that means that the dring is full so we stop
2153 			 * receiving new requests until an existing request
2154 			 * is processed, removed from the write queue and
2155 			 * then from the dring.
2156 			 */
2157 			task->write_index = vd->write_index;
2158 			vd->write_queue[task->write_index] = buf;
2159 			vd->write_index =
2160 			    VD_WRITE_INDEX_NEXT(vd, vd->write_index);
2161 		}
2162 
2163 		buf->b_private = task;
2164 
2165 		ASSERT(vd->ioq != NULL);
2166 
2167 		request->status = 0;
2168 		(void) ddi_taskq_dispatch(task->vd->ioq, vd_bio_task, buf,
2169 		    DDI_SLEEP);
2170 
2171 	} else {
2172 
2173 		if (request->operation == VD_OP_BREAD) {
2174 			buf->b_flags |= B_READ;
2175 		} else {
2176 			buf->b_flags |= B_WRITE;
2177 		}
2178 
2179 		/* convert VIO block number to buf block number */
2180 		buf->b_lblkno = offset << vd->vio_bshift;
2181 
2182 		request->status = ldi_strategy(vd->ldi_handle[slice], buf);
2183 	}
2184 
2185 	/*
2186 	 * This is to indicate to the caller that the request
2187 	 * needs to be finished by vd_complete_bio() by calling
2188 	 * biowait() there and waiting for that to return before
2189 	 * triggering the notification of the vDisk client.
2190 	 *
2191 	 * This is necessary when writing to real disks as
2192 	 * otherwise calls to ldi_strategy() would be serialized
2193 	 * behind the calls to biowait() and performance would
2194 	 * suffer.
2195 	 */
2196 	if (request->status == 0)
2197 		return (EINPROGRESS);
2198 
2199 	biofini(buf);
2200 
2201 io_done:
2202 	/* Clean up after error or completion */
2203 	rv = ldc_mem_release(task->mhdl, 0, buflen);
2204 	if (rv) {
2205 		PR0("ldc_mem_release() returned err %d ", rv);
2206 		status = EIO;
2207 	}
2208 	rv = ldc_mem_unmap(task->mhdl);
2209 	if (rv) {
2210 		PR0("ldc_mem_unmap() returned err %d ", rv);
2211 		status = EIO;
2212 	}
2213 
2214 	return (status);
2215 }
2216 
2217 /*
2218  * This function should only be called from vd_notify to ensure that requests
2219  * are responded to in the order that they are received.
2220  */
2221 static int
send_msg(ldc_handle_t ldc_handle,void * msg,size_t msglen)2222 send_msg(ldc_handle_t ldc_handle, void *msg, size_t msglen)
2223 {
2224 	int	status;
2225 	size_t	nbytes;
2226 
2227 	do {
2228 		nbytes = msglen;
2229 		status = ldc_write(ldc_handle, msg, &nbytes);
2230 		if (status != EWOULDBLOCK)
2231 			break;
2232 		drv_usecwait(vds_ldc_delay);
2233 	} while (status == EWOULDBLOCK);
2234 
2235 	if (status != 0) {
2236 		if (status != ECONNRESET)
2237 			PR0("ldc_write() returned errno %d", status);
2238 		return (status);
2239 	} else if (nbytes != msglen) {
2240 		PR0("ldc_write() performed only partial write");
2241 		return (EIO);
2242 	}
2243 
2244 	PR1("SENT %lu bytes", msglen);
2245 	return (0);
2246 }
2247 
2248 static void
vd_need_reset(vd_t * vd,boolean_t reset_ldc)2249 vd_need_reset(vd_t *vd, boolean_t reset_ldc)
2250 {
2251 	mutex_enter(&vd->lock);
2252 	vd->reset_state	= B_TRUE;
2253 	vd->reset_ldc	= reset_ldc;
2254 	mutex_exit(&vd->lock);
2255 }
2256 
2257 /*
2258  * Reset the state of the connection with a client, if needed; reset the LDC
2259  * transport as well, if needed.  This function should only be called from the
2260  * "vd_recv_msg", as it waits for tasks - otherwise a deadlock can occur.
2261  */
2262 static void
vd_reset_if_needed(vd_t * vd)2263 vd_reset_if_needed(vd_t *vd)
2264 {
2265 	int	status = 0;
2266 
2267 	mutex_enter(&vd->lock);
2268 	if (!vd->reset_state) {
2269 		ASSERT(!vd->reset_ldc);
2270 		mutex_exit(&vd->lock);
2271 		return;
2272 	}
2273 	mutex_exit(&vd->lock);
2274 
2275 	PR0("Resetting connection state with %s", VD_CLIENT(vd));
2276 
2277 	/*
2278 	 * Let any asynchronous I/O complete before possibly pulling the rug
2279 	 * out from under it; defer checking vd->reset_ldc, as one of the
2280 	 * asynchronous tasks might set it
2281 	 */
2282 	if (vd->ioq != NULL)
2283 		ddi_taskq_wait(vd->ioq);
2284 	ddi_taskq_wait(vd->completionq);
2285 
2286 	status = vd_flush_write(vd);
2287 	if (status) {
2288 		PR0("flushwrite returned error %d", status);
2289 	}
2290 
2291 	if ((vd->initialized & VD_DRING) &&
2292 	    ((status = ldc_mem_dring_unmap(vd->dring_handle)) != 0))
2293 		PR0("ldc_mem_dring_unmap() returned errno %d", status);
2294 
2295 	vd_free_dring_task(vd);
2296 
2297 	/* Free the staging buffer for msgs */
2298 	if (vd->vio_msgp != NULL) {
2299 		kmem_free(vd->vio_msgp, vd->max_msglen);
2300 		vd->vio_msgp = NULL;
2301 	}
2302 
2303 	/* Free the inband message buffer */
2304 	if (vd->inband_task.msg != NULL) {
2305 		kmem_free(vd->inband_task.msg, vd->max_msglen);
2306 		vd->inband_task.msg = NULL;
2307 	}
2308 
2309 	mutex_enter(&vd->lock);
2310 
2311 	if (vd->reset_ldc)
2312 		PR0("taking down LDC channel");
2313 	if (vd->reset_ldc && ((status = ldc_down(vd->ldc_handle)) != 0))
2314 		PR0("ldc_down() returned errno %d", status);
2315 
2316 	/* Reset exclusive access rights */
2317 	vd_reset_access(vd);
2318 
2319 	vd->initialized	&= ~(VD_SID | VD_SEQ_NUM | VD_DRING);
2320 	vd->state	= VD_STATE_INIT;
2321 	vd->max_msglen	= sizeof (vio_msg_t);	/* baseline vio message size */
2322 
2323 	/* Allocate the staging buffer */
2324 	vd->vio_msgp = kmem_alloc(vd->max_msglen, KM_SLEEP);
2325 
2326 	PR0("calling ldc_up\n");
2327 	(void) ldc_up(vd->ldc_handle);
2328 
2329 	vd->reset_state	= B_FALSE;
2330 	vd->reset_ldc	= B_FALSE;
2331 
2332 	mutex_exit(&vd->lock);
2333 }
2334 
2335 static void vd_recv_msg(void *arg);
2336 
2337 static void
vd_mark_in_reset(vd_t * vd)2338 vd_mark_in_reset(vd_t *vd)
2339 {
2340 	int status;
2341 
2342 	PR0("vd_mark_in_reset: marking vd in reset\n");
2343 
2344 	vd_need_reset(vd, B_FALSE);
2345 	status = ddi_taskq_dispatch(vd->startq, vd_recv_msg, vd, DDI_SLEEP);
2346 	if (status == DDI_FAILURE) {
2347 		PR0("cannot schedule task to recv msg\n");
2348 		vd_need_reset(vd, B_TRUE);
2349 		return;
2350 	}
2351 }
2352 
2353 static int
vd_mark_elem_done(vd_t * vd,int idx,int elem_status,int elem_nbytes)2354 vd_mark_elem_done(vd_t *vd, int idx, int elem_status, int elem_nbytes)
2355 {
2356 	boolean_t		accepted;
2357 	int			status;
2358 	on_trap_data_t		otd;
2359 	vd_dring_entry_t	*elem = VD_DRING_ELEM(idx);
2360 
2361 	if (vd->reset_state)
2362 		return (0);
2363 
2364 	/* Acquire the element */
2365 	if ((status = VIO_DRING_ACQUIRE(&otd, vd->dring_mtype,
2366 	    vd->dring_handle, idx, idx)) != 0) {
2367 		if (status == ECONNRESET) {
2368 			vd_mark_in_reset(vd);
2369 			return (0);
2370 		} else {
2371 			return (status);
2372 		}
2373 	}
2374 
2375 	/* Set the element's status and mark it done */
2376 	accepted = (elem->hdr.dstate == VIO_DESC_ACCEPTED);
2377 	if (accepted) {
2378 		elem->payload.nbytes	= elem_nbytes;
2379 		elem->payload.status	= elem_status;
2380 		elem->hdr.dstate	= VIO_DESC_DONE;
2381 	} else {
2382 		/* Perhaps client timed out waiting for I/O... */
2383 		PR0("element %u no longer \"accepted\"", idx);
2384 		VD_DUMP_DRING_ELEM(elem);
2385 	}
2386 	/* Release the element */
2387 	if ((status = VIO_DRING_RELEASE(vd->dring_mtype,
2388 	    vd->dring_handle, idx, idx)) != 0) {
2389 		if (status == ECONNRESET) {
2390 			vd_mark_in_reset(vd);
2391 			return (0);
2392 		} else {
2393 			PR0("VIO_DRING_RELEASE() returned errno %d",
2394 			    status);
2395 			return (status);
2396 		}
2397 	}
2398 
2399 	return (accepted ? 0 : EINVAL);
2400 }
2401 
2402 /*
2403  * Return Values
2404  *	0	- operation completed successfully
2405  *	EIO	- encountered LDC / task error
2406  *
2407  * Side Effect
2408  *	sets request->status = <disk operation status>
2409  */
2410 static int
vd_complete_bio(vd_task_t * task)2411 vd_complete_bio(vd_task_t *task)
2412 {
2413 	int			status		= 0;
2414 	int			rv		= 0;
2415 	vd_t			*vd		= task->vd;
2416 	vd_dring_payload_t	*request	= task->request;
2417 	struct buf		*buf		= &task->buf;
2418 	int			wid, nwrites;
2419 
2420 
2421 	ASSERT(vd != NULL);
2422 	ASSERT(request != NULL);
2423 	ASSERT(task->msg != NULL);
2424 	ASSERT(task->msglen >= sizeof (*task->msg));
2425 
2426 	if (buf->b_flags & B_DONE) {
2427 		/*
2428 		 * If the I/O is already done then we don't call biowait()
2429 		 * because biowait() might already have been called when
2430 		 * flushing a previous asynchronous write. So we just
2431 		 * retrieve the status of the request.
2432 		 */
2433 		request->status = geterror(buf);
2434 	} else {
2435 		/*
2436 		 * Wait for the I/O. For synchronous I/O, biowait() will return
2437 		 * when the I/O has completed. For asynchronous write, it will
2438 		 * return the write has been submitted to the backend, but it
2439 		 * may not have been committed.
2440 		 */
2441 		request->status = biowait(buf);
2442 	}
2443 
2444 	if (buf->b_flags & B_ASYNC) {
2445 		/*
2446 		 * Asynchronous writes are used when writing to a file or a
2447 		 * ZFS volume. In that case the bio notification indicates
2448 		 * that the write has started. We have to flush the backend
2449 		 * to ensure that the write has been committed before marking
2450 		 * the request as completed.
2451 		 */
2452 		ASSERT(task->request->operation == VD_OP_BWRITE);
2453 
2454 		wid = task->write_index;
2455 
2456 		/* check if write has been already flushed */
2457 		if (vd->write_queue[wid] != NULL) {
2458 
2459 			vd->write_queue[wid] = NULL;
2460 			wid = VD_WRITE_INDEX_NEXT(vd, wid);
2461 
2462 			/*
2463 			 * Because flushing is time consuming, it is worth
2464 			 * waiting for any other writes so that they can be
2465 			 * included in this single flush request.
2466 			 */
2467 			if (vd_awflush & VD_AWFLUSH_GROUP) {
2468 				nwrites = 1;
2469 				while (vd->write_queue[wid] != NULL) {
2470 					(void) biowait(vd->write_queue[wid]);
2471 					vd->write_queue[wid] = NULL;
2472 					wid = VD_WRITE_INDEX_NEXT(vd, wid);
2473 					nwrites++;
2474 				}
2475 				DTRACE_PROBE2(flushgrp, vd_task_t *, task,
2476 				    int, nwrites);
2477 			}
2478 
2479 			if (vd_awflush & VD_AWFLUSH_IMMEDIATE) {
2480 				request->status = vd_flush_write(vd);
2481 			} else if (vd_awflush & VD_AWFLUSH_DEFER) {
2482 				(void) taskq_dispatch(system_taskq,
2483 				    (void (*)(void *))vd_flush_write, vd,
2484 				    DDI_SLEEP);
2485 				request->status = 0;
2486 			}
2487 		}
2488 	}
2489 
2490 	/* Update the number of bytes read/written */
2491 	request->nbytes += buf->b_bcount - buf->b_resid;
2492 
2493 	/* Release the buffer */
2494 	if (!vd->reset_state)
2495 		status = ldc_mem_release(task->mhdl, 0, buf->b_bufsize);
2496 	if (status) {
2497 		PR0("ldc_mem_release() returned errno %d copying to "
2498 		    "client", status);
2499 		if (status == ECONNRESET) {
2500 			vd_mark_in_reset(vd);
2501 		}
2502 		rv = EIO;
2503 	}
2504 
2505 	/* Unmap the memory, even if in reset */
2506 	status = ldc_mem_unmap(task->mhdl);
2507 	if (status) {
2508 		PR0("ldc_mem_unmap() returned errno %d copying to client",
2509 		    status);
2510 		if (status == ECONNRESET) {
2511 			vd_mark_in_reset(vd);
2512 		}
2513 		rv = EIO;
2514 	}
2515 
2516 	biofini(buf);
2517 
2518 	return (rv);
2519 }
2520 
2521 /*
2522  * Description:
2523  *	This function is called by the two functions called by a taskq
2524  *	[ vd_complete_notify() and vd_serial_notify()) ] to send the
2525  *	message to the client.
2526  *
2527  * Parameters:
2528  *	arg 	- opaque pointer to structure containing task to be completed
2529  *
2530  * Return Values
2531  *	None
2532  */
2533 static void
vd_notify(vd_task_t * task)2534 vd_notify(vd_task_t *task)
2535 {
2536 	int	status;
2537 
2538 	ASSERT(task != NULL);
2539 	ASSERT(task->vd != NULL);
2540 
2541 	/*
2542 	 * Send the "ack" or "nack" back to the client; if sending the message
2543 	 * via LDC fails, arrange to reset both the connection state and LDC
2544 	 * itself
2545 	 */
2546 	PR2("Sending %s",
2547 	    (task->msg->tag.vio_subtype == VIO_SUBTYPE_ACK) ? "ACK" : "NACK");
2548 
2549 	status = send_msg(task->vd->ldc_handle, task->msg, task->msglen);
2550 	switch (status) {
2551 	case 0:
2552 		break;
2553 	case ECONNRESET:
2554 		vd_mark_in_reset(task->vd);
2555 		break;
2556 	default:
2557 		PR0("initiating full reset");
2558 		vd_need_reset(task->vd, B_TRUE);
2559 		break;
2560 	}
2561 
2562 	DTRACE_PROBE1(task__end, vd_task_t *, task);
2563 }
2564 
2565 /*
2566  * Description:
2567  *	Mark the Dring entry as Done and (if necessary) send an ACK/NACK to
2568  *	the vDisk client
2569  *
2570  * Parameters:
2571  *	task 		- structure containing the request sent from client
2572  *
2573  * Return Values
2574  *	None
2575  */
2576 static void
vd_complete_notify(vd_task_t * task)2577 vd_complete_notify(vd_task_t *task)
2578 {
2579 	int			status		= 0;
2580 	vd_t			*vd		= task->vd;
2581 	vd_dring_payload_t	*request	= task->request;
2582 
2583 	/* Update the dring element for a dring client */
2584 	if (!vd->reset_state && (vd->xfer_mode == VIO_DRING_MODE_V1_0)) {
2585 		status = vd_mark_elem_done(vd, task->index,
2586 		    request->status, request->nbytes);
2587 		if (status == ECONNRESET)
2588 			vd_mark_in_reset(vd);
2589 		else if (status == EACCES)
2590 			vd_need_reset(vd, B_TRUE);
2591 	}
2592 
2593 	/*
2594 	 * If a transport error occurred while marking the element done or
2595 	 * previously while executing the task, arrange to "nack" the message
2596 	 * when the final task in the descriptor element range completes
2597 	 */
2598 	if ((status != 0) || (task->status != 0))
2599 		task->msg->tag.vio_subtype = VIO_SUBTYPE_NACK;
2600 
2601 	/*
2602 	 * Only the final task for a range of elements will respond to and
2603 	 * free the message
2604 	 */
2605 	if (task->type == VD_NONFINAL_RANGE_TASK) {
2606 		return;
2607 	}
2608 
2609 	/*
2610 	 * We should only send an ACK/NACK here if we are not currently in
2611 	 * reset as, depending on how we reset, the dring may have been
2612 	 * blown away and we don't want to ACK/NACK a message that isn't
2613 	 * there.
2614 	 */
2615 	if (!vd->reset_state)
2616 		vd_notify(task);
2617 }
2618 
2619 /*
2620  * Description:
2621  *	This is the basic completion function called to handle inband data
2622  *	requests and handshake messages. All it needs to do is trigger a
2623  *	message to the client that the request is completed.
2624  *
2625  * Parameters:
2626  *	arg 	- opaque pointer to structure containing task to be completed
2627  *
2628  * Return Values
2629  *	None
2630  */
2631 static void
vd_serial_notify(void * arg)2632 vd_serial_notify(void *arg)
2633 {
2634 	vd_task_t		*task = (vd_task_t *)arg;
2635 
2636 	ASSERT(task != NULL);
2637 	vd_notify(task);
2638 }
2639 
2640 /* ARGSUSED */
2641 static int
vd_geom2dk_geom(void * vd_buf,size_t vd_buf_len,void * ioctl_arg)2642 vd_geom2dk_geom(void *vd_buf, size_t vd_buf_len, void *ioctl_arg)
2643 {
2644 	VD_GEOM2DK_GEOM((vd_geom_t *)vd_buf, (struct dk_geom *)ioctl_arg);
2645 	return (0);
2646 }
2647 
2648 /* ARGSUSED */
2649 static int
vd_vtoc2vtoc(void * vd_buf,size_t vd_buf_len,void * ioctl_arg)2650 vd_vtoc2vtoc(void *vd_buf, size_t vd_buf_len, void *ioctl_arg)
2651 {
2652 	VD_VTOC2VTOC((vd_vtoc_t *)vd_buf, (struct extvtoc *)ioctl_arg);
2653 	return (0);
2654 }
2655 
2656 static void
dk_geom2vd_geom(void * ioctl_arg,void * vd_buf)2657 dk_geom2vd_geom(void *ioctl_arg, void *vd_buf)
2658 {
2659 	DK_GEOM2VD_GEOM((struct dk_geom *)ioctl_arg, (vd_geom_t *)vd_buf);
2660 }
2661 
2662 static void
vtoc2vd_vtoc(void * ioctl_arg,void * vd_buf)2663 vtoc2vd_vtoc(void *ioctl_arg, void *vd_buf)
2664 {
2665 	VTOC2VD_VTOC((struct extvtoc *)ioctl_arg, (vd_vtoc_t *)vd_buf);
2666 }
2667 
2668 static int
vd_get_efi_in(void * vd_buf,size_t vd_buf_len,void * ioctl_arg)2669 vd_get_efi_in(void *vd_buf, size_t vd_buf_len, void *ioctl_arg)
2670 {
2671 	vd_efi_t *vd_efi = (vd_efi_t *)vd_buf;
2672 	dk_efi_t *dk_efi = (dk_efi_t *)ioctl_arg;
2673 	size_t data_len;
2674 
2675 	data_len = vd_buf_len - (sizeof (vd_efi_t) - sizeof (uint64_t));
2676 	if (vd_efi->length > data_len)
2677 		return (EINVAL);
2678 
2679 	dk_efi->dki_lba = vd_efi->lba;
2680 	dk_efi->dki_length = vd_efi->length;
2681 	dk_efi->dki_data = kmem_zalloc(vd_efi->length, KM_SLEEP);
2682 	return (0);
2683 }
2684 
2685 static void
vd_get_efi_out(void * ioctl_arg,void * vd_buf)2686 vd_get_efi_out(void *ioctl_arg, void *vd_buf)
2687 {
2688 	int len;
2689 	vd_efi_t *vd_efi = (vd_efi_t *)vd_buf;
2690 	dk_efi_t *dk_efi = (dk_efi_t *)ioctl_arg;
2691 
2692 	len = vd_efi->length;
2693 	DK_EFI2VD_EFI(dk_efi, vd_efi);
2694 	kmem_free(dk_efi->dki_data, len);
2695 }
2696 
2697 static int
vd_set_efi_in(void * vd_buf,size_t vd_buf_len,void * ioctl_arg)2698 vd_set_efi_in(void *vd_buf, size_t vd_buf_len, void *ioctl_arg)
2699 {
2700 	vd_efi_t *vd_efi = (vd_efi_t *)vd_buf;
2701 	dk_efi_t *dk_efi = (dk_efi_t *)ioctl_arg;
2702 	size_t data_len;
2703 
2704 	data_len = vd_buf_len - (sizeof (vd_efi_t) - sizeof (uint64_t));
2705 	if (vd_efi->length > data_len)
2706 		return (EINVAL);
2707 
2708 	dk_efi->dki_data = kmem_alloc(vd_efi->length, KM_SLEEP);
2709 	VD_EFI2DK_EFI(vd_efi, dk_efi);
2710 	return (0);
2711 }
2712 
2713 static void
vd_set_efi_out(void * ioctl_arg,void * vd_buf)2714 vd_set_efi_out(void *ioctl_arg, void *vd_buf)
2715 {
2716 	vd_efi_t *vd_efi = (vd_efi_t *)vd_buf;
2717 	dk_efi_t *dk_efi = (dk_efi_t *)ioctl_arg;
2718 
2719 	kmem_free(dk_efi->dki_data, vd_efi->length);
2720 }
2721 
2722 static int
vd_scsicmd_in(void * vd_buf,size_t vd_buf_len,void * ioctl_arg)2723 vd_scsicmd_in(void *vd_buf, size_t vd_buf_len, void *ioctl_arg)
2724 {
2725 	size_t vd_scsi_len;
2726 	vd_scsi_t *vd_scsi = (vd_scsi_t *)vd_buf;
2727 	struct uscsi_cmd *uscsi = (struct uscsi_cmd *)ioctl_arg;
2728 
2729 	/* check buffer size */
2730 	vd_scsi_len = VD_SCSI_SIZE;
2731 	vd_scsi_len += P2ROUNDUP(vd_scsi->cdb_len, sizeof (uint64_t));
2732 	vd_scsi_len += P2ROUNDUP(vd_scsi->sense_len, sizeof (uint64_t));
2733 	vd_scsi_len += P2ROUNDUP(vd_scsi->datain_len, sizeof (uint64_t));
2734 	vd_scsi_len += P2ROUNDUP(vd_scsi->dataout_len, sizeof (uint64_t));
2735 
2736 	ASSERT(vd_scsi_len % sizeof (uint64_t) == 0);
2737 
2738 	if (vd_buf_len < vd_scsi_len)
2739 		return (EINVAL);
2740 
2741 	/* set flags */
2742 	uscsi->uscsi_flags = vd_scsi_debug;
2743 
2744 	if (vd_scsi->options & VD_SCSI_OPT_NORETRY) {
2745 		uscsi->uscsi_flags |= USCSI_ISOLATE;
2746 		uscsi->uscsi_flags |= USCSI_DIAGNOSE;
2747 	}
2748 
2749 	/* task attribute */
2750 	switch (vd_scsi->task_attribute) {
2751 	case VD_SCSI_TASK_ACA:
2752 		uscsi->uscsi_flags |= USCSI_HEAD;
2753 		break;
2754 	case VD_SCSI_TASK_HQUEUE:
2755 		uscsi->uscsi_flags |= USCSI_HTAG;
2756 		break;
2757 	case VD_SCSI_TASK_ORDERED:
2758 		uscsi->uscsi_flags |= USCSI_OTAG;
2759 		break;
2760 	default:
2761 		uscsi->uscsi_flags |= USCSI_NOTAG;
2762 		break;
2763 	}
2764 
2765 	/* timeout */
2766 	uscsi->uscsi_timeout = vd_scsi->timeout;
2767 
2768 	/* cdb data */
2769 	uscsi->uscsi_cdb = (caddr_t)VD_SCSI_DATA_CDB(vd_scsi);
2770 	uscsi->uscsi_cdblen = vd_scsi->cdb_len;
2771 
2772 	/* sense buffer */
2773 	if (vd_scsi->sense_len != 0) {
2774 		uscsi->uscsi_flags |= USCSI_RQENABLE;
2775 		uscsi->uscsi_rqbuf = (caddr_t)VD_SCSI_DATA_SENSE(vd_scsi);
2776 		uscsi->uscsi_rqlen = vd_scsi->sense_len;
2777 	}
2778 
2779 	if (vd_scsi->datain_len != 0 && vd_scsi->dataout_len != 0) {
2780 		/* uscsi does not support read/write request */
2781 		return (EINVAL);
2782 	}
2783 
2784 	/* request data-in */
2785 	if (vd_scsi->datain_len != 0) {
2786 		uscsi->uscsi_flags |= USCSI_READ;
2787 		uscsi->uscsi_buflen = vd_scsi->datain_len;
2788 		uscsi->uscsi_bufaddr = (char *)VD_SCSI_DATA_IN(vd_scsi);
2789 	}
2790 
2791 	/* request data-out */
2792 	if (vd_scsi->dataout_len != 0) {
2793 		uscsi->uscsi_buflen = vd_scsi->dataout_len;
2794 		uscsi->uscsi_bufaddr = (char *)VD_SCSI_DATA_OUT(vd_scsi);
2795 	}
2796 
2797 	return (0);
2798 }
2799 
2800 static void
vd_scsicmd_out(void * ioctl_arg,void * vd_buf)2801 vd_scsicmd_out(void *ioctl_arg, void *vd_buf)
2802 {
2803 	vd_scsi_t *vd_scsi = (vd_scsi_t *)vd_buf;
2804 	struct uscsi_cmd *uscsi = (struct uscsi_cmd *)ioctl_arg;
2805 
2806 	/* output fields */
2807 	vd_scsi->cmd_status = uscsi->uscsi_status;
2808 
2809 	/* sense data */
2810 	if ((uscsi->uscsi_flags & USCSI_RQENABLE) &&
2811 	    (uscsi->uscsi_status == STATUS_CHECK ||
2812 	    uscsi->uscsi_status == STATUS_TERMINATED)) {
2813 		vd_scsi->sense_status = uscsi->uscsi_rqstatus;
2814 		if (uscsi->uscsi_rqstatus == STATUS_GOOD)
2815 			vd_scsi->sense_len -= uscsi->uscsi_rqresid;
2816 		else
2817 			vd_scsi->sense_len = 0;
2818 	} else {
2819 		vd_scsi->sense_len = 0;
2820 	}
2821 
2822 	if (uscsi->uscsi_status != STATUS_GOOD) {
2823 		vd_scsi->dataout_len = 0;
2824 		vd_scsi->datain_len = 0;
2825 		return;
2826 	}
2827 
2828 	if (uscsi->uscsi_flags & USCSI_READ) {
2829 		/* request data (read) */
2830 		vd_scsi->datain_len -= uscsi->uscsi_resid;
2831 		vd_scsi->dataout_len = 0;
2832 	} else {
2833 		/* request data (write) */
2834 		vd_scsi->datain_len = 0;
2835 		vd_scsi->dataout_len -= uscsi->uscsi_resid;
2836 	}
2837 }
2838 
2839 static ushort_t
vd_lbl2cksum(struct dk_label * label)2840 vd_lbl2cksum(struct dk_label *label)
2841 {
2842 	int	count;
2843 	ushort_t sum, *sp;
2844 
2845 	count =	(sizeof (struct dk_label)) / (sizeof (short)) - 1;
2846 	sp = (ushort_t *)label;
2847 	sum = 0;
2848 	while (count--) {
2849 		sum ^= *sp++;
2850 	}
2851 
2852 	return (sum);
2853 }
2854 
2855 /*
2856  * Copy information from a vtoc and dk_geom structures to a dk_label structure.
2857  */
2858 static void
vd_vtocgeom_to_label(struct extvtoc * vtoc,struct dk_geom * geom,struct dk_label * label)2859 vd_vtocgeom_to_label(struct extvtoc *vtoc, struct dk_geom *geom,
2860     struct dk_label *label)
2861 {
2862 	int i;
2863 
2864 	ASSERT(vtoc->v_nparts == V_NUMPAR);
2865 	ASSERT(vtoc->v_sanity == VTOC_SANE);
2866 
2867 	bzero(label, sizeof (struct dk_label));
2868 
2869 	label->dkl_ncyl = geom->dkg_ncyl;
2870 	label->dkl_acyl = geom->dkg_acyl;
2871 	label->dkl_pcyl = geom->dkg_pcyl;
2872 	label->dkl_nhead = geom->dkg_nhead;
2873 	label->dkl_nsect = geom->dkg_nsect;
2874 	label->dkl_intrlv = geom->dkg_intrlv;
2875 	label->dkl_apc = geom->dkg_apc;
2876 	label->dkl_rpm = geom->dkg_rpm;
2877 	label->dkl_write_reinstruct = geom->dkg_write_reinstruct;
2878 	label->dkl_read_reinstruct = geom->dkg_read_reinstruct;
2879 
2880 	label->dkl_vtoc.v_nparts = V_NUMPAR;
2881 	label->dkl_vtoc.v_sanity = VTOC_SANE;
2882 	label->dkl_vtoc.v_version = vtoc->v_version;
2883 	for (i = 0; i < V_NUMPAR; i++) {
2884 		label->dkl_vtoc.v_timestamp[i] = vtoc->timestamp[i];
2885 		label->dkl_vtoc.v_part[i].p_tag = vtoc->v_part[i].p_tag;
2886 		label->dkl_vtoc.v_part[i].p_flag = vtoc->v_part[i].p_flag;
2887 		label->dkl_map[i].dkl_cylno = vtoc->v_part[i].p_start /
2888 		    (label->dkl_nhead * label->dkl_nsect);
2889 		label->dkl_map[i].dkl_nblk = vtoc->v_part[i].p_size;
2890 	}
2891 
2892 	/*
2893 	 * The bootinfo array can not be copied with bcopy() because
2894 	 * elements are of type long in vtoc (so 64-bit) and of type
2895 	 * int in dk_vtoc (so 32-bit).
2896 	 */
2897 	label->dkl_vtoc.v_bootinfo[0] = vtoc->v_bootinfo[0];
2898 	label->dkl_vtoc.v_bootinfo[1] = vtoc->v_bootinfo[1];
2899 	label->dkl_vtoc.v_bootinfo[2] = vtoc->v_bootinfo[2];
2900 	bcopy(vtoc->v_asciilabel, label->dkl_asciilabel, LEN_DKL_ASCII);
2901 	bcopy(vtoc->v_volume, label->dkl_vtoc.v_volume, LEN_DKL_VVOL);
2902 
2903 	/* re-compute checksum */
2904 	label->dkl_magic = DKL_MAGIC;
2905 	label->dkl_cksum = vd_lbl2cksum(label);
2906 }
2907 
2908 /*
2909  * Copy information from a dk_label structure to a vtoc and dk_geom structures.
2910  */
2911 static void
vd_label_to_vtocgeom(struct dk_label * label,struct extvtoc * vtoc,struct dk_geom * geom)2912 vd_label_to_vtocgeom(struct dk_label *label, struct extvtoc *vtoc,
2913     struct dk_geom *geom)
2914 {
2915 	int i;
2916 
2917 	bzero(vtoc, sizeof (struct extvtoc));
2918 	bzero(geom, sizeof (struct dk_geom));
2919 
2920 	geom->dkg_ncyl = label->dkl_ncyl;
2921 	geom->dkg_acyl = label->dkl_acyl;
2922 	geom->dkg_nhead = label->dkl_nhead;
2923 	geom->dkg_nsect = label->dkl_nsect;
2924 	geom->dkg_intrlv = label->dkl_intrlv;
2925 	geom->dkg_apc = label->dkl_apc;
2926 	geom->dkg_rpm = label->dkl_rpm;
2927 	geom->dkg_pcyl = label->dkl_pcyl;
2928 	geom->dkg_write_reinstruct = label->dkl_write_reinstruct;
2929 	geom->dkg_read_reinstruct = label->dkl_read_reinstruct;
2930 
2931 	vtoc->v_sanity = label->dkl_vtoc.v_sanity;
2932 	vtoc->v_version = label->dkl_vtoc.v_version;
2933 	vtoc->v_sectorsz = DEV_BSIZE;
2934 	vtoc->v_nparts = label->dkl_vtoc.v_nparts;
2935 
2936 	for (i = 0; i < vtoc->v_nparts; i++) {
2937 		vtoc->v_part[i].p_tag = label->dkl_vtoc.v_part[i].p_tag;
2938 		vtoc->v_part[i].p_flag = label->dkl_vtoc.v_part[i].p_flag;
2939 		vtoc->v_part[i].p_start = label->dkl_map[i].dkl_cylno *
2940 		    (label->dkl_nhead * label->dkl_nsect);
2941 		vtoc->v_part[i].p_size = label->dkl_map[i].dkl_nblk;
2942 		vtoc->timestamp[i] = label->dkl_vtoc.v_timestamp[i];
2943 	}
2944 
2945 	/*
2946 	 * The bootinfo array can not be copied with bcopy() because
2947 	 * elements are of type long in vtoc (so 64-bit) and of type
2948 	 * int in dk_vtoc (so 32-bit).
2949 	 */
2950 	vtoc->v_bootinfo[0] = label->dkl_vtoc.v_bootinfo[0];
2951 	vtoc->v_bootinfo[1] = label->dkl_vtoc.v_bootinfo[1];
2952 	vtoc->v_bootinfo[2] = label->dkl_vtoc.v_bootinfo[2];
2953 	bcopy(label->dkl_asciilabel, vtoc->v_asciilabel, LEN_DKL_ASCII);
2954 	bcopy(label->dkl_vtoc.v_volume, vtoc->v_volume, LEN_DKL_VVOL);
2955 }
2956 
2957 /*
2958  * Check if a geometry is valid for a single-slice disk. A geometry is
2959  * considered valid if the main attributes of the geometry match with the
2960  * attributes of the fake geometry we have created.
2961  */
2962 static boolean_t
vd_slice_geom_isvalid(vd_t * vd,struct dk_geom * geom)2963 vd_slice_geom_isvalid(vd_t *vd, struct dk_geom *geom)
2964 {
2965 	ASSERT(vd->vdisk_type == VD_DISK_TYPE_SLICE);
2966 	ASSERT(vd->vdisk_label == VD_DISK_LABEL_VTOC);
2967 
2968 	if (geom->dkg_ncyl != vd->dk_geom.dkg_ncyl ||
2969 	    geom->dkg_acyl != vd->dk_geom.dkg_acyl ||
2970 	    geom->dkg_nsect != vd->dk_geom.dkg_nsect ||
2971 	    geom->dkg_pcyl != vd->dk_geom.dkg_pcyl)
2972 		return (B_FALSE);
2973 
2974 	return (B_TRUE);
2975 }
2976 
2977 /*
2978  * Check if a vtoc is valid for a single-slice disk. A vtoc is considered
2979  * valid if the main attributes of the vtoc match with the attributes of the
2980  * fake vtoc we have created.
2981  */
2982 static boolean_t
vd_slice_vtoc_isvalid(vd_t * vd,struct extvtoc * vtoc)2983 vd_slice_vtoc_isvalid(vd_t *vd, struct extvtoc *vtoc)
2984 {
2985 	size_t csize;
2986 	int i;
2987 
2988 	ASSERT(vd->vdisk_type == VD_DISK_TYPE_SLICE);
2989 	ASSERT(vd->vdisk_label == VD_DISK_LABEL_VTOC);
2990 
2991 	if (vtoc->v_sanity != vd->vtoc.v_sanity ||
2992 	    vtoc->v_version != vd->vtoc.v_version ||
2993 	    vtoc->v_nparts != vd->vtoc.v_nparts ||
2994 	    strcmp(vtoc->v_volume, vd->vtoc.v_volume) != 0 ||
2995 	    strcmp(vtoc->v_asciilabel, vd->vtoc.v_asciilabel) != 0)
2996 		return (B_FALSE);
2997 
2998 	/* slice 2 should be unchanged */
2999 	if (vtoc->v_part[VD_ENTIRE_DISK_SLICE].p_start !=
3000 	    vd->vtoc.v_part[VD_ENTIRE_DISK_SLICE].p_start ||
3001 	    vtoc->v_part[VD_ENTIRE_DISK_SLICE].p_size !=
3002 	    vd->vtoc.v_part[VD_ENTIRE_DISK_SLICE].p_size)
3003 		return (B_FALSE);
3004 
3005 	/*
3006 	 * Slice 0 should be mostly unchanged and cover most of the disk.
3007 	 * However we allow some flexibility wrt to the start and the size
3008 	 * of this slice mainly because we can't exactly know how it will
3009 	 * be defined by the OS installer.
3010 	 *
3011 	 * We allow slice 0 to be defined as starting on any of the first
3012 	 * 4 cylinders.
3013 	 */
3014 	csize = vd->dk_geom.dkg_nhead * vd->dk_geom.dkg_nsect;
3015 
3016 	if (vtoc->v_part[0].p_start > 4 * csize ||
3017 	    vtoc->v_part[0].p_size > vtoc->v_part[VD_ENTIRE_DISK_SLICE].p_size)
3018 			return (B_FALSE);
3019 
3020 	if (vd->vtoc.v_part[0].p_size >= 4 * csize &&
3021 	    vtoc->v_part[0].p_size < vd->vtoc.v_part[0].p_size - 4 *csize)
3022 			return (B_FALSE);
3023 
3024 	/* any other slice should have a size of 0 */
3025 	for (i = 1; i < vtoc->v_nparts; i++) {
3026 		if (i != VD_ENTIRE_DISK_SLICE &&
3027 		    vtoc->v_part[i].p_size != 0)
3028 			return (B_FALSE);
3029 	}
3030 
3031 	return (B_TRUE);
3032 }
3033 
3034 /*
3035  * Handle ioctls to a disk slice.
3036  *
3037  * Return Values
3038  *	0	- Indicates that there are no errors in disk operations
3039  *	ENOTSUP	- Unknown disk label type or unsupported DKIO ioctl
3040  *	EINVAL	- Not enough room to copy the EFI label
3041  *
3042  */
3043 static int
vd_do_slice_ioctl(vd_t * vd,int cmd,void * ioctl_arg)3044 vd_do_slice_ioctl(vd_t *vd, int cmd, void *ioctl_arg)
3045 {
3046 	dk_efi_t *dk_ioc;
3047 	struct extvtoc *vtoc;
3048 	struct dk_geom *geom;
3049 	size_t len, lba;
3050 
3051 	ASSERT(vd->vdisk_type == VD_DISK_TYPE_SLICE);
3052 
3053 	if (cmd == DKIOCFLUSHWRITECACHE)
3054 		return (vd_flush_write(vd));
3055 
3056 	switch (vd->vdisk_label) {
3057 
3058 	/* ioctls for a single slice disk with a VTOC label */
3059 	case VD_DISK_LABEL_VTOC:
3060 
3061 		switch (cmd) {
3062 
3063 		case DKIOCGGEOM:
3064 			ASSERT(ioctl_arg != NULL);
3065 			bcopy(&vd->dk_geom, ioctl_arg, sizeof (vd->dk_geom));
3066 			return (0);
3067 
3068 		case DKIOCGEXTVTOC:
3069 			ASSERT(ioctl_arg != NULL);
3070 			bcopy(&vd->vtoc, ioctl_arg, sizeof (vd->vtoc));
3071 			return (0);
3072 
3073 		case DKIOCSGEOM:
3074 			ASSERT(ioctl_arg != NULL);
3075 			if (vd_slice_single_slice)
3076 				return (ENOTSUP);
3077 
3078 			/* fake success only if new geometry is valid */
3079 			geom = (struct dk_geom *)ioctl_arg;
3080 			if (!vd_slice_geom_isvalid(vd, geom))
3081 				return (EINVAL);
3082 
3083 			return (0);
3084 
3085 		case DKIOCSEXTVTOC:
3086 			ASSERT(ioctl_arg != NULL);
3087 			if (vd_slice_single_slice)
3088 				return (ENOTSUP);
3089 
3090 			/* fake sucess only if the new vtoc is valid */
3091 			vtoc = (struct extvtoc *)ioctl_arg;
3092 			if (!vd_slice_vtoc_isvalid(vd, vtoc))
3093 				return (EINVAL);
3094 
3095 			return (0);
3096 
3097 		default:
3098 			return (ENOTSUP);
3099 		}
3100 
3101 	/* ioctls for a single slice disk with an EFI label */
3102 	case VD_DISK_LABEL_EFI:
3103 
3104 		if (cmd != DKIOCGETEFI && cmd != DKIOCSETEFI)
3105 			return (ENOTSUP);
3106 
3107 		ASSERT(ioctl_arg != NULL);
3108 		dk_ioc = (dk_efi_t *)ioctl_arg;
3109 
3110 		len = dk_ioc->dki_length;
3111 		lba = dk_ioc->dki_lba;
3112 
3113 		if ((lba != VD_EFI_LBA_GPT && lba != VD_EFI_LBA_GPE) ||
3114 		    (lba == VD_EFI_LBA_GPT && len < sizeof (efi_gpt_t)) ||
3115 		    (lba == VD_EFI_LBA_GPE && len < sizeof (efi_gpe_t)))
3116 			return (EINVAL);
3117 
3118 		switch (cmd) {
3119 		case DKIOCGETEFI:
3120 			len = vd_slice_flabel_read(vd,
3121 			    (caddr_t)dk_ioc->dki_data,
3122 			    lba * vd->vdisk_bsize, len);
3123 
3124 			ASSERT(len > 0);
3125 
3126 			return (0);
3127 
3128 		case DKIOCSETEFI:
3129 			if (vd_slice_single_slice)
3130 				return (ENOTSUP);
3131 
3132 			/* we currently don't support writing EFI */
3133 			return (EIO);
3134 		}
3135 
3136 	default:
3137 		/* Unknown disk label type */
3138 		return (ENOTSUP);
3139 	}
3140 }
3141 
3142 static int
vds_efi_alloc_and_read(vd_t * vd,efi_gpt_t ** gpt,efi_gpe_t ** gpe)3143 vds_efi_alloc_and_read(vd_t *vd, efi_gpt_t **gpt, efi_gpe_t **gpe)
3144 {
3145 	vd_efi_dev_t edev;
3146 	int status;
3147 
3148 	VD_EFI_DEV_SET(edev, vd, (vd_efi_ioctl_func)vd_backend_ioctl);
3149 
3150 	status = vd_efi_alloc_and_read(&edev, gpt, gpe);
3151 
3152 	return (status);
3153 }
3154 
3155 static void
vds_efi_free(vd_t * vd,efi_gpt_t * gpt,efi_gpe_t * gpe)3156 vds_efi_free(vd_t *vd, efi_gpt_t *gpt, efi_gpe_t *gpe)
3157 {
3158 	vd_efi_dev_t edev;
3159 
3160 	VD_EFI_DEV_SET(edev, vd, (vd_efi_ioctl_func)vd_backend_ioctl);
3161 
3162 	vd_efi_free(&edev, gpt, gpe);
3163 }
3164 
3165 static int
vd_dskimg_validate_efi(vd_t * vd)3166 vd_dskimg_validate_efi(vd_t *vd)
3167 {
3168 	efi_gpt_t *gpt;
3169 	efi_gpe_t *gpe;
3170 	int i, nparts, status;
3171 	struct uuid efi_reserved = EFI_RESERVED;
3172 
3173 	if ((status = vds_efi_alloc_and_read(vd, &gpt, &gpe)) != 0)
3174 		return (status);
3175 
3176 	bzero(&vd->vtoc, sizeof (struct extvtoc));
3177 	bzero(&vd->dk_geom, sizeof (struct dk_geom));
3178 	bzero(vd->slices, sizeof (vd_slice_t) * VD_MAXPART);
3179 
3180 	vd->efi_reserved = -1;
3181 
3182 	nparts = gpt->efi_gpt_NumberOfPartitionEntries;
3183 
3184 	for (i = 0; i < nparts && i < VD_MAXPART; i++) {
3185 
3186 		if (gpe[i].efi_gpe_StartingLBA == 0 &&
3187 		    gpe[i].efi_gpe_EndingLBA == 0) {
3188 			continue;
3189 		}
3190 
3191 		vd->slices[i].start = gpe[i].efi_gpe_StartingLBA;
3192 		vd->slices[i].nblocks = gpe[i].efi_gpe_EndingLBA -
3193 		    gpe[i].efi_gpe_StartingLBA + 1;
3194 
3195 		if (bcmp(&gpe[i].efi_gpe_PartitionTypeGUID, &efi_reserved,
3196 		    sizeof (struct uuid)) == 0)
3197 			vd->efi_reserved = i;
3198 
3199 	}
3200 
3201 	ASSERT(vd->vdisk_size != 0);
3202 	vd->slices[VD_EFI_WD_SLICE].start = 0;
3203 	vd->slices[VD_EFI_WD_SLICE].nblocks = vd->vdisk_size;
3204 
3205 	vds_efi_free(vd, gpt, gpe);
3206 
3207 	return (status);
3208 }
3209 
3210 /*
3211  * Function:
3212  *	vd_dskimg_validate_geometry
3213  *
3214  * Description:
3215  *	Read the label and validate the geometry of a disk image. The driver
3216  *	label, vtoc and geometry information are updated according to the
3217  *	label read from the disk image.
3218  *
3219  *	If no valid label is found, the label is set to unknown and the
3220  *	function returns EINVAL, but a default vtoc and geometry are provided
3221  *	to the driver. If an EFI label is found, ENOTSUP is returned.
3222  *
3223  * Parameters:
3224  *	vd	- disk on which the operation is performed.
3225  *
3226  * Return Code:
3227  *	0	- success.
3228  *	EIO	- error reading the label from the disk image.
3229  *	EINVAL	- unknown disk label.
3230  *	ENOTSUP	- geometry not applicable (EFI label).
3231  */
3232 static int
vd_dskimg_validate_geometry(vd_t * vd)3233 vd_dskimg_validate_geometry(vd_t *vd)
3234 {
3235 	struct dk_label label;
3236 	struct dk_geom *geom = &vd->dk_geom;
3237 	struct extvtoc *vtoc = &vd->vtoc;
3238 	int i;
3239 	int status = 0;
3240 
3241 	ASSERT(VD_DSKIMG(vd));
3242 
3243 	if (VD_DSKIMG_LABEL_READ(vd, &label) < 0)
3244 		return (EIO);
3245 
3246 	if (label.dkl_magic != DKL_MAGIC ||
3247 	    label.dkl_cksum != vd_lbl2cksum(&label) ||
3248 	    (vd_dskimg_validate_sanity &&
3249 	    label.dkl_vtoc.v_sanity != VTOC_SANE) ||
3250 	    label.dkl_vtoc.v_nparts != V_NUMPAR) {
3251 
3252 		if (vd_dskimg_validate_efi(vd) == 0) {
3253 			vd->vdisk_label = VD_DISK_LABEL_EFI;
3254 			return (ENOTSUP);
3255 		}
3256 
3257 		vd->vdisk_label = VD_DISK_LABEL_UNK;
3258 		vd_build_default_label(vd->dskimg_size, vd->vdisk_bsize,
3259 		    &label);
3260 		status = EINVAL;
3261 	} else {
3262 		vd->vdisk_label = VD_DISK_LABEL_VTOC;
3263 	}
3264 
3265 	/* Update the driver geometry and vtoc */
3266 	vd_label_to_vtocgeom(&label, vtoc, geom);
3267 
3268 	/* Update logical partitions */
3269 	bzero(vd->slices, sizeof (vd_slice_t) * VD_MAXPART);
3270 	if (vd->vdisk_label != VD_DISK_LABEL_UNK) {
3271 		for (i = 0; i < vtoc->v_nparts; i++) {
3272 			vd->slices[i].start = vtoc->v_part[i].p_start;
3273 			vd->slices[i].nblocks = vtoc->v_part[i].p_size;
3274 		}
3275 	}
3276 
3277 	return (status);
3278 }
3279 
3280 /*
3281  * Handle ioctls to a disk image.
3282  *
3283  * Return Values
3284  *	0	- Indicates that there are no errors
3285  *	!= 0	- Disk operation returned an error
3286  */
3287 static int
vd_do_dskimg_ioctl(vd_t * vd,int cmd,void * ioctl_arg)3288 vd_do_dskimg_ioctl(vd_t *vd, int cmd, void *ioctl_arg)
3289 {
3290 	struct dk_label label;
3291 	struct dk_geom *geom;
3292 	struct extvtoc *vtoc;
3293 	dk_efi_t *efi;
3294 	int rc;
3295 
3296 	ASSERT(VD_DSKIMG(vd));
3297 
3298 	switch (cmd) {
3299 
3300 	case DKIOCGGEOM:
3301 		ASSERT(ioctl_arg != NULL);
3302 		geom = (struct dk_geom *)ioctl_arg;
3303 
3304 		rc = vd_dskimg_validate_geometry(vd);
3305 		if (rc != 0 && rc != EINVAL)
3306 			return (rc);
3307 		bcopy(&vd->dk_geom, geom, sizeof (struct dk_geom));
3308 		return (0);
3309 
3310 	case DKIOCGEXTVTOC:
3311 		ASSERT(ioctl_arg != NULL);
3312 		vtoc = (struct extvtoc *)ioctl_arg;
3313 
3314 		rc = vd_dskimg_validate_geometry(vd);
3315 		if (rc != 0 && rc != EINVAL)
3316 			return (rc);
3317 		bcopy(&vd->vtoc, vtoc, sizeof (struct extvtoc));
3318 		return (0);
3319 
3320 	case DKIOCSGEOM:
3321 		ASSERT(ioctl_arg != NULL);
3322 		geom = (struct dk_geom *)ioctl_arg;
3323 
3324 		if (geom->dkg_nhead == 0 || geom->dkg_nsect == 0)
3325 			return (EINVAL);
3326 
3327 		/*
3328 		 * The current device geometry is not updated, just the driver
3329 		 * "notion" of it. The device geometry will be effectively
3330 		 * updated when a label is written to the device during a next
3331 		 * DKIOCSEXTVTOC.
3332 		 */
3333 		bcopy(ioctl_arg, &vd->dk_geom, sizeof (vd->dk_geom));
3334 		return (0);
3335 
3336 	case DKIOCSEXTVTOC:
3337 		ASSERT(ioctl_arg != NULL);
3338 		ASSERT(vd->dk_geom.dkg_nhead != 0 &&
3339 		    vd->dk_geom.dkg_nsect != 0);
3340 		vtoc = (struct extvtoc *)ioctl_arg;
3341 
3342 		if (vtoc->v_sanity != VTOC_SANE ||
3343 		    vtoc->v_sectorsz != DEV_BSIZE ||
3344 		    vtoc->v_nparts != V_NUMPAR)
3345 			return (EINVAL);
3346 
3347 		vd_vtocgeom_to_label(vtoc, &vd->dk_geom, &label);
3348 
3349 		/* write label to the disk image */
3350 		if ((rc = vd_dskimg_set_vtoc(vd, &label)) != 0)
3351 			return (rc);
3352 
3353 		break;
3354 
3355 	case DKIOCFLUSHWRITECACHE:
3356 		return (vd_flush_write(vd));
3357 
3358 	case DKIOCGETEFI:
3359 		ASSERT(ioctl_arg != NULL);
3360 		efi = (dk_efi_t *)ioctl_arg;
3361 
3362 		if (vd_dskimg_rw(vd, VD_SLICE_NONE, VD_OP_BREAD,
3363 		    (caddr_t)efi->dki_data, efi->dki_lba, efi->dki_length) < 0)
3364 			return (EIO);
3365 
3366 		return (0);
3367 
3368 	case DKIOCSETEFI:
3369 		ASSERT(ioctl_arg != NULL);
3370 		efi = (dk_efi_t *)ioctl_arg;
3371 
3372 		if (vd_dskimg_rw(vd, VD_SLICE_NONE, VD_OP_BWRITE,
3373 		    (caddr_t)efi->dki_data, efi->dki_lba, efi->dki_length) < 0)
3374 			return (EIO);
3375 
3376 		break;
3377 
3378 
3379 	default:
3380 		return (ENOTSUP);
3381 	}
3382 
3383 	ASSERT(cmd == DKIOCSEXTVTOC || cmd == DKIOCSETEFI);
3384 
3385 	/* label has changed, revalidate the geometry */
3386 	(void) vd_dskimg_validate_geometry(vd);
3387 
3388 	/*
3389 	 * The disk geometry may have changed, so we need to write
3390 	 * the devid (if there is one) so that it is stored at the
3391 	 * right location.
3392 	 */
3393 	if (vd_dskimg_write_devid(vd, vd->dskimg_devid) != 0) {
3394 		PR0("Fail to write devid");
3395 	}
3396 
3397 	return (0);
3398 }
3399 
3400 static int
vd_backend_ioctl(vd_t * vd,int cmd,caddr_t arg)3401 vd_backend_ioctl(vd_t *vd, int cmd, caddr_t arg)
3402 {
3403 	int rval = 0, status;
3404 	struct vtoc vtoc;
3405 
3406 	/*
3407 	 * Call the appropriate function to execute the ioctl depending
3408 	 * on the type of vdisk.
3409 	 */
3410 	if (vd->vdisk_type == VD_DISK_TYPE_SLICE) {
3411 
3412 		/* slice, file or volume exported as a single slice disk */
3413 		status = vd_do_slice_ioctl(vd, cmd, arg);
3414 
3415 	} else if (VD_DSKIMG(vd)) {
3416 
3417 		/* file or volume exported as a full disk */
3418 		status = vd_do_dskimg_ioctl(vd, cmd, arg);
3419 
3420 	} else {
3421 
3422 		/* disk device exported as a full disk */
3423 		status = ldi_ioctl(vd->ldi_handle[0], cmd, (intptr_t)arg,
3424 		    vd->open_flags | FKIOCTL, kcred, &rval);
3425 
3426 		/*
3427 		 * By default VTOC ioctls are done using ioctls for the
3428 		 * extended VTOC. Some drivers (in particular non-Sun drivers)
3429 		 * may not support these ioctls. In that case, we fallback to
3430 		 * the regular VTOC ioctls.
3431 		 */
3432 		if (status == ENOTTY) {
3433 			switch (cmd) {
3434 
3435 			case DKIOCGEXTVTOC:
3436 				cmd = DKIOCGVTOC;
3437 				status = ldi_ioctl(vd->ldi_handle[0], cmd,
3438 				    (intptr_t)&vtoc, vd->open_flags | FKIOCTL,
3439 				    kcred, &rval);
3440 				vtoctoextvtoc(vtoc,
3441 				    (*(struct extvtoc *)(void *)arg));
3442 				break;
3443 
3444 			case DKIOCSEXTVTOC:
3445 				cmd = DKIOCSVTOC;
3446 				extvtoctovtoc((*(struct extvtoc *)(void *)arg),
3447 				    vtoc);
3448 				status = ldi_ioctl(vd->ldi_handle[0], cmd,
3449 				    (intptr_t)&vtoc, vd->open_flags | FKIOCTL,
3450 				    kcred, &rval);
3451 				break;
3452 			}
3453 		}
3454 	}
3455 
3456 #ifdef DEBUG
3457 	if (rval != 0) {
3458 		PR0("ioctl %x set rval = %d, which is not being returned"
3459 		    " to caller", cmd, rval);
3460 	}
3461 #endif /* DEBUG */
3462 
3463 	return (status);
3464 }
3465 
3466 /*
3467  * Description:
3468  *	This is the function that processes the ioctl requests (farming it
3469  *	out to functions that handle slices, files or whole disks)
3470  *
3471  * Return Values
3472  *     0		- ioctl operation completed successfully
3473  *     != 0		- The LDC error value encountered
3474  *			  (propagated back up the call stack as a task error)
3475  *
3476  * Side Effect
3477  *     sets request->status to the return value of the ioctl function.
3478  */
3479 static int
vd_do_ioctl(vd_t * vd,vd_dring_payload_t * request,void * buf,vd_ioctl_t * ioctl)3480 vd_do_ioctl(vd_t *vd, vd_dring_payload_t *request, void* buf, vd_ioctl_t *ioctl)
3481 {
3482 	int	status = 0;
3483 	size_t	nbytes = request->nbytes;	/* modifiable copy */
3484 
3485 
3486 	ASSERT(request->slice < vd->nslices);
3487 	PR0("Performing %s", ioctl->operation_name);
3488 
3489 	/* Get data from client and convert, if necessary */
3490 	if (ioctl->copyin != NULL)  {
3491 		ASSERT(nbytes != 0 && buf != NULL);
3492 		PR1("Getting \"arg\" data from client");
3493 		if ((status = ldc_mem_copy(vd->ldc_handle, buf, 0, &nbytes,
3494 		    request->cookie, request->ncookies,
3495 		    LDC_COPY_IN)) != 0) {
3496 			PR0("ldc_mem_copy() returned errno %d "
3497 			    "copying from client", status);
3498 			return (status);
3499 		}
3500 
3501 		/* Convert client's data, if necessary */
3502 		if (ioctl->copyin == VD_IDENTITY_IN) {
3503 			/* use client buffer */
3504 			ioctl->arg = buf;
3505 		} else {
3506 			/* convert client vdisk operation data to ioctl data */
3507 			status = (ioctl->copyin)(buf, nbytes,
3508 			    (void *)ioctl->arg);
3509 			if (status != 0) {
3510 				request->status = status;
3511 				return (0);
3512 			}
3513 		}
3514 	}
3515 
3516 	if (ioctl->operation == VD_OP_SCSICMD) {
3517 		struct uscsi_cmd *uscsi = (struct uscsi_cmd *)ioctl->arg;
3518 
3519 		/* check write permission */
3520 		if (!(vd->open_flags & FWRITE) &&
3521 		    !(uscsi->uscsi_flags & USCSI_READ)) {
3522 			PR0("uscsi fails because backend is opened read-only");
3523 			request->status = EROFS;
3524 			return (0);
3525 		}
3526 	}
3527 
3528 	/*
3529 	 * Send the ioctl to the disk backend.
3530 	 */
3531 	request->status = vd_backend_ioctl(vd, ioctl->cmd, ioctl->arg);
3532 
3533 	if (request->status != 0) {
3534 		PR0("ioctl(%s) = errno %d", ioctl->cmd_name, request->status);
3535 		if (ioctl->operation == VD_OP_SCSICMD &&
3536 		    ((struct uscsi_cmd *)ioctl->arg)->uscsi_status != 0)
3537 			/*
3538 			 * USCSICMD has reported an error and the uscsi_status
3539 			 * field is not zero. This means that the SCSI command
3540 			 * has completed but it has an error. So we should
3541 			 * mark the VD operation has succesfully completed
3542 			 * and clients can check the SCSI status field for
3543 			 * SCSI errors.
3544 			 */
3545 			request->status = 0;
3546 		else
3547 			return (0);
3548 	}
3549 
3550 	/* Convert data and send to client, if necessary */
3551 	if (ioctl->copyout != NULL)  {
3552 		ASSERT(nbytes != 0 && buf != NULL);
3553 		PR1("Sending \"arg\" data to client");
3554 
3555 		/* Convert ioctl data to vdisk operation data, if necessary */
3556 		if (ioctl->copyout != VD_IDENTITY_OUT)
3557 			(ioctl->copyout)((void *)ioctl->arg, buf);
3558 
3559 		if ((status = ldc_mem_copy(vd->ldc_handle, buf, 0, &nbytes,
3560 		    request->cookie, request->ncookies,
3561 		    LDC_COPY_OUT)) != 0) {
3562 			PR0("ldc_mem_copy() returned errno %d "
3563 			    "copying to client", status);
3564 			return (status);
3565 		}
3566 	}
3567 
3568 	return (status);
3569 }
3570 
3571 #define	RNDSIZE(expr) P2ROUNDUP(sizeof (expr), sizeof (uint64_t))
3572 
3573 /*
3574  * Description:
3575  *	This generic function is called by the task queue to complete
3576  *	the processing of the tasks. The specific completion function
3577  *	is passed in as a field in the task pointer.
3578  *
3579  * Parameters:
3580  *	arg 	- opaque pointer to structure containing task to be completed
3581  *
3582  * Return Values
3583  *	None
3584  */
3585 static void
vd_complete(void * arg)3586 vd_complete(void *arg)
3587 {
3588 	vd_task_t	*task = (vd_task_t *)arg;
3589 
3590 	ASSERT(task != NULL);
3591 	ASSERT(task->status == EINPROGRESS);
3592 	ASSERT(task->completef != NULL);
3593 
3594 	task->status = task->completef(task);
3595 	if (task->status)
3596 		PR0("%s: Error %d completing task", __func__, task->status);
3597 
3598 	/* Now notify the vDisk client */
3599 	vd_complete_notify(task);
3600 }
3601 
3602 static int
vd_ioctl(vd_task_t * task)3603 vd_ioctl(vd_task_t *task)
3604 {
3605 	int			i, status;
3606 	void			*buf = NULL;
3607 	struct dk_geom		dk_geom = {0};
3608 	struct extvtoc		vtoc = {0};
3609 	struct dk_efi		dk_efi = {0};
3610 	struct uscsi_cmd	uscsi = {0};
3611 	vd_t			*vd		= task->vd;
3612 	vd_dring_payload_t	*request	= task->request;
3613 	vd_ioctl_t		ioctl[] = {
3614 		/* Command (no-copy) operations */
3615 		{VD_OP_FLUSH, STRINGIZE(VD_OP_FLUSH), 0,
3616 		    DKIOCFLUSHWRITECACHE, STRINGIZE(DKIOCFLUSHWRITECACHE),
3617 		    NULL, NULL, NULL, B_TRUE},
3618 
3619 		/* "Get" (copy-out) operations */
3620 		{VD_OP_GET_WCE, STRINGIZE(VD_OP_GET_WCE), RNDSIZE(int),
3621 		    DKIOCGETWCE, STRINGIZE(DKIOCGETWCE),
3622 		    NULL, VD_IDENTITY_IN, VD_IDENTITY_OUT, B_FALSE},
3623 		{VD_OP_GET_DISKGEOM, STRINGIZE(VD_OP_GET_DISKGEOM),
3624 		    RNDSIZE(vd_geom_t),
3625 		    DKIOCGGEOM, STRINGIZE(DKIOCGGEOM),
3626 		    &dk_geom, NULL, dk_geom2vd_geom, B_FALSE},
3627 		{VD_OP_GET_VTOC, STRINGIZE(VD_OP_GET_VTOC), RNDSIZE(vd_vtoc_t),
3628 		    DKIOCGEXTVTOC, STRINGIZE(DKIOCGEXTVTOC),
3629 		    &vtoc, NULL, vtoc2vd_vtoc, B_FALSE},
3630 		{VD_OP_GET_EFI, STRINGIZE(VD_OP_GET_EFI), RNDSIZE(vd_efi_t),
3631 		    DKIOCGETEFI, STRINGIZE(DKIOCGETEFI),
3632 		    &dk_efi, vd_get_efi_in, vd_get_efi_out, B_FALSE},
3633 
3634 		/* "Set" (copy-in) operations */
3635 		{VD_OP_SET_WCE, STRINGIZE(VD_OP_SET_WCE), RNDSIZE(int),
3636 		    DKIOCSETWCE, STRINGIZE(DKIOCSETWCE),
3637 		    NULL, VD_IDENTITY_IN, VD_IDENTITY_OUT, B_TRUE},
3638 		{VD_OP_SET_DISKGEOM, STRINGIZE(VD_OP_SET_DISKGEOM),
3639 		    RNDSIZE(vd_geom_t),
3640 		    DKIOCSGEOM, STRINGIZE(DKIOCSGEOM),
3641 		    &dk_geom, vd_geom2dk_geom, NULL, B_TRUE},
3642 		{VD_OP_SET_VTOC, STRINGIZE(VD_OP_SET_VTOC), RNDSIZE(vd_vtoc_t),
3643 		    DKIOCSEXTVTOC, STRINGIZE(DKIOCSEXTVTOC),
3644 		    &vtoc, vd_vtoc2vtoc, NULL, B_TRUE},
3645 		{VD_OP_SET_EFI, STRINGIZE(VD_OP_SET_EFI), RNDSIZE(vd_efi_t),
3646 		    DKIOCSETEFI, STRINGIZE(DKIOCSETEFI),
3647 		    &dk_efi, vd_set_efi_in, vd_set_efi_out, B_TRUE},
3648 
3649 		{VD_OP_SCSICMD, STRINGIZE(VD_OP_SCSICMD), RNDSIZE(vd_scsi_t),
3650 		    USCSICMD, STRINGIZE(USCSICMD),
3651 		    &uscsi, vd_scsicmd_in, vd_scsicmd_out, B_FALSE},
3652 	};
3653 	size_t		nioctls = (sizeof (ioctl))/(sizeof (ioctl[0]));
3654 
3655 
3656 	ASSERT(vd != NULL);
3657 	ASSERT(request != NULL);
3658 	ASSERT(request->slice < vd->nslices);
3659 
3660 	/*
3661 	 * Determine ioctl corresponding to caller's "operation" and
3662 	 * validate caller's "nbytes"
3663 	 */
3664 	for (i = 0; i < nioctls; i++) {
3665 		if (request->operation == ioctl[i].operation) {
3666 			/* LDC memory operations require 8-byte multiples */
3667 			ASSERT(ioctl[i].nbytes % sizeof (uint64_t) == 0);
3668 
3669 			if (request->operation == VD_OP_GET_EFI ||
3670 			    request->operation == VD_OP_SET_EFI ||
3671 			    request->operation == VD_OP_SCSICMD) {
3672 				if (request->nbytes >= ioctl[i].nbytes)
3673 					break;
3674 				PR0("%s:  Expected at least nbytes = %lu, "
3675 				    "got %lu", ioctl[i].operation_name,
3676 				    ioctl[i].nbytes, request->nbytes);
3677 				return (EINVAL);
3678 			}
3679 
3680 			if (request->nbytes != ioctl[i].nbytes) {
3681 				PR0("%s:  Expected nbytes = %lu, got %lu",
3682 				    ioctl[i].operation_name, ioctl[i].nbytes,
3683 				    request->nbytes);
3684 				return (EINVAL);
3685 			}
3686 
3687 			break;
3688 		}
3689 	}
3690 	ASSERT(i < nioctls);	/* because "operation" already validated */
3691 
3692 	if (!(vd->open_flags & FWRITE) && ioctl[i].write) {
3693 		PR0("%s fails because backend is opened read-only",
3694 		    ioctl[i].operation_name);
3695 		request->status = EROFS;
3696 		return (0);
3697 	}
3698 
3699 	if (request->nbytes)
3700 		buf = kmem_zalloc(request->nbytes, KM_SLEEP);
3701 	status = vd_do_ioctl(vd, request, buf, &ioctl[i]);
3702 	if (request->nbytes)
3703 		kmem_free(buf, request->nbytes);
3704 
3705 	return (status);
3706 }
3707 
3708 static int
vd_get_devid(vd_task_t * task)3709 vd_get_devid(vd_task_t *task)
3710 {
3711 	vd_t *vd = task->vd;
3712 	vd_dring_payload_t *request = task->request;
3713 	vd_devid_t *vd_devid;
3714 	impl_devid_t *devid;
3715 	int status, bufid_len, devid_len, len, sz;
3716 	int bufbytes;
3717 
3718 	PR1("Get Device ID, nbytes=%ld", request->nbytes);
3719 
3720 	if (vd->vdisk_type == VD_DISK_TYPE_SLICE) {
3721 		/*
3722 		 * We don't support devid for single-slice disks because we
3723 		 * have no space to store a fabricated devid and for physical
3724 		 * disk slices, we can't use the devid of the disk otherwise
3725 		 * exporting multiple slices from the same disk will produce
3726 		 * the same devids.
3727 		 */
3728 		PR2("No Device ID for slices");
3729 		request->status = ENOTSUP;
3730 		return (0);
3731 	}
3732 
3733 	if (VD_DSKIMG(vd)) {
3734 		if (vd->dskimg_devid == NULL) {
3735 			PR2("No Device ID");
3736 			request->status = ENOENT;
3737 			return (0);
3738 		} else {
3739 			sz = ddi_devid_sizeof(vd->dskimg_devid);
3740 			devid = kmem_alloc(sz, KM_SLEEP);
3741 			bcopy(vd->dskimg_devid, devid, sz);
3742 		}
3743 	} else {
3744 		if (ddi_lyr_get_devid(vd->dev[request->slice],
3745 		    (ddi_devid_t *)&devid) != DDI_SUCCESS) {
3746 			PR2("No Device ID");
3747 			request->status = ENOENT;
3748 			return (0);
3749 		}
3750 	}
3751 
3752 	bufid_len = request->nbytes - sizeof (vd_devid_t) + 1;
3753 	devid_len = DEVID_GETLEN(devid);
3754 
3755 	/*
3756 	 * Save the buffer size here for use in deallocation.
3757 	 * The actual number of bytes copied is returned in
3758 	 * the 'nbytes' field of the request structure.
3759 	 */
3760 	bufbytes = request->nbytes;
3761 
3762 	vd_devid = kmem_zalloc(bufbytes, KM_SLEEP);
3763 	vd_devid->length = devid_len;
3764 	vd_devid->type = DEVID_GETTYPE(devid);
3765 
3766 	len = (devid_len > bufid_len)? bufid_len : devid_len;
3767 
3768 	bcopy(devid->did_id, vd_devid->id, len);
3769 
3770 	request->status = 0;
3771 
3772 	/* LDC memory operations require 8-byte multiples */
3773 	ASSERT(request->nbytes % sizeof (uint64_t) == 0);
3774 
3775 	if ((status = ldc_mem_copy(vd->ldc_handle, (caddr_t)vd_devid, 0,
3776 	    &request->nbytes, request->cookie, request->ncookies,
3777 	    LDC_COPY_OUT)) != 0) {
3778 		PR0("ldc_mem_copy() returned errno %d copying to client",
3779 		    status);
3780 	}
3781 	PR1("post mem_copy: nbytes=%ld", request->nbytes);
3782 
3783 	kmem_free(vd_devid, bufbytes);
3784 	ddi_devid_free((ddi_devid_t)devid);
3785 
3786 	return (status);
3787 }
3788 
3789 static int
vd_scsi_reset(vd_t * vd)3790 vd_scsi_reset(vd_t *vd)
3791 {
3792 	int rval, status;
3793 	struct uscsi_cmd uscsi = { 0 };
3794 
3795 	uscsi.uscsi_flags = vd_scsi_debug | USCSI_RESET;
3796 	uscsi.uscsi_timeout = vd_scsi_rdwr_timeout;
3797 
3798 	status = ldi_ioctl(vd->ldi_handle[0], USCSICMD, (intptr_t)&uscsi,
3799 	    (vd->open_flags | FKIOCTL), kcred, &rval);
3800 
3801 	return (status);
3802 }
3803 
3804 static int
vd_reset(vd_task_t * task)3805 vd_reset(vd_task_t *task)
3806 {
3807 	vd_t *vd = task->vd;
3808 	vd_dring_payload_t *request = task->request;
3809 
3810 	ASSERT(request->operation == VD_OP_RESET);
3811 	ASSERT(vd->scsi);
3812 
3813 	PR0("Performing VD_OP_RESET");
3814 
3815 	if (request->nbytes != 0) {
3816 		PR0("VD_OP_RESET:  Expected nbytes = 0, got %lu",
3817 		    request->nbytes);
3818 		return (EINVAL);
3819 	}
3820 
3821 	request->status = vd_scsi_reset(vd);
3822 
3823 	return (0);
3824 }
3825 
3826 static int
vd_get_capacity(vd_task_t * task)3827 vd_get_capacity(vd_task_t *task)
3828 {
3829 	int rv;
3830 	size_t nbytes;
3831 	vd_t *vd = task->vd;
3832 	vd_dring_payload_t *request = task->request;
3833 	vd_capacity_t vd_cap = { 0 };
3834 
3835 	ASSERT(request->operation == VD_OP_GET_CAPACITY);
3836 
3837 	PR0("Performing VD_OP_GET_CAPACITY");
3838 
3839 	nbytes = request->nbytes;
3840 
3841 	if (nbytes != RNDSIZE(vd_capacity_t)) {
3842 		PR0("VD_OP_GET_CAPACITY:  Expected nbytes = %lu, got %lu",
3843 		    RNDSIZE(vd_capacity_t), nbytes);
3844 		return (EINVAL);
3845 	}
3846 
3847 	/*
3848 	 * Check the backend size in case it has changed. If the check fails
3849 	 * then we will return the last known size.
3850 	 */
3851 
3852 	(void) vd_backend_check_size(vd);
3853 	ASSERT(vd->vdisk_size != 0);
3854 
3855 	request->status = 0;
3856 
3857 	vd_cap.vdisk_block_size = vd->vdisk_bsize;
3858 	vd_cap.vdisk_size = vd->vdisk_size;
3859 
3860 	if ((rv = ldc_mem_copy(vd->ldc_handle, (char *)&vd_cap, 0, &nbytes,
3861 	    request->cookie, request->ncookies, LDC_COPY_OUT)) != 0) {
3862 		PR0("ldc_mem_copy() returned errno %d copying to client", rv);
3863 		return (rv);
3864 	}
3865 
3866 	return (0);
3867 }
3868 
3869 static int
vd_get_access(vd_task_t * task)3870 vd_get_access(vd_task_t *task)
3871 {
3872 	uint64_t access;
3873 	int rv, rval = 0;
3874 	size_t nbytes;
3875 	vd_t *vd = task->vd;
3876 	vd_dring_payload_t *request = task->request;
3877 
3878 	ASSERT(request->operation == VD_OP_GET_ACCESS);
3879 	ASSERT(vd->scsi);
3880 
3881 	PR0("Performing VD_OP_GET_ACCESS");
3882 
3883 	nbytes = request->nbytes;
3884 
3885 	if (nbytes != sizeof (uint64_t)) {
3886 		PR0("VD_OP_GET_ACCESS:  Expected nbytes = %lu, got %lu",
3887 		    sizeof (uint64_t), nbytes);
3888 		return (EINVAL);
3889 	}
3890 
3891 	request->status = ldi_ioctl(vd->ldi_handle[request->slice], MHIOCSTATUS,
3892 	    NULL, (vd->open_flags | FKIOCTL), kcred, &rval);
3893 
3894 	if (request->status != 0)
3895 		return (0);
3896 
3897 	access = (rval == 0)? VD_ACCESS_ALLOWED : VD_ACCESS_DENIED;
3898 
3899 	if ((rv = ldc_mem_copy(vd->ldc_handle, (char *)&access, 0, &nbytes,
3900 	    request->cookie, request->ncookies, LDC_COPY_OUT)) != 0) {
3901 		PR0("ldc_mem_copy() returned errno %d copying to client", rv);
3902 		return (rv);
3903 	}
3904 
3905 	return (0);
3906 }
3907 
3908 static int
vd_set_access(vd_task_t * task)3909 vd_set_access(vd_task_t *task)
3910 {
3911 	uint64_t flags;
3912 	int rv, rval;
3913 	size_t nbytes;
3914 	vd_t *vd = task->vd;
3915 	vd_dring_payload_t *request = task->request;
3916 
3917 	ASSERT(request->operation == VD_OP_SET_ACCESS);
3918 	ASSERT(vd->scsi);
3919 
3920 	nbytes = request->nbytes;
3921 
3922 	if (nbytes != sizeof (uint64_t)) {
3923 		PR0("VD_OP_SET_ACCESS:  Expected nbytes = %lu, got %lu",
3924 		    sizeof (uint64_t), nbytes);
3925 		return (EINVAL);
3926 	}
3927 
3928 	if ((rv = ldc_mem_copy(vd->ldc_handle, (char *)&flags, 0, &nbytes,
3929 	    request->cookie, request->ncookies, LDC_COPY_IN)) != 0) {
3930 		PR0("ldc_mem_copy() returned errno %d copying from client", rv);
3931 		return (rv);
3932 	}
3933 
3934 	if (flags == VD_ACCESS_SET_CLEAR) {
3935 		PR0("Performing VD_OP_SET_ACCESS (CLEAR)");
3936 		request->status = ldi_ioctl(vd->ldi_handle[request->slice],
3937 		    MHIOCRELEASE, NULL, (vd->open_flags | FKIOCTL), kcred,
3938 		    &rval);
3939 		if (request->status == 0)
3940 			vd->ownership = B_FALSE;
3941 		return (0);
3942 	}
3943 
3944 	/*
3945 	 * As per the VIO spec, the PREEMPT and PRESERVE flags are only valid
3946 	 * when the EXCLUSIVE flag is set.
3947 	 */
3948 	if (!(flags & VD_ACCESS_SET_EXCLUSIVE)) {
3949 		PR0("Invalid VD_OP_SET_ACCESS flags: 0x%lx", flags);
3950 		request->status = EINVAL;
3951 		return (0);
3952 	}
3953 
3954 	switch (flags & (VD_ACCESS_SET_PREEMPT | VD_ACCESS_SET_PRESERVE)) {
3955 
3956 	case VD_ACCESS_SET_PREEMPT | VD_ACCESS_SET_PRESERVE:
3957 		/*
3958 		 * Flags EXCLUSIVE and PREEMPT and PRESERVE. We have to
3959 		 * acquire exclusive access rights, preserve them and we
3960 		 * can use preemption. So we can use the MHIOCTKNOWN ioctl.
3961 		 */
3962 		PR0("Performing VD_OP_SET_ACCESS (EXCLUSIVE|PREEMPT|PRESERVE)");
3963 		request->status = ldi_ioctl(vd->ldi_handle[request->slice],
3964 		    MHIOCTKOWN, NULL, (vd->open_flags | FKIOCTL), kcred, &rval);
3965 		break;
3966 
3967 	case VD_ACCESS_SET_PRESERVE:
3968 		/*
3969 		 * Flags EXCLUSIVE and PRESERVE. We have to acquire exclusive
3970 		 * access rights and preserve them, but not preempt any other
3971 		 * host. So we need to use the MHIOCTKOWN ioctl to enable the
3972 		 * "preserve" feature but we can not called it directly
3973 		 * because it uses preemption. So before that, we use the
3974 		 * MHIOCQRESERVE ioctl to ensure we can get exclusive rights
3975 		 * without preempting anyone.
3976 		 */
3977 		PR0("Performing VD_OP_SET_ACCESS (EXCLUSIVE|PRESERVE)");
3978 		request->status = ldi_ioctl(vd->ldi_handle[request->slice],
3979 		    MHIOCQRESERVE, NULL, (vd->open_flags | FKIOCTL), kcred,
3980 		    &rval);
3981 		if (request->status != 0)
3982 			break;
3983 		request->status = ldi_ioctl(vd->ldi_handle[request->slice],
3984 		    MHIOCTKOWN, NULL, (vd->open_flags | FKIOCTL), kcred, &rval);
3985 		break;
3986 
3987 	case VD_ACCESS_SET_PREEMPT:
3988 		/*
3989 		 * Flags EXCLUSIVE and PREEMPT. We have to acquire exclusive
3990 		 * access rights and we can use preemption. So we try to do
3991 		 * a SCSI reservation, if it fails we reset the disk to clear
3992 		 * any reservation and we try to reserve again.
3993 		 */
3994 		PR0("Performing VD_OP_SET_ACCESS (EXCLUSIVE|PREEMPT)");
3995 		request->status = ldi_ioctl(vd->ldi_handle[request->slice],
3996 		    MHIOCQRESERVE, NULL, (vd->open_flags | FKIOCTL), kcred,
3997 		    &rval);
3998 		if (request->status == 0)
3999 			break;
4000 
4001 		/* reset the disk */
4002 		(void) vd_scsi_reset(vd);
4003 
4004 		/* try again even if the reset has failed */
4005 		request->status = ldi_ioctl(vd->ldi_handle[request->slice],
4006 		    MHIOCQRESERVE, NULL, (vd->open_flags | FKIOCTL), kcred,
4007 		    &rval);
4008 		break;
4009 
4010 	case 0:
4011 		/* Flag EXCLUSIVE only. Just issue a SCSI reservation */
4012 		PR0("Performing VD_OP_SET_ACCESS (EXCLUSIVE)");
4013 		request->status = ldi_ioctl(vd->ldi_handle[request->slice],
4014 		    MHIOCQRESERVE, NULL, (vd->open_flags | FKIOCTL), kcred,
4015 		    &rval);
4016 		break;
4017 	}
4018 
4019 	if (request->status == 0)
4020 		vd->ownership = B_TRUE;
4021 	else
4022 		PR0("VD_OP_SET_ACCESS: error %d", request->status);
4023 
4024 	return (0);
4025 }
4026 
4027 static void
vd_reset_access(vd_t * vd)4028 vd_reset_access(vd_t *vd)
4029 {
4030 	int status, rval;
4031 
4032 	if (vd->file || vd->volume || !vd->ownership)
4033 		return;
4034 
4035 	PR0("Releasing disk ownership");
4036 	status = ldi_ioctl(vd->ldi_handle[0], MHIOCRELEASE, NULL,
4037 	    (vd->open_flags | FKIOCTL), kcred, &rval);
4038 
4039 	/*
4040 	 * An EACCES failure means that there is a reservation conflict,
4041 	 * so we are not the owner of the disk anymore.
4042 	 */
4043 	if (status == 0 || status == EACCES) {
4044 		vd->ownership = B_FALSE;
4045 		return;
4046 	}
4047 
4048 	PR0("Fail to release ownership, error %d", status);
4049 
4050 	/*
4051 	 * We have failed to release the ownership, try to reset the disk
4052 	 * to release reservations.
4053 	 */
4054 	PR0("Resetting disk");
4055 	status = vd_scsi_reset(vd);
4056 
4057 	if (status != 0)
4058 		PR0("Fail to reset disk, error %d", status);
4059 
4060 	/* whatever the result of the reset is, we try the release again */
4061 	status = ldi_ioctl(vd->ldi_handle[0], MHIOCRELEASE, NULL,
4062 	    (vd->open_flags | FKIOCTL), kcred, &rval);
4063 
4064 	if (status == 0 || status == EACCES) {
4065 		vd->ownership = B_FALSE;
4066 		return;
4067 	}
4068 
4069 	PR0("Fail to release ownership, error %d", status);
4070 
4071 	/*
4072 	 * At this point we have done our best to try to reset the
4073 	 * access rights to the disk and we don't know if we still
4074 	 * own a reservation and if any mechanism to preserve the
4075 	 * ownership is still in place. The ultimate solution would
4076 	 * be to reset the system but this is usually not what we
4077 	 * want to happen.
4078 	 */
4079 
4080 	if (vd_reset_access_failure == A_REBOOT) {
4081 		cmn_err(CE_WARN, VD_RESET_ACCESS_FAILURE_MSG
4082 		    ", rebooting the system", vd->device_path);
4083 		(void) uadmin(A_SHUTDOWN, AD_BOOT, NULL);
4084 	} else if (vd_reset_access_failure == A_DUMP) {
4085 		panic(VD_RESET_ACCESS_FAILURE_MSG, vd->device_path);
4086 	}
4087 
4088 	cmn_err(CE_WARN, VD_RESET_ACCESS_FAILURE_MSG, vd->device_path);
4089 }
4090 
4091 /*
4092  * Define the supported operations once the functions for performing them have
4093  * been defined
4094  */
4095 static const vds_operation_t	vds_operation[] = {
4096 #define	X(_s)	#_s, _s
4097 	{X(VD_OP_BREAD),	vd_start_bio,	vd_complete_bio},
4098 	{X(VD_OP_BWRITE),	vd_start_bio,	vd_complete_bio},
4099 	{X(VD_OP_FLUSH),	vd_ioctl,	NULL},
4100 	{X(VD_OP_GET_WCE),	vd_ioctl,	NULL},
4101 	{X(VD_OP_SET_WCE),	vd_ioctl,	NULL},
4102 	{X(VD_OP_GET_VTOC),	vd_ioctl,	NULL},
4103 	{X(VD_OP_SET_VTOC),	vd_ioctl,	NULL},
4104 	{X(VD_OP_GET_DISKGEOM),	vd_ioctl,	NULL},
4105 	{X(VD_OP_SET_DISKGEOM),	vd_ioctl,	NULL},
4106 	{X(VD_OP_GET_EFI),	vd_ioctl,	NULL},
4107 	{X(VD_OP_SET_EFI),	vd_ioctl,	NULL},
4108 	{X(VD_OP_GET_DEVID),	vd_get_devid,	NULL},
4109 	{X(VD_OP_SCSICMD),	vd_ioctl,	NULL},
4110 	{X(VD_OP_RESET),	vd_reset,	NULL},
4111 	{X(VD_OP_GET_CAPACITY),	vd_get_capacity, NULL},
4112 	{X(VD_OP_SET_ACCESS),	vd_set_access,	NULL},
4113 	{X(VD_OP_GET_ACCESS),	vd_get_access,	NULL},
4114 #undef	X
4115 };
4116 
4117 static const size_t	vds_noperations =
4118 	(sizeof (vds_operation))/(sizeof (vds_operation[0]));
4119 
4120 /*
4121  * Process a task specifying a client I/O request
4122  *
4123  * Parameters:
4124  *	task 		- structure containing the request sent from client
4125  *
4126  * Return Value
4127  *	0	- success
4128  *	ENOTSUP	- Unknown/Unsupported VD_OP_XXX operation
4129  *	EINVAL	- Invalid disk slice
4130  *	!= 0	- some other non-zero return value from start function
4131  */
4132 static int
vd_do_process_task(vd_task_t * task)4133 vd_do_process_task(vd_task_t *task)
4134 {
4135 	int			i;
4136 	vd_t			*vd		= task->vd;
4137 	vd_dring_payload_t	*request	= task->request;
4138 
4139 	ASSERT(vd != NULL);
4140 	ASSERT(request != NULL);
4141 
4142 	/* Find the requested operation */
4143 	for (i = 0; i < vds_noperations; i++) {
4144 		if (request->operation == vds_operation[i].operation) {
4145 			/* all operations should have a start func */
4146 			ASSERT(vds_operation[i].start != NULL);
4147 
4148 			task->completef = vds_operation[i].complete;
4149 			break;
4150 		}
4151 	}
4152 
4153 	/*
4154 	 * We need to check that the requested operation is permitted
4155 	 * for the particular client that sent it or that the loop above
4156 	 * did not complete without finding the operation type (indicating
4157 	 * that the requested operation is unknown/unimplemented)
4158 	 */
4159 	if ((VD_OP_SUPPORTED(vd->operations, request->operation) == B_FALSE) ||
4160 	    (i == vds_noperations)) {
4161 		PR0("Unsupported operation %u", request->operation);
4162 		request->status = ENOTSUP;
4163 		return (0);
4164 	}
4165 
4166 	/* Range-check slice */
4167 	if (request->slice >= vd->nslices &&
4168 	    ((vd->vdisk_type != VD_DISK_TYPE_DISK && vd_slice_single_slice) ||
4169 	    request->slice != VD_SLICE_NONE)) {
4170 		PR0("Invalid \"slice\" %u (max %u) for virtual disk",
4171 		    request->slice, (vd->nslices - 1));
4172 		request->status = EINVAL;
4173 		return (0);
4174 	}
4175 
4176 	/*
4177 	 * Call the function pointer that starts the operation.
4178 	 */
4179 	return (vds_operation[i].start(task));
4180 }
4181 
4182 /*
4183  * Description:
4184  *	This function is called by both the in-band and descriptor ring
4185  *	message processing functions paths to actually execute the task
4186  *	requested by the vDisk client. It in turn calls its worker
4187  *	function, vd_do_process_task(), to carry our the request.
4188  *
4189  *	Any transport errors (e.g. LDC errors, vDisk protocol errors) are
4190  *	saved in the 'status' field of the task and are propagated back
4191  *	up the call stack to trigger a NACK
4192  *
4193  *	Any request errors (e.g. ENOTTY from an ioctl) are saved in
4194  *	the 'status' field of the request and result in an ACK being sent
4195  *	by the completion handler.
4196  *
4197  * Parameters:
4198  *	task 		- structure containing the request sent from client
4199  *
4200  * Return Value
4201  *	0		- successful synchronous request.
4202  *	!= 0		- transport error (e.g. LDC errors, vDisk protocol)
4203  *	EINPROGRESS	- task will be finished in a completion handler
4204  */
4205 static int
vd_process_task(vd_task_t * task)4206 vd_process_task(vd_task_t *task)
4207 {
4208 	vd_t	*vd = task->vd;
4209 	int	status;
4210 
4211 	DTRACE_PROBE1(task__start, vd_task_t *, task);
4212 
4213 	task->status =  vd_do_process_task(task);
4214 
4215 	/*
4216 	 * If the task processing function returned EINPROGRESS indicating
4217 	 * that the task needs completing then schedule a taskq entry to
4218 	 * finish it now.
4219 	 *
4220 	 * Otherwise the task processing function returned either zero
4221 	 * indicating that the task was finished in the start function (and we
4222 	 * don't need to wait in a completion function) or the start function
4223 	 * returned an error - in both cases all that needs to happen is the
4224 	 * notification to the vDisk client higher up the call stack.
4225 	 * If the task was using a Descriptor Ring, we need to mark it as done
4226 	 * at this stage.
4227 	 */
4228 	if (task->status == EINPROGRESS) {
4229 		/* Queue a task to complete the operation */
4230 		(void) ddi_taskq_dispatch(vd->completionq, vd_complete,
4231 		    task, DDI_SLEEP);
4232 		return (EINPROGRESS);
4233 	}
4234 
4235 	if (!vd->reset_state && (vd->xfer_mode == VIO_DRING_MODE_V1_0)) {
4236 		/* Update the dring element if it's a dring client */
4237 		status = vd_mark_elem_done(vd, task->index,
4238 		    task->request->status, task->request->nbytes);
4239 		if (status == ECONNRESET)
4240 			vd_mark_in_reset(vd);
4241 		else if (status == EACCES)
4242 			vd_need_reset(vd, B_TRUE);
4243 	}
4244 
4245 	return (task->status);
4246 }
4247 
4248 /*
4249  * Return true if the "type", "subtype", and "env" fields of the "tag" first
4250  * argument match the corresponding remaining arguments; otherwise, return false
4251  */
4252 boolean_t
vd_msgtype(vio_msg_tag_t * tag,int type,int subtype,int env)4253 vd_msgtype(vio_msg_tag_t *tag, int type, int subtype, int env)
4254 {
4255 	return ((tag->vio_msgtype == type) &&
4256 	    (tag->vio_subtype == subtype) &&
4257 	    (tag->vio_subtype_env == env)) ? B_TRUE : B_FALSE;
4258 }
4259 
4260 /*
4261  * Check whether the major/minor version specified in "ver_msg" is supported
4262  * by this server.
4263  */
4264 static boolean_t
vds_supported_version(vio_ver_msg_t * ver_msg)4265 vds_supported_version(vio_ver_msg_t *ver_msg)
4266 {
4267 	for (int i = 0; i < vds_num_versions; i++) {
4268 		ASSERT(vds_version[i].major > 0);
4269 		ASSERT((i == 0) ||
4270 		    (vds_version[i].major < vds_version[i-1].major));
4271 
4272 		/*
4273 		 * If the major versions match, adjust the minor version, if
4274 		 * necessary, down to the highest value supported by this
4275 		 * server and return true so this message will get "ack"ed;
4276 		 * the client should also support all minor versions lower
4277 		 * than the value it sent
4278 		 */
4279 		if (ver_msg->ver_major == vds_version[i].major) {
4280 			if (ver_msg->ver_minor > vds_version[i].minor) {
4281 				PR0("Adjusting minor version from %u to %u",
4282 				    ver_msg->ver_minor, vds_version[i].minor);
4283 				ver_msg->ver_minor = vds_version[i].minor;
4284 			}
4285 			return (B_TRUE);
4286 		}
4287 
4288 		/*
4289 		 * If the message contains a higher major version number, set
4290 		 * the message's major/minor versions to the current values
4291 		 * and return false, so this message will get "nack"ed with
4292 		 * these values, and the client will potentially try again
4293 		 * with the same or a lower version
4294 		 */
4295 		if (ver_msg->ver_major > vds_version[i].major) {
4296 			ver_msg->ver_major = vds_version[i].major;
4297 			ver_msg->ver_minor = vds_version[i].minor;
4298 			return (B_FALSE);
4299 		}
4300 
4301 		/*
4302 		 * Otherwise, the message's major version is less than the
4303 		 * current major version, so continue the loop to the next
4304 		 * (lower) supported version
4305 		 */
4306 	}
4307 
4308 	/*
4309 	 * No common version was found; "ground" the version pair in the
4310 	 * message to terminate negotiation
4311 	 */
4312 	ver_msg->ver_major = 0;
4313 	ver_msg->ver_minor = 0;
4314 	return (B_FALSE);
4315 }
4316 
4317 /*
4318  * Process a version message from a client.  vds expects to receive version
4319  * messages from clients seeking service, but never issues version messages
4320  * itself; therefore, vds can ACK or NACK client version messages, but does
4321  * not expect to receive version-message ACKs or NACKs (and will treat such
4322  * messages as invalid).
4323  */
4324 static int
vd_process_ver_msg(vd_t * vd,vio_msg_t * msg,size_t msglen)4325 vd_process_ver_msg(vd_t *vd, vio_msg_t *msg, size_t msglen)
4326 {
4327 	vio_ver_msg_t	*ver_msg = (vio_ver_msg_t *)msg;
4328 
4329 
4330 	ASSERT(msglen >= sizeof (msg->tag));
4331 
4332 	if (!vd_msgtype(&msg->tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO,
4333 	    VIO_VER_INFO)) {
4334 		return (ENOMSG);	/* not a version message */
4335 	}
4336 
4337 	if (msglen != sizeof (*ver_msg)) {
4338 		PR0("Expected %lu-byte version message; "
4339 		    "received %lu bytes", sizeof (*ver_msg), msglen);
4340 		return (EBADMSG);
4341 	}
4342 
4343 	if (ver_msg->dev_class != VDEV_DISK) {
4344 		PR0("Expected device class %u (disk); received %u",
4345 		    VDEV_DISK, ver_msg->dev_class);
4346 		return (EBADMSG);
4347 	}
4348 
4349 	/*
4350 	 * We're talking to the expected kind of client; set our device class
4351 	 * for "ack/nack" back to the client
4352 	 */
4353 	ver_msg->dev_class = VDEV_DISK_SERVER;
4354 
4355 	/*
4356 	 * Check whether the (valid) version message specifies a version
4357 	 * supported by this server.  If the version is not supported, return
4358 	 * EBADMSG so the message will get "nack"ed; vds_supported_version()
4359 	 * will have updated the message with a supported version for the
4360 	 * client to consider
4361 	 */
4362 	if (!vds_supported_version(ver_msg))
4363 		return (EBADMSG);
4364 
4365 
4366 	/*
4367 	 * A version has been agreed upon; use the client's SID for
4368 	 * communication on this channel now
4369 	 */
4370 	ASSERT(!(vd->initialized & VD_SID));
4371 	vd->sid = ver_msg->tag.vio_sid;
4372 	vd->initialized |= VD_SID;
4373 
4374 	/*
4375 	 * Store the negotiated major and minor version values in the "vd" data
4376 	 * structure so that we can check if certain operations are supported
4377 	 * by the client.
4378 	 */
4379 	vd->version.major = ver_msg->ver_major;
4380 	vd->version.minor = ver_msg->ver_minor;
4381 
4382 	PR0("Using major version %u, minor version %u",
4383 	    ver_msg->ver_major, ver_msg->ver_minor);
4384 	return (0);
4385 }
4386 
4387 static void
vd_set_exported_operations(vd_t * vd)4388 vd_set_exported_operations(vd_t *vd)
4389 {
4390 	vd->operations = 0;	/* clear field */
4391 
4392 	/*
4393 	 * We need to check from the highest version supported to the
4394 	 * lowest because versions with a higher minor number implicitly
4395 	 * support versions with a lower minor number.
4396 	 */
4397 	if (vio_ver_is_supported(vd->version, 1, 1)) {
4398 		ASSERT(vd->open_flags & FREAD);
4399 		vd->operations |= VD_OP_MASK_READ | (1 << VD_OP_GET_CAPACITY);
4400 
4401 		if (vd->open_flags & FWRITE)
4402 			vd->operations |= VD_OP_MASK_WRITE;
4403 
4404 		if (vd->scsi)
4405 			vd->operations |= VD_OP_MASK_SCSI;
4406 
4407 		if (VD_DSKIMG(vd) && vd_dskimg_is_iso_image(vd)) {
4408 			/*
4409 			 * can't write to ISO images, make sure that write
4410 			 * support is not set in case administrator did not
4411 			 * use "options=ro" when doing an ldm add-vdsdev
4412 			 */
4413 			vd->operations &= ~VD_OP_MASK_WRITE;
4414 		}
4415 	} else if (vio_ver_is_supported(vd->version, 1, 0)) {
4416 		vd->operations = VD_OP_MASK_READ | VD_OP_MASK_WRITE;
4417 	}
4418 
4419 	/* we should have already agreed on a version */
4420 	ASSERT(vd->operations != 0);
4421 }
4422 
4423 static int
vd_process_attr_msg(vd_t * vd,vio_msg_t * msg,size_t msglen)4424 vd_process_attr_msg(vd_t *vd, vio_msg_t *msg, size_t msglen)
4425 {
4426 	vd_attr_msg_t	*attr_msg = (vd_attr_msg_t *)msg;
4427 	int		status, retry = 0;
4428 
4429 
4430 	ASSERT(msglen >= sizeof (msg->tag));
4431 
4432 	if (!vd_msgtype(&msg->tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO,
4433 	    VIO_ATTR_INFO)) {
4434 		PR0("Message is not an attribute message");
4435 		return (ENOMSG);
4436 	}
4437 
4438 	if (msglen != sizeof (*attr_msg)) {
4439 		PR0("Expected %lu-byte attribute message; "
4440 		    "received %lu bytes", sizeof (*attr_msg), msglen);
4441 		return (EBADMSG);
4442 	}
4443 
4444 	if (attr_msg->max_xfer_sz == 0) {
4445 		PR0("Received maximum transfer size of 0 from client");
4446 		return (EBADMSG);
4447 	}
4448 
4449 	if ((attr_msg->xfer_mode != VIO_DESC_MODE) &&
4450 	    (attr_msg->xfer_mode != VIO_DRING_MODE_V1_0)) {
4451 		PR0("Client requested unsupported transfer mode");
4452 		return (EBADMSG);
4453 	}
4454 
4455 	/*
4456 	 * check if the underlying disk is ready, if not try accessing
4457 	 * the device again. Open the vdisk device and extract info
4458 	 * about it, as this is needed to respond to the attr info msg
4459 	 */
4460 	if ((vd->initialized & VD_DISK_READY) == 0) {
4461 		PR0("Retry setting up disk (%s)", vd->device_path);
4462 		do {
4463 			status = vd_setup_vd(vd);
4464 			if (status != EAGAIN || ++retry > vds_dev_retries)
4465 				break;
4466 
4467 			/* incremental delay */
4468 			delay(drv_usectohz(vds_dev_delay));
4469 
4470 			/* if vdisk is no longer enabled - return error */
4471 			if (!vd_enabled(vd))
4472 				return (ENXIO);
4473 
4474 		} while (status == EAGAIN);
4475 
4476 		if (status)
4477 			return (ENXIO);
4478 
4479 		vd->initialized |= VD_DISK_READY;
4480 		ASSERT(vd->nslices > 0 && vd->nslices <= V_NUMPAR);
4481 		PR0("vdisk_type = %s, volume = %s, file = %s, nslices = %u",
4482 		    ((vd->vdisk_type == VD_DISK_TYPE_DISK) ? "disk" : "slice"),
4483 		    (vd->volume ? "yes" : "no"),
4484 		    (vd->file ? "yes" : "no"),
4485 		    vd->nslices);
4486 	}
4487 
4488 	/* Success:  valid message and transfer mode */
4489 	vd->xfer_mode = attr_msg->xfer_mode;
4490 
4491 	if (vd->xfer_mode == VIO_DESC_MODE) {
4492 
4493 		/*
4494 		 * The vd_dring_inband_msg_t contains one cookie; need room
4495 		 * for up to n-1 more cookies, where "n" is the number of full
4496 		 * pages plus possibly one partial page required to cover
4497 		 * "max_xfer_sz".  Add room for one more cookie if
4498 		 * "max_xfer_sz" isn't an integral multiple of the page size.
4499 		 * Must first get the maximum transfer size in bytes.
4500 		 */
4501 		size_t	max_xfer_bytes = attr_msg->vdisk_block_size ?
4502 		    attr_msg->vdisk_block_size * attr_msg->max_xfer_sz :
4503 		    attr_msg->max_xfer_sz;
4504 		size_t	max_inband_msglen =
4505 		    sizeof (vd_dring_inband_msg_t) +
4506 		    ((max_xfer_bytes/PAGESIZE +
4507 		    ((max_xfer_bytes % PAGESIZE) ? 1 : 0))*
4508 		    (sizeof (ldc_mem_cookie_t)));
4509 
4510 		/*
4511 		 * Set the maximum expected message length to
4512 		 * accommodate in-band-descriptor messages with all
4513 		 * their cookies
4514 		 */
4515 		vd->max_msglen = MAX(vd->max_msglen, max_inband_msglen);
4516 
4517 		/*
4518 		 * Initialize the data structure for processing in-band I/O
4519 		 * request descriptors
4520 		 */
4521 		vd->inband_task.vd	= vd;
4522 		vd->inband_task.msg	= kmem_alloc(vd->max_msglen, KM_SLEEP);
4523 		vd->inband_task.index	= 0;
4524 		vd->inband_task.type	= VD_FINAL_RANGE_TASK;	/* range == 1 */
4525 	}
4526 
4527 	/* Return the device's block size and max transfer size to the client */
4528 	attr_msg->vdisk_block_size	= vd->vdisk_bsize;
4529 	attr_msg->max_xfer_sz		= vd->max_xfer_sz;
4530 
4531 	attr_msg->vdisk_size = vd->vdisk_size;
4532 	attr_msg->vdisk_type = (vd_slice_single_slice)? vd->vdisk_type :
4533 	    VD_DISK_TYPE_DISK;
4534 	attr_msg->vdisk_media = vd->vdisk_media;
4535 
4536 	/* Discover and save the list of supported VD_OP_XXX operations */
4537 	vd_set_exported_operations(vd);
4538 	attr_msg->operations = vd->operations;
4539 
4540 	PR0("%s", VD_CLIENT(vd));
4541 
4542 	ASSERT(vd->dring_task == NULL);
4543 
4544 	return (0);
4545 }
4546 
4547 static int
vd_process_dring_reg_msg(vd_t * vd,vio_msg_t * msg,size_t msglen)4548 vd_process_dring_reg_msg(vd_t *vd, vio_msg_t *msg, size_t msglen)
4549 {
4550 	int			status;
4551 	size_t			expected;
4552 	ldc_mem_info_t		dring_minfo;
4553 	uint8_t			mtype;
4554 	vio_dring_reg_msg_t	*reg_msg = (vio_dring_reg_msg_t *)msg;
4555 
4556 
4557 	ASSERT(msglen >= sizeof (msg->tag));
4558 
4559 	if (!vd_msgtype(&msg->tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO,
4560 	    VIO_DRING_REG)) {
4561 		PR0("Message is not a register-dring message");
4562 		return (ENOMSG);
4563 	}
4564 
4565 	if (msglen < sizeof (*reg_msg)) {
4566 		PR0("Expected at least %lu-byte register-dring message; "
4567 		    "received %lu bytes", sizeof (*reg_msg), msglen);
4568 		return (EBADMSG);
4569 	}
4570 
4571 	expected = sizeof (*reg_msg) +
4572 	    (reg_msg->ncookies - 1)*(sizeof (reg_msg->cookie[0]));
4573 	if (msglen != expected) {
4574 		PR0("Expected %lu-byte register-dring message; "
4575 		    "received %lu bytes", expected, msglen);
4576 		return (EBADMSG);
4577 	}
4578 
4579 	if (vd->initialized & VD_DRING) {
4580 		PR0("A dring was previously registered; only support one");
4581 		return (EBADMSG);
4582 	}
4583 
4584 	if (reg_msg->num_descriptors > INT32_MAX) {
4585 		PR0("reg_msg->num_descriptors = %u; must be <= %u (%s)",
4586 		    reg_msg->ncookies, INT32_MAX, STRINGIZE(INT32_MAX));
4587 		return (EBADMSG);
4588 	}
4589 
4590 	if (reg_msg->ncookies != 1) {
4591 		/*
4592 		 * In addition to fixing the assertion in the success case
4593 		 * below, supporting drings which require more than one
4594 		 * "cookie" requires increasing the value of vd->max_msglen
4595 		 * somewhere in the code path prior to receiving the message
4596 		 * which results in calling this function.  Note that without
4597 		 * making this change, the larger message size required to
4598 		 * accommodate multiple cookies cannot be successfully
4599 		 * received, so this function will not even get called.
4600 		 * Gracefully accommodating more dring cookies might
4601 		 * reasonably demand exchanging an additional attribute or
4602 		 * making a minor protocol adjustment
4603 		 */
4604 		PR0("reg_msg->ncookies = %u != 1", reg_msg->ncookies);
4605 		return (EBADMSG);
4606 	}
4607 
4608 	if (vd_direct_mapped_drings)
4609 		mtype = LDC_DIRECT_MAP;
4610 	else
4611 		mtype = LDC_SHADOW_MAP;
4612 
4613 	status = ldc_mem_dring_map(vd->ldc_handle, reg_msg->cookie,
4614 	    reg_msg->ncookies, reg_msg->num_descriptors,
4615 	    reg_msg->descriptor_size, mtype, &vd->dring_handle);
4616 	if (status != 0) {
4617 		PR0("ldc_mem_dring_map() returned errno %d", status);
4618 		return (status);
4619 	}
4620 
4621 	/*
4622 	 * To remove the need for this assertion, must call
4623 	 * ldc_mem_dring_nextcookie() successfully ncookies-1 times after a
4624 	 * successful call to ldc_mem_dring_map()
4625 	 */
4626 	ASSERT(reg_msg->ncookies == 1);
4627 
4628 	if ((status =
4629 	    ldc_mem_dring_info(vd->dring_handle, &dring_minfo)) != 0) {
4630 		PR0("ldc_mem_dring_info() returned errno %d", status);
4631 		if ((status = ldc_mem_dring_unmap(vd->dring_handle)) != 0)
4632 			PR0("ldc_mem_dring_unmap() returned errno %d", status);
4633 		return (status);
4634 	}
4635 
4636 	if (dring_minfo.vaddr == NULL) {
4637 		PR0("Descriptor ring virtual address is NULL");
4638 		return (ENXIO);
4639 	}
4640 
4641 
4642 	/* Initialize for valid message and mapped dring */
4643 	vd->initialized |= VD_DRING;
4644 	vd->dring_ident = 1;	/* "There Can Be Only One" */
4645 	vd->dring = dring_minfo.vaddr;
4646 	vd->descriptor_size = reg_msg->descriptor_size;
4647 	vd->dring_len = reg_msg->num_descriptors;
4648 	vd->dring_mtype = dring_minfo.mtype;
4649 	reg_msg->dring_ident = vd->dring_ident;
4650 	PR1("descriptor size = %u, dring length = %u",
4651 	    vd->descriptor_size, vd->dring_len);
4652 
4653 	/*
4654 	 * Allocate and initialize a "shadow" array of data structures for
4655 	 * tasks to process I/O requests in dring elements
4656 	 */
4657 	vd->dring_task =
4658 	    kmem_zalloc((sizeof (*vd->dring_task)) * vd->dring_len, KM_SLEEP);
4659 	for (int i = 0; i < vd->dring_len; i++) {
4660 		vd->dring_task[i].vd		= vd;
4661 		vd->dring_task[i].index		= i;
4662 
4663 		status = ldc_mem_alloc_handle(vd->ldc_handle,
4664 		    &(vd->dring_task[i].mhdl));
4665 		if (status) {
4666 			PR0("ldc_mem_alloc_handle() returned err %d ", status);
4667 			return (ENXIO);
4668 		}
4669 
4670 		/*
4671 		 * The descriptor payload varies in length. Calculate its
4672 		 * size by subtracting the header size from the total
4673 		 * descriptor size.
4674 		 */
4675 		vd->dring_task[i].request = kmem_zalloc((vd->descriptor_size -
4676 		    sizeof (vio_dring_entry_hdr_t)), KM_SLEEP);
4677 		vd->dring_task[i].msg = kmem_alloc(vd->max_msglen, KM_SLEEP);
4678 	}
4679 
4680 	if (vd->file || vd->zvol) {
4681 		vd->write_queue =
4682 		    kmem_zalloc(sizeof (buf_t *) * vd->dring_len, KM_SLEEP);
4683 	}
4684 
4685 	return (0);
4686 }
4687 
4688 static int
vd_process_dring_unreg_msg(vd_t * vd,vio_msg_t * msg,size_t msglen)4689 vd_process_dring_unreg_msg(vd_t *vd, vio_msg_t *msg, size_t msglen)
4690 {
4691 	vio_dring_unreg_msg_t	*unreg_msg = (vio_dring_unreg_msg_t *)msg;
4692 
4693 
4694 	ASSERT(msglen >= sizeof (msg->tag));
4695 
4696 	if (!vd_msgtype(&msg->tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO,
4697 	    VIO_DRING_UNREG)) {
4698 		PR0("Message is not an unregister-dring message");
4699 		return (ENOMSG);
4700 	}
4701 
4702 	if (msglen != sizeof (*unreg_msg)) {
4703 		PR0("Expected %lu-byte unregister-dring message; "
4704 		    "received %lu bytes", sizeof (*unreg_msg), msglen);
4705 		return (EBADMSG);
4706 	}
4707 
4708 	if (unreg_msg->dring_ident != vd->dring_ident) {
4709 		PR0("Expected dring ident %lu; received %lu",
4710 		    vd->dring_ident, unreg_msg->dring_ident);
4711 		return (EBADMSG);
4712 	}
4713 
4714 	return (0);
4715 }
4716 
4717 static int
process_rdx_msg(vio_msg_t * msg,size_t msglen)4718 process_rdx_msg(vio_msg_t *msg, size_t msglen)
4719 {
4720 	ASSERT(msglen >= sizeof (msg->tag));
4721 
4722 	if (!vd_msgtype(&msg->tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO, VIO_RDX)) {
4723 		PR0("Message is not an RDX message");
4724 		return (ENOMSG);
4725 	}
4726 
4727 	if (msglen != sizeof (vio_rdx_msg_t)) {
4728 		PR0("Expected %lu-byte RDX message; received %lu bytes",
4729 		    sizeof (vio_rdx_msg_t), msglen);
4730 		return (EBADMSG);
4731 	}
4732 
4733 	PR0("Valid RDX message");
4734 	return (0);
4735 }
4736 
4737 static int
vd_check_seq_num(vd_t * vd,uint64_t seq_num)4738 vd_check_seq_num(vd_t *vd, uint64_t seq_num)
4739 {
4740 	if ((vd->initialized & VD_SEQ_NUM) && (seq_num != vd->seq_num + 1)) {
4741 		PR0("Received seq_num %lu; expected %lu",
4742 		    seq_num, (vd->seq_num + 1));
4743 		PR0("initiating soft reset");
4744 		vd_need_reset(vd, B_FALSE);
4745 		return (1);
4746 	}
4747 
4748 	vd->seq_num = seq_num;
4749 	vd->initialized |= VD_SEQ_NUM;	/* superfluous after first time... */
4750 	return (0);
4751 }
4752 
4753 /*
4754  * Return the expected size of an inband-descriptor message with all the
4755  * cookies it claims to include
4756  */
4757 static size_t
expected_inband_size(vd_dring_inband_msg_t * msg)4758 expected_inband_size(vd_dring_inband_msg_t *msg)
4759 {
4760 	return ((sizeof (*msg)) +
4761 	    (msg->payload.ncookies - 1)*(sizeof (msg->payload.cookie[0])));
4762 }
4763 
4764 /*
4765  * Process an in-band descriptor message:  used with clients like OBP, with
4766  * which vds exchanges descriptors within VIO message payloads, rather than
4767  * operating on them within a descriptor ring
4768  */
4769 static int
vd_process_desc_msg(vd_t * vd,vio_msg_t * msg,size_t msglen)4770 vd_process_desc_msg(vd_t *vd, vio_msg_t *msg, size_t msglen)
4771 {
4772 	size_t			expected;
4773 	vd_dring_inband_msg_t	*desc_msg = (vd_dring_inband_msg_t *)msg;
4774 
4775 
4776 	ASSERT(msglen >= sizeof (msg->tag));
4777 
4778 	if (!vd_msgtype(&msg->tag, VIO_TYPE_DATA, VIO_SUBTYPE_INFO,
4779 	    VIO_DESC_DATA)) {
4780 		PR1("Message is not an in-band-descriptor message");
4781 		return (ENOMSG);
4782 	}
4783 
4784 	if (msglen < sizeof (*desc_msg)) {
4785 		PR0("Expected at least %lu-byte descriptor message; "
4786 		    "received %lu bytes", sizeof (*desc_msg), msglen);
4787 		return (EBADMSG);
4788 	}
4789 
4790 	if (msglen != (expected = expected_inband_size(desc_msg))) {
4791 		PR0("Expected %lu-byte descriptor message; "
4792 		    "received %lu bytes", expected, msglen);
4793 		return (EBADMSG);
4794 	}
4795 
4796 	if (vd_check_seq_num(vd, desc_msg->hdr.seq_num) != 0)
4797 		return (EBADMSG);
4798 
4799 	/*
4800 	 * Valid message:  Set up the in-band descriptor task and process the
4801 	 * request.  Arrange to acknowledge the client's message, unless an
4802 	 * error processing the descriptor task results in setting
4803 	 * VIO_SUBTYPE_NACK
4804 	 */
4805 	PR1("Valid in-band-descriptor message");
4806 	msg->tag.vio_subtype = VIO_SUBTYPE_ACK;
4807 
4808 	ASSERT(vd->inband_task.msg != NULL);
4809 
4810 	bcopy(msg, vd->inband_task.msg, msglen);
4811 	vd->inband_task.msglen	= msglen;
4812 
4813 	/*
4814 	 * The task request is now the payload of the message
4815 	 * that was just copied into the body of the task.
4816 	 */
4817 	desc_msg = (vd_dring_inband_msg_t *)vd->inband_task.msg;
4818 	vd->inband_task.request	= &desc_msg->payload;
4819 
4820 	return (vd_process_task(&vd->inband_task));
4821 }
4822 
4823 static int
vd_process_element(vd_t * vd,vd_task_type_t type,uint32_t idx,vio_msg_t * msg,size_t msglen)4824 vd_process_element(vd_t *vd, vd_task_type_t type, uint32_t idx,
4825     vio_msg_t *msg, size_t msglen)
4826 {
4827 	int			status;
4828 	boolean_t		ready;
4829 	on_trap_data_t		otd;
4830 	vd_dring_entry_t	*elem = VD_DRING_ELEM(idx);
4831 
4832 	/* Accept the updated dring element */
4833 	if ((status = VIO_DRING_ACQUIRE(&otd, vd->dring_mtype,
4834 	    vd->dring_handle, idx, idx)) != 0) {
4835 		return (status);
4836 	}
4837 	ready = (elem->hdr.dstate == VIO_DESC_READY);
4838 	if (ready) {
4839 		elem->hdr.dstate = VIO_DESC_ACCEPTED;
4840 		bcopy(&elem->payload, vd->dring_task[idx].request,
4841 		    (vd->descriptor_size - sizeof (vio_dring_entry_hdr_t)));
4842 	} else {
4843 		PR0("descriptor %u not ready", idx);
4844 		VD_DUMP_DRING_ELEM(elem);
4845 	}
4846 	if ((status = VIO_DRING_RELEASE(vd->dring_mtype,
4847 	    vd->dring_handle, idx, idx)) != 0) {
4848 		PR0("VIO_DRING_RELEASE() returned errno %d", status);
4849 		return (status);
4850 	}
4851 	if (!ready)
4852 		return (EBUSY);
4853 
4854 
4855 	/* Initialize a task and process the accepted element */
4856 	PR1("Processing dring element %u", idx);
4857 	vd->dring_task[idx].type	= type;
4858 
4859 	/* duplicate msg buf for cookies etc. */
4860 	bcopy(msg, vd->dring_task[idx].msg, msglen);
4861 
4862 	vd->dring_task[idx].msglen	= msglen;
4863 	return (vd_process_task(&vd->dring_task[idx]));
4864 }
4865 
4866 static int
vd_process_element_range(vd_t * vd,int start,int end,vio_msg_t * msg,size_t msglen)4867 vd_process_element_range(vd_t *vd, int start, int end,
4868     vio_msg_t *msg, size_t msglen)
4869 {
4870 	int		i, n, nelem, status = 0;
4871 	boolean_t	inprogress = B_FALSE;
4872 	vd_task_type_t	type;
4873 
4874 
4875 	ASSERT(start >= 0);
4876 	ASSERT(end >= 0);
4877 
4878 	/*
4879 	 * Arrange to acknowledge the client's message, unless an error
4880 	 * processing one of the dring elements results in setting
4881 	 * VIO_SUBTYPE_NACK
4882 	 */
4883 	msg->tag.vio_subtype = VIO_SUBTYPE_ACK;
4884 
4885 	/*
4886 	 * Process the dring elements in the range
4887 	 */
4888 	nelem = ((end < start) ? end + vd->dring_len : end) - start + 1;
4889 	for (i = start, n = nelem; n > 0; i = (i + 1) % vd->dring_len, n--) {
4890 		((vio_dring_msg_t *)msg)->end_idx = i;
4891 		type = (n == 1) ? VD_FINAL_RANGE_TASK : VD_NONFINAL_RANGE_TASK;
4892 		status = vd_process_element(vd, type, i, msg, msglen);
4893 		if (status == EINPROGRESS)
4894 			inprogress = B_TRUE;
4895 		else if (status != 0)
4896 			break;
4897 	}
4898 
4899 	/*
4900 	 * If some, but not all, operations of a multi-element range are in
4901 	 * progress, wait for other operations to complete before returning
4902 	 * (which will result in "ack" or "nack" of the message).  Note that
4903 	 * all outstanding operations will need to complete, not just the ones
4904 	 * corresponding to the current range of dring elements; howevever, as
4905 	 * this situation is an error case, performance is less critical.
4906 	 */
4907 	if ((nelem > 1) && (status != EINPROGRESS) && inprogress) {
4908 		if (vd->ioq != NULL)
4909 			ddi_taskq_wait(vd->ioq);
4910 		ddi_taskq_wait(vd->completionq);
4911 	}
4912 
4913 	return (status);
4914 }
4915 
4916 static int
vd_process_dring_msg(vd_t * vd,vio_msg_t * msg,size_t msglen)4917 vd_process_dring_msg(vd_t *vd, vio_msg_t *msg, size_t msglen)
4918 {
4919 	vio_dring_msg_t	*dring_msg = (vio_dring_msg_t *)msg;
4920 
4921 
4922 	ASSERT(msglen >= sizeof (msg->tag));
4923 
4924 	if (!vd_msgtype(&msg->tag, VIO_TYPE_DATA, VIO_SUBTYPE_INFO,
4925 	    VIO_DRING_DATA)) {
4926 		PR1("Message is not a dring-data message");
4927 		return (ENOMSG);
4928 	}
4929 
4930 	if (msglen != sizeof (*dring_msg)) {
4931 		PR0("Expected %lu-byte dring message; received %lu bytes",
4932 		    sizeof (*dring_msg), msglen);
4933 		return (EBADMSG);
4934 	}
4935 
4936 	if (vd_check_seq_num(vd, dring_msg->seq_num) != 0)
4937 		return (EBADMSG);
4938 
4939 	if (dring_msg->dring_ident != vd->dring_ident) {
4940 		PR0("Expected dring ident %lu; received ident %lu",
4941 		    vd->dring_ident, dring_msg->dring_ident);
4942 		return (EBADMSG);
4943 	}
4944 
4945 	if (dring_msg->start_idx >= vd->dring_len) {
4946 		PR0("\"start_idx\" = %u; must be less than %u",
4947 		    dring_msg->start_idx, vd->dring_len);
4948 		return (EBADMSG);
4949 	}
4950 
4951 	if ((dring_msg->end_idx < 0) ||
4952 	    (dring_msg->end_idx >= vd->dring_len)) {
4953 		PR0("\"end_idx\" = %u; must be >= 0 and less than %u",
4954 		    dring_msg->end_idx, vd->dring_len);
4955 		return (EBADMSG);
4956 	}
4957 
4958 	/* Valid message; process range of updated dring elements */
4959 	PR1("Processing descriptor range, start = %u, end = %u",
4960 	    dring_msg->start_idx, dring_msg->end_idx);
4961 	return (vd_process_element_range(vd, dring_msg->start_idx,
4962 	    dring_msg->end_idx, msg, msglen));
4963 }
4964 
4965 static int
recv_msg(ldc_handle_t ldc_handle,void * msg,size_t * nbytes)4966 recv_msg(ldc_handle_t ldc_handle, void *msg, size_t *nbytes)
4967 {
4968 	int	retry, status;
4969 	size_t	size = *nbytes;
4970 
4971 
4972 	for (retry = 0, status = ETIMEDOUT;
4973 	    retry < vds_ldc_retries && status == ETIMEDOUT;
4974 	    retry++) {
4975 		PR1("ldc_read() attempt %d", (retry + 1));
4976 		*nbytes = size;
4977 		status = ldc_read(ldc_handle, msg, nbytes);
4978 	}
4979 
4980 	if (status) {
4981 		PR0("ldc_read() returned errno %d", status);
4982 		if (status != ECONNRESET)
4983 			return (ENOMSG);
4984 		return (status);
4985 	} else if (*nbytes == 0) {
4986 		PR1("ldc_read() returned 0 and no message read");
4987 		return (ENOMSG);
4988 	}
4989 
4990 	PR1("RCVD %lu-byte message", *nbytes);
4991 	return (0);
4992 }
4993 
4994 static int
vd_do_process_msg(vd_t * vd,vio_msg_t * msg,size_t msglen)4995 vd_do_process_msg(vd_t *vd, vio_msg_t *msg, size_t msglen)
4996 {
4997 	int		status;
4998 
4999 
5000 	PR1("Processing (%x/%x/%x) message", msg->tag.vio_msgtype,
5001 	    msg->tag.vio_subtype, msg->tag.vio_subtype_env);
5002 #ifdef	DEBUG
5003 	vd_decode_tag(msg);
5004 #endif
5005 
5006 	/*
5007 	 * Validate session ID up front, since it applies to all messages
5008 	 * once set
5009 	 */
5010 	if ((msg->tag.vio_sid != vd->sid) && (vd->initialized & VD_SID)) {
5011 		PR0("Expected SID %u, received %u", vd->sid,
5012 		    msg->tag.vio_sid);
5013 		return (EBADMSG);
5014 	}
5015 
5016 	PR1("\tWhile in state %d (%s)", vd->state, vd_decode_state(vd->state));
5017 
5018 	/*
5019 	 * Process the received message based on connection state
5020 	 */
5021 	switch (vd->state) {
5022 	case VD_STATE_INIT:	/* expect version message */
5023 		if ((status = vd_process_ver_msg(vd, msg, msglen)) != 0)
5024 			return (status);
5025 
5026 		/* Version negotiated, move to that state */
5027 		vd->state = VD_STATE_VER;
5028 		return (0);
5029 
5030 	case VD_STATE_VER:	/* expect attribute message */
5031 		if ((status = vd_process_attr_msg(vd, msg, msglen)) != 0)
5032 			return (status);
5033 
5034 		/* Attributes exchanged, move to that state */
5035 		vd->state = VD_STATE_ATTR;
5036 		return (0);
5037 
5038 	case VD_STATE_ATTR:
5039 		switch (vd->xfer_mode) {
5040 		case VIO_DESC_MODE:	/* expect RDX message */
5041 			if ((status = process_rdx_msg(msg, msglen)) != 0)
5042 				return (status);
5043 
5044 			/* Ready to receive in-band descriptors */
5045 			vd->state = VD_STATE_DATA;
5046 			return (0);
5047 
5048 		case VIO_DRING_MODE_V1_0:  /* expect register-dring message */
5049 			if ((status =
5050 			    vd_process_dring_reg_msg(vd, msg, msglen)) != 0)
5051 				return (status);
5052 
5053 			/* One dring negotiated, move to that state */
5054 			vd->state = VD_STATE_DRING;
5055 			return (0);
5056 
5057 		default:
5058 			ASSERT("Unsupported transfer mode");
5059 			PR0("Unsupported transfer mode");
5060 			return (ENOTSUP);
5061 		}
5062 
5063 	case VD_STATE_DRING:	/* expect RDX, register-dring, or unreg-dring */
5064 		if ((status = process_rdx_msg(msg, msglen)) == 0) {
5065 			/* Ready to receive data */
5066 			vd->state = VD_STATE_DATA;
5067 			return (0);
5068 		} else if (status != ENOMSG) {
5069 			return (status);
5070 		}
5071 
5072 
5073 		/*
5074 		 * If another register-dring message is received, stay in
5075 		 * dring state in case the client sends RDX; although the
5076 		 * protocol allows multiple drings, this server does not
5077 		 * support using more than one
5078 		 */
5079 		if ((status =
5080 		    vd_process_dring_reg_msg(vd, msg, msglen)) != ENOMSG)
5081 			return (status);
5082 
5083 		/*
5084 		 * Acknowledge an unregister-dring message, but reset the
5085 		 * connection anyway:  Although the protocol allows
5086 		 * unregistering drings, this server cannot serve a vdisk
5087 		 * without its only dring
5088 		 */
5089 		status = vd_process_dring_unreg_msg(vd, msg, msglen);
5090 		return ((status == 0) ? ENOTSUP : status);
5091 
5092 	case VD_STATE_DATA:
5093 		switch (vd->xfer_mode) {
5094 		case VIO_DESC_MODE:	/* expect in-band-descriptor message */
5095 			return (vd_process_desc_msg(vd, msg, msglen));
5096 
5097 		case VIO_DRING_MODE_V1_0: /* expect dring-data or unreg-dring */
5098 			/*
5099 			 * Typically expect dring-data messages, so handle
5100 			 * them first
5101 			 */
5102 			if ((status = vd_process_dring_msg(vd, msg,
5103 			    msglen)) != ENOMSG)
5104 				return (status);
5105 
5106 			/*
5107 			 * Acknowledge an unregister-dring message, but reset
5108 			 * the connection anyway:  Although the protocol
5109 			 * allows unregistering drings, this server cannot
5110 			 * serve a vdisk without its only dring
5111 			 */
5112 			status = vd_process_dring_unreg_msg(vd, msg, msglen);
5113 			return ((status == 0) ? ENOTSUP : status);
5114 
5115 		default:
5116 			ASSERT("Unsupported transfer mode");
5117 			PR0("Unsupported transfer mode");
5118 			return (ENOTSUP);
5119 		}
5120 
5121 	default:
5122 		ASSERT("Invalid client connection state");
5123 		PR0("Invalid client connection state");
5124 		return (ENOTSUP);
5125 	}
5126 }
5127 
5128 static int
vd_process_msg(vd_t * vd,vio_msg_t * msg,size_t msglen)5129 vd_process_msg(vd_t *vd, vio_msg_t *msg, size_t msglen)
5130 {
5131 	int		status;
5132 	boolean_t	reset_ldc = B_FALSE;
5133 	vd_task_t	task;
5134 
5135 	/*
5136 	 * Check that the message is at least big enough for a "tag", so that
5137 	 * message processing can proceed based on tag-specified message type
5138 	 */
5139 	if (msglen < sizeof (vio_msg_tag_t)) {
5140 		PR0("Received short (%lu-byte) message", msglen);
5141 		/* Can't "nack" short message, so drop the big hammer */
5142 		PR0("initiating full reset");
5143 		vd_need_reset(vd, B_TRUE);
5144 		return (EBADMSG);
5145 	}
5146 
5147 	/*
5148 	 * Process the message
5149 	 */
5150 	switch (status = vd_do_process_msg(vd, msg, msglen)) {
5151 	case 0:
5152 		/* "ack" valid, successfully-processed messages */
5153 		msg->tag.vio_subtype = VIO_SUBTYPE_ACK;
5154 		break;
5155 
5156 	case EINPROGRESS:
5157 		/* The completion handler will "ack" or "nack" the message */
5158 		return (EINPROGRESS);
5159 	case ENOMSG:
5160 		PR0("Received unexpected message");
5161 		_NOTE(FALLTHROUGH);
5162 	case EBADMSG:
5163 	case ENOTSUP:
5164 		/* "transport" error will cause NACK of invalid messages */
5165 		msg->tag.vio_subtype = VIO_SUBTYPE_NACK;
5166 		break;
5167 
5168 	default:
5169 		/* "transport" error will cause NACK of invalid messages */
5170 		msg->tag.vio_subtype = VIO_SUBTYPE_NACK;
5171 		/* An LDC error probably occurred, so try resetting it */
5172 		reset_ldc = B_TRUE;
5173 		break;
5174 	}
5175 
5176 	PR1("\tResulting in state %d (%s)", vd->state,
5177 	    vd_decode_state(vd->state));
5178 
5179 	/* populate the task so we can dispatch it on the taskq */
5180 	task.vd = vd;
5181 	task.msg = msg;
5182 	task.msglen = msglen;
5183 
5184 	/*
5185 	 * Queue a task to send the notification that the operation completed.
5186 	 * We need to ensure that requests are responded to in the correct
5187 	 * order and since the taskq is processed serially this ordering
5188 	 * is maintained.
5189 	 */
5190 	(void) ddi_taskq_dispatch(vd->completionq, vd_serial_notify,
5191 	    &task, DDI_SLEEP);
5192 
5193 	/*
5194 	 * To ensure handshake negotiations do not happen out of order, such
5195 	 * requests that come through this path should not be done in parallel
5196 	 * so we need to wait here until the response is sent to the client.
5197 	 */
5198 	ddi_taskq_wait(vd->completionq);
5199 
5200 	/* Arrange to reset the connection for nack'ed or failed messages */
5201 	if ((status != 0) || reset_ldc) {
5202 		PR0("initiating %s reset",
5203 		    (reset_ldc) ? "full" : "soft");
5204 		vd_need_reset(vd, reset_ldc);
5205 	}
5206 
5207 	return (status);
5208 }
5209 
5210 static boolean_t
vd_enabled(vd_t * vd)5211 vd_enabled(vd_t *vd)
5212 {
5213 	boolean_t	enabled;
5214 
5215 	mutex_enter(&vd->lock);
5216 	enabled = vd->enabled;
5217 	mutex_exit(&vd->lock);
5218 	return (enabled);
5219 }
5220 
5221 static void
vd_recv_msg(void * arg)5222 vd_recv_msg(void *arg)
5223 {
5224 	vd_t	*vd = (vd_t *)arg;
5225 	int	rv = 0, status = 0;
5226 
5227 	ASSERT(vd != NULL);
5228 
5229 	PR2("New task to receive incoming message(s)");
5230 
5231 
5232 	while (vd_enabled(vd) && status == 0) {
5233 		size_t		msglen, msgsize;
5234 		ldc_status_t	lstatus;
5235 
5236 		/*
5237 		 * Receive and process a message
5238 		 */
5239 		vd_reset_if_needed(vd);	/* can change vd->max_msglen */
5240 
5241 		/*
5242 		 * check if channel is UP - else break out of loop
5243 		 */
5244 		status = ldc_status(vd->ldc_handle, &lstatus);
5245 		if (lstatus != LDC_UP) {
5246 			PR0("channel not up (status=%d), exiting recv loop\n",
5247 			    lstatus);
5248 			break;
5249 		}
5250 
5251 		ASSERT(vd->max_msglen != 0);
5252 
5253 		msgsize = vd->max_msglen; /* stable copy for alloc/free */
5254 		msglen	= msgsize;	  /* actual len after recv_msg() */
5255 
5256 		status = recv_msg(vd->ldc_handle, vd->vio_msgp, &msglen);
5257 		switch (status) {
5258 		case 0:
5259 			rv = vd_process_msg(vd, (void *)vd->vio_msgp, msglen);
5260 			/* check if max_msglen changed */
5261 			if (msgsize != vd->max_msglen) {
5262 				PR0("max_msglen changed 0x%lx to 0x%lx bytes\n",
5263 				    msgsize, vd->max_msglen);
5264 				kmem_free(vd->vio_msgp, msgsize);
5265 				vd->vio_msgp =
5266 				    kmem_alloc(vd->max_msglen, KM_SLEEP);
5267 			}
5268 			if (rv == EINPROGRESS)
5269 				continue;
5270 			break;
5271 
5272 		case ENOMSG:
5273 			break;
5274 
5275 		case ECONNRESET:
5276 			PR0("initiating soft reset (ECONNRESET)\n");
5277 			vd_need_reset(vd, B_FALSE);
5278 			status = 0;
5279 			break;
5280 
5281 		default:
5282 			/* Probably an LDC failure; arrange to reset it */
5283 			PR0("initiating full reset (status=0x%x)", status);
5284 			vd_need_reset(vd, B_TRUE);
5285 			break;
5286 		}
5287 	}
5288 
5289 	PR2("Task finished");
5290 }
5291 
5292 static uint_t
vd_handle_ldc_events(uint64_t event,caddr_t arg)5293 vd_handle_ldc_events(uint64_t event, caddr_t arg)
5294 {
5295 	vd_t	*vd = (vd_t *)(void *)arg;
5296 	int	status;
5297 
5298 	ASSERT(vd != NULL);
5299 
5300 	if (!vd_enabled(vd))
5301 		return (LDC_SUCCESS);
5302 
5303 	if (event & LDC_EVT_DOWN) {
5304 		PR0("LDC_EVT_DOWN: LDC channel went down");
5305 
5306 		vd_need_reset(vd, B_TRUE);
5307 		status = ddi_taskq_dispatch(vd->startq, vd_recv_msg, vd,
5308 		    DDI_SLEEP);
5309 		if (status == DDI_FAILURE) {
5310 			PR0("cannot schedule task to recv msg\n");
5311 			vd_need_reset(vd, B_TRUE);
5312 		}
5313 	}
5314 
5315 	if (event & LDC_EVT_RESET) {
5316 		PR0("LDC_EVT_RESET: LDC channel was reset");
5317 
5318 		if (vd->state != VD_STATE_INIT) {
5319 			PR0("scheduling full reset");
5320 			vd_need_reset(vd, B_FALSE);
5321 			status = ddi_taskq_dispatch(vd->startq, vd_recv_msg,
5322 			    vd, DDI_SLEEP);
5323 			if (status == DDI_FAILURE) {
5324 				PR0("cannot schedule task to recv msg\n");
5325 				vd_need_reset(vd, B_TRUE);
5326 			}
5327 
5328 		} else {
5329 			PR0("channel already reset, ignoring...\n");
5330 			PR0("doing ldc up...\n");
5331 			(void) ldc_up(vd->ldc_handle);
5332 		}
5333 
5334 		return (LDC_SUCCESS);
5335 	}
5336 
5337 	if (event & LDC_EVT_UP) {
5338 		PR0("EVT_UP: LDC is up\nResetting client connection state");
5339 		PR0("initiating soft reset");
5340 		vd_need_reset(vd, B_FALSE);
5341 		status = ddi_taskq_dispatch(vd->startq, vd_recv_msg,
5342 		    vd, DDI_SLEEP);
5343 		if (status == DDI_FAILURE) {
5344 			PR0("cannot schedule task to recv msg\n");
5345 			vd_need_reset(vd, B_TRUE);
5346 			return (LDC_SUCCESS);
5347 		}
5348 	}
5349 
5350 	if (event & LDC_EVT_READ) {
5351 		int	status;
5352 
5353 		PR1("New data available");
5354 		/* Queue a task to receive the new data */
5355 		status = ddi_taskq_dispatch(vd->startq, vd_recv_msg, vd,
5356 		    DDI_SLEEP);
5357 
5358 		if (status == DDI_FAILURE) {
5359 			PR0("cannot schedule task to recv msg\n");
5360 			vd_need_reset(vd, B_TRUE);
5361 		}
5362 	}
5363 
5364 	return (LDC_SUCCESS);
5365 }
5366 
5367 static uint_t
vds_check_for_vd(mod_hash_key_t key,mod_hash_val_t * val,void * arg)5368 vds_check_for_vd(mod_hash_key_t key, mod_hash_val_t *val, void *arg)
5369 {
5370 	_NOTE(ARGUNUSED(key, val))
5371 	(*((uint_t *)arg))++;
5372 	return (MH_WALK_TERMINATE);
5373 }
5374 
5375 
5376 static int
vds_detach(dev_info_t * dip,ddi_detach_cmd_t cmd)5377 vds_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
5378 {
5379 	uint_t	vd_present = 0;
5380 	minor_t	instance;
5381 	vds_t	*vds;
5382 
5383 
5384 	switch (cmd) {
5385 	case DDI_DETACH:
5386 		/* the real work happens below */
5387 		break;
5388 	case DDI_SUSPEND:
5389 		PR0("No action required for DDI_SUSPEND");
5390 		return (DDI_SUCCESS);
5391 	default:
5392 		PR0("Unrecognized \"cmd\"");
5393 		return (DDI_FAILURE);
5394 	}
5395 
5396 	ASSERT(cmd == DDI_DETACH);
5397 	instance = ddi_get_instance(dip);
5398 	if ((vds = ddi_get_soft_state(vds_state, instance)) == NULL) {
5399 		PR0("Could not get state for instance %u", instance);
5400 		ddi_soft_state_free(vds_state, instance);
5401 		return (DDI_FAILURE);
5402 	}
5403 
5404 	/* Do no detach when serving any vdisks */
5405 	mod_hash_walk(vds->vd_table, vds_check_for_vd, &vd_present);
5406 	if (vd_present) {
5407 		PR0("Not detaching because serving vdisks");
5408 		return (DDI_FAILURE);
5409 	}
5410 
5411 	PR0("Detaching");
5412 	if (vds->initialized & VDS_MDEG) {
5413 		(void) mdeg_unregister(vds->mdeg);
5414 		kmem_free(vds->ispecp->specp, sizeof (vds_prop_template));
5415 		kmem_free(vds->ispecp, sizeof (mdeg_node_spec_t));
5416 		vds->ispecp = NULL;
5417 		vds->mdeg = NULL;
5418 	}
5419 
5420 	vds_driver_types_free(vds);
5421 
5422 	if (vds->initialized & VDS_LDI)
5423 		(void) ldi_ident_release(vds->ldi_ident);
5424 	mod_hash_destroy_hash(vds->vd_table);
5425 	ddi_soft_state_free(vds_state, instance);
5426 	return (DDI_SUCCESS);
5427 }
5428 
5429 /*
5430  * Description:
5431  *	This function checks to see if the disk image being used as a
5432  *	virtual disk is an ISO image. An ISO image is a special case
5433  *	which can be booted/installed from like a CD/DVD.
5434  *
5435  * Parameters:
5436  *	vd		- disk on which the operation is performed.
5437  *
5438  * Return Code:
5439  *	B_TRUE		- The disk image is an ISO 9660 compliant image
5440  *	B_FALSE		- just a regular disk image
5441  */
5442 static boolean_t
vd_dskimg_is_iso_image(vd_t * vd)5443 vd_dskimg_is_iso_image(vd_t *vd)
5444 {
5445 	char	iso_buf[ISO_SECTOR_SIZE];
5446 	int	i, rv;
5447 	uint_t	sec;
5448 
5449 	ASSERT(VD_DSKIMG(vd));
5450 
5451 	/*
5452 	 * If we have already discovered and saved this info we can
5453 	 * short-circuit the check and avoid reading the disk image.
5454 	 */
5455 	if (vd->vdisk_media == VD_MEDIA_DVD || vd->vdisk_media == VD_MEDIA_CD)
5456 		return (B_TRUE);
5457 
5458 	/*
5459 	 * We wish to read the sector that should contain the 2nd ISO volume
5460 	 * descriptor. The second field in this descriptor is called the
5461 	 * Standard Identifier and is set to CD001 for a CD-ROM compliant
5462 	 * to the ISO 9660 standard.
5463 	 */
5464 	sec = (ISO_VOLDESC_SEC * ISO_SECTOR_SIZE) / vd->vdisk_bsize;
5465 	rv = vd_dskimg_rw(vd, VD_SLICE_NONE, VD_OP_BREAD, (caddr_t)iso_buf,
5466 	    sec, ISO_SECTOR_SIZE);
5467 
5468 	if (rv < 0)
5469 		return (B_FALSE);
5470 
5471 	for (i = 0; i < ISO_ID_STRLEN; i++) {
5472 		if (ISO_STD_ID(iso_buf)[i] != ISO_ID_STRING[i])
5473 			return (B_FALSE);
5474 	}
5475 
5476 	return (B_TRUE);
5477 }
5478 
5479 /*
5480  * Description:
5481  *	This function checks to see if the virtual device is an ATAPI
5482  *	device. ATAPI devices use Group 1 Read/Write commands, so
5483  *	any USCSI calls vds makes need to take this into account.
5484  *
5485  * Parameters:
5486  *	vd		- disk on which the operation is performed.
5487  *
5488  * Return Code:
5489  *	B_TRUE		- The virtual disk is backed by an ATAPI device
5490  *	B_FALSE		- not an ATAPI device (presumably SCSI)
5491  */
5492 static boolean_t
vd_is_atapi_device(vd_t * vd)5493 vd_is_atapi_device(vd_t *vd)
5494 {
5495 	boolean_t	is_atapi = B_FALSE;
5496 	char		*variantp;
5497 	int		rv;
5498 
5499 	ASSERT(vd->ldi_handle[0] != NULL);
5500 	ASSERT(!vd->file);
5501 
5502 	rv = ldi_prop_lookup_string(vd->ldi_handle[0],
5503 	    (LDI_DEV_T_ANY | DDI_PROP_DONTPASS), "variant", &variantp);
5504 	if (rv == DDI_PROP_SUCCESS) {
5505 		PR0("'variant' property exists for %s", vd->device_path);
5506 		if (strcmp(variantp, "atapi") == 0)
5507 			is_atapi = B_TRUE;
5508 		ddi_prop_free(variantp);
5509 	}
5510 
5511 	rv = ldi_prop_exists(vd->ldi_handle[0], LDI_DEV_T_ANY, "atapi");
5512 	if (rv) {
5513 		PR0("'atapi' property exists for %s", vd->device_path);
5514 		is_atapi = B_TRUE;
5515 	}
5516 
5517 	return (is_atapi);
5518 }
5519 
5520 static int
vd_setup_full_disk(vd_t * vd)5521 vd_setup_full_disk(vd_t *vd)
5522 {
5523 	int		status;
5524 	major_t		major = getmajor(vd->dev[0]);
5525 	minor_t		minor = getminor(vd->dev[0]) - VD_ENTIRE_DISK_SLICE;
5526 
5527 	ASSERT(vd->vdisk_type == VD_DISK_TYPE_DISK);
5528 
5529 	/* set the disk size, block size and the media type of the disk */
5530 	status = vd_backend_check_size(vd);
5531 
5532 	if (status != 0) {
5533 		if (!vd->scsi) {
5534 			/* unexpected failure */
5535 			PRN("Check size failed for %s (errno %d)",
5536 			    vd->device_path, status);
5537 			return (EIO);
5538 		}
5539 
5540 		/*
5541 		 * The function can fail for SCSI disks which are present but
5542 		 * reserved by another system. In that case, we don't know the
5543 		 * size of the disk and the block size.
5544 		 */
5545 		vd->vdisk_size = VD_SIZE_UNKNOWN;
5546 		vd->vdisk_bsize = 0;
5547 		vd->backend_bsize = 0;
5548 		vd->vdisk_media = VD_MEDIA_FIXED;
5549 	}
5550 
5551 	/* Move dev number and LDI handle to entire-disk-slice array elements */
5552 	vd->dev[VD_ENTIRE_DISK_SLICE]		= vd->dev[0];
5553 	vd->dev[0]				= 0;
5554 	vd->ldi_handle[VD_ENTIRE_DISK_SLICE]	= vd->ldi_handle[0];
5555 	vd->ldi_handle[0]			= NULL;
5556 
5557 	/* Initialize device numbers for remaining slices and open them */
5558 	for (int slice = 0; slice < vd->nslices; slice++) {
5559 		/*
5560 		 * Skip the entire-disk slice, as it's already open and its
5561 		 * device known
5562 		 */
5563 		if (slice == VD_ENTIRE_DISK_SLICE)
5564 			continue;
5565 		ASSERT(vd->dev[slice] == 0);
5566 		ASSERT(vd->ldi_handle[slice] == NULL);
5567 
5568 		/*
5569 		 * Construct the device number for the current slice
5570 		 */
5571 		vd->dev[slice] = makedevice(major, (minor + slice));
5572 
5573 		/*
5574 		 * Open all slices of the disk to serve them to the client.
5575 		 * Slices are opened exclusively to prevent other threads or
5576 		 * processes in the service domain from performing I/O to
5577 		 * slices being accessed by a client.  Failure to open a slice
5578 		 * results in vds not serving this disk, as the client could
5579 		 * attempt (and should be able) to access any slice immediately.
5580 		 * Any slices successfully opened before a failure will get
5581 		 * closed by vds_destroy_vd() as a result of the error returned
5582 		 * by this function.
5583 		 *
5584 		 * We need to do the open with FNDELAY so that opening an empty
5585 		 * slice does not fail.
5586 		 */
5587 		PR0("Opening device major %u, minor %u = slice %u",
5588 		    major, minor, slice);
5589 
5590 		/*
5591 		 * Try to open the device. This can fail for example if we are
5592 		 * opening an empty slice. So in case of a failure, we try the
5593 		 * open again but this time with the FNDELAY flag.
5594 		 */
5595 		status = ldi_open_by_dev(&vd->dev[slice], OTYP_BLK,
5596 		    vd->open_flags, kcred, &vd->ldi_handle[slice],
5597 		    vd->vds->ldi_ident);
5598 
5599 		if (status != 0) {
5600 			status = ldi_open_by_dev(&vd->dev[slice], OTYP_BLK,
5601 			    vd->open_flags | FNDELAY, kcred,
5602 			    &vd->ldi_handle[slice], vd->vds->ldi_ident);
5603 		}
5604 
5605 		if (status != 0) {
5606 			PRN("ldi_open_by_dev() returned errno %d "
5607 			    "for slice %u", status, slice);
5608 			/* vds_destroy_vd() will close any open slices */
5609 			vd->ldi_handle[slice] = NULL;
5610 			return (status);
5611 		}
5612 	}
5613 
5614 	return (0);
5615 }
5616 
5617 /*
5618  * When a slice or a volume is exported as a single-slice disk, we want
5619  * the disk backend (i.e. the slice or volume) to be entirely mapped as
5620  * a slice without the addition of any metadata.
5621  *
5622  * So when exporting the disk as a VTOC disk, we fake a disk with the following
5623  * layout:
5624  *                flabel +--- flabel_limit
5625  *                 <->   V
5626  *                 0 1   C                          D  E
5627  *                 +-+---+--------------------------+--+
5628  *  virtual disk:  |L|XXX|           slice 0        |AA|
5629  *                 +-+---+--------------------------+--+
5630  *                  ^    :                          :
5631  *                  |    :                          :
5632  *      VTOC LABEL--+    :                          :
5633  *                       +--------------------------+
5634  *  disk backend:        |     slice/volume/file    |
5635  *                       +--------------------------+
5636  *                       0                          N
5637  *
5638  * N is the number of blocks in the slice/volume/file.
5639  *
5640  * We simulate a disk with N+M blocks, where M is the number of blocks
5641  * simluated at the beginning and at the end of the disk (blocks 0-C
5642  * and D-E).
5643  *
5644  * The first blocks (0 to C-1) are emulated and can not be changed. Blocks C
5645  * to D defines slice 0 and are mapped to the backend. Finally we emulate 2
5646  * alternate cylinders at the end of the disk (blocks D-E). In summary we have:
5647  *
5648  * - block 0 (L) returns a fake VTOC label
5649  * - blocks 1 to C-1 (X) are unused and return 0
5650  * - blocks C to D-1 are mapped to the exported slice or volume
5651  * - blocks D and E (A) are blocks defining alternate cylinders (2 cylinders)
5652  *
5653  * Note: because we define a fake disk geometry, it is possible that the length
5654  * of the backend is not a multiple of the size of cylinder, in that case the
5655  * very end of the backend will not map to any block of the virtual disk.
5656  */
5657 static int
vd_setup_partition_vtoc(vd_t * vd)5658 vd_setup_partition_vtoc(vd_t *vd)
5659 {
5660 	char *device_path = vd->device_path;
5661 	char unit;
5662 	size_t size, csize;
5663 
5664 	/* Initialize dk_geom structure for single-slice device */
5665 	if (vd->dk_geom.dkg_nsect == 0) {
5666 		PRN("%s geometry claims 0 sectors per track", device_path);
5667 		return (EIO);
5668 	}
5669 	if (vd->dk_geom.dkg_nhead == 0) {
5670 		PRN("%s geometry claims 0 heads", device_path);
5671 		return (EIO);
5672 	}
5673 
5674 	/* size of a cylinder in block */
5675 	csize = vd->dk_geom.dkg_nhead * vd->dk_geom.dkg_nsect;
5676 
5677 	/*
5678 	 * Add extra cylinders: we emulate the first cylinder (which contains
5679 	 * the disk label).
5680 	 */
5681 	vd->dk_geom.dkg_ncyl = vd->vdisk_size / csize + 1;
5682 
5683 	/* we emulate 2 alternate cylinders */
5684 	vd->dk_geom.dkg_acyl = 2;
5685 	vd->dk_geom.dkg_pcyl = vd->dk_geom.dkg_ncyl + vd->dk_geom.dkg_acyl;
5686 
5687 
5688 	/* Initialize vtoc structure for single-slice device */
5689 	bzero(vd->vtoc.v_part, sizeof (vd->vtoc.v_part));
5690 	vd->vtoc.v_part[0].p_tag = V_UNASSIGNED;
5691 	vd->vtoc.v_part[0].p_flag = 0;
5692 	/*
5693 	 * Partition 0 starts on cylinder 1 and its size has to be
5694 	 * a multiple of a number of cylinder.
5695 	 */
5696 	vd->vtoc.v_part[0].p_start = csize; /* start on cylinder 1 */
5697 	vd->vtoc.v_part[0].p_size = (vd->vdisk_size / csize) * csize;
5698 
5699 	if (vd_slice_single_slice) {
5700 		vd->vtoc.v_nparts = 1;
5701 		bcopy(VD_ASCIILABEL, vd->vtoc.v_asciilabel,
5702 		    MIN(sizeof (VD_ASCIILABEL),
5703 		    sizeof (vd->vtoc.v_asciilabel)));
5704 		bcopy(VD_VOLUME_NAME, vd->vtoc.v_volume,
5705 		    MIN(sizeof (VD_VOLUME_NAME), sizeof (vd->vtoc.v_volume)));
5706 	} else {
5707 		/* adjust the number of slices */
5708 		vd->nslices = V_NUMPAR;
5709 		vd->vtoc.v_nparts = V_NUMPAR;
5710 
5711 		/* define slice 2 representing the entire disk */
5712 		vd->vtoc.v_part[VD_ENTIRE_DISK_SLICE].p_tag = V_BACKUP;
5713 		vd->vtoc.v_part[VD_ENTIRE_DISK_SLICE].p_flag = 0;
5714 		vd->vtoc.v_part[VD_ENTIRE_DISK_SLICE].p_start = 0;
5715 		vd->vtoc.v_part[VD_ENTIRE_DISK_SLICE].p_size =
5716 		    vd->dk_geom.dkg_ncyl * csize;
5717 
5718 		vd_get_readable_size(vd->vdisk_size * vd->vdisk_bsize,
5719 		    &size, &unit);
5720 
5721 		/*
5722 		 * Set some attributes of the geometry to what format(1m) uses
5723 		 * so that writing a default label using format(1m) does not
5724 		 * produce any error.
5725 		 */
5726 		vd->dk_geom.dkg_bcyl = 0;
5727 		vd->dk_geom.dkg_intrlv = 1;
5728 		vd->dk_geom.dkg_write_reinstruct = 0;
5729 		vd->dk_geom.dkg_read_reinstruct = 0;
5730 
5731 		/*
5732 		 * We must have a correct label name otherwise format(1m) will
5733 		 * not recognized the disk as labeled.
5734 		 */
5735 		(void) snprintf(vd->vtoc.v_asciilabel, LEN_DKL_ASCII,
5736 		    "SUN-DiskSlice-%ld%cB cyl %d alt %d hd %d sec %d",
5737 		    size, unit,
5738 		    vd->dk_geom.dkg_ncyl, vd->dk_geom.dkg_acyl,
5739 		    vd->dk_geom.dkg_nhead, vd->dk_geom.dkg_nsect);
5740 		bzero(vd->vtoc.v_volume, sizeof (vd->vtoc.v_volume));
5741 
5742 		/* create a fake label from the vtoc and geometry */
5743 		vd->flabel_limit = (uint_t)csize;
5744 		vd->flabel_size = VD_LABEL_VTOC_SIZE(vd->vdisk_bsize);
5745 		vd->flabel = kmem_zalloc(vd->flabel_size, KM_SLEEP);
5746 		vd_vtocgeom_to_label(&vd->vtoc, &vd->dk_geom,
5747 		    VD_LABEL_VTOC(vd));
5748 	}
5749 
5750 	/* adjust the vdisk_size, we emulate 3 cylinders */
5751 	vd->vdisk_size += csize * 3;
5752 
5753 	return (0);
5754 }
5755 
5756 /*
5757  * When a slice, volume or file is exported as a single-slice disk, we want
5758  * the disk backend (i.e. the slice, volume or file) to be entirely mapped
5759  * as a slice without the addition of any metadata.
5760  *
5761  * So when exporting the disk as an EFI disk, we fake a disk with the following
5762  * layout: (assuming the block size is 512 bytes)
5763  *
5764  *                  flabel        +--- flabel_limit
5765  *                 <------>       v
5766  *                 0 1 2  L      34                        34+N      P
5767  *                 +-+-+--+-------+--------------------------+-------+
5768  *  virtual disk:  |X|T|EE|XXXXXXX|           slice 0        |RRRRRRR|
5769  *                 +-+-+--+-------+--------------------------+-------+
5770  *                    ^ ^         :                          :
5771  *                    | |         :                          :
5772  *                GPT-+ +-GPE     :                          :
5773  *                                +--------------------------+
5774  *  disk backend:                 |     slice/volume/file    |
5775  *                                +--------------------------+
5776  *                                0                          N
5777  *
5778  * N is the number of blocks in the slice/volume/file.
5779  *
5780  * We simulate a disk with N+M blocks, where M is the number of blocks
5781  * simluated at the beginning and at the end of the disk (blocks 0-34
5782  * and 34+N-P).
5783  *
5784  * The first 34 blocks (0 to 33) are emulated and can not be changed. Blocks 34
5785  * to 34+N defines slice 0 and are mapped to the exported backend, and we
5786  * emulate some blocks at the end of the disk (blocks 34+N to P) as a the EFI
5787  * reserved partition.
5788  *
5789  * - block 0 (X) is unused and return 0
5790  * - block 1 (T) returns a fake EFI GPT (via DKIOCGETEFI)
5791  * - blocks 2 to L-1 (E) defines a fake EFI GPE (via DKIOCGETEFI)
5792  * - blocks L to 33 (X) are unused and return 0
5793  * - blocks 34 to 34+N are mapped to the exported slice, volume or file
5794  * - blocks 34+N+1 to P define a fake reserved partition and backup label, it
5795  *   returns 0
5796  *
5797  * Note: if the backend size is not a multiple of the vdisk block size then
5798  * the very end of the backend will not map to any block of the virtual disk.
5799  */
5800 static int
vd_setup_partition_efi(vd_t * vd)5801 vd_setup_partition_efi(vd_t *vd)
5802 {
5803 	efi_gpt_t *gpt;
5804 	efi_gpe_t *gpe;
5805 	struct uuid uuid = EFI_USR;
5806 	struct uuid efi_reserved = EFI_RESERVED;
5807 	uint32_t crc;
5808 	uint64_t s0_start, s0_end, first_u_lba;
5809 	size_t bsize;
5810 
5811 	ASSERT(vd->vdisk_bsize > 0);
5812 
5813 	bsize = vd->vdisk_bsize;
5814 	/*
5815 	 * The minimum size for the label is 16K (EFI_MIN_ARRAY_SIZE)
5816 	 * for GPEs plus one block for the GPT and one for PMBR.
5817 	 */
5818 	first_u_lba = (EFI_MIN_ARRAY_SIZE / bsize) + 2;
5819 	vd->flabel_limit = (uint_t)first_u_lba;
5820 	vd->flabel_size = VD_LABEL_EFI_SIZE(bsize);
5821 	vd->flabel = kmem_zalloc(vd->flabel_size, KM_SLEEP);
5822 	gpt = VD_LABEL_EFI_GPT(vd, bsize);
5823 	gpe = VD_LABEL_EFI_GPE(vd, bsize);
5824 
5825 	/*
5826 	 * Adjust the vdisk_size, we emulate the first few blocks
5827 	 * for the disk label.
5828 	 */
5829 	vd->vdisk_size += first_u_lba;
5830 	s0_start = first_u_lba;
5831 	s0_end = vd->vdisk_size - 1;
5832 
5833 	gpt->efi_gpt_Signature = LE_64(EFI_SIGNATURE);
5834 	gpt->efi_gpt_Revision = LE_32(EFI_VERSION_CURRENT);
5835 	gpt->efi_gpt_HeaderSize = LE_32(sizeof (efi_gpt_t));
5836 	gpt->efi_gpt_FirstUsableLBA = LE_64(first_u_lba);
5837 	gpt->efi_gpt_PartitionEntryLBA = LE_64(2ULL);
5838 	gpt->efi_gpt_SizeOfPartitionEntry = LE_32(sizeof (efi_gpe_t));
5839 
5840 	UUID_LE_CONVERT(gpe[0].efi_gpe_PartitionTypeGUID, uuid);
5841 	gpe[0].efi_gpe_StartingLBA = LE_64(s0_start);
5842 	gpe[0].efi_gpe_EndingLBA = LE_64(s0_end);
5843 
5844 	if (vd_slice_single_slice) {
5845 		gpt->efi_gpt_NumberOfPartitionEntries = LE_32(1);
5846 	} else {
5847 		/* adjust the number of slices */
5848 		gpt->efi_gpt_NumberOfPartitionEntries = LE_32(VD_MAXPART);
5849 		vd->nslices = V_NUMPAR;
5850 
5851 		/* define a fake reserved partition */
5852 		UUID_LE_CONVERT(gpe[VD_MAXPART - 1].efi_gpe_PartitionTypeGUID,
5853 		    efi_reserved);
5854 		gpe[VD_MAXPART - 1].efi_gpe_StartingLBA =
5855 		    LE_64(s0_end + 1);
5856 		gpe[VD_MAXPART - 1].efi_gpe_EndingLBA =
5857 		    LE_64(s0_end + EFI_MIN_RESV_SIZE);
5858 
5859 		/* adjust the vdisk_size to include the reserved slice */
5860 		vd->vdisk_size += EFI_MIN_RESV_SIZE;
5861 	}
5862 
5863 	gpt->efi_gpt_LastUsableLBA = LE_64(vd->vdisk_size - 1);
5864 
5865 	/* adjust the vdisk size for the backup GPT and GPE */
5866 	vd->vdisk_size += (EFI_MIN_ARRAY_SIZE / bsize) + 1;
5867 	gpt->efi_gpt_AlternateLBA = LE_64(vd->vdisk_size - 1);
5868 
5869 	CRC32(crc, gpe, sizeof (efi_gpe_t) * VD_MAXPART, -1U, crc32_table);
5870 	gpt->efi_gpt_PartitionEntryArrayCRC32 = LE_32(~crc);
5871 
5872 	CRC32(crc, gpt, sizeof (efi_gpt_t), -1U, crc32_table);
5873 	gpt->efi_gpt_HeaderCRC32 = LE_32(~crc);
5874 
5875 	return (0);
5876 }
5877 
5878 /*
5879  * Setup for a virtual disk whose backend is a file (exported as a single slice
5880  * or as a full disk). In that case, the backend is accessed using the vnode
5881  * interface.
5882  */
5883 static int
vd_setup_backend_vnode(vd_t * vd)5884 vd_setup_backend_vnode(vd_t *vd)
5885 {
5886 	int 		rval, status;
5887 	dev_t		dev;
5888 	char		*file_path = vd->device_path;
5889 	ldi_handle_t	lhandle;
5890 	struct dk_cinfo	dk_cinfo;
5891 
5892 	ASSERT(!vd->volume);
5893 
5894 	if ((status = vn_open(file_path, UIO_SYSSPACE, vd->open_flags | FOFFMAX,
5895 	    0, &vd->file_vnode, 0, 0)) != 0) {
5896 		if ((status == ENXIO || status == ENODEV || status == ENOENT ||
5897 		    status == EROFS) && (!(vd->initialized & VD_SETUP_ERROR) &&
5898 		    !(DEVI_IS_ATTACHING(vd->vds->dip)))) {
5899 			PRN("vn_open(%s) = errno %d", file_path, status);
5900 		}
5901 		return (status);
5902 	}
5903 
5904 	/*
5905 	 * We set vd->file now so that vds_destroy_vd will take care of
5906 	 * closing the file and releasing the vnode in case of an error.
5907 	 */
5908 	vd->file = B_TRUE;
5909 
5910 	vd->max_xfer_sz = maxphys / DEV_BSIZE; /* default transfer size */
5911 
5912 	/*
5913 	 * Get max_xfer_sz from the device where the file is.
5914 	 */
5915 	dev = vd->file_vnode->v_vfsp->vfs_dev;
5916 	PR0("underlying device of %s = (%d, %d)\n", file_path,
5917 	    getmajor(dev), getminor(dev));
5918 
5919 	status = ldi_open_by_dev(&dev, OTYP_BLK, FREAD, kcred, &lhandle,
5920 	    vd->vds->ldi_ident);
5921 
5922 	if (status != 0) {
5923 		PR0("ldi_open() returned errno %d for underlying device",
5924 		    status);
5925 	} else {
5926 		if ((status = ldi_ioctl(lhandle, DKIOCINFO,
5927 		    (intptr_t)&dk_cinfo, (vd->open_flags | FKIOCTL), kcred,
5928 		    &rval)) != 0) {
5929 			PR0("ldi_ioctl(DKIOCINFO) returned errno %d for "
5930 			    "underlying device", status);
5931 		} else {
5932 			/*
5933 			 * Store the device's max transfer size for
5934 			 * return to the client
5935 			 */
5936 			vd->max_xfer_sz = dk_cinfo.dki_maxtransfer;
5937 		}
5938 
5939 		PR0("close the underlying device");
5940 		(void) ldi_close(lhandle, FREAD, kcred);
5941 	}
5942 
5943 	PR0("using file %s on device (%d, %d), max_xfer = %u blks",
5944 	    file_path, getmajor(dev), getminor(dev), vd->max_xfer_sz);
5945 
5946 	if (vd->vdisk_type == VD_DISK_TYPE_SLICE)
5947 		status = vd_setup_slice_image(vd);
5948 	else
5949 		status = vd_setup_disk_image(vd);
5950 
5951 	return (status);
5952 }
5953 
5954 static int
vd_setup_slice_image(vd_t * vd)5955 vd_setup_slice_image(vd_t *vd)
5956 {
5957 	struct dk_label label;
5958 	int status;
5959 
5960 	if ((status = vd_backend_check_size(vd)) != 0) {
5961 		PRN("Check size failed for %s (errno %d)",
5962 		    vd->device_path, status);
5963 		return (EIO);
5964 	}
5965 
5966 	vd->vdisk_media = VD_MEDIA_FIXED;
5967 	vd->vdisk_label = (vd_slice_label == VD_DISK_LABEL_UNK)?
5968 	    vd_file_slice_label : vd_slice_label;
5969 
5970 	if (vd->vdisk_label == VD_DISK_LABEL_EFI ||
5971 	    vd->dskimg_size >= 2 * ONE_TERABYTE) {
5972 		status = vd_setup_partition_efi(vd);
5973 	} else {
5974 		/*
5975 		 * We build a default label to get a geometry for
5976 		 * the vdisk. Then the partition setup function will
5977 		 * adjust the vtoc so that it defines a single-slice
5978 		 * disk.
5979 		 */
5980 		vd_build_default_label(vd->dskimg_size, vd->vdisk_bsize,
5981 		    &label);
5982 		vd_label_to_vtocgeom(&label, &vd->vtoc, &vd->dk_geom);
5983 		status = vd_setup_partition_vtoc(vd);
5984 	}
5985 
5986 	return (status);
5987 }
5988 
5989 static int
vd_setup_disk_image(vd_t * vd)5990 vd_setup_disk_image(vd_t *vd)
5991 {
5992 	int status;
5993 	char *backend_path = vd->device_path;
5994 
5995 	if ((status = vd_backend_check_size(vd)) != 0) {
5996 		PRN("Check size failed for %s (errno %d)",
5997 		    backend_path, status);
5998 		return (EIO);
5999 	}
6000 
6001 	/* size should be at least sizeof(dk_label) */
6002 	if (vd->dskimg_size < sizeof (struct dk_label)) {
6003 		PRN("Size of file has to be at least %ld bytes",
6004 		    sizeof (struct dk_label));
6005 		return (EIO);
6006 	}
6007 
6008 	/*
6009 	 * Find and validate the geometry of a disk image.
6010 	 */
6011 	status = vd_dskimg_validate_geometry(vd);
6012 	if (status != 0 && status != EINVAL && status != ENOTSUP) {
6013 		PRN("Failed to read label from %s", backend_path);
6014 		return (EIO);
6015 	}
6016 
6017 	if (vd_dskimg_is_iso_image(vd)) {
6018 		/*
6019 		 * Indicate whether to call this a CD or DVD from the size
6020 		 * of the ISO image (images for both drive types are stored
6021 		 * in the ISO-9600 format). CDs can store up to just under 1Gb
6022 		 */
6023 		if ((vd->vdisk_size * vd->vdisk_bsize) > ONE_GIGABYTE)
6024 			vd->vdisk_media = VD_MEDIA_DVD;
6025 		else
6026 			vd->vdisk_media = VD_MEDIA_CD;
6027 	} else {
6028 		vd->vdisk_media = VD_MEDIA_FIXED;
6029 	}
6030 
6031 	/* Setup devid for the disk image */
6032 
6033 	if (vd->vdisk_label != VD_DISK_LABEL_UNK) {
6034 
6035 		status = vd_dskimg_read_devid(vd, &vd->dskimg_devid);
6036 
6037 		if (status == 0) {
6038 			/* a valid devid was found */
6039 			return (0);
6040 		}
6041 
6042 		if (status != EINVAL) {
6043 			/*
6044 			 * There was an error while trying to read the devid.
6045 			 * So this disk image may have a devid but we are
6046 			 * unable to read it.
6047 			 */
6048 			PR0("can not read devid for %s", backend_path);
6049 			vd->dskimg_devid = NULL;
6050 			return (0);
6051 		}
6052 	}
6053 
6054 	/*
6055 	 * No valid device id was found so we create one. Note that a failure
6056 	 * to create a device id is not fatal and does not prevent the disk
6057 	 * image from being attached.
6058 	 */
6059 	PR1("creating devid for %s", backend_path);
6060 
6061 	if (ddi_devid_init(vd->vds->dip, DEVID_FAB, NULL, 0,
6062 	    &vd->dskimg_devid) != DDI_SUCCESS) {
6063 		PR0("fail to create devid for %s", backend_path);
6064 		vd->dskimg_devid = NULL;
6065 		return (0);
6066 	}
6067 
6068 	/*
6069 	 * Write devid to the disk image. The devid is stored into the disk
6070 	 * image if we have a valid label; otherwise the devid will be stored
6071 	 * when the user writes a valid label.
6072 	 */
6073 	if (vd->vdisk_label != VD_DISK_LABEL_UNK) {
6074 		if (vd_dskimg_write_devid(vd, vd->dskimg_devid) != 0) {
6075 			PR0("fail to write devid for %s", backend_path);
6076 			ddi_devid_free(vd->dskimg_devid);
6077 			vd->dskimg_devid = NULL;
6078 		}
6079 	}
6080 
6081 	return (0);
6082 }
6083 
6084 
6085 /*
6086  * Description:
6087  *	Open a device using its device path (supplied by ldm(1m))
6088  *
6089  * Parameters:
6090  *	vd 	- pointer to structure containing the vDisk info
6091  *	flags	- open flags
6092  *
6093  * Return Value
6094  *	0	- success
6095  *	!= 0	- some other non-zero return value from ldi(9F) functions
6096  */
6097 static int
vd_open_using_ldi_by_name(vd_t * vd,int flags)6098 vd_open_using_ldi_by_name(vd_t *vd, int flags)
6099 {
6100 	int		status;
6101 	char		*device_path = vd->device_path;
6102 
6103 	/* Attempt to open device */
6104 	status = ldi_open_by_name(device_path, flags, kcred,
6105 	    &vd->ldi_handle[0], vd->vds->ldi_ident);
6106 
6107 	/*
6108 	 * The open can fail for example if we are opening an empty slice.
6109 	 * In case of a failure, we try the open again but this time with
6110 	 * the FNDELAY flag.
6111 	 */
6112 	if (status != 0)
6113 		status = ldi_open_by_name(device_path, flags | FNDELAY,
6114 		    kcred, &vd->ldi_handle[0], vd->vds->ldi_ident);
6115 
6116 	if (status != 0) {
6117 		PR0("ldi_open_by_name(%s) = errno %d", device_path, status);
6118 		vd->ldi_handle[0] = NULL;
6119 		return (status);
6120 	}
6121 
6122 	return (0);
6123 }
6124 
6125 /*
6126  * Setup for a virtual disk which backend is a device (a physical disk,
6127  * slice or volume device) exported as a full disk or as a slice. In these
6128  * cases, the backend is accessed using the LDI interface.
6129  */
6130 static int
vd_setup_backend_ldi(vd_t * vd)6131 vd_setup_backend_ldi(vd_t *vd)
6132 {
6133 	int		rval, status;
6134 	struct dk_cinfo	dk_cinfo;
6135 	char		*device_path = vd->device_path;
6136 
6137 	/* device has been opened by vd_identify_dev() */
6138 	ASSERT(vd->ldi_handle[0] != NULL);
6139 	ASSERT(vd->dev[0] != NULL);
6140 
6141 	vd->file = B_FALSE;
6142 
6143 	/* Verify backing device supports dk_cinfo */
6144 	if ((status = ldi_ioctl(vd->ldi_handle[0], DKIOCINFO,
6145 	    (intptr_t)&dk_cinfo, (vd->open_flags | FKIOCTL), kcred,
6146 	    &rval)) != 0) {
6147 		PRN("ldi_ioctl(DKIOCINFO) returned errno %d for %s",
6148 		    status, device_path);
6149 		return (status);
6150 	}
6151 	if (dk_cinfo.dki_partition >= V_NUMPAR) {
6152 		PRN("slice %u >= maximum slice %u for %s",
6153 		    dk_cinfo.dki_partition, V_NUMPAR, device_path);
6154 		return (EIO);
6155 	}
6156 
6157 	/*
6158 	 * The device has been opened read-only by vd_identify_dev(), re-open
6159 	 * it read-write if the write flag is set and we don't have an optical
6160 	 * device such as a CD-ROM, which, for now, we do not permit writes to
6161 	 * and thus should not export write operations to the client.
6162 	 *
6163 	 * Future: if/when we implement support for guest domains writing to
6164 	 * optical devices we will need to do further checking of the media type
6165 	 * to distinguish between read-only and writable discs.
6166 	 */
6167 	if (dk_cinfo.dki_ctype == DKC_CDROM) {
6168 
6169 		vd->open_flags &= ~FWRITE;
6170 
6171 	} else if (vd->open_flags & FWRITE) {
6172 
6173 		(void) ldi_close(vd->ldi_handle[0], vd->open_flags & ~FWRITE,
6174 		    kcred);
6175 		status = vd_open_using_ldi_by_name(vd, vd->open_flags);
6176 		if (status != 0) {
6177 			PR0("Failed to open (%s) = errno %d",
6178 			    device_path, status);
6179 			return (status);
6180 		}
6181 	}
6182 
6183 	/* Store the device's max transfer size for return to the client */
6184 	vd->max_xfer_sz = dk_cinfo.dki_maxtransfer;
6185 
6186 	/*
6187 	 * We need to work out if it's an ATAPI (IDE CD-ROM) or SCSI device so
6188 	 * that we can use the correct CDB group when sending USCSI commands.
6189 	 */
6190 	vd->is_atapi_dev = vd_is_atapi_device(vd);
6191 
6192 	/*
6193 	 * Export a full disk.
6194 	 *
6195 	 * The exported device can be either a volume, a disk or a CD/DVD
6196 	 * device.  We export a device as a full disk if we have an entire
6197 	 * disk slice (slice 2) and if this slice is exported as a full disk
6198 	 * and not as a single slice disk. A CD or DVD device is exported
6199 	 * as a full disk (even if it isn't s2). A volume is exported as a
6200 	 * full disk as long as the "slice" option is not specified.
6201 	 */
6202 	if (vd->vdisk_type == VD_DISK_TYPE_DISK) {
6203 
6204 		if (vd->volume) {
6205 			/* setup disk image */
6206 			return (vd_setup_disk_image(vd));
6207 		}
6208 
6209 		if (dk_cinfo.dki_partition == VD_ENTIRE_DISK_SLICE ||
6210 		    dk_cinfo.dki_ctype == DKC_CDROM) {
6211 			ASSERT(!vd->volume);
6212 			if (dk_cinfo.dki_ctype == DKC_SCSI_CCS)
6213 				vd->scsi = B_TRUE;
6214 			return (vd_setup_full_disk(vd));
6215 		}
6216 	}
6217 
6218 	/*
6219 	 * Export a single slice disk.
6220 	 *
6221 	 * The exported device can be either a volume device or a disk slice. If
6222 	 * it is a disk slice different from slice 2 then it is always exported
6223 	 * as a single slice disk even if the "slice" option is not specified.
6224 	 * If it is disk slice 2 or a volume device then it is exported as a
6225 	 * single slice disk only if the "slice" option is specified.
6226 	 */
6227 	return (vd_setup_single_slice_disk(vd));
6228 }
6229 
6230 static int
vd_setup_single_slice_disk(vd_t * vd)6231 vd_setup_single_slice_disk(vd_t *vd)
6232 {
6233 	int status, rval;
6234 	struct dk_label label;
6235 	char *device_path = vd->device_path;
6236 	struct vtoc vtoc;
6237 
6238 	vd->vdisk_media = VD_MEDIA_FIXED;
6239 
6240 	if (vd->volume) {
6241 		ASSERT(vd->vdisk_type == VD_DISK_TYPE_SLICE);
6242 	}
6243 
6244 	/*
6245 	 * We export the slice as a single slice disk even if the "slice"
6246 	 * option was not specified.
6247 	 */
6248 	vd->vdisk_type  = VD_DISK_TYPE_SLICE;
6249 	vd->nslices	= 1;
6250 
6251 	/* Get size of backing device */
6252 	if ((status = vd_backend_check_size(vd)) != 0) {
6253 		PRN("Check size failed for %s (errno %d)", device_path, status);
6254 		return (EIO);
6255 	}
6256 
6257 	/*
6258 	 * When exporting a slice or a device as a single slice disk, we don't
6259 	 * care about any partitioning exposed by the backend. The goal is just
6260 	 * to export the backend as a flat storage. We provide a fake partition
6261 	 * table (either a VTOC or EFI), which presents only one slice, to
6262 	 * accommodate tools expecting a disk label. The selection of the label
6263 	 * type (VTOC or EFI) depends on the value of the vd_slice_label
6264 	 * variable.
6265 	 */
6266 	if (vd_slice_label == VD_DISK_LABEL_EFI ||
6267 	    vd->vdisk_size >= ONE_TERABYTE / vd->vdisk_bsize) {
6268 		vd->vdisk_label = VD_DISK_LABEL_EFI;
6269 	} else {
6270 		status = ldi_ioctl(vd->ldi_handle[0], DKIOCGEXTVTOC,
6271 		    (intptr_t)&vd->vtoc, (vd->open_flags | FKIOCTL),
6272 		    kcred, &rval);
6273 
6274 		if (status == ENOTTY) {
6275 			/* try with the non-extended vtoc ioctl */
6276 			status = ldi_ioctl(vd->ldi_handle[0], DKIOCGVTOC,
6277 			    (intptr_t)&vtoc, (vd->open_flags | FKIOCTL),
6278 			    kcred, &rval);
6279 			vtoctoextvtoc(vtoc, vd->vtoc);
6280 		}
6281 
6282 		if (status == 0) {
6283 			status = ldi_ioctl(vd->ldi_handle[0], DKIOCGGEOM,
6284 			    (intptr_t)&vd->dk_geom, (vd->open_flags | FKIOCTL),
6285 			    kcred, &rval);
6286 
6287 			if (status != 0) {
6288 				PRN("ldi_ioctl(DKIOCGEOM) returned errno %d "
6289 				    "for %s", status, device_path);
6290 				return (status);
6291 			}
6292 			vd->vdisk_label = VD_DISK_LABEL_VTOC;
6293 
6294 		} else if (vd_slice_label == VD_DISK_LABEL_VTOC) {
6295 
6296 			vd->vdisk_label = VD_DISK_LABEL_VTOC;
6297 			vd_build_default_label(vd->vdisk_size * vd->vdisk_bsize,
6298 			    vd->vdisk_bsize, &label);
6299 			vd_label_to_vtocgeom(&label, &vd->vtoc, &vd->dk_geom);
6300 
6301 		} else {
6302 			vd->vdisk_label = VD_DISK_LABEL_EFI;
6303 		}
6304 	}
6305 
6306 	if (vd->vdisk_label == VD_DISK_LABEL_VTOC) {
6307 		/* export with a fake VTOC label */
6308 		status = vd_setup_partition_vtoc(vd);
6309 
6310 	} else {
6311 		/* export with a fake EFI label */
6312 		status = vd_setup_partition_efi(vd);
6313 	}
6314 
6315 	return (status);
6316 }
6317 
6318 /*
6319  * This function is invoked when setting up the vdisk backend and to process
6320  * the VD_OP_GET_CAPACITY operation. It checks the backend size and set the
6321  * following attributes of the vd structure:
6322  *
6323  * - vdisk_bsize: block size for the virtual disk used by the VIO protocol. Its
6324  *   value is 512 bytes (DEV_BSIZE) when the backend is a file, a volume or a
6325  *   CD/DVD. When the backend is a disk or a disk slice then it has the value
6326  *   of the logical block size of that disk (as returned by the DKIOCGMEDIAINFO
6327  *   ioctl). This block size is expected to be a power of 2 and a multiple of
6328  *   512.
6329  *
6330  * - vdisk_size: size of the virtual disk expressed as a number of vdisk_bsize
6331  *   blocks.
6332  *
6333  * vdisk_size and vdisk_bsize are sent to the vdisk client during the connection
6334  * handshake and in the result of a VD_OP_GET_CAPACITY operation.
6335  *
6336  * - backend_bsize: block size of the backend device. backend_bsize has the same
6337  *   value as vdisk_bsize except when the backend is a CD/DVD. In that case,
6338  *   vdisk_bsize is set to 512 (DEV_BSIZE) while backend_bsize is set to the
6339  *   effective logical block size of the CD/DVD (usually 2048).
6340  *
6341  * - dskimg_size: size of the backend when the backend is a disk image. This
6342  *   attribute is set only when the backend is a file or a volume, otherwise it
6343  *   is unused.
6344  *
6345  * - vio_bshift: number of bit to shift to convert a VIO block number (which
6346  *   uses a block size of vdisk_bsize) to a buf(9s) block number (which uses a
6347  *   block size of 512 bytes) i.e. we have vdisk_bsize = 512 x 2 ^ vio_bshift
6348  *
6349  * - vdisk_media: media of the virtual disk. This function only sets this
6350  *   attribute for physical disk and CD/DVD. For other backend types, this
6351  *   attribute is set in the setup function of the backend.
6352  */
6353 static int
vd_backend_check_size(vd_t * vd)6354 vd_backend_check_size(vd_t *vd)
6355 {
6356 	size_t backend_size, backend_bsize, vdisk_bsize;
6357 	size_t old_size, new_size;
6358 	struct dk_minfo minfo;
6359 	vattr_t vattr;
6360 	int rval, rv, media, nshift = 0;
6361 	uint32_t n;
6362 
6363 	if (vd->file) {
6364 
6365 		/* file (slice or full disk) */
6366 		vattr.va_mask = AT_SIZE;
6367 		rv = VOP_GETATTR(vd->file_vnode, &vattr, 0, kcred, NULL);
6368 		if (rv != 0) {
6369 			PR0("VOP_GETATTR(%s) = errno %d", vd->device_path, rv);
6370 			return (rv);
6371 		}
6372 		backend_size = vattr.va_size;
6373 		backend_bsize = DEV_BSIZE;
6374 		vdisk_bsize = DEV_BSIZE;
6375 
6376 	} else if (vd->volume) {
6377 
6378 		/* volume (slice or full disk) */
6379 		rv = ldi_get_size(vd->ldi_handle[0], &backend_size);
6380 		if (rv != DDI_SUCCESS) {
6381 			PR0("ldi_get_size() failed for %s", vd->device_path);
6382 			return (EIO);
6383 		}
6384 		backend_bsize = DEV_BSIZE;
6385 		vdisk_bsize = DEV_BSIZE;
6386 
6387 	} else {
6388 
6389 		/* physical disk or slice */
6390 		rv = ldi_ioctl(vd->ldi_handle[0], DKIOCGMEDIAINFO,
6391 		    (intptr_t)&minfo, (vd->open_flags | FKIOCTL),
6392 		    kcred, &rval);
6393 		if (rv != 0) {
6394 			PR0("DKIOCGMEDIAINFO failed for %s (err=%d)",
6395 			    vd->device_path, rv);
6396 			return (rv);
6397 		}
6398 
6399 		if (vd->vdisk_type == VD_DISK_TYPE_SLICE) {
6400 			rv = ldi_get_size(vd->ldi_handle[0], &backend_size);
6401 			if (rv != DDI_SUCCESS) {
6402 				PR0("ldi_get_size() failed for %s",
6403 				    vd->device_path);
6404 				return (EIO);
6405 			}
6406 		} else {
6407 			ASSERT(vd->vdisk_type == VD_DISK_TYPE_DISK);
6408 			backend_size = minfo.dki_capacity * minfo.dki_lbsize;
6409 		}
6410 
6411 		backend_bsize = minfo.dki_lbsize;
6412 		media = DK_MEDIATYPE2VD_MEDIATYPE(minfo.dki_media_type);
6413 
6414 		/*
6415 		 * If the device is a CD or a DVD then we force the vdisk block
6416 		 * size to 512 bytes (DEV_BSIZE). In that case, vdisk_bsize can
6417 		 * be different from backend_size.
6418 		 */
6419 		if (media == VD_MEDIA_CD || media == VD_MEDIA_DVD)
6420 			vdisk_bsize = DEV_BSIZE;
6421 		else
6422 			vdisk_bsize = backend_bsize;
6423 	}
6424 
6425 	/* check vdisk block size */
6426 	if (vdisk_bsize == 0 || vdisk_bsize % DEV_BSIZE != 0)
6427 		return (EINVAL);
6428 
6429 	old_size = vd->vdisk_size;
6430 	new_size = backend_size / vdisk_bsize;
6431 
6432 	/* check if size has changed */
6433 	if (old_size != VD_SIZE_UNKNOWN && old_size == new_size &&
6434 	    vd->vdisk_bsize == vdisk_bsize)
6435 		return (0);
6436 
6437 	/* cache info for blk conversion */
6438 	for (n = vdisk_bsize / DEV_BSIZE; n > 1; n >>= 1) {
6439 		if ((n & 0x1) != 0) {
6440 			/* blk_size is not a power of 2 */
6441 			return (EINVAL);
6442 		}
6443 		nshift++;
6444 	}
6445 
6446 	vd->vio_bshift = nshift;
6447 	vd->vdisk_size = new_size;
6448 	vd->vdisk_bsize = vdisk_bsize;
6449 	vd->backend_bsize = backend_bsize;
6450 
6451 	if (vd->file || vd->volume)
6452 		vd->dskimg_size = backend_size;
6453 
6454 	/*
6455 	 * If we are exporting a single-slice disk and the size of the backend
6456 	 * has changed then we regenerate the partition setup so that the
6457 	 * partitioning matches with the new disk backend size.
6458 	 */
6459 
6460 	if (vd->vdisk_type == VD_DISK_TYPE_SLICE) {
6461 		/* slice or file or device exported as a slice */
6462 		if (vd->vdisk_label == VD_DISK_LABEL_VTOC) {
6463 			rv = vd_setup_partition_vtoc(vd);
6464 			if (rv != 0) {
6465 				PR0("vd_setup_partition_vtoc() failed for %s "
6466 				    "(err = %d)", vd->device_path, rv);
6467 				return (rv);
6468 			}
6469 		} else {
6470 			rv = vd_setup_partition_efi(vd);
6471 			if (rv != 0) {
6472 				PR0("vd_setup_partition_efi() failed for %s "
6473 				    "(err = %d)", vd->device_path, rv);
6474 				return (rv);
6475 			}
6476 		}
6477 
6478 	} else if (!vd->file && !vd->volume) {
6479 		/* physical disk */
6480 		ASSERT(vd->vdisk_type == VD_DISK_TYPE_DISK);
6481 		vd->vdisk_media = media;
6482 	}
6483 
6484 	return (0);
6485 }
6486 
6487 /*
6488  * Description:
6489  *	Open a device using its device path and identify if this is
6490  *	a disk device or a volume device.
6491  *
6492  * Parameters:
6493  *	vd 	- pointer to structure containing the vDisk info
6494  *	dtype	- return the driver type of the device
6495  *
6496  * Return Value
6497  *	0	- success
6498  *	!= 0	- some other non-zero return value from ldi(9F) functions
6499  */
6500 static int
vd_identify_dev(vd_t * vd,int * dtype)6501 vd_identify_dev(vd_t *vd, int *dtype)
6502 {
6503 	int status, i;
6504 	char *device_path = vd->device_path;
6505 	char *drv_name;
6506 	int drv_type;
6507 	vds_t *vds = vd->vds;
6508 
6509 	status = vd_open_using_ldi_by_name(vd, vd->open_flags & ~FWRITE);
6510 	if (status != 0) {
6511 		PR0("Failed to open (%s) = errno %d", device_path, status);
6512 		return (status);
6513 	}
6514 
6515 	/* Get device number of backing device */
6516 	if ((status = ldi_get_dev(vd->ldi_handle[0], &vd->dev[0])) != 0) {
6517 		PRN("ldi_get_dev() returned errno %d for %s",
6518 		    status, device_path);
6519 		return (status);
6520 	}
6521 
6522 	/*
6523 	 * We start by looking if the driver is in the list from vds.conf
6524 	 * so that we can override the built-in list using vds.conf.
6525 	 */
6526 	drv_name = ddi_major_to_name(getmajor(vd->dev[0]));
6527 	drv_type = VD_DRIVER_UNKNOWN;
6528 
6529 	/* check vds.conf list */
6530 	for (i = 0; i < vds->num_drivers; i++) {
6531 		if (vds->driver_types[i].type == VD_DRIVER_UNKNOWN) {
6532 			/* ignore invalid entries */
6533 			continue;
6534 		}
6535 		if (strcmp(drv_name, vds->driver_types[i].name) == 0) {
6536 			drv_type = vds->driver_types[i].type;
6537 			goto done;
6538 		}
6539 	}
6540 
6541 	/* check built-in list */
6542 	for (i = 0; i < VDS_NUM_DRIVERS; i++) {
6543 		if (strcmp(drv_name, vds_driver_types[i].name) == 0) {
6544 			drv_type = vds_driver_types[i].type;
6545 			goto done;
6546 		}
6547 	}
6548 
6549 done:
6550 	PR0("driver %s identified as %s", drv_name,
6551 	    (drv_type == VD_DRIVER_DISK)? "DISK" :
6552 	    (drv_type == VD_DRIVER_VOLUME)? "VOLUME" : "UNKNOWN");
6553 
6554 	if (strcmp(drv_name, "zfs") == 0)
6555 		vd->zvol = B_TRUE;
6556 
6557 	*dtype = drv_type;
6558 
6559 	return (0);
6560 }
6561 
6562 static int
vd_setup_vd(vd_t * vd)6563 vd_setup_vd(vd_t *vd)
6564 {
6565 	int		status, drv_type, pseudo;
6566 	dev_info_t	*dip;
6567 	vnode_t 	*vnp;
6568 	char		*path = vd->device_path;
6569 	char		tq_name[TASKQ_NAMELEN];
6570 
6571 	/* make sure the vdisk backend is valid */
6572 	if ((status = lookupname(path, UIO_SYSSPACE,
6573 	    FOLLOW, NULLVPP, &vnp)) != 0) {
6574 		PR0("Cannot lookup %s errno %d", path, status);
6575 		goto done;
6576 	}
6577 
6578 	switch (vnp->v_type) {
6579 	case VREG:
6580 		/*
6581 		 * Backend is a file so it is exported as a full disk or as a
6582 		 * single slice disk using the vnode interface.
6583 		 */
6584 		VN_RELE(vnp);
6585 		vd->volume = B_FALSE;
6586 		status = vd_setup_backend_vnode(vd);
6587 		break;
6588 
6589 	case VBLK:
6590 	case VCHR:
6591 		/*
6592 		 * Backend is a device. In that case, it is exported using the
6593 		 * LDI interface, and it is exported either as a single-slice
6594 		 * disk or as a full disk depending on the "slice" option and
6595 		 * on the type of device.
6596 		 *
6597 		 * - A volume device is exported as a single-slice disk if the
6598 		 *   "slice" is specified, otherwise it is exported as a full
6599 		 *   disk.
6600 		 *
6601 		 * - A disk slice (different from slice 2) is always exported
6602 		 *   as a single slice disk using the LDI interface.
6603 		 *
6604 		 * - The slice 2 of a disk is exported as a single slice disk
6605 		 *   if the "slice" option is specified, otherwise the entire
6606 		 *   disk will be exported.
6607 		 *
6608 		 * - The slice of a CD or DVD is exported as single slice disk
6609 		 *   if the "slice" option is specified, otherwise the entire
6610 		 *   disk will be exported.
6611 		 */
6612 
6613 		/* check if this is a pseudo device */
6614 		if ((dip = ddi_hold_devi_by_instance(getmajor(vnp->v_rdev),
6615 		    dev_to_instance(vnp->v_rdev), 0))  == NULL) {
6616 			PRN("%s is no longer accessible", path);
6617 			VN_RELE(vnp);
6618 			status = EIO;
6619 			break;
6620 		}
6621 		pseudo = is_pseudo_device(dip);
6622 		ddi_release_devi(dip);
6623 		VN_RELE(vnp);
6624 
6625 		if ((status = vd_identify_dev(vd, &drv_type)) != 0) {
6626 			if (status != ENODEV && status != ENXIO &&
6627 			    status != ENOENT && status != EROFS) {
6628 				PRN("%s identification failed with status %d",
6629 				    path, status);
6630 				status = EIO;
6631 			}
6632 			break;
6633 		}
6634 
6635 		/*
6636 		 * If the driver hasn't been identified then we consider that
6637 		 * pseudo devices are volumes and other devices are disks.
6638 		 */
6639 		if (drv_type == VD_DRIVER_VOLUME ||
6640 		    (drv_type == VD_DRIVER_UNKNOWN && pseudo)) {
6641 			vd->volume = B_TRUE;
6642 		}
6643 
6644 		/*
6645 		 * If this is a volume device then its usage depends if the
6646 		 * "slice" option is set or not. If the "slice" option is set
6647 		 * then the volume device will be exported as a single slice,
6648 		 * otherwise it will be exported as a full disk.
6649 		 *
6650 		 * For backward compatibility, if vd_volume_force_slice is set
6651 		 * then we always export volume devices as slices.
6652 		 */
6653 		if (vd->volume && vd_volume_force_slice) {
6654 			vd->vdisk_type = VD_DISK_TYPE_SLICE;
6655 			vd->nslices = 1;
6656 		}
6657 
6658 		status = vd_setup_backend_ldi(vd);
6659 		break;
6660 
6661 	default:
6662 		PRN("Unsupported vdisk backend %s", path);
6663 		VN_RELE(vnp);
6664 		status = EBADF;
6665 	}
6666 
6667 done:
6668 	if (status != 0) {
6669 		/*
6670 		 * If the error is retryable print an error message only
6671 		 * during the first try.
6672 		 */
6673 		if (status == ENXIO || status == ENODEV ||
6674 		    status == ENOENT || status == EROFS) {
6675 			if (!(vd->initialized & VD_SETUP_ERROR) &&
6676 			    !(DEVI_IS_ATTACHING(vd->vds->dip))) {
6677 				PRN("%s is currently inaccessible (error %d)",
6678 				    path, status);
6679 			}
6680 			status = EAGAIN;
6681 		} else {
6682 			PRN("%s can not be exported as a virtual disk "
6683 			    "(error %d)", path, status);
6684 		}
6685 		vd->initialized |= VD_SETUP_ERROR;
6686 
6687 	} else if (vd->initialized & VD_SETUP_ERROR) {
6688 		/* print a message only if we previously had an error */
6689 		PRN("%s is now online", path);
6690 		vd->initialized &= ~VD_SETUP_ERROR;
6691 	}
6692 
6693 	/*
6694 	 * For file or ZFS volume we also need an I/O queue.
6695 	 *
6696 	 * The I/O task queue is initialized here and not in vds_do_init_vd()
6697 	 * (as the start and completion queues) because vd_setup_vd() will be
6698 	 * call again if the backend is not available, and we need to know if
6699 	 * the backend is a ZFS volume or a file.
6700 	 */
6701 	if ((vd->file || vd->zvol) && vd->ioq == NULL) {
6702 		(void) snprintf(tq_name, sizeof (tq_name), "vd_ioq%lu", vd->id);
6703 
6704 		if ((vd->ioq = ddi_taskq_create(vd->vds->dip, tq_name,
6705 		    vd_ioq_nthreads, TASKQ_DEFAULTPRI, 0)) == NULL) {
6706 			PRN("Could not create io task queue");
6707 			return (EIO);
6708 		}
6709 	}
6710 
6711 	return (status);
6712 }
6713 
6714 static int
vds_do_init_vd(vds_t * vds,uint64_t id,char * device_path,uint64_t options,uint64_t ldc_id,vd_t ** vdp)6715 vds_do_init_vd(vds_t *vds, uint64_t id, char *device_path, uint64_t options,
6716     uint64_t ldc_id, vd_t **vdp)
6717 {
6718 	char			tq_name[TASKQ_NAMELEN];
6719 	int			status;
6720 	ddi_iblock_cookie_t	iblock = NULL;
6721 	ldc_attr_t		ldc_attr;
6722 	vd_t			*vd;
6723 
6724 
6725 	ASSERT(vds != NULL);
6726 	ASSERT(device_path != NULL);
6727 	ASSERT(vdp != NULL);
6728 	PR0("Adding vdisk for %s", device_path);
6729 
6730 	if ((vd = kmem_zalloc(sizeof (*vd), KM_NOSLEEP)) == NULL) {
6731 		PRN("No memory for virtual disk");
6732 		return (EAGAIN);
6733 	}
6734 	*vdp = vd;	/* assign here so vds_destroy_vd() can cleanup later */
6735 	vd->id = id;
6736 	vd->vds = vds;
6737 	(void) strncpy(vd->device_path, device_path, MAXPATHLEN);
6738 
6739 	/* Setup open flags */
6740 	vd->open_flags = FREAD;
6741 
6742 	if (!(options & VD_OPT_RDONLY))
6743 		vd->open_flags |= FWRITE;
6744 
6745 	if (options & VD_OPT_EXCLUSIVE)
6746 		vd->open_flags |= FEXCL;
6747 
6748 	/* Setup disk type */
6749 	if (options & VD_OPT_SLICE) {
6750 		vd->vdisk_type = VD_DISK_TYPE_SLICE;
6751 		vd->nslices = 1;
6752 	} else {
6753 		vd->vdisk_type = VD_DISK_TYPE_DISK;
6754 		vd->nslices = V_NUMPAR;
6755 	}
6756 
6757 	/* default disk label */
6758 	vd->vdisk_label = VD_DISK_LABEL_UNK;
6759 
6760 	/* Open vdisk and initialize parameters */
6761 	if ((status = vd_setup_vd(vd)) == 0) {
6762 		vd->initialized |= VD_DISK_READY;
6763 
6764 		ASSERT(vd->nslices > 0 && vd->nslices <= V_NUMPAR);
6765 		PR0("vdisk_type = %s, volume = %s, file = %s, nslices = %u",
6766 		    ((vd->vdisk_type == VD_DISK_TYPE_DISK) ? "disk" : "slice"),
6767 		    (vd->volume ? "yes" : "no"), (vd->file ? "yes" : "no"),
6768 		    vd->nslices);
6769 	} else {
6770 		if (status != EAGAIN)
6771 			return (status);
6772 	}
6773 
6774 	/* Initialize locking */
6775 	if (ddi_get_soft_iblock_cookie(vds->dip, DDI_SOFTINT_MED,
6776 	    &iblock) != DDI_SUCCESS) {
6777 		PRN("Could not get iblock cookie.");
6778 		return (EIO);
6779 	}
6780 
6781 	mutex_init(&vd->lock, NULL, MUTEX_DRIVER, iblock);
6782 	vd->initialized |= VD_LOCKING;
6783 
6784 
6785 	/* Create start and completion task queues for the vdisk */
6786 	(void) snprintf(tq_name, sizeof (tq_name), "vd_startq%lu", id);
6787 	PR1("tq_name = %s", tq_name);
6788 	if ((vd->startq = ddi_taskq_create(vds->dip, tq_name, 1,
6789 	    TASKQ_DEFAULTPRI, 0)) == NULL) {
6790 		PRN("Could not create task queue");
6791 		return (EIO);
6792 	}
6793 	(void) snprintf(tq_name, sizeof (tq_name), "vd_completionq%lu", id);
6794 	PR1("tq_name = %s", tq_name);
6795 	if ((vd->completionq = ddi_taskq_create(vds->dip, tq_name, 1,
6796 	    TASKQ_DEFAULTPRI, 0)) == NULL) {
6797 		PRN("Could not create task queue");
6798 		return (EIO);
6799 	}
6800 
6801 	/* Allocate the staging buffer */
6802 	vd->max_msglen = sizeof (vio_msg_t);	/* baseline vio message size */
6803 	vd->vio_msgp = kmem_alloc(vd->max_msglen, KM_SLEEP);
6804 
6805 	vd->enabled = 1;	/* before callback can dispatch to startq */
6806 
6807 
6808 	/* Bring up LDC */
6809 	ldc_attr.devclass	= LDC_DEV_BLK_SVC;
6810 	ldc_attr.instance	= ddi_get_instance(vds->dip);
6811 	ldc_attr.mode		= LDC_MODE_UNRELIABLE;
6812 	ldc_attr.mtu		= VD_LDC_MTU;
6813 	if ((status = ldc_init(ldc_id, &ldc_attr, &vd->ldc_handle)) != 0) {
6814 		PRN("Could not initialize LDC channel %lx, "
6815 		    "init failed with error %d", ldc_id, status);
6816 		return (status);
6817 	}
6818 	vd->initialized |= VD_LDC;
6819 
6820 	if ((status = ldc_reg_callback(vd->ldc_handle, vd_handle_ldc_events,
6821 	    (caddr_t)vd)) != 0) {
6822 		PRN("Could not initialize LDC channel %lu,"
6823 		    "reg_callback failed with error %d", ldc_id, status);
6824 		return (status);
6825 	}
6826 
6827 	if ((status = ldc_open(vd->ldc_handle)) != 0) {
6828 		PRN("Could not initialize LDC channel %lu,"
6829 		    "open failed with error %d", ldc_id, status);
6830 		return (status);
6831 	}
6832 
6833 	if ((status = ldc_up(vd->ldc_handle)) != 0) {
6834 		PR0("ldc_up() returned errno %d", status);
6835 	}
6836 
6837 	/* Allocate the inband task memory handle */
6838 	status = ldc_mem_alloc_handle(vd->ldc_handle, &(vd->inband_task.mhdl));
6839 	if (status) {
6840 		PRN("Could not initialize LDC channel %lu,"
6841 		    "alloc_handle failed with error %d", ldc_id, status);
6842 		return (ENXIO);
6843 	}
6844 
6845 	/* Add the successfully-initialized vdisk to the server's table */
6846 	if (mod_hash_insert(vds->vd_table, (mod_hash_key_t)id, vd) != 0) {
6847 		PRN("Error adding vdisk ID %lu to table", id);
6848 		return (EIO);
6849 	}
6850 
6851 	/* store initial state */
6852 	vd->state = VD_STATE_INIT;
6853 
6854 	return (0);
6855 }
6856 
6857 static void
vd_free_dring_task(vd_t * vdp)6858 vd_free_dring_task(vd_t *vdp)
6859 {
6860 	if (vdp->dring_task != NULL) {
6861 		ASSERT(vdp->dring_len != 0);
6862 		/* Free all dring_task memory handles */
6863 		for (int i = 0; i < vdp->dring_len; i++) {
6864 			(void) ldc_mem_free_handle(vdp->dring_task[i].mhdl);
6865 			kmem_free(vdp->dring_task[i].request,
6866 			    (vdp->descriptor_size -
6867 			    sizeof (vio_dring_entry_hdr_t)));
6868 			vdp->dring_task[i].request = NULL;
6869 			kmem_free(vdp->dring_task[i].msg, vdp->max_msglen);
6870 			vdp->dring_task[i].msg = NULL;
6871 		}
6872 		kmem_free(vdp->dring_task,
6873 		    (sizeof (*vdp->dring_task)) * vdp->dring_len);
6874 		vdp->dring_task = NULL;
6875 	}
6876 
6877 	if (vdp->write_queue != NULL) {
6878 		kmem_free(vdp->write_queue, sizeof (buf_t *) * vdp->dring_len);
6879 		vdp->write_queue = NULL;
6880 	}
6881 }
6882 
6883 /*
6884  * Destroy the state associated with a virtual disk
6885  */
6886 static void
vds_destroy_vd(void * arg)6887 vds_destroy_vd(void *arg)
6888 {
6889 	vd_t	*vd = (vd_t *)arg;
6890 	int	retry = 0, rv;
6891 
6892 	if (vd == NULL)
6893 		return;
6894 
6895 	PR0("Destroying vdisk state");
6896 
6897 	/* Disable queuing requests for the vdisk */
6898 	if (vd->initialized & VD_LOCKING) {
6899 		mutex_enter(&vd->lock);
6900 		vd->enabled = 0;
6901 		mutex_exit(&vd->lock);
6902 	}
6903 
6904 	/* Drain and destroy start queue (*before* destroying ioq) */
6905 	if (vd->startq != NULL)
6906 		ddi_taskq_destroy(vd->startq);	/* waits for queued tasks */
6907 
6908 	/* Drain and destroy the I/O queue (*before* destroying completionq) */
6909 	if (vd->ioq != NULL)
6910 		ddi_taskq_destroy(vd->ioq);
6911 
6912 	/* Drain and destroy completion queue (*before* shutting down LDC) */
6913 	if (vd->completionq != NULL)
6914 		ddi_taskq_destroy(vd->completionq);	/* waits for tasks */
6915 
6916 	vd_free_dring_task(vd);
6917 
6918 	/* Free the inband task memory handle */
6919 	(void) ldc_mem_free_handle(vd->inband_task.mhdl);
6920 
6921 	/* Shut down LDC */
6922 	if (vd->initialized & VD_LDC) {
6923 		/* unmap the dring */
6924 		if (vd->initialized & VD_DRING)
6925 			(void) ldc_mem_dring_unmap(vd->dring_handle);
6926 
6927 		/* close LDC channel - retry on EAGAIN */
6928 		while ((rv = ldc_close(vd->ldc_handle)) == EAGAIN) {
6929 			if (++retry > vds_ldc_retries) {
6930 				PR0("Timed out closing channel");
6931 				break;
6932 			}
6933 			drv_usecwait(vds_ldc_delay);
6934 		}
6935 		if (rv == 0) {
6936 			(void) ldc_unreg_callback(vd->ldc_handle);
6937 			(void) ldc_fini(vd->ldc_handle);
6938 		} else {
6939 			/*
6940 			 * Closing the LDC channel has failed. Ideally we should
6941 			 * fail here but there is no Zeus level infrastructure
6942 			 * to handle this. The MD has already been changed and
6943 			 * we have to do the close. So we try to do as much
6944 			 * clean up as we can.
6945 			 */
6946 			(void) ldc_set_cb_mode(vd->ldc_handle, LDC_CB_DISABLE);
6947 			while (ldc_unreg_callback(vd->ldc_handle) == EAGAIN)
6948 				drv_usecwait(vds_ldc_delay);
6949 		}
6950 	}
6951 
6952 	/* Free the staging buffer for msgs */
6953 	if (vd->vio_msgp != NULL) {
6954 		kmem_free(vd->vio_msgp, vd->max_msglen);
6955 		vd->vio_msgp = NULL;
6956 	}
6957 
6958 	/* Free the inband message buffer */
6959 	if (vd->inband_task.msg != NULL) {
6960 		kmem_free(vd->inband_task.msg, vd->max_msglen);
6961 		vd->inband_task.msg = NULL;
6962 	}
6963 
6964 	if (vd->file) {
6965 		/* Close file */
6966 		(void) VOP_CLOSE(vd->file_vnode, vd->open_flags, 1,
6967 		    0, kcred, NULL);
6968 		VN_RELE(vd->file_vnode);
6969 	} else {
6970 		/* Close any open backing-device slices */
6971 		for (uint_t slice = 0; slice < V_NUMPAR; slice++) {
6972 			if (vd->ldi_handle[slice] != NULL) {
6973 				PR0("Closing slice %u", slice);
6974 				(void) ldi_close(vd->ldi_handle[slice],
6975 				    vd->open_flags, kcred);
6976 			}
6977 		}
6978 	}
6979 
6980 	/* Free disk image devid */
6981 	if (vd->dskimg_devid != NULL)
6982 		ddi_devid_free(vd->dskimg_devid);
6983 
6984 	/* Free any fake label */
6985 	if (vd->flabel) {
6986 		kmem_free(vd->flabel, vd->flabel_size);
6987 		vd->flabel = NULL;
6988 		vd->flabel_size = 0;
6989 	}
6990 
6991 	/* Free lock */
6992 	if (vd->initialized & VD_LOCKING)
6993 		mutex_destroy(&vd->lock);
6994 
6995 	/* Finally, free the vdisk structure itself */
6996 	kmem_free(vd, sizeof (*vd));
6997 }
6998 
6999 static int
vds_init_vd(vds_t * vds,uint64_t id,char * device_path,uint64_t options,uint64_t ldc_id)7000 vds_init_vd(vds_t *vds, uint64_t id, char *device_path, uint64_t options,
7001     uint64_t ldc_id)
7002 {
7003 	int	status;
7004 	vd_t	*vd = NULL;
7005 
7006 
7007 	if ((status = vds_do_init_vd(vds, id, device_path, options,
7008 	    ldc_id, &vd)) != 0)
7009 		vds_destroy_vd(vd);
7010 
7011 	return (status);
7012 }
7013 
7014 static int
vds_do_get_ldc_id(md_t * md,mde_cookie_t vd_node,mde_cookie_t * channel,uint64_t * ldc_id)7015 vds_do_get_ldc_id(md_t *md, mde_cookie_t vd_node, mde_cookie_t *channel,
7016     uint64_t *ldc_id)
7017 {
7018 	int	num_channels;
7019 
7020 
7021 	/* Look for channel endpoint child(ren) of the vdisk MD node */
7022 	if ((num_channels = md_scan_dag(md, vd_node,
7023 	    md_find_name(md, VD_CHANNEL_ENDPOINT),
7024 	    md_find_name(md, "fwd"), channel)) <= 0) {
7025 		PRN("No \"%s\" found for virtual disk", VD_CHANNEL_ENDPOINT);
7026 		return (-1);
7027 	}
7028 
7029 	/* Get the "id" value for the first channel endpoint node */
7030 	if (md_get_prop_val(md, channel[0], VD_ID_PROP, ldc_id) != 0) {
7031 		PRN("No \"%s\" property found for \"%s\" of vdisk",
7032 		    VD_ID_PROP, VD_CHANNEL_ENDPOINT);
7033 		return (-1);
7034 	}
7035 
7036 	if (num_channels > 1) {
7037 		PRN("Using ID of first of multiple channels for this vdisk");
7038 	}
7039 
7040 	return (0);
7041 }
7042 
7043 static int
vds_get_ldc_id(md_t * md,mde_cookie_t vd_node,uint64_t * ldc_id)7044 vds_get_ldc_id(md_t *md, mde_cookie_t vd_node, uint64_t *ldc_id)
7045 {
7046 	int		num_nodes, status;
7047 	size_t		size;
7048 	mde_cookie_t	*channel;
7049 
7050 
7051 	if ((num_nodes = md_node_count(md)) <= 0) {
7052 		PRN("Invalid node count in Machine Description subtree");
7053 		return (-1);
7054 	}
7055 	size = num_nodes*(sizeof (*channel));
7056 	channel = kmem_zalloc(size, KM_SLEEP);
7057 	status = vds_do_get_ldc_id(md, vd_node, channel, ldc_id);
7058 	kmem_free(channel, size);
7059 
7060 	return (status);
7061 }
7062 
7063 /*
7064  * Function:
7065  *	vds_get_options
7066  *
7067  * Description:
7068  * 	Parse the options of a vds node. Options are defined as an array
7069  *	of strings in the vds-block-device-opts property of the vds node
7070  *	in the machine description. Options are returned as a bitmask. The
7071  *	mapping between the bitmask options and the options strings from the
7072  *	machine description is defined in the vd_bdev_options[] array.
7073  *
7074  *	The vds-block-device-opts property is optional. If a vds has no such
7075  *	property then no option is defined.
7076  *
7077  * Parameters:
7078  *	md		- machine description.
7079  *	vd_node		- vds node in the machine description for which
7080  *			  options have to be parsed.
7081  *	options		- the returned options.
7082  *
7083  * Return Code:
7084  *	none.
7085  */
7086 static void
vds_get_options(md_t * md,mde_cookie_t vd_node,uint64_t * options)7087 vds_get_options(md_t *md, mde_cookie_t vd_node, uint64_t *options)
7088 {
7089 	char	*optstr, *opt;
7090 	int	len, n, i;
7091 
7092 	*options = 0;
7093 
7094 	if (md_get_prop_data(md, vd_node, VD_BLOCK_DEVICE_OPTS,
7095 	    (uint8_t **)&optstr, &len) != 0) {
7096 		PR0("No options found");
7097 		return;
7098 	}
7099 
7100 	/* parse options */
7101 	opt = optstr;
7102 	n = sizeof (vd_bdev_options) / sizeof (vd_option_t);
7103 
7104 	while (opt < optstr + len) {
7105 		for (i = 0; i < n; i++) {
7106 			if (strncmp(vd_bdev_options[i].vdo_name,
7107 			    opt, VD_OPTION_NLEN) == 0) {
7108 				*options |= vd_bdev_options[i].vdo_value;
7109 				break;
7110 			}
7111 		}
7112 
7113 		if (i < n) {
7114 			PR0("option: %s", opt);
7115 		} else {
7116 			PRN("option %s is unknown or unsupported", opt);
7117 		}
7118 
7119 		opt += strlen(opt) + 1;
7120 	}
7121 }
7122 
7123 static void
vds_driver_types_free(vds_t * vds)7124 vds_driver_types_free(vds_t *vds)
7125 {
7126 	if (vds->driver_types != NULL) {
7127 		kmem_free(vds->driver_types, sizeof (vd_driver_type_t) *
7128 		    vds->num_drivers);
7129 		vds->driver_types = NULL;
7130 		vds->num_drivers = 0;
7131 	}
7132 }
7133 
7134 /*
7135  * Update the driver type list with information from vds.conf.
7136  */
7137 static void
vds_driver_types_update(vds_t * vds)7138 vds_driver_types_update(vds_t *vds)
7139 {
7140 	char **list, *s;
7141 	uint_t i, num, count = 0, len;
7142 
7143 	if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, vds->dip,
7144 	    DDI_PROP_DONTPASS, "driver-type-list", &list, &num) !=
7145 	    DDI_PROP_SUCCESS)
7146 		return;
7147 
7148 	/*
7149 	 * We create a driver_types list with as many as entries as there
7150 	 * is in the driver-type-list from vds.conf. However only valid
7151 	 * entries will be populated (i.e. entries from driver-type-list
7152 	 * with a valid syntax). Invalid entries will be left blank so
7153 	 * they will have no driver name and the driver type will be
7154 	 * VD_DRIVER_UNKNOWN (= 0).
7155 	 */
7156 	vds->num_drivers = num;
7157 	vds->driver_types = kmem_zalloc(sizeof (vd_driver_type_t) * num,
7158 	    KM_SLEEP);
7159 
7160 	for (i = 0; i < num; i++) {
7161 
7162 		s = strchr(list[i], ':');
7163 
7164 		if (s == NULL) {
7165 			PRN("vds.conf: driver-type-list, entry %d (%s): "
7166 			    "a colon is expected in the entry",
7167 			    i, list[i]);
7168 			continue;
7169 		}
7170 
7171 		len = (uintptr_t)s - (uintptr_t)list[i];
7172 
7173 		if (len == 0) {
7174 			PRN("vds.conf: driver-type-list, entry %d (%s): "
7175 			    "the driver name is empty",
7176 			    i, list[i]);
7177 			continue;
7178 		}
7179 
7180 		if (len >= VD_DRIVER_NAME_LEN) {
7181 			PRN("vds.conf: driver-type-list, entry %d (%s): "
7182 			    "the driver name is too long",
7183 			    i, list[i]);
7184 			continue;
7185 		}
7186 
7187 		if (strcmp(s + 1, "disk") == 0) {
7188 
7189 			vds->driver_types[i].type = VD_DRIVER_DISK;
7190 
7191 		} else if (strcmp(s + 1, "volume") == 0) {
7192 
7193 			vds->driver_types[i].type = VD_DRIVER_VOLUME;
7194 
7195 		} else {
7196 			PRN("vds.conf: driver-type-list, entry %d (%s): "
7197 			    "the driver type is invalid",
7198 			    i, list[i]);
7199 			continue;
7200 		}
7201 
7202 		(void) strncpy(vds->driver_types[i].name, list[i], len);
7203 
7204 		PR0("driver-type-list, entry %d (%s) added",
7205 		    i, list[i]);
7206 
7207 		count++;
7208 	}
7209 
7210 	ddi_prop_free(list);
7211 
7212 	if (count == 0) {
7213 		/* nothing was added, clean up */
7214 		vds_driver_types_free(vds);
7215 	}
7216 }
7217 
7218 static void
vds_add_vd(vds_t * vds,md_t * md,mde_cookie_t vd_node)7219 vds_add_vd(vds_t *vds, md_t *md, mde_cookie_t vd_node)
7220 {
7221 	char		*device_path = NULL;
7222 	uint64_t	id = 0, ldc_id = 0, options = 0;
7223 
7224 	if (md_get_prop_val(md, vd_node, VD_ID_PROP, &id) != 0) {
7225 		PRN("Error getting vdisk \"%s\"", VD_ID_PROP);
7226 		return;
7227 	}
7228 	PR0("Adding vdisk ID %lu", id);
7229 	if (md_get_prop_str(md, vd_node, VD_BLOCK_DEVICE_PROP,
7230 	    &device_path) != 0) {
7231 		PRN("Error getting vdisk \"%s\"", VD_BLOCK_DEVICE_PROP);
7232 		return;
7233 	}
7234 
7235 	vds_get_options(md, vd_node, &options);
7236 
7237 	if (vds_get_ldc_id(md, vd_node, &ldc_id) != 0) {
7238 		PRN("Error getting LDC ID for vdisk %lu", id);
7239 		return;
7240 	}
7241 
7242 	if (vds_init_vd(vds, id, device_path, options, ldc_id) != 0) {
7243 		PRN("Failed to add vdisk ID %lu", id);
7244 		if (mod_hash_destroy(vds->vd_table, (mod_hash_key_t)id) != 0)
7245 			PRN("No vDisk entry found for vdisk ID %lu", id);
7246 		return;
7247 	}
7248 }
7249 
7250 static void
vds_remove_vd(vds_t * vds,md_t * md,mde_cookie_t vd_node)7251 vds_remove_vd(vds_t *vds, md_t *md, mde_cookie_t vd_node)
7252 {
7253 	uint64_t	id = 0;
7254 
7255 
7256 	if (md_get_prop_val(md, vd_node, VD_ID_PROP, &id) != 0) {
7257 		PRN("Unable to get \"%s\" property from vdisk's MD node",
7258 		    VD_ID_PROP);
7259 		return;
7260 	}
7261 	PR0("Removing vdisk ID %lu", id);
7262 	if (mod_hash_destroy(vds->vd_table, (mod_hash_key_t)id) != 0)
7263 		PRN("No vdisk entry found for vdisk ID %lu", id);
7264 }
7265 
7266 static void
vds_change_vd(vds_t * vds,md_t * prev_md,mde_cookie_t prev_vd_node,md_t * curr_md,mde_cookie_t curr_vd_node)7267 vds_change_vd(vds_t *vds, md_t *prev_md, mde_cookie_t prev_vd_node,
7268     md_t *curr_md, mde_cookie_t curr_vd_node)
7269 {
7270 	char		*curr_dev, *prev_dev;
7271 	uint64_t	curr_id = 0, curr_ldc_id = 0, curr_options = 0;
7272 	uint64_t	prev_id = 0, prev_ldc_id = 0, prev_options = 0;
7273 	size_t		len;
7274 
7275 
7276 	/* Validate that vdisk ID has not changed */
7277 	if (md_get_prop_val(prev_md, prev_vd_node, VD_ID_PROP, &prev_id) != 0) {
7278 		PRN("Error getting previous vdisk \"%s\" property",
7279 		    VD_ID_PROP);
7280 		return;
7281 	}
7282 	if (md_get_prop_val(curr_md, curr_vd_node, VD_ID_PROP, &curr_id) != 0) {
7283 		PRN("Error getting current vdisk \"%s\" property", VD_ID_PROP);
7284 		return;
7285 	}
7286 	if (curr_id != prev_id) {
7287 		PRN("Not changing vdisk:  ID changed from %lu to %lu",
7288 		    prev_id, curr_id);
7289 		return;
7290 	}
7291 
7292 	/* Validate that LDC ID has not changed */
7293 	if (vds_get_ldc_id(prev_md, prev_vd_node, &prev_ldc_id) != 0) {
7294 		PRN("Error getting LDC ID for vdisk %lu", prev_id);
7295 		return;
7296 	}
7297 
7298 	if (vds_get_ldc_id(curr_md, curr_vd_node, &curr_ldc_id) != 0) {
7299 		PRN("Error getting LDC ID for vdisk %lu", curr_id);
7300 		return;
7301 	}
7302 	if (curr_ldc_id != prev_ldc_id) {
7303 		_NOTE(NOTREACHED);	/* lint is confused */
7304 		PRN("Not changing vdisk:  "
7305 		    "LDC ID changed from %lu to %lu", prev_ldc_id, curr_ldc_id);
7306 		return;
7307 	}
7308 
7309 	/* Determine whether device path has changed */
7310 	if (md_get_prop_str(prev_md, prev_vd_node, VD_BLOCK_DEVICE_PROP,
7311 	    &prev_dev) != 0) {
7312 		PRN("Error getting previous vdisk \"%s\"",
7313 		    VD_BLOCK_DEVICE_PROP);
7314 		return;
7315 	}
7316 	if (md_get_prop_str(curr_md, curr_vd_node, VD_BLOCK_DEVICE_PROP,
7317 	    &curr_dev) != 0) {
7318 		PRN("Error getting current vdisk \"%s\"", VD_BLOCK_DEVICE_PROP);
7319 		return;
7320 	}
7321 	if (((len = strlen(curr_dev)) == strlen(prev_dev)) &&
7322 	    (strncmp(curr_dev, prev_dev, len) == 0))
7323 		return;	/* no relevant (supported) change */
7324 
7325 	/* Validate that options have not changed */
7326 	vds_get_options(prev_md, prev_vd_node, &prev_options);
7327 	vds_get_options(curr_md, curr_vd_node, &curr_options);
7328 	if (prev_options != curr_options) {
7329 		PRN("Not changing vdisk:  options changed from %lx to %lx",
7330 		    prev_options, curr_options);
7331 		return;
7332 	}
7333 
7334 	PR0("Changing vdisk ID %lu", prev_id);
7335 
7336 	/* Remove old state, which will close vdisk and reset */
7337 	if (mod_hash_destroy(vds->vd_table, (mod_hash_key_t)prev_id) != 0)
7338 		PRN("No entry found for vdisk ID %lu", prev_id);
7339 
7340 	/* Re-initialize vdisk with new state */
7341 	if (vds_init_vd(vds, curr_id, curr_dev, curr_options,
7342 	    curr_ldc_id) != 0) {
7343 		PRN("Failed to change vdisk ID %lu", curr_id);
7344 		return;
7345 	}
7346 }
7347 
7348 static int
vds_process_md(void * arg,mdeg_result_t * md)7349 vds_process_md(void *arg, mdeg_result_t *md)
7350 {
7351 	int	i;
7352 	vds_t	*vds = arg;
7353 
7354 
7355 	if (md == NULL)
7356 		return (MDEG_FAILURE);
7357 	ASSERT(vds != NULL);
7358 
7359 	for (i = 0; i < md->removed.nelem; i++)
7360 		vds_remove_vd(vds, md->removed.mdp, md->removed.mdep[i]);
7361 	for (i = 0; i < md->match_curr.nelem; i++)
7362 		vds_change_vd(vds, md->match_prev.mdp, md->match_prev.mdep[i],
7363 		    md->match_curr.mdp, md->match_curr.mdep[i]);
7364 	for (i = 0; i < md->added.nelem; i++)
7365 		vds_add_vd(vds, md->added.mdp, md->added.mdep[i]);
7366 
7367 	return (MDEG_SUCCESS);
7368 }
7369 
7370 
7371 static int
vds_do_attach(dev_info_t * dip)7372 vds_do_attach(dev_info_t *dip)
7373 {
7374 	int			status, sz;
7375 	int			cfg_handle;
7376 	minor_t			instance = ddi_get_instance(dip);
7377 	vds_t			*vds;
7378 	mdeg_prop_spec_t	*pspecp;
7379 	mdeg_node_spec_t	*ispecp;
7380 
7381 	/*
7382 	 * The "cfg-handle" property of a vds node in an MD contains the MD's
7383 	 * notion of "instance", or unique identifier, for that node; OBP
7384 	 * stores the value of the "cfg-handle" MD property as the value of
7385 	 * the "reg" property on the node in the device tree it builds from
7386 	 * the MD and passes to Solaris.  Thus, we look up the devinfo node's
7387 	 * "reg" property value to uniquely identify this device instance when
7388 	 * registering with the MD event-generation framework.  If the "reg"
7389 	 * property cannot be found, the device tree state is presumably so
7390 	 * broken that there is no point in continuing.
7391 	 */
7392 	if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
7393 	    VD_REG_PROP)) {
7394 		PRN("vds \"%s\" property does not exist", VD_REG_PROP);
7395 		return (DDI_FAILURE);
7396 	}
7397 
7398 	/* Get the MD instance for later MDEG registration */
7399 	cfg_handle = ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
7400 	    VD_REG_PROP, -1);
7401 
7402 	if (ddi_soft_state_zalloc(vds_state, instance) != DDI_SUCCESS) {
7403 		PRN("Could not allocate state for instance %u", instance);
7404 		return (DDI_FAILURE);
7405 	}
7406 
7407 	if ((vds = ddi_get_soft_state(vds_state, instance)) == NULL) {
7408 		PRN("Could not get state for instance %u", instance);
7409 		ddi_soft_state_free(vds_state, instance);
7410 		return (DDI_FAILURE);
7411 	}
7412 
7413 	vds->dip	= dip;
7414 	vds->vd_table	= mod_hash_create_ptrhash("vds_vd_table", VDS_NCHAINS,
7415 	    vds_destroy_vd, sizeof (void *));
7416 
7417 	ASSERT(vds->vd_table != NULL);
7418 
7419 	if ((status = ldi_ident_from_dip(dip, &vds->ldi_ident)) != 0) {
7420 		PRN("ldi_ident_from_dip() returned errno %d", status);
7421 		return (DDI_FAILURE);
7422 	}
7423 	vds->initialized |= VDS_LDI;
7424 
7425 	/* Register for MD updates */
7426 	sz = sizeof (vds_prop_template);
7427 	pspecp = kmem_alloc(sz, KM_SLEEP);
7428 	bcopy(vds_prop_template, pspecp, sz);
7429 
7430 	VDS_SET_MDEG_PROP_INST(pspecp, cfg_handle);
7431 
7432 	/* initialize the complete prop spec structure */
7433 	ispecp = kmem_zalloc(sizeof (mdeg_node_spec_t), KM_SLEEP);
7434 	ispecp->namep = "virtual-device";
7435 	ispecp->specp = pspecp;
7436 
7437 	if (mdeg_register(ispecp, &vd_match, vds_process_md, vds,
7438 	    &vds->mdeg) != MDEG_SUCCESS) {
7439 		PRN("Unable to register for MD updates");
7440 		kmem_free(ispecp, sizeof (mdeg_node_spec_t));
7441 		kmem_free(pspecp, sz);
7442 		return (DDI_FAILURE);
7443 	}
7444 
7445 	vds->ispecp = ispecp;
7446 	vds->initialized |= VDS_MDEG;
7447 
7448 	/* Prevent auto-detaching so driver is available whenever MD changes */
7449 	if (ddi_prop_update_int(DDI_DEV_T_NONE, dip, DDI_NO_AUTODETACH, 1) !=
7450 	    DDI_PROP_SUCCESS) {
7451 		PRN("failed to set \"%s\" property for instance %u",
7452 		    DDI_NO_AUTODETACH, instance);
7453 	}
7454 
7455 	/* read any user defined driver types from conf file and update list */
7456 	vds_driver_types_update(vds);
7457 
7458 	ddi_report_dev(dip);
7459 	return (DDI_SUCCESS);
7460 }
7461 
7462 static int
vds_attach(dev_info_t * dip,ddi_attach_cmd_t cmd)7463 vds_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
7464 {
7465 	int	status;
7466 
7467 	switch (cmd) {
7468 	case DDI_ATTACH:
7469 		PR0("Attaching");
7470 		if ((status = vds_do_attach(dip)) != DDI_SUCCESS)
7471 			(void) vds_detach(dip, DDI_DETACH);
7472 		return (status);
7473 	case DDI_RESUME:
7474 		PR0("No action required for DDI_RESUME");
7475 		return (DDI_SUCCESS);
7476 	default:
7477 		return (DDI_FAILURE);
7478 	}
7479 }
7480 
7481 static struct dev_ops vds_ops = {
7482 	DEVO_REV,	/* devo_rev */
7483 	0,		/* devo_refcnt */
7484 	ddi_no_info,	/* devo_getinfo */
7485 	nulldev,	/* devo_identify */
7486 	nulldev,	/* devo_probe */
7487 	vds_attach,	/* devo_attach */
7488 	vds_detach,	/* devo_detach */
7489 	nodev,		/* devo_reset */
7490 	NULL,		/* devo_cb_ops */
7491 	NULL,		/* devo_bus_ops */
7492 	nulldev,	/* devo_power */
7493 	ddi_quiesce_not_needed,	/* devo_quiesce */
7494 };
7495 
7496 static struct modldrv modldrv = {
7497 	&mod_driverops,
7498 	"virtual disk server",
7499 	&vds_ops,
7500 };
7501 
7502 static struct modlinkage modlinkage = {
7503 	MODREV_1,
7504 	&modldrv,
7505 	NULL
7506 };
7507 
7508 
7509 int
_init(void)7510 _init(void)
7511 {
7512 	int		status;
7513 
7514 	if ((status = ddi_soft_state_init(&vds_state, sizeof (vds_t), 1)) != 0)
7515 		return (status);
7516 
7517 	if ((status = mod_install(&modlinkage)) != 0) {
7518 		ddi_soft_state_fini(&vds_state);
7519 		return (status);
7520 	}
7521 
7522 	return (0);
7523 }
7524 
7525 int
_info(struct modinfo * modinfop)7526 _info(struct modinfo *modinfop)
7527 {
7528 	return (mod_info(&modlinkage, modinfop));
7529 }
7530 
7531 int
_fini(void)7532 _fini(void)
7533 {
7534 	int	status;
7535 
7536 	if ((status = mod_remove(&modlinkage)) != 0)
7537 		return (status);
7538 	ddi_soft_state_fini(&vds_state);
7539 	return (0);
7540 }
7541