static char *
get_devid(const char *path)
{
int fd;
ddi_devid_t devid;
char *minor, *ret;
if ((fd = open(path, O_RDONLY)) < 0)
return (NULL);
minor = NULL;
ret = NULL;
if (devid_get(fd, &devid) == 0) {
if (devid_get_minor_name(fd, &minor) == 0)
ret = devid_str_encode(devid, minor);
if (minor != NULL)
devid_str_free(minor);
devid_free(devid);
}
(void) close(fd);
return (ret);
}
static int
get_attrs(descriptor_t *dp, int fd, nvlist_t *attrs)
{
struct dk_minfo minfo;
int status;
int data_format = FMT_UNKNOWN;
int snum = -1;
int error;
struct extvtoc vtoc;
struct dk_gpt *efip;
struct dk_cinfo dkinfo;
int cooked_fd;
struct stat buf;
if (fd < 0) {
return (ENODEV);
}
/* First make sure media is inserted and spun up. */
if (!media_read_info(fd, &minfo)) {
return (ENODEV);
}
if ((status = read_extvtoc(fd, &vtoc)) >= 0) {
data_format = FMT_VTOC;
} else if (status == VT_ENOTSUP && efi_alloc_and_read(fd, &efip) >= 0) {
data_format = FMT_EFI;
if (nvlist_add_boolean(attrs, DM_EFI) != 0) {
efi_free(efip);
return (ENOMEM);
}
}
if (data_format == FMT_UNKNOWN) {
return (ENODEV);
}
if (ioctl(fd, DKIOCINFO, &dkinfo) >= 0) {
snum = dkinfo.dki_partition;
}
/* check the slice */
if (data_format == FMT_VTOC) {
if (snum < 0 || snum >= vtoc.v_nparts ||
vtoc.v_part[snum].p_size == 0) {
return (ENODEV);
}
} else { /* data_format == FMT_EFI */
if (snum < 0 || snum >= efip->efi_nparts ||
efip->efi_parts[snum].p_size == 0) {
efi_free(efip);
return (ENODEV);
}
}
/* the slice exists */
if (nvlist_add_uint32(attrs, DM_INDEX, snum) != 0) {
if (data_format == FMT_EFI) {
efi_free(efip);
}
return (ENOMEM);
}
if (data_format == FMT_VTOC) {
if (nvlist_add_uint64(attrs, DM_START, vtoc.v_part[snum].p_start)
!= 0) {
return (ENOMEM);
}
if (nvlist_add_uint64(attrs, DM_SIZE, vtoc.v_part[snum].p_size)
!= 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_TAG, vtoc.v_part[snum].p_tag)
!= 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_FLAG, vtoc.v_part[snum].p_flag)
!= 0) {
return (ENOMEM);
}
} else { /* data_format == FMT_EFI */
if (nvlist_add_uint64(attrs, DM_START,
efip->efi_parts[snum].p_start) != 0) {
efi_free(efip);
return (ENOMEM);
}
if (nvlist_add_uint64(attrs, DM_SIZE, efip->efi_parts[snum].p_size)
!= 0) {
efi_free(efip);
return (ENOMEM);
}
if (efip->efi_parts[snum].p_name[0] != 0) {
char label[EFI_PART_NAME_LEN + 1];
(void) snprintf(label, sizeof (label), "%.*s",
EFI_PART_NAME_LEN, efip->efi_parts[snum].p_name);
if (nvlist_add_string(attrs, DM_EFI_NAME, label) != 0) {
efi_free(efip);
return (ENOMEM);
}
}
}
if (data_format == FMT_EFI) {
efi_free(efip);
}
if (inuse_mnt(dp->name, attrs, &error)) {
if (error != 0)
return (error);
}
if (fstat(fd, &buf) != -1) {
if (nvlist_add_uint64(attrs, DM_DEVT, buf.st_rdev) != 0) {
return (ENOMEM);
}
}
/*
* We need to open the cooked slice (not the raw one) to get the
* correct devid.
*/
cooked_fd = open(dp->name, O_RDONLY|O_NDELAY);
if (cooked_fd >= 0) {
int no_mem = 0;
ddi_devid_t devid;
if (devid_get(cooked_fd, &devid) == 0) {
char *minor;
if (devid_get_minor_name(cooked_fd, &minor) == 0) {
char *devidstr;
if ((devidstr = devid_str_encode(devid, minor)) != 0) {
if (nvlist_add_string(attrs, DM_DEVICEID, devidstr)
!= 0) {
no_mem = 1;
}
devid_str_free(devidstr);
}
devid_str_free(minor);
}
devid_free(devid);
}
(void) close(cooked_fd);
if (no_mem) {
return (ENOMEM);
}
}
return (0);
}
/*
* Create a leaf vdev. Determine if this is a file or a device. If it's a
* device, fill in the device id to make a complete nvlist. Valid forms for a
* leaf vdev are:
*
* /dev/dsk/xxx Complete disk path
* /xxx Full path to file
* xxx Shorthand for /dev/dsk/xxx
*/
nvlist_t *
make_leaf_vdev(const char *arg)
{
char path[MAXPATHLEN];
struct stat statbuf;
nvlist_t *vdev = NULL;
char *type = NULL;
boolean_t wholedisk = B_FALSE;
/*
* Determine what type of vdev this is, and put the full path into
* 'path'. We detect whether this is a device of file afterwards by
* checking the st_mode of the file.
*/
if (arg[0] == '/') {
/*
* Complete device or file path. Exact type is determined by
* examining the file descriptor afterwards.
*/
if (is_whole_disk(arg, &statbuf)) {
wholedisk = B_TRUE;
} else if (stat(arg, &statbuf) != 0) {
(void) fprintf(stderr,
gettext("cannot open '%s': %s\n"),
arg, strerror(errno));
return (NULL);
}
(void) strlcpy(path, arg, sizeof (path));
} else {
/*
* This may be a short path for a device, or it could be total
* gibberish. Check to see if it's a known device in
* /dev/dsk/. As part of this check, see if we've been given a
* an entire disk (minus the slice number).
*/
(void) snprintf(path, sizeof (path), "%s/%s", DISK_ROOT,
arg);
if (is_whole_disk(path, &statbuf)) {
wholedisk = B_TRUE;
} else if (stat(path, &statbuf) != 0) {
/*
* If we got ENOENT, then the user gave us
* gibberish, so try to direct them with a
* reasonable error message. Otherwise,
* regurgitate strerror() since it's the best we
* can do.
*/
if (errno == ENOENT) {
(void) fprintf(stderr,
gettext("cannot open '%s': no such "
"device in %s\n"), arg, DISK_ROOT);
(void) fprintf(stderr,
gettext("must be a full path or "
"shorthand device name\n"));
return (NULL);
} else {
(void) fprintf(stderr,
gettext("cannot open '%s': %s\n"),
path, strerror(errno));
return (NULL);
}
}
}
/*
* Determine whether this is a device or a file.
*/
if (S_ISBLK(statbuf.st_mode)) {
type = VDEV_TYPE_DISK;
} else if (S_ISREG(statbuf.st_mode)) {
type = VDEV_TYPE_FILE;
} else {
(void) fprintf(stderr, gettext("cannot use '%s': must be a "
"block device or regular file\n"), path);
return (NULL);
}
/*
* Finally, we have the complete device or file, and we know that it is
* acceptable to use. Construct the nvlist to describe this vdev. All
* vdevs have a 'path' element, and devices also have a 'devid' element.
*/
verify(nvlist_alloc(&vdev, NV_UNIQUE_NAME, 0) == 0);
verify(nvlist_add_string(vdev, ZPOOL_CONFIG_PATH, path) == 0);
verify(nvlist_add_string(vdev, ZPOOL_CONFIG_TYPE, type) == 0);
if (strcmp(type, VDEV_TYPE_DISK) == 0)
verify(nvlist_add_uint64(vdev, ZPOOL_CONFIG_WHOLE_DISK,
(uint64_t)wholedisk) == 0);
/*
* For a whole disk, defer getting its devid until after labeling it.
*/
if (S_ISBLK(statbuf.st_mode) && !wholedisk) {
/*
* Get the devid for the device.
*/
int fd;
ddi_devid_t devid;
char *minor = NULL, *devid_str = NULL;
if ((fd = open(path, O_RDONLY)) < 0) {
(void) fprintf(stderr, gettext("cannot open '%s': "
"%s\n"), path, strerror(errno));
nvlist_free(vdev);
return (NULL);
}
if (devid_get(fd, &devid) == 0) {
if (devid_get_minor_name(fd, &minor) == 0 &&
(devid_str = devid_str_encode(devid, minor)) !=
NULL) {
verify(nvlist_add_string(vdev,
ZPOOL_CONFIG_DEVID, devid_str) == 0);
}
if (devid_str != NULL)
devid_str_free(devid_str);
if (minor != NULL)
devid_str_free(minor);
devid_free(devid);
}
(void) close(fd);
}
return (vdev);
}
