OpenSolaris_b135/lib/lvm/libmeta/common/meta_name.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 <meta.h>
#include <metad.h>
#include <ctype.h>
#include <string.h>
#include <sys/fs/ufs_fsdir.h>
/*
* Just in case we're not in a build environment, make sure that
* TEXT_DOMAIN gets set to something.
*/
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
/*
* Macros to produce a quoted string containing the value of a
* preprocessor macro. For example, if SIZE is defined to be 256,
* VAL2STR(SIZE) is "256". This is used to construct format
* strings for scanf-family functions below.
*/
#define QUOTE(x) #x
#define VAL2STR(x) QUOTE(x)
extern char *getfullblkname();
/*
* caches
*/
static mdsetnamelist_t *setlistp = NULL;
static mddrivenamelist_t *drivelistp = NULL;
static mdnamelist_t *fastnmlp = NULL;
static mdhspnamelist_t *hsplistp = NULL;
/*
* Static definitions
*/
static int chksetname(mdsetname_t **spp, char *sname, md_error_t *ep);
/*
* FUNCTION: meta_dsk_to_rdsk()
* INPUT: str - Fully qualified pathname of a block or character device
* RETURNS: char * - The pathname of the raw device
* PURPOSE: Allocation of a new string representing the character device
* associated with the input string. Note that no checking is
* done to verify the existence of this device file.
*/
static char *
meta_dsk_to_rdsk(char *str)
{
char *dp = NULL;
char *rdskp = NULL;
assert(*str == '/');
if ((dp = strstr(str, "/rdsk/")) != NULL)
return (Strdup(str));
/*
* If this is a malformed string, (i.e. containing neither
* "/rdsk/" nor "/dsk/") then check to see if the caller
* is passing old school device names like "/dev/[r]sd" or
* exotic hardware presenting "/dev/[r]dc" names.
*/
if ((dp = strstr(str, "/dsk/")) == NULL) {
if (strncmp(str, "/dev/r", 6) == 0) {
return (Strdup(str));
} else if (strncmp(str, "/dev/", 5) == 0) {
dp = str + 4;
} else {
return (NULL);
}
}
dp++;
if (*dp == '\0')
return (NULL);
rdskp = Zalloc(strlen(str) + 2);
(void) strncpy(rdskp, str, dp - str);
rdskp[dp - str] = 'r';
(void) strcpy(rdskp + (dp - str) + 1, dp);
return (rdskp);
}
/*
* FUNCTION: rawname()
* INPUT: uname - Fully qualified pathname of a block or character device
* RETURNS: char * - The fully qualified character device pathname
* PURPOSE: Return the fully qualified pathname of the character device
* corresponding to the block or character device passed in.
*/
static char *
rawname(char *uname)
{
char *new_path = NULL;
int ret = -1;
struct stat statbuf;
if (*uname != '/')
return (NULL);
if ((new_path = meta_dsk_to_rdsk(uname)) == NULL)
return (NULL);
if (strncmp("/dev/", new_path, 5) == 0) {
ret = stat(new_path, &statbuf);
if (ret != 0 || (! S_ISCHR(statbuf.st_mode))) {
Free(new_path);
return (NULL);
}
}
return (new_path);
}
char *
blkname(
char *uname
)
{
char *p;
if ((p = getfullblkname(uname)) == NULL) {
return (NULL);
} else if (*p == '\0') {
Free(p);
return (NULL);
} else {
return (p);
}
}
/*
* FUNCTION: parse_device()
* INPUT: sp - pointer to setname struct
* uname - Name of either a hotspare pool or metadevice
* This can either be a fully qualified path or
* in the form [set name/]device
* OUTPUT: snamep - name of the set that uname is in
* fnamep - metadevice or hsp with path and set name info stripped
* This parameter is dynamically allocated and must be
* freed by the calling function.
* PURPOSE: Parse uname and sp into the set name and device name strings.
* If the set name is specified as part of uname then use that
* otherwise attempt to get the set name from sp.
*/
void
parse_device(
mdsetname_t *sp,
char *uname,
char **fnamep, /* dynamically alloced - caller must free */
char **snamep /* dynamically alloced - caller must free */
)
{
char setname[FILENAME_MAX+1];
char devname[FILENAME_MAX+1];
char *tname = Malloc(strlen(uname) + 1);
int len;
char *up;
char *tp;
int lcws; /* last character was slash */
/* Now copy uname to tname by throwing away any duplicate '/' */
for (lcws = 0, tp = tname, up = uname; *up; up++) {
if (lcws) {
if (*up == '/') {
continue;
} else {
lcws = 0;
}
}
if (*up == '/') {
lcws = 1;
}
*tp++ = *up; /* ++ is done by for loop */
}
*tp = '\0';
/* fully-qualified - local set */
if (((sscanf(tname, "/dev/md/dsk/%" VAL2STR(FILENAME_MAX) "s%n",
devname, &len) == 1) && (strlen(tname) == len)) ||
((sscanf(tname, "/dev/md/rdsk/%" VAL2STR(FILENAME_MAX) "s%n",
devname, &len) == 1) && (strlen(tname) == len))) {
*snamep = Strdup(MD_LOCAL_NAME);
*fnamep = Strdup(devname);
Free(tname);
return;
}
/* with setname specified - either fully qualified and relative spec */
if (((sscanf(tname, "%[^/]/%" VAL2STR(FILENAME_MAX) "s%n",
setname, devname, &len) == 2) && (strlen(tname) == len)) ||
((sscanf(tname, "/dev/md/%[^/]/dsk/%" VAL2STR(FILENAME_MAX) "s%n",
setname, devname, &len) == 2) && (strlen(tname) == len)) ||
((sscanf(tname, "/dev/md/%[^/]/rdsk/%" VAL2STR(FILENAME_MAX) "s%n",
setname, devname, &len) == 2) && (strlen(tname) == len))) {
*snamep = Strdup(setname);
*fnamep = Strdup(devname);
Free(tname);
return;
}
/* without setname specified */
*fnamep = tname;
if (sp != NULL && !metaislocalset(sp))
*snamep = Strdup(sp->setname);
else
*snamep = NULL;
}
/*
* check for "all"
*/
int
meta_is_all(char *s)
{
if ((strcoll(s, gettext("all")) == 0) ||
(strcoll(s, gettext("ALL")) == 0))
return (1);
return (0);
}
/*
* check for "none"
*/
int
meta_is_none(char *s)
{
if ((strcoll(s, gettext("none")) == 0) ||
(strcoll(s, gettext("NONE")) == 0))
return (1);
return (0);
}
static int
valid_name_syntax(char *uname)
{
int i;
int uname_len;
if (uname == NULL || !isalpha(uname[0]))
return (0);
uname_len = strlen(uname);
if (uname_len > MAXNAMLEN)
return (0);
/* 'all' and 'none' are reserved */
if (meta_is_all(uname) || meta_is_none(uname))
return (0);
for (i = 1; i < uname_len; i++) {
if ((isalnum(uname[i]) || uname[i] == '-' ||
uname[i] == '_' || uname[i] == '.'))
continue;
break;
}
if (i < uname_len)
return (0);
return (1);
}
/*
* canonicalize name
*/
char *
meta_canonicalize(
mdsetname_t *sp,
char *uname
)
{
char *sname = NULL;
char *tname = NULL;
char *cname;
/* return the dev name and set name */
parse_device(sp, uname, &tname, &sname);
if (!valid_name_syntax(tname)) {
Free(tname);
if (sname != NULL)
Free(sname);
return (NULL);
}
if ((sname == NULL) || (strcmp(sname, MD_LOCAL_NAME) == 0))
cname = tname;
else {
size_t cname_len;
cname_len = strlen(tname) + strlen(sname) + 2;
cname = Malloc(cname_len);
(void) snprintf(
cname, cname_len, "%s/%s", sname, tname);
Free(tname);
}
if (sname != NULL)
Free(sname);
return (cname);
}
/*
* canonicalize name and check the set
*/
char *
meta_canonicalize_check_set(
mdsetname_t **spp,
char *uname,
md_error_t *ep
)
{
char *sname = NULL;
char *tname = NULL;
char *cname;
/* return the dev name and set name */
parse_device(*spp, uname, &tname, &sname);
if (!valid_name_syntax(tname)) {
(void) mderror(ep, MDE_NAME_ILLEGAL, tname);
if (sname != NULL)
Free(sname);
Free(tname);
return (NULL);
}
/* check the set name returned from the name for validity */
if (chksetname(spp, sname, ep) != 0) {
Free(tname);
if (sname != NULL)
Free(sname);
return (NULL);
}
if ((sname == NULL) || (strcmp(sname, MD_LOCAL_NAME) == 0))
cname = tname;
else {
size_t cname_len;
cname_len = strlen(tname) + strlen(sname) + 2;
cname = Malloc(cname_len);
(void) snprintf(
cname, cname_len, "%s/%s", sname, tname);
Free(tname);
}
if (sname != NULL)
Free(sname);
return (cname);
}
/*
* Verify that the name is a valid hsp/metadevice name
*/
static int
parse_meta_hsp_name(char *uname)
{
char *sname = NULL;
char *tname = NULL;
int ret;
/* return the dev name and set name */
parse_device(NULL, uname, &tname, &sname);
ret = valid_name_syntax(tname);
if (sname != NULL)
Free(sname);
Free(tname);
return (ret);
}
/*
* check that name is a metadevice
*/
int
is_metaname(
char *uname
)
{
return (parse_meta_hsp_name(uname));
}
/*
* check that name is a hotspare pool
*/
int
is_hspname(
char *uname
)
{
return (parse_meta_hsp_name(uname));
}
/*
* check to verify that name is an existing metadevice
*/
int
is_existing_metadevice(
mdsetname_t *sp,
char *uname
)
{
char *raw_name;
char *set_name;
char *full_path;
char *fname = NULL;
int pathlen;
int retval = 0;
assert(uname != NULL);
/*
* If it is an absolute name of a metadevice, then just call rawname
* on the input
*/
if (uname[0] == '/') {
if (strncmp("/dev/md", uname, strlen("/dev/md")) == 0 &&
(raw_name = rawname(uname)) != NULL) {
Free(raw_name);
return (1);
}
return (0);
}
/* create a fully specified path from the parsed string */
parse_device(sp, uname, &fname, &set_name);
if ((set_name == NULL) || (strcmp(set_name, MD_LOCAL_NAME) == 0)) {
pathlen = strlen("/dev/md/rdsk/") + strlen(fname) + 1;
full_path = Zalloc(pathlen);
(void) snprintf(full_path, pathlen, "/dev/md/rdsk/%s", fname);
} else {
pathlen = strlen("/dev/md//rdsk/") + strlen(fname) +
strlen(set_name) + 1;
full_path = Zalloc(pathlen);
(void) snprintf(full_path, pathlen, "/dev/md/%s/rdsk/%s",
set_name, fname);
}
if ((raw_name = rawname(full_path)) != NULL) {
Free(raw_name);
retval = 1;
}
if (set_name != NULL)
Free(set_name);
Free(fname);
Free(full_path);
return (retval);
}
/*
* check to verify that name is an existing hsp
*/
int
is_existing_hsp(
mdsetname_t *sp,
char *uname
)
{
md_error_t status = mdnullerror;
hsp_t hsp;
set_t cur_set;
if (sp != NULL)
cur_set = sp->setno;
else
cur_set = 0;
hsp = meta_gethspnmentbyname(cur_set, MD_SIDEWILD, uname, &status);
if (hsp == MD_HSP_NONE) {
mdclrerror(&status);
return (0);
}
return (1);
}
/*
* check to verify that name is an existing metadevice or hotspare pool
*/
int
is_existing_meta_hsp(
mdsetname_t *sp,
char *uname
)
{
if (is_existing_metadevice(sp, uname) ||
is_existing_hsp(sp, uname))
return (1);
return (0);
}
/*
* mdsetname_t stuff
*/
/*
* initialize setname
*/
static void
metainitsetname(
mdsetname_t *sp
)
{
(void) memset(sp, '\0', sizeof (*sp));
}
static void
metafreesetdesc(md_set_desc *sd)
{
md_mnnode_desc *nd;
if (MD_MNSET_DESC(sd)) {
nd = sd->sd_nodelist;
while (nd) {
sd->sd_nodelist = nd->nd_next;
Free(nd);
nd = sd->sd_nodelist;
}
}
metafreedrivedesc(&sd->sd_drvs);
Free(sd);
}
/*
* free allocated setname
*/
static void
metafreesetname(
mdsetname_t *sp
)
{
if (sp->setname != NULL)
Free(sp->setname);
if (sp->setdesc != NULL)
metafreesetdesc(sp->setdesc);
metainitsetname(sp);
}
/*
* flush the setname cache
*/
static void
metaflushsetnames()
{
mdsetnamelist_t *p, *n;
for (p = setlistp, n = NULL; (p != NULL); p = n) {
n = p->next;
metafreesetname(p->sp);
Free(p->sp);
Free(p);
}
setlistp = NULL;
}
/*
* get set number
*/
static int
getsetno(
char *sname,
set_t *setnop,
md_error_t *ep
)
{
md_set_record *sr;
size_t len;
/* local set */
if ((sname == NULL) || (strcmp(sname, MD_LOCAL_NAME) == 0)) {
*setnop = 0;
return (0);
}
/* shared set */
if ((sr = getsetbyname(sname, ep)) == NULL) {
if (mdisrpcerror(ep, RPC_PROGNOTREGISTERED)) {
char *p;
len = strlen(sname) + 30;
p = Malloc(len);
(void) snprintf(p, len, "setname \"%s\"", sname);
(void) mderror(ep, MDE_NO_SET, p);
Free(p);
}
return (-1);
}
*setnop = sr->sr_setno;
free_sr(sr);
return (0);
}
/*
* find setname from name
*/
mdsetname_t *
metasetname(
char *sname,
md_error_t *ep
)
{
mdsetnamelist_t **tail;
set_t setno;
mdsetname_t *sp;
/* look for cached value first */
assert(sname != NULL);
for (tail = &setlistp; (*tail != NULL); tail = &(*tail)->next) {
sp = (*tail)->sp;
if (strcmp(sp->setname, sname) == 0) {
return (sp);
}
}
/* setup set */
if (getsetno(sname, &setno, ep) != 0)
return (NULL);
/* allocate new list element and setname */
*tail = Zalloc(sizeof (**tail));
sp = (*tail)->sp = Zalloc(sizeof (*sp));
sp->setname = Strdup(sname);
sp->setno = setno;
sp->lockfd = MD_NO_LOCK;
return (sp);
}
/*
* find setname from setno
*/
mdsetname_t *
metasetnosetname(
set_t setno,
md_error_t *ep
)
{
mdsetnamelist_t *slp;
mdsetname_t *sp;
md_set_record *sr;
/* look for cached value first */
for (slp = setlistp; (slp != NULL); slp = slp->next) {
sp = slp->sp;
if (sp->setno == setno)
return (sp);
}
/* local set */
if (setno == MD_LOCAL_SET)
return (metasetname(MD_LOCAL_NAME, ep));
/* shared set */
if ((sr = getsetbynum(setno, ep)) == NULL)
return (NULL);
sp = metasetname(sr->sr_setname, ep);
free_sr(sr);
return (sp);
}
mdsetname_t *
metafakesetname(
set_t setno,
char *sname
)
{
mdsetnamelist_t **tail;
mdsetname_t *sp;
/* look for cached value first */
for (tail = &setlistp; (*tail != NULL); tail = &(*tail)->next) {
sp = (*tail)->sp;
if (sp->setno == setno) {
if ((sp->setname == NULL) && (sname != NULL))
sp->setname = Strdup(sname);
return (sp);
}
}
/* allocate new list element and setname */
*tail = Zalloc(sizeof (**tail));
sp = (*tail)->sp = Zalloc(sizeof (*sp));
if (sname != NULL)
sp->setname = Strdup(sname);
sp->setno = setno;
sp->lockfd = MD_NO_LOCK;
return (sp);
}
/*
* setup set record (sr) and cache it in the mdsetname_t struct
*/
md_set_desc *
sr2setdesc(
md_set_record *sr
)
{
md_set_desc *sd;
int i;
md_mnset_record *mnsr;
md_mnnode_desc *nd, *nd_prev = 0;
md_mnnode_record *nr;
md_error_t status = mdnullerror;
md_error_t *ep = &status;
int nodecnt, nrcnt;
mndiskset_membershiplist_t *nl, *nl2;
sd = Zalloc(sizeof (*sd));
sd->sd_ctime = sr->sr_ctime;
sd->sd_genid = sr->sr_genid;
sd->sd_setno = sr->sr_setno;
sd->sd_flags = sr->sr_flags;
if (MD_MNSET_DESC(sd)) {
mnsr = (md_mnset_record *)sr;
(void) strlcpy(sd->sd_mn_master_nodenm,
mnsr->sr_master_nodenm, sizeof (sd->sd_mn_master_nodenm));
sd->sd_mn_master_nodeid = mnsr->sr_master_nodeid;
if (strcmp(mnsr->sr_master_nodenm, mynode()) == 0) {
sd->sd_mn_am_i_master = 1;
}
/*
* Get membershiplist from API routine. If there's
* an error, just use a NULL nodelist.
*/
if (meta_read_nodelist(&nodecnt, &nl, ep) == -1) {
nodecnt = 0; /* no nodes are alive */
nl = NULL;
}
nr = mnsr->sr_nodechain;
nrcnt = 0;
/*
* Node descriptor node list must be built in
* ascending order of nodeid. The nodechain
* in the mnset record is in ascending order,
* so just make them the same.
*/
while (nr) {
nd = Zalloc(sizeof (*nd));
if (nd_prev) {
nd_prev->nd_next = nd;
} else {
sd->sd_nodelist = nd;
}
nd->nd_ctime = nr->nr_ctime;
nd->nd_genid = nr->nr_genid;
nd->nd_flags = nr->nr_flags;
(void) strlcpy(nd->nd_nodename, nr->nr_nodename,
sizeof (nd->nd_nodename));
nd->nd_nodeid = nr->nr_nodeid;
if (strcmp(nd->nd_nodename, mynode()) == 0) {
sd->sd_mn_mynode = nd;
}
if (nd->nd_nodeid == sd->sd_mn_master_nodeid) {
sd->sd_mn_masternode = nd;
}
/*
* If node is marked ALIVE, then set priv_ic
* from membership list. During the early part
* of a reconfig cycle, the membership list may
* have been changed, (a node entering or leaving
* the cluster), but rpc.metad hasn't flushed
* its data yet. So, if node is marked alive, but
* is no longer in the membership list (node has
* left the cluster) then just leave priv_ic to NULL.
*/
if (nd->nd_flags & MD_MN_NODE_ALIVE) {
nl2 = nl;
while (nl2) {
if (nl2->msl_node_id == nd->nd_nodeid) {
(void) strlcpy(nd->nd_priv_ic,
nl2->msl_node_addr,
sizeof (nd->nd_priv_ic));
break;
}
nl2 = nl2->next;
}
}
nr = nr->nr_next;
nrcnt++;
nd_prev = nd;
}
sd->sd_mn_numnodes = nrcnt;
if (nodecnt)
meta_free_nodelist(nl);
/* Just copying to keep consistent view between sr & sd */
(void) strlcpy(sd->sd_nodes[0], mnsr->sr_nodes_bw_compat[0],
sizeof (sd->sd_nodes[0]));
} else {
for (i = 0; i < MD_MAXSIDES; i++)
(void) strlcpy(sd->sd_nodes[i], sr->sr_nodes[i],
sizeof (sd->sd_nodes[i]));
}
sd->sd_med = sr->sr_med; /* structure assignment */
return (sd);
}
md_set_desc *
metaget_setdesc(
mdsetname_t *sp,
md_error_t *ep
)
{
md_set_record *sr;
if (sp->setdesc != NULL)
return (sp->setdesc);
if (sp->setname != NULL) {
if ((sr = getsetbyname(sp->setname, ep)) != NULL) {
sp->setdesc = sr2setdesc(sr);
free_sr(sr);
return (sp->setdesc);
}
}
if (sp->setno > 0) {
if ((sr = getsetbynum(sp->setno, ep)) != NULL) {
sp->setdesc = sr2setdesc(sr);
free_sr(sr);
return (sp->setdesc);
}
}
return (NULL);
}
void
metaflushsetname(mdsetname_t *sp)
{
if (sp == NULL)
return;
if (sp->setdesc == NULL)
return;
metafreesetdesc(sp->setdesc);
sp->setdesc = NULL;
}
/*
* check for local set
*/
int
metaislocalset(
mdsetname_t *sp
)
{
assert(sp->setname != NULL);
if (strcmp(sp->setname, MD_LOCAL_NAME) == 0) {
assert(sp->setno == MD_LOCAL_SET);
return (1);
} else {
assert(sp->setno != MD_LOCAL_SET);
return (0);
}
}
/*
* check for same set
*/
int
metaissameset(
mdsetname_t *sp1,
mdsetname_t *sp2
)
{
if (strcmp(sp1->setname, sp2->setname) == 0) {
assert(sp1->setno == sp2->setno);
return (1);
} else {
assert(sp1->setno != sp2->setno);
return (0);
}
}
/*
* check to see if set changed
*/
static int
chkset(
mdsetname_t **spp,
char *sname,
md_error_t *ep
)
{
/* if we already have a set, make sure it's the same */
if (*spp != NULL && !metaislocalset(*spp)) {
if ((*spp)->setname != sname &&
strcmp((*spp)->setname, sname) != 0) {
return (mderror(ep, MDE_SET_DIFF, sname));
}
return (0);
}
/* otherwise store new set name and number */
if ((*spp = metasetname(sname, ep)) == NULL) {
return (-1);
}
/* return success */
return (0);
}
/*
* check to see if set changed from default
*/
static int
chksetname(
mdsetname_t **spp,
char *sname,
md_error_t *ep
)
{
/* default to *spp's setname, or if that is NULL to MD_LOCAL_NAME */
if (sname == NULL) {
if (*spp) {
return (0);
} else {
sname = MD_LOCAL_NAME;
}
}
/* see if changed */
return (chkset(spp, sname, ep));
}
/*
* check setname from setno
*/
static int
chksetno(
mdsetname_t **spp,
set_t setno,
md_error_t *ep
)
{
md_set_record *sr;
int rval;
/* local set */
if (setno == 0)
return (chkset(spp, MD_LOCAL_NAME, ep));
/* shared set */
if ((sr = getsetbynum(setno, ep)) == NULL)
return (-1);
rval = chkset(spp, sr->sr_setname, ep);
free_sr(sr);
return (rval);
}
/*
* mddrivename_t stuff
*/
/*
* initialize name
*/
static void
metainitname(
mdname_t *np
)
{
(void) memset(np, 0, sizeof (*np));
np->dev = NODEV64;
np->key = MD_KEYBAD;
np->end_blk = -1;
np->start_blk = -1;
}
/*
* free allocated name
*/
static void
metafreename(
mdname_t *np
)
{
if (np->cname != NULL)
Free(np->cname);
if (np->bname != NULL)
Free(np->bname);
if (np->rname != NULL)
Free(np->rname);
if (np->devicesname != NULL)
Free(np->devicesname);
metainitname(np);
}
/*
* initialize drive name
*/
static void
metainitdrivename(
mddrivename_t *dnp
)
{
(void) memset(dnp, 0, sizeof (*dnp));
dnp->side_names_key = MD_KEYBAD;
}
/*
* flush side names
*/
void
metaflushsidenames(
mddrivename_t *dnp
)
{
mdsidenames_t *p, *n;
for (p = dnp->side_names, n = NULL; (p != NULL); p = n) {
n = p->next;
if (p->dname != NULL)
Free(p->dname);
if (p->cname != NULL)
Free(p->cname);
Free(p);
}
dnp->side_names = NULL;
}
/*
* free drive name
*/
void
metafreedrivename(
mddrivename_t *dnp
)
{
uint_t slice;
if (dnp->cname != NULL)
Free(dnp->cname);
if (dnp->rname != NULL)
Free(dnp->rname);
metafreevtoc(&dnp->vtoc);
for (slice = 0; (slice < dnp->parts.parts_len); ++slice)
metafreename(&dnp->parts.parts_val[slice]);
if (dnp->parts.parts_val != NULL)
Free(dnp->parts.parts_val);
metaflushsidenames(dnp);
if (dnp->miscname != NULL)
Free(dnp->miscname);
meta_free_unit(dnp);
metainitdrivename(dnp);
}
/*
* flush the drive name cache
*/
void
metaflushdrivenames()
{
mddrivenamelist_t *p, *n;
for (p = drivelistp, n = NULL; (p != NULL); p = n) {
n = p->next;
metafreedrivename(p->drivenamep);
Free(p->drivenamep);
Free(p);
}
drivelistp = NULL;
}
/*
* peel off s%u from name
*/
char *
metadiskname(
char *name
)
{
char *p, *e;
char onmb[BUFSIZ+1], cnmb[BUFSIZ];
uint_t d = 0;
int l = 0;
int cl = strlen(name);
/*
* Handle old style names, which are of the form /dev/rXXNN[a-h].
*/
if (sscanf(name, "/dev/r%" VAL2STR(BUFSIZ) "[^0-9/]%u%*[a-h]%n",
onmb, &d, &l) == 2 && l == cl) {
(void) snprintf(cnmb, sizeof (cnmb), "/dev/r%s%u", onmb, d);
return (Strdup(cnmb));
}
/*
* Handle old style names, which are of the form /dev/XXNN[a-h].
*/
if (sscanf(name, "/dev/%" VAL2STR(BUFSIZ) "[^0-9/]%u%*[a-h]%n",
onmb, &d, &l) == 2 && l == cl) {
(void) snprintf(cnmb, sizeof (cnmb), "/dev/%s%u", onmb, d);
return (Strdup(cnmb));
}
/* gobble number and 's' */
p = e = name + strlen(name) - 1;
for (; (p > name); --p) {
if (!isdigit(*p))
break;
}
if ((p == e) || (p <= name))
return (Strdup(name));
if (*p != 's' && strchr("dt", *p) == NULL)
return (Strdup(name));
else if (strchr("dt", *p) != NULL)
return (Strdup(name));
p--;
if ((p <= name) || (!isdigit(*p)))
return (Strdup(name));
*(++p) = '\0';
e = Strdup(name);
*p = 's';
return (e);
}
/*
* free list of drivenames
*/
void
metafreedrivenamelist(
mddrivenamelist_t *dnlp
)
{
mddrivenamelist_t *next = NULL;
for (/* void */; (dnlp != NULL); dnlp = next) {
next = dnlp->next;
Free(dnlp);
}
}
/*
* build list of drivenames
*/
int
metadrivenamelist(
mdsetname_t **spp,
mddrivenamelist_t **dnlpp,
int argc,
char *argv[],
md_error_t *ep
)
{
mddrivenamelist_t **tailpp = dnlpp;
int count = 0;
for (*dnlpp = NULL; (argc > 0); ++count, --argc, ++argv) {
mddrivenamelist_t *dnlp = Zalloc(sizeof (*dnlp));
if ((dnlp->drivenamep = metadrivename(spp, argv[0],
ep)) == NULL) {
metafreedrivenamelist(*dnlpp);
*dnlpp = NULL;
return (-1);
}
*tailpp = dnlp;
tailpp = &dnlp->next;
}
return (count);
}
/*
* append to end of drivename list
*/
mddrivename_t *
metadrivenamelist_append(
mddrivenamelist_t **dnlpp,
mddrivename_t *dnp
)
{
mddrivenamelist_t *dnlp;
/* run to end of list */
for (; (*dnlpp != NULL); dnlpp = &(*dnlpp)->next)
;
/* allocate new list element */
dnlp = *dnlpp = Zalloc(sizeof (*dnlp));
/* append drivename */
dnlp->drivenamep = dnp;
return (dnp);
}
/*
* FUNCTION: meta_drivenamelist_append_wrapper()
* INPUT: tailpp - pointer to the list tail pointer
* dnp - name node to be appended to list
* OUTPUT: none
* RETURNS: mddrivenamelist_t * - new tail of the list.
* PURPOSE: wrapper to meta_namelist_append for performance.
* metanamelist_append finds the tail each time which slows
* down long lists. By keeping track of the tail ourselves
* we can change metadrivenamelist_append into a
* constant time operation.
*/
mddrivenamelist_t **
meta_drivenamelist_append_wrapper(
mddrivenamelist_t **tailpp,
mddrivename_t *dnp
)
{
(void) metadrivenamelist_append(tailpp, dnp);
/* If it's the first item in the list, return it instead of the next */
if ((*tailpp)->next == NULL)
return (tailpp);
return (&(*tailpp)->next);
}
/*
* mdname_t stuff
*/
/*
* check set and get comparison name
*
* NOTE: This function has a side effect of setting *spp if the setname
* has been specified and *spp is not already set.
*/
char *
meta_name_getname(
mdsetname_t **spp,
char *uname,
meta_device_type_t uname_type,
md_error_t *ep
)
{
if (uname_type == META_DEVICE || uname_type == HSP_DEVICE ||
(uname_type == UNKNOWN && is_existing_metadevice(*spp, uname))) {
/*
* if the setname is specified in uname, *spp is set,
* and the set names don't agree then canonical name will be
* returned as NULL
*/
return (meta_canonicalize_check_set(spp, uname, ep));
}
/* if it is not a meta/hsp and *spp is not set then set it to local */
if (chksetname(spp, NULL, ep) != 0)
return (NULL);
/* if it is not a meta/hsp name then just return uname */
return (Strdup(uname));
}
/*
* FUNCTION: getrname()
* INPUT: spp - the setname struct
* uname - the possibly unqualified device name
* type - ptr to the device type of uname
* OUTPUT: ep - return error pointer
* RETURNS: char* - character string containing the fully
* qualified raw device name
* PURPOSE: Create the fully qualified raw name for the possibly
* unqualified device name. If uname is an absolute
* path the raw name is derived from the input string.
* Otherwise, an attempt is made to get the rawname by
* catting "/dev/md/rdsk" and "/dev/rdsk". If the input
* value of type is UNKNOWN and it can be successfully
* determined then update type to the correct value.
*/
static char *
getrname(mdsetname_t **spp, char *uname,
meta_device_type_t *type, md_error_t *ep)
{
char *rname;
char *fname;
int i;
int rname_cnt = 0;
char *rname_list[3];
meta_device_type_t tmp_type;
assert(uname != NULL);
/* if it is an absolute name then just call rawname on the input */
if (uname[0] == '/') {
if ((rname = rawname(uname)) != NULL) {
/*
* If the returned rname does not match with
* the specified uname type, we'll return null.
*/
if (strncmp(rname, "/dev/md", strlen("/dev/md")) == 0) {
if (*type == LOGICAL_DEVICE) {
(void) mdsyserror(ep, ENOENT, uname);
return (NULL);
}
*type = META_DEVICE;
} else {
if (*type == META_DEVICE) {
(void) mdsyserror(ep, ENOENT, uname);
return (NULL);
}
*type = LOGICAL_DEVICE;
}
return (rname);
}
/* out of luck */
(void) mdsyserror(ep, ENOENT, uname);
return (NULL);
}
/*
* Get device that matches the requested type. If
* a match is found, return immediately. If type is
* UNKNOWN, save all the found devices in rname_list
* so we can determine later whether the input uname
* is ambiguous.
*
* Check for metadevice before physical device.
* With the introduction of softpartitions it is more
* likely to be a metadevice.
*/
/* metadevice short form */
if (*type == META_DEVICE || *type == UNKNOWN) {
if (metaislocalset(*spp)) {
fname = Malloc(strlen(uname) +
strlen("/dev/md/rdsk/") + 1);
(void) strcpy(fname, "/dev/md/rdsk/");
(void) strcat(fname, uname);
} else {
char *p;
size_t len;
if ((p = strchr(uname, '/')) != NULL) {
++p;
} else {
p = uname;
}
len = strlen((*spp)->setname) + strlen(p) +
strlen("/dev/md//rdsk/") + 1;
fname = Malloc(len);
(void) snprintf(fname, len, "/dev/md/%s/rdsk/%s",
(*spp)->setname, p);
}
rname = rawname(fname);
if (*type == META_DEVICE) {
/*
* Handle the case where we have a new metadevice
* that does not yet exist in the name-space(e.g
* metarecover in MN sets where /dev/md entry is
* not yet created in the non-master nodes). In
* this case we return the constructed metadevice
* name as that will exist after the metainit call
* has created it.
*/
if (rname == NULL) {
rname = Strdup(fname);
}
Free(fname);
return (rname);
}
Free(fname);
if ((rname != NULL) && (*type == UNKNOWN)) {
/* Save this result */
rname_list[rname_cnt] = rname;
rname_cnt ++;
}
}
if (*type == LOGICAL_DEVICE || *type == UNKNOWN) {
fname = Malloc(strlen(uname) + strlen("/dev/rdsk/") + 1);
(void) strcpy(fname, "/dev/rdsk/");
(void) strcat(fname, uname);
rname = rawname(fname);
Free(fname);
if (rname != NULL) {
/* Simply return if a logical device was requested */
if (*type == LOGICAL_DEVICE) {
return (rname);
} else {
rname_list[rname_cnt] = rname;
rname_cnt ++;
}
}
}
/*
* At this point, we've searched /dev/md/rdsk, /dev/rdsk and
* ./ for the specified device. rname_list contains all
* the matches we've found and rname_cnt is the number of
* matches.
*
* We know that either we don't have a match if a specific
* type was given, in which case we simply return NULL or
* we have an UNKNOWN device with 1-3 entries in rname_list.
*
* If we get 3 entries, rname_cnt == 3, it's ambiguous.
* If we only get 1 entry, rname_cnt == 1, return rname_list[0].
* If we get 2 entries that are not the same, it's ambigous.
*/
rname = NULL;
if (rname_cnt == 0 || *type != UNKNOWN) {
/* out of luck */
(void) mdsyserror(ep, ENOENT, uname);
return (NULL);
} else {
if (rname_cnt == 3) {
(void) mderror(ep, MDE_AMBIGUOUS_DEV, uname);
(void) printf(dgettext(TEXT_DOMAIN,
"Error: ambiguous device name.\n%s %s %s\n\n"),
rname_list[0], rname_list[1], rname_list[2]);
rname = NULL;
}
/* grab the type in case it is not ambiguous */
if (strncmp(rname_list[0], "/dev/md", strlen("/dev/md")) == 0)
tmp_type = META_DEVICE;
else
tmp_type = LOGICAL_DEVICE;
if (rname_cnt == 1) {
rname = Strdup(rname_list[0]);
*type = tmp_type;
} else {
/*
* Prevent the case where the command is run in
* either /dev/md/rdsk or /dev/rdsk so the both
* rname_list[0] and rname_list[1] are the same.
*/
if (strcmp(rname_list[0], rname_list[1]) != 0) {
(void) mderror(ep, MDE_AMBIGUOUS_DEV, uname);
if (rname_cnt != 3) {
/*
* For the rname_cnt == 3 case, the
* error was printed above.
*/
(void) printf(dgettext(TEXT_DOMAIN,
"Error: ambiguous device "
"name.\n%s %s\n\n"),
rname_list[0], rname_list[1]);
}
rname = NULL;
} else {
rname = Strdup(rname_list[0]);
*type = tmp_type;
}
}
for (i = 0; i < rname_cnt; i++)
Free(rname_list[i]);
return (rname);
}
}
/*
* get raw slice and drive names
*/
static char *
getrawnames(
mdsetname_t **spp,
char *uname,
char **dnamep,
meta_device_type_t *uname_type,
md_error_t *ep
)
{
char *rname = NULL;
size_t len;
/*
* Incorrect code path if type is HSP_DEVICE
*/
assert(*uname_type != HSP_DEVICE);
/* initialize */
*dnamep = NULL;
/* get slice name */
if ((rname = getrname(spp, uname, uname_type, ep)) != NULL) {
*dnamep = metadiskname(rname);
return (rname);
}
/*
* If name cannot be found, if may be because is is not accessible.
* If it is an absolute name, try all possible disk name formats and
* if it is device name, assume it is /dev/rdsk/..
* Since the code below assumes logical devices, if the given
* uname_type is META_DEVICE, there's nothing to do.
*/
if (mdissyserror(ep, ENOENT) && *uname_type != META_DEVICE) {
if (uname[0] == '/') {
/* Absolute name */
uint_t d = 0;
int l = 0;
char onmb[BUFSIZ+1], snm[BUFSIZ+1];
/*
* Handle old style raw names
*/
if (sscanf(uname,
"/dev/r%" VAL2STR(BUFSIZ) "[^0-9/]%u"
"%" VAL2STR(BUFSIZ) "[a-h]%n",
onmb, &d, snm, &l) == 3 && l == strlen(uname)) {
mdclrerror(ep);
rname = Strdup(uname);
*dnamep = metadiskname(rname);
*uname_type = LOGICAL_DEVICE;
return (rname);
}
/*
* Handle old style block names
*/
if (sscanf(uname,
"/dev/%" VAL2STR(BUFSIZ) "[^0-9/]%u"
"%" VAL2STR(BUFSIZ) "[a-h]%n",
onmb, &d, snm, &l) == 3 && l == strlen(uname)) {
len = strlen(uname) + 1 + 1;
rname = Malloc(len);
(void) snprintf(rname, len, "/dev/r%s%u%s",
onmb, d, snm);
*dnamep = metadiskname(rname);
*uname_type = LOGICAL_DEVICE;
return (rname);
}
/* /.../dsk/... or /.../rdsk/... */
if ((rname = meta_dsk_to_rdsk(uname)) != NULL) {
mdclrerror(ep);
*dnamep = metadiskname(rname);
*uname_type = LOGICAL_DEVICE;
return (rname);
}
} else {
/*
* If it's not an absolute name but is a valid ctd name,
* guess at /dev/rdsk/...
*/
uint_t s;
if (parse_ctd(uname, &s) == 0) {
len = strlen(uname) + strlen("/dev/rdsk/") + 1;
rname = Malloc(len);
(void) snprintf(rname, len, "/dev/rdsk/%s",
uname);
*dnamep = metadiskname(rname);
*uname_type = LOGICAL_DEVICE;
return (rname);
}
}
}
/* out of luck */
if (!mdiserror(ep, MDE_AMBIGUOUS_DEV))
(void) mderror(ep, MDE_UNIT_NOT_FOUND, uname);
return (NULL);
}
/*
* get number of slices for name
*/
static int
getnslice(
char *rname,
char *dname,
uint_t *slicep
)
{
char *srname;
uint_t nslice;
size_t dl = strlen(dname);
size_t rl = strlen(rname);
size_t l = 0;
size_t len;
/*
* get our slice number - works only with names that end in s%u -
* all others return -1.
*/
if (dl >= rl ||
sscanf(&rname[dl], "s%u%n", slicep, &l) != 1 || l != rl ||
(int)*slicep < 0) {
return (-1);
}
/*
* go find how many slices there really are
*/
len = strlen(dname) + 20 + 1;
srname = Malloc(len);
for (nslice = 0; /* void */; ++nslice) {
struct stat statbuf;
/* build slice name */
(void) snprintf(srname, len, "%ss%u", dname, nslice);
/* see if it's there */
if ((meta_stat(srname, &statbuf) != 0) ||
(! S_ISCHR(statbuf.st_mode))) {
break;
}
}
Free(srname);
/* Need to make sure that we at least have V_NUMPAR */
nslice = max(nslice, V_NUMPAR);
/* make sure we have at least our slice */
if (nslice < *slicep)
return (-1);
/* return number of slices */
return (nslice);
}
/*
* Attempt to parse the input string as a c[t]ds specifier
* The target can either be a SCSI target id or if the device
* is in a fabric configuration in a fibre channel setup then
* the target is a standard WWN (world wide name).
*
* if successful return 0
* if c[t]dp name return 1
* otherwise return -1
*/
int
parse_ctd(
char *uname,
uint_t *slice)
{
uint_t channel;
uint_t target;
uint_t device;
int has_target = 1;
uint_t cl;
uint_t target_str_len;
char *partial_ctd_str;
char *target_str;
char *device_start_pos;
int l = -1;
/* pull off the channel spec and the 't' for the target */
if (sscanf(uname, "c%ut%n", &channel, &l) != 1 || l == -1) {
/* check for cds style name */
if (sscanf(uname, "c%ud%n", &channel, &l) != 1 || l == -1) {
return (-1);
} else {
l--; /* we want to be on the 'd' */
has_target = 0;
}
}
partial_ctd_str = uname + l;
/* find the beginning of the device specifier */
device_start_pos = strrchr(partial_ctd_str, 'd');
if (device_start_pos == NULL) {
return (-1);
}
/* check to see if it is a ctd with a WWN or SCSI target */
if (has_target) {
/* pull off the target and see if it is a WWN */
target_str_len = device_start_pos - partial_ctd_str + 2;
target_str = (char *)Malloc(target_str_len+1);
(void) strcpy(target_str, "0X");
(void) strncpy(target_str+2, partial_ctd_str,
target_str_len - 2);
target_str[target_str_len] = '\0';
if (sscanf(target_str, "%x%n", &target, &l) != 1 ||
l != target_str_len) {
Free(target_str);
return (-1);
}
Free(target_str);
}
/* check the device and slice */
cl = strlen(device_start_pos);
if (sscanf(device_start_pos, "d%us%u%n", &device, slice, &l) != 2 ||
l != cl) {
/* check the device and partition */
if (sscanf(device_start_pos, "d%up%u%n", &device, slice, &l)
== 2 && l == cl) {
return (1);
}
return (-1);
}
return (0);
}
/*
* get number of slices for name
*/
static int
uname2sliceno(
char *uname,
meta_device_type_t uname_type,
uint_t *slicep,
md_error_t *ep
)
{
uint_t c = 0, t = 0, d = 0;
int l = 0, cl = 0;
int fd;
struct dk_cinfo cinfo;
char *p;
char *rname = NULL;
if (uname_type == META_DEVICE)
return (*slicep = 0);
if ((p = strrchr(uname, '/')) != NULL)
p++;
else
p = uname;
cl = strlen(p);
if (parse_ctd(p, slicep) == 0)
return (*slicep);
else if (sscanf(p, "mc%ut%ud%us%u%n", &c, &t, &d, slicep, &l) == 4 &&
l == cl)
return (*slicep);
else if (sscanf(p, "d%us%u%n", &d, slicep, &l) == 2 && l == cl)
return (*slicep);
/*
* If we can't get the slice from the name, then we have to do it the
* hard and expensive way.
*/
if ((rname = rawname(uname)) == NULL)
return (-1);
/* get controller info */
if ((fd = open(rname, (O_RDONLY|O_NDELAY), 0)) < 0) {
Free(rname);
return (-1);
}
if (ioctl(fd, DKIOCINFO, &cinfo) != 0) {
int save = errno;
if (save == ENOTTY)
(void) mddeverror(ep, MDE_NOT_DISK, NODEV64, rname);
else
(void) mdsyserror(ep, save, rname);
Free(rname);
(void) close(fd);
return (-1);
}
(void) close(fd); /* sd/ssd bug */
if (cinfo.dki_partition < V_NUMPAR) {
Free(rname);
return (*slicep = cinfo.dki_partition);
}
return (mddeverror(ep, MDE_NOT_DISK, NODEV64, rname));
}
/*
* get partition info
*/
static int
getparts(
mddrivename_t *dnp,
char *rname,
char *dname,
meta_device_type_t uname_type,
uint_t *npartsp,
uint_t *partnop,
md_error_t *ep
)
{
int nparts;
uint_t partno;
mdname_t name;
mdvtoc_t *vtocp;
/* metadevice */
if (uname_type == META_DEVICE) {
dnp->type = MDT_META;
nparts = 1;
partno = 0;
goto gotit;
}
/* see how many partitions in drive, this is really tricky */
metainitname(&name);
name.rname = rname;
name.drivenamep = dnp;
if ((vtocp = metagetvtoc(&name, TRUE, &partno, ep)) != NULL) {
dnp->type = MDT_COMP;
nparts = vtocp->nparts;
/* partno already setup */
/* dname already setup */
goto gotit;
}
if ((ep->info.errclass == MDEC_DEV) &&
(ep->info.md_error_info_t_u.dev_error.errnum == MDE_TOO_MANY_PARTS))
return (-1);
/* fallback and try and guess (used to check for just EACCES here) */
if ((dname != NULL) &&
((nparts = getnslice(rname, dname, &partno)) > 0)) {
dnp->type = MDT_ACCES;
if (mdanysyserror(ep)) {
dnp->errnum =
ep->info.md_error_info_t_u.sys_error.errnum;
} else {
dnp->errnum = ENOENT;
}
mdclrerror(ep);
/* nparts already setup */
/* partno already setup */
/* dname already setup */
nparts = roundup(nparts, V_NUMPAR);
goto gotit;
}
/* nothing worked */
dnp->type = MDT_UNKNOWN;
if (mdissyserror(ep, EACCES))
dnp->type = MDT_ACCES;
if (mdanysyserror(ep)) {
dnp->errnum = ep->info.md_error_info_t_u.sys_error.errnum;
} else {
dnp->errnum = ENOENT;
}
mdclrerror(ep);
nparts = V_NUMPAR;
if (uname2sliceno(rname, uname_type, &partno, ep) < 0) {
mdclrerror(ep);
partno = 0;
}
/* return success */
gotit:
assert(nparts > 0);
if (partno >= nparts)
return (mdsyserror(ep, ENOENT, rname));
*npartsp = nparts;
*partnop = partno;
return (0);
}
/*
* get block name
*/
static int
getbname(
mdname_t *np,
md_error_t *ep
)
{
char *rname = np->rname;
char *bname;
/* fully qualified */
assert(rname != NULL);
if ((bname = blkname(rname)) != NULL) {
if (np->bname)
Free(np->bname);
np->bname = bname;
return (0);
}
/* out of luck */
return (mdsyserror(ep, ENOENT, rname));
}
static void
getcname(
mdsetname_t *sp,
mdname_t *np
)
{
char *sname = sp->setname;
char *bname = np->bname;
char *p;
size_t len;
assert(sname != NULL);
assert(bname != NULL);
assert(np->drivenamep->type != MDT_FAST_COMP &&
np->drivenamep->type != MDT_FAST_META);
/* regular device */
if ((strncmp(bname, "/dev/dsk/", strlen("/dev/dsk/")) == 0) &&
(strchr((p = bname + strlen("/dev/dsk/")), '/') == NULL)) {
if (np->cname)
Free(np->cname);
np->cname = Strdup(p);
return;
}
if ((strncmp(bname, "/dev/ap/dsk/", strlen("/dev/ap/dsk/")) == 0) &&
(strchr((p = bname + strlen("/dev/ap/dsk/")), '/') == NULL)) {
if (np->cname)
Free(np->cname);
np->cname = Strdup(p);
return;
}
if ((strncmp(bname, "/dev/did/dsk/", strlen("/dev/did/dsk/")) == 0) &&
(strchr((p = bname + strlen("/dev/did/dsk/")), '/') == NULL)) {
if (np->cname)
Free(np->cname);
np->cname = Strdup(p);
return;
}
/* anything else but metadevice */
if (np->drivenamep->type != MDT_META) {
if (np->cname)
Free(np->cname);
np->cname = Strdup(bname);
return;
}
/* metadevice */
p = strrchr(bname, '/');
assert(p != NULL);
++p;
if (metaislocalset(sp)) {
if (np->cname)
Free(np->cname);
np->cname = Strdup(p);
} else {
assert(sname[0] != '\0');
if (np->cname)
Free(np->cname);
len = strlen(sname) + 1 + strlen(p) + 1;
np->cname = Malloc(len);
(void) snprintf(np->cname, len, "%s/%s", sname, p);
}
}
/*
* get dev
*/
int
meta_getdev(
mdsetname_t *sp,
mdname_t *np,
md_error_t *ep
)
{
struct stat statbuf;
/* get dev */
if (meta_stat(np->rname, &statbuf) != 0)
return (mdsyserror(ep, errno, np->rname));
else if (! S_ISCHR(statbuf.st_mode))
return (mddeverror(ep, MDE_NOT_DISK, NODEV64, np->rname));
np->dev = meta_expldev(statbuf.st_rdev);
assert(np->drivenamep->type != MDT_FAST_META &&
np->drivenamep->type != MDT_FAST_COMP);
/* check set */
assert((np->drivenamep->type == MDT_META) ?
(sp->setno == MD_MIN2SET(meta_getminor(np->dev))) : 1);
/* return sucess */
return (0);
}
/*
* set up names for a slice
*/
static int
getnames(
mdsetname_t *sp,
mdname_t *np,
char *rname,
md_error_t *ep
)
{
/* get names */
if (np->rname)
Free(np->rname);
np->rname = Strdup(rname);
if (getbname(np, ep) != 0)
return (-1);
getcname(sp, np);
if (meta_getdev(sp, np, ep) != 0)
return (-1);
/* return success */
return (0);
}
/*
* fake up names for a slice
*/
static void
getfakenames(
mdsetname_t *sp,
mdname_t *np,
char *rname
)
{
char *p;
char onmb[BUFSIZ+1], snm[BUFSIZ+1];
uint_t d = 0;
int l = 0;
/* fake names */
if (np->rname != NULL)
Free(np->rname);
np->rname = Strdup(rname);
if (np->bname != NULL)
Free(np->bname);
np->bname = Strdup(rname);
/*
* Fixup old style names
*/
if (sscanf(rname, "/dev/r%" VAL2STR(BUFSIZ) "[^0-9/]%u"
"%" VAL2STR(BUFSIZ) "[a-h]%n",
onmb, &d, snm, &l) == 3 && l == strlen(rname))
(void) snprintf(np->bname, l, "/dev/%s%u%s", onmb, d, snm);
/*
* Fixup new style names
*/
if ((p = strstr(np->bname, "/rdsk/")) != NULL) {
for (++p; (*(p + 1) != '\0'); ++p)
*p = *(p + 1);
*p = '\0';
}
if (np->cname != NULL)
Free(np->cname);
getcname(sp, np);
}
static mdname_t *
setup_slice(
mdsetname_t *sp,
meta_device_type_t uname_type,
mddrivename_t *dnp,
char *uname,
char *rname,
char *dname,
uint_t partno,
md_error_t *ep
)
{
char *srname = NULL;
mdname_t *np;
/* must have a set */
assert(sp != NULL);
assert(partno < dnp->parts.parts_len);
assert(dname != NULL);
np = &dnp->parts.parts_val[partno];
if (rname)
srname = rname;
else if (uname_type == META_DEVICE)
srname = dname;
else {
char onmb[BUFSIZ+1];
uint_t d = 0;
int l = 0, cl = strlen(dname);
size_t len;
len = cl + 20 + 1;
srname = Malloc(len);
/*
* Handle /dev/rXXNN.
*/
if (sscanf(dname, "/dev/r%" VAL2STR(BUFSIZ) "[^0-9/]%u%n",
onmb, &d, &l) == 2 && l == cl) {
(void) snprintf(srname, len, "/dev/r%s%u%c", onmb, d,
'a' + partno);
} else if (sscanf(dname, "/dev/%" VAL2STR(BUFSIZ) "[^0-9/]%u%n",
onmb, &d, &l) == 2 && l == cl) {
(void) snprintf(srname, len, "/dev/%s%u%c", onmb, d,
'a' + partno);
} else {
/* build the slice that is wanted */
(void) snprintf(srname, len, "%ss%u", dname, partno);
}
}
if (getnames(sp, np, srname, ep) != 0) {
if (dnp->type == MDT_UNKNOWN) {
mdclrerror(ep);
getfakenames(sp, np, srname);
} else if (dnp->type == MDT_COMP && mdissyserror(ep, ENOENT)) {
dnp->type = MDT_UNKNOWN;
if (mdanysyserror(ep)) {
dnp->errnum =
ep->info.md_error_info_t_u.sys_error.errnum;
} else {
dnp->errnum = ENOENT;
}
mdclrerror(ep);
getfakenames(sp, np, srname);
} else {
mdclrerror(ep);
if (getnames(sp, np, dname, ep) != 0) {
np = NULL;
goto fixup;
}
}
}
out:
if ((srname != rname) && (srname != dname))
Free(srname);
/* return name */
return (np);
fixup:
if (mdanysyserror(ep)) {
char *p;
int errnum = ep->info.md_error_info_t_u.sys_error.errnum;
mdclrerror(ep);
if (uname && *uname) {
if ((p = strrchr(uname, '/')) != NULL)
(void) mdsyserror(ep, errnum, ++p);
else
(void) mdsyserror(ep, errnum, uname);
} else {
if ((p = strrchr(srname, '/')) != NULL)
(void) mdsyserror(ep, errnum, ++p);
else
(void) mdsyserror(ep, errnum, srname);
}
}
goto out;
}
/*
* flush the fast name cache
*/
static void
metafreefastnm(mdname_t **np)
{
mddrivename_t *dnp;
assert(np != NULL && *np != NULL);
if ((dnp = (*np)->drivenamep) != NULL) {
if (dnp->cname != NULL)
Free(dnp->cname);
if (dnp->rname != NULL)
Free(dnp->rname);
if (dnp->miscname != NULL)
Free(dnp->miscname);
meta_free_unit(dnp);
Free(dnp);
}
if ((*np)->cname != NULL)
Free((*np)->cname);
if ((*np)->bname != NULL)
Free((*np)->bname);
if ((*np)->rname != NULL)
Free((*np)->rname);
if ((*np)->devicesname != NULL)
Free((*np)->devicesname);
Free(*np);
*np = NULL;
}
/*
* flush the fast name cache
*/
static void
metaflushfastnames()
{
mdnamelist_t *p, *n;
for (p = fastnmlp, n = NULL; (p != NULL); p = n) {
n = p->next;
metafreefastnm(&p->namep);
Free(p);
}
fastnmlp = NULL;
}
static char *
getrname_fast(char *unm, meta_device_type_t uname_type, md_error_t *ep)
{
uint_t d = 0;
int l = 0;
int cl = strlen(unm);
char onmb[BUFSIZ+1], snm[BUFSIZ+1], cnmb[BUFSIZ];
char *rnm;
size_t len;
if (uname_type == META_DEVICE) {
/* fully qualified - local set */
if (((sscanf(unm, "/dev/md/dsk/%" VAL2STR(BUFSIZ) "s%n",
onmb, &len) == 1) && (cl == len)) || ((sscanf(unm,
"/dev/md/rdsk/%" VAL2STR(BUFSIZ) "s%n",
onmb, &len) == 1) && (cl == len))) {
len = strlen("/dev/md/rdsk/") + strlen(onmb) + 1;
rnm = Zalloc(len);
(void) snprintf(rnm, len, "/dev/md/rdsk/%s", onmb);
return (rnm);
}
/* fully qualified - setname specified */
if (((sscanf(unm, "/dev/md/%[^/]/dsk/%"
VAL2STR(BUFSIZ) "s%n", snm, onmb, &len) == 2) &&
(cl == len)) || ((sscanf(unm, "/dev/md/%[^/]/rdsk/%"
VAL2STR(BUFSIZ) "s%n", snm, onmb, &len) == 2) &&
(cl == len))) {
len = strlen("/dev/md//rdsk/") + strlen(snm) +
strlen(onmb) + 1;
rnm = Zalloc(len);
(void) snprintf(rnm, len, "/dev/md/%s/rdsk/%s",
snm, onmb);
return (rnm);
}
/* Fully qualified path - error */
if (unm[0] == '/') {
(void) mdsyserror(ep, EINVAL, unm);
return (NULL);
}
/* setname specified <setname>/<metadev> */
if (((sscanf(unm, "%[^/]/%" VAL2STR(BUFSIZ) "s%n",
snm, onmb, &len) == 2) && (cl == len))) {
/* Not <setname>/<metadev> - error */
if (strchr(onmb, '/') != NULL) {
(void) mdsyserror(ep, EINVAL, unm);
return (NULL);
}
len = strlen("/dev/md//rdsk/") + strlen(snm) +
strlen(onmb) + 1;
rnm = Zalloc(len);
(void) snprintf(rnm, len, "/dev/md/%s/rdsk/%s",
snm, onmb);
return (rnm);
}
/* Must be simple metaname/hsp pool name */
len = strlen("/dev/md/rdsk/") + strlen(unm) + 1;
rnm = Zalloc(len);
(void) snprintf(rnm, len, "/dev/md/rdsk/%s", unm);
return (rnm);
}
/* NOT Fully qualified path, done */
if (unm[0] != '/') {
(void) mdsyserror(ep, EINVAL, unm);
return (NULL);
}
/*
* Get slice information from old style names of the form
* /dev/rXXNN[a-h] or /dev/XXNN[a-h], must be done before regular
* devices, but after metadevices.
*/
if ((sscanf(unm, "/dev/r%" VAL2STR(BUFSIZ) "[^0-9/]%u"
"%" VAL2STR(BUFSIZ) "[a-h]%n",
onmb, &d, snm, &l) == 3 ||
sscanf(unm, "/dev/%" VAL2STR(BUFSIZ) "[^0-9/]%u"
"%" VAL2STR(BUFSIZ) "[a-h]%n",
onmb, &d, snm, &l) == 3) && l == cl) {
if (strchr("abcdefgh", snm[0]) != NULL) {
(void) snprintf(cnmb, sizeof (cnmb), "/dev/r%s%u%s",
onmb, d, snm);
return (Strdup(cnmb));
}
}
/* /.../dsk/... or /.../rdsk/... */
if ((rnm = meta_dsk_to_rdsk(unm)) != NULL)
return (rnm);
/*
* Shouldn't get here but if we do then we have an unrecognized
* fully qualified path - error
*/
(void) mdsyserror(ep, EINVAL, unm);
return (NULL);
}
static mdname_t *
metainitfastname(
mdsetname_t *sp,
char *uname,
meta_device_type_t uname_type,
md_error_t *ep
)
{
uint_t c = 0, t = 0, d = 0, s = 0;
int l = 0;
mddrivename_t *dnp;
mdname_t *np;
mdnamelist_t **fnlpp;
char *cname;
for (fnlpp = &fastnmlp; (*fnlpp != NULL); fnlpp = &(*fnlpp)->next) {
np = (*fnlpp)->namep;
if (strcmp(np->bname, uname) == 0)
return (np);
}
*fnlpp = Zalloc(sizeof (**fnlpp));
np = (*fnlpp)->namep = Zalloc(sizeof (mdname_t));
metainitname(np);
dnp = np->drivenamep = Zalloc(sizeof (mddrivename_t));
metainitdrivename(dnp);
/* Metadevices */
if (uname_type == META_DEVICE &&
(cname = meta_canonicalize(sp, uname)) != NULL) {
np->cname = cname;
dnp->type = MDT_FAST_META;
goto done;
}
/* Others */
dnp->type = MDT_FAST_COMP;
if (((sscanf(uname, "/dev/rdsk/c%ut%ud%us%u%n", &c, &t, &d,
&s, &l) == 4 ||
sscanf(uname, "/dev/dsk/c%ut%ud%us%u%n", &c, &t, &d,
&s, &l) == 4 ||
sscanf(uname, "/dev/ap/rdsk/mc%ut%ud%us%u%n", &c, &t, &d,
&s, &l) == 4 ||
sscanf(uname, "/dev/ap/dsk/mc%ut%ud%us%u%n", &c, &t, &d,
&s, &l) == 4 ||
sscanf(uname, "/dev/did/rdsk/d%us%u%n", &t, &s, &l) == 2 ||
sscanf(uname, "/dev/did/dsk/d%us%u%n", &t, &s, &l) == 2||
sscanf(uname, "/dev/rdsk/c%ud%us%u%n", &c, &d, &s, &l) == 3 ||
sscanf(uname, "/dev/dsk/c%ud%us%u%n", &c, &d, &s, &l) == 3 ||
sscanf(uname, "/dev/rdsk/c%ut%ud%u%n", &c, &t, &d, &l) == 3 ||
sscanf(uname, "/dev/dsk/c%ut%ud%u%n", &c, &t, &d, &l) == 3 ||
sscanf(uname, "/dev/ap/rdsk/mc%ut%ud%u%n", &c, &t, &d, &l) == 3 ||
sscanf(uname, "/dev/ap/dsk/mc%ut%ud%u%n", &c, &t, &d, &l) == 3 ||
sscanf(uname, "/dev/did/rdsk/d%u%n", &t, &l) == 1 ||
sscanf(uname, "/dev/did/dsk/d%u%n", &t, &l) == 1 ||
sscanf(uname, "/dev/rdsk/c%ud%u%n", &c, &d, &l) == 2 ||
sscanf(uname, "/dev/dsk/c%ud%u%n", &c, &d, &l) == 2) &&
l == strlen(uname))) {
if ((np->cname = strrchr(uname, '/')) == NULL)
np->cname = Strdup(uname);
else
np->cname = Strdup(++np->cname);
} else {
np->cname = Strdup(uname);
}
done:
/* Driver always gives us block names */
np->bname = Strdup(uname);
/* canonical disk name */
if ((dnp->cname = metadiskname(np->cname)) == NULL)
dnp->cname = Strdup(np->cname);
if ((np->rname = getrname_fast(uname, uname_type, ep)) != NULL) {
if ((dnp->rname = metadiskname(np->rname)) == NULL)
dnp->rname = Strdup(np->rname);
} else {
metafreefastnm(&(*fnlpp)->namep);
Free(*fnlpp);
*fnlpp = NULL;
return (NULL);
}
/* cleanup, return success */
return (np);
}
/*
* set up names for a device
*/
static mdname_t *
metaname_common(
mdsetname_t **spp,
char *uname,
int fast,
meta_device_type_t uname_type,
md_error_t *ep
)
{
mddrivenamelist_t **tail;
mddrivename_t *dnp;
uint_t slice;
mdname_t *np;
char *rname = NULL;
char *dname = NULL;
char *cname = NULL;
uint_t nparts, partno;
assert(uname != NULL);
/* check setname */
if ((cname = meta_name_getname(spp, uname, uname_type, ep)) == NULL)
return (NULL);
assert(*spp != NULL);
Free(cname);
/* get raw name (rname) of the slice and drive (dname) we have */
if ((rname = getrawnames(spp, uname,
&dname, &uname_type, ep)) == NULL) {
return (NULL);
}
assert(uname_type != UNKNOWN);
/* look in cache first */
for (tail = &drivelistp; (*tail != NULL); tail = &(*tail)->next) {
dnp = (*tail)->drivenamep;
/* check to see if the drive name is already in the cache */
if ((dnp->rname != NULL) && strcmp(dnp->rname, dname) == 0) {
Free(rname);
if (dname != NULL)
Free(dname);
if (uname2sliceno(uname, uname_type, &partno, ep) < 0)
return (NULL);
return (metaslicename(dnp, partno, ep));
}
}
/*
* If a fast names is OK, then get one, and be done.
*/
if (fast) {
Free(rname);
if (dname != NULL)
Free(dname);
return (metainitfastname(*spp, uname, uname_type, ep));
}
/* allocate new list element and drive */
*tail = Zalloc(sizeof (**tail));
dnp = (*tail)->drivenamep = Zalloc(sizeof (*dnp));
metainitdrivename(dnp);
/* get parts info */
if (getparts(dnp, rname, dname, uname_type, &nparts, &partno, ep) != 0)
goto out;
/*
* libmeta needs at least V_NUMPAR partitions.
* If we have an EFI partition with less than V_NUMPAR slices,
* we nevertheless reserve space for V_NUMPAR
*/
if (nparts < V_NUMPAR) {
nparts = V_NUMPAR;
}
/* allocate and link in parts */
dnp->parts.parts_len = nparts;
dnp->parts.parts_val = Zalloc((sizeof (*dnp->parts.parts_val)) *
dnp->parts.parts_len);
for (slice = 0; (slice < nparts); ++slice) {
np = &dnp->parts.parts_val[slice];
metainitname(np);
np->drivenamep = dnp;
}
/* setup name_t (or slice) wanted */
if ((np = setup_slice(*spp, uname_type, dnp, uname, rname,
dname, partno, ep)) == NULL)
goto out;
/* canonical disk name */
if ((dnp->cname = metadiskname(np->cname)) == NULL)
dnp->cname = Strdup(np->cname);
if ((dnp->rname = metadiskname(np->rname)) == NULL)
dnp->rname = Strdup(np->rname);
/* cleanup, return success */
if (dname != NULL)
Free(dname);
Free(rname);
return (np);
/* cleanup, return error */
out:
if (dname != NULL)
Free(dname);
if (rname != NULL)
Free(rname);
metafreedrivename(dnp);
Free(dnp);
Free(*tail);
*tail = NULL;
return (NULL);
}
/*
* metaname()
*
* Wrapper function for metaname_common()
* If the second arg is a metadevice name then it is important that this should
* be a canonical name (eg d30 rather than /dev/md/dsk/d30). If this is not the
* case then a bad entry may be placed into the drivelistp cache.
*/
mdname_t *
metaname(
mdsetname_t **spp,
char *uname,
meta_device_type_t uname_type,
md_error_t *ep
)
{
return (metaname_common(spp, uname, 0, uname_type, ep));
}
mdname_t *
metaname_fast(
mdsetname_t **spp,
char *uname,
meta_device_type_t uname_type,
md_error_t *ep
)
{
return (metaname_common(spp, uname, 1, uname_type, ep));
}
/*
* Get the dnp using the device id.
*
* We have the potential to have more than 1 dnp with the same disk name but
* have different device ids. This would happen in the case of a partial
* diskset. The unavailable disk name is relative to the prior host and could
* possibly be the same as a disk on this system. The only way to tell which
* dnp belongs with this disk is by searching by device id. We have the
* potential to have the case where 1) the disk who's device id we pass in is
* in the system. In this case the name and the device id are both valid for
* the disk. 2) The disk whose device id we've been passed is not in the
* system and no disk with the same name has a dnp on the list. And 3) The
* disk whose device id we've been passed is not on the system but there is
* a disk with the same name (different devid) that is on the system. Here's
* what we return for each of those cases:
* 1) If disk is in system:
* disk is found on drivelistp or we create a new drivename and it's
* fully populated as expected.
* 2) If disk not in system, no collision
* Disk with the same devid is not found on drivelistp, we create a new
* drivename structure and the dnp->devid is filled in not from getparts
* but from the devidp passed in. No other disk in the system has the
* same "name" or devid.
* This situation would be caused by the import of a partial diskset.
* 3) If disk not in system, collision
* Disk with the same devid is not found on the drivelistp, we create a
* new drivename struct but getparts will use the information from the
* name which is actually in reference to another disk of the same name
* in the system. getparts will fill in the dnp->devid with the value
* from the other disk and we overwrite this with the value of this disk.
* To get into this situation one of the disks is actually unavailable
* as in the case of a partial import.
*/
mddrivename_t *
meta_getdnp_bydevid(
mdsetname_t *sp,
side_t sideno,
ddi_devid_t devidp,
mdkey_t key,
md_error_t *ep
)
{
ddi_devid_t dnp_devidp;
char *nm;
mddrivenamelist_t **tail;
mddrivename_t *dnp;
uint_t slice;
mdname_t *np;
char *rname = NULL;
char *dname = NULL;
uint_t nparts, partno;
int ret;
md_set_desc *sd = NULL;
meta_device_type_t uname_type = LOGICAL_DEVICE;
/* look in the cache first */
for (tail = &drivelistp; (*tail != NULL); tail = &(*tail)->next) {
dnp = (*tail)->drivenamep;
if (dnp->type != MDT_COMP)
continue;
ret = devid_str_decode(dnp->devid, &dnp_devidp, NULL);
if (ret != 0) {
/* unable to decode the devid */
return (NULL);
}
/* compare with the devid passed in. */
if (devid_compare(devidp, dnp_devidp) == 0) {
/* match! We have the same disk */
devid_free(dnp_devidp);
return (dnp);
}
devid_free(dnp_devidp);
}
/* drive not in the cache */
if ((sd = metaget_setdesc(sp, ep)) == NULL) {
return (NULL);
}
/* get namespace info */
if (MD_MNSET_DESC(sd)) {
if ((nm = meta_getnmbykey(MD_LOCAL_SET, sideno,
key, ep)) == NULL)
return (NULL);
} else {
if ((nm = meta_getnmbykey(MD_LOCAL_SET,
sideno+SKEW, key, ep)) == NULL)
return (NULL);
}
/* get raw name (rname) of the slice and drive name (dname) */
if ((rname = getrawnames(&sp, nm, &dname, &uname_type, ep)) == NULL) {
return (NULL);
}
/* allocate new list element and drive */
*tail = Zalloc(sizeof (**tail));
dnp = (*tail)->drivenamep = Zalloc(sizeof (*dnp));
metainitdrivename(dnp);
/* get parts info */
/*
* Note that if the disk is unavailable this name will point to
* either a nonexistent disk and thus the part info and devid will
* be empty or the name will point to the wrong disk and this
* information will be invalid. Because of this, we overwrite the
* dnp->devid with the correct one after getparts returns.
*/
if (getparts(dnp, rname, dname, uname_type, &nparts, &partno, ep) != 0)
goto out;
dnp->devid = devid_str_encode(devidp, NULL);
/*
* libmeta needs at least V_NUMPAR partitions.
* If we have an EFI partition with less than V_NUMPAR slices,
* we nevertheless reserve space for V_NUMPAR
*/
if (nparts < V_NUMPAR) {
nparts = V_NUMPAR;
}
/* allocate and link in parts */
dnp->parts.parts_len = nparts;
dnp->parts.parts_val = Zalloc((sizeof (*dnp->parts.parts_val)) *
dnp->parts.parts_len);
for (slice = 0; (slice < nparts); ++slice) {
np = &dnp->parts.parts_val[slice];
metainitname(np);
np->drivenamep = dnp;
}
/* setup name_t (or slice) wanted */
if ((np = setup_slice(sp, uname_type, dnp, nm, rname,
dname, partno, ep)) == NULL)
goto out;
/* canonical disk name */
if ((dnp->cname = metadiskname(np->cname)) == NULL)
dnp->cname = Strdup(np->cname);
if ((dnp->rname = metadiskname(np->rname)) == NULL)
dnp->rname = Strdup(np->rname);
if (dname != NULL)
Free(dname);
Free(rname);
return (dnp);
out:
if (dname != NULL)
Free(dname);
if (rname != NULL)
Free(rname);
metafreedrivename(dnp);
Free(dnp);
Free(*tail);
*tail = NULL;
return (NULL);
}
/*
* Search the drivename list by devid instead of name. If you don't find
* an entry with the same device id, create one for the uname passed in.
*/
mddrivename_t *
metadrivenamebydevid(
mdsetname_t **spp,
char *devid,
char *uname,
md_error_t *ep
)
{
ddi_devid_t dnp_devidp, in_devidp;
mdname_t *np;
mddrivenamelist_t **tail;
char *rname = NULL;
mddrivename_t *dnp;
char *dname;
int ret;
uint_t nparts, partno;
uint_t slice;
meta_device_type_t uname_type = LOGICAL_DEVICE;
/* look in the cache first */
for (tail = &drivelistp; (*tail != NULL); tail = &(*tail)->next) {
dnp = (*tail)->drivenamep;
if (dnp->type != MDT_COMP)
continue;
/* decode the dnp devid */
ret = devid_str_decode(dnp->devid, &dnp_devidp, NULL);
if (ret != 0) {
/* unable to decode the devid */
return (NULL);
}
/* decode the passed in devid */
ret = devid_str_decode(devid, &in_devidp, NULL);
if (ret != 0) {
/* unable to decode the devid */
devid_free(dnp_devidp);
return (NULL);
}
/* compare with the devids */
if (devid_compare(in_devidp, dnp_devidp) == 0) {
/* match! We have the same disk */
devid_free(dnp_devidp);
devid_free(in_devidp);
return (dnp);
}
}
devid_free(dnp_devidp);
devid_free(in_devidp);
/* not in the cache */
/* get raw name (rname) of the slice and drive (dname) we have */
if ((rname = getrawnames(spp, uname, &dname, &uname_type,
ep)) == NULL) {
return (NULL);
}
/* allocate new list element and drive */
*tail = Zalloc(sizeof (**tail));
dnp = (*tail)->drivenamep = Zalloc(sizeof (*dnp));
metainitdrivename(dnp);
/* get parts info */
if (getparts(dnp, rname, dname, uname_type, &nparts, &partno, ep) != 0)
goto out;
/*
* libmeta needs at least V_NUMPAR partitions.
* If we have an EFI partition with less than V_NUMPAR slices,
* we nevertheless reserve space for V_NUMPAR
*/
if (nparts < V_NUMPAR) {
nparts = V_NUMPAR;
}
/* allocate and link in parts */
dnp->parts.parts_len = nparts;
dnp->parts.parts_val = Zalloc((sizeof (*dnp->parts.parts_val)) *
dnp->parts.parts_len);
for (slice = 0; (slice < nparts); ++slice) {
np = &dnp->parts.parts_val[slice];
metainitname(np);
np->drivenamep = dnp;
}
/* setup name_t (or slice) wanted */
if ((np = setup_slice(*spp, uname_type, dnp, uname, rname,
dname, partno, ep)) == NULL)
goto out;
/* canonical disk name */
if ((dnp->cname = metadiskname(np->cname)) == NULL)
dnp->cname = Strdup(np->cname);
if ((dnp->rname = metadiskname(np->rname)) == NULL)
dnp->rname = Strdup(np->rname);
/* cleanup, return success */
if (dname != NULL)
Free(dname);
Free(rname);
return (dnp);
/* cleanup, return error */
out:
if (dname != NULL)
Free(dname);
if (rname != NULL)
Free(rname);
metafreedrivename(dnp);
Free(dnp);
Free(*tail);
*tail = NULL;
return (NULL);
}
/*
* set up names for a drive
*/
mddrivename_t *
metadrivename(
mdsetname_t **spp,
char *uname,
md_error_t *ep
)
{
char *slicename;
mdname_t *np;
mddrivenamelist_t **tail;
mddrivename_t *dnp;
char *dname;
int i;
int mplen;
size_t len;
assert(uname != NULL);
if ((dname = metadiskname(uname)) == NULL) {
(void) mdsyserror(ep, ENOENT, uname);
return (NULL);
}
/* look in cache first */
for (tail = &drivelistp; (*tail != NULL); tail = &(*tail)->next) {
dnp = (*tail)->drivenamep;
if ((dnp->cname != NULL &&
(strcmp(dnp->cname, dname) == 0)) ||
(dnp->rname != NULL &&
(strcmp(dnp->rname, dname) == 0))) {
Free(dname);
return (dnp);
}
}
Free(dname);
/* Check each possible slice name based on MD_MAX_PARTS. */
/*
* Figure out how much string space to reserve to fit
* (MD_MAX_PARTS - 1) into the name string; the loop will
* increment the mplen counter once for each decimal digit in
* (MD_MAX_PARTS - 1).
*/
for (i = MD_MAX_PARTS - 1, mplen = 0; i; i /= 10, ++mplen)
;
len = strlen(uname) + mplen + 2;
slicename = Malloc(len);
/* Check for each slice in turn until we find one */
for (np = NULL, i = 0; ((np == NULL) && (i < MD_MAX_PARTS)); ++i) {
(void) snprintf(slicename, len, "%ss%d", uname, i);
np = metaname(spp, slicename, LOGICAL_DEVICE, ep);
}
Free(slicename);
if (np == NULL) {
if ((mdiserror(ep, MDE_UNIT_NOT_FOUND)) &&
((dname = metadiskname(uname)) != NULL)) {
Free(dname);
(void) mderror(ep, MDE_NOT_DRIVENAME, uname);
}
return (NULL);
}
return (np->drivenamep);
}
/*
* FUNCTION: metaslicename_type()
* INPUT: dnp - the drivename structure
* sliceno - the slice on the drive to return
* type - LOGICAL_DEVICE or META_DEVICE
* OUTPUT: ep - return error pointer
* RETURNS: mdname_t- pointer the the slice name structure
* PURPOSE: interface to the parts struct in the drive name struct
* Since there is no guarantee that the slice name
* structures are populated users should call this
* function rather than accessing the structure directly
* since it will populate the structure values if they
* haven't already been populated before returning.
*/
mdname_t *
metaslicename_type(
mddrivename_t *dnp,
uint_t sliceno,
meta_device_type_t uname_type,
md_error_t *ep
)
{
mdsetname_t *sp = NULL;
char *namep = NULL;
mdname_t *np;
assert(dnp->type != MDT_FAST_COMP && dnp->type != MDT_FAST_META);
if (sliceno >= dnp->parts.parts_len) {
(void) mderror(ep, MDE_NOSLICE, dnp->cname);
return (NULL);
}
np = &dnp->parts.parts_val[sliceno];
/* check to see if the struct is already populated */
if (np->cname) {
return (np);
}
if ((namep = meta_name_getname(&sp, dnp->cname,
uname_type, ep)) == NULL)
return (NULL);
np = setup_slice(sp, uname_type, dnp, NULL, NULL, dnp->rname,
sliceno, ep);
Free(namep);
return (np);
}
/*
* FUNCTION: metaslicename()
* INPUT: dnp - the drivename structure
* sliceno - the slice on the drive to return
* OUTPUT: ep - return error pointer
* RETURNS: mdname_t- pointer the the slice name structure
* PURPOSE: interface to the parts struct in the drive name struct
* Since there is no guarantee that the slice name
* structures are populated users should call this
* function rather than accessing the structure directly
* since it will populate the structure values if they
* haven't already been populated before returning.
*/
mdname_t *
metaslicename(
mddrivename_t *dnp,
uint_t sliceno,
md_error_t *ep
)
{
return (metaslicename_type(dnp, sliceno, LOGICAL_DEVICE, ep));
}
/*
* set up metadevice name from id
*/
mdname_t *
metamnumname(
mdsetname_t **spp,
minor_t mnum,
int fast,
md_error_t *ep
)
{
set_t setno = MD_MIN2SET(mnum);
mdsetname_t *sp = NULL;
char *uname;
mdname_t *np;
md_dev64_t dev;
mdkey_t key;
/* check set first */
if (spp == NULL)
spp = &sp;
if (chksetno(spp, setno, ep) != 0)
return (NULL);
assert(*spp != NULL);
sp = *spp;
/* get corresponding device name */
dev = metamakedev(mnum);
if ((uname = meta_getnmentbydev(sp->setno, MD_SIDEWILD, dev,
NULL, NULL, &key, ep)) == NULL)
return (NULL);
/* setup name */
if (fast) {
np = metaname_fast(spp, uname, META_DEVICE, ep);
if (np) {
np->dev = dev;
np->key = key;
}
} else
np = metaname(spp, uname, META_DEVICE, ep);
Free(uname);
return (np);
}
/*
* return metadevice name
*/
char *
get_mdname(
mdsetname_t *sp,
minor_t mnum
)
{
mdname_t *np;
md_error_t status = mdnullerror;
mdsetname_t **spp = NULL;
if (sp != NULL)
spp = &sp;
/* get name */
if ((np = metamnumname(spp, mnum, 0, &status)) == NULL) {
return (NULL);
}
assert(meta_getminor(np->dev) == mnum);
/* return name */
return (np->cname);
}
/*
* check for device type
*/
int
metaismeta(
mdname_t *np
)
{
return (np->drivenamep->type == MDT_META ||
np->drivenamep->type == MDT_FAST_META);
}
int
metachkmeta(
mdname_t *np,
md_error_t *ep
)
{
if (! metaismeta(np)) {
return (mddeverror(ep, MDE_NOT_META, np->dev,
np->cname));
}
return (0);
}
int
metachkdisk(
mdname_t *np,
md_error_t *ep
)
{
mddrivename_t *dnp = np->drivenamep;
assert(dnp->type != MDT_FAST_COMP && dnp->type != MDT_FAST_META);
if ((! metaismeta(np)) && (dnp->type != MDT_COMP)) {
switch (dnp->type) {
case MDT_ACCES:
case MDT_UNKNOWN:
return (mdsyserror(ep, dnp->errnum, np->bname));
default:
assert(0);
return (mddeverror(ep, MDE_NOT_DISK, np->dev,
np->cname));
}
}
return (0);
}
int
metachkcomp(
mdname_t *np,
md_error_t *ep
)
{
if (metaismeta(np)) {
return (mddeverror(ep, MDE_IS_META, np->dev,
np->cname));
}
return (metachkdisk(np, ep));
}
/*
* free list of names
*/
void
metafreenamelist(
mdnamelist_t *nlp
)
{
mdnamelist_t *next = NULL;
for (/* void */; (nlp != NULL); nlp = next) {
next = nlp->next;
Free(nlp);
}
}
/*
* build list of names
*/
int
metanamelist(
mdsetname_t **spp,
mdnamelist_t **nlpp,
int argc,
char *argv[],
meta_device_type_t type,
md_error_t *ep
)
{
mdnamelist_t **tailpp = nlpp;
int count = 0;
for (*nlpp = NULL; (argc > 0); ++count, --argc, ++argv) {
mdnamelist_t *nlp = Zalloc(sizeof (*nlp));
if ((nlp->namep = metaname(spp, argv[0],
type, ep)) == NULL) {
metafreenamelist(*nlpp);
*nlpp = NULL;
return (-1);
}
*tailpp = nlp;
tailpp = &nlp->next;
}
return (count);
}
/*
* append to end of name list
*/
mdname_t *
metanamelist_append(
mdnamelist_t **nlpp,
mdname_t *np
)
{
mdnamelist_t *nlp;
/* run to end of list */
for (; (*nlpp != NULL); nlpp = &(*nlpp)->next)
;
/* allocate new list element */
nlp = *nlpp = Zalloc(sizeof (*nlp));
/* append name */
nlp->namep = np;
return (np);
}
/*
* FUNCTION: meta_namelist_append_wrapper()
* INPUT: tailpp - pointer to the list tail pointer
* np - name node to be appended to list
* OUTPUT: none
* RETURNS: mdnamelist_t * - new tail of the list.
* PURPOSE: wrapper to meta_namelist_append for performance.
* metanamelist_append finds the tail each time which slows
* down long lists. By keeping track of the tail ourselves
* we can change metanamelist_append into a constant time
* operation.
*/
mdnamelist_t **
meta_namelist_append_wrapper(
mdnamelist_t **tailpp,
mdname_t *np
)
{
(void) metanamelist_append(tailpp, np);
/* If it's the first item in the list, return it instead of the next */
if ((*tailpp)->next == NULL)
return (tailpp);
return (&(*tailpp)->next);
}
/*
* mdhspname_t stuff
*/
/*
* initialize hspname
*/
static void
metainithspname(
mdhspname_t *hspnamep
)
{
(void) memset(hspnamep, '\0', sizeof (*hspnamep));
hspnamep->hsp = MD_HSP_NONE;
}
/*
* free allocated hspname
*/
static void
metafreehspname(
mdhspname_t *hspnamep
)
{
if (hspnamep->hspname != NULL)
Free(hspnamep->hspname);
if (hspnamep->unitp != NULL)
meta_invalidate_hsp(hspnamep);
metainithspname(hspnamep);
}
/*
* clear the hspname cache
*/
static void
metaflushhspnames()
{
mdhspnamelist_t *p, *n;
for (p = hsplistp, n = NULL; (p != NULL); p = n) {
n = p->next;
metafreehspname(p->hspnamep);
Free(p->hspnamep);
Free(p);
}
hsplistp = NULL;
}
/*
* check set and get comparison name
*/
static char *
gethspname(
mdsetname_t **spp,
char *uname,
md_error_t *ep
)
{
char *cname = NULL;
cname = meta_canonicalize(*spp, uname);
/* if it is not a meta/hsp name then flag an error */
if (cname == NULL) {
(void) mdsyserror(ep, ENOENT, uname);
return (NULL);
}
return (cname);
}
/*
* set up a hotspare pool name structure using both the name
* and the self id
*/
static mdhspname_t *
metahspname_hsp(
mdsetname_t **spp,
char *uname,
hsp_t hsp,
md_error_t *ep
)
{
char *cname;
mdhspnamelist_t **tail;
mdhspname_t *hspnp;
/* check setname */
assert(uname != NULL);
if ((cname = gethspname(spp, uname, ep)) == NULL)
return (NULL);
assert(*spp != NULL);
/* look in cache first */
for (tail = &hsplistp; (*tail != NULL); tail = &(*tail)->next) {
hspnp = (*tail)->hspnamep;
if (strcmp(hspnp->hspname, cname) == 0) {
Free(cname);
/* if the hsp value has not been set then set it now */
if (hspnp->hsp == MD_HSP_NONE)
hspnp->hsp = hsp;
return (hspnp);
}
}
/* if the hsp number isn't specified then attempt to get it */
if (hsp == MD_HSP_NONE && (hsp = meta_gethspnmentbyname((*spp)->setno,
MD_SIDEWILD, cname, ep)) == MD_HSP_NONE) {
if (! mdisok(ep)) {
/*
* If the error is ENOENT, then we will continue on,
* because the device does not yet exist.
* For other types of errors, however, we'll bail out.
*/
if (! mdissyserror(ep, ENOENT)) {
Free(cname);
return (NULL);
}
mdclrerror(ep);
}
}
/* allocate new list element and hspname */
*tail = Zalloc(sizeof (**tail));
hspnp = (*tail)->hspnamep = Zalloc(sizeof (*hspnp));
metainithspname(hspnp);
/* save hspname and number */
hspnp->hspname = cname;
hspnp->hsp = hsp;
/* success */
return (hspnp);
}
/*
* set up names for a hotspare pool
*/
mdhspname_t *
metahspname(
mdsetname_t **spp,
char *uname,
md_error_t *ep
)
{
return (metahspname_hsp(spp, uname, MD_HSP_NONE, ep));
}
/*
* set up hotspare pool name from key
*/
mdhspname_t *
metahsphspname(
mdsetname_t **spp,
hsp_t hsp,
md_error_t *ep
)
{
set_t setno = HSP_SET(hsp);
mdsetname_t *sp = NULL;
char *uname;
mdhspname_t *hspnp;
/* check set first */
if (spp == NULL)
spp = &sp;
if (chksetno(spp, setno, ep) != 0)
return (NULL);
assert(*spp != NULL);
sp = *spp;
/* get corresponding hotspare pool name */
if ((uname = meta_gethspnmentbyid(sp->setno,
MD_SIDEWILD, hsp, ep)) == NULL)
return (NULL);
/* setup name */
hspnp = metahspname_hsp(spp, uname, hsp, ep);
Free(uname);
return (hspnp);
}
/*
* return hotspare pool name
*/
char *
get_hspname(mdsetname_t *sp, hsp_t hsp)
{
mdhspname_t *hspnp;
md_error_t status = mdnullerror;
mdsetname_t **spp = NULL;
if (sp != NULL)
spp = &sp;
/* get name */
if ((hspnp = metahsphspname(spp, hsp, &status)) == NULL) {
mdclrerror(&status);
return (NULL);
}
/* return name */
return (hspnp->hspname);
}
/*
* free hotspare pool list
*/
void
metafreehspnamelist(mdhspnamelist_t *hspnlp)
{
mdhspnamelist_t *next = NULL;
for (/* void */; (hspnlp != NULL); hspnlp = next) {
next = hspnlp->next;
Free(hspnlp);
}
}
/*
* build list of hotspare pool names
*/
int
metahspnamelist(
mdsetname_t **spp,
mdhspnamelist_t **hspnlpp,
int argc,
char *argv[],
md_error_t *ep
)
{
mdhspnamelist_t **tailpp = hspnlpp;
int count = 0;
for (*hspnlpp = NULL; (argc > 0); ++count, --argc, ++argv) {
mdhspnamelist_t *hspnlp = Zalloc(sizeof (*hspnlp));
if ((hspnlp->hspnamep = metahspname(spp, argv[0],
ep)) == NULL) {
metafreehspnamelist(*hspnlpp);
*hspnlpp = NULL;
return (-1);
}
*tailpp = hspnlp;
tailpp = &hspnlp->next;
}
return (count);
}
/*
* append to end of hotspare pool list
*/
mdhspname_t *
metahspnamelist_append(mdhspnamelist_t **hspnlpp, mdhspname_t *hspnp)
{
mdhspnamelist_t *hspnlp;
/* run to end of list */
for (; (*hspnlpp != NULL); hspnlpp = &(*hspnlpp)->next)
;
/* allocate new list element */
hspnlp = *hspnlpp = Zalloc(sizeof (*hspnlp));
/* append hotspare pool name */
hspnlp->hspnamep = hspnp;
return (hspnp);
}
/*
* get name from dev
*/
mdname_t *
metadevname(
mdsetname_t **spp,
md_dev64_t dev,
md_error_t *ep)
{
char *device_name;
mdname_t *namep;
mdkey_t key;
/* short circuit metadevices */
assert(dev != NODEV64);
if (meta_dev_ismeta(dev))
return (metamnumname(spp, meta_getminor(dev), 0, ep));
/* create local set, if necessary */
if (*spp == NULL) {
if ((*spp = metasetname(MD_LOCAL_NAME, ep)) == NULL)
return (NULL);
}
/* get name from namespace */
if ((device_name = meta_getnmentbydev((*spp)->setno, MD_SIDEWILD,
dev, NULL, NULL, &key, ep)) == NULL) {
return (NULL);
}
namep = metaname_fast(spp, device_name, LOGICAL_DEVICE, ep);
if (namep != NULL)
namep->key = key;
Free(device_name);
return (namep);
}
/*
* return cached name from md_dev64_t
*/
static char *
metadevtocachename(md_dev64_t dev)
{
mddrivenamelist_t *dnlp;
/* look in cache */
for (dnlp = drivelistp; (dnlp != NULL); dnlp = dnlp->next) {
mddrivename_t *dnp = dnlp->drivenamep;
uint_t i;
for (i = 0; (i < dnp->parts.parts_len); ++i) {
mdname_t *np = &dnp->parts.parts_val[i];
if (np->dev == dev)
return (np->cname);
}
}
/* not found */
return (NULL);
}
/*
* Ask the driver for the name, which has been stored in the
* metadevice state database (on behalf of the utilities).
* (by devno)
*/
char *
get_devname(
set_t setno,
md_dev64_t dev)
{
mdsetname_t *sp;
mdname_t *np;
md_error_t status = mdnullerror;
/* get name */
if ((setno == MD_SET_BAD) ||
((sp = metasetnosetname(setno, &status)) == NULL) ||
((np = metadevname(&sp, dev, &status)) == NULL)) {
mdclrerror(&status);
return (metadevtocachename(dev));
}
/* return name */
return (np->cname);
}
/*
* get name from key
*/
mdname_t *
metakeyname(
mdsetname_t **spp,
mdkey_t key,
int fast,
md_error_t *ep
)
{
char *device_name;
md_dev64_t dev = NODEV64;
mdname_t *namep;
/* create local set, if necessary */
if (*spp == NULL) {
if ((*spp = metasetname(MD_LOCAL_NAME, ep)) == NULL)
return (NULL);
}
/* get name from namespace */
if ((device_name = meta_getnmentbykey((*spp)->setno, MD_SIDEWILD,
key, NULL, NULL, &dev, ep)) == NULL) {
return (NULL);
}
if (fast)
namep = metaname_fast(spp, device_name, UNKNOWN, ep);
else
namep = metaname(spp, device_name, UNKNOWN, ep);
assert(dev != NODEV64);
if (namep)
namep->dev = dev;
Free(device_name);
return (namep);
}
/*
* completely flush metadev/hsp caches
*/
void
metaflushmetanames()
{
metaflushhspnames();
metaflushdrivenames();
metaflushfastnames();
metaflushstatcache();
}
/*
* completely flush the caches
*/
void
metaflushnames(int flush_sr_cache)
{
metaflushhspnames();
metaflushdrivenames();
metaflushsetnames();
metaflushctlrcache();
metaflushfastnames();
metaflushstatcache();
if (flush_sr_cache)
sr_cache_flush(0);
}
/*
* meta_get_hotspare_names
* returns an mdnamelist_t of hot spare names
*/
int
meta_get_hotspare_names(
mdsetname_t *sp,
mdnamelist_t **nlpp,
int options,
md_error_t *ep
)
{
mdhspnamelist_t *hspnlp = NULL;
mdhspnamelist_t *hspp;
int cnt = 0;
assert(nlpp != NULL);
/* get hotspare names */
if (meta_get_hsp_names(sp, &hspnlp, options, ep) < 0) {
cnt = -1;
goto out;
}
/* build name list */
for (hspp = hspnlp; (hspp != NULL); hspp = hspp->next) {
md_hsp_t *hsp;
int i;
if ((hsp = meta_get_hsp(sp, hspp->hspnamep, ep)) == NULL) {
cnt = -1;
goto out;
}
for (i = 0; (i < hsp->hotspares.hotspares_len); i++) {
md_hs_t *hs = &hsp->hotspares.hotspares_val[i];
(void) metanamelist_append(nlpp, hs->hsnamep);
++cnt;
}
}
/* cleanup and return count or error */
out:
metafreehspnamelist(hspnlp);
if ((cnt == -1) && mdisok(ep)) {
/*
* At least try to give some sort of meaningful error
*/
(void) mderror(ep, MDE_NO_HSPS, "Generic Hotspare Error");
}
return (cnt);
}
/*
* meta_create_non_dup_list
* INPUT: mdnp mdname_t pointer to add to the list if a new name
* ldevidp list of non-duplicate names.
* OUTPUT: ldevidp list of non-duplicate names.
* meta_create_non_dup_list will take a mdname_t pointer and if the device
* is not in the list (ldevidp) will add it to the list.
* User needs to free allocated memory.
*/
void
meta_create_non_dup_list(
mdname_t *mdnp,
mddevid_t **ldevidpp
)
{
char *lcname;
mddevid_t *tmp;
mddevid_t *lastdevidp;
mddevid_t *lldevidp;
char *ctd, *slice;
mddevid_t *ldevidp;
if (mdnp == NULL)
return;
ldevidp = *ldevidpp;
/*
* Grab the name of the device and strip off slice information
*/
lcname = Strdup(mdnp->cname);
if (lcname == NULL) {
return;
}
ctd = strrchr(lcname, '/');
if (ctd != NULL)
slice = strrchr(ctd, 's');
else
slice = strrchr(lcname, 's');
if (slice != NULL)
*slice = '\0';
if (ldevidp == NULL) {
/* first item in list */
ldevidp = Zalloc(sizeof (mddevid_t));
ldevidp->ctdname = lcname;
ldevidp->key = mdnp->key;
*ldevidpp = ldevidp;
} else {
for (tmp = ldevidp; (tmp != NULL); tmp = tmp->next) {
if (strcmp(tmp->ctdname, lcname) == 0) {
/* already there so just return */
Free(lcname);
return;
}
lastdevidp = tmp;
}
lldevidp = Zalloc(sizeof (mddevid_t));
lldevidp->ctdname = lcname;
lldevidp->key = mdnp->key;
lastdevidp->next = lldevidp;
}
}