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 * Copyright (c) 2006 Pawel Jakub Dawidek <pjd@FreeBSD.org> 23 * All rights reserved. 24 * 25 * Portions Copyright (c) 2012 Martin Matuska <mm@FreeBSD.org> 26 */ 27 28#include <sys/zfs_context.h> 29#include <sys/param.h> 30#include <sys/kernel.h> 31#include <sys/bio.h> 32#include <sys/disk.h> 33#include <sys/spa.h> 34#include <sys/spa_impl.h> 35#include <sys/vdev_impl.h> 36#include <sys/fs/zfs.h> 37#include <sys/zio.h> 38#include <geom/geom.h> 39#include <geom/geom_int.h> 40 41/* 42 * Virtual device vector for GEOM. 43 */ 44 45struct g_class zfs_vdev_class = { 46 .name = "ZFS::VDEV", 47 .version = G_VERSION, 48}; 49 50DECLARE_GEOM_CLASS(zfs_vdev_class, zfs_vdev); 51 52SYSCTL_DECL(_vfs_zfs_vdev); 53/* Don't send BIO_FLUSH. */ 54static int vdev_geom_bio_flush_disable = 0; 55TUNABLE_INT("vfs.zfs.vdev.bio_flush_disable", &vdev_geom_bio_flush_disable); 56SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, bio_flush_disable, CTLFLAG_RW, 57 &vdev_geom_bio_flush_disable, 0, "Disable BIO_FLUSH"); 58/* Don't send BIO_DELETE. */ 59static int vdev_geom_bio_delete_disable = 0; 60TUNABLE_INT("vfs.zfs.vdev.bio_delete_disable", &vdev_geom_bio_delete_disable); 61SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, bio_delete_disable, CTLFLAG_RW, 62 &vdev_geom_bio_delete_disable, 0, "Disable BIO_DELETE"); 63 64static void 65vdev_geom_orphan(struct g_consumer *cp) 66{ 67 vdev_t *vd; 68 69 g_topology_assert(); 70 71 vd = cp->private; 72 if (vd == NULL) 73 return; 74 75 /* 76 * Orphan callbacks occur from the GEOM event thread. 77 * Concurrent with this call, new I/O requests may be 78 * working their way through GEOM about to find out 79 * (only once executed by the g_down thread) that we've 80 * been orphaned from our disk provider. These I/Os 81 * must be retired before we can detach our consumer. 82 * This is most easily achieved by acquiring the 83 * SPA ZIO configuration lock as a writer, but doing 84 * so with the GEOM topology lock held would cause 85 * a lock order reversal. Instead, rely on the SPA's 86 * async removal support to invoke a close on this 87 * vdev once it is safe to do so. 88 */ 89 zfs_post_remove(vd->vdev_spa, vd); 90 vd->vdev_remove_wanted = B_TRUE; 91 spa_async_request(vd->vdev_spa, SPA_ASYNC_REMOVE); 92} 93 94static struct g_consumer * 95vdev_geom_attach(struct g_provider *pp) 96{ 97 struct g_geom *gp; 98 struct g_consumer *cp; 99 100 g_topology_assert(); 101 102 ZFS_LOG(1, "Attaching to %s.", pp->name); 103 /* Do we have geom already? No? Create one. */ 104 LIST_FOREACH(gp, &zfs_vdev_class.geom, geom) { 105 if (gp->flags & G_GEOM_WITHER) 106 continue; 107 if (strcmp(gp->name, "zfs::vdev") != 0) 108 continue; 109 break; 110 } 111 if (gp == NULL) { 112 gp = g_new_geomf(&zfs_vdev_class, "zfs::vdev"); 113 gp->orphan = vdev_geom_orphan; 114 cp = g_new_consumer(gp); 115 if (g_attach(cp, pp) != 0) { 116 g_wither_geom(gp, ENXIO); 117 return (NULL); 118 } 119 if (g_access(cp, 1, 0, 1) != 0) { 120 g_wither_geom(gp, ENXIO); 121 return (NULL); 122 } 123 ZFS_LOG(1, "Created geom and consumer for %s.", pp->name); 124 } else { 125 /* Check if we are already connected to this provider. */ 126 LIST_FOREACH(cp, &gp->consumer, consumer) { 127 if (cp->provider == pp) { 128 ZFS_LOG(1, "Found consumer for %s.", pp->name); 129 break; 130 } 131 } 132 if (cp == NULL) { 133 cp = g_new_consumer(gp); 134 if (g_attach(cp, pp) != 0) { 135 g_destroy_consumer(cp); 136 return (NULL); 137 } 138 if (g_access(cp, 1, 0, 1) != 0) { 139 g_detach(cp); 140 g_destroy_consumer(cp); 141 return (NULL); 142 } 143 ZFS_LOG(1, "Created consumer for %s.", pp->name); 144 } else { 145 if (g_access(cp, 1, 0, 1) != 0) 146 return (NULL); 147 ZFS_LOG(1, "Used existing consumer for %s.", pp->name); 148 } 149 } 150 return (cp); 151} 152 153static void 154vdev_geom_detach(void *arg, int flag __unused) 155{ 156 struct g_geom *gp; 157 struct g_consumer *cp; 158 159 g_topology_assert(); 160 cp = arg; 161 gp = cp->geom; 162 163 ZFS_LOG(1, "Closing access to %s.", cp->provider->name); 164 g_access(cp, -1, 0, -1); 165 /* Destroy consumer on last close. */ 166 if (cp->acr == 0 && cp->ace == 0) { 167 ZFS_LOG(1, "Destroyed consumer to %s.", cp->provider->name); 168 if (cp->acw > 0) 169 g_access(cp, 0, -cp->acw, 0); 170 g_detach(cp); 171 g_destroy_consumer(cp); 172 } 173 /* Destroy geom if there are no consumers left. */ 174 if (LIST_EMPTY(&gp->consumer)) { 175 ZFS_LOG(1, "Destroyed geom %s.", gp->name); 176 g_wither_geom(gp, ENXIO); 177 } 178} 179 180static uint64_t 181nvlist_get_guid(nvlist_t *list) 182{ 183 uint64_t value; 184 185 value = 0; 186 nvlist_lookup_uint64(list, ZPOOL_CONFIG_GUID, &value); 187 return (value); 188} 189 190static int 191vdev_geom_io(struct g_consumer *cp, int cmd, void *data, off_t offset, off_t size) 192{ 193 struct bio *bp; 194 u_char *p; 195 off_t off, maxio; 196 int error; 197 198 ASSERT((offset % cp->provider->sectorsize) == 0); 199 ASSERT((size % cp->provider->sectorsize) == 0); 200 201 bp = g_alloc_bio(); 202 off = offset; 203 offset += size; 204 p = data; 205 maxio = MAXPHYS - (MAXPHYS % cp->provider->sectorsize); 206 error = 0; 207 208 for (; off < offset; off += maxio, p += maxio, size -= maxio) { 209 bzero(bp, sizeof(*bp)); 210 bp->bio_cmd = cmd; 211 bp->bio_done = NULL; 212 bp->bio_offset = off; 213 bp->bio_length = MIN(size, maxio); 214 bp->bio_data = p; 215 g_io_request(bp, cp); 216 error = biowait(bp, "vdev_geom_io"); 217 if (error != 0) 218 break; 219 } 220 221 g_destroy_bio(bp); 222 return (error); 223} 224 225static void 226vdev_geom_taste_orphan(struct g_consumer *cp) 227{ 228 229 KASSERT(1 == 0, ("%s called while tasting %s.", __func__, 230 cp->provider->name)); 231} 232 233static int 234vdev_geom_read_config(struct g_consumer *cp, nvlist_t **config) 235{ 236 struct g_provider *pp; 237 vdev_label_t *label; 238 char *p, *buf; 239 size_t buflen; 240 uint64_t psize; 241 off_t offset, size; 242 uint64_t guid, state, txg; 243 int error, l, len; 244 245 g_topology_assert_not(); 246 247 pp = cp->provider; 248 ZFS_LOG(1, "Reading config from %s...", pp->name); 249 250 psize = pp->mediasize; 251 psize = P2ALIGN(psize, (uint64_t)sizeof(vdev_label_t)); 252 253 size = sizeof(*label) + pp->sectorsize - 254 ((sizeof(*label) - 1) % pp->sectorsize) - 1; 255 256 guid = 0; 257 label = kmem_alloc(size, KM_SLEEP); 258 buflen = sizeof(label->vl_vdev_phys.vp_nvlist); 259 260 *config = NULL; 261 for (l = 0; l < VDEV_LABELS; l++) { 262 263 offset = vdev_label_offset(psize, l, 0); 264 if ((offset % pp->sectorsize) != 0) 265 continue; 266 267 if (vdev_geom_io(cp, BIO_READ, label, offset, size) != 0) 268 continue; 269 buf = label->vl_vdev_phys.vp_nvlist; 270 271 if (nvlist_unpack(buf, buflen, config, 0) != 0) 272 continue; 273 274 if (nvlist_lookup_uint64(*config, ZPOOL_CONFIG_POOL_STATE, 275 &state) != 0 || state > POOL_STATE_L2CACHE) { 276 nvlist_free(*config); 277 *config = NULL; 278 continue; 279 } 280 281 if (state != POOL_STATE_SPARE && state != POOL_STATE_L2CACHE && 282 (nvlist_lookup_uint64(*config, ZPOOL_CONFIG_POOL_TXG, 283 &txg) != 0 || txg == 0)) { 284 nvlist_free(*config); 285 *config = NULL; 286 continue; 287 } 288 289 break; 290 } 291 292 kmem_free(label, size); 293 return (*config == NULL ? ENOENT : 0); 294} 295 296static void 297resize_configs(nvlist_t ***configs, uint64_t *count, uint64_t id) 298{ 299 nvlist_t **new_configs; 300 uint64_t i; 301 302 if (id < *count) 303 return; 304 new_configs = kmem_zalloc((id + 1) * sizeof(nvlist_t *), 305 KM_SLEEP); 306 for (i = 0; i < *count; i++) 307 new_configs[i] = (*configs)[i]; 308 if (*configs != NULL) 309 kmem_free(*configs, *count * sizeof(void *)); 310 *configs = new_configs; 311 *count = id + 1; 312} 313 314static void 315process_vdev_config(nvlist_t ***configs, uint64_t *count, nvlist_t *cfg, 316 const char *name, uint64_t* known_pool_guid) 317{ 318 nvlist_t *vdev_tree; 319 uint64_t pool_guid; 320 uint64_t vdev_guid, known_guid; 321 uint64_t id, txg, known_txg; 322 char *pname; 323 int i; 324 325 if (nvlist_lookup_string(cfg, ZPOOL_CONFIG_POOL_NAME, &pname) != 0 || 326 strcmp(pname, name) != 0) 327 goto ignore; 328 329 if (nvlist_lookup_uint64(cfg, ZPOOL_CONFIG_POOL_GUID, &pool_guid) != 0) 330 goto ignore; 331 332 if (nvlist_lookup_uint64(cfg, ZPOOL_CONFIG_TOP_GUID, &vdev_guid) != 0) 333 goto ignore; 334 335 if (nvlist_lookup_nvlist(cfg, ZPOOL_CONFIG_VDEV_TREE, &vdev_tree) != 0) 336 goto ignore; 337 338 if (nvlist_lookup_uint64(vdev_tree, ZPOOL_CONFIG_ID, &id) != 0) 339 goto ignore; 340 341 VERIFY(nvlist_lookup_uint64(cfg, ZPOOL_CONFIG_POOL_TXG, &txg) == 0); 342 343 if (*known_pool_guid != 0) { 344 if (pool_guid != *known_pool_guid) 345 goto ignore; 346 } else 347 *known_pool_guid = pool_guid; 348 349 resize_configs(configs, count, id); 350 351 if ((*configs)[id] != NULL) { 352 VERIFY(nvlist_lookup_uint64((*configs)[id], 353 ZPOOL_CONFIG_POOL_TXG, &known_txg) == 0); 354 if (txg <= known_txg) 355 goto ignore; 356 nvlist_free((*configs)[id]); 357 } 358 359 (*configs)[id] = cfg; 360 return; 361 362ignore: 363 nvlist_free(cfg); 364} 365 366static int 367vdev_geom_attach_taster(struct g_consumer *cp, struct g_provider *pp) 368{ 369 int error; 370 371 if (pp->flags & G_PF_WITHER) 372 return (EINVAL); 373 if (pp->sectorsize > VDEV_PAD_SIZE || !ISP2(pp->sectorsize)) 374 return (EINVAL); 375 g_attach(cp, pp); 376 error = g_access(cp, 1, 0, 0); 377 if (error != 0) 378 g_detach(cp); 379 return (error); 380} 381 382static void 383vdev_geom_detach_taster(struct g_consumer *cp) 384{ 385 g_access(cp, -1, 0, 0); 386 g_detach(cp); 387} 388 389int 390vdev_geom_read_pool_label(const char *name, 391 nvlist_t ***configs, uint64_t *count) 392{ 393 struct g_class *mp; 394 struct g_geom *gp, *zgp; 395 struct g_provider *pp; 396 struct g_consumer *zcp; 397 nvlist_t *vdev_cfg; 398 uint64_t pool_guid; 399 int error; 400 401 DROP_GIANT(); 402 g_topology_lock(); 403 404 zgp = g_new_geomf(&zfs_vdev_class, "zfs::vdev::taste"); 405 /* This orphan function should be never called. */ 406 zgp->orphan = vdev_geom_taste_orphan; 407 zcp = g_new_consumer(zgp); 408 409 *configs = NULL; 410 *count = 0; 411 pool_guid = 0; 412 LIST_FOREACH(mp, &g_classes, class) { 413 if (mp == &zfs_vdev_class) 414 continue; 415 LIST_FOREACH(gp, &mp->geom, geom) { 416 if (gp->flags & G_GEOM_WITHER) 417 continue; 418 LIST_FOREACH(pp, &gp->provider, provider) { 419 if (pp->flags & G_PF_WITHER) 420 continue; 421 if (vdev_geom_attach_taster(zcp, pp) != 0) 422 continue; 423 g_topology_unlock(); 424 error = vdev_geom_read_config(zcp, &vdev_cfg); 425 g_topology_lock(); 426 vdev_geom_detach_taster(zcp); 427 if (error) 428 continue; 429 ZFS_LOG(1, "successfully read vdev config"); 430 431 process_vdev_config(configs, count, 432 vdev_cfg, name, &pool_guid); 433 } 434 } 435 } 436 437 g_destroy_consumer(zcp); 438 g_destroy_geom(zgp); 439 g_topology_unlock(); 440 PICKUP_GIANT(); 441 442 return (*count > 0 ? 0 : ENOENT); 443} 444 445static uint64_t 446vdev_geom_read_guid(struct g_consumer *cp) 447{ 448 nvlist_t *config; 449 uint64_t guid; 450 451 g_topology_assert_not(); 452 453 guid = 0; 454 if (vdev_geom_read_config(cp, &config) == 0) { 455 guid = nvlist_get_guid(config); 456 nvlist_free(config); 457 } 458 return (guid); 459} 460 461static struct g_consumer * 462vdev_geom_attach_by_guid(uint64_t guid) 463{ 464 struct g_class *mp; 465 struct g_geom *gp, *zgp; 466 struct g_provider *pp; 467 struct g_consumer *cp, *zcp; 468 uint64_t pguid; 469 470 g_topology_assert(); 471 472 zgp = g_new_geomf(&zfs_vdev_class, "zfs::vdev::taste"); 473 /* This orphan function should be never called. */ 474 zgp->orphan = vdev_geom_taste_orphan; 475 zcp = g_new_consumer(zgp); 476 477 cp = NULL; 478 LIST_FOREACH(mp, &g_classes, class) { 479 if (mp == &zfs_vdev_class) 480 continue; 481 LIST_FOREACH(gp, &mp->geom, geom) { 482 if (gp->flags & G_GEOM_WITHER) 483 continue; 484 LIST_FOREACH(pp, &gp->provider, provider) { 485 if (vdev_geom_attach_taster(zcp, pp) != 0) 486 continue; 487 g_topology_unlock(); 488 pguid = vdev_geom_read_guid(zcp); 489 g_topology_lock(); 490 vdev_geom_detach_taster(zcp); 491 if (pguid != guid) 492 continue; 493 cp = vdev_geom_attach(pp); 494 if (cp == NULL) { 495 printf("ZFS WARNING: Unable to attach to %s.\n", 496 pp->name); 497 continue; 498 } 499 break; 500 } 501 if (cp != NULL) 502 break; 503 } 504 if (cp != NULL) 505 break; 506 } 507end: 508 g_destroy_consumer(zcp); 509 g_destroy_geom(zgp); 510 return (cp); 511} 512 513static struct g_consumer * 514vdev_geom_open_by_guid(vdev_t *vd) 515{ 516 struct g_consumer *cp; 517 char *buf; 518 size_t len; 519 520 g_topology_assert(); 521 522 ZFS_LOG(1, "Searching by guid [%ju].", (uintmax_t)vd->vdev_guid); 523 cp = vdev_geom_attach_by_guid(vd->vdev_guid); 524 if (cp != NULL) { 525 len = strlen(cp->provider->name) + strlen("/dev/") + 1; 526 buf = kmem_alloc(len, KM_SLEEP); 527 528 snprintf(buf, len, "/dev/%s", cp->provider->name); 529 spa_strfree(vd->vdev_path); 530 vd->vdev_path = buf; 531 532 ZFS_LOG(1, "Attach by guid [%ju] succeeded, provider %s.", 533 (uintmax_t)vd->vdev_guid, vd->vdev_path); 534 } else { 535 ZFS_LOG(1, "Search by guid [%ju] failed.", 536 (uintmax_t)vd->vdev_guid); 537 } 538 539 return (cp); 540} 541 542static struct g_consumer * 543vdev_geom_open_by_path(vdev_t *vd, int check_guid) 544{ 545 struct g_provider *pp; 546 struct g_consumer *cp; 547 uint64_t guid; 548 549 g_topology_assert(); 550 551 cp = NULL; 552 pp = g_provider_by_name(vd->vdev_path + sizeof("/dev/") - 1); 553 if (pp != NULL) { 554 ZFS_LOG(1, "Found provider by name %s.", vd->vdev_path); 555 cp = vdev_geom_attach(pp); 556 if (cp != NULL && check_guid && ISP2(pp->sectorsize) && 557 pp->sectorsize <= VDEV_PAD_SIZE) { 558 g_topology_unlock(); 559 guid = vdev_geom_read_guid(cp); 560 g_topology_lock(); 561 if (guid != vd->vdev_guid) { 562 vdev_geom_detach(cp, 0); 563 cp = NULL; 564 ZFS_LOG(1, "guid mismatch for provider %s: " 565 "%ju != %ju.", vd->vdev_path, 566 (uintmax_t)vd->vdev_guid, (uintmax_t)guid); 567 } else { 568 ZFS_LOG(1, "guid match for provider %s.", 569 vd->vdev_path); 570 } 571 } 572 } 573 574 return (cp); 575} 576 577static int 578vdev_geom_open(vdev_t *vd, uint64_t *psize, uint64_t *max_psize, 579 uint64_t *logical_ashift, uint64_t *physical_ashift) 580{ 581 struct g_provider *pp; 582 struct g_consumer *cp; 583 size_t bufsize; 584 int error; 585 586 /* 587 * We must have a pathname, and it must be absolute. 588 */ 589 if (vd->vdev_path == NULL || vd->vdev_path[0] != '/') { 590 vd->vdev_stat.vs_aux = VDEV_AUX_BAD_LABEL; 591 return (EINVAL); 592 } 593 594 vd->vdev_tsd = NULL; 595 596 DROP_GIANT(); 597 g_topology_lock(); 598 error = 0; 599 600 /* 601 * If we're creating or splitting a pool, just find the GEOM provider 602 * by its name and ignore GUID mismatches. 603 */ 604 if (vd->vdev_spa->spa_load_state == SPA_LOAD_NONE || 605 vd->vdev_spa->spa_splitting_newspa == B_TRUE) 606 cp = vdev_geom_open_by_path(vd, 0); 607 else { 608 cp = vdev_geom_open_by_path(vd, 1); 609 if (cp == NULL) { 610 /* 611 * The device at vd->vdev_path doesn't have the 612 * expected guid. The disks might have merely 613 * moved around so try all other GEOM providers 614 * to find one with the right guid. 615 */ 616 cp = vdev_geom_open_by_guid(vd); 617 } 618 } 619 620 if (cp == NULL) { 621 ZFS_LOG(1, "Provider %s not found.", vd->vdev_path); 622 error = ENOENT; 623 } else if (cp->provider->sectorsize > VDEV_PAD_SIZE || 624 !ISP2(cp->provider->sectorsize)) { 625 ZFS_LOG(1, "Provider %s has unsupported sectorsize.", 626 vd->vdev_path); 627 vdev_geom_detach(cp, 0); 628 error = EINVAL; 629 cp = NULL; 630 } else if (cp->acw == 0 && (spa_mode(vd->vdev_spa) & FWRITE) != 0) { 631 int i; 632 633 for (i = 0; i < 5; i++) { 634 error = g_access(cp, 0, 1, 0); 635 if (error == 0) 636 break; 637 g_topology_unlock(); 638 tsleep(vd, 0, "vdev", hz / 2); 639 g_topology_lock(); 640 } 641 if (error != 0) { 642 printf("ZFS WARNING: Unable to open %s for writing (error=%d).\n", 643 vd->vdev_path, error); 644 vdev_geom_detach(cp, 0); 645 cp = NULL; 646 } 647 } 648 g_topology_unlock(); 649 PICKUP_GIANT(); 650 if (cp == NULL) { 651 vd->vdev_stat.vs_aux = VDEV_AUX_OPEN_FAILED; 652 return (error); 653 } 654 655 cp->private = vd; 656 vd->vdev_tsd = cp; 657 pp = cp->provider; 658 659 /* 660 * Determine the actual size of the device. 661 */ 662 *max_psize = *psize = pp->mediasize; 663 664 /* 665 * Determine the device's minimum transfer size and preferred 666 * transfer size. 667 */ 668 *logical_ashift = highbit(MAX(pp->sectorsize, SPA_MINBLOCKSIZE)) - 1; 669 *physical_ashift = 0; 670 if (pp->stripesize) 671 *physical_ashift = highbit(pp->stripesize) - 1; 672 673 /* 674 * Clear the nowritecache settings, so that on a vdev_reopen() 675 * we will try again. 676 */ 677 vd->vdev_nowritecache = B_FALSE; 678 679 if (vd->vdev_physpath != NULL) 680 spa_strfree(vd->vdev_physpath); 681 bufsize = sizeof("/dev/") + strlen(pp->name); 682 vd->vdev_physpath = kmem_alloc(bufsize, KM_SLEEP); 683 snprintf(vd->vdev_physpath, bufsize, "/dev/%s", pp->name); 684 685 return (0); 686} 687 688static void 689vdev_geom_close(vdev_t *vd) 690{ 691 struct g_consumer *cp; 692 693 cp = vd->vdev_tsd; 694 if (cp == NULL) 695 return; 696 vd->vdev_tsd = NULL; 697 vd->vdev_delayed_close = B_FALSE; 698 cp->private = NULL; /* XXX locking */ 699 g_post_event(vdev_geom_detach, cp, M_WAITOK, NULL); 700} 701 702static void 703vdev_geom_io_intr(struct bio *bp) 704{ 705 vdev_t *vd; 706 zio_t *zio; 707 708 zio = bp->bio_caller1; 709 vd = zio->io_vd; 710 zio->io_error = bp->bio_error; 711 if (zio->io_error == 0 && bp->bio_resid != 0) 712 zio->io_error = EIO; 713 if (bp->bio_cmd == BIO_FLUSH && bp->bio_error == ENOTSUP) { 714 /* 715 * If we get ENOTSUP, we know that no future 716 * attempts will ever succeed. In this case we 717 * set a persistent bit so that we don't bother 718 * with the ioctl in the future. 719 */ 720 vd->vdev_nowritecache = B_TRUE; 721 } 722 if (bp->bio_cmd == BIO_DELETE && bp->bio_error == ENOTSUP) { 723 /* 724 * If we get ENOTSUP, we know that no future 725 * attempts will ever succeed. In this case we 726 * set a persistent bit so that we don't bother 727 * with the ioctl in the future. 728 */ 729 vd->vdev_notrim = B_TRUE; 730 } 731 if (zio->io_error == EIO && !vd->vdev_remove_wanted) { 732 /* 733 * If provider's error is set we assume it is being 734 * removed. 735 */ 736 if (bp->bio_to->error != 0) { 737 /* 738 * We post the resource as soon as possible, instead of 739 * when the async removal actually happens, because the 740 * DE is using this information to discard previous I/O 741 * errors. 742 */ 743 /* XXX: zfs_post_remove() can sleep. */ 744 zfs_post_remove(zio->io_spa, vd); 745 vd->vdev_remove_wanted = B_TRUE; 746 spa_async_request(zio->io_spa, SPA_ASYNC_REMOVE); 747 } else if (!vd->vdev_delayed_close) { 748 vd->vdev_delayed_close = B_TRUE; 749 } 750 } 751 g_destroy_bio(bp); 752 zio_interrupt(zio); 753} 754 755static int 756vdev_geom_io_start(zio_t *zio) 757{ 758 vdev_t *vd; 759 struct g_consumer *cp; 760 struct bio *bp; 761 int error; 762 763 vd = zio->io_vd; 764 765 if (zio->io_type == ZIO_TYPE_IOCTL) { 766 /* XXPOLICY */ 767 if (!vdev_readable(vd)) { 768 zio->io_error = ENXIO; 769 return (ZIO_PIPELINE_CONTINUE); 770 } 771 772 switch (zio->io_cmd) { 773 case DKIOCFLUSHWRITECACHE: 774 if (zfs_nocacheflush || vdev_geom_bio_flush_disable) 775 break; 776 if (vd->vdev_nowritecache) { 777 zio->io_error = ENOTSUP; 778 break; 779 } 780 goto sendreq; 781 case DKIOCTRIM: 782 if (vdev_geom_bio_delete_disable) 783 break; 784 if (vd->vdev_notrim) { 785 zio->io_error = ENOTSUP; 786 break; 787 } 788 goto sendreq; 789 default: 790 zio->io_error = ENOTSUP; 791 } 792 793 return (ZIO_PIPELINE_CONTINUE); 794 } 795sendreq: 796 cp = vd->vdev_tsd; 797 if (cp == NULL) { 798 zio->io_error = ENXIO; 799 return (ZIO_PIPELINE_CONTINUE); 800 } 801 bp = g_alloc_bio(); 802 bp->bio_caller1 = zio; 803 switch (zio->io_type) { 804 case ZIO_TYPE_READ: 805 case ZIO_TYPE_WRITE: 806 bp->bio_cmd = zio->io_type == ZIO_TYPE_READ ? BIO_READ : BIO_WRITE; 807 bp->bio_data = zio->io_data; 808 bp->bio_offset = zio->io_offset; 809 bp->bio_length = zio->io_size; 810 break; 811 case ZIO_TYPE_IOCTL: 812 switch (zio->io_cmd) { 813 case DKIOCFLUSHWRITECACHE: 814 bp->bio_cmd = BIO_FLUSH; 815 bp->bio_flags |= BIO_ORDERED; 816 bp->bio_data = NULL; 817 bp->bio_offset = cp->provider->mediasize; 818 bp->bio_length = 0; 819 break; 820 case DKIOCTRIM: 821 bp->bio_cmd = BIO_DELETE; 822 bp->bio_data = NULL; 823 bp->bio_offset = zio->io_offset; 824 bp->bio_length = zio->io_size; 825 break; 826 } 827 break; 828 } 829 bp->bio_done = vdev_geom_io_intr; 830 831 g_io_request(bp, cp); 832 833 return (ZIO_PIPELINE_STOP); 834} 835 836static void 837vdev_geom_io_done(zio_t *zio) 838{ 839} 840 841static void 842vdev_geom_hold(vdev_t *vd) 843{ 844} 845 846static void 847vdev_geom_rele(vdev_t *vd) 848{ 849} 850 851vdev_ops_t vdev_geom_ops = { 852 vdev_geom_open, 853 vdev_geom_close, 854 vdev_default_asize, 855 vdev_geom_io_start, 856 vdev_geom_io_done, 857 NULL, 858 vdev_geom_hold, 859 vdev_geom_rele, 860 VDEV_TYPE_DISK, /* name of this vdev type */ 861 B_TRUE /* leaf vdev */ 862}; 863