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); }