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.
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.
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]
22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright (c) 2013 by Delphix. All rights reserved.
24 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
25 * Copyright 2013 Joyent, Inc. All rights reserved.
28 #include <sys/zfs_context.h>
29 #include <sys/spa_impl.h>
30 #include <sys/refcount.h>
31 #include <sys/vdev_disk.h>
32 #include <sys/vdev_impl.h>
33 #include <sys/fs/zfs.h>
35 #include <sys/sunldi.h>
36 #include <sys/efi_partition.h>
37 #include <sys/fm/fs/zfs.h>
40 * Virtual device vector for disks.
43 extern ldi_ident_t zfs_li
;
46 vdev_disk_hold(vdev_t
*vd
)
51 ASSERT(spa_config_held(vd
->vdev_spa
, SCL_STATE
, RW_WRITER
));
54 * We must have a pathname, and it must be absolute.
56 if (vd
->vdev_path
== NULL
|| vd
->vdev_path
[0] != '/')
60 * Only prefetch path and devid info if the device has
63 if (vd
->vdev_tsd
!= NULL
)
66 if (vd
->vdev_wholedisk
== -1ULL) {
67 size_t len
= strlen(vd
->vdev_path
) + 3;
68 char *buf
= kmem_alloc(len
, KM_SLEEP
);
70 (void) snprintf(buf
, len
, "%ss0", vd
->vdev_path
);
72 (void) ldi_vp_from_name(buf
, &vd
->vdev_name_vp
);
76 if (vd
->vdev_name_vp
== NULL
)
77 (void) ldi_vp_from_name(vd
->vdev_path
, &vd
->vdev_name_vp
);
79 if (vd
->vdev_devid
!= NULL
&&
80 ddi_devid_str_decode(vd
->vdev_devid
, &devid
, &minor
) == 0) {
81 (void) ldi_vp_from_devid(devid
, minor
, &vd
->vdev_devid_vp
);
82 ddi_devid_str_free(minor
);
83 ddi_devid_free(devid
);
88 vdev_disk_rele(vdev_t
*vd
)
90 ASSERT(spa_config_held(vd
->vdev_spa
, SCL_STATE
, RW_WRITER
));
92 if (vd
->vdev_name_vp
) {
93 VN_RELE_ASYNC(vd
->vdev_name_vp
,
94 dsl_pool_vnrele_taskq(vd
->vdev_spa
->spa_dsl_pool
));
95 vd
->vdev_name_vp
= NULL
;
97 if (vd
->vdev_devid_vp
) {
98 VN_RELE_ASYNC(vd
->vdev_devid_vp
,
99 dsl_pool_vnrele_taskq(vd
->vdev_spa
->spa_dsl_pool
));
100 vd
->vdev_devid_vp
= NULL
;
105 vdev_disk_get_space(vdev_t
*vd
, uint64_t capacity
, uint_t blksz
)
107 ASSERT(vd
->vdev_wholedisk
);
109 vdev_disk_t
*dvd
= vd
->vdev_tsd
;
112 uint64_t avail_space
= 0;
113 int efisize
= EFI_LABEL_SIZE
* 2;
115 dk_ioc
.dki_data
= kmem_alloc(efisize
, KM_SLEEP
);
117 dk_ioc
.dki_length
= efisize
;
118 dk_ioc
.dki_data_64
= (uint64_t)(uintptr_t)dk_ioc
.dki_data
;
119 efi
= dk_ioc
.dki_data
;
121 if (ldi_ioctl(dvd
->vd_lh
, DKIOCGETEFI
, (intptr_t)&dk_ioc
,
122 FKIOCTL
, kcred
, NULL
) == 0) {
123 uint64_t efi_altern_lba
= LE_64(efi
->efi_gpt_AlternateLBA
);
125 zfs_dbgmsg("vdev %s, capacity %llu, altern lba %llu",
126 vd
->vdev_path
, capacity
, efi_altern_lba
);
127 if (capacity
> efi_altern_lba
)
128 avail_space
= (capacity
- efi_altern_lba
) * blksz
;
130 kmem_free(dk_ioc
.dki_data
, efisize
);
131 return (avail_space
);
135 * We want to be loud in DEBUG kernels when DKIOCGMEDIAINFOEXT fails, or when
136 * even a fallback to DKIOCGMEDIAINFO fails.
139 #define VDEV_DEBUG(...) cmn_err(CE_NOTE, __VA_ARGS__)
141 #define VDEV_DEBUG(...) /* Nothing... */
145 vdev_disk_open(vdev_t
*vd
, uint64_t *psize
, uint64_t *max_psize
,
148 spa_t
*spa
= vd
->vdev_spa
;
151 struct dk_minfo_ext ude
;
154 struct dk_minfo_ext
*dkmext
= &dks
.ude
;
155 struct dk_minfo
*dkm
= &dks
.ud
;
159 boolean_t validate_devid
= B_FALSE
;
161 uint64_t capacity
= 0, blksz
= 0, pbsize
;
164 * We must have a pathname, and it must be absolute.
166 if (vd
->vdev_path
== NULL
|| vd
->vdev_path
[0] != '/') {
167 vd
->vdev_stat
.vs_aux
= VDEV_AUX_BAD_LABEL
;
168 return (SET_ERROR(EINVAL
));
172 * Reopen the device if it's not currently open. Otherwise,
173 * just update the physical size of the device.
175 if (vd
->vdev_tsd
!= NULL
) {
176 ASSERT(vd
->vdev_reopening
);
181 dvd
= vd
->vdev_tsd
= kmem_zalloc(sizeof (vdev_disk_t
), KM_SLEEP
);
184 * When opening a disk device, we want to preserve the user's original
185 * intent. We always want to open the device by the path the user gave
186 * us, even if it is one of multiple paths to the same device. But we
187 * also want to be able to survive disks being removed/recabled.
188 * Therefore the sequence of opening devices is:
190 * 1. Try opening the device by path. For legacy pools without the
191 * 'whole_disk' property, attempt to fix the path by appending 's0'.
193 * 2. If the devid of the device matches the stored value, return
196 * 3. Otherwise, the device may have moved. Try opening the device
197 * by the devid instead.
199 if (vd
->vdev_devid
!= NULL
) {
200 if (ddi_devid_str_decode(vd
->vdev_devid
, &dvd
->vd_devid
,
201 &dvd
->vd_minor
) != 0) {
202 vd
->vdev_stat
.vs_aux
= VDEV_AUX_BAD_LABEL
;
203 return (SET_ERROR(EINVAL
));
207 error
= EINVAL
; /* presume failure */
209 if (vd
->vdev_path
!= NULL
) {
211 if (vd
->vdev_wholedisk
== -1ULL) {
212 size_t len
= strlen(vd
->vdev_path
) + 3;
213 char *buf
= kmem_alloc(len
, KM_SLEEP
);
216 (void) snprintf(buf
, len
, "%ss0", vd
->vdev_path
);
218 if (ldi_open_by_name(buf
, spa_mode(spa
), kcred
,
220 spa_strfree(vd
->vdev_path
);
222 vd
->vdev_wholedisk
= 1ULL;
223 (void) ldi_close(lh
, spa_mode(spa
), kcred
);
229 error
= ldi_open_by_name(vd
->vdev_path
, spa_mode(spa
), kcred
,
230 &dvd
->vd_lh
, zfs_li
);
233 * Compare the devid to the stored value.
235 if (error
== 0 && vd
->vdev_devid
!= NULL
&&
236 ldi_get_devid(dvd
->vd_lh
, &devid
) == 0) {
237 if (ddi_devid_compare(devid
, dvd
->vd_devid
) != 0) {
238 error
= SET_ERROR(EINVAL
);
239 (void) ldi_close(dvd
->vd_lh
, spa_mode(spa
),
243 ddi_devid_free(devid
);
247 * If we succeeded in opening the device, but 'vdev_wholedisk'
248 * is not yet set, then this must be a slice.
250 if (error
== 0 && vd
->vdev_wholedisk
== -1ULL)
251 vd
->vdev_wholedisk
= 0;
255 * If we were unable to open by path, or the devid check fails, open by
258 if (error
!= 0 && vd
->vdev_devid
!= NULL
) {
259 error
= ldi_open_by_devid(dvd
->vd_devid
, dvd
->vd_minor
,
260 spa_mode(spa
), kcred
, &dvd
->vd_lh
, zfs_li
);
264 * If all else fails, then try opening by physical path (if available)
265 * or the logical path (if we failed due to the devid check). While not
266 * as reliable as the devid, this will give us something, and the higher
267 * level vdev validation will prevent us from opening the wrong device.
270 if (vd
->vdev_devid
!= NULL
)
271 validate_devid
= B_TRUE
;
273 if (vd
->vdev_physpath
!= NULL
&&
274 (dev
= ddi_pathname_to_dev_t(vd
->vdev_physpath
)) != NODEV
)
275 error
= ldi_open_by_dev(&dev
, OTYP_BLK
, spa_mode(spa
),
276 kcred
, &dvd
->vd_lh
, zfs_li
);
279 * Note that we don't support the legacy auto-wholedisk support
280 * as above. This hasn't been used in a very long time and we
281 * don't need to propagate its oddities to this edge condition.
283 if (error
&& vd
->vdev_path
!= NULL
)
284 error
= ldi_open_by_name(vd
->vdev_path
, spa_mode(spa
),
285 kcred
, &dvd
->vd_lh
, zfs_li
);
289 vd
->vdev_stat
.vs_aux
= VDEV_AUX_OPEN_FAILED
;
294 * Now that the device has been successfully opened, update the devid
297 if (validate_devid
&& spa_writeable(spa
) &&
298 ldi_get_devid(dvd
->vd_lh
, &devid
) == 0) {
299 if (ddi_devid_compare(devid
, dvd
->vd_devid
) != 0) {
302 vd_devid
= ddi_devid_str_encode(devid
, dvd
->vd_minor
);
303 zfs_dbgmsg("vdev %s: update devid from %s, "
304 "to %s", vd
->vdev_path
, vd
->vdev_devid
, vd_devid
);
305 spa_strfree(vd
->vdev_devid
);
306 vd
->vdev_devid
= spa_strdup(vd_devid
);
307 ddi_devid_str_free(vd_devid
);
309 ddi_devid_free(devid
);
313 * Once a device is opened, verify that the physical device path (if
314 * available) is up to date.
316 if (ldi_get_dev(dvd
->vd_lh
, &dev
) == 0 &&
317 ldi_get_otyp(dvd
->vd_lh
, &otyp
) == 0) {
318 char *physpath
, *minorname
;
320 physpath
= kmem_alloc(MAXPATHLEN
, KM_SLEEP
);
322 if (ddi_dev_pathname(dev
, otyp
, physpath
) == 0 &&
323 ldi_get_minor_name(dvd
->vd_lh
, &minorname
) == 0 &&
324 (vd
->vdev_physpath
== NULL
||
325 strcmp(vd
->vdev_physpath
, physpath
) != 0)) {
326 if (vd
->vdev_physpath
)
327 spa_strfree(vd
->vdev_physpath
);
328 (void) strlcat(physpath
, ":", MAXPATHLEN
);
329 (void) strlcat(physpath
, minorname
, MAXPATHLEN
);
330 vd
->vdev_physpath
= spa_strdup(physpath
);
333 kmem_free(minorname
, strlen(minorname
) + 1);
334 kmem_free(physpath
, MAXPATHLEN
);
339 * Determine the actual size of the device.
341 if (ldi_get_size(dvd
->vd_lh
, psize
) != 0) {
342 vd
->vdev_stat
.vs_aux
= VDEV_AUX_OPEN_FAILED
;
343 return (SET_ERROR(EINVAL
));
349 * Determine the device's minimum transfer size.
350 * If the ioctl isn't supported, assume DEV_BSIZE.
352 if ((error
= ldi_ioctl(dvd
->vd_lh
, DKIOCGMEDIAINFOEXT
,
353 (intptr_t)dkmext
, FKIOCTL
, kcred
, NULL
)) == 0) {
354 capacity
= dkmext
->dki_capacity
- 1;
355 blksz
= dkmext
->dki_lbsize
;
356 pbsize
= dkmext
->dki_pbsize
;
357 } else if ((error
= ldi_ioctl(dvd
->vd_lh
, DKIOCGMEDIAINFO
,
358 (intptr_t)dkm
, FKIOCTL
, kcred
, NULL
)) == 0) {
360 "vdev_disk_open(\"%s\"): fallback to DKIOCGMEDIAINFO\n",
362 capacity
= dkm
->dki_capacity
- 1;
363 blksz
= dkm
->dki_lbsize
;
366 VDEV_DEBUG("vdev_disk_open(\"%s\"): "
367 "both DKIOCGMEDIAINFO{,EXT} calls failed, %d\n",
368 vd
->vdev_path
, error
);
372 *ashift
= highbit(MAX(pbsize
, SPA_MINBLOCKSIZE
)) - 1;
374 if (vd
->vdev_wholedisk
== 1) {
379 * If we have the capability to expand, we'd have
380 * found out via success from DKIOCGMEDIAINFO{,EXT}.
381 * Adjust max_psize upward accordingly since we know
382 * we own the whole disk now.
384 *max_psize
+= vdev_disk_get_space(vd
, capacity
, blksz
);
385 zfs_dbgmsg("capacity change: vdev %s, psize %llu, "
386 "max_psize %llu", vd
->vdev_path
, *psize
,
391 * Since we own the whole disk, try to enable disk write
392 * caching. We ignore errors because it's OK if we can't do it.
394 (void) ldi_ioctl(dvd
->vd_lh
, DKIOCSETWCE
, (intptr_t)&wce
,
395 FKIOCTL
, kcred
, NULL
);
399 * Clear the nowritecache bit, so that on a vdev_reopen() we will
402 vd
->vdev_nowritecache
= B_FALSE
;
408 vdev_disk_close(vdev_t
*vd
)
410 vdev_disk_t
*dvd
= vd
->vdev_tsd
;
412 if (vd
->vdev_reopening
|| dvd
== NULL
)
415 if (dvd
->vd_minor
!= NULL
)
416 ddi_devid_str_free(dvd
->vd_minor
);
418 if (dvd
->vd_devid
!= NULL
)
419 ddi_devid_free(dvd
->vd_devid
);
421 if (dvd
->vd_lh
!= NULL
)
422 (void) ldi_close(dvd
->vd_lh
, spa_mode(vd
->vdev_spa
), kcred
);
424 vd
->vdev_delayed_close
= B_FALSE
;
425 kmem_free(dvd
, sizeof (vdev_disk_t
));
430 vdev_disk_physio(vdev_t
*vd
, caddr_t data
,
431 size_t size
, uint64_t offset
, int flags
, boolean_t isdump
)
433 vdev_disk_t
*dvd
= vd
->vdev_tsd
;
435 ASSERT(vd
->vdev_ops
== &vdev_disk_ops
);
438 * If in the context of an active crash dump, use the ldi_dump(9F)
439 * call instead of ldi_strategy(9F) as usual.
442 ASSERT3P(dvd
, !=, NULL
);
443 return (ldi_dump(dvd
->vd_lh
, data
, lbtodb(offset
),
447 return (vdev_disk_ldi_physio(dvd
->vd_lh
, data
, size
, offset
, flags
));
451 vdev_disk_ldi_physio(ldi_handle_t vd_lh
, caddr_t data
,
452 size_t size
, uint64_t offset
, int flags
)
458 return (SET_ERROR(EINVAL
));
460 ASSERT(flags
& B_READ
|| flags
& B_WRITE
);
462 bp
= getrbuf(KM_SLEEP
);
463 bp
->b_flags
= flags
| B_BUSY
| B_NOCACHE
| B_FAILFAST
;
465 bp
->b_un
.b_addr
= (void *)data
;
466 bp
->b_lblkno
= lbtodb(offset
);
467 bp
->b_bufsize
= size
;
469 error
= ldi_strategy(vd_lh
, bp
);
471 if ((error
= biowait(bp
)) == 0 && bp
->b_resid
!= 0)
472 error
= SET_ERROR(EIO
);
479 vdev_disk_io_intr(buf_t
*bp
)
481 vdev_buf_t
*vb
= (vdev_buf_t
*)bp
;
482 zio_t
*zio
= vb
->vb_io
;
485 * The rest of the zio stack only deals with EIO, ECKSUM, and ENXIO.
486 * Rather than teach the rest of the stack about other error
487 * possibilities (EFAULT, etc), we normalize the error value here.
489 zio
->io_error
= (geterror(bp
) != 0 ? EIO
: 0);
491 if (zio
->io_error
== 0 && bp
->b_resid
!= 0)
492 zio
->io_error
= SET_ERROR(EIO
);
494 kmem_free(vb
, sizeof (vdev_buf_t
));
500 vdev_disk_ioctl_free(zio_t
*zio
)
502 kmem_free(zio
->io_vsd
, sizeof (struct dk_callback
));
505 static const zio_vsd_ops_t vdev_disk_vsd_ops
= {
506 vdev_disk_ioctl_free
,
507 zio_vsd_default_cksum_report
511 vdev_disk_ioctl_done(void *zio_arg
, int error
)
513 zio_t
*zio
= zio_arg
;
515 zio
->io_error
= error
;
521 vdev_disk_io_start(zio_t
*zio
)
523 vdev_t
*vd
= zio
->io_vd
;
524 vdev_disk_t
*dvd
= vd
->vdev_tsd
;
526 struct dk_callback
*dkc
;
530 if (zio
->io_type
== ZIO_TYPE_IOCTL
) {
532 if (!vdev_readable(vd
)) {
533 zio
->io_error
= SET_ERROR(ENXIO
);
534 return (ZIO_PIPELINE_CONTINUE
);
537 switch (zio
->io_cmd
) {
539 case DKIOCFLUSHWRITECACHE
:
541 if (zfs_nocacheflush
)
544 if (vd
->vdev_nowritecache
) {
545 zio
->io_error
= SET_ERROR(ENOTSUP
);
549 zio
->io_vsd
= dkc
= kmem_alloc(sizeof (*dkc
), KM_SLEEP
);
550 zio
->io_vsd_ops
= &vdev_disk_vsd_ops
;
552 dkc
->dkc_callback
= vdev_disk_ioctl_done
;
553 dkc
->dkc_flag
= FLUSH_VOLATILE
;
554 dkc
->dkc_cookie
= zio
;
556 error
= ldi_ioctl(dvd
->vd_lh
, zio
->io_cmd
,
557 (uintptr_t)dkc
, FKIOCTL
, kcred
, NULL
);
561 * The ioctl will be done asychronously,
562 * and will call vdev_disk_ioctl_done()
565 return (ZIO_PIPELINE_STOP
);
568 if (error
== ENOTSUP
|| error
== ENOTTY
) {
570 * If we get ENOTSUP or ENOTTY, we know that
571 * no future attempts will ever succeed.
572 * In this case we set a persistent bit so
573 * that we don't bother with the ioctl in the
576 vd
->vdev_nowritecache
= B_TRUE
;
578 zio
->io_error
= error
;
583 zio
->io_error
= SET_ERROR(ENOTSUP
);
586 return (ZIO_PIPELINE_CONTINUE
);
589 vb
= kmem_alloc(sizeof (vdev_buf_t
), KM_SLEEP
);
595 bp
->b_flags
= B_BUSY
| B_NOCACHE
|
596 (zio
->io_type
== ZIO_TYPE_READ
? B_READ
: B_WRITE
);
597 if (!(zio
->io_flags
& (ZIO_FLAG_IO_RETRY
| ZIO_FLAG_TRYHARD
)))
598 bp
->b_flags
|= B_FAILFAST
;
599 bp
->b_bcount
= zio
->io_size
;
600 bp
->b_un
.b_addr
= zio
->io_data
;
601 bp
->b_lblkno
= lbtodb(zio
->io_offset
);
602 bp
->b_bufsize
= zio
->io_size
;
603 bp
->b_iodone
= (int (*)())vdev_disk_io_intr
;
605 /* ldi_strategy() will return non-zero only on programming errors */
606 VERIFY(ldi_strategy(dvd
->vd_lh
, bp
) == 0);
608 return (ZIO_PIPELINE_STOP
);
612 vdev_disk_io_done(zio_t
*zio
)
614 vdev_t
*vd
= zio
->io_vd
;
617 * If the device returned EIO, then attempt a DKIOCSTATE ioctl to see if
618 * the device has been removed. If this is the case, then we trigger an
619 * asynchronous removal of the device. Otherwise, probe the device and
620 * make sure it's still accessible.
622 if (zio
->io_error
== EIO
&& !vd
->vdev_remove_wanted
) {
623 vdev_disk_t
*dvd
= vd
->vdev_tsd
;
624 int state
= DKIO_NONE
;
626 if (ldi_ioctl(dvd
->vd_lh
, DKIOCSTATE
, (intptr_t)&state
,
627 FKIOCTL
, kcred
, NULL
) == 0 && state
!= DKIO_INSERTED
) {
629 * We post the resource as soon as possible, instead of
630 * when the async removal actually happens, because the
631 * DE is using this information to discard previous I/O
634 zfs_post_remove(zio
->io_spa
, vd
);
635 vd
->vdev_remove_wanted
= B_TRUE
;
636 spa_async_request(zio
->io_spa
, SPA_ASYNC_REMOVE
);
637 } else if (!vd
->vdev_delayed_close
) {
638 vd
->vdev_delayed_close
= B_TRUE
;
643 vdev_ops_t vdev_disk_ops
= {
652 VDEV_TYPE_DISK
, /* name of this vdev type */
653 B_TRUE
/* leaf vdev */
657 * Given the root disk device devid or pathname, read the label from
658 * the device, and construct a configuration nvlist.
661 vdev_disk_read_rootlabel(char *devpath
, char *devid
, nvlist_t
**config
)
667 ddi_devid_t tmpdevid
;
672 * Read the device label and build the nvlist.
674 if (devid
!= NULL
&& ddi_devid_str_decode(devid
, &tmpdevid
,
676 error
= ldi_open_by_devid(tmpdevid
, minor_name
,
677 FREAD
, kcred
, &vd_lh
, zfs_li
);
678 ddi_devid_free(tmpdevid
);
679 ddi_devid_str_free(minor_name
);
682 if (error
&& (error
= ldi_open_by_name(devpath
, FREAD
, kcred
, &vd_lh
,
686 if (ldi_get_size(vd_lh
, &s
)) {
687 (void) ldi_close(vd_lh
, FREAD
, kcred
);
688 return (SET_ERROR(EIO
));
691 size
= P2ALIGN_TYPED(s
, sizeof (vdev_label_t
), uint64_t);
692 label
= kmem_alloc(sizeof (vdev_label_t
), KM_SLEEP
);
695 for (l
= 0; l
< VDEV_LABELS
; l
++) {
696 uint64_t offset
, state
, txg
= 0;
698 /* read vdev label */
699 offset
= vdev_label_offset(size
, l
, 0);
700 if (vdev_disk_ldi_physio(vd_lh
, (caddr_t
)label
,
701 VDEV_SKIP_SIZE
+ VDEV_PHYS_SIZE
, offset
, B_READ
) != 0)
704 if (nvlist_unpack(label
->vl_vdev_phys
.vp_nvlist
,
705 sizeof (label
->vl_vdev_phys
.vp_nvlist
), config
, 0) != 0) {
710 if (nvlist_lookup_uint64(*config
, ZPOOL_CONFIG_POOL_STATE
,
711 &state
) != 0 || state
>= POOL_STATE_DESTROYED
) {
712 nvlist_free(*config
);
717 if (nvlist_lookup_uint64(*config
, ZPOOL_CONFIG_POOL_TXG
,
718 &txg
) != 0 || txg
== 0) {
719 nvlist_free(*config
);
727 kmem_free(label
, sizeof (vdev_label_t
));
728 (void) ldi_close(vd_lh
, FREAD
, kcred
);
730 error
= SET_ERROR(EIDRM
);