/*
* Use libblkid to quickly search for zfs devices
*/
static int
zpool_find_import_blkid(libzfs_handle_t *hdl, pool_list_t *pools)
{
blkid_cache cache;
blkid_dev_iterate iter;
blkid_dev dev;
const char *devname;
nvlist_t *config;
int fd, err, num_labels;
err = blkid_get_cache(&cache, NULL);
if (err != 0) {
(void) zfs_error_fmt(hdl, EZFS_BADCACHE,
dgettext(TEXT_DOMAIN, "blkid_get_cache() %d"), err);
goto err_blkid1;
}
err = blkid_probe_all(cache);
if (err != 0) {
(void) zfs_error_fmt(hdl, EZFS_BADCACHE,
dgettext(TEXT_DOMAIN, "blkid_probe_all() %d"), err);
goto err_blkid2;
}
iter = blkid_dev_iterate_begin(cache);
if (iter == NULL) {
(void) zfs_error_fmt(hdl, EZFS_BADCACHE,
dgettext(TEXT_DOMAIN, "blkid_dev_iterate_begin()"));
goto err_blkid2;
}
err = blkid_dev_set_search(iter, "TYPE", "zfs_member");
if (err != 0) {
(void) zfs_error_fmt(hdl, EZFS_BADCACHE,
dgettext(TEXT_DOMAIN, "blkid_dev_set_search() %d"), err);
goto err_blkid3;
}
while (blkid_dev_next(iter, &dev) == 0) {
devname = blkid_dev_devname(dev);
if ((fd = open(devname, O_RDONLY)) < 0)
continue;
err = zpool_read_label(fd, &config, &num_labels);
(void) close(fd);
if (err != 0) {
(void) no_memory(hdl);
goto err_blkid3;
}
if (config != NULL) {
err = add_config(hdl, pools, devname, 0,
num_labels, config);
if (err != 0)
goto err_blkid3;
}
}
err_blkid3:
blkid_dev_iterate_end(iter);
err_blkid2:
blkid_put_cache(cache);
err_blkid1:
return (err);
}
int main(int argc, char **argv)
{
blkid_cache cache = NULL;
char *devices[128] = { NULL, };
char *show[128] = { NULL, };
char *search_type = NULL, *search_value = NULL;
char *read = NULL;
char *write = NULL;
unsigned int numdev = 0, numtag = 0;
int version = 0;
int err = 4;
unsigned int i;
int output_format = 0;
int lookup = 0, gc = 0;
int c;
while ((c = getopt (argc, argv, "c:f:ghlLo:s:t:w:v")) != EOF)
switch (c) {
case 'c':
if (optarg && !*optarg)
read = NULL;
else
read = optarg;
if (!write)
write = read;
break;
case 'l':
lookup++;
break;
case 'L':
output_format = OUTPUT_PRETTY_LIST;
break;
case 'g':
gc = 1;
break;
case 'o':
if (!strcmp(optarg, "value"))
output_format = OUTPUT_VALUE_ONLY;
else if (!strcmp(optarg, "device"))
output_format = OUTPUT_DEVICE_ONLY;
else if (!strcmp(optarg, "list"))
output_format = OUTPUT_PRETTY_LIST;
else if (!strcmp(optarg, "full"))
output_format = 0;
else {
fprintf(stderr, "Invalid output format %s. "
"Choose from value,\n\t"
"device, list, or full\n", optarg);
exit(1);
}
break;
case 's':
if (numtag >= sizeof(show) / sizeof(*show)) {
fprintf(stderr, "Too many tags specified\n");
usage(err);
}
show[numtag++] = optarg;
break;
case 't':
if (search_type) {
fprintf(stderr, "Can only search for "
"one NAME=value pair\n");
usage(err);
}
if (blkid_parse_tag_string(optarg,
&search_type,
&search_value)) {
fprintf(stderr, "-t needs NAME=value pair\n");
usage(err);
}
break;
case 'v':
version = 1;
break;
case 'w':
if (optarg && !*optarg)
write = NULL;
else
write = optarg;
break;
case 'h':
err = 0;
default:
usage(err);
}
while (optind < argc)
devices[numdev++] = argv[optind++];
if (version) {
print_version(stdout);
goto exit;
}
if (blkid_get_cache(&cache, read) < 0)
goto exit;
err = 2;
if (gc) {
blkid_gc_cache(cache);
goto exit;
}
if (output_format & OUTPUT_PRETTY_LIST)
pretty_print_dev(NULL);
if (lookup) {
blkid_dev dev;
if (!search_type) {
fprintf(stderr, "The lookup option requires a "
"search type specified using -t\n");
exit(1);
}
/* Load any additional devices not in the cache */
for (i = 0; i < numdev; i++)
blkid_get_dev(cache, devices[i], BLKID_DEV_NORMAL);
if ((dev = blkid_find_dev_with_tag(cache, search_type,
search_value))) {
print_tags(dev, show, numtag, output_format);
err = 0;
}
/* If we didn't specify a single device, show all available devices */
} else if (!numdev) {
blkid_dev_iterate iter;
blkid_dev dev;
blkid_probe_all(cache);
iter = blkid_dev_iterate_begin(cache);
blkid_dev_set_search(iter, search_type, search_value);
while (blkid_dev_next(iter, &dev) == 0) {
dev = blkid_verify(cache, dev);
if (!dev)
continue;
print_tags(dev, show, numtag, output_format);
err = 0;
}
blkid_dev_iterate_end(iter);
/* Add all specified devices to cache (optionally display tags) */
} else for (i = 0; i < numdev; i++) {
blkid_dev dev = blkid_get_dev(cache, devices[i],
BLKID_DEV_NORMAL);
if (dev) {
if (search_type &&
!blkid_dev_has_tag(dev, search_type,
search_value))
continue;
print_tags(dev, show, numtag, output_format);
err = 0;
}
}
exit:
free(search_type);
free(search_value);
blkid_put_cache(cache);
return err;
}
int main(int argc, char **argv)
{
blkid_cache cache = NULL;
char *devices[128] = { NULL, };
char *show[128] = { NULL, };
char *search_type = NULL, *search_value = NULL;
char *read = NULL;
char *write = NULL;
int fltr_usage = 0;
char **fltr_type = NULL;
int fltr_flag = BLKID_FLTR_ONLYIN;
unsigned int numdev = 0, numtag = 0;
int version = 0;
int err = 4;
unsigned int i;
int output_format = 0;
int lookup = 0, gc = 0, lowprobe = 0, eval = 0;
int c;
uintmax_t offset = 0, size = 0;
show[0] = NULL;
while ((c = getopt (argc, argv, "c:f:ghilL:n:o:O:ps:S:t:u:U:w:v")) != EOF)
switch (c) {
case 'c':
if (optarg && !*optarg)
read = NULL;
else
read = optarg;
if (!write)
write = read;
break;
case 'L':
eval++;
search_value = strdup(optarg);
search_type = strdup("LABEL");
break;
case 'n':
if (fltr_usage) {
fprintf(stderr, "error: -u and -n options are mutually exclusive\n");
exit(4);
}
fltr_type = list_to_types(optarg, &fltr_flag);
break;
case 'u':
if (fltr_type) {
fprintf(stderr, "error: -u and -n options are mutually exclusive\n");
exit(4);
}
fltr_usage = list_to_usage(optarg, &fltr_flag);
break;
case 'U':
eval++;
search_value = strdup(optarg);
search_type = strdup("UUID");
break;
case 'i':
lowprobe |= LOWPROBE_TOPOLOGY;
break;
case 'l':
lookup++;
break;
case 'g':
gc = 1;
break;
case 'o':
if (!strcmp(optarg, "value"))
output_format = OUTPUT_VALUE_ONLY;
else if (!strcmp(optarg, "device"))
output_format = OUTPUT_DEVICE_ONLY;
else if (!strcmp(optarg, "list"))
output_format = OUTPUT_PRETTY_LIST;
else if (!strcmp(optarg, "udev"))
output_format = OUTPUT_UDEV_LIST;
else if (!strcmp(optarg, "export"))
output_format = OUTPUT_EXPORT_LIST;
else if (!strcmp(optarg, "full"))
output_format = 0;
else {
fprintf(stderr, "Invalid output format %s. "
"Choose from value,\n\t"
"device, list, udev or full\n", optarg);
exit(4);
}
break;
case 'O':
if (strtosize(optarg, &offset))
fprintf(stderr,
"Invalid offset '%s' specified\n",
optarg);
break;
case 'p':
lowprobe |= LOWPROBE_SUPERBLOCKS;
break;
case 's':
if (numtag + 1 >= sizeof(show) / sizeof(*show)) {
fprintf(stderr, "Too many tags specified\n");
usage(err);
}
show[numtag++] = optarg;
show[numtag] = NULL;
break;
case 'S':
if (strtosize(optarg, &size))
fprintf(stderr,
"Invalid size '%s' specified\n",
optarg);
break;
case 't':
if (search_type) {
fprintf(stderr, "Can only search for "
"one NAME=value pair\n");
usage(err);
}
if (blkid_parse_tag_string(optarg,
&search_type,
&search_value)) {
fprintf(stderr, "-t needs NAME=value pair\n");
usage(err);
}
break;
case 'v':
version = 1;
break;
case 'w':
if (optarg && !*optarg)
write = NULL;
else
write = optarg;
break;
case 'h':
err = 0;
default:
usage(err);
}
while (optind < argc)
devices[numdev++] = argv[optind++];
if (version) {
print_version(stdout);
goto exit;
}
/* convert LABEL/UUID lookup to evaluate request */
if (lookup && output_format == OUTPUT_DEVICE_ONLY && search_type &&
(!strcmp(search_type, "LABEL") || !strcmp(search_type, "UUID"))) {
eval++;
lookup = 0;
}
if (!lowprobe && !eval && blkid_get_cache(&cache, read) < 0)
goto exit;
if (gc) {
blkid_gc_cache(cache);
err = 0;
goto exit;
}
err = 2;
if (eval == 0 && (output_format & OUTPUT_PRETTY_LIST)) {
if (lowprobe) {
fprintf(stderr, "The low-level probing mode does not "
"support 'list' output format\n");
exit(4);
}
pretty_print_dev(NULL);
}
if (lowprobe) {
/*
* Low-level API
*/
blkid_probe pr;
if (!numdev) {
fprintf(stderr, "The low-level probing mode "
"requires a device\n");
exit(4);
}
/* automatically enable 'export' format for I/O Limits */
if (!output_format && (lowprobe & LOWPROBE_TOPOLOGY))
output_format = OUTPUT_EXPORT_LIST;
pr = blkid_new_probe();
if (!pr)
goto exit;
if (lowprobe & LOWPROBE_SUPERBLOCKS) {
blkid_probe_set_superblocks_flags(pr,
BLKID_SUBLKS_LABEL | BLKID_SUBLKS_UUID |
BLKID_SUBLKS_TYPE | BLKID_SUBLKS_SECTYPE |
BLKID_SUBLKS_USAGE | BLKID_SUBLKS_VERSION);
if (fltr_usage && blkid_probe_filter_superblocks_usage(
pr, fltr_flag, fltr_usage))
goto exit;
else if (fltr_type && blkid_probe_filter_superblocks_type(
pr, fltr_flag, fltr_type))
goto exit;
}
for (i = 0; i < numdev; i++)
err = lowprobe_device(pr, devices[i], lowprobe, show,
output_format,
(blkid_loff_t) offset,
(blkid_loff_t) size);
blkid_free_probe(pr);
} else if (eval) {
/*
* Evaluate API
*/
char *res = blkid_evaluate_tag(search_type, search_value, NULL);
if (res) {
err = 0;
printf("%s\n", res);
}
} else if (lookup) {
/*
* Classic (cache based) API
*/
blkid_dev dev;
if (!search_type) {
fprintf(stderr, "The lookup option requires a "
"search type specified using -t\n");
exit(4);
}
/* Load any additional devices not in the cache */
for (i = 0; i < numdev; i++)
blkid_get_dev(cache, devices[i], BLKID_DEV_NORMAL);
if ((dev = blkid_find_dev_with_tag(cache, search_type,
search_value))) {
print_tags(dev, show, output_format);
err = 0;
}
/* If we didn't specify a single device, show all available devices */
} else if (!numdev) {
blkid_dev_iterate iter;
blkid_dev dev;
blkid_probe_all(cache);
iter = blkid_dev_iterate_begin(cache);
blkid_dev_set_search(iter, search_type, search_value);
while (blkid_dev_next(iter, &dev) == 0) {
dev = blkid_verify(cache, dev);
if (!dev)
continue;
print_tags(dev, show, output_format);
err = 0;
}
blkid_dev_iterate_end(iter);
/* Add all specified devices to cache (optionally display tags) */
} else for (i = 0; i < numdev; i++) {
blkid_dev dev = blkid_get_dev(cache, devices[i],
BLKID_DEV_NORMAL);
if (dev) {
if (search_type &&
!blkid_dev_has_tag(dev, search_type,
search_value))
continue;
print_tags(dev, show, output_format);
err = 0;
}
}
exit:
free(search_type);
free(search_value);
free_types_list(fltr_type);
if (!lowprobe && !eval)
blkid_put_cache(cache);
return err;
}
int main(int argc, char **argv)
{
blkid_cache cache = NULL;
char **devices = NULL;
char *show[128] = { NULL, };
char *search_type = NULL, *search_value = NULL;
char *read = NULL;
int fltr_usage = 0;
char **fltr_type = NULL;
int fltr_flag = BLKID_FLTR_ONLYIN;
unsigned int numdev = 0, numtag = 0;
int version = 0;
int err = BLKID_EXIT_OTHER;
unsigned int i;
int output_format = 0;
int lookup = 0, gc = 0, lowprobe = 0, eval = 0;
int c;
uintmax_t offset = 0, size = 0;
static const ul_excl_t excl[] = { /* rows and cols in in ASCII order */
{ 'n','u' },
{ 0 }
};
int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
show[0] = NULL;
atexit(close_stdout);
while ((c = getopt (argc, argv,
"c:df:ghilL:n:ko:O:ps:S:t:u:U:w:Vv")) != EOF) {
err_exclusive_options(c, NULL, excl, excl_st);
switch (c) {
case 'c':
if (optarg && !*optarg)
read = NULL;
else
read = optarg;
break;
case 'd':
raw_chars = 1;
break;
case 'L':
eval++;
search_value = xstrdup(optarg);
search_type = xstrdup("LABEL");
break;
case 'n':
fltr_type = list_to_types(optarg, &fltr_flag);
break;
case 'u':
fltr_usage = list_to_usage(optarg, &fltr_flag);
break;
case 'U':
eval++;
search_value = xstrdup(optarg);
search_type = xstrdup("UUID");
break;
case 'i':
lowprobe |= LOWPROBE_TOPOLOGY;
break;
case 'l':
lookup++;
break;
case 'g':
gc = 1;
break;
case 'k':
{
size_t idx = 0;
const char *name = NULL;
while (blkid_superblocks_get_name(idx++, &name, NULL) == 0)
printf("%s\n", name);
exit(EXIT_SUCCESS);
}
case 'o':
if (!strcmp(optarg, "value"))
output_format = OUTPUT_VALUE_ONLY;
else if (!strcmp(optarg, "device"))
output_format = OUTPUT_DEVICE_ONLY;
else if (!strcmp(optarg, "list"))
output_format = OUTPUT_PRETTY_LIST; /* deprecated */
else if (!strcmp(optarg, "udev"))
output_format = OUTPUT_UDEV_LIST;
else if (!strcmp(optarg, "export"))
output_format = OUTPUT_EXPORT_LIST;
else if (!strcmp(optarg, "full"))
output_format = 0;
else {
fprintf(stderr, "Invalid output format %s. "
"Choose from value,\n\t"
"device, list, udev or full\n", optarg);
exit(BLKID_EXIT_OTHER);
}
break;
case 'O':
offset = strtosize_or_err(optarg, "invalid offset argument");
break;
case 'p':
lowprobe |= LOWPROBE_SUPERBLOCKS;
break;
case 's':
if (numtag + 1 >= sizeof(show) / sizeof(*show)) {
fprintf(stderr, "Too many tags specified\n");
usage(err);
}
show[numtag++] = optarg;
show[numtag] = NULL;
break;
case 'S':
size = strtosize_or_err(optarg, "invalid size argument");
break;
case 't':
if (search_type) {
fprintf(stderr, "Can only search for "
"one NAME=value pair\n");
usage(err);
}
if (blkid_parse_tag_string(optarg,
&search_type,
&search_value)) {
fprintf(stderr, "-t needs NAME=value pair\n");
usage(err);
}
break;
case 'V':
case 'v':
version = 1;
break;
case 'w':
/* ignore - backward compatibility */
break;
case 'h':
err = 0;
/* fallthrough */
default:
usage(err);
}
}
/* The rest of the args are device names */
if (optind < argc) {
devices = xcalloc(argc - optind, sizeof(char *));
while (optind < argc)
devices[numdev++] = argv[optind++];
}
if (version) {
print_version(stdout);
goto exit;
}
/* convert LABEL/UUID lookup to evaluate request */
if (lookup && output_format == OUTPUT_DEVICE_ONLY && search_type &&
(!strcmp(search_type, "LABEL") || !strcmp(search_type, "UUID"))) {
eval++;
lookup = 0;
}
if (!lowprobe && !eval && blkid_get_cache(&cache, read) < 0)
goto exit;
if (gc) {
blkid_gc_cache(cache);
err = 0;
goto exit;
}
err = BLKID_EXIT_NOTFOUND;
if (eval == 0 && (output_format & OUTPUT_PRETTY_LIST)) {
if (lowprobe) {
fprintf(stderr, "The low-level probing mode does not "
"support 'list' output format\n");
exit(BLKID_EXIT_OTHER);
}
pretty_print_dev(NULL);
}
if (lowprobe) {
/*
* Low-level API
*/
blkid_probe pr;
if (!numdev) {
fprintf(stderr, "The low-level probing mode "
"requires a device\n");
exit(BLKID_EXIT_OTHER);
}
/* automatically enable 'export' format for I/O Limits */
if (!output_format && (lowprobe & LOWPROBE_TOPOLOGY))
output_format = OUTPUT_EXPORT_LIST;
pr = blkid_new_probe();
if (!pr)
goto exit;
if (lowprobe & LOWPROBE_SUPERBLOCKS) {
blkid_probe_set_superblocks_flags(pr,
BLKID_SUBLKS_LABEL | BLKID_SUBLKS_UUID |
BLKID_SUBLKS_TYPE | BLKID_SUBLKS_SECTYPE |
BLKID_SUBLKS_USAGE | BLKID_SUBLKS_VERSION);
if (fltr_usage && blkid_probe_filter_superblocks_usage(
pr, fltr_flag, fltr_usage))
goto exit;
else if (fltr_type && blkid_probe_filter_superblocks_type(
pr, fltr_flag, fltr_type))
goto exit;
}
for (i = 0; i < numdev; i++) {
err = lowprobe_device(pr, devices[i], lowprobe, show,
output_format,
(blkid_loff_t) offset,
(blkid_loff_t) size);
if (err)
break;
}
blkid_free_probe(pr);
} else if (eval) {
/*
* Evaluate API
*/
char *res = blkid_evaluate_tag(search_type, search_value, NULL);
if (res) {
err = 0;
printf("%s\n", res);
}
} else if (lookup) {
/*
* Classic (cache based) API
*/
blkid_dev dev;
if (!search_type) {
fprintf(stderr, "The lookup option requires a "
"search type specified using -t\n");
exit(BLKID_EXIT_OTHER);
}
/* Load any additional devices not in the cache */
for (i = 0; i < numdev; i++)
blkid_get_dev(cache, devices[i], BLKID_DEV_NORMAL);
if ((dev = blkid_find_dev_with_tag(cache, search_type,
search_value))) {
print_tags(dev, show, output_format);
err = 0;
}
/* If we didn't specify a single device, show all available devices */
} else if (!numdev) {
blkid_dev_iterate iter;
blkid_dev dev;
blkid_probe_all(cache);
iter = blkid_dev_iterate_begin(cache);
blkid_dev_set_search(iter, search_type, search_value);
while (blkid_dev_next(iter, &dev) == 0) {
dev = blkid_verify(cache, dev);
if (!dev)
continue;
print_tags(dev, show, output_format);
err = 0;
}
blkid_dev_iterate_end(iter);
/* Add all specified devices to cache (optionally display tags) */
} else for (i = 0; i < numdev; i++) {
blkid_dev dev = blkid_get_dev(cache, devices[i],
BLKID_DEV_NORMAL);
if (dev) {
if (search_type &&
!blkid_dev_has_tag(dev, search_type,
search_value))
continue;
print_tags(dev, show, output_format);
err = 0;
}
}
exit:
free(search_type);
free(search_value);
free_types_list(fltr_type);
if (!lowprobe && !eval)
blkid_put_cache(cache);
free(devices);
return err;
}