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