OpenSolaris_b135/lib/lvm/libmeta/common/meta_error.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 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* 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
/*
* print metedevice errors
*/
#include <meta.h>
#include <sys/lvm/md_mddb.h>
#include <syslog.h>
/*
* clear error
*/
void
mdclrerror(
md_error_t *ep
)
{
if (ep->name != NULL)
Free(ep->name);
if (ep->host != NULL)
Free(ep->host);
if (ep->extra != NULL)
Free(ep->extra);
(void) memset(ep, '\0', sizeof (*ep));
}
/*
* cook names
*/
static char *
md_name(
minor_t mnum
)
{
char *name;
/* get name, or fake it */
if ((name = get_mdname(NULL, mnum)) == NULL) {
char buf[40];
(void) sprintf(buf, "%lu/%lu", MD_MIN2SET(mnum),
MD_MIN2UNIT(mnum));
return (Strdup(buf));
}
return (Strdup(name));
}
static char *
dev_name(
set_t setno,
md_dev64_t dev
)
{
char *name;
/* get name or fake it */
if (dev == NODEV64)
return (Strdup(dgettext(TEXT_DOMAIN, "unknown device")));
if ((name = get_devname(setno, dev)) == NULL) {
char buf[40];
(void) sprintf(buf, "%lu.%lu", meta_getmajor(dev),
meta_getminor(dev));
return (Strdup(buf));
}
return (Strdup(name));
}
static char *
hsp_name(
hsp_t hsp
)
{
char *name;
if ((name = get_hspname(NULL, hsp)) == NULL) {
char buf[40];
(void) sprintf(buf, "%u/%u", HSP_SET(hsp), HSP_ID(hsp));
return (Strdup(buf));
}
return (Strdup(name));
}
static char *
set_name(
set_t setno
)
{
mdsetname_t *sp;
md_error_t xep = mdnullerror;
if (setno == MD_SET_BAD)
return (NULL);
if ((sp = metasetnosetname(setno, &xep)) == NULL) {
char buf[40];
mdclrerror(&xep);
(void) sprintf(buf, "setno %u", setno);
return (Strdup(buf));
}
return (Strdup(sp->setname));
}
/*
* fill in all the appropriate md_error_t fields
*/
static void
metacookerror(
md_error_t *ep, /* generic error */
char *name /* optional name or host */
)
{
/* get host name */
if (ep->host != NULL) {
Free(ep->host);
ep->host = NULL;
}
if ((ep->info.errclass == MDEC_RPC) &&
(name != NULL) && (*name != '\0')) {
ep->host = Strdup(name);
name = NULL;
} else
ep->host = Strdup(mynode());
/* get appropriate name */
if (ep->name != NULL) {
Free(ep->name);
ep->name = NULL;
}
if ((name != NULL) && (*name != '\0')) {
ep->name = Strdup(name);
} else {
switch (ep->info.errclass) {
/* can't do anything about these */
case MDEC_VOID:
case MDEC_SYS:
case MDEC_RPC:
default:
break;
/* device name */
case MDEC_DEV:
{
md_dev_error_t *ip =
&ep->info.md_error_info_t_u.dev_error;
ep->name = dev_name(MD_SET_BAD, ip->dev);
break;
}
/* device name */
case MDEC_USE:
{
md_use_error_t *ip =
&ep->info.md_error_info_t_u.use_error;
ep->name = dev_name(MD_SET_BAD, ip->dev);
if (ip->where == NULL) {
ip->where = Strdup(dgettext(TEXT_DOMAIN,
"unknown"));
}
break;
}
/* metadevice name */
case MDEC_MD:
{
md_md_error_t *ip =
&ep->info.md_error_info_t_u.md_error;
ep->name = md_name(ip->mnum);
break;
}
/* component name */
case MDEC_COMP:
{
md_comp_error_t *ip =
&ep->info.md_error_info_t_u.comp_error;
char *mdname, *devname;
size_t len;
mdname = md_name(ip->comp.mnum);
devname = dev_name(MD_MIN2SET(ip->comp.mnum),
ip->comp.dev);
len = strlen(mdname) + strlen(": ")
+ strlen(devname) + 1;
ep->name = Malloc(len);
(void) snprintf(ep->name, len, "%s: %s",
mdname, devname);
Free(mdname);
Free(devname);
break;
}
/* hotspare pool name */
case MDEC_HSP:
{
md_hsp_error_t *ip =
&ep->info.md_error_info_t_u.hsp_error;
ep->name = hsp_name(ip->hsp);
break;
}
/* hotspare name */
case MDEC_HS:
{
md_hs_error_t *ip =
&ep->info.md_error_info_t_u.hs_error;
char *hspname, *devname;
size_t len;
hspname = hsp_name(ip->hs.hsp);
devname = dev_name(HSP_SET(ip->hs.hsp), ip->hs.dev);
len = strlen(hspname) + strlen(": ")
+ strlen(devname) + 1;
ep->name = Malloc(len);
(void) snprintf(ep->name, len, "%s: %s",
hspname, devname);
Free(hspname);
Free(devname);
break;
}
/* mddb name */
case MDEC_MDDB:
{
md_mddb_error_t *ip =
&ep->info.md_error_info_t_u.mddb_error;
if (ip->mnum != NODEV32)
ep->name = md_name(ip->mnum);
ep->name = set_name(ip->setno);
break;
}
/* set name */
case MDEC_DS:
{
md_ds_error_t *ip =
&ep->info.md_error_info_t_u.ds_error;
ep->name = set_name(ip->setno);
break;
}
}
}
}
/*
* simple error
*/
int
mderror(
md_error_t *ep,
md_void_errno_t errnum,
char *name
)
{
md_void_error_t *ip = &ep->info.md_error_info_t_u.void_error;
mdclrerror(ep);
ep->info.errclass = MDEC_VOID;
ip->errnum = errnum;
metacookerror(ep, name);
return (-1);
}
/*
* system error
*/
int
mdsyserror(
md_error_t *ep,
int errnum,
char *name
)
{
md_sys_error_t *ip = &ep->info.md_error_info_t_u.sys_error;
mdclrerror(ep);
if (errnum != 0) {
ep->info.errclass = MDEC_SYS;
ip->errnum = errnum;
}
metacookerror(ep, name);
return (-1);
}
/*
* RPC error
*/
int
mdrpcerror(
md_error_t *ep,
CLIENT *clntp,
char *host,
char *extra
)
{
md_rpc_error_t *ip = &ep->info.md_error_info_t_u.rpc_error;
struct rpc_err rpcerr;
mdclrerror(ep);
clnt_geterr(clntp, &rpcerr);
ep->info.errclass = MDEC_RPC;
ip->errnum = rpcerr.re_status;
metacookerror(ep, host);
mderrorextra(ep, extra);
return (-1);
}
/*
* RPC create error
*/
int
mdrpccreateerror(
md_error_t *ep,
char *host,
char *extra
)
{
md_rpc_error_t *ip = &ep->info.md_error_info_t_u.rpc_error;
mdclrerror(ep);
ep->info.errclass = MDEC_RPC;
ip->errnum = rpc_createerr.cf_stat;
metacookerror(ep, host);
mderrorextra(ep, extra);
return (-1);
}
/*
* device error
*/
int
mddeverror(
md_error_t *ep,
md_dev_errno_t errnum,
md_dev64_t dev,
char *name
)
{
md_dev_error_t *ip = &ep->info.md_error_info_t_u.dev_error;
mdclrerror(ep);
ep->info.errclass = MDEC_DEV;
ip->errnum = errnum;
ip->dev = dev;
metacookerror(ep, name);
return (-1);
}
/*
* use error
*/
int
mduseerror(
md_error_t *ep,
md_use_errno_t errnum,
md_dev64_t dev,
char *where,
char *name
)
{
md_use_error_t *ip = &ep->info.md_error_info_t_u.use_error;
assert(where != NULL);
mdclrerror(ep);
ep->info.errclass = MDEC_USE;
ip->errnum = errnum;
ip->dev = dev;
ip->where = Strdup(where);
metacookerror(ep, name);
return (-1);
}
/*
* overlap error
*/
int
mdoverlaperror(
md_error_t *ep,
md_overlap_errno_t errnum,
char *name,
char *where,
char *overlap
)
{
md_overlap_error_t *ip =
&ep->info.md_error_info_t_u.overlap_error;
assert(overlap != NULL);
mdclrerror(ep);
ep->info.errclass = MDEC_OVERLAP;
ip->errnum = errnum;
ip->overlap = Strdup(overlap);
ip->where = NULL;
if (where != NULL)
ip->where = Strdup(where);
metacookerror(ep, name);
return (-1);
}
/*
* metadevice error
*/
int
mdmderror(
md_error_t *ep,
md_md_errno_t errnum,
minor_t mnum,
char *name
)
{
md_md_error_t *ip = &ep->info.md_error_info_t_u.md_error;
mdclrerror(ep);
ep->info.errclass = MDEC_MD;
ip->errnum = errnum;
ip->mnum = mnum;
metacookerror(ep, name);
return (-1);
}
/*
* component error
*/
int
mdcomperror(
md_error_t *ep,
md_comp_errno_t errnum,
minor_t mnum,
md_dev64_t dev,
char *name
)
{
md_comp_error_t *ip = &ep->info.md_error_info_t_u.comp_error;
mdclrerror(ep);
ep->info.errclass = MDEC_COMP;
ip->errnum = errnum;
ip->comp.mnum = mnum;
ip->comp.dev = dev;
metacookerror(ep, name);
return (-1);
}
/*
* hotspare pool error
*/
int
mdhsperror(
md_error_t *ep,
md_hsp_errno_t errnum,
hsp_t hsp,
char *name
)
{
md_hsp_error_t *ip = &ep->info.md_error_info_t_u.hsp_error;
mdclrerror(ep);
ep->info.errclass = MDEC_HSP;
ip->errnum = errnum;
ip->hsp = hsp;
metacookerror(ep, name);
return (-1);
}
/*
* hotspare error
*/
int
mdhserror(
md_error_t *ep,
md_hs_errno_t errnum,
hsp_t hsp,
md_dev64_t dev,
char *name
)
{
md_hs_error_t *ip = &ep->info.md_error_info_t_u.hs_error;
mdclrerror(ep);
ep->info.errclass = MDEC_HS;
ip->errnum = errnum;
ip->hs.hsp = hsp;
ip->hs.dev = dev;
metacookerror(ep, name);
return (-1);
}
/*
* MDDB error
*/
int
mdmddberror(
md_error_t *ep,
md_mddb_errno_t errnum,
minor_t mnum,
set_t setno,
size_t size,
char *name
)
{
md_mddb_error_t *ip = &ep->info.md_error_info_t_u.mddb_error;
mdclrerror(ep);
ep->info.errclass = MDEC_MDDB;
ip->errnum = errnum;
ip->mnum = mnum;
ip->setno = setno;
ip->size = size;
metacookerror(ep, name);
return (-1);
}
/*
* metadevice diskset (ds) error
*/
int
mddserror(
md_error_t *ep,
md_ds_errno_t errnum,
set_t setno,
char *node,
char *drive,
char *name
)
{
md_ds_error_t *ip = &ep->info.md_error_info_t_u.ds_error;
mdclrerror(ep);
ep->info.errclass = MDEC_DS;
ip->errnum = errnum;
ip->setno = setno;
ip->node = ((node != NULL) ? Strdup(node) : NULL);
ip->drive = ((drive != NULL) ? Strdup(drive) : NULL);
metacookerror(ep, name);
return (-1);
}
/*
* clear/attach extra context information
*/
void
mderrorextra(
md_error_t *ep,
char *extra
)
{
if (ep->extra != NULL)
Free(ep->extra);
if (extra != NULL)
ep->extra = Strdup(extra);
else
ep->extra = NULL;
}
/*
* steal (copy) an error code safely
*/
int
mdstealerror(
md_error_t *to,
md_error_t *from
)
{
mdclrerror(to);
*to = *from;
(void) memset(from, '\0', sizeof (*from));
return (-1);
}
/*
* do an ioctl, cook the error, and return status
*/
int
metaioctl(
int cmd,
void *data,
md_error_t *ep,
char *name
)
{
int fd;
/* open admin device */
if ((fd = open_admin(ep)) < 0)
return (-1);
/* do ioctl */
mdclrerror(ep);
if (ioctl(fd, cmd, data) != 0) {
return (mdsyserror(ep, errno, name));
} else if (! mdisok(ep)) {
metacookerror(ep, name);
return (-1);
}
/* return success */
return (0);
}
/*
* print void class errors
*/
static char *
void_to_str(
md_error_t *ep,
char *buf,
size_t size
)
{
md_void_error_t *ip = &ep->info.md_error_info_t_u.void_error;
char *p = buf + strlen(buf);
size_t psize = size - strlen(buf);
switch (ip->errnum) {
case MDE_NONE:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "no error"));
break;
case MDE_UNIT_NOT_FOUND:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "unit not found"));
break;
case MDE_DUPDRIVE:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "drive specified more than once"));
break;
case MDE_INVAL_HSOP:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "illegal hot spare operation"));
break;
case MDE_NO_SET:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "no such set"));
break;
case MDE_SET_DIFF:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "set name is inconsistent"));
break;
case MDE_BAD_RD_OPT:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "invalid read option"));
break;
case MDE_BAD_WR_OPT:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "invalid write option"));
break;
case MDE_BAD_PASS_NUM:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "invalid pass number"));
break;
case MDE_BAD_RESYNC_OPT:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "invalid resync option"));
break;
case MDE_BAD_INTERLACE:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "invalid interlace"));
break;
case MDE_NO_HSPS:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "no hotspare pools found"));
break;
case MDE_NOTENOUGH_DB:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"must have at least 1 database (-f overrides)"));
break;
case MDE_DELDB_NOTALLOWED:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"cannot delete the last database replica in the diskset"));
break;
case MDE_DEL_VALIDDB_NOTALLOWED:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"Deleting specified valid replicas results in stale "
"state database. Configuration changes with stale "
"database result in panic(-f overrides)"));
break;
case MDE_SYSTEM_FILE:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "error in system file"));
break;
case MDE_MDDB_FILE:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "error in mddb.cf file"));
break;
case MDE_MDDB_CKSUM:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "checksum error in mddb.cf file"));
break;
case MDE_VFSTAB_FILE:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "error in vfstab file"));
break;
case MDE_NOSLICE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"invalid slice number for drive name"));
break;
case MDE_SYNTAX:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "syntax error"));
break;
case MDE_OPTION:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "illegal option"));
break;
case MDE_TAKE_OWN:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "failed to reserve any drives"));
break;
case MDE_NOT_DRIVENAME:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "not a valid drive name"));
break;
case MDE_RESERVED:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "reserved by another host"));
break;
case MDE_DVERSION:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "driver version mismatch"));
break;
case MDE_MVERSION:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"metadevice state database version mismatch"));
break;
case MDE_TESTERROR:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "TEST ERROR MESSAGE"));
break;
case MDE_BAD_ORIG_NCOL:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "invalid column count"));
break;
case MDE_RAID_INVALID:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"devices were not RAIDed previously or "
"are specified in the wrong order"));
break;
case MDE_MED_ERROR:
break;
case MDE_TOOMANYMED:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"too many mediator hosts requested"));
break;
case MDE_NOMED:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "no mediator hosts found"));
break;
case MDE_ONLYNODENAME:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"only the nodename of a host is required for deletes"));
break;
case MDE_RAID_BAD_PW_CNT:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"simultaneous writes out of range"));
break;
case MDE_DEVID_TOOBIG:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"relocation information size is greater than reported"));
break;
case MDE_NOPERM:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"Permission denied. You must have root privilege "
"to execute this command."));
break;
case MDE_NODEVID:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"Device relocation information not available "
"for this device"));
break;
case MDE_NOROOT:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"no root filesystem in /etc/mnttab"));
break;
case MDE_EOF_TRANS:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
MD_EOF_TRANS_MSG));
break;
case MDE_NOT_MN:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"option only valid within a multi-owner set"));
break;
case MDE_ABR_SET:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"Invalid command for mirror with ABR set"));
break;
case MDE_INVAL_MNOP:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"Invalid operation on multi-owner set"));
break;
case MDE_MNSET_NOTRANS:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"Trans metadevice not supported on multi-owner set"));
break;
case MDE_MNSET_NORAID:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"RAID-5 metadevice not supported on multi-owner set"));
break;
case MDE_FORCE_DEL_ALL_DRV:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"Must specify -f option to delete all drives from set"));
break;
case MDE_STRIPE_TRUNC_SINGLE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"The necessary rounding would result in data loss. "
"You can avoid this by concatenating additional devices "
"totaling at least %s blocks, or by increasing the size "
"of the specified component by exactly %s blocks."),
ep->extra, ep->extra);
break;
case MDE_STRIPE_TRUNC_MULTIPLE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"The necessary rounding would result in data loss. "
"You can avoid this by concatenating additional devices "
"totaling at least %s blocks."), ep->extra);
break;
case MDE_SMF_FAIL:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"failed to enable/disable SVM service"));
break;
case MDE_SMF_NO_SERVICE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"service(s) not online in SMF"));
break;
case MDE_AMBIGUOUS_DEV:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"Specify complete path to avoid ambiguity."));
break;
case MDE_NAME_IN_USE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"Name already in use for metadevice or hot spare pool."));
break;
case MDE_NAME_ILLEGAL:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"Invalid name for metadevice or hot spare pool."));
break;
case MDE_ZONE_ADMIN:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"Volume administration unavailable within non-global zones."));
break;
case MDE_MISSING_DEVID_DISK:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"device id does not exist."));
break;
default:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"unknown void error code %d"), ip->errnum);
break;
}
return (buf);
}
/*
* print sys class errors
*/
static char *
sys_to_str(
md_error_t *ep,
char *buf,
size_t size
)
{
md_sys_error_t *ip = &ep->info.md_error_info_t_u.sys_error;
char *emsg;
char *p = buf + strlen(buf);
size_t psize = size - strlen(buf);
if ((emsg = strerror(ip->errnum)) == NULL) {
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "unknown errno %d out of range"),
ip->errnum);
} else {
(void) snprintf(p, psize, "%s", emsg);
}
return (buf);
}
/*
* print RPC class errors
*/
static char *
rpc_to_str(
md_error_t *ep,
char *buf,
size_t size
)
{
md_rpc_error_t *ip = &ep->info.md_error_info_t_u.rpc_error;
char *p = buf + strlen(buf);
size_t psize = size - strlen(buf);
(void) snprintf(p, psize, "%s", clnt_sperrno(ip->errnum));
return (buf);
}
/*
* print dev class errors
*/
static char *
dev_to_str(
md_error_t *ep,
char *buf,
size_t size
)
{
md_dev_error_t *ip = &ep->info.md_error_info_t_u.dev_error;
char *p = buf + strlen(buf);
size_t psize = size - strlen(buf);
switch (ip->errnum) {
case MDE_INVAL_HS:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "hotspare doesn't exist"));
break;
case MDE_FIX_INVAL_STATE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"cannot enable hotspared device"));
break;
case MDE_FIX_INVAL_HS_STATE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"hotspare isn't broken, can't enable"));
break;
case MDE_NOT_META:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "not a metadevice"));
break;
case MDE_IS_DUMP:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "is a dump device"));
break;
case MDE_IS_META:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "is a metadevice"));
break;
case MDE_IS_SWAPPED:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "is swapped on"));
break;
case MDE_NAME_SPACE:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "namespace error"));
break;
case MDE_IN_SHARED_SET:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "device in shared set"));
break;
case MDE_NOT_IN_SET:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "device not in set"));
break;
case MDE_NOT_DISK:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "not a disk device"));
break;
case MDE_CANT_CONFIRM:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "can't confirm device"));
break;
case MDE_INVALID_PART:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "invalid partition"));
break;
case MDE_HAS_MDDB:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"has a metadevice database replica"));
break;
case MDE_NO_DB:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"no metadevice database replica on device"));
break;
case MDE_CANTVERIFY_VTOC:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "unable to verify the vtoc"));
break;
case MDE_NOT_LOCAL:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "not in local set"));
break;
case MDE_DEVICES_NAME:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "can't parse /devices name"));
break;
case MDE_REPCOMP_INVAL:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"replica slice is not usable as a metadevice component"));
break;
case MDE_REPCOMP_ONLY:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"only replica slice is usable for a diskset "
"database replica"));
break;
case MDE_INV_ROOT:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"invalid root device for this operation"));
break;
case MDE_MULTNM:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"multiple entries for device in Solaris Volume Manager "
"configuration"));
break;
case MDE_TOO_MANY_PARTS:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"Disks with more than %d partitions are not supported "
"in Solaris Volume Manager"), MD_MAX_PARTS);
break;
case MDE_REPART_REPLICA:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"cannot repartition a slice with an existing replica"));
break;
case MDE_DISKNAMETOOLONG:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"disk name is too long with device ids disabled "
"in Solaris Volume Manager. Check /kernel/drv/md.conf "
"for md_devid_destroy, remove it and reboot"));
break;
default:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "unknown dev error code %d"),
ip->errnum);
break;
}
return (buf);
}
/*
* print overlap class errors
*/
static char *
overlap_to_str(
md_error_t *ep,
char *buf,
size_t size
)
{
md_overlap_error_t *ip =
&ep->info.md_error_info_t_u.overlap_error;
char *p = buf + strlen(buf);
size_t psize = size - strlen(buf);
switch (ip->errnum) {
case MDE_OVERLAP_MOUNTED:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"overlaps with %s which is mounted as \'%s\'"),
ip->overlap, ip->where);
break;
case MDE_OVERLAP_SWAP:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"overlaps with %s which is a swap device"), ip->overlap);
break;
case MDE_OVERLAP_DUMP:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"overlaps with %s which is the dump device"), ip->overlap);
break;
default:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"unknown overlap error code %d"), ip->errnum);
break;
}
return (buf);
}
/*
* print use class errors
*/
static char *
use_to_str(
md_error_t *ep,
char *buf,
size_t size
)
{
md_use_error_t *ip = &ep->info.md_error_info_t_u.use_error;
char *p = buf + strlen(buf);
size_t psize = size - strlen(buf);
switch (ip->errnum) {
case MDE_IS_MOUNTED:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "is mounted on %s"),
ip->where);
break;
case MDE_ALREADY:
/*
* when the object of the error (existing device that
* would being used by SVM) is the metadb then it is necessary
* to explicitly specify the string in the error message so
* that it can be successfully localized for the Asian locales.
*/
if (strcmp(ip->where, MDB_STR) != 0) {
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"has appeared more than once in the "
"specification of %s"), ip->where);
} else {
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"has appeared more than once in the "
"specification of " MDB_STR));
}
break;
case MDE_OVERLAP:
/*
* when the object of the error (existing device that
* would overlap) is the metadb then it is necessary
* to explicitly specify the string in the error message so
* that it can be successfully localized for the Asian locales.
*/
if (strcmp(ip->where, MDB_STR) != 0) {
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "overlaps with device in %s"),
ip->where);
} else {
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "overlaps with device in "
MDB_STR));
}
break;
case MDE_SAME_DEVID:
/*
* when the object of the error (existing device in the
* metaconfiguration that has the same devid)
* is the metadb then it is necessary
* to explicitly specify the string in the error message so
* that it can be successfully localized for the Asian locales.
*/
if (strcmp(ip->where, MDB_STR) != 0) {
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"identical devid detected on %s"), ip->where);
} else {
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"identical devid detected in " MDB_STR));
}
break;
default:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"unknown dev error code %d"), ip->errnum);
break;
}
return (buf);
}
/*
* print md class errors
*/
static char *
md_to_str(
md_error_t *ep,
char *buf,
size_t size
)
{
md_md_error_t *ip = &ep->info.md_error_info_t_u.md_error;
char *p = buf + strlen(buf);
size_t psize = size - strlen(buf);
switch (ip->errnum) {
case MDE_INVAL_UNIT:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "invalid unit"));
break;
case MDE_UNIT_NOT_SETUP:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "unit not set up"));
break;
case MDE_UNIT_ALREADY_SETUP:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "unit already set up"));
break;
case MDE_NOT_MM:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "unit is not a mirror"));
break;
case MDE_IS_SM:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "illegal to clear submirror"));
break;
case MDE_IS_OPEN:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "metadevice is open"));
break;
case MDE_C_WITH_INVAL_SM:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"attempted to clear mirror with submirror(s) "
"in invalid state"));
break;
case MDE_RESYNC_ACTIVE:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "resync in progress"));
break;
case MDE_LAST_SM_RE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"attempt to replace a component on the last "
"running submirror"));
break;
case MDE_MIRROR_FULL:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"mirror has maximum number of submirrors"));
break;
case MDE_IN_UNAVAIL_STATE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"component is in unavailable state; run 'metastat -i'"));
break;
case MDE_IN_USE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"metadevice in use"));
break;
case MDE_SM_TOO_SMALL:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "submirror too small to attach"));
break;
case MDE_NO_LABELED_SM:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"can't attach labeled submirror to an unlabeled mirror"));
break;
case MDE_SM_OPEN_ERR:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "submirror open error"));
break;
case MDE_CANT_FIND_SM:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "can't find submirror in mirror"));
break;
case MDE_LAST_SM:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"attempt to detach last running submirror"));
break;
case MDE_NO_READABLE_SM:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"operation would result in no readable submirrors"));
break;
case MDE_SM_FAILED_COMPS:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"attempt an operation on a submirror "
"that has erred components"));
break;
case MDE_ILLEGAL_SM_STATE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"attempt operation on a submirror in illegal state"));
break;
case MDE_RR_ALLOC_ERROR:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"attach failed, unable to allocate new resync info"));
break;
case MDE_MIRROR_OPEN_FAILURE:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "insufficient devices to open"));
break;
case MDE_MIRROR_THREAD_FAILURE:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "mirror thread failure"));
break;
case MDE_GROW_DELAYED:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "growing of metadevice delayed"));
break;
case MDE_NOT_MT:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "unit is not a trans"));
break;
case MDE_HS_IN_USE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"can't modify hot spare pool, hot spare in use"));
break;
case MDE_HAS_LOG:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "already has log"));
break;
case MDE_UNKNOWN_TYPE:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "unknown metadevice type"));
break;
case MDE_NOT_STRIPE:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "unit is not a concat/stripe"));
break;
case MDE_NOT_RAID:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "unit is not a RAID"));
break;
case MDE_NROWS:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "not enough stripes specified"));
break;
case MDE_NCOMPS:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "not enough components specified"));
break;
case MDE_NSUBMIRS:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "not enough submirrors specified"));
break;
case MDE_BAD_STRIPE:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "invalid stripe configuration"));
break;
case MDE_BAD_MIRROR:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "invalid mirror configuration"));
break;
case MDE_BAD_TRANS:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "invalid trans configuration"));
break;
case MDE_BAD_RAID:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "invalid RAID configuration"));
break;
case MDE_RAID_OPEN_FAILURE:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "resync unable to open RAID unit"));
break;
case MDE_RAID_THREAD_FAILURE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"attempt to start resync thread failed"));
break;
case MDE_RAID_NEED_FORCE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"operation requires -f (force) flag"));
break;
case MDE_NO_LOG:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "log has already been detached"));
break;
case MDE_RAID_DOI:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "only valid action is metaclear"));
break;
case MDE_RAID_LAST_ERRED:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"in Last Erred state, "
"errored components must be replaced"));
break;
case MDE_RAID_NOT_OKAY:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"all components must be Okay to perform this operation"));
break;
case MDE_RENAME_BUSY:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"metadevice is temporarily too busy for renames"));
break;
case MDE_RENAME_SOURCE_BAD:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"source metadevice is not able to be renamed"));
break;
case MDE_RENAME_TARGET_BAD:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"target metadevice is not able to be renamed"));
break;
case MDE_RENAME_TARGET_UNRELATED:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"target metadevice is not related to source metadevice"));
break;
case MDE_RENAME_CONFIG_ERROR:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"metadevice driver configuration error; "
"rename can't occur"));
break;
case MDE_RENAME_ORDER:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"units may not be renamed in that order"));
break;
case MDE_RECOVER_FAILED:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "recovery failed"));
break;
case MDE_SP_NOSPACE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"not enough space available for request"));
break;
case MDE_SP_BADWMREAD:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "error reading extent header"));
break;
case MDE_SP_BADWMWRITE:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "error writing extent header"));
break;
case MDE_SP_BADWMMAGIC:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "bad magic number in extent header"));
break;
case MDE_SP_BADWMCRC:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "bad checksum in extent header"));
break;
case MDE_NOT_SP:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "unit is not a soft partition"));
break;
case MDE_SP_OVERLAP:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "overlapping extents specified"));
break;
case MDE_SP_BAD_LENGTH:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "bad length specified"));
break;
case MDE_SP_NOSP:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "no soft partitions on this device"));
break;
case MDE_UNIT_TOO_LARGE:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "Volume size cannot exceed 1 TByte"));
break;
case MDE_LOG_TOO_LARGE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"Trans log size must be less than 1 TByte"));
break;
default:
(void) snprintf(p, psize,
dgettext(TEXT_DOMAIN, "unknown md error code %d"),
ip->errnum);
break;
}
return (buf);
}
/*
* print comp class errors
*/
static char *
comp_to_str(
md_error_t *ep,
char *buf,
size_t size
)
{
md_comp_error_t *ip = &ep->info.md_error_info_t_u.comp_error;
char *p = buf + strlen(buf);
size_t psize = size - strlen(buf);
switch (ip->errnum) {
case MDE_CANT_FIND_COMP:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"can't find component in unit"));
break;
case MDE_REPL_INVAL_STATE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"component in invalid state to replace - "
"Replace \"Maintenance\" components first"));
break;
case MDE_COMP_TOO_SMALL:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"replace failure, new component is too small"));
break;
case MDE_COMP_OPEN_ERR:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"unable to open concat/stripe component"));
break;
case MDE_RAID_COMP_ERRED:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"must replace errored component first"));
break;
case MDE_MAXIO:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"maxtransfer is too small"));
break;
case MDE_SP_COMP_OPEN_ERR:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"error opening device under soft partition. Check"
" device status, then use metadevadm(1M)."));
break;
default:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"unknown comp error code %d"), ip->errnum);
break;
}
return (buf);
}
/*
* print hsp class errors
*/
static char *
hsp_to_str(
md_error_t *ep,
char *buf,
size_t size
)
{
md_hsp_error_t *ip = &ep->info.md_error_info_t_u.hsp_error;
char *p = buf + strlen(buf);
size_t psize = size - strlen(buf);
switch (ip->errnum) {
case MDE_HSP_CREATE_FAILURE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"hotspare pool database create failure"));
break;
case MDE_HSP_IN_USE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"hotspare pool in use"));
break;
case MDE_INVAL_HSP:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"invalid hotspare pool"));
break;
case MDE_HSP_BUSY:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"hotspare pool is busy"));
break;
case MDE_HSP_REF:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"hotspare pool is referenced"));
break;
case MDE_HSP_ALREADY_SETUP:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"hotspare pool is already setup"));
break;
case MDE_BAD_HSP:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"invalid hotspare pool configuration"));
break;
case MDE_HSP_UNIT_TOO_LARGE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"units in the hotspare pool cannot exceed 1 TByte"));
break;
default:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"unknown hsp error code %d"), ip->errnum);
break;
}
return (buf);
}
/*
* print hs class errors
*/
static char *
hs_to_str(
md_error_t *ep,
char *buf,
size_t size
)
{
md_hs_error_t *ip = &ep->info.md_error_info_t_u.hs_error;
char *p = buf + strlen(buf);
size_t psize = size - strlen(buf);
switch (ip->errnum) {
case MDE_HS_RESVD:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"hotspare is in use"));
break;
case MDE_HS_CREATE_FAILURE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"hotspare database create failure"));
break;
case MDE_HS_INUSE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"add or replace failed, hot spare is already in use"));
break;
case MDE_HS_UNIT_TOO_LARGE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"hotspare size cannot exceed 1 TByte"));
break;
default:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"unknown hs error code %d"), ip->errnum);
break;
}
return (buf);
}
/*
* print mddb class errors
*/
static char *
mddb_to_str(
md_error_t *ep,
char *buf,
size_t size
)
{
md_mddb_error_t *ip = &ep->info.md_error_info_t_u.mddb_error;
char *p = buf + strlen(buf);
size_t psize = size - strlen(buf);
switch (ip->errnum) {
case MDE_TOOMANY_REPLICAS:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"%d metadevice database replicas is too many; the maximum is %d"),
ip->size, MDDB_NLB);
break;
case MDE_REPLICA_TOOSMALL:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"device size %d is too small for metadevice database replica"),
ip->size);
break;
case MDE_NOTVERIFIED:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"data not returned correctly from disk"));
break;
case MDE_DB_INVALID:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"invalid argument"));
break;
case MDE_DB_EXISTS:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"metadevice database replica exists on device"));
break;
case MDE_DB_MASTER:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"has bad master block on device"));
break;
case MDE_DB_TOOSMALL:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"device is too small"));
break;
case MDE_DB_NORECORD:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"no such metadevice database record"));
break;
case MDE_DB_NOSPACE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"metadevice database is full, can't create new records"));
break;
case MDE_DB_NOTNOW:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"metadevice database has too few replicas, for "
"metadevice database operation"));
break;
case MDE_DB_NODB:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"there are no existing databases"));
break;
case MDE_DB_NOTOWNER:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"not owner of metadevice database"));
break;
case MDE_DB_STALE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"stale databases"));
break;
case MDE_DB_TOOFEW:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"not enough databases"));
break;
case MDE_DB_TAGDATA:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"tagged data detected, user intervention required"));
break;
case MDE_DB_ACCOK:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"50% replicas & 50% mediator hosts available, "
"user intervention required"));
break;
case MDE_DB_NTAGDATA:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"no tagged data available or only one tag found"));
break;
case MDE_DB_ACCNOTOK:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"50% replicas & 50% mediator hosts not available"));
break;
case MDE_DB_NOLOCBLK:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"no valid locator blocks were found"));
break;
case MDE_DB_NOLOCNMS:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"no valid locator name information was found"));
break;
case MDE_DB_NODIRBLK:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"no valid directory blocks were found"));
break;
case MDE_DB_NOTAGREC:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"no tag record was allocated, so data "
"tagging is disabled"));
break;
case MDE_DB_NOTAG:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"no tag records exist or no matching tag was found"));
break;
case MDE_DB_BLKRANGE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"logical block number %d out of range"), ip->size);
break;
default:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"unknown mddb error code %d"), ip->errnum);
break;
}
return (buf);
}
/*
* print diskset (ds) class errors
*/
static char *
ds_to_str(
md_error_t *ep,
char *buf,
size_t size
)
{
md_ds_error_t *ip = &ep->info.md_error_info_t_u.ds_error;
char *p = buf + strlen(buf);
size_t psize = size - strlen(buf);
switch (ip->errnum) {
case MDE_DS_DUPHOST:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"host %s is specified more than once"), ip->node);
break;
case MDE_DS_NOTNODENAME:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"\"%s\" is not a nodename, but a network name"), ip->node);
break;
case MDE_DS_SELFNOTIN:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"nodename of host %s creating the set must be included"),
ip->node);
break;
case MDE_DS_NODEHASSET:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"host %s already has set"), ip->node);
break;
case MDE_DS_NODENOSET:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"host %s does not have set"), ip->node);
break;
case MDE_DS_NOOWNER:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"must be owner of the set for this command"));
break;
case MDE_DS_NOTOWNER:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"only the current owner %s may operate on this set"),
ip->node);
break;
case MDE_DS_NODEISNOTOWNER:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"host %s is not the owner"), ip->node);
break;
case MDE_DS_NODEINSET:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"host %s is already in the set"), ip->node);
break;
case MDE_DS_NODENOTINSET:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"host %s is not in the set"), ip->node);
break;
case MDE_DS_SETNUMBUSY:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"host %s already has a set numbered %ld"),
ip->node, ip->setno);
break;
case MDE_DS_SETNUMNOTAVAIL:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"no available set numbers"));
break;
case MDE_DS_SETNAMEBUSY:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"set name is in-use or invalid on host %s"), ip->node);
break;
case MDE_DS_DRIVENOTCOMMON:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"drive %s is not common with host %s"),
ip->drive, ip->node);
break;
case MDE_DS_DRIVEINSET:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"drive %s is in set %s"), ip->drive, ip->node);
break;
case MDE_DS_DRIVENOTINSET:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"drive %s is not in set"), ip->drive);
break;
case MDE_DS_DRIVEINUSE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"drive %s is in use"), ip->drive);
break;
case MDE_DS_DUPDRIVE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"drive %s is specified more than once"), ip->drive);
break;
case MDE_DS_INVALIDSETNAME:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"set name contains invalid characters"));
break;
case MDE_DS_HASDRIVES:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"unable to delete set, it still has drives"));
break;
case MDE_DS_SIDENUMNOTAVAIL:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"maximum number of nodenames exceeded"));
break;
case MDE_DS_SETNAMETOOLONG:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"set name is too long"));
break;
case MDE_DS_NODENAMETOOLONG:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"host name %s is too long"), ip->node);
break;
case MDE_DS_OHACANTDELSELF:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"administrator host %s deletion disallowed in one host admin mode"),
ip->node);
break;
case MDE_DS_HOSTNOSIDE:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"side information missing for host %s"), ip->node);
break;
case MDE_DS_SETLOCKED:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"host %s is modifying set - try later or restart rpc.metad"),
ip->drive);
break;
case MDE_DS_ULKSBADKEY:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"set unlock failed - bad key"));
break;
case MDE_DS_LKSBADKEY:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"set lock failed - bad key"));
break;
case MDE_DS_WRITEWITHSULK:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"write operation attempted on set with set unlocked"));
break;
case MDE_DS_SETCLEANUP:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"set \"%s\" is out of date - cleaning up - take failed"),
ip->node);
break;
case MDE_DS_CANTDELSELF:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"administrator host %s can't be deleted, other hosts still in set\n"
"Use -f to override"), ip->node);
break;
case MDE_DS_HASMED:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"unable to delete set, it still has mediator hosts"));
break;
case MDE_DS_TOOMANYALIAS:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"%s causes there to be more aliases than allowed"),
ip->node);
break;
case MDE_DS_ISMED:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"%s is already a mediator host"), ip->node);
break;
case MDE_DS_ISNOTMED:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"%s is not a mediator host"), ip->node);
break;
case MDE_DS_INVALIDMEDNAME:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"mediator name \"%s\" contains invalid characters"),
ip->node);
break;
case MDE_DS_ALIASNOMATCH:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"mediator alias \"%s\" is not an alias for host "
"\"%s\""), ip->node, ip->drive);
break;
case MDE_DS_NOMEDONHOST:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"unable to contact %s on host \"%s\""),
MED_SERVNAME, ip->node);
break;
case MDE_DS_DRIVENOTONHOST:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"drive %s is not present on host %s"),
ip->drive, ip->node);
break;
case MDE_DS_CANTDELMASTER:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"master %s can't be deleted, other hosts still in set"),
ip->node);
break;
case MDE_DS_NOTINMEMBERLIST:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"node %s is not in membership list"),
ip->node);
break;
case MDE_DS_MNCANTDELSELF:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"host %s can't delete self from multi-owner set\n"
"while other hosts still in set"),
ip->node);
break;
case MDE_DS_RPCVERSMISMATCH:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"host %s does not support multi-owner diskset"),
ip->node);
break;
case MDE_DS_WITHDRAWMASTER:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"master host %s cannot withdraw from multi-owner diskset "
"when other owner nodes are still present in diskset"),
ip->node);
break;
case MDE_DS_CANTRESNARF:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"imported set could not be loaded"));
break;
case MDE_DS_INSUFQUORUM:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"insufficient replica quorum detected. Use "
"-f to force import of the set"));
break;
case MDE_DS_EXTENDEDNM:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"multiple namespace records detected"));
break;
case MDE_DS_COMMDCTL_SUSPEND_NYD:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"rpc.mdcommd on host %s is not yet drained during "
"suspend operation"),
ip->node);
break;
case MDE_DS_COMMDCTL_SUSPEND_FAIL:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"rpc.mdcommd on host %s failed suspend operation"),
ip->node);
break;
case MDE_DS_COMMDCTL_REINIT_FAIL:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"rpc.mdcommd on host %s failed reinitialization operation"),
ip->node);
break;
case MDE_DS_COMMDCTL_RESUME_FAIL:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"rpc.mdcommd on host %s failed resume operation"),
ip->node);
break;
case MDE_DS_NOTNOW_RECONFIG:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"command terminated, host %s starting reconfig cycle"),
ip->node);
break;
case MDE_DS_NOTNOW_CMD:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"metaset or metadb command already running on diskset "
"on host %s"), ip->node);
break;
case MDE_DS_COMMD_SEND_FAIL:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"rpc.mdcommd on host %s failed operation"),
ip->node);
break;
case MDE_DS_MASTER_ONLY:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"this command must be run on the master node of the set,"
" which is currently %s"), ip->node);
break;
case MDE_DS_SINGLEHOST:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"diskset is auto-take; cannot accept additional hosts"));
break;
case MDE_DS_AUTONOTSET:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"auto-take is not enabled on diskset"));
break;
case MDE_DS_INVALIDDEVID:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"Invalid device id on drive %s on host %s"), ip->drive,
ip->node);
break;
case MDE_DS_SETNOTIMP:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"Unable to import set on node %s"), ip->node);
break;
case MDE_DS_NOTSELFIDENTIFY:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"Drive %s won't be self identifying"), ip->drive);
break;
default:
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"unknown diskset error code %d"), ip->errnum);
break;
}
return (buf);
}
/*
* convert error to printable string
*/
static char *
mde_to_str(
md_error_t *ep
)
{
static char buf[BUFSIZ];
size_t bufsz;
/* intialize buf */
buf[0] = '\0';
bufsz = sizeof (buf);
/* class specific */
switch (ep->info.errclass) {
case MDEC_VOID:
return (void_to_str(ep, buf, bufsz));
case MDEC_SYS:
return (sys_to_str(ep, buf, bufsz));
case MDEC_RPC:
return (rpc_to_str(ep, buf, bufsz));
case MDEC_DEV:
return (dev_to_str(ep, buf, bufsz));
case MDEC_USE:
return (use_to_str(ep, buf, bufsz));
case MDEC_MD:
return (md_to_str(ep, buf, bufsz));
case MDEC_COMP:
return (comp_to_str(ep, buf, bufsz));
case MDEC_HSP:
return (hsp_to_str(ep, buf, bufsz));
case MDEC_HS:
return (hs_to_str(ep, buf, bufsz));
case MDEC_MDDB:
return (mddb_to_str(ep, buf, bufsz));
case MDEC_DS:
return (ds_to_str(ep, buf, bufsz));
case MDEC_OVERLAP:
return (overlap_to_str(ep, buf, bufsz));
default:
(void) snprintf(buf, bufsz,
dgettext(TEXT_DOMAIN, "unknown error class %d"),
ep->info.errclass);
return (buf);
}
}
/*
* print log prefix
*/
void
md_logpfx(
FILE *fp
)
{
time_t t;
struct tm *tm;
char buf[100];
if ((time(&t) != (time_t)-1) &&
((tm = localtime(&t)) != NULL) &&
(strftime(buf, sizeof (buf), (char *)0, tm) < sizeof (buf))) {
(void) fprintf(fp, "%s: ", buf);
}
(void) fprintf(fp, "%s: ", myname);
}
/*
* varargs sperror()
*/
/*PRINTFLIKE2*/
static char *
mde_vsperror(
md_error_t *ep,
const char *fmt,
va_list ap
)
{
static char buf[BUFSIZ];
size_t bufsz = sizeof (buf);
char *p = buf;
char *host1 = "";
char *host2 = "";
char *extra1 = "";
char *extra2 = "";
char *name1 = "";
char *name2 = "";
/* get stuff */
if ((ep->host != NULL) && (*(ep->host) != '\0')) {
host1 = ep->host;
host2 = ": ";
}
if ((ep->extra != NULL) && (*(ep->extra) != '\0')) {
extra1 = ep->extra;
extra2 = ": ";
}
if ((ep->name != NULL) && (*(ep->name) != '\0')) {
name1 = ep->name;
name2 = ": ";
}
/* context */
(void) snprintf(p, bufsz, "%s%s%s%s%s%s",
host1, host2, extra1, extra2, name1, name2);
p = &buf[strlen(buf)];
bufsz -= strlen(buf);
/* user defined part */
if ((fmt != NULL) && (*fmt != '\0')) {
(void) vsnprintf(p, bufsz, fmt, ap);
p = &buf[strlen(buf)];
bufsz = sizeof (buf) - strlen(buf);
(void) snprintf(p, bufsz, ": ");
p = &buf[strlen(buf)];
bufsz = sizeof (buf) - strlen(buf);
}
/* error code */
(void) snprintf(p, bufsz, "%s\n", mde_to_str(ep));
/* return error message */
return (buf);
}
/*
* printf-like sperror()
*/
/*PRINTFLIKE2*/
char *
mde_sperror(
md_error_t *ep,
const char *fmt,
...
)
{
va_list ap;
char *emsg;
va_start(ap, fmt);
emsg = mde_vsperror(ep, fmt, ap);
va_end(ap);
return (emsg);
}
/*
* printf-like perror()
*/
/*PRINTFLIKE2*/
void
mde_perror(
md_error_t *ep,
const char *fmt,
...
)
{
va_list ap;
char *emsg;
/* get error message */
va_start(ap, fmt);
emsg = mde_vsperror(ep, fmt, ap);
va_end(ap);
assert((emsg != NULL) && (*emsg != '\0'));
/* stderr */
(void) fprintf(stderr, "%s: %s\n", myname, emsg);
(void) fflush(stderr);
/* metalog */
if (metalogfp != NULL) {
md_logpfx(metalogfp);
(void) fprintf(metalogfp, "%s\n", emsg);
(void) fflush(metalogfp);
(void) fsync(fileno(metalogfp));
}
/* syslog */
if (metasyslog) {
syslog(LOG_ERR, emsg);
}
}
/*
* printf-like perror()
*/
/*PRINTFLIKE1*/
void
md_perror(
const char *fmt,
...
)
{
md_error_t status = mdnullerror;
va_list ap;
char *emsg;
/* get error message */
(void) mdsyserror(&status, errno, NULL);
va_start(ap, fmt);
emsg = mde_vsperror(&status, fmt, ap);
va_end(ap);
assert((emsg != NULL) && (*emsg != '\0'));
mdclrerror(&status);
/* stderr */
(void) fprintf(stderr, "%s: %s\n", myname, emsg);
(void) fflush(stderr);
/* metalog */
if (metalogfp != NULL) {
md_logpfx(metalogfp);
(void) fprintf(metalogfp, "%s\n", emsg);
(void) fflush(metalogfp);
(void) fsync(fileno(metalogfp));
}
/* syslog */
if (metasyslog) {
syslog(LOG_ERR, emsg);
}
}
/*
* printf-like log
*/
/*PRINTFLIKE1*/
void
md_eprintf(
const char *fmt,
...
)
{
va_list ap;
/* begin */
va_start(ap, fmt);
/* stderr */
(void) fprintf(stderr, "%s: ", myname);
(void) vfprintf(stderr, fmt, ap);
(void) fflush(stderr);
/* metalog */
if (metalogfp != NULL) {
md_logpfx(metalogfp);
(void) vfprintf(metalogfp, fmt, ap);
(void) fflush(metalogfp);
(void) fsync(fileno(metalogfp));
}
/* syslog */
if (metasyslog) {
vsyslog(LOG_ERR, fmt, ap);
}
/* end */
va_end(ap);
}
/*
* metaclust timing messages logging routine
*
* level - The class of the message to be logged. Message will be logged
* if this is less than or equal to the verbosity level.
*/
void
meta_mc_log(int level, const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
/*
* Log all messages upto MC_LOG2 to syslog regardless of the
* verbosity level
*/
if (metasyslog && (level <= MC_LOG2)) {
if (level <= MC_LOG1)
(void) vsyslog(LOG_ERR, fmt, args);
else
(void) vsyslog(LOG_INFO, fmt, args);
}
/*
* Print all messages to stderr provided the message level is
* within the verbosity level
*/
if (level <= verbosity) {
(void) fprintf(stderr, "%s: ", myname);
(void) vfprintf(stderr, fmt, args);
(void) fprintf(stderr, "\n");
(void) fflush(stderr);
}
va_end(args);
}