/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * 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_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("libvxvmsc.so", RTLD_NOW)) == NULL) {
	    return (lh);
	}

	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);
}