OpenSolaris_b135/lib/lvm/libmeta/common/meta_med.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.
*/
/*
* 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
/*
* Mediator functions
*/
#include <meta.h>
#include <metamed.h>
#include <dlfcn.h>
#include <sdssc.h>
/*
* There are too many external factors that affect the timing of the
* operations, so we set the timeout to a very large value, in this
* case 1 day, which should handle HW timeouts, large configurations,
* and other potential delays.
*/
#define CL_LONG_TMO 86400L /* 1 day */
#define CL_MEDIUM_TMO 3600L /* 1 hour */
#define CL_SHORT_TMO 600L /* 10 minutes */
#define CL_DEF_TMO 10L /* 10 seconds */
static md_timeval32_t def_rpcb_timeout = { MD_CLNT_CREATE_TOUT, 0 };
/*
* RPC handle
*/
typedef struct {
char *hostname;
CLIENT *clntp;
} med_handle_t;
/*
* Data to be sent from med_clnt_create_timed to med_create_helper via
* meta_client_create_retry.
*/
typedef struct {
rpcprog_t mcd_program; /* RPC program designation */
rpcvers_t mcd_version; /* RPC version */
char *mcd_nettype; /* Type of network to use for RPC */
} med_create_data_t;
/*
* Perform the work of actually doing the clnt_create for
* meta_client_create_retry.
*/
static CLIENT *
med_create_helper(char *hostname, void *private, struct timeval *time_out)
{
med_create_data_t *cd = (med_create_data_t *)private;
return (clnt_create_timed(hostname, cd->mcd_program, cd->mcd_version,
cd->mcd_nettype, time_out));
}
static
CLIENT *med_clnt_create_timed(
char *hostname,
const ulong_t prog,
const ulong_t vers,
char *nettype,
const md_timeval32_t *tp
)
{
med_create_data_t cd; /* Create data. */
cd.mcd_program = prog;
cd.mcd_version = vers;
cd.mcd_nettype = nettype;
return (meta_client_create_retry(hostname, med_create_helper,
(void *)&cd, (time_t)tp->tv_sec, NULL));
}
/*
* Set the timeout value for this client handle.
*/
static int
cl_sto_medd(
CLIENT *clntp,
char *hostname,
long time_out,
md_error_t *ep
)
{
md_timeval32_t nto;
(void) memset(&nto, '\0', sizeof (nto));
nto.tv_sec = time_out;
if (clnt_control(clntp, CLSET_TIMEOUT, (char *)&nto) != TRUE)
return (mdrpcerror(ep, clntp, hostname,
dgettext(TEXT_DOMAIN, "metad client set timeout")));
return (0);
}
/*
* close RPC connection
*/
static void
close_medd(
med_handle_t *hp
)
{
assert(hp != NULL);
if (hp->hostname != NULL) {
Free(hp->hostname);
}
if (hp->clntp != NULL) {
auth_destroy(hp->clntp->cl_auth);
clnt_destroy(hp->clntp);
}
Free(hp);
}
/*
* open RPC connection to rpc.medd
*/
static med_handle_t *
open_medd(
char *hostname,
long time_out,
md_error_t *ep
)
{
CLIENT *clntp;
med_handle_t *hp;
/* default to local host */
if ((hostname == NULL) || (*hostname == '\0'))
hostname = mynode();
/* open RPC connection */
assert(hostname != NULL);
if ((clntp = med_clnt_create_timed(hostname, MED_PROG, MED_VERS,
"tcp", &def_rpcb_timeout)) == NULL) {
if (rpc_createerr.cf_stat != RPC_PROGNOTREGISTERED)
clnt_pcreateerror(hostname);
(void) mdrpccreateerror(ep, hostname,
"medd med_clnt_create_timed");
return (NULL);
} else {
auth_destroy(clntp->cl_auth);
clntp->cl_auth = authsys_create_default();
assert(clntp->cl_auth != NULL);
}
if (cl_sto_medd(clntp, hostname, time_out, ep) != 0)
return (NULL);
/* return connection */
hp = Zalloc(sizeof (*hp));
hp->hostname = Strdup(hostname);
hp->clntp = clntp;
return (hp);
}
/*
* steal and convert med_err_t
*/
int
meddstealerror(
md_error_t *ep,
med_err_t *medep
)
{
char buf[BUFSIZ];
char *p = buf;
size_t psize = BUFSIZ;
char *emsg;
int rval = -1;
/* no error */
if (medep->med_errno == 0) {
/* assert(medep->name == NULL); */
rval = 0;
goto out;
}
/* steal error */
if ((medep->med_node != NULL) && (medep->med_node[0] != '\0')) {
(void) snprintf(p, psize, "%s: ", medep->med_node);
p = &buf[strlen(buf)];
psize = buf + BUFSIZ - p;
}
if ((medep->med_misc != NULL) && (medep->med_misc[0] != '\0')) {
(void) snprintf(p, psize, "%s: ", medep->med_misc);
p = &buf[strlen(buf)];
psize = buf + BUFSIZ - p;
}
if (medep->med_errno < 0) {
if ((emsg = med_errnum_to_str(medep->med_errno)) != NULL)
(void) snprintf(p, psize, "%s", emsg);
else
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"unknown mediator errno %d\n"), medep->med_errno);
} else {
if ((emsg = strerror(medep->med_errno)) != NULL)
(void) snprintf(p, psize, "%s", emsg);
else
(void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
"errno %d out of range"), medep->med_errno);
}
(void) mderror(ep, MDE_MED_ERROR, buf);
/* cleanup, return success */
out:
if (medep->med_node != NULL)
Free(medep->med_node);
if (medep->med_misc != NULL)
Free(medep->med_misc);
(void) memset(medep, 0, sizeof (*medep));
return (rval);
}
static med_handle_t *
open_medd_wrap(
md_h_t *mdhp,
long time_out,
md_error_t *ep
)
{
med_handle_t *hp = NULL;
int i;
char *hnm;
assert(mdhp && mdhp->a_cnt > 0);
/* Loop through the hosts listed */
i = min(mdhp->a_cnt, MAX_HOST_ADDRS) - 1;
for (; i >= 0; i--) {
hnm = mdhp->a_nm[i];
if ((hp = open_medd(hnm, time_out, ep)) == NULL) {
if (mdanyrpcerror(ep) && i != 0) {
mdclrerror(ep);
continue;
}
}
return (hp);
}
rpc_createerr.cf_stat = RPC_CANTSEND;
rpc_createerr.cf_error.re_status = 0;
(void) mdrpccreateerror(ep, mdhp->a_nm[0],
dgettext(TEXT_DOMAIN, "medd open wrap"));
return (NULL);
}
static int
setup_med_transtab(md_error_t *ep)
{
mddb_med_t_parm_t *tp = NULL;
struct stat statb;
int i;
size_t alloc_size = 0;
int err = 0;
if ((tp = Zalloc(sizeof (mddb_med_t_parm_t))) == NULL)
return (mdsyserror(ep, ENOMEM, "setup_med_transtab"));
if (metaioctl(MD_MED_GET_TLEN, tp, &tp->med_tp_mde, NULL) != 0) {
err = mdstealerror(ep, &tp->med_tp_mde);
goto out;
}
if (tp->med_tp_setup == 1)
goto out;
alloc_size = (sizeof (mddb_med_t_parm_t) - sizeof (mddb_med_t_ent_t)) +
(sizeof (mddb_med_t_ent_t) * tp->med_tp_nents);
if ((tp = Realloc(tp, alloc_size)) == NULL) {
err = mdsyserror(ep, ENOMEM, "setup_med_transtab");
goto out;
}
if (metaioctl(MD_MED_GET_T, tp, &tp->med_tp_mde, NULL) != 0) {
err = mdstealerror(ep, &tp->med_tp_mde);
goto out;
}
for (i = 0; i < tp->med_tp_nents; i++) {
if (meta_stat(tp->med_tp_ents[i].med_te_nm, &statb) == -1) {
md_perror("setup_med_transtab(): stat():");
tp->med_tp_ents[i].med_te_dev = NODEV64;
} else {
tp->med_tp_ents[i].med_te_dev =
meta_expldev(statb.st_rdev);
}
}
if (metaioctl(MD_MED_SET_T, tp, &tp->med_tp_mde, NULL) != 0)
err = mdstealerror(ep, &tp->med_tp_mde);
out:
Free(tp);
return (err);
}
/*
* Externals
*/
/*
* NULLPROC - just returns a response
*/
int
clnt_med_null(
char *hostname,
md_error_t *ep
)
{
med_handle_t *hp;
med_err_t res;
/* initialize */
mdclrerror(ep);
/* do it */
if ((hp = open_medd(hostname, CL_DEF_TMO, ep)) == NULL)
return (-1);
if (med_null_1(NULL, &res, hp->clntp) != RPC_SUCCESS)
(void) mdrpcerror(ep, hp->clntp, hostname,
dgettext(TEXT_DOMAIN, "medd nullproc"));
close_medd(hp);
xdr_free(xdr_med_err_t, (char *)&res);
if (! mdisok(ep))
return (-1);
return (0);
}
/*
* Update the mediator information on the mediator.
* This function does the same functionality as
* clnt_med_upd_data() except that it takes different
* argument so that host which is just a mediator, can
* still update its mediator record.
*/
int
clnt_user_med_upd_data(
md_h_t *mdhp,
bool_t obandiskset,
char *setname,
uint_t setnum,
med_data_t *meddp,
md_error_t *ep
)
{
med_handle_t *hp;
med_upd_data_args_t args;
med_err_t res;
/* Initialize */
mdclrerror(ep);
(void) memset(&args, 0, sizeof (args));
(void) memset(&res, 0, sizeof (res));
/* Build args */
if (obandiskset)
args.med.med_caller = Strdup(MED_MN_CALLER);
else
args.med.med_caller = Strdup(mynode());
args.med.med_setname = Strdup(setname);
args.med.med_setno = setnum;
args.med_data = *meddp;
if ((hp = open_medd_wrap(mdhp, CL_DEF_TMO, ep)) == NULL)
return (-1);
if (med_upd_data_1(&args, &res, hp->clntp) != RPC_SUCCESS)
(void) mdrpcerror(ep, hp->clntp, hp->hostname,
dgettext(TEXT_DOMAIN, "medd get record"));
else
(void) meddstealerror(ep, &res);
close_medd(hp);
xdr_free(xdr_med_upd_data_args_t, (char *)&args);
xdr_free(xdr_med_err_t, (char *)&res);
if (! mdisok(ep))
return (-1);
return (0);
}
/*
* Get the mediator information from the client.
* The code does same functinality as clnt_med_get_data()
* except that it takes different arguments so that
* host which doesn't have set information, can still
* get access to mediator information
*/
int
clnt_user_med_get_data(
md_h_t *mdhp,
bool_t obandiskset,
char *setname,
uint_t setnum,
med_data_t *meddp,
md_error_t *ep
)
{
int rval = -1;
med_handle_t *hp;
med_args_t args;
med_get_data_res_t res;
/* Initialize */
mdclrerror(ep);
(void) memset(&args, 0, sizeof (args));
(void) memset(&res, 0, sizeof (res));
/* Build args */
if (obandiskset)
args.med.med_caller = Strdup(MED_MN_CALLER);
else
args.med.med_caller = Strdup(mynode());
args.med.med_setname = Strdup(setname);
args.med.med_setno = setnum;
if ((hp = open_medd_wrap(mdhp, CL_DEF_TMO, ep)) == NULL)
return (-1);
if (med_get_data_1(&args, &res, hp->clntp) != RPC_SUCCESS)
(void) mdrpcerror(ep, hp->clntp, hp->hostname,
dgettext(TEXT_DOMAIN, "medd get record"));
else
(void) meddstealerror(ep, &res.med_status);
close_medd(hp);
if (mdisok(ep)) {
/* copy the mediator data in meddp */
(void) memmove(meddp, &res.med_data, sizeof (med_data_t));
rval = 0;
}
xdr_free(xdr_med_args_t, (char *)&args);
xdr_free(xdr_med_get_data_res_t, (char *)&res);
return (rval);
}
/*
* Update the mediator information on the mediator.
* *** This is not normally called from user code, the kernel does this! ***
*/
int
clnt_med_upd_data(
md_h_t *mdhp,
mdsetname_t *sp,
med_data_t *meddp,
md_error_t *ep
)
{
med_handle_t *hp;
med_upd_data_args_t args;
med_err_t res;
md_set_desc *sd;
/* initialize */
mdclrerror(ep);
(void) memset(&args, 0, sizeof (args));
(void) memset(&res, 0, sizeof (res));
/* build args */
if ((sd = metaget_setdesc(sp, ep)) == NULL)
return (-1);
if (MD_MNSET_DESC(sd))
/*
* In the MN diskset, use a generic nodename, multiowner, as
* the node initiating the RPC request. This allows
* any node to access mediator information.
*
* MN diskset reconfig cycle forces consistent
* view of set/node/drive/mediator information across all nodes
* in the MN diskset. This allows the relaxation of
* node name checking in rpc.metamedd for MN disksets.
*
* In the traditional diskset, only a calling node that is
* in the mediator record's diskset nodelist can access
* mediator data.
*/
args.med.med_caller = Strdup(MED_MN_CALLER);
else
args.med.med_caller = Strdup(mynode());
args.med.med_setname = Strdup(sp->setname);
args.med.med_setno = sp->setno;
args.med_data = *meddp;
/* do it */
if ((hp = open_medd_wrap(mdhp, CL_DEF_TMO, ep)) == NULL)
return (-1);
if (med_upd_data_1(&args, &res, hp->clntp) != RPC_SUCCESS)
(void) mdrpcerror(ep, hp->clntp, hp->hostname,
dgettext(TEXT_DOMAIN, "medd update data"));
else
(void) meddstealerror(ep, &res);
close_medd(hp);
xdr_free(xdr_med_upd_data_args_t, (char *)&args);
xdr_free(xdr_med_err_t, (char *)&res);
if (! mdisok(ep))
return (-1);
return (0);
}
/*
* Get the mediator data for this client from the mediator
*/
int
clnt_med_get_data(
md_h_t *mdhp,
mdsetname_t *sp,
med_data_t *meddp,
md_error_t *ep
)
{
med_handle_t *hp;
med_args_t args;
med_get_data_res_t res;
int rval = -1;
md_set_desc *sd;
/* initialize */
mdclrerror(ep);
(void) memset(&args, 0, sizeof (args));
(void) memset(&res, 0, sizeof (res));
/* build args */
if ((sd = metaget_setdesc(sp, ep)) == NULL)
return (-1);
if (MD_MNSET_DESC(sd))
/*
* In the MN diskset, use a generic nodename, multiowner, as
* the node initiating the RPC request. This allows
* any node to access mediator information.
*
* MN diskset reconfig cycle forces consistent
* view of set/node/drive/mediator information across all nodes
* in the MN diskset. This allows the relaxation of
* node name checking in rpc.metamedd for MN disksets.
*
* In the traditional diskset, only a calling node that is
* in the mediator record's diskset nodelist can access
* mediator data.
*/
args.med.med_caller = Strdup(MED_MN_CALLER);
else
args.med.med_caller = Strdup(mynode());
args.med.med_setname = Strdup(sp->setname);
args.med.med_setno = sp->setno;
/* do it */
if ((hp = open_medd_wrap(mdhp, CL_DEF_TMO, ep)) == NULL)
return (-1);
if (med_get_data_1(&args, &res, hp->clntp) != RPC_SUCCESS)
(void) mdrpcerror(ep, hp->clntp, hp->hostname,
dgettext(TEXT_DOMAIN, "medd get data"));
else
(void) meddstealerror(ep, &res.med_status);
close_medd(hp);
if (mdisok(ep)) {
/* do something with the results */
(void) memmove(meddp, &res.med_data, sizeof (med_data_t));
rval = 0;
}
xdr_free(xdr_med_args_t, (char *)&args);
xdr_free(xdr_med_get_data_res_t, (char *)&res);
return (rval);
}
/*
* Update the mediator record on the mediator.
*/
int
clnt_med_upd_rec(
md_h_t *mdhp,
mdsetname_t *sp,
med_rec_t *medrp,
md_error_t *ep
)
{
med_handle_t *hp;
med_upd_rec_args_t args;
med_err_t res;
md_set_desc *sd;
/* initialize */
mdclrerror(ep);
(void) memset(&args, 0, sizeof (args));
(void) memset(&res, 0, sizeof (res));
/* build args */
if ((sd = metaget_setdesc(sp, ep)) == NULL)
return (-1);
if (MD_MNSET_DESC(sd))
/*
* In the MN diskset, use a generic nodename, multiowner, as
* the node initiating the RPC request. This allows
* any node to access mediator information.
*
* MN diskset reconfig cycle forces consistent
* view of set/node/drive/mediator information across all nodes
* in the MN diskset. This allows the relaxation of
* node name checking in rpc.metamedd for MN disksets.
*
* In the traditional diskset, only a calling node that is
* in the mediator record's diskset nodelist can access
* mediator data.
*/
args.med.med_caller = Strdup(MED_MN_CALLER);
else
args.med.med_caller = Strdup(mynode());
args.med.med_setname = Strdup(sp->setname);
args.med.med_setno = sp->setno;
args.med_flags = 0;
args.med_rec = *medrp; /* structure assignment */
/* do it */
if ((hp = open_medd_wrap(mdhp, CL_DEF_TMO, ep)) == NULL)
return (-1);
if (med_upd_rec_1(&args, &res, hp->clntp) != RPC_SUCCESS)
(void) mdrpcerror(ep, hp->clntp, hp->hostname,
dgettext(TEXT_DOMAIN, "medd update record"));
else
(void) meddstealerror(ep, &res);
close_medd(hp);
xdr_free(xdr_med_upd_rec_args_t, (char *)&args);
xdr_free(xdr_med_err_t, (char *)&res);
if (! mdisok(ep))
return (-1);
return (0);
}
/*
* Get the mediator record for this client from the mediator
*/
int
clnt_med_get_rec(
md_h_t *mdhp,
mdsetname_t *sp,
med_rec_t *medrp,
md_error_t *ep
)
{
med_handle_t *hp;
med_args_t args;
med_get_rec_res_t res;
int rval = -1;
md_set_desc *sd;
/* initialize */
mdclrerror(ep);
(void) memset(&args, 0, sizeof (args));
(void) memset(&res, 0, sizeof (res));
/* build args */
if ((sd = metaget_setdesc(sp, ep)) == NULL)
return (-1);
if (MD_MNSET_DESC(sd))
/*
* In the MN diskset, use a generic nodename, multiowner, as
* the node initiating the RPC request. This allows
* any node to access mediator information.
*
* MN diskset reconfig cycle forces consistent
* view of set/node/drive/mediator information across all nodes
* in the MN diskset. This allows the relaxation of
* node name checking in rpc.metamedd for MN disksets.
*
* In the traditional diskset, only a calling node that is
* in the mediator record's diskset nodelist can access
* mediator data.
*/
args.med.med_caller = Strdup(MED_MN_CALLER);
else
args.med.med_caller = Strdup(mynode());
args.med.med_setname = Strdup(sp->setname);
args.med.med_setno = sp->setno;
/* do it */
if ((hp = open_medd_wrap(mdhp, CL_DEF_TMO, ep)) == NULL)
return (-1);
if (med_get_rec_1(&args, &res, hp->clntp) != RPC_SUCCESS)
(void) mdrpcerror(ep, hp->clntp, hp->hostname,
dgettext(TEXT_DOMAIN, "medd get record"));
else
(void) meddstealerror(ep, &res.med_status);
close_medd(hp);
if (mdisok(ep)) {
/* do something with the results */
(void) memmove(medrp, &res.med_rec, sizeof (med_rec_t));
rval = 0;
}
xdr_free(xdr_med_args_t, (char *)&args);
xdr_free(xdr_med_get_rec_res_t, (char *)&res);
return (rval);
}
/*
* Get the name of the host from the mediator daemon.
*/
int
clnt_med_hostname(
char *hostname,
char **ret_hostname,
md_error_t *ep
)
{
med_handle_t *hp;
med_hnm_res_t res;
int rval = -1;
/* initialize */
mdclrerror(ep);
(void) memset(&res, 0, sizeof (res));
/* No args */
/* do it */
if ((hp = open_medd(hostname, CL_DEF_TMO, ep)) == NULL)
return (-1);
if (med_hostname_1(NULL, &res, hp->clntp) != RPC_SUCCESS)
(void) mdrpcerror(ep, hp->clntp, hostname,
dgettext(TEXT_DOMAIN, "medd hostname"));
else
(void) meddstealerror(ep, &res.med_status);
close_medd(hp);
if (mdisok(ep)) {
/* do something with the results */
rval = 0;
if (ret_hostname != NULL)
*ret_hostname = Strdup(res.med_hnm);
}
xdr_free(xdr_med_hnm_res_t, (char *)&res);
return (rval);
}
int
meta_med_hnm2ip(md_hi_arr_t *mp, md_error_t *ep)
{
int i, j;
int max_meds;
if ((max_meds = get_max_meds(ep)) == 0)
return (-1);
for (i = 0; i < max_meds; i++) {
mp->n_lst[i].a_flg = 0;
/* See if this is the local host */
if (mp->n_lst[i].a_cnt > 0 &&
strcmp(mp->n_lst[i].a_nm[0], mynode()) == NULL)
mp->n_lst[i].a_flg |= NMIP_F_LOCAL;
for (j = 0; j < mp->n_lst[i].a_cnt; j++) {
struct hostent *hp;
char *hnm = mp->n_lst[i].a_nm[j];
/*
* Cluster nodename support
*
* See if the clustering code can give us an IP addr
* for the stored name. If not, find it the old way
* which will use the public interface.
*/
if (sdssc_get_priv_ipaddr(mp->n_lst[i].a_nm[j],
(struct in_addr *)&mp->n_lst[i].a_ip[j]) !=
SDSSC_OKAY) {
if ((hp = gethostbyname(hnm)) == NULL)
return (mdsyserror(ep, EADDRNOTAVAIL,
hnm));
/* We only do INET addresses */
if (hp->h_addrtype != AF_INET)
return (mdsyserror(ep, EPFNOSUPPORT,
hnm));
/* We take the first address only */
if (*hp->h_addr_list) {
(void) memmove(&mp->n_lst[i].a_ip[j],
*hp->h_addr_list,
sizeof (struct in_addr));
} else
return (mdsyserror(ep, EADDRNOTAVAIL,
hnm));
}
}
}
return (0);
}
int
meta_h2hi(md_h_arr_t *mdhp, md_hi_arr_t *mdhip, md_error_t *ep)
{
int i, j;
int max_meds;
if ((max_meds = get_max_meds(ep)) == 0)
return (-1);
mdhip->n_cnt = mdhp->n_cnt;
for (i = 0; i < max_meds; i++) {
mdhip->n_lst[i].a_flg = 0;
mdhip->n_lst[i].a_cnt = mdhp->n_lst[i].a_cnt;
if (mdhp->n_lst[i].a_cnt == 0)
continue;
for (j = 0; j < mdhp->n_lst[i].a_cnt; j++)
(void) strcpy(mdhip->n_lst[i].a_nm[j],
mdhp->n_lst[i].a_nm[j]);
}
return (0);
}
int
meta_hi2h(md_hi_arr_t *mdhip, md_h_arr_t *mdhp, md_error_t *ep)
{
int i, j;
int max_meds;
if ((max_meds = get_max_meds(ep)) == 0)
return (-1);
mdhp->n_cnt = mdhip->n_cnt;
for (i = 0; i < max_meds; i++) {
mdhp->n_lst[i].a_cnt = mdhip->n_lst[i].a_cnt;
if (mdhip->n_lst[i].a_cnt == 0)
continue;
for (j = 0; j < mdhip->n_lst[i].a_cnt; j++)
(void) strcpy(mdhp->n_lst[i].a_nm[j],
mdhip->n_lst[i].a_nm[j]);
}
return (0);
}
int
setup_med_cfg(
mdsetname_t *sp,
mddb_config_t *cp,
int force,
md_error_t *ep
)
{
md_set_desc *sd;
int i;
int max_meds;
if (metaislocalset(sp))
return (0);
if ((sd = metaget_setdesc(sp, ep)) == NULL)
return (-1);
if (setup_med_transtab(ep))
return (-1);
if (meta_h2hi(&sd->sd_med, &cp->c_med, ep))
return (-1);
/* Make sure the ip addresses are current */
if (meta_med_hnm2ip(&cp->c_med, ep))
return (-1);
if (force)
return (0);
if ((max_meds = get_max_meds(ep)) == 0)
return (-1);
/* Make sure metamedd still running on host - only chk nodename */
for (i = 0; i < max_meds; i++) {
char *hostname;
char *hnm;
if (sd->sd_med.n_lst[i].a_cnt == 0)
continue;
hnm = sd->sd_med.n_lst[i].a_nm[0];
if (clnt_med_hostname(hnm, &hostname, ep))
return (mddserror(ep, MDE_DS_NOMEDONHOST, sp->setno,
hnm, NULL, sp->setname));
Free(hostname);
}
return (0);
}
/*
* This is a general routine to get mediator information from
* file /etc/lvm/meddb. Commands medstat and metainit use this
* routine to get mediator information from all mediator hosts or update
* its mediator record respectively.
*/
int
meta_mediator_info_from_file(char *sname, int verbose, md_error_t *ep)
{
uint_t c;
int i;
int j;
int fd;
int rec_size;
char *setname;
uint_t setnum;
med_rec_t *rec_buf = NULL;
med_db_hdr_t *dbhbr;
med_rec_t *medrecp;
med_data_t medd;
med_data_t save_medd;
md_h_t mdh;
uint_t latest_med_dat_cc = 0;
int retval = 0;
int medok = 0;
int golden = 0;
bool_t obandiskset;
int isSetFound = 0;
/* Open the meddb file */
if ((fd = open(MED_DB_FILE, O_RDONLY, 0)) == -1) {
/*
* During the start up of the SVM services, this function
* will be called with an empty sname. In that case it is
* entirely possible for the MED_DB_FILE not to exist.
* If so, then no need to report an error.
*/
if (sname != NULL) {
(void) mdsyserror(ep, errno, MED_DB_FILE);
mde_perror(ep, dgettext(TEXT_DOMAIN,
"Error in opening meddb file"));
return (1);
}
return (0);
}
/* Initialize rec_size */
rec_size = roundup(sizeof (med_rec_t), DEV_BSIZE);
/* Allocate a record buffer */
if ((rec_buf = malloc(rec_size)) == NULL) {
(void) mdsyserror(ep, errno, MED_DB_FILE);
mde_perror(ep, dgettext(TEXT_DOMAIN,
"Error in allocating memory"));
goto out;
}
/* read the file header */
if ((read(fd, rec_buf, rec_size)) != rec_size) {
(void) mdsyserror(ep, EINVAL, MED_DB_FILE);
mde_perror(ep, dgettext(TEXT_DOMAIN,
"Error in reading mediator record"));
goto out;
}
dbhbr = (med_db_hdr_t *)rec_buf;
/* Number of records in the mediator file */
c = dbhbr->med_dbh_nm;
for (i = 0; i < c; i++) {
(void) memset(rec_buf, 0, rec_size);
if (read(fd, rec_buf, rec_size) == -1) {
(void) mdsyserror(ep, errno, MED_DB_FILE);
mde_perror(ep, dgettext(TEXT_DOMAIN,
"Error in reading mediator record"));
goto out;
}
medrecp = (med_rec_t *)rec_buf;
/*
* For oban diskset first entry in the rec_nodes field is
* "multiowner" and all other entries are empty.
* Check if this is really multiowner diskset.
*/
if ((strcmp(medrecp->med_rec_nodes[0], MED_MN_CALLER) == 0) &&
(medrecp->med_rec_nodes[1][0] == '\0'))
obandiskset = TRUE;
else
obandiskset = FALSE;
if (sname != NULL) {
/*
* Continue if the set name is not in our interest.
* This is required when this routine is called
* from medstat
*/
if (strcmp(sname, medrecp->med_rec_snm) != 0) {
continue;
}
if (verbose)
(void) printf("%8.8s\t\t%6.6s\t%6.6s\n",
gettext("Mediator"), gettext("Status"),
gettext("Golden"));
isSetFound = 1;
setname = sname;
} else {
setname = medrecp->med_rec_snm;
}
setnum = medrecp->med_rec_sn;
(void) memset(&medd, '\0', sizeof (medd));
(void) memset(&mdh, '\0', sizeof (mdh));
(void) memset(&save_medd, '\0', sizeof (save_medd));
latest_med_dat_cc = 0;
for (j = 0; j < MED_MAX_HOSTS; j++) {
/*
* It is possible for the n_lst[j] slot to be empty
* if the mediator node has already been removed so
* go to the next slot.
*/
if (medrecp->med_rec_meds.n_lst[j].a_cnt == 0)
continue;
mdh = medrecp->med_rec_meds.n_lst[j];
if ((sname != NULL) && (verbose))
(void) printf("%-17.17s\t",
medrecp->med_rec_meds.n_lst[j].a_nm[0]);
if (clnt_user_med_get_data(&mdh, obandiskset,
setname, setnum, &medd, ep) == -1) {
if (sname == NULL) {
continue;
} else {
if (mdanyrpcerror(ep)) {
if (verbose)
(void) printf("%s\n",
gettext("Unreach"
"able"));
continue;
} else if (mdiserror(ep,
MDE_MED_ERROR)) {
if (verbose)
(void) printf("%s\n",
gettext("Bad"));
} else {
if (verbose)
(void) printf("%s\n",
gettext("Fatal"));
}
mde_perror(ep, "");
if (mdiserror(ep, MDE_MED_ERROR))
continue;
goto out;
}
} else {
/*
* Make sure this node has the correct value
* for the mediator record. If not we want the
* highest value from the other nodes. Save it
* for updating once the loop through all the
* mediator nodes has completed.
*/
if (sname == NULL) {
if (latest_med_dat_cc <
medd.med_dat_cc) {
latest_med_dat_cc =
medd.med_dat_cc;
(void) memcpy(&save_medd, &medd,
sizeof (medd));
}
} else {
if (verbose)
(void) printf("%s",
gettext("Ok"));
if (medd.med_dat_fl & MED_DFL_GOLDEN) {
if (verbose)
(void) printf("\t%s",
gettext("Yes"));
golden++;
} else {
if (verbose)
(void) printf("\t%s",
gettext("No"));
}
if (verbose)
(void) printf("\n");
medok++;
}
}
}
if (sname == NULL) {
/*
* Mediators only become active when there are
* replica updates to the sets and this can only
* occur when there is a disk in the set.
* If there are no disks found then the save_medd
* structure will be empty. If save_medd is empty,
* do not update the set.
*/
if (save_medd.med_dat_sn == 0)
continue;
/*
* Update the latest mediator information
* on this node
*/
(void) strlcpy(mdh.a_nm[0], mynode(),
sizeof (mdh.a_nm[0]));
mdh.a_cnt = 1;
if (clnt_user_med_upd_data(&mdh, obandiskset,
setname, setnum, &save_medd, ep) == -1) {
/*
* We had some errors while updaing the
* record. This means this metaset is
* not updated with latest mediator
* information.
*/
mde_perror(ep, "");
}
} else {
if (golden) {
retval = 0;
goto out;
}
if (medok < ((medrecp->med_rec_meds.n_cnt / 2) + 1))
retval = 1;
}
}
out:
if ((sname != NULL) && (isSetFound == 0)) {
(void) mderror(ep, MDE_NO_SET, sname);
mde_perror(ep, "");
retval = 1;
}
if (rec_buf != NULL)
Free(rec_buf);
if (close(fd) < 0) {
(void) mdsyserror(ep, errno, MED_DB_FILE);
mde_perror(ep, dgettext(TEXT_DOMAIN,
"Error in closing meddb file"));
return (1);
}
return (retval);
}