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