/*
* 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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Attempt to dynamically link in the Veritas libvxvmsc.so so that we can
* see if there are any Veritas volumes on any of the slices.
*/
#include <stdlib.h>
#include <stdio.h>
#include <strings.h>
#include <sys/param.h>
#include <sys/errno.h>
#include <thread.h>
#include <synch.h>
#include <dlfcn.h>
#include <link.h>
#include <ctype.h>
#include "libdiskmgt.h"
#include "disks_private.h"
#define VXVM_LIB_NAME "libvxvmsc.so"
#define VXVM_NAME_SIZE 1
#define VXVM_PATH_SIZE 2
typedef char *vm_name_t;
typedef char *vm_path_t;
/*
* Pointers to libvxvmsc.so functions that we dynamically resolve.
*/
static int (*vxdl_libvxvm_get_version)(int version);
static int (*vxdl_libvxvm_get_conf)(int param);
static int (*vxdl_libvxvm_get_dgs)(int len, vm_name_t namep[]);
static int (*vxdl_libvxvm_get_disks)(vm_name_t dgname, int len,
vm_path_t pathp[]);
#define MAX_DISK_GROUPS 128
#define MAX_DISKS_DG 1024
struct vxvm_list {
struct vxvm_list *next;
char *slice;
};
static struct vxvm_list *vxvm_listp = NULL;
static time_t timestamp = 0;
static mutex_t vxvm_lock = DEFAULTMUTEX;
static int add_use_record(char *devname);
static void free_vxvm();
static void *init_vxvm();
static int is_ctds(char *name);
static int load_vxvm();
int
inuse_vxvm(char *slice, nvlist_t *attrs, int *errp)
{
int found = 0;
time_t curr_time;
char *sp = NULL;
*errp = 0;
if (slice == NULL) {
return (found);
}
/*
* Since vxvm "encapsulates" the disk we need to match on any
* slice passed in. Strip the slice component from the devname.
*/
if (is_ctds(slice)) {
if ((sp = strrchr(slice, '/')) == NULL)
sp = slice;
while (*sp && *sp != 's')
sp++;
if (*sp)
*sp = 0;
else
sp = NULL;
}
(void) mutex_lock(&vxvm_lock);
curr_time = time(NULL);
if (timestamp < curr_time && (curr_time - timestamp) > 60) {
free_vxvm(); /* free old entries */
*errp = load_vxvm(); /* load the cache */
timestamp = curr_time;
}
if (*errp == 0) {
struct vxvm_list *listp;
listp = vxvm_listp;
while (listp != NULL) {
if (strcmp(slice, listp->slice) == 0) {
libdiskmgt_add_str(attrs, DM_USED_BY,
DM_USE_VXVM, errp);
libdiskmgt_add_str(attrs, DM_USED_NAME,
"", errp);
found = 1;
break;
}
listp = listp->next;
}
}
(void) mutex_unlock(&vxvm_lock);
/* restore slice name to orignal value */
if (sp != NULL)
*sp = 's';
return (found);
}
static int
add_use_record(char *devname)
{
struct vxvm_list *sp;
sp = (struct vxvm_list *)malloc(sizeof (struct vxvm_list));
if (sp == NULL) {
return (ENOMEM);
}
if ((sp->slice = strdup(devname)) == NULL) {
free(sp);
return (ENOMEM);
}
sp->next = vxvm_listp;
vxvm_listp = sp;
/*
* Since vxvm "encapsulates" the disk we need to match on any
* slice passed in. Strip the slice component from the devname.
*/
if (is_ctds(sp->slice)) {
char *dp;
if ((dp = strrchr(sp->slice, '/')) == NULL)
dp = sp->slice;
while (*dp && *dp != 's')
dp++;
*dp = 0;
}
return (0);
}
/*
* If the input name is in c[t]ds format then return 1, otherwise return 0.
*/
static int
is_ctds(char *name)
{
char *p;
if ((p = strrchr(name, '/')) == NULL)
p = name;
else
p++;
if (*p++ != 'c') {
return (0);
}
/* skip controller digits */
while (isdigit(*p)) {
p++;
}
/* handle optional target */
if (*p == 't') {
p++;
/* skip over target */
while (isdigit(*p) || isupper(*p)) {
p++;
}
}
if (*p++ != 'd') {
return (0);
}
while (isdigit(*p)) {
p++;
}
if (*p++ != 's') {
return (0);
}
/* check the slice number */
while (isdigit(*p)) {
p++;
}
if (*p != 0) {
return (0);
}
return (1);
}
/*
* Free the list of vxvm entries.
*/
static void
free_vxvm()
{
struct vxvm_list *listp = vxvm_listp;
struct vxvm_list *nextp;
while (listp != NULL) {
nextp = listp->next;
free((void *)listp->slice);
free((void *)listp);
listp = nextp;
}
vxvm_listp = NULL;
}
/*
* Try to dynamically link the vxvm functions we need.
*/
static void *
init_vxvm()
{
void *lh;
if ((lh = dlopen(VXVM_LIB_NAME, RTLD_NOW)) == NULL) {
return (NULL);
}
if ((vxdl_libvxvm_get_version = (int (*)(int))dlsym(lh,
"libvxvm_get_version")) == NULL) {
(void) dlclose(lh);
return (NULL);
}
if ((vxdl_libvxvm_get_conf = (int (*)(int))dlsym(lh,
"libvxvm_get_conf")) == NULL) {
(void) dlclose(lh);
return (NULL);
}
if ((vxdl_libvxvm_get_dgs = (int (*)(int, vm_name_t []))dlsym(lh,
"libvxvm_get_dgs")) == NULL) {
(void) dlclose(lh);
return (NULL);
}
if ((vxdl_libvxvm_get_disks = (int (*)(vm_name_t, int, vm_path_t []))
dlsym(lh, "libvxvm_get_disks")) == NULL) {
(void) dlclose(lh);
return (NULL);
}
return (lh);
}
static int
load_vxvm()
{
void *lh;
int vers;
int nsize;
int psize;
int n_disk_groups;
vm_name_t *namep;
char *pnp;
vm_path_t *pathp;
int i;
if ((lh = init_vxvm()) == NULL) {
/* No library. */
return (0);
}
vers = (vxdl_libvxvm_get_version)(1 << 8);
if (vers == -1) {
/* unsupported version */
(void) dlclose(lh);
return (0);
}
nsize = (vxdl_libvxvm_get_conf)(VXVM_NAME_SIZE);
psize = (vxdl_libvxvm_get_conf)(VXVM_PATH_SIZE);
if (nsize == -1 || psize == -1) {
(void) dlclose(lh);
return (0);
}
namep = (vm_name_t *)calloc(MAX_DISK_GROUPS, nsize);
if (namep == NULL) {
(void) dlclose(lh);
return (ENOMEM);
}
pathp = (vm_path_t *)calloc(MAX_DISKS_DG, psize);
if (pathp == NULL) {
(void) dlclose(lh);
free(namep);
return (ENOMEM);
}
n_disk_groups = (vxdl_libvxvm_get_dgs)(MAX_DISK_GROUPS, namep);
if (n_disk_groups < 0) {
(void) dlclose(lh);
free(namep);
free(pathp);
return (0);
}
pnp = (char *)namep;
for (i = 0; i < n_disk_groups; i++) {
int n_disks;
n_disks = (vxdl_libvxvm_get_disks)(pnp, MAX_DISKS_DG, pathp);
if (n_disks >= 0) {
int j;
char *ppp;
ppp = (char *)pathp;
for (j = 0; j < n_disks; j++) {
if (strncmp(ppp, "/dev/vx/", 8) == 0) {
char *pslash;
char nm[MAXPATHLEN];
pslash = strrchr(ppp, '/');
pslash++;
(void) snprintf(nm, sizeof (nm),
"/dev/dsk/%s", pslash);
if (add_use_record(nm)) {
(void) dlclose(lh);
free(pathp);
free(namep);
return (ENOMEM);
}
} else {
if (add_use_record(ppp)) {
(void) dlclose(lh);
free(pathp);
free(namep);
return (ENOMEM);
}
}
ppp += psize;
}
}
pnp += nsize;
}
(void) dlclose(lh);
free(pathp);
free(namep);
return (0);
}