OpenSolaris_b135/lib/libdiskmgt/common/entry.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <fcntl.h>
#include <libdevinfo.h>
#include <stdio.h>
#include <sys/sunddi.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <libintl.h>
#include <locale.h>
#include <sys/debug.h>
#include <strings.h>
#include <sys/stat.h>
#include <sys/swap.h>
#include "libdiskmgt.h"
#include "disks_private.h"
#include "partition.h"
#define ANY_ZPOOL_USE(who) \
(((who) == DM_WHO_ZPOOL_FORCE) || \
((who) == DM_WHO_ZPOOL) || \
((who) == DM_WHO_ZPOOL_SPARE))
extern char *getfullblkname();
extern dm_desc_type_t drive_assoc_types[];
extern dm_desc_type_t bus_assoc_types[];
extern dm_desc_type_t controller_assoc_types[];
extern dm_desc_type_t media_assoc_types[];
extern dm_desc_type_t slice_assoc_types[];
extern dm_desc_type_t partition_assoc_types[];
extern dm_desc_type_t path_assoc_types[];
extern dm_desc_type_t alias_assoc_types[];
static dm_descriptor_t *ptr_array_to_desc_array(descriptor_t **ptrs, int *errp);
static descriptor_t **desc_array_to_ptr_array(dm_descriptor_t *da, int *errp);
static int build_usage_string(char *dname, char *by, char *data, char **use,
int *found, int *errp);
void
dm_free_descriptor(dm_descriptor_t desc)
{
descriptor_t *dp;
if (desc == NULL) {
return;
}
dp = (descriptor_t *)(uintptr_t)desc;
cache_wlock();
cache_free_descriptor(dp);
cache_unlock();
}
void
dm_free_descriptors(dm_descriptor_t *desc_list)
{
descriptor_t **dp;
int error;
if (desc_list == NULL) {
return;
}
dp = desc_array_to_ptr_array(desc_list, &error);
if (error != 0) {
free(desc_list);
return;
}
cache_wlock();
cache_free_descriptors(dp);
cache_unlock();
}
/*ARGSUSED*/
void
dm_free_name(char *name)
{
free(name);
}
dm_descriptor_t *
dm_get_associated_descriptors(dm_descriptor_t desc, dm_desc_type_t type,
int *errp)
{
descriptor_t **descs = NULL;
descriptor_t *dp;
dp = (descriptor_t *)(uintptr_t)desc;
cache_wlock();
if (!cache_is_valid_desc(dp)) {
cache_unlock();
*errp = EBADF;
return (NULL);
}
/* verify that the descriptor is still valid */
if (dp->p.generic == NULL) {
cache_unlock();
*errp = ENODEV;
return (NULL);
}
switch (dp->type) {
case DM_DRIVE:
descs = drive_get_assoc_descriptors(dp, type, errp);
break;
case DM_BUS:
descs = bus_get_assoc_descriptors(dp, type, errp);
break;
case DM_CONTROLLER:
descs = controller_get_assoc_descriptors(dp, type, errp);
break;
case DM_MEDIA:
descs = media_get_assoc_descriptors(dp, type, errp);
break;
case DM_SLICE:
descs = slice_get_assoc_descriptors(dp, type, errp);
break;
case DM_PARTITION:
descs = partition_get_assoc_descriptors(dp, type, errp);
break;
case DM_PATH:
descs = path_get_assoc_descriptors(dp, type, errp);
break;
case DM_ALIAS:
descs = alias_get_assoc_descriptors(dp, type, errp);
break;
default:
*errp = EINVAL;
break;
}
cache_unlock();
return (ptr_array_to_desc_array(descs, errp));
}
dm_desc_type_t *
dm_get_associated_types(dm_desc_type_t type)
{
switch (type) {
case DM_DRIVE:
return (drive_assoc_types);
case DM_BUS:
return (bus_assoc_types);
case DM_CONTROLLER:
return (controller_assoc_types);
case DM_MEDIA:
return (media_assoc_types);
case DM_SLICE:
return (slice_assoc_types);
case DM_PARTITION:
return (partition_assoc_types);
case DM_PATH:
return (path_assoc_types);
case DM_ALIAS:
return (alias_assoc_types);
}
return (NULL);
}
nvlist_t *
dm_get_attributes(dm_descriptor_t desc, int *errp)
{
descriptor_t *dp;
nvlist_t *attrs = NULL;
dp = (descriptor_t *)(uintptr_t)desc;
cache_rlock();
if (!cache_is_valid_desc(dp)) {
cache_unlock();
*errp = EBADF;
return (NULL);
}
/* verify that the descriptor is still valid */
if (dp->p.generic == NULL) {
cache_unlock();
*errp = ENODEV;
return (NULL);
}
switch (dp->type) {
case DM_DRIVE:
attrs = drive_get_attributes(dp, errp);
break;
case DM_BUS:
attrs = bus_get_attributes(dp, errp);
break;
case DM_CONTROLLER:
attrs = controller_get_attributes(dp, errp);
break;
case DM_MEDIA:
attrs = media_get_attributes(dp, errp);
break;
case DM_SLICE:
attrs = slice_get_attributes(dp, errp);
break;
case DM_PARTITION:
attrs = partition_get_attributes(dp, errp);
break;
case DM_PATH:
attrs = path_get_attributes(dp, errp);
break;
case DM_ALIAS:
attrs = alias_get_attributes(dp, errp);
break;
default:
*errp = EINVAL;
break;
}
cache_unlock();
return (attrs);
}
dm_descriptor_t
dm_get_descriptor_by_name(dm_desc_type_t desc_type, char *name, int *errp)
{
dm_descriptor_t desc = NULL;
cache_wlock();
switch (desc_type) {
case DM_DRIVE:
desc = (uintptr_t)drive_get_descriptor_by_name(name, errp);
break;
case DM_BUS:
desc = (uintptr_t)bus_get_descriptor_by_name(name, errp);
break;
case DM_CONTROLLER:
desc = (uintptr_t)controller_get_descriptor_by_name(name,
errp);
break;
case DM_MEDIA:
desc = (uintptr_t)media_get_descriptor_by_name(name, errp);
break;
case DM_SLICE:
desc = (uintptr_t)slice_get_descriptor_by_name(name, errp);
break;
case DM_PARTITION:
desc = (uintptr_t)partition_get_descriptor_by_name(name,
errp);
break;
case DM_PATH:
desc = (uintptr_t)path_get_descriptor_by_name(name, errp);
break;
case DM_ALIAS:
desc = (uintptr_t)alias_get_descriptor_by_name(name, errp);
break;
default:
*errp = EINVAL;
break;
}
cache_unlock();
return (desc);
}
dm_descriptor_t *
dm_get_descriptors(dm_desc_type_t type, int filter[], int *errp)
{
descriptor_t **descs = NULL;
cache_wlock();
switch (type) {
case DM_DRIVE:
descs = drive_get_descriptors(filter, errp);
break;
case DM_BUS:
descs = bus_get_descriptors(filter, errp);
break;
case DM_CONTROLLER:
descs = controller_get_descriptors(filter, errp);
break;
case DM_MEDIA:
descs = media_get_descriptors(filter, errp);
break;
case DM_SLICE:
descs = slice_get_descriptors(filter, errp);
break;
case DM_PARTITION:
descs = partition_get_descriptors(filter, errp);
break;
case DM_PATH:
descs = path_get_descriptors(filter, errp);
break;
case DM_ALIAS:
descs = alias_get_descriptors(filter, errp);
break;
default:
*errp = EINVAL;
break;
}
cache_unlock();
return (ptr_array_to_desc_array(descs, errp));
}
char *
dm_get_name(dm_descriptor_t desc, int *errp)
{
descriptor_t *dp;
char *nm = NULL;
char *name = NULL;
dp = (descriptor_t *)(uintptr_t)desc;
cache_rlock();
if (!cache_is_valid_desc(dp)) {
cache_unlock();
*errp = EBADF;
return (NULL);
}
/* verify that the descriptor is still valid */
if (dp->p.generic == NULL) {
cache_unlock();
*errp = ENODEV;
return (NULL);
}
switch (dp->type) {
case DM_DRIVE:
nm = (drive_get_name(dp));
break;
case DM_BUS:
nm = (bus_get_name(dp));
break;
case DM_CONTROLLER:
nm = (controller_get_name(dp));
break;
case DM_MEDIA:
nm = (media_get_name(dp));
break;
case DM_SLICE:
nm = (slice_get_name(dp));
break;
case DM_PARTITION:
nm = (partition_get_name(dp));
break;
case DM_PATH:
nm = (path_get_name(dp));
break;
case DM_ALIAS:
nm = (alias_get_name(dp));
break;
}
cache_unlock();
*errp = 0;
if (nm != NULL) {
name = strdup(nm);
if (name == NULL) {
*errp = ENOMEM;
return (NULL);
}
return (name);
}
return (NULL);
}
nvlist_t *
dm_get_stats(dm_descriptor_t desc, int stat_type, int *errp)
{
descriptor_t *dp;
nvlist_t *stats = NULL;
dp = (descriptor_t *)(uintptr_t)desc;
cache_rlock();
if (!cache_is_valid_desc(dp)) {
cache_unlock();
*errp = EBADF;
return (NULL);
}
/* verify that the descriptor is still valid */
if (dp->p.generic == NULL) {
cache_unlock();
*errp = ENODEV;
return (NULL);
}
switch (dp->type) {
case DM_DRIVE:
stats = drive_get_stats(dp, stat_type, errp);
break;
case DM_BUS:
stats = bus_get_stats(dp, stat_type, errp);
break;
case DM_CONTROLLER:
stats = controller_get_stats(dp, stat_type, errp);
break;
case DM_MEDIA:
stats = media_get_stats(dp, stat_type, errp);
break;
case DM_SLICE:
if (stat_type == DM_SLICE_STAT_USE) {
/*
* If NOINUSE_CHECK is set, we do not perform
* the in use checking if the user has set stat_type
* DM_SLICE_STAT_USE
*/
if (NOINUSE_SET) {
stats = NULL;
break;
}
}
stats = slice_get_stats(dp, stat_type, errp);
break;
case DM_PARTITION:
stats = partition_get_stats(dp, stat_type, errp);
break;
case DM_PATH:
stats = path_get_stats(dp, stat_type, errp);
break;
case DM_ALIAS:
stats = alias_get_stats(dp, stat_type, errp);
break;
default:
*errp = EINVAL;
break;
}
cache_unlock();
return (stats);
}
dm_desc_type_t
dm_get_type(dm_descriptor_t desc)
{
descriptor_t *dp;
dp = (descriptor_t *)(uintptr_t)desc;
cache_rlock();
if (!cache_is_valid_desc(dp)) {
cache_unlock();
return (-1);
}
cache_unlock();
return (dp->type);
}
/*
* Returns, via slices paramater, a dm_descriptor_t list of
* slices for the named disk drive.
*/
void
dm_get_slices(char *drive, dm_descriptor_t **slices, int *errp)
{
dm_descriptor_t alias;
dm_descriptor_t *media;
dm_descriptor_t *disk;
*slices = NULL;
*errp = 0;
if (drive == NULL) {
return;
}
alias = dm_get_descriptor_by_name(DM_ALIAS, drive, errp);
/*
* Errors must be handled by the caller. The dm_descriptor_t *
* values will be NULL if an error occured in these calls.
*/
if (alias != NULL) {
disk = dm_get_associated_descriptors(alias, DM_DRIVE, errp);
dm_free_descriptor(alias);
if (disk != NULL) {
media = dm_get_associated_descriptors(*disk,
DM_MEDIA, errp);
dm_free_descriptors(disk);
if (media != NULL) {
*slices = dm_get_associated_descriptors(*media,
DM_SLICE, errp);
dm_free_descriptors(media);
}
}
}
}
/*
* Convenience function to get slice stats
*/
void
dm_get_slice_stats(char *slice, nvlist_t **dev_stats, int *errp)
{
dm_descriptor_t devp;
*dev_stats = NULL;
*errp = 0;
if (slice == NULL) {
return;
}
/*
* Errors must be handled by the caller. The dm_descriptor_t *
* values will be NULL if an error occured in these calls.
*/
devp = dm_get_descriptor_by_name(DM_SLICE, slice, errp);
if (devp != NULL) {
*dev_stats = dm_get_stats(devp, DM_SLICE_STAT_USE,
errp);
dm_free_descriptor(devp);
}
}
/*
* Checks for overlapping slices. If the given device is a slice, and it
* overlaps with any non-backup slice on the disk, return true with a detailed
* description similar to dm_inuse().
*/
int
dm_isoverlapping(char *slicename, char **overlaps_with, int *errp)
{
dm_descriptor_t slice = NULL;
dm_descriptor_t *media = NULL;
dm_descriptor_t *slices = NULL;
int i = 0;
uint32_t in_snum;
uint64_t start_block = 0;
uint64_t end_block = 0;
uint64_t media_size = 0;
uint64_t size = 0;
nvlist_t *media_attrs = NULL;
nvlist_t *slice_attrs = NULL;
int ret = 0;
slice = dm_get_descriptor_by_name(DM_SLICE, slicename, errp);
if (slice == NULL)
goto out;
/*
* Get the list of slices be fetching the associated media, and then all
* associated slices.
*/
media = dm_get_associated_descriptors(slice, DM_MEDIA, errp);
if (media == NULL || *media == NULL || *errp != 0)
goto out;
slices = dm_get_associated_descriptors(*media, DM_SLICE, errp);
if (slices == NULL || *slices == NULL || *errp != 0)
goto out;
media_attrs = dm_get_attributes(*media, errp);
if (media_attrs == NULL || *errp)
goto out;
*errp = nvlist_lookup_uint64(media_attrs, DM_NACCESSIBLE, &media_size);
if (*errp != 0)
goto out;
slice_attrs = dm_get_attributes(slice, errp);
if (slice_attrs == NULL || *errp != 0)
goto out;
*errp = nvlist_lookup_uint64(slice_attrs, DM_START, &start_block);
if (*errp != 0)
goto out;
*errp = nvlist_lookup_uint64(slice_attrs, DM_SIZE, &size);
if (*errp != 0)
goto out;
*errp = nvlist_lookup_uint32(slice_attrs, DM_INDEX, &in_snum);
if (*errp != 0)
goto out;
end_block = (start_block + size) - 1;
for (i = 0; slices[i]; i ++) {
uint64_t other_start;
uint64_t other_end;
uint64_t other_size;
uint32_t snum;
nvlist_t *other_attrs = dm_get_attributes(slices[i], errp);
if (other_attrs == NULL)
continue;
if (*errp != 0)
goto out;
*errp = nvlist_lookup_uint64(other_attrs, DM_START,
&other_start);
if (*errp) {
nvlist_free(other_attrs);
goto out;
}
*errp = nvlist_lookup_uint64(other_attrs, DM_SIZE,
&other_size);
if (*errp) {
nvlist_free(other_attrs);
ret = -1;
goto out;
}
other_end = (other_size + other_start) - 1;
*errp = nvlist_lookup_uint32(other_attrs, DM_INDEX,
&snum);
if (*errp) {
nvlist_free(other_attrs);
ret = -1;
goto out;
}
/*
* Check to see if there are > 2 overlapping regions
* on this media in the same region as this slice.
* This is done by assuming the following:
* Slice 2 is the backup slice if it is the size
* of the whole disk
* If slice 2 is the overlap and slice 2 is the size of
* the whole disk, continue. If another slice is found
* that overlaps with our slice, return it.
* There is the potential that there is more than one slice
* that our slice overlaps with, however, we only return
* the first overlapping slice we find.
*
*/
if (start_block >= other_start && start_block <= other_end) {
if ((snum == 2 && (other_size == media_size)) ||
snum == in_snum) {
continue;
} else {
char *str = dm_get_name(slices[i], errp);
if (*errp != 0) {
nvlist_free(other_attrs);
ret = -1;
goto out;
}
*overlaps_with = strdup(str);
dm_free_name(str);
nvlist_free(other_attrs);
ret = 1;
goto out;
}
} else if (other_start >= start_block &&
other_start <= end_block) {
if ((snum == 2 && (other_size == media_size)) ||
snum == in_snum) {
continue;
} else {
char *str = dm_get_name(slices[i], errp);
if (*errp != 0) {
nvlist_free(other_attrs);
ret = -1;
goto out;
}
*overlaps_with = strdup(str);
dm_free_name(str);
nvlist_free(other_attrs);
ret = 1;
goto out;
}
}
nvlist_free(other_attrs);
}
out:
if (media_attrs)
nvlist_free(media_attrs);
if (slice_attrs)
nvlist_free(slice_attrs);
if (slices)
dm_free_descriptors(slices);
if (media)
dm_free_descriptors(media);
if (slice)
dm_free_descriptor(slice);
return (ret);
}
/*
* Get the full list of swap entries. Returns -1 on error, or >= 0 to
* indicate the number of entries in the list. Callers are responsible
* for calling dm_free_swapentries() to deallocate memory. If this
* returns 0, the swaptbl_t still needs to be freed.
*/
int
dm_get_swapentries(swaptbl_t **stp, int *errp)
{
int count, i;
swaptbl_t *tbl;
char *ptr;
*stp = NULL;
/* get number of swap entries */
if ((count = swapctl(SC_GETNSWP, NULL)) < 0) {
*errp = errno;
return (-1);
}
if (count == 0) {
return (0);
}
/* allocate space */
tbl = calloc(1, sizeof (int) + count * sizeof (swapent_t));
if (tbl == NULL) {
*errp = ENOMEM;
return (-1);
}
ptr = calloc(1, count * MAXPATHLEN);
if (ptr == NULL) {
*errp = ENOMEM;
free(tbl);
return (-1);
}
/* set up pointers to the pathnames */
tbl->swt_n = count;
for (i = 0; i < count; i++) {
tbl->swt_ent[i].ste_path = ptr;
ptr += MAXPATHLEN;
}
/* get list of swap paths */
count = swapctl(SC_LIST, tbl);
if (count < 0) {
*errp = errno;
free(ptr);
free(tbl);
return (-1);
}
*stp = tbl;
return (count);
}
/* ARGSUSED */
void
dm_free_swapentries(swaptbl_t *stp)
{
ASSERT(stp != NULL);
free(stp->swt_ent[0].ste_path);
free(stp);
}
/*
* Check a slice to see if it's being used by swap.
*/
int
dm_inuse_swap(const char *dev_name, int *errp)
{
int count;
int found;
swaptbl_t *tbl = NULL;
*errp = 0;
count = dm_get_swapentries(&tbl, errp);
if (count < 0 || *errp) {
if (tbl)
dm_free_swapentries(tbl);
return (-1);
}
/* if there are no swap entries, we're done */
if (!count) {
return (0);
}
ASSERT(tbl != NULL);
found = 0;
while (count--) {
if (strcmp(dev_name, tbl->swt_ent[count].ste_path) == 0) {
found = 1;
break;
}
}
dm_free_swapentries(tbl);
return (found);
}
/*
* Returns 'in use' details, if found, about a specific dev_name,
* based on the caller(who). It is important to note that it is possible
* for there to be more than one 'in use' statistic regarding a dev_name.
* The **msg parameter returns a list of 'in use' details. This message
* is formatted via gettext().
*/
int
dm_inuse(char *dev_name, char **msg, dm_who_type_t who, int *errp)
{
nvlist_t *dev_stats = NULL;
char *by, *data;
nvpair_t *nvwhat = NULL;
nvpair_t *nvdesc = NULL;
int found = 0;
int err;
char *dname = NULL;
*errp = 0;
*msg = NULL;
/*
* If the user doesn't want to do in use checking, return.
*/
if (NOINUSE_SET)
return (0);
dname = getfullblkname(dev_name);
/*
* If we cannot find the block name, we cannot check the device
* for in use statistics. So, return found, which is == 0.
*/
if (dname == NULL || *dname == '\0') {
return (found);
}
/*
* Slice stats for swap devices are only returned if mounted
* (e.g. /tmp). Other devices or files being used for swap
* are ignored, so we add a special check here to use swapctl(2)
* to perform in-use checking.
*/
if (ANY_ZPOOL_USE(who) && (err = dm_inuse_swap(dname, errp))) {
/* on error, dm_inuse_swap sets errp */
if (err < 0) {
free(dname);
return (err);
}
/* simulate a mounted swap device */
(void) build_usage_string(dname, DM_USE_MOUNT, "swap", msg,
&found, errp);
/* if this fails, dm_get_usage_string changed */
ASSERT(found == 1);
free(dname);
return (found);
}
dm_get_slice_stats(dname, &dev_stats, errp);
if (dev_stats == NULL) {
/*
* If there is an error, but it isn't a no device found error
* return the error as recorded. Otherwise, with a full
* block name, we might not be able to get the slice
* associated, and will get an ENODEV error. For example,
* an SVM metadevice will return a value from getfullblkname()
* but libdiskmgt won't be able to find this device for
* statistics gathering. This is expected and we should not
* report errnoneous errors.
*/
if (*errp) {
if (*errp == ENODEV) {
*errp = 0;
}
}
free(dname);
return (found);
}
for (;;) {
nvwhat = nvlist_next_nvpair(dev_stats, nvdesc);
nvdesc = nvlist_next_nvpair(dev_stats, nvwhat);
/*
* End of the list found.
*/
if (nvwhat == NULL || nvdesc == NULL) {
break;
}
/*
* Otherwise, we check to see if this client(who) cares
* about this in use scenario
*/
ASSERT(strcmp(nvpair_name(nvwhat), DM_USED_BY) == 0);
ASSERT(strcmp(nvpair_name(nvdesc), DM_USED_NAME) == 0);
/*
* If we error getting the string value continue on
* to the next pair(if there is one)
*/
if (nvpair_value_string(nvwhat, &by)) {
continue;
}
if (nvpair_value_string(nvdesc, &data)) {
continue;
}
switch (who) {
case DM_WHO_MKFS:
/*
* mkfs is not in use for these cases.
* All others are in use.
*/
if (strcmp(by, DM_USE_LU) == 0 ||
strcmp(by, DM_USE_FS) == 0 ||
strcmp(by, DM_USE_EXPORTED_ZPOOL) == 0) {
break;
}
if (build_usage_string(dname,
by, data, msg, &found, errp) != 0) {
if (*errp) {
goto out;
}
}
break;
case DM_WHO_SWAP:
/*
* Not in use for this.
*/
if (strcmp(by, DM_USE_DUMP) == 0 ||
strcmp(by, DM_USE_FS) == 0 ||
strcmp(by, DM_USE_EXPORTED_ZPOOL) == 0) {
break;
}
if (strcmp(by, DM_USE_LU) == 0 &&
strcmp(data, "-") == 0) {
break;
}
if (strcmp(by, DM_USE_VFSTAB) == 0 &&
strcmp(data, "") == 0) {
break;
}
if (build_usage_string(dname,
by, data, msg, &found, errp) != 0) {
if (*errp) {
goto out;
}
}
break;
case DM_WHO_DUMP:
/*
* Not in use for this.
*/
if ((strcmp(by, DM_USE_MOUNT) == 0 &&
strcmp(data, "swap") == 0) ||
strcmp(by, DM_USE_DUMP) == 0 ||
strcmp(by, DM_USE_FS) == 0 ||
strcmp(by, DM_USE_EXPORTED_ZPOOL) == 0) {
break;
}
if (build_usage_string(dname,
by, data, msg, &found, errp)) {
if (*errp) {
goto out;
}
}
break;
case DM_WHO_FORMAT:
if (strcmp(by, DM_USE_FS) == 0 ||
strcmp(by, DM_USE_EXPORTED_ZPOOL) == 0)
break;
if (build_usage_string(dname,
by, data, msg, &found, errp) != 0) {
if (*errp) {
goto out;
}
}
break;
case DM_WHO_ZPOOL_FORCE:
if (strcmp(by, DM_USE_FS) == 0 ||
strcmp(by, DM_USE_EXPORTED_ZPOOL) == 0)
break;
/* FALLTHROUGH */
case DM_WHO_ZPOOL:
if (build_usage_string(dname,
by, data, msg, &found, errp) != 0) {
if (*errp)
goto out;
}
break;
case DM_WHO_ZPOOL_SPARE:
if (strcmp(by, DM_USE_SPARE_ZPOOL) != 0) {
if (build_usage_string(dname, by,
data, msg, &found, errp) != 0) {
if (*errp)
goto out;
}
}
break;
default:
/*
* nothing found in use for this client
* of libdiskmgt. Default is 'not in use'.
*/
break;
}
}
out:
if (dname != NULL)
free(dname);
if (dev_stats != NULL)
nvlist_free(dev_stats);
return (found);
}
void
dm_get_usage_string(char *what, char *how, char **usage_string)
{
if (usage_string == NULL || what == NULL) {
return;
}
*usage_string = NULL;
if (strcmp(what, DM_USE_MOUNT) == 0) {
if (strcmp(how, "swap") == 0) {
*usage_string = dgettext(TEXT_DOMAIN,
"%s is currently used by swap. Please see swap(1M)."
"\n");
} else {
*usage_string = dgettext(TEXT_DOMAIN,
"%s is currently mounted on %s."
" Please see umount(1M).\n");
}
} else if (strcmp(what, DM_USE_VFSTAB) == 0) {
*usage_string = dgettext(TEXT_DOMAIN,
"%s is normally mounted on %s according to /etc/vfstab. "
"Please remove this entry to use this device.\n");
} else if (strcmp(what, DM_USE_FS) == 0) {
*usage_string = dgettext(TEXT_DOMAIN,
"%s contains a %s filesystem.\n");
} else if (strcmp(what, DM_USE_SVM) == 0) {
if (strcmp(how, "mdb") == 0) {
*usage_string = dgettext(TEXT_DOMAIN,
"%s contains an SVM %s. Please see "
"metadb(1M).\n");
} else {
*usage_string = dgettext(TEXT_DOMAIN,
"%s is part of SVM volume %s. "
"Please see metaclear(1M).\n");
}
} else if (strcmp(what, DM_USE_VXVM) == 0) {
*usage_string = dgettext(TEXT_DOMAIN,
"%s is part of VxVM volume %s.\n");
} else if (strcmp(what, DM_USE_LU) == 0) {
*usage_string = dgettext(TEXT_DOMAIN,
"%s is in use for live upgrade %s. Please see ludelete(1M)."
"\n");
} else if (strcmp(what, DM_USE_DUMP) == 0) {
*usage_string = dgettext(TEXT_DOMAIN,
"%s is in use by %s. Please see dumpadm(1M)."
"\n");
} else if (strcmp(what, DM_USE_EXPORTED_ZPOOL) == 0) {
*usage_string = dgettext(TEXT_DOMAIN,
"%s is part of exported or potentially active ZFS pool %s. "
"Please see zpool(1M).\n");
} else if (strcmp(what, DM_USE_ACTIVE_ZPOOL) == 0) {
*usage_string = dgettext(TEXT_DOMAIN,
"%s is part of active ZFS pool %s. Please see zpool(1M)."
"\n");
} else if (strcmp(what, DM_USE_SPARE_ZPOOL) == 0) {
*usage_string = dgettext(TEXT_DOMAIN,
"%s is reserved as a hot spare for ZFS pool %s. Please "
"see zpool(1M).\n");
} else if (strcmp(what, DM_USE_L2CACHE_ZPOOL) == 0) {
*usage_string = dgettext(TEXT_DOMAIN,
"%s is in use as a cache device for ZFS pool %s. "
"Please see zpool(1M).\n");
}
}
void
libdiskmgt_add_str(nvlist_t *attrs, char *name, char *val, int *errp)
{
if (*errp == 0) {
*errp = nvlist_add_string(attrs, name, val);
}
}
descriptor_t **
libdiskmgt_empty_desc_array(int *errp)
{
descriptor_t **empty;
empty = (descriptor_t **)calloc(1, sizeof (descriptor_t *));
if (empty == NULL) {
*errp = ENOMEM;
return (NULL);
}
empty[0] = NULL;
*errp = 0;
return (empty);
}
void
libdiskmgt_init_debug()
{
char *valp;
if ((valp = getenv(DM_DEBUG)) != NULL) {
dm_debug = atoi(valp);
}
}
int
libdiskmgt_str_eq(char *nm1, char *nm2)
{
if (nm1 == NULL) {
if (dm_debug) {
(void) fprintf(stderr, "WARNING: str_eq nm1 NULL\n");
}
if (nm2 == NULL) {
return (1);
} else {
return (0);
}
}
/* nm1 != NULL */
if (nm2 == NULL) {
if (dm_debug) {
(void) fprintf(stderr, "WARNING: str_eq nm2 NULL\n");
}
return (0);
}
if (strcmp(nm1, nm2) == 0) {
return (1);
}
return (0);
}
/*ARGSUSED*/
static descriptor_t **
desc_array_to_ptr_array(dm_descriptor_t *descs, int *errp)
{
#ifdef _LP64
return ((descriptor_t **)descs);
#else
/* convert the 64 bit descriptors to 32 bit ptrs */
int cnt;
int i;
descriptor_t **da;
for (cnt = 0; descs[cnt]; cnt++)
;
da = (descriptor_t **)calloc(cnt + 1, sizeof (descriptor_t *));
if (da == NULL) {
*errp = ENOMEM;
return (NULL);
}
for (i = 0; descs[i]; i++) {
da[i] = (descriptor_t *)(uintptr_t)descs[i];
}
*errp = 0;
free(descs);
return (da);
#endif
}
/*ARGSUSED*/
static dm_descriptor_t *
ptr_array_to_desc_array(descriptor_t **ptrs, int *errp)
{
#ifdef _LP64
return ((dm_descriptor_t *)ptrs);
#else
/* convert the 32 bit ptrs to the 64 bit descriptors */
int cnt;
int i;
dm_descriptor_t *da;
if (*errp != 0 || ptrs == NULL) {
return (NULL);
}
for (cnt = 0; ptrs[cnt]; cnt++)
;
da = (dm_descriptor_t *)calloc(cnt + 1, sizeof (dm_descriptor_t));
if (da == NULL) {
*errp = ENOMEM;
return (NULL);
}
for (i = 0; ptrs[i]; i++) {
da[i] = (uintptr_t)ptrs[i];
}
*errp = 0;
free(ptrs);
return (da);
#endif
}
/*
* Build the usage string for the in use data. Return the build string in
* the msg parameter. This function takes care of reallocing all the memory
* for this usage string. Usage string is returned already formatted for
* localization.
*/
static int
build_usage_string(char *dname, char *by, char *data, char **msg,
int *found, int *errp)
{
int len0;
int len1;
char *use;
char *p;
*errp = 0;
dm_get_usage_string(by, data, &use);
if (!use) {
return (-1);
}
if (*msg)
len0 = strlen(*msg);
else
len0 = 0;
/* LINTED */
len1 = snprintf(NULL, 0, use, dname, data);
/*
* If multiple in use details they
* are listed 1 per line for ease of
* reading. dm_find_usage_string
* formats these appropriately.
*/
if ((p = realloc(*msg, len0 + len1 + 1)) == NULL) {
*errp = errno;
free(*msg);
return (-1);
}
*msg = p;
/* LINTED */
(void) snprintf(*msg + len0, len1 + 1, use, dname, data);
(*found)++;
return (0);
}