int
fmd_adm_module_stats(fmd_adm_t *ap, const char *name, fmd_adm_stats_t *sp)
{
struct fmd_rpc_modstat rms;
enum clnt_stat cs;
uint_t retries = 0;
if (name == NULL || sp == NULL)
return (fmd_adm_set_errno(ap, EINVAL));
bzero(&rms, sizeof (rms)); /* tell xdr to allocate memory for us */
do {
cs = fmd_adm_moddstat_1((char *)name, &rms, ap->adm_clnt);
} while (fmd_adm_retry(ap, cs, &retries));
if (cs != RPC_SUCCESS)
return (fmd_adm_set_errno(ap, EPROTO));
if (rms.rms_err != 0) {
xdr_free(xdr_fmd_rpc_modstat, (char *)&rms);
return (fmd_adm_set_svcerr(ap, rms.rms_err));
}
sp->ams_buf = rms.rms_buf.rms_buf_val;
sp->ams_len = rms.rms_buf.rms_buf_len;
return (0);
}
int
fmd_adm_rsrc_count(fmd_adm_t *ap, int all, uint32_t *rcp)
{
struct fmd_rpc_rsrclist rrl;
enum clnt_stat cs;
uint_t retries = 0;
if (rcp == NULL)
return (fmd_adm_set_errno(ap, EINVAL));
bzero(&rrl, sizeof (rrl)); /* tell xdr to allocate memory for us */
do {
cs = fmd_adm_rsrclist_1(all, &rrl, ap->adm_clnt);
} while (fmd_adm_retry(ap, cs, &retries));
if (cs != RPC_SUCCESS)
return (fmd_adm_set_errno(ap, EPROTO));
if (rrl.rrl_err != 0) {
xdr_free(xdr_fmd_rpc_rsrclist, (char *)&rrl);
return (fmd_adm_set_svcerr(ap, rrl.rrl_err));
}
*rcp = rrl.rrl_cnt;
xdr_free(xdr_fmd_rpc_rsrclist, (char *)&rrl);
return (0);
}
int
fmd_adm_module_iter(fmd_adm_t *ap, fmd_adm_module_f *func, void *arg)
{
struct fmd_rpc_modinfo *rmi, **rms, **rmp;
struct fmd_rpc_modlist rml;
fmd_adm_modinfo_t ami;
enum clnt_stat cs;
uint_t retries = 0;
bzero(&rml, sizeof (rml)); /* tell xdr to allocate memory for us */
do {
cs = fmd_adm_modinfo_1(&rml, ap->adm_clnt);
} while (fmd_adm_retry(ap, cs, &retries));
if (cs != RPC_SUCCESS)
return (fmd_adm_set_errno(ap, EPROTO));
if (rml.rml_err != 0 || rml.rml_len == 0) {
xdr_free(xdr_fmd_rpc_modlist, (char *)&rml);
return (fmd_adm_set_svcerr(ap, rml.rml_err));
}
if ((rms = rmp = malloc(sizeof (void *) * rml.rml_len)) == NULL) {
xdr_free(xdr_fmd_rpc_modlist, (char *)&rml);
return (fmd_adm_set_errno(ap, EAGAIN));
}
for (rmi = rml.rml_list; rmi != NULL; rmi = rmi->rmi_next)
*rmp++ = rmi; /* store copy of pointer in array for sorting */
qsort(rms, rml.rml_len, sizeof (void *), fmd_adm_module_cmp);
for (rmp = rms; rmp < rms + rml.rml_len; rmp++) {
rmi = *rmp;
ami.ami_name = rmi->rmi_name;
ami.ami_desc = rmi->rmi_desc;
ami.ami_vers = rmi->rmi_vers;
ami.ami_flags = 0;
if (rmi->rmi_faulty)
ami.ami_flags |= FMD_ADM_MOD_FAILED;
if (func(&ami, arg) != 0)
break;
}
free(rms);
xdr_free(xdr_fmd_rpc_modlist, (char *)&rml);
return (0);
}
int
fmd_adm_xprt_iter(fmd_adm_t *ap, fmd_adm_xprt_f *func, void *arg)
{
struct fmd_rpc_xprtlist rxl;
uint_t i;
enum clnt_stat cs;
uint_t retries = 0;
bzero(&rxl, sizeof (rxl)); /* tell xdr to allocate memory for us */
do {
cs = fmd_adm_xprtlist_1(&rxl, ap->adm_clnt);
} while (fmd_adm_retry(ap, cs, &retries));
if (cs != RPC_SUCCESS)
return (fmd_adm_set_errno(ap, EPROTO));
if (rxl.rxl_err != 0) {
xdr_free(xdr_fmd_rpc_xprtlist, (char *)&rxl);
return (fmd_adm_set_svcerr(ap, rxl.rxl_err));
}
for (i = 0; i < rxl.rxl_len; i++)
func(rxl.rxl_buf.rxl_buf_val[i], arg);
xdr_free(xdr_fmd_rpc_xprtlist, (char *)&rxl);
return (0);
}
/*
* Our approach to cases is the same as for resources: we first obtain a
* list of UUIDs, sort them, then obtain the case information for each.
*/
int
fmd_adm_case_iter(fmd_adm_t *ap,int type)
{
int ret = 0;
int num = 20;
int index = 0;
char cmd[32];
while ((num > 0 && index == 0) || num == 20){
sprintf(cmd,"GET CASELIST:%d:%d",FAF_NUM*index,type);
index++;
ret = fmd_adm_get_list(ap,cmd);
if (ret < 0)
return (fmd_adm_set_errno(ap, EPROTO));
num = fmd_adm_get_caseinfo(ap);
sleep(1);
if (num < 0)
return (-1);
}
return (0);
}
int
fmd_adm_log_rotate(fmd_adm_t *ap, const char *log)
{
int err;
enum clnt_stat cs;
uint_t retries = 0;
if (log == NULL)
return (fmd_adm_set_errno(ap, EINVAL));
do {
cs = fmd_adm_logrotate_1((char *)log, &err, ap->adm_clnt);
} while (fmd_adm_retry(ap, cs, &retries));
if (cs != RPC_SUCCESS)
return (fmd_adm_set_errno(ap, EPROTO));
return (fmd_adm_set_svcerr(ap, err));
}
int
fmd_adm_serd_reset(fmd_adm_t *ap, const char *mod, const char *name)
{
char *s1 = (char *)mod, *s2 = (char *)name;
int err;
enum clnt_stat cs;
uint_t retries = 0;
if (mod == NULL || name == NULL || strchr(mod, '/') != NULL)
return (fmd_adm_set_errno(ap, EINVAL));
do {
cs = fmd_adm_serdreset_1(s1, s2, &err, ap->adm_clnt);
} while (fmd_adm_retry(ap, cs, &retries));
if (cs != RPC_SUCCESS)
return (fmd_adm_set_errno(ap, EPROTO));
return (fmd_adm_set_svcerr(ap, err));
}
int
fmd_adm_case_acquit(fmd_adm_t *ap, const char *uuid)
{
char *str = (char *)uuid;
int err;
enum clnt_stat cs;
uint_t retries = 0;
if (uuid == NULL)
return (fmd_adm_set_errno(ap, EINVAL));
do {
cs = fmd_adm_caseacquit_1(str, &err, ap->adm_clnt);
} while (fmd_adm_retry(ap, cs, &retries));
if (cs != RPC_SUCCESS)
return (fmd_adm_set_errno(ap, EPROTO));
return (fmd_adm_set_svcerr(ap, err));
}
int
fmd_adm_module_gc(fmd_adm_t *ap, const char *name)
{
char *str = (char *)name;
int err;
enum clnt_stat cs;
uint_t retries = 0;
if (name == NULL || strchr(name, '/') != NULL)
return (fmd_adm_set_errno(ap, EINVAL));
do {
cs = fmd_adm_modgc_1(str, &err, ap->adm_clnt);
} while (fmd_adm_retry(ap, cs, &retries));
if (cs != RPC_SUCCESS)
return (fmd_adm_set_errno(ap, EPROTO));
return (fmd_adm_set_svcerr(ap, err));
}
int
fmd_adm_module_load(fmd_adm_t *ap, const char *path)
{
char *str = (char *)path;
int err;
enum clnt_stat cs;
uint_t retries = 0;
if (path == NULL || path[0] != '/')
return (fmd_adm_set_errno(ap, EINVAL));
do {
cs = fmd_adm_modload_1(str, &err, ap->adm_clnt);
} while (fmd_adm_retry(ap, cs, &retries));
if (cs != RPC_SUCCESS)
return (fmd_adm_set_errno(ap, EPROTO));
return (fmd_adm_set_svcerr(ap, err));
}
int
fmd_adm_rsrc_replaced(fmd_adm_t *ap, const char *fmri)
{
char *str = (char *)fmri;
int err;
enum clnt_stat cs;
uint_t retries = 0;
if (fmri == NULL)
return (fmd_adm_set_errno(ap, EINVAL));
do {
cs = fmd_adm_rsrcreplaced_1(str, &err, ap->adm_clnt);
} while (fmd_adm_retry(ap, cs, &retries));
if (cs != RPC_SUCCESS)
return (fmd_adm_set_errno(ap, EPROTO));
return (fmd_adm_set_svcerr(ap, err));
}
int
fmd_adm_mod_iter(fmd_adm_t *ap)
{
int ret = 0;
char cmd[] = "GET MODLIST";
ret = fmd_adm_get_list(ap,cmd);
if (ret != 0)
return (fmd_adm_set_errno(ap, EPROTO));
if (fmd_adm_get_modinfo(ap) != 0)
return (-1);
return (0);
}
int
fmd_adm_stats_free(fmd_adm_t *ap, fmd_adm_stats_t *sp)
{
struct fmd_rpc_modstat rms;
if (sp == NULL)
return (fmd_adm_set_errno(ap, EINVAL));
rms.rms_buf.rms_buf_val = sp->ams_buf;
rms.rms_buf.rms_buf_len = sp->ams_len;
rms.rms_err = 0;
xdr_free(xdr_fmd_rpc_modstat, (char *)&rms);
bzero(sp, sizeof (fmd_adm_stats_t));
return (0);
}
int
fmd_adm_load_module(fmd_adm_t *ap ,char *path){
char cmd[128] = "LOAD:";
strcpy(cmd+5,path);
if((fmd_adm_get_list(ap,cmd)) != 0)
return (fmd_adm_set_errno(ap, EPROTO));
if(strstr((char*)ap->adm_buf,"LOAD:") != NULL){
return (-1);
}
printf("%s\n",(char*)ap->adm_buf);
if(strstr(ap->adm_buf,"failed") != 0){
printf("please view /var/log/fms/fms.log for load failed reason\n");
return (-1);
}
return 0;
}
int
fmd_adm_config_module(fmd_adm_t *ap ,char *module, char * mode){
char cmd[128];
sprintf(cmd,"CONFIG:%s:%s",module,mode);
if((fmd_adm_get_list(ap,cmd)) != 0)
return (fmd_adm_set_errno(ap, EPROTO));
if(strstr((char*)ap->adm_buf,"UNLOAD:") != NULL){
return (-1);
}
printf("%s\n",(char*)ap->adm_buf);
if(strstr(ap->adm_buf,"failed")!= 0){
printf("please view /var/log/fms/fms.log for unload failed reason\n");
return (-1);
}
return 0;
}
int
fmd_adm_serd_iter(fmd_adm_t *ap, const char *name,
fmd_adm_serd_f *func, void *arg)
{
struct fmd_rpc_serdlist rsl;
struct fmd_rpc_serdinfo rsi;
char **serds, *p;
fmd_adm_serdinfo_t asi;
enum clnt_stat cs;
uint_t retries = 0;
int i, rv;
bzero(&rsl, sizeof (rsl)); /* tell xdr to allocate memory for us */
do {
cs = fmd_adm_serdlist_1((char *)name, &rsl, ap->adm_clnt);
} while (fmd_adm_retry(ap, cs, &retries));
if (cs != RPC_SUCCESS)
return (fmd_adm_set_errno(ap, EPROTO));
if (rsl.rsl_err != 0 || rsl.rsl_len == 0) {
xdr_free(xdr_fmd_rpc_serdlist, (char *)&rsl);
return (fmd_adm_set_svcerr(ap, rsl.rsl_err));
}
if ((serds = malloc(sizeof (char *) * rsl.rsl_cnt)) == NULL) {
xdr_free(xdr_fmd_rpc_serdlist, (char *)&rsl);
return (fmd_adm_set_errno(ap, EAGAIN));
}
p = rsl.rsl_buf.rsl_buf_val;
for (i = 0; i < rsl.rsl_cnt; i++, p += strlen(p) + 1)
serds[i] = p;
qsort(serds, rsl.rsl_cnt, sizeof (char *), fmd_adm_serd_cmp);
for (i = 0; i < rsl.rsl_cnt; i++) {
bzero(&rsi, sizeof (rsi));
retries = 0;
do {
cs = fmd_adm_serdinfo_1((char *)name, serds[i], &rsi,
ap->adm_clnt);
} while (fmd_adm_retry(ap, cs, &retries));
if (cs != RPC_SUCCESS) {
free(serds);
xdr_free(xdr_fmd_rpc_serdlist, (char *)&rsl);
return (fmd_adm_set_errno(ap, EPROTO));
}
if (rsi.rsi_err != 0 && rsi.rsi_err != FMD_ADM_ERR_SERDSRCH) {
free(serds);
xdr_free(xdr_fmd_rpc_serdinfo, (char *)&rsi);
xdr_free(xdr_fmd_rpc_serdlist, (char *)&rsl);
return (fmd_adm_set_svcerr(ap, rsi.rsi_err));
}
if (rsi.rsi_err == FMD_ADM_ERR_SERDSRCH) {
xdr_free(xdr_fmd_rpc_serdinfo, (char *)&rsi);
continue;
}
bzero(&asi, sizeof (asi));
asi.asi_name = rsi.rsi_name;
asi.asi_delta = rsi.rsi_delta;
asi.asi_n = rsi.rsi_n;
asi.asi_t = rsi.rsi_t;
asi.asi_count = rsi.rsi_count;
asi.asi_flags = 0;
if (rsi.rsi_fired)
asi.asi_flags |= FMD_ADM_SERD_FIRED;
rv = func(&asi, arg);
xdr_free(xdr_fmd_rpc_serdinfo, (char *)&rsi);
if (rv != 0)
break;
}
free(serds);
xdr_free(xdr_fmd_rpc_serdlist, (char *)&rsl);
return (0);
}
/*
* Our approach to cases is the same as for resources: we first obtain a
* list of UUIDs, sort them, then obtain the case information for each.
*/
int
fmd_adm_case_iter(fmd_adm_t *ap, const char *url_token, fmd_adm_case_f *func,
void *arg)
{
struct fmd_rpc_caselist rcl;
struct fmd_rpc_caseinfo rci;
fmd_adm_caseinfo_t aci;
char **uuids, *p;
int i, rv;
enum clnt_stat cs;
uint_t retries = 0;
bzero(&rcl, sizeof (rcl)); /* tell xdr to allocate memory for us */
do {
cs = fmd_adm_caselist_1(&rcl, ap->adm_clnt);
} while (fmd_adm_retry(ap, cs, &retries));
if (cs != RPC_SUCCESS)
return (fmd_adm_set_errno(ap, EPROTO));
if (rcl.rcl_err != 0) {
xdr_free(xdr_fmd_rpc_caselist, (char *)&rcl);
return (fmd_adm_set_svcerr(ap, rcl.rcl_err));
}
if ((uuids = malloc(sizeof (char *) * rcl.rcl_cnt)) == NULL) {
xdr_free(xdr_fmd_rpc_caselist, (char *)&rcl);
return (fmd_adm_set_errno(ap, EAGAIN));
}
p = rcl.rcl_buf.rcl_buf_val;
for (i = 0; i < rcl.rcl_cnt; i++, p += strlen(p) + 1)
uuids[i] = p;
qsort(uuids, rcl.rcl_cnt, sizeof (char *), fmd_adm_case_cmp);
for (i = 0; i < rcl.rcl_cnt; i++) {
bzero(&rci, sizeof (rci));
retries = 0;
do {
cs = fmd_adm_caseinfo_1(uuids[i], &rci, ap->adm_clnt);
} while (fmd_adm_retry(ap, cs, &retries));
if (cs != RPC_SUCCESS) {
free(uuids);
xdr_free(xdr_fmd_rpc_caselist, (char *)&rcl);
return (fmd_adm_set_errno(ap, EPROTO));
}
if (rci.rci_err != 0 && rci.rci_err != FMD_ADM_ERR_CASESRCH) {
xdr_free(xdr_fmd_rpc_caseinfo, (char *)&rci);
free(uuids);
xdr_free(xdr_fmd_rpc_caselist, (char *)&rcl);
return (fmd_adm_set_svcerr(ap, rci.rci_err));
}
if (rci.rci_err == FMD_ADM_ERR_CASESRCH) {
xdr_free(xdr_fmd_rpc_caseinfo, (char *)&rci);
continue;
}
bzero(&aci, sizeof (aci));
if ((rv = nvlist_unpack(rci.rci_evbuf.rci_evbuf_val,
rci.rci_evbuf.rci_evbuf_len, &aci.aci_event, 0)) != 0) {
xdr_free(xdr_fmd_rpc_caseinfo, (char *)&rci);
free(uuids);
xdr_free(xdr_fmd_rpc_caselist, (char *)&rcl);
return (fmd_adm_set_errno(ap, rv));
}
if ((rv = nvlist_lookup_string(aci.aci_event, FM_SUSPECT_UUID,
(char **)&aci.aci_uuid)) != 0) {
xdr_free(xdr_fmd_rpc_caseinfo, (char *)&rci);
free(uuids);
xdr_free(xdr_fmd_rpc_caselist, (char *)&rcl);
nvlist_free(aci.aci_event);
return (fmd_adm_set_errno(ap, rv));
}
if ((rv = nvlist_lookup_string(aci.aci_event,
FM_SUSPECT_DIAG_CODE, (char **)&aci.aci_code)) != 0) {
xdr_free(xdr_fmd_rpc_caseinfo, (char *)&rci);
free(uuids);
xdr_free(xdr_fmd_rpc_caselist, (char *)&rcl);
nvlist_free(aci.aci_event);
return (fmd_adm_set_errno(ap, rv));
}
rv = fmd_adm_case_one(&aci, url_token, func, arg);
xdr_free(xdr_fmd_rpc_caseinfo, (char *)&rci);
nvlist_free(aci.aci_event);
if (rv != 0)
break;
}
free(uuids);
xdr_free(xdr_fmd_rpc_caselist, (char *)&rcl);
return (0);
}
int
fmd_adm_rsrc_iter(fmd_adm_t *ap, int all, fmd_adm_rsrc_f *func, void *arg)
{
struct fmd_rpc_rsrclist rrl;
struct fmd_rpc_rsrcinfo rri;
fmd_adm_rsrcinfo_t ari;
char **fmris, *p;
int i, rv;
enum clnt_stat cs;
uint_t retries = 0;
bzero(&rrl, sizeof (rrl)); /* tell xdr to allocate memory for us */
do {
cs = fmd_adm_rsrclist_1(all, &rrl, ap->adm_clnt);
} while (fmd_adm_retry(ap, cs, &retries));
if (cs != RPC_SUCCESS)
return (fmd_adm_set_errno(ap, EPROTO));
if (rrl.rrl_err != 0) {
xdr_free(xdr_fmd_rpc_rsrclist, (char *)&rrl);
return (fmd_adm_set_svcerr(ap, rrl.rrl_err));
}
if ((fmris = malloc(sizeof (char *) * rrl.rrl_cnt)) == NULL) {
xdr_free(xdr_fmd_rpc_rsrclist, (char *)&rrl);
return (fmd_adm_set_errno(ap, EAGAIN));
}
/*
* The fmd_adm_rsrclist_1 request returns an opaque XDR buffer that is
* a string table of FMRIs (e.g. "fmriA\0fmriB\0...") where rrl_cnt is
* the number of strings in the table and rrl_buf_val is its address.
* We construct an array of pointers into the string table and sort it.
*/
p = rrl.rrl_buf.rrl_buf_val;
for (i = 0; i < rrl.rrl_cnt; i++, p += strlen(p) + 1)
fmris[i] = p; /* store fmri pointer in array for sorting */
qsort(fmris, rrl.rrl_cnt, sizeof (char *), fmd_adm_rsrc_cmp);
/*
* For each FMRI in the resource cache snapshot, use fmd_adm_rsrcinfo_1
* to get more information and the invoke the callback function. If
* FMD_ADM_ERR_RSRCSRCH is returned, the FMRI has been purged from the
* cache since our snapshot: this error is therefore silently ignored.
*/
for (i = 0; i < rrl.rrl_cnt; i++) {
bzero(&rri, sizeof (rri));
retries = 0;
do {
cs = fmd_adm_rsrcinfo_1(fmris[i], &rri, ap->adm_clnt);
} while (fmd_adm_retry(ap, cs, &retries));
if (cs != RPC_SUCCESS) {
free(fmris);
xdr_free(xdr_fmd_rpc_rsrclist, (char *)&rrl);
return (fmd_adm_set_errno(ap, EPROTO));
}
if (rri.rri_err != 0 && rri.rri_err != FMD_ADM_ERR_RSRCSRCH) {
xdr_free(xdr_fmd_rpc_rsrcinfo, (char *)&rri);
free(fmris);
xdr_free(xdr_fmd_rpc_rsrclist, (char *)&rrl);
return (fmd_adm_set_svcerr(ap, rri.rri_err));
}
if (rri.rri_err == FMD_ADM_ERR_RSRCSRCH) {
xdr_free(xdr_fmd_rpc_rsrcinfo, (char *)&rri);
continue;
}
ari.ari_fmri = rri.rri_fmri;
ari.ari_uuid = rri.rri_uuid;
ari.ari_case = rri.rri_case;
ari.ari_flags = 0;
if (rri.rri_faulty)
ari.ari_flags |= FMD_ADM_RSRC_FAULTY;
if (rri.rri_unusable)
ari.ari_flags |= FMD_ADM_RSRC_UNUSABLE;
if (rri.rri_invisible)
ari.ari_flags |= FMD_ADM_RSRC_INVISIBLE;
rv = func(&ari, arg);
xdr_free(xdr_fmd_rpc_rsrcinfo, (char *)&rri);
if (rv != 0)
break;
}
free(fmris);
xdr_free(xdr_fmd_rpc_rsrclist, (char *)&rrl);
return (0);
}
