1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright 2017 Nexenta Systems, Inc. All rights reserved. 25 * Copyright (c) 2013 by Delphix. All rights reserved. 26 */ 27 28 #include <sys/sysmacros.h> 29 #include <sys/conf.h> 30 #include <sys/file.h> 31 #include <sys/ddi.h> 32 #include <sys/sunddi.h> 33 #include <sys/modctl.h> 34 #include <sys/scsi/scsi.h> 35 #include <sys/scsi/impl/scsi_reset_notify.h> 36 #include <sys/disp.h> 37 #include <sys/byteorder.h> 38 #include <sys/pathname.h> 39 #include <sys/atomic.h> 40 #include <sys/nvpair.h> 41 #include <sys/fs/zfs.h> 42 #include <sys/sdt.h> 43 #include <sys/dkio.h> 44 #include <sys/zfs_ioctl.h> 45 46 #include <sys/stmf.h> 47 #include <sys/lpif.h> 48 #include <sys/stmf_ioctl.h> 49 #include <sys/stmf_sbd_ioctl.h> 50 51 #include "stmf_sbd.h" 52 #include "sbd_impl.h" 53 54 #define SBD_IS_ZVOL(zvol) (strncmp("/dev/zvol", zvol, 9)) 55 56 extern sbd_status_t sbd_pgr_meta_init(sbd_lu_t *sl); 57 extern sbd_status_t sbd_pgr_meta_load(sbd_lu_t *sl); 58 extern void sbd_pgr_reset(sbd_lu_t *sl); 59 60 static int sbd_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, 61 void **result); 62 static int sbd_attach(dev_info_t *dip, ddi_attach_cmd_t cmd); 63 static int sbd_detach(dev_info_t *dip, ddi_detach_cmd_t cmd); 64 static int sbd_open(dev_t *devp, int flag, int otype, cred_t *credp); 65 static int sbd_close(dev_t dev, int flag, int otype, cred_t *credp); 66 static int stmf_sbd_ioctl(dev_t dev, int cmd, intptr_t data, int mode, 67 cred_t *credp, int *rval); 68 void sbd_lp_cb(stmf_lu_provider_t *lp, int cmd, void *arg, uint32_t flags); 69 stmf_status_t sbd_proxy_reg_lu(uint8_t *luid, void *proxy_reg_arg, 70 uint32_t proxy_reg_arg_len); 71 stmf_status_t sbd_proxy_dereg_lu(uint8_t *luid, void *proxy_reg_arg, 72 uint32_t proxy_reg_arg_len); 73 stmf_status_t sbd_proxy_msg(uint8_t *luid, void *proxy_arg, 74 uint32_t proxy_arg_len, uint32_t type); 75 int sbd_create_register_lu(sbd_create_and_reg_lu_t *slu, int struct_sz, 76 uint32_t *err_ret); 77 int sbd_create_standby_lu(sbd_create_standby_lu_t *slu, uint32_t *err_ret); 78 int sbd_set_lu_standby(sbd_set_lu_standby_t *stlu, uint32_t *err_ret); 79 int sbd_import_lu(sbd_import_lu_t *ilu, int struct_sz, uint32_t *err_ret, 80 int no_register, sbd_lu_t **slr); 81 int sbd_import_active_lu(sbd_import_lu_t *ilu, sbd_lu_t *sl, uint32_t *err_ret); 82 int sbd_delete_lu(sbd_delete_lu_t *dlu, int struct_sz, uint32_t *err_ret); 83 int sbd_modify_lu(sbd_modify_lu_t *mlu, int struct_sz, uint32_t *err_ret); 84 int sbd_set_global_props(sbd_global_props_t *mlu, int struct_sz, 85 uint32_t *err_ret); 86 int sbd_get_global_props(sbd_global_props_t *oslp, uint32_t oslp_sz, 87 uint32_t *err_ret); 88 int sbd_get_lu_props(sbd_lu_props_t *islp, uint32_t islp_sz, 89 sbd_lu_props_t *oslp, uint32_t oslp_sz, uint32_t *err_ret); 90 static char *sbd_get_zvol_name(sbd_lu_t *); 91 static int sbd_get_unmap_props(sbd_unmap_props_t *sup, sbd_unmap_props_t *osup, 92 uint32_t *err_ret); 93 sbd_status_t sbd_create_zfs_meta_object(sbd_lu_t *sl); 94 sbd_status_t sbd_open_zfs_meta(sbd_lu_t *sl); 95 sbd_status_t sbd_read_zfs_meta(sbd_lu_t *sl, uint8_t *buf, uint64_t sz, 96 uint64_t off); 97 sbd_status_t sbd_write_zfs_meta(sbd_lu_t *sl, uint8_t *buf, uint64_t sz, 98 uint64_t off); 99 sbd_status_t sbd_update_zfs_prop(sbd_lu_t *sl); 100 int sbd_is_zvol(char *path); 101 int sbd_zvolget(char *zvol_name, char **comstarprop); 102 int sbd_zvolset(char *zvol_name, char *comstarprop); 103 char sbd_ctoi(char c); 104 void sbd_close_lu(sbd_lu_t *sl); 105 106 static ldi_ident_t sbd_zfs_ident; 107 static stmf_lu_provider_t *sbd_lp; 108 static sbd_lu_t *sbd_lu_list = NULL; 109 static kmutex_t sbd_lock; 110 static dev_info_t *sbd_dip; 111 static uint32_t sbd_lu_count = 0; 112 113 /* Global property settings for the logical unit */ 114 char sbd_vendor_id[] = "SUN "; 115 char sbd_product_id[] = "COMSTAR "; 116 char sbd_revision[] = "1.0 "; 117 char *sbd_mgmt_url = NULL; 118 uint16_t sbd_mgmt_url_alloc_size = 0; 119 krwlock_t sbd_global_prop_lock; 120 121 static char sbd_name[] = "sbd"; 122 123 static struct cb_ops sbd_cb_ops = { 124 sbd_open, /* open */ 125 sbd_close, /* close */ 126 nodev, /* strategy */ 127 nodev, /* print */ 128 nodev, /* dump */ 129 nodev, /* read */ 130 nodev, /* write */ 131 stmf_sbd_ioctl, /* ioctl */ 132 nodev, /* devmap */ 133 nodev, /* mmap */ 134 nodev, /* segmap */ 135 nochpoll, /* chpoll */ 136 ddi_prop_op, /* cb_prop_op */ 137 0, /* streamtab */ 138 D_NEW | D_MP, /* cb_flag */ 139 CB_REV, /* rev */ 140 nodev, /* aread */ 141 nodev /* awrite */ 142 }; 143 144 static struct dev_ops sbd_ops = { 145 DEVO_REV, 146 0, 147 sbd_getinfo, 148 nulldev, /* identify */ 149 nulldev, /* probe */ 150 sbd_attach, 151 sbd_detach, 152 nodev, /* reset */ 153 &sbd_cb_ops, 154 NULL, /* bus_ops */ 155 NULL /* power */ 156 }; 157 158 #define SBD_NAME "COMSTAR SBD" 159 160 static struct modldrv modldrv = { 161 &mod_driverops, 162 SBD_NAME, 163 &sbd_ops 164 }; 165 166 static struct modlinkage modlinkage = { 167 MODREV_1, 168 &modldrv, 169 NULL 170 }; 171 172 int 173 _init(void) 174 { 175 int ret; 176 177 ret = mod_install(&modlinkage); 178 if (ret) 179 return (ret); 180 sbd_lp = (stmf_lu_provider_t *)stmf_alloc(STMF_STRUCT_LU_PROVIDER, 181 0, 0); 182 sbd_lp->lp_lpif_rev = LPIF_REV_2; 183 sbd_lp->lp_instance = 0; 184 sbd_lp->lp_name = sbd_name; 185 sbd_lp->lp_cb = sbd_lp_cb; 186 sbd_lp->lp_alua_support = 1; 187 sbd_lp->lp_proxy_msg = sbd_proxy_msg; 188 sbd_zfs_ident = ldi_ident_from_anon(); 189 190 if (stmf_register_lu_provider(sbd_lp) != STMF_SUCCESS) { 191 (void) mod_remove(&modlinkage); 192 stmf_free(sbd_lp); 193 return (EINVAL); 194 } 195 mutex_init(&sbd_lock, NULL, MUTEX_DRIVER, NULL); 196 rw_init(&sbd_global_prop_lock, NULL, RW_DRIVER, NULL); 197 return (0); 198 } 199 200 int 201 _fini(void) 202 { 203 int ret; 204 205 /* 206 * If we have registered lus, then make sure they are all offline 207 * if so then deregister them. This should drop the sbd_lu_count 208 * to zero. 209 */ 210 if (sbd_lu_count) { 211 sbd_lu_t *slu; 212 213 /* See if all of them are offline */ 214 mutex_enter(&sbd_lock); 215 for (slu = sbd_lu_list; slu != NULL; slu = slu->sl_next) { 216 if ((slu->sl_state != STMF_STATE_OFFLINE) || 217 slu->sl_state_not_acked) { 218 mutex_exit(&sbd_lock); 219 return (EBUSY); 220 } 221 } 222 mutex_exit(&sbd_lock); 223 224 #if 0 225 /* ok start deregistering them */ 226 while (sbd_lu_list) { 227 sbd_store_t *sst = sbd_lu_list->sl_sst; 228 if (sst->sst_deregister_lu(sst) != STMF_SUCCESS) 229 return (EBUSY); 230 } 231 #endif 232 return (EBUSY); 233 } 234 if (stmf_deregister_lu_provider(sbd_lp) != STMF_SUCCESS) 235 return (EBUSY); 236 ret = mod_remove(&modlinkage); 237 if (ret != 0) { 238 (void) stmf_register_lu_provider(sbd_lp); 239 return (ret); 240 } 241 stmf_free(sbd_lp); 242 mutex_destroy(&sbd_lock); 243 rw_destroy(&sbd_global_prop_lock); 244 ldi_ident_release(sbd_zfs_ident); 245 return (0); 246 } 247 248 int 249 _info(struct modinfo *modinfop) 250 { 251 return (mod_info(&modlinkage, modinfop)); 252 } 253 254 /* ARGSUSED */ 255 static int 256 sbd_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result) 257 { 258 switch (cmd) { 259 case DDI_INFO_DEVT2DEVINFO: 260 *result = sbd_dip; 261 break; 262 case DDI_INFO_DEVT2INSTANCE: 263 *result = (void *)(uintptr_t)ddi_get_instance(sbd_dip); 264 break; 265 default: 266 return (DDI_FAILURE); 267 } 268 269 return (DDI_SUCCESS); 270 } 271 272 static int 273 sbd_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 274 { 275 switch (cmd) { 276 case DDI_ATTACH: 277 sbd_dip = dip; 278 279 if (ddi_create_minor_node(dip, "admin", S_IFCHR, 0, 280 DDI_NT_STMF_LP, 0) != DDI_SUCCESS) { 281 break; 282 } 283 ddi_report_dev(dip); 284 return (DDI_SUCCESS); 285 } 286 287 return (DDI_FAILURE); 288 } 289 290 static int 291 sbd_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 292 { 293 switch (cmd) { 294 case DDI_DETACH: 295 ddi_remove_minor_node(dip, 0); 296 return (DDI_SUCCESS); 297 } 298 299 return (DDI_FAILURE); 300 } 301 302 /* ARGSUSED */ 303 static int 304 sbd_open(dev_t *devp, int flag, int otype, cred_t *credp) 305 { 306 if (otype != OTYP_CHR) 307 return (EINVAL); 308 return (0); 309 } 310 311 /* ARGSUSED */ 312 static int 313 sbd_close(dev_t dev, int flag, int otype, cred_t *credp) 314 { 315 return (0); 316 } 317 318 /* ARGSUSED */ 319 static int 320 stmf_sbd_ioctl(dev_t dev, int cmd, intptr_t data, int mode, 321 cred_t *credp, int *rval) 322 { 323 stmf_iocdata_t *iocd; 324 void *ibuf = NULL; 325 void *obuf = NULL; 326 sbd_lu_t *nsl; 327 int i; 328 int ret; 329 330 if (drv_priv(credp) != 0) { 331 return (EPERM); 332 } 333 334 ret = stmf_copyin_iocdata(data, mode, &iocd, &ibuf, &obuf); 335 if (ret) 336 return (ret); 337 iocd->stmf_error = 0; 338 339 switch (cmd) { 340 case SBD_IOCTL_CREATE_AND_REGISTER_LU: 341 if (iocd->stmf_ibuf_size < 342 (sizeof (sbd_create_and_reg_lu_t) - 8)) { 343 ret = EFAULT; 344 break; 345 } 346 if ((iocd->stmf_obuf_size == 0) || 347 (iocd->stmf_obuf_size > iocd->stmf_ibuf_size)) { 348 ret = EINVAL; 349 break; 350 } 351 ret = sbd_create_register_lu((sbd_create_and_reg_lu_t *) 352 ibuf, iocd->stmf_ibuf_size, &iocd->stmf_error); 353 bcopy(ibuf, obuf, iocd->stmf_obuf_size); 354 break; 355 case SBD_IOCTL_SET_LU_STANDBY: 356 if (iocd->stmf_ibuf_size < sizeof (sbd_set_lu_standby_t)) { 357 ret = EFAULT; 358 break; 359 } 360 if (iocd->stmf_obuf_size) { 361 ret = EINVAL; 362 break; 363 } 364 ret = sbd_set_lu_standby((sbd_set_lu_standby_t *)ibuf, 365 &iocd->stmf_error); 366 break; 367 case SBD_IOCTL_IMPORT_LU: 368 if (iocd->stmf_ibuf_size < 369 (sizeof (sbd_import_lu_t) - 8)) { 370 ret = EFAULT; 371 break; 372 } 373 if ((iocd->stmf_obuf_size == 0) || 374 (iocd->stmf_obuf_size > iocd->stmf_ibuf_size)) { 375 ret = EINVAL; 376 break; 377 } 378 ret = sbd_import_lu((sbd_import_lu_t *)ibuf, 379 iocd->stmf_ibuf_size, &iocd->stmf_error, 0, NULL); 380 bcopy(ibuf, obuf, iocd->stmf_obuf_size); 381 break; 382 case SBD_IOCTL_DELETE_LU: 383 if (iocd->stmf_ibuf_size < (sizeof (sbd_delete_lu_t) - 8)) { 384 ret = EFAULT; 385 break; 386 } 387 if (iocd->stmf_obuf_size) { 388 ret = EINVAL; 389 break; 390 } 391 ret = sbd_delete_lu((sbd_delete_lu_t *)ibuf, 392 iocd->stmf_ibuf_size, &iocd->stmf_error); 393 break; 394 case SBD_IOCTL_MODIFY_LU: 395 if (iocd->stmf_ibuf_size < (sizeof (sbd_modify_lu_t) - 8)) { 396 ret = EFAULT; 397 break; 398 } 399 if (iocd->stmf_obuf_size) { 400 ret = EINVAL; 401 break; 402 } 403 ret = sbd_modify_lu((sbd_modify_lu_t *)ibuf, 404 iocd->stmf_ibuf_size, &iocd->stmf_error); 405 break; 406 case SBD_IOCTL_SET_GLOBAL_LU: 407 if (iocd->stmf_ibuf_size < (sizeof (sbd_global_props_t) - 8)) { 408 ret = EFAULT; 409 break; 410 } 411 if (iocd->stmf_obuf_size) { 412 ret = EINVAL; 413 break; 414 } 415 ret = sbd_set_global_props((sbd_global_props_t *)ibuf, 416 iocd->stmf_ibuf_size, &iocd->stmf_error); 417 break; 418 case SBD_IOCTL_GET_GLOBAL_LU: 419 if (iocd->stmf_ibuf_size) { 420 ret = EINVAL; 421 break; 422 } 423 if (iocd->stmf_obuf_size < sizeof (sbd_global_props_t)) { 424 ret = EINVAL; 425 break; 426 } 427 ret = sbd_get_global_props((sbd_global_props_t *)obuf, 428 iocd->stmf_obuf_size, &iocd->stmf_error); 429 break; 430 case SBD_IOCTL_GET_LU_PROPS: 431 if (iocd->stmf_ibuf_size < (sizeof (sbd_lu_props_t) - 8)) { 432 ret = EFAULT; 433 break; 434 } 435 if (iocd->stmf_obuf_size < sizeof (sbd_lu_props_t)) { 436 ret = EINVAL; 437 break; 438 } 439 ret = sbd_get_lu_props((sbd_lu_props_t *)ibuf, 440 iocd->stmf_ibuf_size, (sbd_lu_props_t *)obuf, 441 iocd->stmf_obuf_size, &iocd->stmf_error); 442 break; 443 case SBD_IOCTL_GET_LU_LIST: 444 mutex_enter(&sbd_lock); 445 iocd->stmf_obuf_max_nentries = sbd_lu_count; 446 iocd->stmf_obuf_nentries = min((iocd->stmf_obuf_size >> 4), 447 sbd_lu_count); 448 for (nsl = sbd_lu_list, i = 0; nsl && 449 (i < iocd->stmf_obuf_nentries); i++, nsl = nsl->sl_next) { 450 bcopy(nsl->sl_device_id + 4, 451 &(((uint8_t *)obuf)[i << 4]), 16); 452 } 453 mutex_exit(&sbd_lock); 454 ret = 0; 455 iocd->stmf_error = 0; 456 break; 457 case SBD_IOCTL_GET_UNMAP_PROPS: 458 if (iocd->stmf_ibuf_size < sizeof (sbd_unmap_props_t)) { 459 ret = EFAULT; 460 break; 461 } 462 if (iocd->stmf_obuf_size < sizeof (sbd_unmap_props_t)) { 463 ret = EINVAL; 464 break; 465 } 466 ret = sbd_get_unmap_props((sbd_unmap_props_t *)ibuf, 467 (sbd_unmap_props_t *)obuf, &iocd->stmf_error); 468 break; 469 default: 470 ret = ENOTTY; 471 } 472 473 if (ret == 0) { 474 ret = stmf_copyout_iocdata(data, mode, iocd, obuf); 475 } else if (iocd->stmf_error) { 476 (void) stmf_copyout_iocdata(data, mode, iocd, obuf); 477 } 478 if (obuf) { 479 kmem_free(obuf, iocd->stmf_obuf_size); 480 obuf = NULL; 481 } 482 if (ibuf) { 483 kmem_free(ibuf, iocd->stmf_ibuf_size); 484 ibuf = NULL; 485 } 486 kmem_free(iocd, sizeof (stmf_iocdata_t)); 487 return (ret); 488 } 489 490 /* ARGSUSED */ 491 void 492 sbd_lp_cb(stmf_lu_provider_t *lp, int cmd, void *arg, uint32_t flags) 493 { 494 nvpair_t *np; 495 char *s; 496 sbd_import_lu_t *ilu; 497 uint32_t ilu_sz; 498 uint32_t struct_sz; 499 uint32_t err_ret; 500 int iret; 501 502 if ((cmd != STMF_PROVIDER_DATA_UPDATED) || (arg == NULL)) { 503 return; 504 } 505 506 if ((flags & (STMF_PCB_STMF_ONLINING | STMF_PCB_PREG_COMPLETE)) == 0) { 507 return; 508 } 509 510 np = NULL; 511 ilu_sz = 1024; 512 ilu = (sbd_import_lu_t *)kmem_zalloc(ilu_sz, KM_SLEEP); 513 while ((np = nvlist_next_nvpair((nvlist_t *)arg, np)) != NULL) { 514 if (nvpair_type(np) != DATA_TYPE_STRING) { 515 continue; 516 } 517 if (nvpair_value_string(np, &s) != 0) { 518 continue; 519 } 520 struct_sz = max(8, strlen(s) + 1); 521 struct_sz += sizeof (sbd_import_lu_t) - 8; 522 if (struct_sz > ilu_sz) { 523 kmem_free(ilu, ilu_sz); 524 ilu_sz = struct_sz + 32; 525 ilu = (sbd_import_lu_t *)kmem_zalloc(ilu_sz, KM_SLEEP); 526 } 527 ilu->ilu_struct_size = struct_sz; 528 (void) strcpy(ilu->ilu_meta_fname, s); 529 iret = sbd_import_lu(ilu, struct_sz, &err_ret, 0, NULL); 530 if (iret) { 531 stmf_trace(0, "sbd_lp_cb: import_lu failed, ret = %d, " 532 "err_ret = %d", iret, err_ret); 533 } else { 534 stmf_trace(0, "Imported the LU %s", nvpair_name(np)); 535 } 536 } 537 538 if (ilu) { 539 kmem_free(ilu, ilu_sz); 540 ilu = NULL; 541 } 542 } 543 544 sbd_status_t 545 sbd_link_lu(sbd_lu_t *sl) 546 { 547 sbd_lu_t *nsl; 548 549 mutex_enter(&sbd_lock); 550 mutex_enter(&sl->sl_lock); 551 ASSERT(sl->sl_trans_op != SL_OP_NONE); 552 553 if (sl->sl_flags & SL_LINKED) { 554 mutex_exit(&sbd_lock); 555 mutex_exit(&sl->sl_lock); 556 return (SBD_ALREADY); 557 } 558 for (nsl = sbd_lu_list; nsl; nsl = nsl->sl_next) { 559 if (strcmp(nsl->sl_name, sl->sl_name) == 0) 560 break; 561 } 562 if (nsl) { 563 mutex_exit(&sbd_lock); 564 mutex_exit(&sl->sl_lock); 565 return (SBD_ALREADY); 566 } 567 sl->sl_next = sbd_lu_list; 568 sbd_lu_list = sl; 569 sl->sl_flags |= SL_LINKED; 570 mutex_exit(&sbd_lock); 571 mutex_exit(&sl->sl_lock); 572 return (SBD_SUCCESS); 573 } 574 575 void 576 sbd_unlink_lu(sbd_lu_t *sl) 577 { 578 sbd_lu_t **ppnsl; 579 580 mutex_enter(&sbd_lock); 581 mutex_enter(&sl->sl_lock); 582 ASSERT(sl->sl_trans_op != SL_OP_NONE); 583 584 ASSERT(sl->sl_flags & SL_LINKED); 585 for (ppnsl = &sbd_lu_list; *ppnsl; ppnsl = &((*ppnsl)->sl_next)) { 586 if (*ppnsl == sl) 587 break; 588 } 589 ASSERT(*ppnsl); 590 *ppnsl = (*ppnsl)->sl_next; 591 sl->sl_flags &= ~SL_LINKED; 592 mutex_exit(&sbd_lock); 593 mutex_exit(&sl->sl_lock); 594 } 595 596 sbd_status_t 597 sbd_find_and_lock_lu(uint8_t *guid, uint8_t *meta_name, uint8_t op, 598 sbd_lu_t **ppsl) 599 { 600 sbd_lu_t *sl; 601 int found = 0; 602 sbd_status_t sret; 603 604 mutex_enter(&sbd_lock); 605 for (sl = sbd_lu_list; sl; sl = sl->sl_next) { 606 if (guid) { 607 found = bcmp(sl->sl_device_id + 4, guid, 16) == 0; 608 } else { 609 found = strcmp(sl->sl_name, (char *)meta_name) == 0; 610 } 611 if (found) 612 break; 613 } 614 if (!found) { 615 mutex_exit(&sbd_lock); 616 return (SBD_NOT_FOUND); 617 } 618 mutex_enter(&sl->sl_lock); 619 if (sl->sl_trans_op == SL_OP_NONE) { 620 sl->sl_trans_op = op; 621 *ppsl = sl; 622 sret = SBD_SUCCESS; 623 } else { 624 sret = SBD_BUSY; 625 } 626 mutex_exit(&sl->sl_lock); 627 mutex_exit(&sbd_lock); 628 return (sret); 629 } 630 631 sbd_status_t 632 sbd_read_meta(sbd_lu_t *sl, uint64_t offset, uint64_t size, uint8_t *buf) 633 { 634 uint64_t meta_align; 635 uint64_t starting_off; 636 uint64_t data_off; 637 uint64_t ending_off; 638 uint64_t io_size; 639 uint8_t *io_buf; 640 vnode_t *vp; 641 sbd_status_t ret; 642 ssize_t resid; 643 int vret; 644 645 ASSERT(sl->sl_flags & SL_META_OPENED); 646 if (sl->sl_flags & SL_SHARED_META) { 647 meta_align = (((uint64_t)1) << sl->sl_data_blocksize_shift) - 1; 648 vp = sl->sl_data_vp; 649 ASSERT(vp); 650 } else { 651 meta_align = (((uint64_t)1) << sl->sl_meta_blocksize_shift) - 1; 652 if ((sl->sl_flags & SL_ZFS_META) == 0) { 653 vp = sl->sl_meta_vp; 654 ASSERT(vp); 655 } 656 } 657 starting_off = offset & ~(meta_align); 658 data_off = offset & meta_align; 659 ending_off = (offset + size + meta_align) & (~meta_align); 660 if (ending_off > sl->sl_meta_size_used) { 661 bzero(buf, size); 662 if (starting_off >= sl->sl_meta_size_used) { 663 return (SBD_SUCCESS); 664 } 665 ending_off = (sl->sl_meta_size_used + meta_align) & 666 (~meta_align); 667 if (size > (ending_off - (starting_off + data_off))) { 668 size = ending_off - (starting_off + data_off); 669 } 670 } 671 io_size = ending_off - starting_off; 672 io_buf = (uint8_t *)kmem_zalloc(io_size, KM_SLEEP); 673 ASSERT((starting_off + io_size) <= sl->sl_total_meta_size); 674 675 /* 676 * Don't proceed if the device has been closed 677 * This can occur on an access state change to standby or 678 * a delete. The writer lock is acquired before closing the 679 * lu. If importing, reading the metadata is valid, hence 680 * the check on SL_OP_IMPORT_LU. 681 */ 682 rw_enter(&sl->sl_access_state_lock, RW_READER); 683 if ((sl->sl_flags & SL_MEDIA_LOADED) == 0 && 684 sl->sl_trans_op != SL_OP_IMPORT_LU) { 685 rw_exit(&sl->sl_access_state_lock); 686 ret = SBD_FILEIO_FAILURE; 687 goto sbd_read_meta_failure; 688 } 689 if (sl->sl_flags & SL_ZFS_META) { 690 if ((ret = sbd_read_zfs_meta(sl, io_buf, io_size, 691 starting_off)) != SBD_SUCCESS) { 692 rw_exit(&sl->sl_access_state_lock); 693 goto sbd_read_meta_failure; 694 } 695 } else { 696 vret = vn_rdwr(UIO_READ, vp, (caddr_t)io_buf, (ssize_t)io_size, 697 (offset_t)starting_off, UIO_SYSSPACE, FRSYNC, 698 RLIM64_INFINITY, CRED(), &resid); 699 700 if (vret || resid) { 701 ret = SBD_FILEIO_FAILURE | vret; 702 rw_exit(&sl->sl_access_state_lock); 703 goto sbd_read_meta_failure; 704 } 705 } 706 rw_exit(&sl->sl_access_state_lock); 707 708 bcopy(io_buf + data_off, buf, size); 709 ret = SBD_SUCCESS; 710 711 sbd_read_meta_failure: 712 kmem_free(io_buf, io_size); 713 return (ret); 714 } 715 716 sbd_status_t 717 sbd_write_meta(sbd_lu_t *sl, uint64_t offset, uint64_t size, uint8_t *buf) 718 { 719 uint64_t meta_align; 720 uint64_t starting_off; 721 uint64_t data_off; 722 uint64_t ending_off; 723 uint64_t io_size; 724 uint8_t *io_buf; 725 vnode_t *vp; 726 sbd_status_t ret; 727 ssize_t resid; 728 int vret; 729 730 ASSERT(sl->sl_flags & SL_META_OPENED); 731 if (sl->sl_flags & SL_SHARED_META) { 732 meta_align = (((uint64_t)1) << sl->sl_data_blocksize_shift) - 1; 733 vp = sl->sl_data_vp; 734 ASSERT(vp); 735 } else { 736 meta_align = (((uint64_t)1) << sl->sl_meta_blocksize_shift) - 1; 737 if ((sl->sl_flags & SL_ZFS_META) == 0) { 738 vp = sl->sl_meta_vp; 739 ASSERT(vp); 740 } 741 } 742 starting_off = offset & ~(meta_align); 743 data_off = offset & meta_align; 744 ending_off = (offset + size + meta_align) & (~meta_align); 745 io_size = ending_off - starting_off; 746 io_buf = (uint8_t *)kmem_zalloc(io_size, KM_SLEEP); 747 ret = sbd_read_meta(sl, starting_off, io_size, io_buf); 748 if (ret != SBD_SUCCESS) { 749 goto sbd_write_meta_failure; 750 } 751 bcopy(buf, io_buf + data_off, size); 752 /* 753 * Don't proceed if the device has been closed 754 * This can occur on an access state change to standby or 755 * a delete. The writer lock is acquired before closing the 756 * lu. If importing, reading the metadata is valid, hence 757 * the check on SL_OP_IMPORT_LU. 758 */ 759 rw_enter(&sl->sl_access_state_lock, RW_READER); 760 if ((sl->sl_flags & SL_MEDIA_LOADED) == 0 && 761 sl->sl_trans_op != SL_OP_IMPORT_LU) { 762 rw_exit(&sl->sl_access_state_lock); 763 ret = SBD_FILEIO_FAILURE; 764 goto sbd_write_meta_failure; 765 } 766 if (sl->sl_flags & SL_ZFS_META) { 767 if ((ret = sbd_write_zfs_meta(sl, io_buf, io_size, 768 starting_off)) != SBD_SUCCESS) { 769 rw_exit(&sl->sl_access_state_lock); 770 goto sbd_write_meta_failure; 771 } 772 } else { 773 vret = vn_rdwr(UIO_WRITE, vp, (caddr_t)io_buf, (ssize_t)io_size, 774 (offset_t)starting_off, UIO_SYSSPACE, FDSYNC, 775 RLIM64_INFINITY, CRED(), &resid); 776 777 if (vret || resid) { 778 ret = SBD_FILEIO_FAILURE | vret; 779 rw_exit(&sl->sl_access_state_lock); 780 goto sbd_write_meta_failure; 781 } 782 } 783 rw_exit(&sl->sl_access_state_lock); 784 785 ret = SBD_SUCCESS; 786 787 sbd_write_meta_failure: 788 kmem_free(io_buf, io_size); 789 return (ret); 790 } 791 792 uint8_t 793 sbd_calc_sum(uint8_t *buf, int size) 794 { 795 uint8_t s = 0; 796 797 while (size > 0) 798 s += buf[--size]; 799 800 return (s); 801 } 802 803 uint8_t 804 sbd_calc_section_sum(sm_section_hdr_t *sm, uint32_t sz) 805 { 806 uint8_t s, o; 807 808 o = sm->sms_chksum; 809 sm->sms_chksum = 0; 810 s = sbd_calc_sum((uint8_t *)sm, sz); 811 sm->sms_chksum = o; 812 813 return (s); 814 } 815 816 uint32_t 817 sbd_strlen(char *str, uint32_t maxlen) 818 { 819 uint32_t i; 820 821 for (i = 0; i < maxlen; i++) { 822 if (str[i] == 0) 823 return (i); 824 } 825 return (i); 826 } 827 828 void 829 sbd_swap_meta_start(sbd_meta_start_t *sm) 830 { 831 if (sm->sm_magic == SBD_MAGIC) 832 return; 833 sm->sm_magic = BSWAP_64(sm->sm_magic); 834 sm->sm_meta_size = BSWAP_64(sm->sm_meta_size); 835 sm->sm_meta_size_used = BSWAP_64(sm->sm_meta_size_used); 836 sm->sm_ver_major = BSWAP_16(sm->sm_ver_major); 837 sm->sm_ver_minor = BSWAP_16(sm->sm_ver_minor); 838 sm->sm_ver_subminor = BSWAP_16(sm->sm_ver_subminor); 839 } 840 841 void 842 sbd_swap_section_hdr(sm_section_hdr_t *sm) 843 { 844 if (sm->sms_data_order == SMS_DATA_ORDER) 845 return; 846 sm->sms_offset = BSWAP_64(sm->sms_offset); 847 sm->sms_size = BSWAP_32(sm->sms_size); 848 sm->sms_id = BSWAP_16(sm->sms_id); 849 sm->sms_chksum += SMS_DATA_ORDER - sm->sms_data_order; 850 sm->sms_data_order = SMS_DATA_ORDER; 851 } 852 853 void 854 sbd_swap_lu_info_1_0(sbd_lu_info_1_0_t *sli) 855 { 856 sbd_swap_section_hdr(&sli->sli_sms_header); 857 if (sli->sli_data_order == SMS_DATA_ORDER) 858 return; 859 sli->sli_sms_header.sms_chksum += SMS_DATA_ORDER - sli->sli_data_order; 860 sli->sli_data_order = SMS_DATA_ORDER; 861 sli->sli_total_store_size = BSWAP_64(sli->sli_total_store_size); 862 sli->sli_total_meta_size = BSWAP_64(sli->sli_total_meta_size); 863 sli->sli_lu_data_offset = BSWAP_64(sli->sli_lu_data_offset); 864 sli->sli_lu_data_size = BSWAP_64(sli->sli_lu_data_size); 865 sli->sli_flags = BSWAP_32(sli->sli_flags); 866 sli->sli_blocksize = BSWAP_16(sli->sli_blocksize); 867 } 868 869 void 870 sbd_swap_lu_info_1_1(sbd_lu_info_1_1_t *sli) 871 { 872 sbd_swap_section_hdr(&sli->sli_sms_header); 873 if (sli->sli_data_order == SMS_DATA_ORDER) 874 return; 875 sli->sli_sms_header.sms_chksum += SMS_DATA_ORDER - sli->sli_data_order; 876 sli->sli_data_order = SMS_DATA_ORDER; 877 sli->sli_flags = BSWAP_32(sli->sli_flags); 878 sli->sli_lu_size = BSWAP_64(sli->sli_lu_size); 879 sli->sli_meta_fname_offset = BSWAP_64(sli->sli_meta_fname_offset); 880 sli->sli_data_fname_offset = BSWAP_64(sli->sli_data_fname_offset); 881 sli->sli_serial_offset = BSWAP_64(sli->sli_serial_offset); 882 sli->sli_alias_offset = BSWAP_64(sli->sli_alias_offset); 883 sli->sli_mgmt_url_offset = BSWAP_64(sli->sli_mgmt_url_offset); 884 } 885 886 sbd_status_t 887 sbd_load_section_hdr(sbd_lu_t *sl, sm_section_hdr_t *sms) 888 { 889 sm_section_hdr_t h; 890 uint64_t st; 891 sbd_status_t ret; 892 893 for (st = sl->sl_meta_offset + sizeof (sbd_meta_start_t); 894 st < sl->sl_meta_size_used; st += h.sms_size) { 895 if ((ret = sbd_read_meta(sl, st, sizeof (sm_section_hdr_t), 896 (uint8_t *)&h)) != SBD_SUCCESS) { 897 return (ret); 898 } 899 if (h.sms_data_order != SMS_DATA_ORDER) { 900 sbd_swap_section_hdr(&h); 901 } 902 if ((h.sms_data_order != SMS_DATA_ORDER) || 903 (h.sms_offset != st) || (h.sms_size < sizeof (h)) || 904 ((st + h.sms_size) > sl->sl_meta_size_used)) { 905 return (SBD_META_CORRUPTED); 906 } 907 if (h.sms_id == sms->sms_id) { 908 bcopy(&h, sms, sizeof (h)); 909 return (SBD_SUCCESS); 910 } 911 } 912 913 return (SBD_NOT_FOUND); 914 } 915 916 sbd_status_t 917 sbd_load_meta_start(sbd_lu_t *sl) 918 { 919 sbd_meta_start_t *sm; 920 sbd_status_t ret; 921 922 /* Fake meta params initially */ 923 sl->sl_total_meta_size = (uint64_t)-1; 924 sl->sl_meta_size_used = sl->sl_meta_offset + sizeof (sbd_meta_start_t); 925 926 sm = kmem_zalloc(sizeof (*sm), KM_SLEEP); 927 ret = sbd_read_meta(sl, sl->sl_meta_offset, sizeof (*sm), 928 (uint8_t *)sm); 929 if (ret != SBD_SUCCESS) { 930 goto load_meta_start_failed; 931 } 932 933 if (sm->sm_magic != SBD_MAGIC) { 934 sbd_swap_meta_start(sm); 935 } 936 937 if ((sm->sm_magic != SBD_MAGIC) || (sbd_calc_sum((uint8_t *)sm, 938 sizeof (*sm) - 1) != sm->sm_chksum)) { 939 ret = SBD_META_CORRUPTED; 940 goto load_meta_start_failed; 941 } 942 943 if (sm->sm_ver_major != SBD_VER_MAJOR) { 944 ret = SBD_NOT_SUPPORTED; 945 goto load_meta_start_failed; 946 } 947 948 sl->sl_total_meta_size = sm->sm_meta_size; 949 sl->sl_meta_size_used = sm->sm_meta_size_used; 950 ret = SBD_SUCCESS; 951 952 load_meta_start_failed: 953 kmem_free(sm, sizeof (*sm)); 954 return (ret); 955 } 956 957 sbd_status_t 958 sbd_write_meta_start(sbd_lu_t *sl, uint64_t meta_size, uint64_t meta_size_used) 959 { 960 sbd_meta_start_t *sm; 961 sbd_status_t ret; 962 963 sm = (sbd_meta_start_t *)kmem_zalloc(sizeof (sbd_meta_start_t), 964 KM_SLEEP); 965 966 sm->sm_magic = SBD_MAGIC; 967 sm->sm_meta_size = meta_size; 968 sm->sm_meta_size_used = meta_size_used; 969 sm->sm_ver_major = SBD_VER_MAJOR; 970 sm->sm_ver_minor = SBD_VER_MINOR; 971 sm->sm_ver_subminor = SBD_VER_SUBMINOR; 972 sm->sm_chksum = sbd_calc_sum((uint8_t *)sm, sizeof (*sm) - 1); 973 974 ret = sbd_write_meta(sl, sl->sl_meta_offset, sizeof (*sm), 975 (uint8_t *)sm); 976 kmem_free(sm, sizeof (*sm)); 977 978 return (ret); 979 } 980 981 sbd_status_t 982 sbd_read_meta_section(sbd_lu_t *sl, sm_section_hdr_t **ppsms, uint16_t sms_id) 983 { 984 sbd_status_t ret; 985 sm_section_hdr_t sms; 986 int alloced = 0; 987 988 mutex_enter(&sl->sl_metadata_lock); 989 if (((*ppsms) == NULL) || ((*ppsms)->sms_offset == 0)) { 990 bzero(&sms, sizeof (sm_section_hdr_t)); 991 sms.sms_id = sms_id; 992 if ((ret = sbd_load_section_hdr(sl, &sms)) != SBD_SUCCESS) { 993 mutex_exit(&sl->sl_metadata_lock); 994 return (ret); 995 } else { 996 if ((*ppsms) == NULL) { 997 *ppsms = (sm_section_hdr_t *)kmem_zalloc( 998 sms.sms_size, KM_SLEEP); 999 alloced = 1; 1000 } 1001 bcopy(&sms, *ppsms, sizeof (sm_section_hdr_t)); 1002 } 1003 } 1004 1005 ret = sbd_read_meta(sl, (*ppsms)->sms_offset, (*ppsms)->sms_size, 1006 (uint8_t *)(*ppsms)); 1007 if (ret == SBD_SUCCESS) { 1008 uint8_t s; 1009 if ((*ppsms)->sms_data_order != SMS_DATA_ORDER) 1010 sbd_swap_section_hdr(*ppsms); 1011 if ((*ppsms)->sms_id != SMS_ID_UNUSED) { 1012 s = sbd_calc_section_sum(*ppsms, (*ppsms)->sms_size); 1013 if (s != (*ppsms)->sms_chksum) 1014 ret = SBD_META_CORRUPTED; 1015 } 1016 } 1017 mutex_exit(&sl->sl_metadata_lock); 1018 1019 if ((ret != SBD_SUCCESS) && alloced) 1020 kmem_free(*ppsms, sms.sms_size); 1021 return (ret); 1022 } 1023 1024 sbd_status_t 1025 sbd_load_section_hdr_unbuffered(sbd_lu_t *sl, sm_section_hdr_t *sms) 1026 { 1027 sbd_status_t ret; 1028 1029 /* 1030 * Bypass buffering and re-read the meta data from permanent storage. 1031 */ 1032 if (sl->sl_flags & SL_ZFS_META) { 1033 if ((ret = sbd_open_zfs_meta(sl)) != SBD_SUCCESS) { 1034 return (ret); 1035 } 1036 } 1037 /* Re-get the meta sizes into sl */ 1038 if ((ret = sbd_load_meta_start(sl)) != SBD_SUCCESS) { 1039 return (ret); 1040 } 1041 return (sbd_load_section_hdr(sl, sms)); 1042 } 1043 1044 sbd_status_t 1045 sbd_write_meta_section(sbd_lu_t *sl, sm_section_hdr_t *sms) 1046 { 1047 sm_section_hdr_t t; 1048 uint64_t off, s; 1049 uint64_t unused_start; 1050 sbd_status_t ret; 1051 sbd_status_t write_meta_ret = SBD_SUCCESS; 1052 uint8_t *cb; 1053 int meta_size_changed = 0; 1054 sm_section_hdr_t sms_before_unused = {0}; 1055 1056 mutex_enter(&sl->sl_metadata_lock); 1057 write_meta_section_again: 1058 if (sms->sms_offset) { 1059 /* 1060 * If the section already exists and the size is the 1061 * same as this new data then overwrite in place. If 1062 * the sizes are different then mark the existing as 1063 * unused and look for free space. 1064 */ 1065 ret = sbd_read_meta(sl, sms->sms_offset, sizeof (t), 1066 (uint8_t *)&t); 1067 if (ret != SBD_SUCCESS) { 1068 mutex_exit(&sl->sl_metadata_lock); 1069 return (ret); 1070 } 1071 if (t.sms_data_order != SMS_DATA_ORDER) { 1072 sbd_swap_section_hdr(&t); 1073 } 1074 if (t.sms_id != sms->sms_id) { 1075 mutex_exit(&sl->sl_metadata_lock); 1076 return (SBD_INVALID_ARG); 1077 } 1078 if (t.sms_size == sms->sms_size) { 1079 ret = sbd_write_meta(sl, sms->sms_offset, 1080 sms->sms_size, (uint8_t *)sms); 1081 mutex_exit(&sl->sl_metadata_lock); 1082 return (ret); 1083 } 1084 sms_before_unused = t; 1085 1086 t.sms_id = SMS_ID_UNUSED; 1087 /* 1088 * For unused sections we only use chksum of the header. for 1089 * all other sections, the chksum is for the entire section. 1090 */ 1091 t.sms_chksum = sbd_calc_section_sum(&t, sizeof (t)); 1092 ret = sbd_write_meta(sl, t.sms_offset, sizeof (t), 1093 (uint8_t *)&t); 1094 if (ret != SBD_SUCCESS) { 1095 mutex_exit(&sl->sl_metadata_lock); 1096 return (ret); 1097 } 1098 sms->sms_offset = 0; 1099 } else { 1100 /* Section location is unknown, search for it. */ 1101 t.sms_id = sms->sms_id; 1102 t.sms_data_order = SMS_DATA_ORDER; 1103 ret = sbd_load_section_hdr(sl, &t); 1104 if (ret == SBD_SUCCESS) { 1105 sms->sms_offset = t.sms_offset; 1106 sms->sms_chksum = 1107 sbd_calc_section_sum(sms, sms->sms_size); 1108 goto write_meta_section_again; 1109 } else if (ret != SBD_NOT_FOUND) { 1110 mutex_exit(&sl->sl_metadata_lock); 1111 return (ret); 1112 } 1113 } 1114 1115 /* 1116 * At this point we know that section does not already exist. 1117 * Find space large enough to hold the section or grow meta if 1118 * possible. 1119 */ 1120 unused_start = 0; 1121 s = 0; /* size of space found */ 1122 1123 /* 1124 * Search all sections for unused space of sufficient size. 1125 * The first one found is taken. Contiguous unused sections 1126 * will be combined. 1127 */ 1128 for (off = sl->sl_meta_offset + sizeof (sbd_meta_start_t); 1129 off < sl->sl_meta_size_used; off += t.sms_size) { 1130 ret = sbd_read_meta(sl, off, sizeof (t), (uint8_t *)&t); 1131 if (ret != SBD_SUCCESS) { 1132 mutex_exit(&sl->sl_metadata_lock); 1133 return (ret); 1134 } 1135 if (t.sms_data_order != SMS_DATA_ORDER) 1136 sbd_swap_section_hdr(&t); 1137 if (t.sms_size == 0) { 1138 mutex_exit(&sl->sl_metadata_lock); 1139 return (SBD_META_CORRUPTED); 1140 } 1141 if (t.sms_id == SMS_ID_UNUSED) { 1142 if (unused_start == 0) 1143 unused_start = off; 1144 /* 1145 * Calculate size of the unused space, break out 1146 * if it satisfies the requirement. 1147 */ 1148 s = t.sms_size - unused_start + off; 1149 if ((s == sms->sms_size) || (s >= (sms->sms_size + 1150 sizeof (t)))) { 1151 break; 1152 } else { 1153 s = 0; 1154 } 1155 } else { 1156 unused_start = 0; 1157 } 1158 } 1159 1160 off = (unused_start == 0) ? sl->sl_meta_size_used : unused_start; 1161 /* 1162 * If none found, how much room is at the end? 1163 * See if the data can be expanded. 1164 */ 1165 if (s == 0) { 1166 s = sl->sl_total_meta_size - off; 1167 if (s >= sms->sms_size || !(sl->sl_flags & SL_SHARED_META)) { 1168 s = sms->sms_size; 1169 meta_size_changed = 1; 1170 } else { 1171 s = 0; 1172 } 1173 } 1174 1175 if (s == 0) { 1176 mutex_exit(&sl->sl_metadata_lock); 1177 return (SBD_ALLOC_FAILURE); 1178 } 1179 1180 sms->sms_offset = off; 1181 sms->sms_chksum = sbd_calc_section_sum(sms, sms->sms_size); 1182 /* 1183 * Since we may have to write more than one section (current + 1184 * any unused), use a combined buffer. 1185 */ 1186 cb = kmem_zalloc(s, KM_SLEEP); 1187 bcopy(sms, cb, sms->sms_size); 1188 if (s > sms->sms_size) { 1189 t.sms_offset = off + sms->sms_size; 1190 t.sms_size = s - sms->sms_size; 1191 t.sms_id = SMS_ID_UNUSED; 1192 t.sms_data_order = SMS_DATA_ORDER; 1193 t.sms_chksum = sbd_calc_section_sum(&t, sizeof (t)); 1194 bcopy(&t, cb + sms->sms_size, sizeof (t)); 1195 } 1196 /* 1197 * Two write events & statuses take place. Failure writing the 1198 * meta section takes precedence, can possibly be rolled back, 1199 * & gets reported. Else return status from writing the meta start. 1200 */ 1201 ret = SBD_SUCCESS; /* Set a default, it's not always loaded below. */ 1202 if (meta_size_changed) { 1203 uint64_t old_meta_size; 1204 uint64_t old_sz_used = sl->sl_meta_size_used; /* save a copy */ 1205 old_meta_size = sl->sl_total_meta_size; /* save a copy */ 1206 1207 write_meta_ret = sbd_write_meta(sl, off, s, cb); 1208 if (write_meta_ret == SBD_SUCCESS) { 1209 sl->sl_meta_size_used = off + s; 1210 if (sl->sl_total_meta_size < sl->sl_meta_size_used) { 1211 uint64_t meta_align = 1212 (((uint64_t)1) << 1213 sl->sl_meta_blocksize_shift) - 1; 1214 sl->sl_total_meta_size = 1215 (sl->sl_meta_size_used + meta_align) & 1216 (~meta_align); 1217 } 1218 ret = sbd_write_meta_start(sl, sl->sl_total_meta_size, 1219 sl->sl_meta_size_used); 1220 if (ret != SBD_SUCCESS) { 1221 sl->sl_meta_size_used = old_sz_used; 1222 sl->sl_total_meta_size = old_meta_size; 1223 } 1224 } else { 1225 sl->sl_meta_size_used = old_sz_used; 1226 sl->sl_total_meta_size = old_meta_size; 1227 } 1228 } else { 1229 write_meta_ret = sbd_write_meta(sl, off, s, cb); 1230 } 1231 if ((write_meta_ret != SBD_SUCCESS) && 1232 (sms_before_unused.sms_offset != 0)) { 1233 sm_section_hdr_t new_sms; 1234 sm_section_hdr_t *unused_sms; 1235 /* 1236 * On failure writing the meta section attempt to undo 1237 * the change to unused. 1238 * Re-read the meta data from permanent storage. 1239 * The section id can't exist for undo to be possible. 1240 * Read what should be the entire old section data and 1241 * insure the old data's still present by validating 1242 * against it's old checksum. 1243 */ 1244 new_sms.sms_id = sms->sms_id; 1245 new_sms.sms_data_order = SMS_DATA_ORDER; 1246 if (sbd_load_section_hdr_unbuffered(sl, &new_sms) != 1247 SBD_NOT_FOUND) { 1248 goto done; 1249 } 1250 unused_sms = kmem_zalloc(sms_before_unused.sms_size, KM_SLEEP); 1251 if (sbd_read_meta(sl, sms_before_unused.sms_offset, 1252 sms_before_unused.sms_size, 1253 (uint8_t *)unused_sms) != SBD_SUCCESS) { 1254 goto done; 1255 } 1256 if (unused_sms->sms_data_order != SMS_DATA_ORDER) { 1257 sbd_swap_section_hdr(unused_sms); 1258 } 1259 if (unused_sms->sms_id != SMS_ID_UNUSED) { 1260 goto done; 1261 } 1262 if (unused_sms->sms_offset != sms_before_unused.sms_offset) { 1263 goto done; 1264 } 1265 if (unused_sms->sms_size != sms_before_unused.sms_size) { 1266 goto done; 1267 } 1268 unused_sms->sms_id = sms_before_unused.sms_id; 1269 if (sbd_calc_section_sum(unused_sms, 1270 sizeof (sm_section_hdr_t)) != 1271 sbd_calc_section_sum(&sms_before_unused, 1272 sizeof (sm_section_hdr_t))) { 1273 goto done; 1274 } 1275 unused_sms->sms_chksum = 1276 sbd_calc_section_sum(unused_sms, unused_sms->sms_size); 1277 if (unused_sms->sms_chksum != sms_before_unused.sms_chksum) { 1278 goto done; 1279 } 1280 (void) sbd_write_meta(sl, unused_sms->sms_offset, 1281 sizeof (sm_section_hdr_t), (uint8_t *)unused_sms); 1282 } 1283 done: 1284 mutex_exit(&sl->sl_metadata_lock); 1285 kmem_free(cb, s); 1286 if (write_meta_ret != SBD_SUCCESS) { 1287 return (write_meta_ret); 1288 } 1289 return (ret); 1290 } 1291 1292 sbd_status_t 1293 sbd_write_lu_info(sbd_lu_t *sl) 1294 { 1295 sbd_lu_info_1_1_t *sli; 1296 int s; 1297 uint8_t *p; 1298 char *zvol_name = NULL; 1299 sbd_status_t ret; 1300 1301 mutex_enter(&sl->sl_lock); 1302 1303 s = sl->sl_serial_no_size; 1304 if ((sl->sl_flags & (SL_SHARED_META | SL_ZFS_META)) == 0) { 1305 if (sl->sl_data_filename) { 1306 s += strlen(sl->sl_data_filename) + 1; 1307 } 1308 } 1309 if (sl->sl_flags & SL_ZFS_META) { 1310 zvol_name = sbd_get_zvol_name(sl); 1311 s += strlen(zvol_name) + 1; 1312 } 1313 if (sl->sl_alias) { 1314 s += strlen(sl->sl_alias) + 1; 1315 } 1316 if (sl->sl_mgmt_url) { 1317 s += strlen(sl->sl_mgmt_url) + 1; 1318 } 1319 sli = (sbd_lu_info_1_1_t *)kmem_zalloc(sizeof (*sli) + s, KM_SLEEP); 1320 p = sli->sli_buf; 1321 if ((sl->sl_flags & (SL_SHARED_META | SL_ZFS_META)) == 0) { 1322 sli->sli_flags |= SLI_SEPARATE_META; 1323 (void) strcpy((char *)p, sl->sl_data_filename); 1324 sli->sli_data_fname_offset = 1325 (uintptr_t)p - (uintptr_t)sli->sli_buf; 1326 sli->sli_flags |= SLI_DATA_FNAME_VALID; 1327 p += strlen(sl->sl_data_filename) + 1; 1328 } 1329 if (sl->sl_flags & SL_ZFS_META) { 1330 (void) strcpy((char *)p, zvol_name); 1331 sli->sli_meta_fname_offset = 1332 (uintptr_t)p - (uintptr_t)sli->sli_buf; 1333 sli->sli_flags |= SLI_META_FNAME_VALID | SLI_ZFS_META; 1334 p += strlen(zvol_name) + 1; 1335 kmem_free(zvol_name, strlen(zvol_name) + 1); 1336 zvol_name = NULL; 1337 } 1338 if (sl->sl_alias) { 1339 (void) strcpy((char *)p, sl->sl_alias); 1340 sli->sli_alias_offset = 1341 (uintptr_t)p - (uintptr_t)sli->sli_buf; 1342 sli->sli_flags |= SLI_ALIAS_VALID; 1343 p += strlen(sl->sl_alias) + 1; 1344 } 1345 if (sl->sl_mgmt_url) { 1346 (void) strcpy((char *)p, sl->sl_mgmt_url); 1347 sli->sli_mgmt_url_offset = 1348 (uintptr_t)p - (uintptr_t)sli->sli_buf; 1349 sli->sli_flags |= SLI_MGMT_URL_VALID; 1350 p += strlen(sl->sl_mgmt_url) + 1; 1351 } 1352 if (sl->sl_flags & SL_WRITE_PROTECTED) { 1353 sli->sli_flags |= SLI_WRITE_PROTECTED; 1354 } 1355 if (sl->sl_flags & SL_SAVED_WRITE_CACHE_DISABLE) { 1356 sli->sli_flags |= SLI_WRITEBACK_CACHE_DISABLE; 1357 } 1358 if (sl->sl_flags & SL_VID_VALID) { 1359 bcopy(sl->sl_vendor_id, sli->sli_vid, 8); 1360 sli->sli_flags |= SLI_VID_VALID; 1361 } 1362 if (sl->sl_flags & SL_PID_VALID) { 1363 bcopy(sl->sl_product_id, sli->sli_pid, 16); 1364 sli->sli_flags |= SLI_PID_VALID; 1365 } 1366 if (sl->sl_flags & SL_REV_VALID) { 1367 bcopy(sl->sl_revision, sli->sli_rev, 4); 1368 sli->sli_flags |= SLI_REV_VALID; 1369 } 1370 if (sl->sl_serial_no_size) { 1371 bcopy(sl->sl_serial_no, p, sl->sl_serial_no_size); 1372 sli->sli_serial_size = sl->sl_serial_no_size; 1373 sli->sli_serial_offset = 1374 (uintptr_t)p - (uintptr_t)sli->sli_buf; 1375 sli->sli_flags |= SLI_SERIAL_VALID; 1376 p += sli->sli_serial_size; 1377 } 1378 sli->sli_lu_size = sl->sl_lu_size; 1379 sli->sli_data_blocksize_shift = sl->sl_data_blocksize_shift; 1380 sli->sli_data_order = SMS_DATA_ORDER; 1381 bcopy(sl->sl_device_id, sli->sli_device_id, 20); 1382 1383 sli->sli_sms_header.sms_size = sizeof (*sli) + s; 1384 sli->sli_sms_header.sms_id = SMS_ID_LU_INFO_1_1; 1385 sli->sli_sms_header.sms_data_order = SMS_DATA_ORDER; 1386 1387 mutex_exit(&sl->sl_lock); 1388 ret = sbd_write_meta_section(sl, (sm_section_hdr_t *)sli); 1389 kmem_free(sli, sizeof (*sli) + s); 1390 return (ret); 1391 } 1392 1393 /* 1394 * Will scribble SL_UNMAP_ENABLED into sl_flags if we succeed. 1395 */ 1396 static void 1397 do_unmap_setup(sbd_lu_t *sl) 1398 { 1399 ASSERT((sl->sl_flags & SL_UNMAP_ENABLED) == 0); 1400 1401 if ((sl->sl_flags & SL_ZFS_META) == 0) 1402 return; /* No UNMAP for you. */ 1403 1404 sl->sl_flags |= SL_UNMAP_ENABLED; 1405 } 1406 1407 int 1408 sbd_populate_and_register_lu(sbd_lu_t *sl, uint32_t *err_ret) 1409 { 1410 stmf_lu_t *lu = sl->sl_lu; 1411 stmf_status_t ret; 1412 1413 do_unmap_setup(sl); 1414 1415 lu->lu_id = (scsi_devid_desc_t *)sl->sl_device_id; 1416 if (sl->sl_alias) { 1417 lu->lu_alias = sl->sl_alias; 1418 } else { 1419 lu->lu_alias = sl->sl_name; 1420 } 1421 if (sl->sl_access_state == SBD_LU_STANDBY) { 1422 /* call set access state */ 1423 ret = stmf_set_lu_access(lu, STMF_LU_STANDBY); 1424 if (ret != STMF_SUCCESS) { 1425 *err_ret = SBD_RET_ACCESS_STATE_FAILED; 1426 return (EIO); 1427 } 1428 } 1429 /* set proxy_reg_cb_arg to meta filename */ 1430 if (sl->sl_meta_filename) { 1431 lu->lu_proxy_reg_arg = sl->sl_meta_filename; 1432 lu->lu_proxy_reg_arg_len = strlen(sl->sl_meta_filename) + 1; 1433 } else { 1434 lu->lu_proxy_reg_arg = sl->sl_data_filename; 1435 lu->lu_proxy_reg_arg_len = strlen(sl->sl_data_filename) + 1; 1436 } 1437 lu->lu_lp = sbd_lp; 1438 lu->lu_task_alloc = sbd_task_alloc; 1439 lu->lu_new_task = sbd_new_task; 1440 lu->lu_dbuf_xfer_done = sbd_dbuf_xfer_done; 1441 lu->lu_send_status_done = sbd_send_status_done; 1442 lu->lu_task_free = sbd_task_free; 1443 lu->lu_abort = sbd_abort; 1444 lu->lu_dbuf_free = sbd_dbuf_free; 1445 lu->lu_ctl = sbd_ctl; 1446 lu->lu_info = sbd_info; 1447 sl->sl_state = STMF_STATE_OFFLINE; 1448 1449 if ((ret = stmf_register_lu(lu)) != STMF_SUCCESS) { 1450 stmf_trace(0, "Failed to register with framework, ret=%llx", 1451 ret); 1452 if (ret == STMF_ALREADY) { 1453 *err_ret = SBD_RET_GUID_ALREADY_REGISTERED; 1454 } 1455 return (EIO); 1456 } 1457 1458 *err_ret = 0; 1459 return (0); 1460 } 1461 1462 int 1463 sbd_open_data_file(sbd_lu_t *sl, uint32_t *err_ret, int lu_size_valid, 1464 int vp_valid, int keep_open) 1465 { 1466 int ret; 1467 int flag; 1468 ulong_t nbits; 1469 uint64_t supported_size; 1470 vattr_t vattr; 1471 enum vtype vt; 1472 struct dk_cinfo dki; 1473 int unused; 1474 1475 mutex_enter(&sl->sl_lock); 1476 if (vp_valid) { 1477 goto odf_over_open; 1478 } 1479 if (sl->sl_data_filename[0] != '/') { 1480 *err_ret = SBD_RET_DATA_PATH_NOT_ABSOLUTE; 1481 mutex_exit(&sl->sl_lock); 1482 return (EINVAL); 1483 } 1484 if ((ret = lookupname(sl->sl_data_filename, UIO_SYSSPACE, FOLLOW, 1485 NULLVPP, &sl->sl_data_vp)) != 0) { 1486 *err_ret = SBD_RET_DATA_FILE_LOOKUP_FAILED; 1487 mutex_exit(&sl->sl_lock); 1488 return (ret); 1489 } 1490 sl->sl_data_vtype = vt = sl->sl_data_vp->v_type; 1491 VN_RELE(sl->sl_data_vp); 1492 if ((vt != VREG) && (vt != VCHR) && (vt != VBLK)) { 1493 *err_ret = SBD_RET_WRONG_DATA_FILE_TYPE; 1494 mutex_exit(&sl->sl_lock); 1495 return (EINVAL); 1496 } 1497 if (sl->sl_flags & SL_WRITE_PROTECTED) { 1498 flag = FREAD | FOFFMAX; 1499 } else { 1500 flag = FREAD | FWRITE | FOFFMAX | FEXCL; 1501 } 1502 if ((ret = vn_open(sl->sl_data_filename, UIO_SYSSPACE, flag, 0, 1503 &sl->sl_data_vp, 0, 0)) != 0) { 1504 *err_ret = SBD_RET_DATA_FILE_OPEN_FAILED; 1505 mutex_exit(&sl->sl_lock); 1506 return (ret); 1507 } 1508 odf_over_open: 1509 vattr.va_mask = AT_SIZE; 1510 if ((ret = VOP_GETATTR(sl->sl_data_vp, &vattr, 0, CRED(), NULL)) != 0) { 1511 *err_ret = SBD_RET_DATA_FILE_GETATTR_FAILED; 1512 goto odf_close_data_and_exit; 1513 } 1514 if ((vt != VREG) && (vattr.va_size == 0)) { 1515 /* 1516 * Its a zero byte block or char device. This cannot be 1517 * a raw disk. 1518 */ 1519 *err_ret = SBD_RET_WRONG_DATA_FILE_TYPE; 1520 ret = EINVAL; 1521 goto odf_close_data_and_exit; 1522 } 1523 /* sl_data_readable size includes any metadata. */ 1524 sl->sl_data_readable_size = vattr.va_size; 1525 1526 if (VOP_PATHCONF(sl->sl_data_vp, _PC_FILESIZEBITS, &nbits, 1527 CRED(), NULL) != 0) { 1528 nbits = 0; 1529 } 1530 /* nbits cannot be greater than 64 */ 1531 sl->sl_data_fs_nbits = (uint8_t)nbits; 1532 if (lu_size_valid) { 1533 sl->sl_total_data_size = sl->sl_lu_size; 1534 if (sl->sl_flags & SL_SHARED_META) { 1535 sl->sl_total_data_size += SHARED_META_DATA_SIZE; 1536 } 1537 if ((nbits > 0) && (nbits < 64)) { 1538 /* 1539 * The expression below is correct only if nbits is 1540 * positive and less than 64. 1541 */ 1542 supported_size = (((uint64_t)1) << nbits) - 1; 1543 if (sl->sl_total_data_size > supported_size) { 1544 *err_ret = SBD_RET_SIZE_NOT_SUPPORTED_BY_FS; 1545 ret = EINVAL; 1546 goto odf_close_data_and_exit; 1547 } 1548 } 1549 } else { 1550 sl->sl_total_data_size = vattr.va_size; 1551 if (sl->sl_flags & SL_SHARED_META) { 1552 if (vattr.va_size > SHARED_META_DATA_SIZE) { 1553 sl->sl_lu_size = vattr.va_size - 1554 SHARED_META_DATA_SIZE; 1555 } else { 1556 *err_ret = SBD_RET_FILE_SIZE_ERROR; 1557 ret = EINVAL; 1558 goto odf_close_data_and_exit; 1559 } 1560 } else { 1561 sl->sl_lu_size = vattr.va_size; 1562 } 1563 } 1564 if (sl->sl_lu_size < SBD_MIN_LU_SIZE) { 1565 *err_ret = SBD_RET_FILE_SIZE_ERROR; 1566 ret = EINVAL; 1567 goto odf_close_data_and_exit; 1568 } 1569 if (sl->sl_lu_size & 1570 ((((uint64_t)1) << sl->sl_data_blocksize_shift) - 1)) { 1571 *err_ret = SBD_RET_FILE_ALIGN_ERROR; 1572 ret = EINVAL; 1573 goto odf_close_data_and_exit; 1574 } 1575 /* 1576 * Get the minor device for direct zvol access 1577 */ 1578 if (sl->sl_flags & SL_ZFS_META) { 1579 if ((ret = VOP_IOCTL(sl->sl_data_vp, DKIOCINFO, (intptr_t)&dki, 1580 FKIOCTL, kcred, &unused, NULL)) != 0) { 1581 cmn_err(CE_WARN, "ioctl(DKIOCINFO) failed %d", ret); 1582 /* zvol reserves 0, so this would fail later */ 1583 sl->sl_zvol_minor = 0; 1584 } else { 1585 sl->sl_zvol_minor = dki.dki_unit; 1586 if (sbd_zvol_get_volume_params(sl) == 0) 1587 sl->sl_flags |= SL_CALL_ZVOL; 1588 } 1589 } 1590 sl->sl_flags |= SL_MEDIA_LOADED; 1591 mutex_exit(&sl->sl_lock); 1592 return (0); 1593 1594 odf_close_data_and_exit: 1595 if (!keep_open) { 1596 (void) VOP_CLOSE(sl->sl_data_vp, flag, 1, 0, CRED(), NULL); 1597 VN_RELE(sl->sl_data_vp); 1598 } 1599 mutex_exit(&sl->sl_lock); 1600 return (ret); 1601 } 1602 1603 void 1604 sbd_close_lu(sbd_lu_t *sl) 1605 { 1606 int flag; 1607 1608 if (((sl->sl_flags & SL_SHARED_META) == 0) && 1609 (sl->sl_flags & SL_META_OPENED)) { 1610 if (sl->sl_flags & SL_ZFS_META) { 1611 rw_destroy(&sl->sl_zfs_meta_lock); 1612 if (sl->sl_zfs_meta) { 1613 kmem_free(sl->sl_zfs_meta, ZAP_MAXVALUELEN / 2); 1614 sl->sl_zfs_meta = NULL; 1615 } 1616 } else { 1617 flag = FREAD | FWRITE | FOFFMAX | FEXCL; 1618 (void) VOP_CLOSE(sl->sl_meta_vp, flag, 1, 0, 1619 CRED(), NULL); 1620 VN_RELE(sl->sl_meta_vp); 1621 } 1622 sl->sl_flags &= ~SL_META_OPENED; 1623 } 1624 if (sl->sl_flags & SL_MEDIA_LOADED) { 1625 if (sl->sl_flags & SL_WRITE_PROTECTED) { 1626 flag = FREAD | FOFFMAX; 1627 } else { 1628 flag = FREAD | FWRITE | FOFFMAX | FEXCL; 1629 } 1630 (void) VOP_CLOSE(sl->sl_data_vp, flag, 1, 0, CRED(), NULL); 1631 VN_RELE(sl->sl_data_vp); 1632 sl->sl_flags &= ~SL_MEDIA_LOADED; 1633 if (sl->sl_flags & SL_SHARED_META) { 1634 sl->sl_flags &= ~SL_META_OPENED; 1635 } 1636 } 1637 } 1638 1639 int 1640 sbd_set_lu_standby(sbd_set_lu_standby_t *stlu, uint32_t *err_ret) 1641 { 1642 sbd_lu_t *sl; 1643 sbd_status_t sret; 1644 stmf_status_t stret; 1645 uint8_t old_access_state; 1646 1647 sret = sbd_find_and_lock_lu(stlu->stlu_guid, NULL, 1648 SL_OP_MODIFY_LU, &sl); 1649 if (sret != SBD_SUCCESS) { 1650 if (sret == SBD_BUSY) { 1651 *err_ret = SBD_RET_LU_BUSY; 1652 return (EBUSY); 1653 } else if (sret == SBD_NOT_FOUND) { 1654 *err_ret = SBD_RET_NOT_FOUND; 1655 return (ENOENT); 1656 } 1657 *err_ret = SBD_RET_ACCESS_STATE_FAILED; 1658 return (EIO); 1659 } 1660 1661 old_access_state = sl->sl_access_state; 1662 sl->sl_access_state = SBD_LU_TRANSITION_TO_STANDBY; 1663 stret = stmf_set_lu_access((stmf_lu_t *)sl->sl_lu, STMF_LU_STANDBY); 1664 if (stret != STMF_SUCCESS) { 1665 sl->sl_trans_op = SL_OP_NONE; 1666 *err_ret = SBD_RET_ACCESS_STATE_FAILED; 1667 sl->sl_access_state = old_access_state; 1668 return (EIO); 1669 } 1670 1671 /* 1672 * acquire the writer lock here to ensure we're not pulling 1673 * the rug from the vn_rdwr to the backing store 1674 */ 1675 rw_enter(&sl->sl_access_state_lock, RW_WRITER); 1676 sbd_close_lu(sl); 1677 rw_exit(&sl->sl_access_state_lock); 1678 1679 sl->sl_trans_op = SL_OP_NONE; 1680 return (0); 1681 } 1682 1683 int 1684 sbd_close_delete_lu(sbd_lu_t *sl, int ret) 1685 { 1686 1687 /* 1688 * acquire the writer lock here to ensure we're not pulling 1689 * the rug from the vn_rdwr to the backing store 1690 */ 1691 rw_enter(&sl->sl_access_state_lock, RW_WRITER); 1692 sbd_close_lu(sl); 1693 rw_exit(&sl->sl_access_state_lock); 1694 1695 if (sl->sl_flags & SL_LINKED) 1696 sbd_unlink_lu(sl); 1697 mutex_destroy(&sl->sl_metadata_lock); 1698 mutex_destroy(&sl->sl_lock); 1699 rw_destroy(&sl->sl_pgr->pgr_lock); 1700 rw_destroy(&sl->sl_access_state_lock); 1701 if (sl->sl_serial_no_alloc_size) { 1702 kmem_free(sl->sl_serial_no, sl->sl_serial_no_alloc_size); 1703 } 1704 if (sl->sl_data_fname_alloc_size) { 1705 kmem_free(sl->sl_data_filename, sl->sl_data_fname_alloc_size); 1706 } 1707 if (sl->sl_alias_alloc_size) { 1708 kmem_free(sl->sl_alias, sl->sl_alias_alloc_size); 1709 } 1710 if (sl->sl_mgmt_url_alloc_size) { 1711 kmem_free(sl->sl_mgmt_url, sl->sl_mgmt_url_alloc_size); 1712 } 1713 stmf_free(sl->sl_lu); 1714 return (ret); 1715 } 1716 1717 int 1718 sbd_create_register_lu(sbd_create_and_reg_lu_t *slu, int struct_sz, 1719 uint32_t *err_ret) 1720 { 1721 char *namebuf; 1722 sbd_lu_t *sl; 1723 stmf_lu_t *lu; 1724 char *p; 1725 int sz; 1726 int alloc_sz; 1727 int ret = EIO; 1728 int flag; 1729 int wcd = 0; 1730 uint32_t hid = 0; 1731 enum vtype vt; 1732 1733 sz = struct_sz - sizeof (sbd_create_and_reg_lu_t) + 8 + 1; 1734 1735 *err_ret = 0; 1736 1737 /* Lets validate various offsets */ 1738 if (((slu->slu_meta_fname_valid) && 1739 (slu->slu_meta_fname_off >= sz)) || 1740 (slu->slu_data_fname_off >= sz) || 1741 ((slu->slu_alias_valid) && 1742 (slu->slu_alias_off >= sz)) || 1743 ((slu->slu_mgmt_url_valid) && 1744 (slu->slu_mgmt_url_off >= sz)) || 1745 ((slu->slu_serial_valid) && 1746 ((slu->slu_serial_off + slu->slu_serial_size) >= sz))) { 1747 return (EINVAL); 1748 } 1749 1750 namebuf = kmem_zalloc(sz, KM_SLEEP); 1751 bcopy(slu->slu_buf, namebuf, sz - 1); 1752 namebuf[sz - 1] = 0; 1753 1754 alloc_sz = sizeof (sbd_lu_t) + sizeof (sbd_pgr_t); 1755 if (slu->slu_meta_fname_valid) { 1756 alloc_sz += strlen(namebuf + slu->slu_meta_fname_off) + 1; 1757 } 1758 alloc_sz += strlen(namebuf + slu->slu_data_fname_off) + 1; 1759 if (slu->slu_alias_valid) { 1760 alloc_sz += strlen(namebuf + slu->slu_alias_off) + 1; 1761 } 1762 if (slu->slu_mgmt_url_valid) { 1763 alloc_sz += strlen(namebuf + slu->slu_mgmt_url_off) + 1; 1764 } 1765 if (slu->slu_serial_valid) { 1766 alloc_sz += slu->slu_serial_size; 1767 } 1768 1769 lu = (stmf_lu_t *)stmf_alloc(STMF_STRUCT_STMF_LU, alloc_sz, 0); 1770 if (lu == NULL) { 1771 kmem_free(namebuf, sz); 1772 return (ENOMEM); 1773 } 1774 sl = (sbd_lu_t *)lu->lu_provider_private; 1775 bzero(sl, alloc_sz); 1776 sl->sl_lu = lu; 1777 sl->sl_alloc_size = alloc_sz; 1778 sl->sl_pgr = (sbd_pgr_t *)(sl + 1); 1779 rw_init(&sl->sl_pgr->pgr_lock, NULL, RW_DRIVER, NULL); 1780 mutex_init(&sl->sl_lock, NULL, MUTEX_DRIVER, NULL); 1781 mutex_init(&sl->sl_metadata_lock, NULL, MUTEX_DRIVER, NULL); 1782 rw_init(&sl->sl_access_state_lock, NULL, RW_DRIVER, NULL); 1783 p = ((char *)sl) + sizeof (sbd_lu_t) + sizeof (sbd_pgr_t); 1784 sl->sl_data_filename = p; 1785 (void) strcpy(sl->sl_data_filename, namebuf + slu->slu_data_fname_off); 1786 p += strlen(sl->sl_data_filename) + 1; 1787 sl->sl_meta_offset = SBD_META_OFFSET; 1788 sl->sl_access_state = SBD_LU_ACTIVE; 1789 if (slu->slu_meta_fname_valid) { 1790 sl->sl_alias = sl->sl_name = sl->sl_meta_filename = p; 1791 (void) strcpy(sl->sl_meta_filename, namebuf + 1792 slu->slu_meta_fname_off); 1793 p += strlen(sl->sl_meta_filename) + 1; 1794 } else { 1795 sl->sl_alias = sl->sl_name = sl->sl_data_filename; 1796 if (sbd_is_zvol(sl->sl_data_filename)) { 1797 sl->sl_flags |= SL_ZFS_META; 1798 sl->sl_meta_offset = 0; 1799 } else { 1800 sl->sl_flags |= SL_SHARED_META; 1801 sl->sl_data_offset = SHARED_META_DATA_SIZE; 1802 sl->sl_total_meta_size = SHARED_META_DATA_SIZE; 1803 sl->sl_meta_size_used = 0; 1804 } 1805 } 1806 if (slu->slu_alias_valid) { 1807 sl->sl_alias = p; 1808 (void) strcpy(p, namebuf + slu->slu_alias_off); 1809 p += strlen(sl->sl_alias) + 1; 1810 } 1811 if (slu->slu_mgmt_url_valid) { 1812 sl->sl_mgmt_url = p; 1813 (void) strcpy(p, namebuf + slu->slu_mgmt_url_off); 1814 p += strlen(sl->sl_mgmt_url) + 1; 1815 } 1816 if (slu->slu_serial_valid) { 1817 sl->sl_serial_no = (uint8_t *)p; 1818 bcopy(namebuf + slu->slu_serial_off, sl->sl_serial_no, 1819 slu->slu_serial_size); 1820 sl->sl_serial_no_size = slu->slu_serial_size; 1821 p += slu->slu_serial_size; 1822 } 1823 kmem_free(namebuf, sz); 1824 if (slu->slu_vid_valid) { 1825 bcopy(slu->slu_vid, sl->sl_vendor_id, 8); 1826 sl->sl_flags |= SL_VID_VALID; 1827 } 1828 if (slu->slu_pid_valid) { 1829 bcopy(slu->slu_pid, sl->sl_product_id, 16); 1830 sl->sl_flags |= SL_PID_VALID; 1831 } 1832 if (slu->slu_rev_valid) { 1833 bcopy(slu->slu_rev, sl->sl_revision, 4); 1834 sl->sl_flags |= SL_REV_VALID; 1835 } 1836 if (slu->slu_write_protected) { 1837 sl->sl_flags |= SL_WRITE_PROTECTED; 1838 } 1839 if (slu->slu_blksize_valid) { 1840 if (!ISP2(slu->slu_blksize) || 1841 (slu->slu_blksize > (32 * 1024)) || 1842 (slu->slu_blksize == 0)) { 1843 *err_ret = SBD_RET_INVALID_BLKSIZE; 1844 ret = EINVAL; 1845 goto scm_err_out; 1846 } 1847 while ((1 << sl->sl_data_blocksize_shift) != slu->slu_blksize) { 1848 sl->sl_data_blocksize_shift++; 1849 } 1850 } else { 1851 sl->sl_data_blocksize_shift = 9; /* 512 by default */ 1852 slu->slu_blksize = 512; 1853 } 1854 1855 /* Now lets start creating meta */ 1856 sl->sl_trans_op = SL_OP_CREATE_REGISTER_LU; 1857 if (sbd_link_lu(sl) != SBD_SUCCESS) { 1858 *err_ret = SBD_RET_FILE_ALREADY_REGISTERED; 1859 ret = EALREADY; 1860 goto scm_err_out; 1861 } 1862 1863 /* 1st focus on the data store */ 1864 if (slu->slu_lu_size_valid) { 1865 sl->sl_lu_size = slu->slu_lu_size; 1866 } 1867 ret = sbd_open_data_file(sl, err_ret, slu->slu_lu_size_valid, 0, 0); 1868 slu->slu_ret_filesize_nbits = sl->sl_data_fs_nbits; 1869 slu->slu_lu_size = sl->sl_lu_size; 1870 if (ret) { 1871 goto scm_err_out; 1872 } 1873 1874 /* 1875 * Check if we were explicitly asked to disable/enable write 1876 * cache on the device, otherwise get current device setting. 1877 */ 1878 if (slu->slu_writeback_cache_disable_valid) { 1879 if (slu->slu_writeback_cache_disable) { 1880 /* 1881 * Set write cache disable on the device. If it fails, 1882 * we'll support it using sync/flush. 1883 */ 1884 (void) sbd_wcd_set(1, sl); 1885 wcd = 1; 1886 } else { 1887 /* 1888 * Set write cache enable on the device. If it fails, 1889 * return an error. 1890 */ 1891 if (sbd_wcd_set(0, sl) != SBD_SUCCESS) { 1892 *err_ret = SBD_RET_WRITE_CACHE_SET_FAILED; 1893 ret = EFAULT; 1894 goto scm_err_out; 1895 } 1896 } 1897 } else { 1898 sbd_wcd_get(&wcd, sl); 1899 } 1900 1901 if (wcd) { 1902 sl->sl_flags |= SL_WRITEBACK_CACHE_DISABLE | 1903 SL_SAVED_WRITE_CACHE_DISABLE; 1904 } 1905 1906 if (sl->sl_flags & SL_SHARED_META) { 1907 goto over_meta_open; 1908 } 1909 if (sl->sl_flags & SL_ZFS_META) { 1910 if (sbd_create_zfs_meta_object(sl) != SBD_SUCCESS) { 1911 *err_ret = SBD_RET_ZFS_META_CREATE_FAILED; 1912 ret = ENOMEM; 1913 goto scm_err_out; 1914 } 1915 sl->sl_meta_blocksize_shift = 0; 1916 goto over_meta_create; 1917 } 1918 if ((ret = lookupname(sl->sl_meta_filename, UIO_SYSSPACE, FOLLOW, 1919 NULLVPP, &sl->sl_meta_vp)) != 0) { 1920 *err_ret = SBD_RET_META_FILE_LOOKUP_FAILED; 1921 goto scm_err_out; 1922 } 1923 sl->sl_meta_vtype = vt = sl->sl_meta_vp->v_type; 1924 VN_RELE(sl->sl_meta_vp); 1925 if ((vt != VREG) && (vt != VCHR) && (vt != VBLK)) { 1926 *err_ret = SBD_RET_WRONG_META_FILE_TYPE; 1927 ret = EINVAL; 1928 goto scm_err_out; 1929 } 1930 if (vt == VREG) { 1931 sl->sl_meta_blocksize_shift = 0; 1932 } else { 1933 sl->sl_meta_blocksize_shift = 9; 1934 } 1935 flag = FREAD | FWRITE | FOFFMAX | FEXCL; 1936 if ((ret = vn_open(sl->sl_meta_filename, UIO_SYSSPACE, flag, 0, 1937 &sl->sl_meta_vp, 0, 0)) != 0) { 1938 *err_ret = SBD_RET_META_FILE_OPEN_FAILED; 1939 goto scm_err_out; 1940 } 1941 over_meta_create: 1942 sl->sl_total_meta_size = sl->sl_meta_offset + sizeof (sbd_meta_start_t); 1943 sl->sl_total_meta_size += 1944 (((uint64_t)1) << sl->sl_meta_blocksize_shift) - 1; 1945 sl->sl_total_meta_size &= 1946 ~((((uint64_t)1) << sl->sl_meta_blocksize_shift) - 1); 1947 sl->sl_meta_size_used = 0; 1948 over_meta_open: 1949 sl->sl_flags |= SL_META_OPENED; 1950 1951 sl->sl_device_id[3] = 16; 1952 if (slu->slu_guid_valid) { 1953 sl->sl_device_id[0] = 0xf1; 1954 sl->sl_device_id[1] = 3; 1955 sl->sl_device_id[2] = 0; 1956 bcopy(slu->slu_guid, sl->sl_device_id + 4, 16); 1957 } else { 1958 if (slu->slu_host_id_valid) 1959 hid = slu->slu_host_id; 1960 if (!slu->slu_company_id_valid) 1961 slu->slu_company_id = COMPANY_ID_SUN; 1962 if (stmf_scsilib_uniq_lu_id2(slu->slu_company_id, hid, 1963 (scsi_devid_desc_t *)&sl->sl_device_id[0]) != 1964 STMF_SUCCESS) { 1965 *err_ret = SBD_RET_META_CREATION_FAILED; 1966 ret = EIO; 1967 goto scm_err_out; 1968 } 1969 bcopy(sl->sl_device_id + 4, slu->slu_guid, 16); 1970 } 1971 1972 /* Lets create the meta now */ 1973 mutex_enter(&sl->sl_metadata_lock); 1974 if (sbd_write_meta_start(sl, sl->sl_total_meta_size, 1975 sizeof (sbd_meta_start_t)) != SBD_SUCCESS) { 1976 mutex_exit(&sl->sl_metadata_lock); 1977 *err_ret = SBD_RET_META_CREATION_FAILED; 1978 ret = EIO; 1979 goto scm_err_out; 1980 } 1981 mutex_exit(&sl->sl_metadata_lock); 1982 sl->sl_meta_size_used = sl->sl_meta_offset + sizeof (sbd_meta_start_t); 1983 1984 if (sbd_write_lu_info(sl) != SBD_SUCCESS) { 1985 *err_ret = SBD_RET_META_CREATION_FAILED; 1986 ret = EIO; 1987 goto scm_err_out; 1988 } 1989 1990 if (sbd_pgr_meta_init(sl) != SBD_SUCCESS) { 1991 *err_ret = SBD_RET_META_CREATION_FAILED; 1992 ret = EIO; 1993 goto scm_err_out; 1994 } 1995 1996 /* 1997 * Update the zvol separately as this need only be called upon 1998 * completion of the metadata initialization. 1999 */ 2000 if (sl->sl_flags & SL_ZFS_META) { 2001 if (sbd_update_zfs_prop(sl) != SBD_SUCCESS) { 2002 *err_ret = SBD_RET_META_CREATION_FAILED; 2003 ret = EIO; 2004 goto scm_err_out; 2005 } 2006 } 2007 2008 ret = sbd_populate_and_register_lu(sl, err_ret); 2009 if (ret) { 2010 goto scm_err_out; 2011 } 2012 2013 sl->sl_trans_op = SL_OP_NONE; 2014 atomic_inc_32(&sbd_lu_count); 2015 return (0); 2016 2017 scm_err_out: 2018 return (sbd_close_delete_lu(sl, ret)); 2019 } 2020 2021 stmf_status_t 2022 sbd_proxy_msg(uint8_t *luid, void *proxy_arg, uint32_t proxy_arg_len, 2023 uint32_t type) 2024 { 2025 switch (type) { 2026 case STMF_MSG_LU_ACTIVE: 2027 return (sbd_proxy_reg_lu(luid, proxy_arg, 2028 proxy_arg_len)); 2029 case STMF_MSG_LU_REGISTER: 2030 return (sbd_proxy_reg_lu(luid, proxy_arg, 2031 proxy_arg_len)); 2032 case STMF_MSG_LU_DEREGISTER: 2033 return (sbd_proxy_dereg_lu(luid, proxy_arg, 2034 proxy_arg_len)); 2035 default: 2036 return (STMF_INVALID_ARG); 2037 } 2038 } 2039 2040 2041 /* 2042 * register a standby logical unit 2043 * proxy_reg_arg contains the meta filename 2044 */ 2045 stmf_status_t 2046 sbd_proxy_reg_lu(uint8_t *luid, void *proxy_reg_arg, uint32_t proxy_reg_arg_len) 2047 { 2048 sbd_lu_t *sl; 2049 sbd_status_t sret; 2050 sbd_create_standby_lu_t *stlu; 2051 int alloc_sz; 2052 uint32_t err_ret = 0; 2053 stmf_status_t stret = STMF_SUCCESS; 2054 2055 if (luid == NULL) { 2056 return (STMF_INVALID_ARG); 2057 } 2058 2059 do { 2060 sret = sbd_find_and_lock_lu(luid, NULL, SL_OP_MODIFY_LU, &sl); 2061 } while (sret == SBD_BUSY); 2062 2063 if (sret == SBD_NOT_FOUND) { 2064 alloc_sz = sizeof (*stlu) + proxy_reg_arg_len - 8; 2065 stlu = (sbd_create_standby_lu_t *)kmem_zalloc(alloc_sz, 2066 KM_SLEEP); 2067 bcopy(luid, stlu->stlu_guid, 16); 2068 if (proxy_reg_arg_len) { 2069 bcopy(proxy_reg_arg, stlu->stlu_meta_fname, 2070 proxy_reg_arg_len); 2071 stlu->stlu_meta_fname_size = proxy_reg_arg_len; 2072 } 2073 if (sbd_create_standby_lu(stlu, &err_ret) != 0) { 2074 cmn_err(CE_WARN, 2075 "Unable to create standby logical unit for %s", 2076 stlu->stlu_meta_fname); 2077 stret = STMF_FAILURE; 2078 } 2079 kmem_free(stlu, alloc_sz); 2080 return (stret); 2081 } else if (sret == SBD_SUCCESS) { 2082 /* 2083 * if the lu is already registered, then the lu should now 2084 * be in standby mode 2085 */ 2086 sbd_it_data_t *it; 2087 if (sl->sl_access_state != SBD_LU_STANDBY) { 2088 mutex_enter(&sl->sl_lock); 2089 sl->sl_access_state = SBD_LU_STANDBY; 2090 for (it = sl->sl_it_list; it != NULL; 2091 it = it->sbd_it_next) { 2092 it->sbd_it_ua_conditions |= 2093 SBD_UA_ASYMMETRIC_ACCESS_CHANGED; 2094 it->sbd_it_flags &= 2095 ~SBD_IT_HAS_SCSI2_RESERVATION; 2096 sl->sl_flags &= ~SL_LU_HAS_SCSI2_RESERVATION; 2097 } 2098 mutex_exit(&sl->sl_lock); 2099 sbd_pgr_reset(sl); 2100 } 2101 sl->sl_trans_op = SL_OP_NONE; 2102 } else { 2103 cmn_err(CE_WARN, "could not find and lock logical unit"); 2104 stret = STMF_FAILURE; 2105 } 2106 out: 2107 return (stret); 2108 } 2109 2110 /* ARGSUSED */ 2111 stmf_status_t 2112 sbd_proxy_dereg_lu(uint8_t *luid, void *proxy_reg_arg, 2113 uint32_t proxy_reg_arg_len) 2114 { 2115 sbd_delete_lu_t dlu = {0}; 2116 uint32_t err_ret; 2117 2118 if (luid == NULL) { 2119 cmn_err(CE_WARN, "de-register lu request had null luid"); 2120 return (STMF_INVALID_ARG); 2121 } 2122 2123 bcopy(luid, &dlu.dlu_guid, 16); 2124 2125 if (sbd_delete_lu(&dlu, (int)sizeof (dlu), &err_ret) != 0) { 2126 cmn_err(CE_WARN, "failed to delete de-register lu request"); 2127 return (STMF_FAILURE); 2128 } 2129 2130 return (STMF_SUCCESS); 2131 } 2132 2133 int 2134 sbd_create_standby_lu(sbd_create_standby_lu_t *slu, uint32_t *err_ret) 2135 { 2136 sbd_lu_t *sl; 2137 stmf_lu_t *lu; 2138 int ret = EIO; 2139 int alloc_sz; 2140 2141 alloc_sz = sizeof (sbd_lu_t) + sizeof (sbd_pgr_t) + 2142 slu->stlu_meta_fname_size; 2143 lu = (stmf_lu_t *)stmf_alloc(STMF_STRUCT_STMF_LU, alloc_sz, 0); 2144 if (lu == NULL) { 2145 return (ENOMEM); 2146 } 2147 sl = (sbd_lu_t *)lu->lu_provider_private; 2148 bzero(sl, alloc_sz); 2149 sl->sl_lu = lu; 2150 sl->sl_alloc_size = alloc_sz; 2151 2152 sl->sl_pgr = (sbd_pgr_t *)(sl + 1); 2153 sl->sl_meta_filename = ((char *)sl) + sizeof (sbd_lu_t) + 2154 sizeof (sbd_pgr_t); 2155 2156 if (slu->stlu_meta_fname_size > 0) { 2157 (void) strcpy(sl->sl_meta_filename, slu->stlu_meta_fname); 2158 } 2159 sl->sl_name = sl->sl_meta_filename; 2160 2161 sl->sl_device_id[3] = 16; 2162 sl->sl_device_id[0] = 0xf1; 2163 sl->sl_device_id[1] = 3; 2164 sl->sl_device_id[2] = 0; 2165 bcopy(slu->stlu_guid, sl->sl_device_id + 4, 16); 2166 lu->lu_id = (scsi_devid_desc_t *)sl->sl_device_id; 2167 sl->sl_access_state = SBD_LU_STANDBY; 2168 2169 rw_init(&sl->sl_pgr->pgr_lock, NULL, RW_DRIVER, NULL); 2170 mutex_init(&sl->sl_lock, NULL, MUTEX_DRIVER, NULL); 2171 mutex_init(&sl->sl_metadata_lock, NULL, MUTEX_DRIVER, NULL); 2172 rw_init(&sl->sl_access_state_lock, NULL, RW_DRIVER, NULL); 2173 2174 sl->sl_trans_op = SL_OP_CREATE_REGISTER_LU; 2175 2176 if (sbd_link_lu(sl) != SBD_SUCCESS) { 2177 *err_ret = SBD_RET_FILE_ALREADY_REGISTERED; 2178 ret = EALREADY; 2179 goto scs_err_out; 2180 } 2181 2182 ret = sbd_populate_and_register_lu(sl, err_ret); 2183 if (ret) { 2184 goto scs_err_out; 2185 } 2186 2187 sl->sl_trans_op = SL_OP_NONE; 2188 atomic_inc_32(&sbd_lu_count); 2189 return (0); 2190 2191 scs_err_out: 2192 return (sbd_close_delete_lu(sl, ret)); 2193 } 2194 2195 int 2196 sbd_load_sli_1_0(sbd_lu_t *sl, uint32_t *err_ret) 2197 { 2198 sbd_lu_info_1_0_t *sli = NULL; 2199 sbd_status_t sret; 2200 2201 sret = sbd_read_meta_section(sl, (sm_section_hdr_t **)&sli, 2202 SMS_ID_LU_INFO_1_0); 2203 2204 if (sret != SBD_SUCCESS) { 2205 *err_ret = SBD_RET_NO_META; 2206 return (EIO); 2207 } 2208 if (sli->sli_data_order != SMS_DATA_ORDER) { 2209 sbd_swap_lu_info_1_0(sli); 2210 if (sli->sli_data_order != SMS_DATA_ORDER) { 2211 kmem_free(sli, sli->sli_sms_header.sms_size); 2212 *err_ret = SBD_RET_NO_META; 2213 return (EIO); 2214 } 2215 } 2216 2217 sl->sl_flags |= SL_SHARED_META; 2218 sl->sl_data_blocksize_shift = 9; 2219 sl->sl_data_offset = SHARED_META_DATA_SIZE; 2220 sl->sl_lu_size = sli->sli_total_store_size - SHARED_META_DATA_SIZE; 2221 sl->sl_total_data_size = SHARED_META_DATA_SIZE + sl->sl_lu_size; 2222 bcopy(sli->sli_lu_devid, sl->sl_device_id, 20); 2223 2224 kmem_free(sli, sli->sli_sms_header.sms_size); 2225 return (0); 2226 } 2227 2228 int 2229 sbd_import_lu(sbd_import_lu_t *ilu, int struct_sz, uint32_t *err_ret, 2230 int no_register, sbd_lu_t **slr) 2231 { 2232 stmf_lu_t *lu; 2233 sbd_lu_t *sl; 2234 sbd_lu_info_1_1_t *sli = NULL; 2235 int asz; 2236 int ret = 0; 2237 stmf_status_t stret; 2238 int flag; 2239 int wcd = 0; 2240 int data_opened; 2241 uint16_t sli_buf_sz; 2242 uint8_t *sli_buf_copy = NULL; 2243 enum vtype vt; 2244 int standby = 0; 2245 sbd_status_t sret; 2246 2247 if (no_register && slr == NULL) { 2248 return (EINVAL); 2249 } 2250 ilu->ilu_meta_fname[struct_sz - sizeof (*ilu) + 8 - 1] = 0; 2251 /* 2252 * check whether logical unit is already registered ALUA 2253 * For a standby logical unit, the meta filename is set. Use 2254 * that to search for an existing logical unit. 2255 */ 2256 sret = sbd_find_and_lock_lu(NULL, (uint8_t *)&(ilu->ilu_meta_fname), 2257 SL_OP_IMPORT_LU, &sl); 2258 2259 if (sret == SBD_SUCCESS) { 2260 if (sl->sl_access_state != SBD_LU_ACTIVE) { 2261 no_register = 1; 2262 standby = 1; 2263 lu = sl->sl_lu; 2264 if (sl->sl_alias_alloc_size) { 2265 kmem_free(sl->sl_alias, 2266 sl->sl_alias_alloc_size); 2267 sl->sl_alias_alloc_size = 0; 2268 sl->sl_alias = NULL; 2269 lu->lu_alias = NULL; 2270 } 2271 if (sl->sl_meta_filename == NULL) { 2272 sl->sl_meta_filename = sl->sl_data_filename; 2273 } else if (sl->sl_data_fname_alloc_size) { 2274 kmem_free(sl->sl_data_filename, 2275 sl->sl_data_fname_alloc_size); 2276 sl->sl_data_fname_alloc_size = 0; 2277 } 2278 if (sl->sl_serial_no_alloc_size) { 2279 kmem_free(sl->sl_serial_no, 2280 sl->sl_serial_no_alloc_size); 2281 sl->sl_serial_no_alloc_size = 0; 2282 } 2283 if (sl->sl_mgmt_url_alloc_size) { 2284 kmem_free(sl->sl_mgmt_url, 2285 sl->sl_mgmt_url_alloc_size); 2286 sl->sl_mgmt_url_alloc_size = 0; 2287 } 2288 } else { 2289 *err_ret = SBD_RET_FILE_ALREADY_REGISTERED; 2290 bcopy(sl->sl_device_id + 4, ilu->ilu_ret_guid, 16); 2291 sl->sl_trans_op = SL_OP_NONE; 2292 return (EALREADY); 2293 } 2294 } else if (sret == SBD_NOT_FOUND) { 2295 asz = strlen(ilu->ilu_meta_fname) + 1; 2296 2297 lu = (stmf_lu_t *)stmf_alloc(STMF_STRUCT_STMF_LU, 2298 sizeof (sbd_lu_t) + sizeof (sbd_pgr_t) + asz, 0); 2299 if (lu == NULL) { 2300 return (ENOMEM); 2301 } 2302 sl = (sbd_lu_t *)lu->lu_provider_private; 2303 bzero(sl, sizeof (*sl)); 2304 sl->sl_lu = lu; 2305 sl->sl_pgr = (sbd_pgr_t *)(sl + 1); 2306 sl->sl_meta_filename = ((char *)sl) + sizeof (*sl) + 2307 sizeof (sbd_pgr_t); 2308 (void) strcpy(sl->sl_meta_filename, ilu->ilu_meta_fname); 2309 sl->sl_name = sl->sl_meta_filename; 2310 rw_init(&sl->sl_pgr->pgr_lock, NULL, RW_DRIVER, NULL); 2311 rw_init(&sl->sl_access_state_lock, NULL, RW_DRIVER, NULL); 2312 mutex_init(&sl->sl_lock, NULL, MUTEX_DRIVER, NULL); 2313 mutex_init(&sl->sl_metadata_lock, NULL, MUTEX_DRIVER, NULL); 2314 sl->sl_trans_op = SL_OP_IMPORT_LU; 2315 } else { 2316 *err_ret = SBD_RET_META_FILE_LOOKUP_FAILED; 2317 return (EIO); 2318 } 2319 2320 /* we're only loading the metadata */ 2321 if (!no_register) { 2322 if (sbd_link_lu(sl) != SBD_SUCCESS) { 2323 *err_ret = SBD_RET_FILE_ALREADY_REGISTERED; 2324 bcopy(sl->sl_device_id + 4, ilu->ilu_ret_guid, 16); 2325 ret = EALREADY; 2326 goto sim_err_out; 2327 } 2328 } 2329 if ((ret = lookupname(sl->sl_meta_filename, UIO_SYSSPACE, FOLLOW, 2330 NULLVPP, &sl->sl_meta_vp)) != 0) { 2331 *err_ret = SBD_RET_META_FILE_LOOKUP_FAILED; 2332 goto sim_err_out; 2333 } 2334 if (sbd_is_zvol(sl->sl_meta_filename)) { 2335 sl->sl_flags |= SL_ZFS_META; 2336 sl->sl_data_filename = sl->sl_meta_filename; 2337 } 2338 sl->sl_meta_vtype = vt = sl->sl_meta_vp->v_type; 2339 VN_RELE(sl->sl_meta_vp); 2340 if ((vt != VREG) && (vt != VCHR) && (vt != VBLK)) { 2341 *err_ret = SBD_RET_WRONG_META_FILE_TYPE; 2342 ret = EINVAL; 2343 goto sim_err_out; 2344 } 2345 if (sl->sl_flags & SL_ZFS_META) { 2346 if (sbd_open_zfs_meta(sl) != SBD_SUCCESS) { 2347 /* let see if metadata is in the 64k block */ 2348 sl->sl_flags &= ~SL_ZFS_META; 2349 } 2350 } 2351 if (!(sl->sl_flags & SL_ZFS_META)) { 2352 /* metadata is always writable */ 2353 flag = FREAD | FWRITE | FOFFMAX | FEXCL; 2354 if ((ret = vn_open(sl->sl_meta_filename, UIO_SYSSPACE, flag, 0, 2355 &sl->sl_meta_vp, 0, 0)) != 0) { 2356 *err_ret = SBD_RET_META_FILE_OPEN_FAILED; 2357 goto sim_err_out; 2358 } 2359 } 2360 if ((sl->sl_flags & SL_ZFS_META) || (vt == VREG)) { 2361 sl->sl_meta_blocksize_shift = 0; 2362 } else { 2363 sl->sl_meta_blocksize_shift = 9; 2364 } 2365 sl->sl_meta_offset = (sl->sl_flags & SL_ZFS_META) ? 0 : SBD_META_OFFSET; 2366 sl->sl_flags |= SL_META_OPENED; 2367 2368 mutex_enter(&sl->sl_metadata_lock); 2369 sret = sbd_load_meta_start(sl); 2370 mutex_exit(&sl->sl_metadata_lock); 2371 if (sret != SBD_SUCCESS) { 2372 if (sret == SBD_META_CORRUPTED) { 2373 *err_ret = SBD_RET_NO_META; 2374 } else if (sret == SBD_NOT_SUPPORTED) { 2375 *err_ret = SBD_RET_VERSION_NOT_SUPPORTED; 2376 } else { 2377 *err_ret = SBD_RET_NO_META; 2378 } 2379 ret = EINVAL; 2380 goto sim_err_out; 2381 } 2382 2383 /* Now lets see if we can read the most recent LU info */ 2384 sret = sbd_read_meta_section(sl, (sm_section_hdr_t **)&sli, 2385 SMS_ID_LU_INFO_1_1); 2386 if ((sret == SBD_NOT_FOUND) && ((sl->sl_flags & SL_ZFS_META) == 0)) { 2387 ret = sbd_load_sli_1_0(sl, err_ret); 2388 if (ret) { 2389 goto sim_err_out; 2390 } 2391 goto sim_sli_loaded; 2392 } 2393 if (sret != SBD_SUCCESS) { 2394 *err_ret = SBD_RET_NO_META; 2395 ret = EIO; 2396 goto sim_err_out; 2397 } 2398 /* load sli 1.1 */ 2399 if (sli->sli_data_order != SMS_DATA_ORDER) { 2400 sbd_swap_lu_info_1_1(sli); 2401 if (sli->sli_data_order != SMS_DATA_ORDER) { 2402 *err_ret = SBD_RET_NO_META; 2403 ret = EIO; 2404 goto sim_err_out; 2405 } 2406 } 2407 2408 sli_buf_sz = sli->sli_sms_header.sms_size - 2409 sizeof (sbd_lu_info_1_1_t) + 8; 2410 sli_buf_copy = kmem_alloc(sli_buf_sz + 1, KM_SLEEP); 2411 bcopy(sli->sli_buf, sli_buf_copy, sli_buf_sz); 2412 sli_buf_copy[sli_buf_sz] = 0; 2413 2414 /* Make sure all the offsets are within limits */ 2415 if (((sli->sli_flags & SLI_META_FNAME_VALID) && 2416 (sli->sli_meta_fname_offset > sli_buf_sz)) || 2417 ((sli->sli_flags & SLI_DATA_FNAME_VALID) && 2418 (sli->sli_data_fname_offset > sli_buf_sz)) || 2419 ((sli->sli_flags & SLI_MGMT_URL_VALID) && 2420 (sli->sli_mgmt_url_offset > sli_buf_sz)) || 2421 ((sli->sli_flags & SLI_SERIAL_VALID) && 2422 ((sli->sli_serial_offset + sli->sli_serial_size) > sli_buf_sz)) || 2423 ((sli->sli_flags & SLI_ALIAS_VALID) && 2424 (sli->sli_alias_offset > sli_buf_sz))) { 2425 *err_ret = SBD_RET_NO_META; 2426 ret = EIO; 2427 goto sim_err_out; 2428 } 2429 2430 sl->sl_lu_size = sli->sli_lu_size; 2431 sl->sl_data_blocksize_shift = sli->sli_data_blocksize_shift; 2432 bcopy(sli->sli_device_id, sl->sl_device_id, 20); 2433 if (sli->sli_flags & SLI_SERIAL_VALID) { 2434 sl->sl_serial_no_size = sl->sl_serial_no_alloc_size = 2435 sli->sli_serial_size; 2436 sl->sl_serial_no = kmem_zalloc(sli->sli_serial_size, KM_SLEEP); 2437 bcopy(sli_buf_copy + sli->sli_serial_offset, sl->sl_serial_no, 2438 sl->sl_serial_no_size); 2439 } 2440 if (sli->sli_flags & SLI_SEPARATE_META) { 2441 sl->sl_total_data_size = sl->sl_lu_size; 2442 if (sli->sli_flags & SLI_DATA_FNAME_VALID) { 2443 sl->sl_data_fname_alloc_size = strlen((char *) 2444 sli_buf_copy + sli->sli_data_fname_offset) + 1; 2445 sl->sl_data_filename = kmem_zalloc( 2446 sl->sl_data_fname_alloc_size, KM_SLEEP); 2447 (void) strcpy(sl->sl_data_filename, 2448 (char *)sli_buf_copy + sli->sli_data_fname_offset); 2449 } 2450 } else { 2451 if (sl->sl_flags & SL_ZFS_META) { 2452 sl->sl_total_data_size = sl->sl_lu_size; 2453 sl->sl_data_offset = 0; 2454 } else { 2455 sl->sl_total_data_size = 2456 sl->sl_lu_size + SHARED_META_DATA_SIZE; 2457 sl->sl_data_offset = SHARED_META_DATA_SIZE; 2458 sl->sl_flags |= SL_SHARED_META; 2459 } 2460 } 2461 if (sli->sli_flags & SLI_ALIAS_VALID) { 2462 sl->sl_alias_alloc_size = strlen((char *)sli_buf_copy + 2463 sli->sli_alias_offset) + 1; 2464 sl->sl_alias = kmem_alloc(sl->sl_alias_alloc_size, KM_SLEEP); 2465 (void) strcpy(sl->sl_alias, (char *)sli_buf_copy + 2466 sli->sli_alias_offset); 2467 } 2468 if (sli->sli_flags & SLI_MGMT_URL_VALID) { 2469 sl->sl_mgmt_url_alloc_size = strlen((char *)sli_buf_copy + 2470 sli->sli_mgmt_url_offset) + 1; 2471 sl->sl_mgmt_url = kmem_alloc(sl->sl_mgmt_url_alloc_size, 2472 KM_SLEEP); 2473 (void) strcpy(sl->sl_mgmt_url, (char *)sli_buf_copy + 2474 sli->sli_mgmt_url_offset); 2475 } 2476 if (sli->sli_flags & SLI_WRITE_PROTECTED) { 2477 sl->sl_flags |= SL_WRITE_PROTECTED; 2478 } 2479 if (sli->sli_flags & SLI_VID_VALID) { 2480 sl->sl_flags |= SL_VID_VALID; 2481 bcopy(sli->sli_vid, sl->sl_vendor_id, 8); 2482 } 2483 if (sli->sli_flags & SLI_PID_VALID) { 2484 sl->sl_flags |= SL_PID_VALID; 2485 bcopy(sli->sli_pid, sl->sl_product_id, 16); 2486 } 2487 if (sli->sli_flags & SLI_REV_VALID) { 2488 sl->sl_flags |= SL_REV_VALID; 2489 bcopy(sli->sli_rev, sl->sl_revision, 4); 2490 } 2491 if (sli->sli_flags & SLI_WRITEBACK_CACHE_DISABLE) { 2492 sl->sl_flags |= SL_WRITEBACK_CACHE_DISABLE; 2493 } 2494 sim_sli_loaded: 2495 if ((sl->sl_flags & SL_SHARED_META) == 0) { 2496 data_opened = 0; 2497 } else { 2498 data_opened = 1; 2499 sl->sl_data_filename = sl->sl_meta_filename; 2500 sl->sl_data_vp = sl->sl_meta_vp; 2501 sl->sl_data_vtype = sl->sl_meta_vtype; 2502 } 2503 2504 sret = sbd_pgr_meta_load(sl); 2505 if (sret != SBD_SUCCESS) { 2506 *err_ret = SBD_RET_NO_META; 2507 ret = EIO; 2508 goto sim_err_out; 2509 } 2510 2511 ret = sbd_open_data_file(sl, err_ret, 1, data_opened, 0); 2512 if (ret) { 2513 goto sim_err_out; 2514 } 2515 2516 /* 2517 * set write cache disable on the device 2518 * Note: this shouldn't fail on import unless the cache capabilities 2519 * of the device changed. If that happened, modify will need to 2520 * be used to set the cache flag appropriately after import is done. 2521 */ 2522 if (sl->sl_flags & SL_WRITEBACK_CACHE_DISABLE) { 2523 (void) sbd_wcd_set(1, sl); 2524 wcd = 1; 2525 /* 2526 * if not explicitly set, attempt to set it to enable, if that fails 2527 * get the current setting and use that 2528 */ 2529 } else { 2530 sret = sbd_wcd_set(0, sl); 2531 if (sret != SBD_SUCCESS) { 2532 sbd_wcd_get(&wcd, sl); 2533 } 2534 } 2535 2536 if (wcd) { 2537 sl->sl_flags |= SL_WRITEBACK_CACHE_DISABLE | 2538 SL_SAVED_WRITE_CACHE_DISABLE; 2539 } 2540 2541 /* we're only loading the metadata */ 2542 if (!no_register) { 2543 ret = sbd_populate_and_register_lu(sl, err_ret); 2544 if (ret) { 2545 goto sim_err_out; 2546 } 2547 atomic_inc_32(&sbd_lu_count); 2548 } 2549 2550 bcopy(sl->sl_device_id + 4, ilu->ilu_ret_guid, 16); 2551 sl->sl_trans_op = SL_OP_NONE; 2552 2553 if (sli) { 2554 kmem_free(sli, sli->sli_sms_header.sms_size); 2555 sli = NULL; 2556 } 2557 if (sli_buf_copy) { 2558 kmem_free(sli_buf_copy, sli_buf_sz + 1); 2559 sli_buf_copy = NULL; 2560 } 2561 if (no_register && !standby) { 2562 *slr = sl; 2563 } 2564 2565 /* 2566 * if this was imported from standby, set the access state 2567 * to active. 2568 */ 2569 if (standby) { 2570 sbd_it_data_t *it; 2571 mutex_enter(&sl->sl_lock); 2572 sl->sl_access_state = SBD_LU_ACTIVE; 2573 for (it = sl->sl_it_list; it != NULL; 2574 it = it->sbd_it_next) { 2575 it->sbd_it_ua_conditions |= 2576 SBD_UA_ASYMMETRIC_ACCESS_CHANGED; 2577 it->sbd_it_ua_conditions |= SBD_UA_POR; 2578 it->sbd_it_flags |= SBD_IT_PGR_CHECK_FLAG; 2579 } 2580 mutex_exit(&sl->sl_lock); 2581 /* call set access state */ 2582 stret = stmf_set_lu_access(lu, STMF_LU_ACTIVE); 2583 if (stret != STMF_SUCCESS) { 2584 *err_ret = SBD_RET_ACCESS_STATE_FAILED; 2585 sl->sl_access_state = SBD_LU_STANDBY; 2586 goto sim_err_out; 2587 } 2588 if (sl->sl_alias) { 2589 lu->lu_alias = sl->sl_alias; 2590 } else { 2591 lu->lu_alias = sl->sl_name; 2592 } 2593 } 2594 sl->sl_access_state = SBD_LU_ACTIVE; 2595 return (0); 2596 2597 sim_err_out: 2598 if (sli) { 2599 kmem_free(sli, sli->sli_sms_header.sms_size); 2600 sli = NULL; 2601 } 2602 if (sli_buf_copy) { 2603 kmem_free(sli_buf_copy, sli_buf_sz + 1); 2604 sli_buf_copy = NULL; 2605 } 2606 2607 if (standby) { 2608 *err_ret = SBD_RET_ACCESS_STATE_FAILED; 2609 sl->sl_trans_op = SL_OP_NONE; 2610 return (EIO); 2611 } else { 2612 return (sbd_close_delete_lu(sl, ret)); 2613 } 2614 } 2615 2616 int 2617 sbd_modify_lu(sbd_modify_lu_t *mlu, int struct_sz, uint32_t *err_ret) 2618 { 2619 sbd_lu_t *sl = NULL; 2620 uint16_t alias_sz; 2621 int ret = 0; 2622 sbd_it_data_t *it; 2623 sbd_status_t sret; 2624 uint64_t old_size; 2625 int modify_unregistered = 0; 2626 int ua = 0; 2627 sbd_import_lu_t *ilu; 2628 stmf_lu_t *lu; 2629 uint32_t ilu_sz; 2630 uint32_t sz; 2631 2632 sz = struct_sz - sizeof (*mlu) + 8 + 1; 2633 2634 /* if there is data in the buf, null terminate it */ 2635 if (struct_sz > sizeof (*mlu)) { 2636 mlu->mlu_buf[struct_sz - sizeof (*mlu) + 8 - 1] = 0; 2637 } 2638 2639 *err_ret = 0; 2640 2641 /* Lets validate offsets */ 2642 if (((mlu->mlu_alias_valid) && 2643 (mlu->mlu_alias_off >= sz)) || 2644 ((mlu->mlu_mgmt_url_valid) && 2645 (mlu->mlu_mgmt_url_off >= sz)) || 2646 (mlu->mlu_by_fname) && 2647 (mlu->mlu_fname_off >= sz)) { 2648 return (EINVAL); 2649 } 2650 2651 /* 2652 * We'll look for the device but if we don't find it registered, 2653 * we'll still try to modify the unregistered device. 2654 */ 2655 if (mlu->mlu_by_guid) { 2656 sret = sbd_find_and_lock_lu(mlu->mlu_input_guid, NULL, 2657 SL_OP_MODIFY_LU, &sl); 2658 } else if (mlu->mlu_by_fname) { 2659 sret = sbd_find_and_lock_lu(NULL, 2660 (uint8_t *)&(mlu->mlu_buf[mlu->mlu_fname_off]), 2661 SL_OP_MODIFY_LU, &sl); 2662 } else { 2663 return (EINVAL); 2664 } 2665 2666 2667 if (sret != SBD_SUCCESS) { 2668 if (sret == SBD_BUSY) { 2669 *err_ret = SBD_RET_LU_BUSY; 2670 return (EBUSY); 2671 } else if (sret != SBD_NOT_FOUND) { 2672 return (EIO); 2673 } else if (!mlu->mlu_by_fname) { 2674 return (EINVAL); 2675 } 2676 /* Okay, try to import the device */ 2677 struct_sz = max(8, strlen(&(mlu->mlu_buf[mlu->mlu_fname_off])) 2678 + 1); 2679 struct_sz += sizeof (sbd_import_lu_t) - 8; 2680 ilu_sz = struct_sz; 2681 ilu = (sbd_import_lu_t *)kmem_zalloc(ilu_sz, KM_SLEEP); 2682 ilu->ilu_struct_size = struct_sz; 2683 (void) strcpy(ilu->ilu_meta_fname, 2684 &(mlu->mlu_buf[mlu->mlu_fname_off])); 2685 ret = sbd_import_lu(ilu, struct_sz, err_ret, 1, &sl); 2686 kmem_free(ilu, ilu_sz); 2687 if (ret != SBD_SUCCESS) { 2688 return (ENOENT); 2689 } 2690 modify_unregistered = 1; 2691 } 2692 2693 if (sl->sl_access_state != SBD_LU_ACTIVE) { 2694 *err_ret = SBD_RET_ACCESS_STATE_FAILED; 2695 ret = EINVAL; 2696 goto smm_err_out; 2697 } 2698 2699 /* check for write cache change */ 2700 if (mlu->mlu_writeback_cache_disable_valid) { 2701 /* set wce on device */ 2702 sret = sbd_wcd_set(mlu->mlu_writeback_cache_disable, sl); 2703 if (!mlu->mlu_writeback_cache_disable && sret != SBD_SUCCESS) { 2704 *err_ret = SBD_RET_WRITE_CACHE_SET_FAILED; 2705 ret = EFAULT; 2706 goto smm_err_out; 2707 } 2708 mutex_enter(&sl->sl_lock); 2709 if (!mlu->mlu_writeback_cache_disable) { 2710 if (sl->sl_flags & SL_WRITEBACK_CACHE_DISABLE) { 2711 ua = 1; 2712 sl->sl_flags &= ~SL_WRITEBACK_CACHE_DISABLE; 2713 sl->sl_flags &= ~SL_SAVED_WRITE_CACHE_DISABLE; 2714 } 2715 } else { 2716 if ((sl->sl_flags & SL_WRITEBACK_CACHE_DISABLE) == 0) { 2717 ua = 1; 2718 sl->sl_flags |= SL_WRITEBACK_CACHE_DISABLE; 2719 sl->sl_flags |= SL_SAVED_WRITE_CACHE_DISABLE; 2720 } 2721 } 2722 for (it = sl->sl_it_list; ua && it != NULL; 2723 it = it->sbd_it_next) { 2724 it->sbd_it_ua_conditions |= 2725 SBD_UA_MODE_PARAMETERS_CHANGED; 2726 } 2727 mutex_exit(&sl->sl_lock); 2728 } 2729 ua = 0; 2730 2731 if (mlu->mlu_alias_valid) { 2732 alias_sz = strlen((char *)mlu->mlu_buf + 2733 mlu->mlu_alias_off) + 1; 2734 /* 2735 * Use the allocated buffer or alloc a new one. 2736 * Don't copy into sl_alias if sl_alias_alloc_size is 0 2737 * otherwise or you'll be writing over the data/metadata 2738 * filename. 2739 */ 2740 mutex_enter(&sl->sl_lock); 2741 if (sl->sl_alias_alloc_size > 0 && 2742 sl->sl_alias_alloc_size < alias_sz) { 2743 kmem_free(sl->sl_alias, 2744 sl->sl_alias_alloc_size); 2745 sl->sl_alias_alloc_size = 0; 2746 } 2747 if (sl->sl_alias_alloc_size == 0) { 2748 sl->sl_alias = kmem_alloc(alias_sz, KM_SLEEP); 2749 sl->sl_alias_alloc_size = alias_sz; 2750 } 2751 (void) strcpy(sl->sl_alias, (char *)mlu->mlu_buf + 2752 mlu->mlu_alias_off); 2753 lu = sl->sl_lu; 2754 lu->lu_alias = sl->sl_alias; 2755 mutex_exit(&sl->sl_lock); 2756 } 2757 2758 if (mlu->mlu_mgmt_url_valid) { 2759 uint16_t url_sz; 2760 2761 url_sz = strlen((char *)mlu->mlu_buf + mlu->mlu_mgmt_url_off); 2762 if (url_sz > 0) 2763 url_sz++; 2764 2765 mutex_enter(&sl->sl_lock); 2766 if (sl->sl_mgmt_url_alloc_size > 0 && 2767 (url_sz == 0 || sl->sl_mgmt_url_alloc_size < url_sz)) { 2768 kmem_free(sl->sl_mgmt_url, sl->sl_mgmt_url_alloc_size); 2769 sl->sl_mgmt_url = NULL; 2770 sl->sl_mgmt_url_alloc_size = 0; 2771 } 2772 if (url_sz > 0) { 2773 if (sl->sl_mgmt_url_alloc_size == 0) { 2774 sl->sl_mgmt_url = kmem_alloc(url_sz, KM_SLEEP); 2775 sl->sl_mgmt_url_alloc_size = url_sz; 2776 } 2777 (void) strcpy(sl->sl_mgmt_url, (char *)mlu->mlu_buf + 2778 mlu->mlu_mgmt_url_off); 2779 } 2780 for (it = sl->sl_it_list; it != NULL; 2781 it = it->sbd_it_next) { 2782 it->sbd_it_ua_conditions |= 2783 SBD_UA_MODE_PARAMETERS_CHANGED; 2784 } 2785 mutex_exit(&sl->sl_lock); 2786 } 2787 2788 if (mlu->mlu_write_protected_valid) { 2789 mutex_enter(&sl->sl_lock); 2790 if (mlu->mlu_write_protected) { 2791 if ((sl->sl_flags & SL_WRITE_PROTECTED) == 0) { 2792 ua = 1; 2793 sl->sl_flags |= SL_WRITE_PROTECTED; 2794 } 2795 } else { 2796 if (sl->sl_flags & SL_WRITE_PROTECTED) { 2797 ua = 1; 2798 sl->sl_flags &= ~SL_WRITE_PROTECTED; 2799 } 2800 } 2801 for (it = sl->sl_it_list; ua && it != NULL; 2802 it = it->sbd_it_next) { 2803 it->sbd_it_ua_conditions |= 2804 SBD_UA_MODE_PARAMETERS_CHANGED; 2805 } 2806 mutex_exit(&sl->sl_lock); 2807 } 2808 2809 if (mlu->mlu_lu_size_valid) { 2810 /* 2811 * validate lu size and set 2812 * For open file only (registered lu) 2813 */ 2814 mutex_enter(&sl->sl_lock); 2815 old_size = sl->sl_lu_size; 2816 sl->sl_lu_size = mlu->mlu_lu_size; 2817 mutex_exit(&sl->sl_lock); 2818 ret = sbd_open_data_file(sl, err_ret, 1, 1, 1); 2819 if (ret) { 2820 mutex_enter(&sl->sl_lock); 2821 sl->sl_lu_size = old_size; 2822 mutex_exit(&sl->sl_lock); 2823 goto smm_err_out; 2824 } 2825 if (old_size != mlu->mlu_lu_size) { 2826 mutex_enter(&sl->sl_lock); 2827 for (it = sl->sl_it_list; it != NULL; 2828 it = it->sbd_it_next) { 2829 it->sbd_it_ua_conditions |= 2830 SBD_UA_CAPACITY_CHANGED; 2831 } 2832 mutex_exit(&sl->sl_lock); 2833 } 2834 } 2835 2836 if (sbd_write_lu_info(sl) != SBD_SUCCESS) { 2837 *err_ret = SBD_RET_META_CREATION_FAILED; 2838 ret = EIO; 2839 } 2840 2841 smm_err_out: 2842 if (modify_unregistered) { 2843 (void) sbd_close_delete_lu(sl, 0); 2844 } else { 2845 sl->sl_trans_op = SL_OP_NONE; 2846 } 2847 return (ret); 2848 } 2849 2850 int 2851 sbd_set_global_props(sbd_global_props_t *mlu, int struct_sz, 2852 uint32_t *err_ret) 2853 { 2854 sbd_lu_t *sl = NULL; 2855 int ret = 0; 2856 sbd_it_data_t *it; 2857 uint32_t sz; 2858 2859 sz = struct_sz - sizeof (*mlu) + 8 + 1; 2860 2861 /* if there is data in the buf, null terminate it */ 2862 if (struct_sz > sizeof (*mlu)) { 2863 mlu->mlu_buf[struct_sz - sizeof (*mlu) + 8 - 1] = 0; 2864 } 2865 2866 *err_ret = 0; 2867 2868 /* Lets validate offsets */ 2869 if (((mlu->mlu_mgmt_url_valid) && 2870 (mlu->mlu_mgmt_url_off >= sz))) { 2871 return (EINVAL); 2872 } 2873 2874 if (mlu->mlu_mgmt_url_valid) { 2875 uint16_t url_sz; 2876 2877 url_sz = strlen((char *)mlu->mlu_buf + mlu->mlu_mgmt_url_off); 2878 if (url_sz > 0) 2879 url_sz++; 2880 2881 rw_enter(&sbd_global_prop_lock, RW_WRITER); 2882 if (sbd_mgmt_url_alloc_size > 0 && 2883 (url_sz == 0 || sbd_mgmt_url_alloc_size < url_sz)) { 2884 kmem_free(sbd_mgmt_url, sbd_mgmt_url_alloc_size); 2885 sbd_mgmt_url = NULL; 2886 sbd_mgmt_url_alloc_size = 0; 2887 } 2888 if (url_sz > 0) { 2889 if (sbd_mgmt_url_alloc_size == 0) { 2890 sbd_mgmt_url = kmem_alloc(url_sz, KM_SLEEP); 2891 sbd_mgmt_url_alloc_size = url_sz; 2892 } 2893 (void) strcpy(sbd_mgmt_url, (char *)mlu->mlu_buf + 2894 mlu->mlu_mgmt_url_off); 2895 } 2896 /* 2897 * check each lu to determine whether a UA is needed. 2898 */ 2899 mutex_enter(&sbd_lock); 2900 for (sl = sbd_lu_list; sl; sl = sl->sl_next) { 2901 if (sl->sl_mgmt_url) { 2902 continue; 2903 } 2904 mutex_enter(&sl->sl_lock); 2905 for (it = sl->sl_it_list; it != NULL; 2906 it = it->sbd_it_next) { 2907 it->sbd_it_ua_conditions |= 2908 SBD_UA_MODE_PARAMETERS_CHANGED; 2909 } 2910 mutex_exit(&sl->sl_lock); 2911 } 2912 mutex_exit(&sbd_lock); 2913 rw_exit(&sbd_global_prop_lock); 2914 } 2915 return (ret); 2916 } 2917 2918 /* ARGSUSED */ 2919 int 2920 sbd_delete_locked_lu(sbd_lu_t *sl, uint32_t *err_ret, 2921 stmf_state_change_info_t *ssi) 2922 { 2923 int i; 2924 stmf_status_t ret; 2925 2926 if ((sl->sl_state == STMF_STATE_OFFLINE) && 2927 !sl->sl_state_not_acked) { 2928 goto sdl_do_dereg; 2929 } 2930 2931 if ((sl->sl_state != STMF_STATE_ONLINE) || 2932 sl->sl_state_not_acked) { 2933 return (EBUSY); 2934 } 2935 2936 ret = stmf_ctl(STMF_CMD_LU_OFFLINE, sl->sl_lu, ssi); 2937 if ((ret != STMF_SUCCESS) && (ret != STMF_ALREADY)) { 2938 return (EBUSY); 2939 } 2940 2941 for (i = 0; i < 500; i++) { 2942 if ((sl->sl_state == STMF_STATE_OFFLINE) && 2943 !sl->sl_state_not_acked) { 2944 goto sdl_do_dereg; 2945 } 2946 delay(drv_usectohz(10000)); 2947 } 2948 return (EBUSY); 2949 2950 sdl_do_dereg:; 2951 if (stmf_deregister_lu(sl->sl_lu) != STMF_SUCCESS) 2952 return (EBUSY); 2953 atomic_dec_32(&sbd_lu_count); 2954 2955 return (sbd_close_delete_lu(sl, 0)); 2956 } 2957 2958 int 2959 sbd_delete_lu(sbd_delete_lu_t *dlu, int struct_sz, uint32_t *err_ret) 2960 { 2961 sbd_lu_t *sl; 2962 sbd_status_t sret; 2963 stmf_state_change_info_t ssi; 2964 int ret; 2965 2966 if (dlu->dlu_by_meta_name) { 2967 ((char *)dlu)[struct_sz - 1] = 0; 2968 sret = sbd_find_and_lock_lu(NULL, dlu->dlu_meta_name, 2969 SL_OP_DELETE_LU, &sl); 2970 } else { 2971 sret = sbd_find_and_lock_lu(dlu->dlu_guid, NULL, 2972 SL_OP_DELETE_LU, &sl); 2973 } 2974 if (sret != SBD_SUCCESS) { 2975 if (sret == SBD_BUSY) { 2976 *err_ret = SBD_RET_LU_BUSY; 2977 return (EBUSY); 2978 } else if (sret == SBD_NOT_FOUND) { 2979 *err_ret = SBD_RET_NOT_FOUND; 2980 return (ENOENT); 2981 } 2982 return (EIO); 2983 } 2984 2985 ssi.st_rflags = STMF_RFLAG_USER_REQUEST; 2986 ssi.st_additional_info = "sbd_delete_lu call (ioctl)"; 2987 ret = sbd_delete_locked_lu(sl, err_ret, &ssi); 2988 2989 if (ret) { 2990 /* Once its locked, no need to grab mutex again */ 2991 sl->sl_trans_op = SL_OP_NONE; 2992 } 2993 return (ret); 2994 } 2995 2996 sbd_status_t 2997 sbd_data_read(sbd_lu_t *sl, struct scsi_task *task, 2998 uint64_t offset, uint64_t size, uint8_t *buf) 2999 { 3000 int ret; 3001 long resid; 3002 3003 if ((offset + size) > sl->sl_lu_size) { 3004 return (SBD_IO_PAST_EOF); 3005 } 3006 3007 offset += sl->sl_data_offset; 3008 3009 if ((offset + size) > sl->sl_data_readable_size) { 3010 uint64_t store_end; 3011 if (offset > sl->sl_data_readable_size) { 3012 bzero(buf, size); 3013 return (SBD_SUCCESS); 3014 } 3015 store_end = sl->sl_data_readable_size - offset; 3016 bzero(buf + store_end, size - store_end); 3017 size = store_end; 3018 } 3019 3020 DTRACE_PROBE5(backing__store__read__start, sbd_lu_t *, sl, 3021 uint8_t *, buf, uint64_t, size, uint64_t, offset, 3022 scsi_task_t *, task); 3023 3024 /* 3025 * Don't proceed if the device has been closed 3026 * This can occur on an access state change to standby or 3027 * a delete. The writer lock is acquired before closing the 3028 * lu. 3029 */ 3030 rw_enter(&sl->sl_access_state_lock, RW_READER); 3031 if ((sl->sl_flags & SL_MEDIA_LOADED) == 0) { 3032 rw_exit(&sl->sl_access_state_lock); 3033 return (SBD_FAILURE); 3034 } 3035 ret = vn_rdwr(UIO_READ, sl->sl_data_vp, (caddr_t)buf, (ssize_t)size, 3036 (offset_t)offset, UIO_SYSSPACE, 0, RLIM64_INFINITY, CRED(), 3037 &resid); 3038 rw_exit(&sl->sl_access_state_lock); 3039 3040 DTRACE_PROBE6(backing__store__read__end, sbd_lu_t *, sl, 3041 uint8_t *, buf, uint64_t, size, uint64_t, offset, 3042 int, ret, scsi_task_t *, task); 3043 3044 over_sl_data_read: 3045 if (ret || resid) { 3046 stmf_trace(0, "UIO_READ failed, ret = %d, resid = %d", ret, 3047 resid); 3048 return (SBD_FAILURE); 3049 } 3050 3051 return (SBD_SUCCESS); 3052 } 3053 3054 sbd_status_t 3055 sbd_data_write(sbd_lu_t *sl, struct scsi_task *task, 3056 uint64_t offset, uint64_t size, uint8_t *buf) 3057 { 3058 int ret; 3059 long resid; 3060 sbd_status_t sret = SBD_SUCCESS; 3061 int ioflag; 3062 3063 if ((offset + size) > sl->sl_lu_size) { 3064 return (SBD_IO_PAST_EOF); 3065 } 3066 3067 offset += sl->sl_data_offset; 3068 3069 if ((sl->sl_flags & SL_WRITEBACK_CACHE_DISABLE) && 3070 (sl->sl_flags & SL_FLUSH_ON_DISABLED_WRITECACHE)) { 3071 ioflag = FSYNC; 3072 } else { 3073 ioflag = 0; 3074 } 3075 3076 DTRACE_PROBE5(backing__store__write__start, sbd_lu_t *, sl, 3077 uint8_t *, buf, uint64_t, size, uint64_t, offset, 3078 scsi_task_t *, task); 3079 3080 /* 3081 * Don't proceed if the device has been closed 3082 * This can occur on an access state change to standby or 3083 * a delete. The writer lock is acquired before closing the 3084 * lu. 3085 */ 3086 rw_enter(&sl->sl_access_state_lock, RW_READER); 3087 if ((sl->sl_flags & SL_MEDIA_LOADED) == 0) { 3088 rw_exit(&sl->sl_access_state_lock); 3089 return (SBD_FAILURE); 3090 } 3091 ret = vn_rdwr(UIO_WRITE, sl->sl_data_vp, (caddr_t)buf, (ssize_t)size, 3092 (offset_t)offset, UIO_SYSSPACE, ioflag, RLIM64_INFINITY, CRED(), 3093 &resid); 3094 rw_exit(&sl->sl_access_state_lock); 3095 3096 DTRACE_PROBE6(backing__store__write__end, sbd_lu_t *, sl, 3097 uint8_t *, buf, uint64_t, size, uint64_t, offset, 3098 int, ret, scsi_task_t *, task); 3099 3100 if ((ret == 0) && (resid == 0) && 3101 (sl->sl_flags & SL_WRITEBACK_CACHE_DISABLE) && 3102 (sl->sl_flags & SL_FLUSH_ON_DISABLED_WRITECACHE)) { 3103 sret = sbd_flush_data_cache(sl, 1); 3104 } 3105 over_sl_data_write: 3106 3107 if ((ret || resid) || (sret != SBD_SUCCESS)) { 3108 return (SBD_FAILURE); 3109 } else if ((offset + size) > sl->sl_data_readable_size) { 3110 uint64_t old_size, new_size; 3111 3112 do { 3113 old_size = sl->sl_data_readable_size; 3114 if ((offset + size) <= old_size) 3115 break; 3116 new_size = offset + size; 3117 } while (atomic_cas_64(&sl->sl_data_readable_size, old_size, 3118 new_size) != old_size); 3119 } 3120 3121 return (SBD_SUCCESS); 3122 } 3123 3124 int 3125 sbd_get_global_props(sbd_global_props_t *oslp, uint32_t oslp_sz, 3126 uint32_t *err_ret) 3127 { 3128 uint32_t sz = 0; 3129 uint16_t off; 3130 3131 rw_enter(&sbd_global_prop_lock, RW_READER); 3132 if (sbd_mgmt_url) { 3133 sz += strlen(sbd_mgmt_url) + 1; 3134 } 3135 bzero(oslp, sizeof (*oslp) - 8); 3136 oslp->mlu_buf_size_needed = sz; 3137 3138 if (sz > (oslp_sz - sizeof (*oslp) + 8)) { 3139 *err_ret = SBD_RET_INSUFFICIENT_BUF_SPACE; 3140 rw_exit(&sbd_global_prop_lock); 3141 return (ENOMEM); 3142 } 3143 3144 off = 0; 3145 if (sbd_mgmt_url) { 3146 oslp->mlu_mgmt_url_valid = 1; 3147 oslp->mlu_mgmt_url_off = off; 3148 (void) strcpy((char *)&oslp->mlu_buf[off], sbd_mgmt_url); 3149 off += strlen(sbd_mgmt_url) + 1; 3150 } 3151 3152 rw_exit(&sbd_global_prop_lock); 3153 return (0); 3154 } 3155 3156 static int 3157 sbd_get_unmap_props(sbd_unmap_props_t *sup, 3158 sbd_unmap_props_t *osup, uint32_t *err_ret) 3159 { 3160 sbd_status_t sret; 3161 sbd_lu_t *sl = NULL; 3162 3163 if (sup->sup_guid_valid) { 3164 sret = sbd_find_and_lock_lu(sup->sup_guid, 3165 NULL, SL_OP_LU_PROPS, &sl); 3166 } else { 3167 sret = sbd_find_and_lock_lu(NULL, 3168 (uint8_t *)sup->sup_zvol_path, SL_OP_LU_PROPS, 3169 &sl); 3170 } 3171 if (sret != SBD_SUCCESS) { 3172 if (sret == SBD_BUSY) { 3173 *err_ret = SBD_RET_LU_BUSY; 3174 return (EBUSY); 3175 } else if (sret == SBD_NOT_FOUND) { 3176 *err_ret = SBD_RET_NOT_FOUND; 3177 return (ENOENT); 3178 } 3179 return (EIO); 3180 } 3181 3182 sup->sup_found_lu = 1; 3183 sup->sup_guid_valid = 1; 3184 bcopy(sl->sl_device_id + 4, sup->sup_guid, 16); 3185 if (sl->sl_flags & SL_UNMAP_ENABLED) 3186 sup->sup_unmap_enabled = 1; 3187 else 3188 sup->sup_unmap_enabled = 0; 3189 3190 *osup = *sup; 3191 sl->sl_trans_op = SL_OP_NONE; 3192 3193 return (0); 3194 } 3195 3196 int 3197 sbd_get_lu_props(sbd_lu_props_t *islp, uint32_t islp_sz, 3198 sbd_lu_props_t *oslp, uint32_t oslp_sz, uint32_t *err_ret) 3199 { 3200 sbd_status_t sret; 3201 sbd_lu_t *sl = NULL; 3202 uint32_t sz; 3203 uint16_t off; 3204 3205 if (islp->slp_input_guid) { 3206 sret = sbd_find_and_lock_lu(islp->slp_guid, NULL, 3207 SL_OP_LU_PROPS, &sl); 3208 } else { 3209 ((char *)islp)[islp_sz - 1] = 0; 3210 sret = sbd_find_and_lock_lu(NULL, islp->slp_buf, 3211 SL_OP_LU_PROPS, &sl); 3212 } 3213 if (sret != SBD_SUCCESS) { 3214 if (sret == SBD_BUSY) { 3215 *err_ret = SBD_RET_LU_BUSY; 3216 return (EBUSY); 3217 } else if (sret == SBD_NOT_FOUND) { 3218 *err_ret = SBD_RET_NOT_FOUND; 3219 return (ENOENT); 3220 } 3221 return (EIO); 3222 } 3223 3224 sz = strlen(sl->sl_name) + 1; 3225 if ((sl->sl_flags & (SL_ZFS_META | SL_SHARED_META)) == 0) { 3226 if (sl->sl_data_filename) { 3227 sz += strlen(sl->sl_data_filename) + 1; 3228 } 3229 } 3230 sz += sl->sl_serial_no_size; 3231 if (sl->sl_alias) { 3232 sz += strlen(sl->sl_alias) + 1; 3233 } 3234 3235 rw_enter(&sbd_global_prop_lock, RW_READER); 3236 if (sl->sl_mgmt_url) { 3237 sz += strlen(sl->sl_mgmt_url) + 1; 3238 } else if (sbd_mgmt_url) { 3239 sz += strlen(sbd_mgmt_url) + 1; 3240 } 3241 bzero(oslp, sizeof (*oslp) - 8); 3242 oslp->slp_buf_size_needed = sz; 3243 3244 if (sz > (oslp_sz - sizeof (*oslp) + 8)) { 3245 sl->sl_trans_op = SL_OP_NONE; 3246 *err_ret = SBD_RET_INSUFFICIENT_BUF_SPACE; 3247 rw_exit(&sbd_global_prop_lock); 3248 return (ENOMEM); 3249 } 3250 3251 off = 0; 3252 (void) strcpy((char *)oslp->slp_buf, sl->sl_name); 3253 oslp->slp_meta_fname_off = off; 3254 off += strlen(sl->sl_name) + 1; 3255 if ((sl->sl_flags & (SL_ZFS_META | SL_SHARED_META)) == 0) { 3256 oslp->slp_meta_fname_valid = 1; 3257 oslp->slp_separate_meta = 1; 3258 if (sl->sl_data_filename) { 3259 oslp->slp_data_fname_valid = 1; 3260 oslp->slp_data_fname_off = off; 3261 (void) strcpy((char *)&oslp->slp_buf[off], 3262 sl->sl_data_filename); 3263 off += strlen(sl->sl_data_filename) + 1; 3264 } 3265 } else { 3266 oslp->slp_data_fname_valid = 1; 3267 oslp->slp_data_fname_off = oslp->slp_meta_fname_off; 3268 if (sl->sl_flags & SL_ZFS_META) { 3269 oslp->slp_zfs_meta = 1; 3270 } 3271 } 3272 if (sl->sl_alias) { 3273 oslp->slp_alias_valid = 1; 3274 oslp->slp_alias_off = off; 3275 (void) strcpy((char *)&oslp->slp_buf[off], sl->sl_alias); 3276 off += strlen(sl->sl_alias) + 1; 3277 } 3278 if (sl->sl_mgmt_url) { 3279 oslp->slp_mgmt_url_valid = 1; 3280 oslp->slp_mgmt_url_off = off; 3281 (void) strcpy((char *)&oslp->slp_buf[off], sl->sl_mgmt_url); 3282 off += strlen(sl->sl_mgmt_url) + 1; 3283 } else if (sbd_mgmt_url) { 3284 oslp->slp_mgmt_url_valid = 1; 3285 oslp->slp_mgmt_url_off = off; 3286 (void) strcpy((char *)&oslp->slp_buf[off], sbd_mgmt_url); 3287 off += strlen(sbd_mgmt_url) + 1; 3288 } 3289 if (sl->sl_serial_no_size) { 3290 oslp->slp_serial_off = off; 3291 bcopy(sl->sl_serial_no, &oslp->slp_buf[off], 3292 sl->sl_serial_no_size); 3293 oslp->slp_serial_size = sl->sl_serial_no_size; 3294 oslp->slp_serial_valid = 1; 3295 off += sl->sl_serial_no_size; 3296 } 3297 3298 oslp->slp_lu_size = sl->sl_lu_size; 3299 oslp->slp_blksize = ((uint16_t)1) << sl->sl_data_blocksize_shift; 3300 3301 oslp->slp_access_state = sl->sl_access_state; 3302 3303 if (sl->sl_flags & SL_VID_VALID) { 3304 oslp->slp_lu_vid = 1; 3305 bcopy(sl->sl_vendor_id, oslp->slp_vid, 8); 3306 } else { 3307 bcopy(sbd_vendor_id, oslp->slp_vid, 8); 3308 } 3309 if (sl->sl_flags & SL_PID_VALID) { 3310 oslp->slp_lu_pid = 1; 3311 bcopy(sl->sl_product_id, oslp->slp_pid, 16); 3312 } else { 3313 bcopy(sbd_product_id, oslp->slp_pid, 16); 3314 } 3315 if (sl->sl_flags & SL_REV_VALID) { 3316 oslp->slp_lu_rev = 1; 3317 bcopy(sl->sl_revision, oslp->slp_rev, 4); 3318 } else { 3319 bcopy(sbd_revision, oslp->slp_rev, 4); 3320 } 3321 bcopy(sl->sl_device_id + 4, oslp->slp_guid, 16); 3322 3323 if (sl->sl_flags & SL_WRITEBACK_CACHE_DISABLE) 3324 oslp->slp_writeback_cache_disable_cur = 1; 3325 if (sl->sl_flags & SL_SAVED_WRITE_CACHE_DISABLE) 3326 oslp->slp_writeback_cache_disable_saved = 1; 3327 if (sl->sl_flags & SL_WRITE_PROTECTED) 3328 oslp->slp_write_protected = 1; 3329 3330 sl->sl_trans_op = SL_OP_NONE; 3331 3332 rw_exit(&sbd_global_prop_lock); 3333 return (0); 3334 } 3335 3336 /* 3337 * Returns an allocated string with the "<pool>/..." form of the zvol name. 3338 */ 3339 static char * 3340 sbd_get_zvol_name(sbd_lu_t *sl) 3341 { 3342 char *src; 3343 char *p; 3344 3345 if (sl->sl_data_filename) 3346 src = sl->sl_data_filename; 3347 else 3348 src = sl->sl_meta_filename; 3349 /* There has to be a better way */ 3350 if (SBD_IS_ZVOL(src) != 0) { 3351 ASSERT(0); 3352 } 3353 src += 14; /* Past /dev/zvol/dsk/ */ 3354 if (*src == '/') 3355 src++; /* or /dev/zvol/rdsk/ */ 3356 p = (char *)kmem_alloc(strlen(src) + 1, KM_SLEEP); 3357 (void) strcpy(p, src); 3358 return (p); 3359 } 3360 3361 /* 3362 * this function creates a local metadata zvol property 3363 */ 3364 sbd_status_t 3365 sbd_create_zfs_meta_object(sbd_lu_t *sl) 3366 { 3367 /* 3368 * -allocate 1/2 the property size, the zfs property 3369 * is 8k in size and stored as ascii hex string, all 3370 * we needed is 4k buffer to store the binary data. 3371 * -initialize reader/write lock 3372 */ 3373 if ((sl->sl_zfs_meta = kmem_zalloc(ZAP_MAXVALUELEN / 2, KM_SLEEP)) 3374 == NULL) 3375 return (SBD_FAILURE); 3376 rw_init(&sl->sl_zfs_meta_lock, NULL, RW_DRIVER, NULL); 3377 return (SBD_SUCCESS); 3378 } 3379 3380 char 3381 sbd_ctoi(char c) 3382 { 3383 if ((c >= '0') && (c <= '9')) 3384 c -= '0'; 3385 else if ((c >= 'A') && (c <= 'F')) 3386 c = c - 'A' + 10; 3387 else if ((c >= 'a') && (c <= 'f')) 3388 c = c - 'a' + 10; 3389 else 3390 c = -1; 3391 return (c); 3392 } 3393 3394 /* 3395 * read zvol property and convert to binary 3396 */ 3397 sbd_status_t 3398 sbd_open_zfs_meta(sbd_lu_t *sl) 3399 { 3400 char *meta = NULL, cl, ch; 3401 int i; 3402 char *tmp, *ptr; 3403 uint64_t rc = SBD_SUCCESS; 3404 int len; 3405 char *file; 3406 3407 if (sl->sl_zfs_meta == NULL) { 3408 if (sbd_create_zfs_meta_object(sl) == SBD_FAILURE) 3409 return (SBD_FAILURE); 3410 } else { 3411 bzero(sl->sl_zfs_meta, (ZAP_MAXVALUELEN / 2)); 3412 } 3413 3414 rw_enter(&sl->sl_zfs_meta_lock, RW_WRITER); 3415 file = sbd_get_zvol_name(sl); 3416 if (sbd_zvolget(file, &meta)) { 3417 rc = SBD_FAILURE; 3418 goto done; 3419 } 3420 tmp = meta; 3421 /* convert ascii hex to binary meta */ 3422 len = strlen(meta); 3423 ptr = sl->sl_zfs_meta; 3424 for (i = 0; i < len; i += 2) { 3425 ch = sbd_ctoi(*tmp++); 3426 cl = sbd_ctoi(*tmp++); 3427 if (ch == -1 || cl == -1) { 3428 rc = SBD_FAILURE; 3429 break; 3430 } 3431 *ptr++ = (ch << 4) + cl; 3432 } 3433 done: 3434 rw_exit(&sl->sl_zfs_meta_lock); 3435 if (meta) 3436 kmem_free(meta, len + 1); 3437 kmem_free(file, strlen(file) + 1); 3438 return (rc); 3439 } 3440 3441 sbd_status_t 3442 sbd_read_zfs_meta(sbd_lu_t *sl, uint8_t *buf, uint64_t sz, uint64_t off) 3443 { 3444 ASSERT(sl->sl_zfs_meta); 3445 rw_enter(&sl->sl_zfs_meta_lock, RW_READER); 3446 bcopy(&sl->sl_zfs_meta[off], buf, sz); 3447 rw_exit(&sl->sl_zfs_meta_lock); 3448 return (SBD_SUCCESS); 3449 } 3450 3451 sbd_status_t 3452 sbd_write_zfs_meta(sbd_lu_t *sl, uint8_t *buf, uint64_t sz, uint64_t off) 3453 { 3454 ASSERT(sl->sl_zfs_meta); 3455 if ((off + sz) > (ZAP_MAXVALUELEN / 2 - 1)) { 3456 return (SBD_META_CORRUPTED); 3457 } 3458 if ((off + sz) > sl->sl_meta_size_used) { 3459 sl->sl_meta_size_used = off + sz; 3460 if (sl->sl_total_meta_size < sl->sl_meta_size_used) { 3461 uint64_t meta_align = 3462 (((uint64_t)1) << sl->sl_meta_blocksize_shift) - 1; 3463 sl->sl_total_meta_size = (sl->sl_meta_size_used + 3464 meta_align) & (~meta_align); 3465 } 3466 } 3467 rw_enter(&sl->sl_zfs_meta_lock, RW_WRITER); 3468 bcopy(buf, &sl->sl_zfs_meta[off], sz); 3469 rw_exit(&sl->sl_zfs_meta_lock); 3470 /* 3471 * During creation of a logical unit, sbd_update_zfs_prop will be 3472 * called separately to avoid multiple calls as each meta section 3473 * create/update will result in a call to sbd_write_zfs_meta(). 3474 * We only need to update the zvol once during create. 3475 */ 3476 mutex_enter(&sl->sl_lock); 3477 if (sl->sl_trans_op != SL_OP_CREATE_REGISTER_LU) { 3478 mutex_exit(&sl->sl_lock); 3479 return (sbd_update_zfs_prop(sl)); 3480 } 3481 mutex_exit(&sl->sl_lock); 3482 return (SBD_SUCCESS); 3483 } 3484 3485 sbd_status_t 3486 sbd_update_zfs_prop(sbd_lu_t *sl) 3487 { 3488 char *ptr, *ah_meta; 3489 char *dp = NULL; 3490 int i, num; 3491 char *file; 3492 sbd_status_t ret = SBD_SUCCESS; 3493 3494 ASSERT(sl->sl_zfs_meta); 3495 ptr = ah_meta = kmem_zalloc(ZAP_MAXVALUELEN, KM_SLEEP); 3496 rw_enter(&sl->sl_zfs_meta_lock, RW_READER); 3497 /* convert local copy to ascii hex */ 3498 dp = sl->sl_zfs_meta; 3499 for (i = 0; i < sl->sl_total_meta_size; i++, dp++) { 3500 num = ((*dp) >> 4) & 0xF; 3501 *ah_meta++ = (num < 10) ? (num + '0') : (num + ('a' - 10)); 3502 num = (*dp) & 0xF; 3503 *ah_meta++ = (num < 10) ? (num + '0') : (num + ('a' - 10)); 3504 } 3505 *ah_meta = NULL; 3506 file = sbd_get_zvol_name(sl); 3507 if (sbd_zvolset(file, (char *)ptr)) { 3508 ret = SBD_META_CORRUPTED; 3509 } 3510 rw_exit(&sl->sl_zfs_meta_lock); 3511 kmem_free(ptr, ZAP_MAXVALUELEN); 3512 kmem_free(file, strlen(file) + 1); 3513 return (ret); 3514 } 3515 3516 int 3517 sbd_is_zvol(char *path) 3518 { 3519 int is_zfs = 0; 3520 3521 if (SBD_IS_ZVOL(path) == 0) 3522 is_zfs = 1; 3523 3524 return (is_zfs); 3525 } 3526 3527 /* 3528 * set write cache disable 3529 * wcd - 1 = disable, 0 = enable 3530 */ 3531 sbd_status_t 3532 sbd_wcd_set(int wcd, sbd_lu_t *sl) 3533 { 3534 /* translate to wce bit */ 3535 int wce = wcd ? 0 : 1; 3536 int ret; 3537 sbd_status_t sret = SBD_SUCCESS; 3538 3539 mutex_enter(&sl->sl_lock); 3540 sl->sl_flags &= ~SL_WRITEBACK_CACHE_SET_UNSUPPORTED; 3541 3542 if (sl->sl_data_vp->v_type == VREG) { 3543 sl->sl_flags |= SL_FLUSH_ON_DISABLED_WRITECACHE; 3544 goto done; 3545 } 3546 3547 ret = VOP_IOCTL(sl->sl_data_vp, DKIOCSETWCE, (intptr_t)&wce, FKIOCTL, 3548 kcred, NULL, NULL); 3549 if (ret == 0) { 3550 sl->sl_flags &= ~SL_WRITEBACK_CACHE_SET_UNSUPPORTED; 3551 sl->sl_flags &= ~SL_FLUSH_ON_DISABLED_WRITECACHE; 3552 } else { 3553 sl->sl_flags |= SL_WRITEBACK_CACHE_SET_UNSUPPORTED; 3554 sl->sl_flags |= SL_FLUSH_ON_DISABLED_WRITECACHE; 3555 sret = SBD_FAILURE; 3556 goto done; 3557 } 3558 3559 done: 3560 mutex_exit(&sl->sl_lock); 3561 return (sret); 3562 } 3563 3564 /* 3565 * get write cache disable 3566 * wcd - 1 = disable, 0 = enable 3567 */ 3568 void 3569 sbd_wcd_get(int *wcd, sbd_lu_t *sl) 3570 { 3571 int wce; 3572 int ret; 3573 3574 if (sl->sl_data_vp->v_type == VREG) { 3575 *wcd = 0; 3576 return; 3577 } 3578 3579 ret = VOP_IOCTL(sl->sl_data_vp, DKIOCGETWCE, (intptr_t)&wce, FKIOCTL, 3580 kcred, NULL, NULL); 3581 /* if write cache get failed, assume disabled */ 3582 if (ret) { 3583 *wcd = 1; 3584 } else { 3585 /* translate to wcd bit */ 3586 *wcd = wce ? 0 : 1; 3587 } 3588 } 3589 3590 int 3591 sbd_zvolget(char *zvol_name, char **comstarprop) 3592 { 3593 ldi_handle_t zfs_lh; 3594 nvlist_t *nv = NULL, *nv2; 3595 zfs_cmd_t *zc; 3596 char *ptr; 3597 int size = 1024; 3598 int unused; 3599 int rc; 3600 3601 if ((rc = ldi_open_by_name("/dev/zfs", FREAD | FWRITE, kcred, 3602 &zfs_lh, sbd_zfs_ident)) != 0) { 3603 cmn_err(CE_WARN, "ldi_open %d", rc); 3604 return (ENXIO); 3605 } 3606 3607 zc = kmem_zalloc(sizeof (zfs_cmd_t), KM_SLEEP); 3608 (void) strlcpy(zc->zc_name, zvol_name, sizeof (zc->zc_name)); 3609 again: 3610 zc->zc_nvlist_dst = (uint64_t)(intptr_t)kmem_alloc(size, 3611 KM_SLEEP); 3612 zc->zc_nvlist_dst_size = size; 3613 rc = ldi_ioctl(zfs_lh, ZFS_IOC_OBJSET_STATS, (intptr_t)zc, 3614 FKIOCTL, kcred, &unused); 3615 /* 3616 * ENOMEM means the list is larger than what we've allocated 3617 * ldi_ioctl will fail with ENOMEM only once 3618 */ 3619 if (rc == ENOMEM) { 3620 int newsize; 3621 newsize = zc->zc_nvlist_dst_size; 3622 kmem_free((void *)(uintptr_t)zc->zc_nvlist_dst, size); 3623 size = newsize; 3624 goto again; 3625 } else if (rc != 0) { 3626 goto out; 3627 } 3628 rc = nvlist_unpack((char *)(uintptr_t)zc->zc_nvlist_dst, 3629 zc->zc_nvlist_dst_size, &nv, 0); 3630 ASSERT(rc == 0); /* nvlist_unpack should not fail */ 3631 if ((rc = nvlist_lookup_nvlist(nv, "stmf_sbd_lu", &nv2)) == 0) { 3632 rc = nvlist_lookup_string(nv2, ZPROP_VALUE, &ptr); 3633 if (rc != 0) { 3634 cmn_err(CE_WARN, "couldn't get value"); 3635 } else { 3636 *comstarprop = kmem_alloc(strlen(ptr) + 1, 3637 KM_SLEEP); 3638 (void) strcpy(*comstarprop, ptr); 3639 } 3640 } 3641 out: 3642 nvlist_free(nv); 3643 kmem_free((void *)(uintptr_t)zc->zc_nvlist_dst, size); 3644 kmem_free(zc, sizeof (zfs_cmd_t)); 3645 (void) ldi_close(zfs_lh, FREAD|FWRITE, kcred); 3646 3647 return (rc); 3648 } 3649 3650 int 3651 sbd_zvolset(char *zvol_name, char *comstarprop) 3652 { 3653 ldi_handle_t zfs_lh; 3654 nvlist_t *nv; 3655 char *packed = NULL; 3656 size_t len; 3657 zfs_cmd_t *zc; 3658 int unused; 3659 int rc; 3660 3661 if ((rc = ldi_open_by_name("/dev/zfs", FREAD | FWRITE, kcred, 3662 &zfs_lh, sbd_zfs_ident)) != 0) { 3663 cmn_err(CE_WARN, "ldi_open %d", rc); 3664 return (ENXIO); 3665 } 3666 (void) nvlist_alloc(&nv, NV_UNIQUE_NAME, KM_SLEEP); 3667 (void) nvlist_add_string(nv, "stmf_sbd_lu", comstarprop); 3668 if ((rc = nvlist_pack(nv, &packed, &len, NV_ENCODE_NATIVE, KM_SLEEP))) { 3669 goto out; 3670 } 3671 3672 zc = kmem_zalloc(sizeof (zfs_cmd_t), KM_SLEEP); 3673 (void) strlcpy(zc->zc_name, zvol_name, sizeof (zc->zc_name)); 3674 zc->zc_nvlist_src = (uint64_t)(intptr_t)packed; 3675 zc->zc_nvlist_src_size = len; 3676 rc = ldi_ioctl(zfs_lh, ZFS_IOC_SET_PROP, (intptr_t)zc, 3677 FKIOCTL, kcred, &unused); 3678 if (rc != 0) { 3679 cmn_err(CE_NOTE, "ioctl failed %d", rc); 3680 } 3681 kmem_free(zc, sizeof (zfs_cmd_t)); 3682 if (packed) 3683 kmem_free(packed, len); 3684 out: 3685 nvlist_free(nv); 3686 (void) ldi_close(zfs_lh, FREAD|FWRITE, kcred); 3687 return (rc); 3688 } 3689 3690 /* 3691 * Unmap a region in a volume. Currently only supported for zvols. 3692 * The list of extents to be freed is passed in a dkioc_free_list_t 3693 * which the caller is responsible for destroying. 3694 */ 3695 int 3696 sbd_unmap(sbd_lu_t *sl, dkioc_free_list_t *dfl) 3697 { 3698 vnode_t *vp; 3699 int unused; 3700 3701 /* Nothing to do */ 3702 if (dfl->dfl_num_exts == 0) 3703 return (0); 3704 3705 /* 3706 * TODO: unmap performance may be improved by not doing the synchronous 3707 * removal of the blocks and writing of the metadata. The 3708 * transaction is in the zil so the state should be stable. 3709 */ 3710 dfl->dfl_flags = (sl->sl_flags & SL_WRITEBACK_CACHE_DISABLE) ? 3711 DF_WAIT_SYNC : 0; 3712 3713 /* Use the data vnode we have to send a fop_ioctl(). */ 3714 vp = sl->sl_data_vp; 3715 if (vp == NULL) { 3716 cmn_err(CE_WARN, "Cannot unmap - no vnode pointer."); 3717 return (EIO); 3718 } 3719 3720 return (VOP_IOCTL(vp, DKIOCFREE, (intptr_t)dfl, FKIOCTL, kcred, 3721 &unused, NULL)); 3722 } 3723