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 2010 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
26 #include <sys/zfs_context.h>
27 #include <sys/spa_impl.h>
28 #include <sys/refcount.h>
29 #include <sys/vdev_disk.h>
30 #include <sys/vdev_impl.h>
31 #include <sys/fs/zfs.h>
33 #include <sys/sunldi.h>
34 #include <sys/fm/fs/zfs.h>
37 * Virtual device vector for disks.
40 extern ldi_ident_t zfs_li
;
42 typedef struct vdev_disk_buf
{
48 vdev_disk_hold(vdev_t
*vd
)
53 ASSERT(spa_config_held(vd
->vdev_spa
, SCL_STATE
, RW_WRITER
));
56 * We must have a pathname, and it must be absolute.
58 if (vd
->vdev_path
== NULL
|| vd
->vdev_path
[0] != '/')
62 * Only prefetch path and devid info if the device has
65 if (vd
->vdev_tsd
!= NULL
)
68 if (vd
->vdev_wholedisk
== -1ULL) {
69 size_t len
= strlen(vd
->vdev_path
) + 3;
70 char *buf
= kmem_alloc(len
, KM_SLEEP
);
72 (void) snprintf(buf
, len
, "%ss0", vd
->vdev_path
);
74 (void) ldi_vp_from_name(buf
, &vd
->vdev_name_vp
);
78 if (vd
->vdev_name_vp
== NULL
)
79 (void) ldi_vp_from_name(vd
->vdev_path
, &vd
->vdev_name_vp
);
81 if (vd
->vdev_devid
!= NULL
&&
82 ddi_devid_str_decode(vd
->vdev_devid
, &devid
, &minor
) == 0) {
83 (void) ldi_vp_from_devid(devid
, minor
, &vd
->vdev_devid_vp
);
84 ddi_devid_str_free(minor
);
85 ddi_devid_free(devid
);
90 vdev_disk_rele(vdev_t
*vd
)
92 ASSERT(spa_config_held(vd
->vdev_spa
, SCL_STATE
, RW_WRITER
));
94 if (vd
->vdev_name_vp
) {
95 VN_RELE_ASYNC(vd
->vdev_name_vp
,
96 dsl_pool_vnrele_taskq(vd
->vdev_spa
->spa_dsl_pool
));
97 vd
->vdev_name_vp
= NULL
;
99 if (vd
->vdev_devid_vp
) {
100 VN_RELE_ASYNC(vd
->vdev_devid_vp
,
101 dsl_pool_vnrele_taskq(vd
->vdev_spa
->spa_dsl_pool
));
102 vd
->vdev_devid_vp
= NULL
;
107 vdev_disk_open(vdev_t
*vd
, uint64_t *psize
, uint64_t *ashift
)
109 spa_t
*spa
= vd
->vdev_spa
;
117 * We must have a pathname, and it must be absolute.
119 if (vd
->vdev_path
== NULL
|| vd
->vdev_path
[0] != '/') {
120 vd
->vdev_stat
.vs_aux
= VDEV_AUX_BAD_LABEL
;
125 * Reopen the device if it's not currently open. Otherwise,
126 * just update the physical size of the device.
128 if (vd
->vdev_tsd
!= NULL
) {
129 ASSERT(vd
->vdev_reopening
);
134 dvd
= vd
->vdev_tsd
= kmem_zalloc(sizeof (vdev_disk_t
), KM_SLEEP
);
137 * When opening a disk device, we want to preserve the user's original
138 * intent. We always want to open the device by the path the user gave
139 * us, even if it is one of multiple paths to the save device. But we
140 * also want to be able to survive disks being removed/recabled.
141 * Therefore the sequence of opening devices is:
143 * 1. Try opening the device by path. For legacy pools without the
144 * 'whole_disk' property, attempt to fix the path by appending 's0'.
146 * 2. If the devid of the device matches the stored value, return
149 * 3. Otherwise, the device may have moved. Try opening the device
150 * by the devid instead.
152 if (vd
->vdev_devid
!= NULL
) {
153 if (ddi_devid_str_decode(vd
->vdev_devid
, &dvd
->vd_devid
,
154 &dvd
->vd_minor
) != 0) {
155 vd
->vdev_stat
.vs_aux
= VDEV_AUX_BAD_LABEL
;
160 error
= EINVAL
; /* presume failure */
162 if (vd
->vdev_path
!= NULL
) {
165 if (vd
->vdev_wholedisk
== -1ULL) {
166 size_t len
= strlen(vd
->vdev_path
) + 3;
167 char *buf
= kmem_alloc(len
, KM_SLEEP
);
170 (void) snprintf(buf
, len
, "%ss0", vd
->vdev_path
);
172 if (ldi_open_by_name(buf
, spa_mode(spa
), kcred
,
174 spa_strfree(vd
->vdev_path
);
176 vd
->vdev_wholedisk
= 1ULL;
177 (void) ldi_close(lh
, spa_mode(spa
), kcred
);
183 error
= ldi_open_by_name(vd
->vdev_path
, spa_mode(spa
), kcred
,
184 &dvd
->vd_lh
, zfs_li
);
187 * Compare the devid to the stored value.
189 if (error
== 0 && vd
->vdev_devid
!= NULL
&&
190 ldi_get_devid(dvd
->vd_lh
, &devid
) == 0) {
191 if (ddi_devid_compare(devid
, dvd
->vd_devid
) != 0) {
193 (void) ldi_close(dvd
->vd_lh
, spa_mode(spa
),
197 ddi_devid_free(devid
);
201 * If we succeeded in opening the device, but 'vdev_wholedisk'
202 * is not yet set, then this must be a slice.
204 if (error
== 0 && vd
->vdev_wholedisk
== -1ULL)
205 vd
->vdev_wholedisk
= 0;
209 * If we were unable to open by path, or the devid check fails, open by
212 if (error
!= 0 && vd
->vdev_devid
!= NULL
)
213 error
= ldi_open_by_devid(dvd
->vd_devid
, dvd
->vd_minor
,
214 spa_mode(spa
), kcred
, &dvd
->vd_lh
, zfs_li
);
217 * If all else fails, then try opening by physical path (if available)
218 * or the logical path (if we failed due to the devid check). While not
219 * as reliable as the devid, this will give us something, and the higher
220 * level vdev validation will prevent us from opening the wrong device.
223 if (vd
->vdev_physpath
!= NULL
&&
224 (dev
= ddi_pathname_to_dev_t(vd
->vdev_physpath
)) != NODEV
)
225 error
= ldi_open_by_dev(&dev
, OTYP_BLK
, spa_mode(spa
),
226 kcred
, &dvd
->vd_lh
, zfs_li
);
229 * Note that we don't support the legacy auto-wholedisk support
230 * as above. This hasn't been used in a very long time and we
231 * don't need to propagate its oddities to this edge condition.
233 if (error
&& vd
->vdev_path
!= NULL
)
234 error
= ldi_open_by_name(vd
->vdev_path
, spa_mode(spa
),
235 kcred
, &dvd
->vd_lh
, zfs_li
);
239 vd
->vdev_stat
.vs_aux
= VDEV_AUX_OPEN_FAILED
;
244 * Once a device is opened, verify that the physical device path (if
245 * available) is up to date.
247 if (ldi_get_dev(dvd
->vd_lh
, &dev
) == 0 &&
248 ldi_get_otyp(dvd
->vd_lh
, &otyp
) == 0) {
249 char *physpath
, *minorname
;
251 physpath
= kmem_alloc(MAXPATHLEN
, KM_SLEEP
);
253 if (ddi_dev_pathname(dev
, otyp
, physpath
) == 0 &&
254 ldi_get_minor_name(dvd
->vd_lh
, &minorname
) == 0 &&
255 (vd
->vdev_physpath
== NULL
||
256 strcmp(vd
->vdev_physpath
, physpath
) != 0)) {
257 if (vd
->vdev_physpath
)
258 spa_strfree(vd
->vdev_physpath
);
259 (void) strlcat(physpath
, ":", MAXPATHLEN
);
260 (void) strlcat(physpath
, minorname
, MAXPATHLEN
);
261 vd
->vdev_physpath
= spa_strdup(physpath
);
264 kmem_free(minorname
, strlen(minorname
) + 1);
265 kmem_free(physpath
, MAXPATHLEN
);
270 * Determine the actual size of the device.
272 if (ldi_get_size(dvd
->vd_lh
, psize
) != 0) {
273 vd
->vdev_stat
.vs_aux
= VDEV_AUX_OPEN_FAILED
;
278 * If we own the whole disk, try to enable disk write caching.
279 * We ignore errors because it's OK if we can't do it.
281 if (vd
->vdev_wholedisk
== 1) {
283 (void) ldi_ioctl(dvd
->vd_lh
, DKIOCSETWCE
, (intptr_t)&wce
,
284 FKIOCTL
, kcred
, NULL
);
288 * Determine the device's minimum transfer size.
289 * If the ioctl isn't supported, assume DEV_BSIZE.
291 if (ldi_ioctl(dvd
->vd_lh
, DKIOCGMEDIAINFO
, (intptr_t)&dkm
,
292 FKIOCTL
, kcred
, NULL
) != 0)
293 dkm
.dki_lbsize
= DEV_BSIZE
;
295 *ashift
= highbit(MAX(dkm
.dki_lbsize
, SPA_MINBLOCKSIZE
)) - 1;
298 * Clear the nowritecache bit, so that on a vdev_reopen() we will
301 vd
->vdev_nowritecache
= B_FALSE
;
307 vdev_disk_close(vdev_t
*vd
)
309 vdev_disk_t
*dvd
= vd
->vdev_tsd
;
311 if (vd
->vdev_reopening
|| dvd
== NULL
)
314 if (dvd
->vd_minor
!= NULL
)
315 ddi_devid_str_free(dvd
->vd_minor
);
317 if (dvd
->vd_devid
!= NULL
)
318 ddi_devid_free(dvd
->vd_devid
);
320 if (dvd
->vd_lh
!= NULL
)
321 (void) ldi_close(dvd
->vd_lh
, spa_mode(vd
->vdev_spa
), kcred
);
323 kmem_free(dvd
, sizeof (vdev_disk_t
));
328 vdev_disk_physio(ldi_handle_t vd_lh
, caddr_t data
, size_t size
,
329 uint64_t offset
, int flags
)
337 ASSERT(flags
& B_READ
|| flags
& B_WRITE
);
339 bp
= getrbuf(KM_SLEEP
);
340 bp
->b_flags
= flags
| B_BUSY
| B_NOCACHE
| B_FAILFAST
;
342 bp
->b_un
.b_addr
= (void *)data
;
343 bp
->b_lblkno
= lbtodb(offset
);
344 bp
->b_bufsize
= size
;
346 error
= ldi_strategy(vd_lh
, bp
);
348 if ((error
= biowait(bp
)) == 0 && bp
->b_resid
!= 0)
356 vdev_disk_io_intr(buf_t
*bp
)
358 vdev_disk_buf_t
*vdb
= (vdev_disk_buf_t
*)bp
;
359 zio_t
*zio
= vdb
->vdb_io
;
362 * The rest of the zio stack only deals with EIO, ECKSUM, and ENXIO.
363 * Rather than teach the rest of the stack about other error
364 * possibilities (EFAULT, etc), we normalize the error value here.
366 zio
->io_error
= (geterror(bp
) != 0 ? EIO
: 0);
368 if (zio
->io_error
== 0 && bp
->b_resid
!= 0)
371 kmem_free(vdb
, sizeof (vdev_disk_buf_t
));
377 vdev_disk_ioctl_free(zio_t
*zio
)
379 kmem_free(zio
->io_vsd
, sizeof (struct dk_callback
));
382 static const zio_vsd_ops_t vdev_disk_vsd_ops
= {
383 vdev_disk_ioctl_free
,
384 zio_vsd_default_cksum_report
388 vdev_disk_ioctl_done(void *zio_arg
, int error
)
390 zio_t
*zio
= zio_arg
;
392 zio
->io_error
= error
;
398 vdev_disk_io_start(zio_t
*zio
)
400 vdev_t
*vd
= zio
->io_vd
;
401 vdev_disk_t
*dvd
= vd
->vdev_tsd
;
402 vdev_disk_buf_t
*vdb
;
403 struct dk_callback
*dkc
;
407 if (zio
->io_type
== ZIO_TYPE_IOCTL
) {
409 if (!vdev_readable(vd
)) {
410 zio
->io_error
= ENXIO
;
411 return (ZIO_PIPELINE_CONTINUE
);
414 switch (zio
->io_cmd
) {
416 case DKIOCFLUSHWRITECACHE
:
418 if (zfs_nocacheflush
)
421 if (vd
->vdev_nowritecache
) {
422 zio
->io_error
= ENOTSUP
;
426 zio
->io_vsd
= dkc
= kmem_alloc(sizeof (*dkc
), KM_SLEEP
);
427 zio
->io_vsd_ops
= &vdev_disk_vsd_ops
;
429 dkc
->dkc_callback
= vdev_disk_ioctl_done
;
430 dkc
->dkc_flag
= FLUSH_VOLATILE
;
431 dkc
->dkc_cookie
= zio
;
433 error
= ldi_ioctl(dvd
->vd_lh
, zio
->io_cmd
,
434 (uintptr_t)dkc
, FKIOCTL
, kcred
, NULL
);
438 * The ioctl will be done asychronously,
439 * and will call vdev_disk_ioctl_done()
442 return (ZIO_PIPELINE_STOP
);
445 if (error
== ENOTSUP
|| error
== ENOTTY
) {
447 * If we get ENOTSUP or ENOTTY, we know that
448 * no future attempts will ever succeed.
449 * In this case we set a persistent bit so
450 * that we don't bother with the ioctl in the
453 vd
->vdev_nowritecache
= B_TRUE
;
455 zio
->io_error
= error
;
460 zio
->io_error
= ENOTSUP
;
463 return (ZIO_PIPELINE_CONTINUE
);
466 vdb
= kmem_alloc(sizeof (vdev_disk_buf_t
), KM_SLEEP
);
472 bp
->b_flags
= B_BUSY
| B_NOCACHE
|
473 (zio
->io_type
== ZIO_TYPE_READ
? B_READ
: B_WRITE
);
474 if (!(zio
->io_flags
& (ZIO_FLAG_IO_RETRY
| ZIO_FLAG_TRYHARD
)))
475 bp
->b_flags
|= B_FAILFAST
;
476 bp
->b_bcount
= zio
->io_size
;
477 bp
->b_un
.b_addr
= zio
->io_data
;
478 bp
->b_lblkno
= lbtodb(zio
->io_offset
);
479 bp
->b_bufsize
= zio
->io_size
;
480 bp
->b_iodone
= (int (*)())vdev_disk_io_intr
;
482 /* ldi_strategy() will return non-zero only on programming errors */
483 VERIFY(ldi_strategy(dvd
->vd_lh
, bp
) == 0);
485 return (ZIO_PIPELINE_STOP
);
489 vdev_disk_io_done(zio_t
*zio
)
491 vdev_t
*vd
= zio
->io_vd
;
494 * If the device returned EIO, then attempt a DKIOCSTATE ioctl to see if
495 * the device has been removed. If this is the case, then we trigger an
496 * asynchronous removal of the device. Otherwise, probe the device and
497 * make sure it's still accessible.
499 if (zio
->io_error
== EIO
&& !vd
->vdev_remove_wanted
) {
500 vdev_disk_t
*dvd
= vd
->vdev_tsd
;
501 int state
= DKIO_NONE
;
503 if (ldi_ioctl(dvd
->vd_lh
, DKIOCSTATE
, (intptr_t)&state
,
504 FKIOCTL
, kcred
, NULL
) == 0 && state
!= DKIO_INSERTED
) {
506 * We post the resource as soon as possible, instead of
507 * when the async removal actually happens, because the
508 * DE is using this information to discard previous I/O
511 zfs_post_remove(zio
->io_spa
, vd
);
512 vd
->vdev_remove_wanted
= B_TRUE
;
513 spa_async_request(zio
->io_spa
, SPA_ASYNC_REMOVE
);
518 vdev_ops_t vdev_disk_ops
= {
527 VDEV_TYPE_DISK
, /* name of this vdev type */
528 B_TRUE
/* leaf vdev */
532 * Given the root disk device devid or pathname, read the label from
533 * the device, and construct a configuration nvlist.
536 vdev_disk_read_rootlabel(char *devpath
, char *devid
, nvlist_t
**config
)
542 ddi_devid_t tmpdevid
;
547 * Read the device label and build the nvlist.
549 if (devid
!= NULL
&& ddi_devid_str_decode(devid
, &tmpdevid
,
551 error
= ldi_open_by_devid(tmpdevid
, minor_name
,
552 FREAD
, kcred
, &vd_lh
, zfs_li
);
553 ddi_devid_free(tmpdevid
);
554 ddi_devid_str_free(minor_name
);
557 if (error
&& (error
= ldi_open_by_name(devpath
, FREAD
, kcred
, &vd_lh
,
561 if (ldi_get_size(vd_lh
, &s
)) {
562 (void) ldi_close(vd_lh
, FREAD
, kcred
);
566 size
= P2ALIGN_TYPED(s
, sizeof (vdev_label_t
), uint64_t);
567 label
= kmem_alloc(sizeof (vdev_label_t
), KM_SLEEP
);
570 for (l
= 0; l
< VDEV_LABELS
; l
++) {
571 uint64_t offset
, state
, txg
= 0;
573 /* read vdev label */
574 offset
= vdev_label_offset(size
, l
, 0);
575 if (vdev_disk_physio(vd_lh
, (caddr_t
)label
,
576 VDEV_SKIP_SIZE
+ VDEV_PHYS_SIZE
, offset
, B_READ
) != 0)
579 if (nvlist_unpack(label
->vl_vdev_phys
.vp_nvlist
,
580 sizeof (label
->vl_vdev_phys
.vp_nvlist
), config
, 0) != 0) {
585 if (nvlist_lookup_uint64(*config
, ZPOOL_CONFIG_POOL_STATE
,
586 &state
) != 0 || state
>= POOL_STATE_DESTROYED
) {
587 nvlist_free(*config
);
592 if (nvlist_lookup_uint64(*config
, ZPOOL_CONFIG_POOL_TXG
,
593 &txg
) != 0 || txg
== 0) {
594 nvlist_free(*config
);
602 kmem_free(label
, sizeof (vdev_label_t
));
603 (void) ldi_close(vd_lh
, FREAD
, kcred
);