tools/diskomizer/findap.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.
 */

#pragma ident	"@(#)findap.c	1.18	09/05/26 SMI"

#include <unistd.h>
#include <ftw.h>
#include <stdlib.h>
#include <stdio.h>
#include <strings.h>
#include <search.h>
#include <errno.h>
#include <sys/vtoc.h>

#define	COMMA ','
#define	COLON ':'

#include "findap.h"
struct devstore {
	struct other_paths *raw_or_cooked[2];
};
struct partstore {
	int nparts;
	struct devstore *devs;
};
struct lunstore {
	int nluns;
	struct partstore *parts;
};
struct pathstore {
	char *wwa;
	struct lunstore luns;
};

static struct pathstore *ps;
static int last_pathstore;
#ifdef FIND_AP_STATS
static int hit_count;
static int miss_count;
#endif
static size_t ndevtree;

static int
pscmp(const void *a, const void *b)
{
	struct pathstore *as, *bs;
	as = (struct pathstore *)a;
	bs = (struct pathstore *)b;
	return (strcmp(as->wwa, bs->wwa));
}
static int
add_to_dev_tree(const char *path, struct about_dev *entry)
{
	struct pathstore *new_ps;
	struct other_paths *op;
	struct pathstore *x;

	if ((new_ps = realloc(ps, (ndevtree + 1) *
	    sizeof (struct pathstore))) == NULL ||
		(op = malloc(sizeof (struct other_paths))) == NULL) {
		return (1);
	}

	if ((x = (struct pathstore *)
		calloc(1, sizeof (struct pathstore))) == NULL) {
		free(op);
		return (1);
	}
	op->path = strdup(path);
	x->wwa = entry->wwa;
	/*
	 * This extra check is a cheat, but a cheat that works.
	 * Since the devices tend to get created all at the same time
	 * nftw will tend to do all the nodes for the same disk
	 * one after another. This check stops us having to do
	 * any more lsearch() calls than are really needed.
	 */
	if (ps != NULL && pscmp(x, &new_ps[last_pathstore]) == 0) {
#ifdef FIND_AP_STATS
		hit_count++;
#endif
		ps = new_ps;
		new_ps = &new_ps[last_pathstore];
	} else {
#ifdef FIND_AP_STATS
		miss_count++;
#endif
		ps = new_ps;
		new_ps = lsearch(x, ps, &ndevtree,
		    sizeof (struct pathstore), pscmp);
		last_pathstore = new_ps - ps;
	}
	if (new_ps->wwa != entry->wwa)
		free(entry->wwa);
	free(x);
	if (new_ps->luns.nluns <= entry->lun) {
		struct partstore *tmp;
		int i;

		tmp = realloc(new_ps->luns.parts, sizeof (struct partstore) *
		    (entry->lun + 1));
		if (tmp == NULL)
			return (1);
		for (i = new_ps->luns.nluns; i <= entry->lun; i++) {
			tmp[i].nparts = 0;
			tmp[i].devs = NULL;
		}
		new_ps->luns.parts = tmp;
		new_ps->luns.nluns = entry->lun + 1;
	}
	if (new_ps->luns.parts[entry->lun].nparts <= entry->part) {
		struct devstore *tmp;
		int i, nparts;

		nparts = entry->part + 1;
		if (nparts < V_NUMPAR)
			nparts = V_NUMPAR;

		tmp = realloc(new_ps->luns.parts[entry->lun].devs,
		    sizeof (struct devstore) * nparts);
		if (tmp == NULL)
			return (1);
		for (i = new_ps->luns.parts[entry->lun].nparts;
		    i < nparts; i++) {
			tmp[i].raw_or_cooked[0] = NULL;
			tmp[i].raw_or_cooked[1] = NULL;
		}
		new_ps->luns.parts[entry->lun].devs = tmp;
		new_ps->luns.parts[entry->lun].nparts = nparts;
	}

	op->next = new_ps->luns.parts[
	    entry->lun].devs[entry->part].raw_or_cooked[entry->israw];
	new_ps->luns.parts[entry->lun].devs[
	    entry->part].raw_or_cooked[entry->israw] = op;

	return (0);
}
static char *
get_wwa(const char *path)
{
	char *tofree, *tmp;
	char *basename;

	tofree = strdup(path);
	tmp = tofree;

	if (tmp == NULL) {
		perror("strdup failed");
		return (NULL);
	}

	basename = strrchr(tofree, '/');

	if (basename == NULL)
		basename = tofree;
	else
		basename += 1;

	if (strncmp(basename, "ssd@", 4) != 0 || strlen(basename) <= 8) {
		free(tofree);
		return (NULL);
	}

	basename += 7;

	tmp = strchr(basename, COLON);
	if (tmp != NULL) {
		*tmp = NULL;
	}
	tmp = strchr(basename, COMMA);

	if (tmp != NULL) {
		*tmp = NULL;
		tmp = strdup(basename);
	} else {
		tmp = NULL;
	}

	free(tofree);

	return (tmp);
}

static long
get_lun(const char *path)
{
	int lun;
	char *tmp;
	tmp = strrchr(path, COLON);

	if (tmp == NULL)
		return (-1);
	while (tmp > path) {
		if (*tmp == COMMA)
			break;
		tmp--;
	}
	if (tmp <= path)
		return (-1);
	tmp++;

	errno = 0;
	lun = strtol(tmp, NULL, 16);

	if (lun == 0 && errno == EINVAL) {
		return (-1);
	}
	return (lun);
}
static char
find_part(const char *path)
{
	char part;
	char *tmp;

	tmp = strrchr(path, COLON);

	if (tmp == NULL)
		return (-1);

	tmp++;

	part = *tmp - 'a';

	if (part > (V_NUMPAR - 1) || part < 0)
		part = -1;
	return (part);
}
static char
is_raw(const char *path)
{
	char *tmp;

	tmp = strrchr(path, COMMA);

	if (tmp == NULL) {
		return (-1);
	}

	tmp++;

	if (strcmp(tmp, "raw") == 0)
		return (1);
	else
		return (0);
}

#ifdef NOT_USED
static void
print_dev(struct about_dev *dv)
{
	char *tmp;

	switch (dv->israw) {
		case 0: tmp = "block device";
				break;
		case 1: tmp = "raw device";
			break;
		default:
			tmp = "error";
			break;
	}
	(void) printf("WWA = %s, part = %c, %s\n",
	    dv->wwa == NULL ? "(nil)" : dv->wwa,
	    dv->part + 'a', tmp);
}
#endif
static void
print_otherpaths(struct other_paths *paths)
{
	while (paths != NULL) {
		(void) printf("%s\n", paths->path);
		paths = paths->next;
	}
}
void
print_paths(struct paths *paths)
{
	(void) printf("Logical path %s\n", paths->logicalpath);
	(void) print_otherpaths(paths->op);
}

static void
free_otherpaths(struct other_paths *paths)
{
	struct other_paths *p;

	while (paths) {
		p = paths->next;
		free(paths->path);
		free(paths);
		paths = p;
	}
}
void
free_paths(struct paths *paths)
{
	free_otherpaths(paths->op);
	if (paths->logicalpath != NULL)
		free(paths->logicalpath);
	free(paths);
}
static struct paths *
dup_paths(struct paths *src)
{
	struct paths *top;
	struct other_paths *tmp, *srctmp;

	if (src == NULL || (top = calloc(1, sizeof (struct paths))) == NULL) {
		return (NULL);
	}
	if ((top->logicalpath = strdup(src->logicalpath)) == NULL) {
		free(top);
		return (NULL);
	}
	if ((top->op = calloc(1, sizeof (struct other_paths))) == NULL) {
		free_paths(top);
		return (NULL);
	}
	for (tmp = top->op, srctmp = src->op; srctmp != NULL;
	    srctmp = srctmp->next) {
		if ((tmp->path = strdup(srctmp->path)) == NULL) {
			free_paths(top);
			return (NULL);
		}
		if (srctmp->next == NULL)
			break;
		if ((tmp->next = calloc(1, sizeof (struct other_paths))) ==
		    NULL) {
			free(tmp->path);
			free_paths(top);
			return (NULL);
		}
		tmp = tmp->next;
	}
	return (top);
}
/*ARGSUSED*/
static int
ftwfunc(const char *path, const struct stat *stat, int flag, struct FTW *ftw)
{
	struct about_dev thisdv;
	if (flag != FTW_F)
		return (0);


	thisdv.wwa = get_wwa(path);
	thisdv.part = find_part(path);
	thisdv.lun = get_lun(path);
	thisdv.israw = is_raw(path);

	if (thisdv.lun != -1 && thisdv.part != -1 && thisdv.wwa != NULL) {
		return (add_to_dev_tree(path, &thisdv));
	}
	return (0);
}
char *
full_path(char *link, char *target)
{
	char *tmp_target, *tmp_link;
	if ((link = strdup(link)) == NULL)
		return (NULL);
	/* first remove the link from the path leaving just the directories */
	tmp_link = strrchr(link, '/');
	if (tmp_link != NULL) {
		*tmp_link = NULL;
	}

	for (tmp_target = target; strncmp("../", tmp_target, 3) == 0;
	    tmp_target += 3) {
		tmp_link = strrchr(link, '/');
		if (tmp_link != NULL) {
			*tmp_link = NULL;
		}
	}
	tmp_link = malloc(strlen(link) + 1 + strlen(tmp_target) + 1);
	if (tmp_link != NULL)
		(void) sprintf(tmp_link, "%s/%s", link, tmp_target);

	free(link);
	return (tmp_link);
}
struct paths *
findap(const char *inpath, const char *devices)
{
	char link_data[1024];
	char *path, *fullpath = NULL;
	struct paths *pa;
	struct pathstore *entry;
	struct about_dev dv;
	struct pathstore this_ps;

	path = strdup(inpath);

	if (path == NULL)
		return (NULL);

	(void) memset(&link_data[0], NULL, 1024);

	if (readlink(path, &link_data[0], 1024) == -1) {

		dv.part = find_part(path);
		if (dv.part == -1) {
			free(path);
			return (NULL);
		}
		dv.wwa = get_wwa(path);
		dv.lun = get_lun(path);
		dv.israw = is_raw(path);
		fullpath = strdup(path);
	} else {
		dv.wwa = get_wwa(&link_data[0]);
		dv.lun = get_lun(&link_data[0]);
		dv.part = find_part(&link_data[0]);
		if (dv.part == -1) {
			free(path);
			return (NULL);
		}
		dv.israw = is_raw(&link_data[0]);
		fullpath = full_path(path, &link_data[0]);
	}
	if (fullpath == NULL) {
		free(path);
		if (dv.wwa != NULL) {
			free(dv.wwa);
		}
		return (NULL);
	}
	if (dv.wwa == NULL) {
		pa = (struct paths *)calloc(1, sizeof (struct paths));
		pa->logicalpath = path;
		if ((pa->op = calloc(1, sizeof (struct other_paths))) == NULL) {
			free(pa);
			pa = NULL;
			free(fullpath);
		} else {
			pa->op->path = fullpath;
		}
		return (pa);
	}
	this_ps.wwa = dv.wwa;

	if (ndevtree == 0) {
		(void) nftw(devices, ftwfunc, 64, FTW_MOUNT);
		qsort(ps, ndevtree, sizeof (struct pathstore), pscmp);
	}

	entry = bsearch(&this_ps, (void *)ps, ndevtree,
	    sizeof (struct pathstore), pscmp);
	free(dv.wwa);
	if (entry != NULL) {
		struct other_paths **ep, *prev = NULL;
		struct paths *pa_out;

		if (*(ep = &entry->luns.parts[dv.lun].devs[
		    dv.part].raw_or_cooked[dv.israw]) == NULL)
			return (NULL);

		pa = (struct paths *)calloc(1, sizeof (struct paths));
		if (pa != NULL) {
			for (pa->op = *ep; pa->op != NULL &&
			    strcmp(pa->op->path, fullpath);
			    pa->op = pa->op->next) {
				prev = pa->op;
			}
			pa->logicalpath = path;
			if (prev != NULL && pa->op != NULL) {
				prev->next = pa->op->next;
				pa->op->next = *ep;
				*ep = pa->op;
			}
		} else {
			free(path);
		}
		if (pa->op) {
			pa_out = dup_paths(pa);
		} else {
			pa_out = NULL;
		}
		free(pa->logicalpath);
		free(pa);
		free(fullpath);
		return (pa_out);
	}
	free(fullpath);
	free(path);
	return (NULL);
}
static void
free_devstore(struct devstore *dev)
{
	if (dev == NULL)
		return;
	if (dev->raw_or_cooked[0])
		free_otherpaths(dev->raw_or_cooked[0]);
	if (dev->raw_or_cooked[1])
		free_otherpaths(dev->raw_or_cooked[1]);
}
static void
free_partstore(struct partstore *pas)
{
	int i;

	if (pas == NULL)
		return;

	for (i = 0; i < pas->nparts; i++)
		free_devstore(&pas->devs[i]);
	if (pas->devs)
		free(pas->devs);
}
static void
free_lunstore(struct lunstore *ls)
{
	int i;

	if (ls == NULL)
		return;
	for (i = 0; i < ls->nluns; i++)
		free_partstore(&ls->parts[i]);
	if (ls->parts)
		free(ls->parts);
}
void
findap_fini(void)
{
	int i;

	for (i = 0; i < ndevtree; i++) {
		free_lunstore(&ps[i].luns);
		free(ps[i].wwa);
	}
	if (ps != NULL) {
		free(ps);
		ps = NULL;
	}
#ifdef FIND_AP_STATS
	printf("Hits = %d\nMisses %d\n", hit_count, miss_count);
#endif
	ndevtree = 0;
}