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