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]
23 * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
24 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
25 * Copyright (c) 2011, 2018 by Delphix. All rights reserved.
26 * Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>
27 * Copyright (c) 2018 Datto Inc.
28 * Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
29 * Copyright (c) 2017, Intel Corporation.
30 * Copyright (c) 2018, loli10K <ezomori.nozomu@gmail.com>
42 #include <sys/efi_partition.h>
43 #include <sys/systeminfo.h>
45 #include <sys/zfs_ioctl.h>
46 #include <sys/vdev_disk.h>
50 #include "zfs_namecheck.h"
52 #include "libzfs_impl.h"
53 #include "zfs_comutil.h"
54 #include "zfeature_common.h"
57 * If the device has being dynamically expanded then we need to relabel
58 * the disk to use the new unallocated space.
61 zpool_relabel_disk(libzfs_handle_t *hdl, const char *path, const char *msg)
65 if ((fd = open(path, O_RDWR|O_DIRECT)) < 0) {
66 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "cannot "
67 "relabel '%s': unable to open device: %d"), path, errno);
68 return (zfs_error(hdl, EZFS_OPENFAILED, msg));
72 * It's possible that we might encounter an error if the device
73 * does not have any unallocated space left. If so, we simply
74 * ignore that error and continue on.
76 * Also, we don't call efi_rescan() - that would just return EBUSY.
77 * The module will do it for us in vdev_disk_open().
79 error = efi_use_whole_disk(fd);
81 /* Flush the buffers to disk and invalidate the page cache. */
83 (void) ioctl(fd, BLKFLSBUF);
86 if (error && error != VT_ENOSPC) {
87 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "cannot "
88 "relabel '%s': unable to read disk capacity"), path);
89 return (zfs_error(hdl, EZFS_NOCAP, msg));
95 * Read the EFI label from the config, if a label does not exist then
96 * pass back the error to the caller. If the caller has passed a non-NULL
97 * diskaddr argument then we set it to the starting address of the EFI
101 read_efi_label(nvlist_t *config, diskaddr_t *sb)
105 char diskname[MAXPATHLEN];
108 if (nvlist_lookup_string(config, ZPOOL_CONFIG_PATH, &path) != 0)
111 (void) snprintf(diskname, sizeof (diskname), "%s%s", DISK_ROOT,
113 if ((fd = open(diskname, O_RDONLY|O_DIRECT)) >= 0) {
116 if ((err = efi_alloc_and_read(fd, &vtoc)) >= 0) {
118 *sb = vtoc->efi_parts[0].p_start;
127 * determine where a partition starts on a disk in the current
131 find_start_block(nvlist_t *config)
135 diskaddr_t sb = MAXOFFSET_T;
138 if (nvlist_lookup_nvlist_array(config,
139 ZPOOL_CONFIG_CHILDREN, &child, &children) != 0) {
140 if (nvlist_lookup_uint64(config,
141 ZPOOL_CONFIG_WHOLE_DISK,
142 &wholedisk) != 0 || !wholedisk) {
143 return (MAXOFFSET_T);
145 if (read_efi_label(config, &sb) < 0)
150 for (c = 0; c < children; c++) {
151 sb = find_start_block(child[c]);
152 if (sb != MAXOFFSET_T) {
156 return (MAXOFFSET_T);
160 zpool_label_disk_check(char *path)
165 if ((fd = open(path, O_RDONLY|O_DIRECT)) < 0)
168 if ((err = efi_alloc_and_read(fd, &vtoc)) != 0) {
173 if (vtoc->efi_flags & EFI_GPT_PRIMARY_CORRUPT) {
185 * Generate a unique partition name for the ZFS member. Partitions must
186 * have unique names to ensure udev will be able to create symlinks under
187 * /dev/disk/by-partlabel/ for all pool members. The partition names are
188 * of the form <pool>-<unique-id>.
191 zpool_label_name(char *label_name, int label_size)
196 fd = open("/dev/urandom", O_RDONLY);
198 if (read(fd, &id, sizeof (id)) != sizeof (id))
205 id = (((uint64_t)rand()) << 32) | (uint64_t)rand();
207 snprintf(label_name, label_size, "zfs-%016llx", (u_longlong_t)id);
211 * Label an individual disk. The name provided is the short name,
212 * stripped of any leading /dev path.
215 zpool_label_disk(libzfs_handle_t *hdl, zpool_handle_t *zhp, const char *name)
217 char path[MAXPATHLEN];
220 size_t resv = EFI_MIN_RESV_SIZE;
222 diskaddr_t start_block;
225 /* prepare an error message just in case */
226 (void) snprintf(errbuf, sizeof (errbuf),
227 dgettext(TEXT_DOMAIN, "cannot label '%s'"), name);
232 verify(nvlist_lookup_nvlist(zhp->zpool_config,
233 ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
235 if (zhp->zpool_start_block == 0)
236 start_block = find_start_block(nvroot);
238 start_block = zhp->zpool_start_block;
239 zhp->zpool_start_block = start_block;
242 start_block = NEW_START_BLOCK;
245 (void) snprintf(path, sizeof (path), "%s/%s", DISK_ROOT, name);
247 if ((fd = open(path, O_RDWR|O_DIRECT|O_EXCL)) < 0) {
249 * This shouldn't happen. We've long since verified that this
252 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "cannot "
253 "label '%s': unable to open device: %d"), path, errno);
254 return (zfs_error(hdl, EZFS_OPENFAILED, errbuf));
257 if (efi_alloc_and_init(fd, EFI_NUMPAR, &vtoc) != 0) {
259 * The only way this can fail is if we run out of memory, or we
260 * were unable to read the disk's capacity
263 (void) no_memory(hdl);
266 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "cannot "
267 "label '%s': unable to read disk capacity"), path);
269 return (zfs_error(hdl, EZFS_NOCAP, errbuf));
272 slice_size = vtoc->efi_last_u_lba + 1;
273 slice_size -= EFI_MIN_RESV_SIZE;
274 if (start_block == MAXOFFSET_T)
275 start_block = NEW_START_BLOCK;
276 slice_size -= start_block;
277 slice_size = P2ALIGN(slice_size, PARTITION_END_ALIGNMENT);
279 vtoc->efi_parts[0].p_start = start_block;
280 vtoc->efi_parts[0].p_size = slice_size;
283 * Why we use V_USR: V_BACKUP confuses users, and is considered
284 * disposable by some EFI utilities (since EFI doesn't have a backup
285 * slice). V_UNASSIGNED is supposed to be used only for zero size
286 * partitions, and efi_write() will fail if we use it. V_ROOT, V_BOOT,
287 * etc. were all pretty specific. V_USR is as close to reality as we
288 * can get, in the absence of V_OTHER.
290 vtoc->efi_parts[0].p_tag = V_USR;
291 zpool_label_name(vtoc->efi_parts[0].p_name, EFI_PART_NAME_LEN);
293 vtoc->efi_parts[8].p_start = slice_size + start_block;
294 vtoc->efi_parts[8].p_size = resv;
295 vtoc->efi_parts[8].p_tag = V_RESERVED;
297 rval = efi_write(fd, vtoc);
299 /* Flush the buffers to disk and invalidate the page cache. */
301 (void) ioctl(fd, BLKFLSBUF);
304 rval = efi_rescan(fd);
307 * Some block drivers (like pcata) may not support EFI GPT labels.
308 * Print out a helpful error message directing the user to manually
309 * label the disk and give a specific slice.
315 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "try using "
316 "parted(8) and then provide a specific slice: %d"), rval);
317 return (zfs_error(hdl, EZFS_LABELFAILED, errbuf));
323 (void) snprintf(path, sizeof (path), "%s/%s", DISK_ROOT, name);
324 (void) zfs_append_partition(path, MAXPATHLEN);
326 /* Wait to udev to signal use the device has settled. */
327 rval = zpool_label_disk_wait(path, DISK_LABEL_WAIT);
329 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "failed to "
330 "detect device partitions on '%s': %d"), path, rval);
331 return (zfs_error(hdl, EZFS_LABELFAILED, errbuf));
334 /* We can't be to paranoid. Read the label back and verify it. */
335 (void) snprintf(path, sizeof (path), "%s/%s", DISK_ROOT, name);
336 rval = zpool_label_disk_check(path);
338 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "freshly written "
339 "EFI label on '%s' is damaged. Ensure\nthis device "
340 "is not in use, and is functioning properly: %d"),
342 return (zfs_error(hdl, EZFS_LABELFAILED, errbuf));