/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2009 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #include <pthread.h> #include <unistd.h> #include <signal.h> #include <inttypes.h> #include <alloca.h> #include <strings.h> #include <stdlib.h> #include <stdio.h> #include <fmd_conf.h> #include <fmd_alloc.h> #include <fmd_error.h> #include <fmd_subr.h> #include <fmd_string.h> #include <fmd.h> const char FMD_PROP_SUBSCRIPTIONS[] = "_subscriptions"; const char FMD_PROP_DICTIONARIES[] = "_dictionaries"; /* * The property formals defined in _fmd_conf_defv[] are added to every config * dictionary that is created. Here we define several special FMD_PROP_* * properties that are used to implement the config file keyword actions, as * well as properties that should be inherited by fmd_conf_t's from fmd.d_conf. */ static const fmd_conf_formal_t _fmd_conf_defv[] = { { FMD_PROP_SUBSCRIPTIONS, &fmd_conf_list, "" }, { FMD_PROP_DICTIONARIES, &fmd_conf_list, "" }, { "fmd.isaname", &fmd_conf_parent, "isaname" }, { "fmd.machine", &fmd_conf_parent, "machine" }, { "fmd.platform", &fmd_conf_parent, "platform" }, { "fmd.rootdir", &fmd_conf_parent, "rootdir" }, }; static const int _fmd_conf_defc = sizeof (_fmd_conf_defv) / sizeof (_fmd_conf_defv[0]); static int set_bool(fmd_conf_param_t *pp, const char *s) { if (strcasecmp(s, "true") == 0) pp->cp_value.cpv_num = 1; else if (strcasecmp(s, "false") == 0) pp->cp_value.cpv_num = 0; else return (fmd_set_errno(EFMD_CONF_INVAL)); return (0); } static void get_bool(const fmd_conf_param_t *pp, void *ptr) { *((int *)ptr) = (int)pp->cp_value.cpv_num; } static int set_i32x(fmd_conf_param_t *pp, const char *s, int64_t min, int64_t max) { int64_t val; char *end; errno = 0; val = strtoll(s, &end, 0); if (errno == EOVERFLOW || val < min || val > max) return (fmd_set_errno(EFMD_CONF_OVERFLOW)); if (errno != 0 || end == s || *end != '\0') return (fmd_set_errno(EFMD_CONF_INVAL)); pp->cp_value.cpv_num = val; return (0); } static int set_i8(fmd_conf_param_t *pp, const char *s) { return (set_i32x(pp, s, INT8_MIN, INT8_MAX)); } static int set_i16(fmd_conf_param_t *pp, const char *s) { return (set_i32x(pp, s, INT16_MIN, INT16_MAX)); } static int set_i32(fmd_conf_param_t *pp, const char *s) { return (set_i32x(pp, s, INT32_MIN, INT32_MAX)); } static void get_i32(const fmd_conf_param_t *pp, void *ptr) { *((int32_t *)ptr) = (int32_t)pp->cp_value.cpv_num; } static int set_ui32x(fmd_conf_param_t *pp, const char *s, uint64_t max) { uint64_t val; char *end; errno = 0; val = strtoull(s, &end, 0); if (errno == EOVERFLOW || val > max) return (fmd_set_errno(EFMD_CONF_OVERFLOW)); if (errno != 0 || end == s || *end != '\0') return (fmd_set_errno(EFMD_CONF_INVAL)); pp->cp_value.cpv_num = val; return (0); } static int set_ui8(fmd_conf_param_t *pp, const char *s) { return (set_ui32x(pp, s, UINT8_MAX)); } static int set_ui16(fmd_conf_param_t *pp, const char *s) { return (set_ui32x(pp, s, UINT16_MAX)); } static int set_ui32(fmd_conf_param_t *pp, const char *s) { return (set_ui32x(pp, s, UINT32_MAX)); } static void get_ui32(const fmd_conf_param_t *pp, void *ptr) { *((uint32_t *)ptr) = (uint32_t)pp->cp_value.cpv_num; } static int set_i64(fmd_conf_param_t *pp, const char *s) { int64_t val; char *end; errno = 0; val = strtoll(s, &end, 0); if (errno == EOVERFLOW) return (fmd_set_errno(EFMD_CONF_OVERFLOW)); if (errno != 0 || end == s || *end != '\0') return (fmd_set_errno(EFMD_CONF_INVAL)); pp->cp_value.cpv_num = val; return (0); } static void get_i64(const fmd_conf_param_t *pp, void *ptr) { *((int64_t *)ptr) = (int64_t)pp->cp_value.cpv_num; } static int set_ui64(fmd_conf_param_t *pp, const char *s) { uint64_t val; char *end; errno = 0; val = strtoull(s, &end, 0); if (errno == EOVERFLOW) return (fmd_set_errno(EFMD_CONF_OVERFLOW)); if (errno != 0 || end == s || *end != '\0') return (fmd_set_errno(EFMD_CONF_INVAL)); pp->cp_value.cpv_num = val; return (0); } static void get_ui64(const fmd_conf_param_t *pp, void *ptr) { *((uint64_t *)ptr) = pp->cp_value.cpv_num; } static int set_str(fmd_conf_param_t *pp, const char *s) { fmd_strfree(pp->cp_value.cpv_str); pp->cp_value.cpv_str = fmd_strdup(s, FMD_SLEEP); return (0); } static void get_str(const fmd_conf_param_t *pp, void *ptr) { *((const char **)ptr) = pp->cp_value.cpv_str; } static void free_str(fmd_conf_param_t *pp) { fmd_strfree(pp->cp_value.cpv_str); pp->cp_value.cpv_str = NULL; } static int set_path(fmd_conf_param_t *pp, const char *value) { size_t len = strlen(value); char *s = alloca(len + 1); char **patv = alloca(sizeof (char *) * len / 2); int patc = 0; static const char *const percent_sign = "%"; char *p, *q; int c, i; static const struct fmd_conf_token { char tok_tag; const char *const *tok_val; } tokens[] = { { 'i', &fmd.d_platform }, { 'm', &fmd.d_machine }, { 'p', &fmd.d_isaname }, { 'r', &fmd.d_rootdir }, { '%', &percent_sign }, { 0, NULL } }; const struct fmd_conf_token *tok; fmd_conf_path_t *pap; pp->cp_formal->cf_ops->co_free(pp); (void) strcpy(s, value); for (p = strtok_r(s, ":", &q); p != NULL; p = strtok_r(NULL, ":", &q)) patv[patc++] = p; pap = fmd_alloc(sizeof (fmd_conf_path_t), FMD_SLEEP); pap->cpa_argv = fmd_alloc(sizeof (char *) * patc, FMD_SLEEP); pap->cpa_argc = patc; for (i = 0; i < patc; i++) { for (len = 0, p = patv[i]; (c = *p) != '\0'; p++, len++) { if (c != '%' || (c = p[1]) == '\0') continue; for (tok = tokens; tok->tok_tag != 0; tok++) { if (c == tok->tok_tag) { len += strlen(*tok->tok_val) - 1; p++; break; } } } pap->cpa_argv[i] = q = fmd_alloc(len + 1, FMD_SLEEP); q[len] = '\0'; for (p = patv[i]; (c = *p) != '\0'; p++) { if (c != '%' || (c = p[1]) == '\0') { *q++ = c; continue; } for (tok = tokens; tok->tok_tag != 0; tok++) { if (c == tok->tok_tag) { (void) strcpy(q, *tok->tok_val); q += strlen(q); p++; break; } } if (tok->tok_tag == 0) *q++ = c; } } pp->cp_value.cpv_ptr = pap; return (0); } static int set_lst(fmd_conf_param_t *pp, const char *value) { fmd_conf_path_t *old; old = pp->cp_value.cpv_ptr; pp->cp_value.cpv_ptr = NULL; if (set_path(pp, value) != 0) { pp->cp_value.cpv_ptr = old; return (-1); /* errno is set for us */ } if (old != NULL) { fmd_conf_path_t *new = pp->cp_value.cpv_ptr; int i, totc = old->cpa_argc + new->cpa_argc; int new_argc = new->cpa_argc; const char **new_argv = new->cpa_argv; new->cpa_argc = 0; new->cpa_argv = fmd_alloc(sizeof (char *) * totc, FMD_SLEEP); for (i = 0; i < old->cpa_argc; i++) new->cpa_argv[new->cpa_argc++] = old->cpa_argv[i]; for (i = 0; i < new_argc; i++) new->cpa_argv[new->cpa_argc++] = new_argv[i]; ASSERT(new->cpa_argc == totc); fmd_free(new_argv, sizeof (char *) * new_argc); fmd_free(old->cpa_argv, sizeof (char *) * old->cpa_argc); fmd_free(old, sizeof (fmd_conf_path_t)); } return (0); } static int del_lst(fmd_conf_param_t *pp, const char *value) { fmd_conf_path_t *pap = pp->cp_value.cpv_ptr; const char **new_argv; int i, new_argc; for (i = 0; i < pap->cpa_argc; i++) { if (strcmp(pap->cpa_argv[i], value) == 0) break; } if (i == pap->cpa_argc) return (fmd_set_errno(ENOENT)); fmd_strfree((char *)pap->cpa_argv[i]); pap->cpa_argv[i] = NULL; new_argc = 0; new_argv = fmd_alloc(sizeof (char *) * (pap->cpa_argc - 1), FMD_SLEEP); for (i = 0; i < pap->cpa_argc; i++) { if (pap->cpa_argv[i] != NULL) new_argv[new_argc++] = pap->cpa_argv[i]; } fmd_free(pap->cpa_argv, sizeof (char *) * pap->cpa_argc); pap->cpa_argv = new_argv; pap->cpa_argc = new_argc; return (0); } static void get_path(const fmd_conf_param_t *pp, void *ptr) { *((fmd_conf_path_t **)ptr) = (fmd_conf_path_t *)pp->cp_value.cpv_ptr; } static void free_path(fmd_conf_param_t *pp) { fmd_conf_path_t *pap = pp->cp_value.cpv_ptr; int i; if (pap == NULL) return; /* no value was ever set */ for (i = 0; i < pap->cpa_argc; i++) fmd_strfree((char *)pap->cpa_argv[i]); fmd_free(pap->cpa_argv, sizeof (char *) * pap->cpa_argc); fmd_free(pap, sizeof (fmd_conf_path_t)); pp->cp_value.cpv_ptr = NULL; } static int set_time(fmd_conf_param_t *pp, const char *s) { static const struct { const char *name; hrtime_t mul; } suffix[] = { { "ns", NANOSEC / NANOSEC }, { "nsec", NANOSEC / NANOSEC }, { "us", NANOSEC / MICROSEC }, { "usec", NANOSEC / MICROSEC }, { "ms", NANOSEC / MILLISEC }, { "msec", NANOSEC / MILLISEC }, { "s", NANOSEC / SEC }, { "sec", NANOSEC / SEC }, { "m", NANOSEC * (hrtime_t)60 }, { "min", NANOSEC * (hrtime_t)60 }, { "h", NANOSEC * (hrtime_t)(60 * 60) }, { "hour", NANOSEC * (hrtime_t)(60 * 60) }, { "d", NANOSEC * (hrtime_t)(24 * 60 * 60) }, { "day", NANOSEC * (hrtime_t)(24 * 60 * 60) }, { "hz", 0 }, { NULL } }; hrtime_t val, mul = 1; char *end; int i; errno = 0; val = strtoull(s, &end, 0); if (errno == EOVERFLOW) return (fmd_set_errno(EFMD_CONF_OVERFLOW)); if (errno != 0 || end == s) return (fmd_set_errno(EFMD_CONF_INVAL)); for (i = 0; suffix[i].name != NULL; i++) { if (strcasecmp(suffix[i].name, end) == 0) { mul = suffix[i].mul; break; } } if (suffix[i].name == NULL && *end != '\0') return (fmd_set_errno(EFMD_CONF_INVAL)); if (mul == 0) { if (val != 0) val = NANOSEC / val; /* compute val as value per sec */ } else val *= mul; pp->cp_value.cpv_num = val; return (0); } static int set_size(fmd_conf_param_t *pp, const char *s) { size_t len = strlen(s); uint64_t val, mul = 1; char *end; switch (s[len - 1]) { case 't': case 'T': mul *= 1024; /*FALLTHRU*/ case 'g': case 'G': mul *= 1024; /*FALLTHRU*/ case 'm': case 'M': mul *= 1024; /*FALLTHRU*/ case 'k': case 'K': mul *= 1024; /*FALLTHRU*/ default: break; } errno = 0; val = strtoull(s, &end, 0) * mul; if (errno == EOVERFLOW) return (fmd_set_errno(EFMD_CONF_OVERFLOW)); if ((mul != 1 && end != &s[len - 1]) || (mul == 1 && *end != '\0') || errno != 0) return (fmd_set_errno(EFMD_CONF_INVAL)); pp->cp_value.cpv_num = val; return (0); } static int set_sig(fmd_conf_param_t *pp, const char *s) { int sig; if (strncasecmp(s, "SIG", 3) == 0) s += 3; /* be friendlier than strsig() and permit the prefix */ if (str2sig(s, &sig) != 0) return (fmd_set_errno(EFMD_CONF_INVAL)); pp->cp_value.cpv_num = sig; return (0); } static void get_par(const fmd_conf_param_t *pp, void *ptr) { if (fmd_conf_getprop(fmd.d_conf, pp->cp_formal->cf_default, ptr) != 0) { fmd_panic("fmd.d_conf does not define '%s' (inherited as %s)\n", (char *)pp->cp_formal->cf_default, pp->cp_formal->cf_name); } } /*ARGSUSED*/ static int set_par(fmd_conf_param_t *pp, const char *s) { return (fmd_set_errno(EFMD_CONF_RDONLY)); } /* * Utility routine for callers who define custom ops where a list of string * tokens are translated into a bitmask. 'cmp' should be set to point to an * array of fmd_conf_mode_t's where the final element has cm_name == NULL. */ int fmd_conf_mode_set(const fmd_conf_mode_t *cma, fmd_conf_param_t *pp, const char *value) { const fmd_conf_mode_t *cmp; char *p, *q, *s = fmd_strdup(value, FMD_SLEEP); size_t len = value ? strlen(value) + 1 : 0; uint_t mode = 0; if (s == NULL) { pp->cp_value.cpv_num = 0; return (0); } for (p = strtok_r(s, ",", &q); p != NULL; p = strtok_r(NULL, ",", &q)) { for (cmp = cma; cmp->cm_name != NULL; cmp++) { if (strcmp(cmp->cm_name, p) == 0) { mode |= cmp->cm_bits; break; } } if (cmp->cm_name == NULL) { fmd_free(s, len); return (fmd_set_errno(EFMD_CONF_INVAL)); } } pp->cp_value.cpv_num = mode; fmd_free(s, len); return (0); } void fmd_conf_mode_get(const fmd_conf_param_t *pp, void *ptr) { *((uint_t *)ptr) = (uint_t)pp->cp_value.cpv_num; } /*ARGSUSED*/ int fmd_conf_notsup(fmd_conf_param_t *pp, const char *value) { return (fmd_set_errno(ENOTSUP)); } /*ARGSUSED*/ void fmd_conf_nop(fmd_conf_param_t *pp) { /* no free required for integer-type parameters */ } #define CONF_DEFINE(name, a, b, c, d) \ const fmd_conf_ops_t name = { a, b, c, d } CONF_DEFINE(fmd_conf_bool, set_bool, get_bool, fmd_conf_notsup, fmd_conf_nop); CONF_DEFINE(fmd_conf_int8, set_i8, get_i32, fmd_conf_notsup, fmd_conf_nop); CONF_DEFINE(fmd_conf_uint8, set_ui8, get_ui32, fmd_conf_notsup, fmd_conf_nop); CONF_DEFINE(fmd_conf_int16, set_i16, get_i32, fmd_conf_notsup, fmd_conf_nop); CONF_DEFINE(fmd_conf_uint16, set_ui16, get_ui32, fmd_conf_notsup, fmd_conf_nop); CONF_DEFINE(fmd_conf_int32, set_i32, get_i32, fmd_conf_notsup, fmd_conf_nop); CONF_DEFINE(fmd_conf_uint32, set_ui32, get_ui32, fmd_conf_notsup, fmd_conf_nop); CONF_DEFINE(fmd_conf_int64, set_i64, get_i64, fmd_conf_notsup, fmd_conf_nop); CONF_DEFINE(fmd_conf_uint64, set_ui64, get_ui64, fmd_conf_notsup, fmd_conf_nop); CONF_DEFINE(fmd_conf_string, set_str, get_str, fmd_conf_notsup, free_str); CONF_DEFINE(fmd_conf_path, set_path, get_path, fmd_conf_notsup, free_path); CONF_DEFINE(fmd_conf_list, set_lst, get_path, del_lst, free_path); CONF_DEFINE(fmd_conf_time, set_time, get_ui64, fmd_conf_notsup, fmd_conf_nop); CONF_DEFINE(fmd_conf_size, set_size, get_ui64, fmd_conf_notsup, fmd_conf_nop); CONF_DEFINE(fmd_conf_signal, set_sig, get_i32, fmd_conf_notsup, fmd_conf_nop); CONF_DEFINE(fmd_conf_parent, set_par, get_par, fmd_conf_notsup, fmd_conf_nop); static char * fmd_conf_skipstr(char *s) { int c; while ((c = *s) != '\0') { if (c == '\\') s++; else if (c == '"') break; s++; } return (s); } static char * fmd_conf_skipnws(char *s) { while (strchr("\f\n\r\t\v ", *s) == NULL) s++; return (s); } static int fmd_conf_tokenize(char *s, char *tokv[]) { int c, tokc = 0; while ((c = *s) != '\0') { switch (c) { case '"': tokv[tokc] = s + 1; s = fmd_conf_skipstr(s + 1); *s++ = '\0'; (void) fmd_stresc2chr(tokv[tokc++]); continue; case '\f': case '\n': case '\r': case '\t': case '\v': case ' ': s++; continue; default: tokv[tokc++] = s; s = fmd_conf_skipnws(s); *s++ = '\0'; } } return (tokc); } static int fmd_conf_exec_setprop(fmd_conf_t *cfp, int argc, char *argv[]) { if (argc != 2) return (fmd_set_errno(EFMD_CONF_USAGE)); return (fmd_conf_setprop(cfp, argv[0], argv[1])); } static int fmd_conf_exec_subscribe(fmd_conf_t *cfp, int argc, char *argv[]) { if (argc != 1) return (fmd_set_errno(EFMD_CONF_USAGE)); return (fmd_conf_setprop(cfp, FMD_PROP_SUBSCRIPTIONS, argv[0])); } static int fmd_conf_exec_dictionary(fmd_conf_t *cfp, int argc, char *argv[]) { if (argc != 1) return (fmd_set_errno(EFMD_CONF_USAGE)); return (fmd_conf_setprop(cfp, FMD_PROP_DICTIONARIES, argv[0])); } static int fmd_conf_parse(fmd_conf_t *cfp, const char *file) { static const fmd_conf_verb_t verbs[] = { { "setprop", fmd_conf_exec_setprop }, { "subscribe", fmd_conf_exec_subscribe }, { "dictionary", fmd_conf_exec_dictionary }, { NULL, NULL } }; int line, errs = 0; char buf[BUFSIZ]; FILE *fp; if ((fp = fopen(file, "r")) == NULL) { if (errno == EMFILE) fmd_error(EFMD_EXIT, "failed to open %s: %s\n", file, fmd_strerror(errno)); else fmd_error(EFMD_CONF_OPEN, "failed to open %s: %s\n", file, fmd_strerror(errno)); return (fmd_set_errno(EFMD_CONF_OPEN)); } for (line = 1; fgets(buf, sizeof (buf), fp) != NULL; line++) { char *tokv[sizeof (buf) / 2 + 1]; int tokc = fmd_conf_tokenize(buf, tokv); const fmd_conf_verb_t *vp; if (tokc == 0 || tokv[0][0] == '#') continue; /* skip blank lines and comment lines */ for (vp = verbs; vp->cv_name != NULL; vp++) { if (strcmp(tokv[0], vp->cv_name) == 0) break; } if (vp->cv_name == NULL) { fmd_error(EFMD_CONF_KEYWORD, "\"%s\", line %d: " "invalid configuration file keyword: %s\n", file, line, tokv[0]); errs++; continue; } if (vp->cv_exec(cfp, tokc - 1, tokv + 1) != 0) { fmd_error(errno, "\"%s\", line %d", file, line); errs++; continue; } } if (ferror(fp) != 0 || fclose(fp) != 0) return (fmd_set_errno(EFMD_CONF_IO)); if (errs != 0) return (fmd_set_errno(EFMD_CONF_ERRS)); return (0); } static void fmd_conf_fill(fmd_conf_t *cfp, fmd_conf_param_t *ppbuf, int argc, const fmd_conf_formal_t *argv, int checkid) { int i; for (i = 0; i < argc; i++, argv++) { fmd_conf_param_t *op, *pp = ppbuf + i; const char *name = argv->cf_name; ulong_t h = fmd_strhash(name) % cfp->cf_parhashlen; if (fmd_strbadid(name, checkid) != NULL) { fmd_error(EFMD_CONF_PROPNAME, "ignoring invalid formal " "property %s\n", name); continue; } for (op = cfp->cf_parhash[h]; op != NULL; op = op->cp_next) { if (strcmp(op->cp_formal->cf_name, name) == 0) { fmd_error(EFMD_CONF_PROPDUP, "ignoring " "duplicate formal property %s\n", name); break; } } if (op != NULL) continue; pp->cp_formal = argv; pp->cp_next = cfp->cf_parhash[h]; cfp->cf_parhash[h] = pp; if (argv->cf_default && argv->cf_ops != &fmd_conf_parent && fmd_conf_setprop(cfp, name, argv->cf_default) != 0) { fmd_error(EFMD_CONF_DEFAULT, "ignoring invalid default " "<%s> for property %s: %s\n", argv->cf_default, name, fmd_strerror(errno)); } } } fmd_conf_t * fmd_conf_open(const char *file, int argc, const fmd_conf_formal_t *argv, uint_t flag) { fmd_conf_t *cfp = fmd_alloc(sizeof (fmd_conf_t), FMD_SLEEP); (void) pthread_rwlock_init(&cfp->cf_lock, NULL); cfp->cf_argv = argv; cfp->cf_argc = argc; cfp->cf_flag = flag; cfp->cf_params = fmd_zalloc( sizeof (fmd_conf_param_t) * (_fmd_conf_defc + argc), FMD_SLEEP); cfp->cf_parhashlen = fmd.d_str_buckets; cfp->cf_parhash = fmd_zalloc( sizeof (fmd_conf_param_t *) * cfp->cf_parhashlen, FMD_SLEEP); cfp->cf_defer = NULL; fmd_conf_fill(cfp, cfp->cf_params, _fmd_conf_defc, _fmd_conf_defv, 0); fmd_conf_fill(cfp, cfp->cf_params + _fmd_conf_defc, argc, argv, 1); if (file != NULL && fmd_conf_parse(cfp, file) != 0) { fmd_conf_close(cfp); return (NULL); } return (cfp); } void fmd_conf_merge(fmd_conf_t *cfp, const char *file) { (void) fmd_conf_parse(cfp, file); } void fmd_conf_propagate(fmd_conf_t *src, fmd_conf_t *dst, const char *scope) { size_t len = strlen(scope); fmd_conf_defer_t *cdp; (void) pthread_rwlock_rdlock(&src->cf_lock); for (cdp = src->cf_defer; cdp != NULL; cdp = cdp->cd_next) { if (len == (size_t)(strchr(cdp->cd_name, ':') - cdp->cd_name) && strncmp(cdp->cd_name, scope, len) == 0 && fmd_conf_setprop( dst, cdp->cd_name + len + 1, cdp->cd_value) != 0) { fmd_error(EFMD_CONF_DEFER, "failed to apply deferred property %s to %s: %s\n", cdp->cd_name, scope, fmd_strerror(errno)); } } (void) pthread_rwlock_unlock(&src->cf_lock); } void fmd_conf_close(fmd_conf_t *cfp) { fmd_conf_param_t *pp = cfp->cf_params; int i, nparams = _fmd_conf_defc + cfp->cf_argc; fmd_conf_defer_t *cdp, *ndp; for (cdp = cfp->cf_defer; cdp != NULL; cdp = ndp) { ndp = cdp->cd_next; fmd_strfree(cdp->cd_name); fmd_strfree(cdp->cd_value); fmd_free(cdp, sizeof (fmd_conf_defer_t)); } fmd_free(cfp->cf_parhash, sizeof (fmd_conf_param_t *) * cfp->cf_parhashlen); for (i = 0; i < nparams; i++, pp++) { if (pp->cp_formal != NULL) pp->cp_formal->cf_ops->co_free(pp); } fmd_free(cfp->cf_params, sizeof (fmd_conf_param_t) * nparams); fmd_free(cfp, sizeof (fmd_conf_t)); } static fmd_conf_param_t * fmd_conf_getparam(fmd_conf_t *cfp, const char *name) { ulong_t h = fmd_strhash(name) % cfp->cf_parhashlen; fmd_conf_param_t *pp = cfp->cf_parhash[h]; ASSERT(RW_LOCK_HELD(&cfp->cf_lock)); for (; pp != NULL; pp = pp->cp_next) { if (strcmp(name, pp->cp_formal->cf_name) == 0) return (pp); } return (NULL); } /* * String-friendly version of fmd_conf_getprop(): return the string as our * return value, and return NULL if the string is the empty string. */ const char * fmd_conf_getnzstr(fmd_conf_t *cfp, const char *name) { const fmd_conf_param_t *pp; char *s = NULL; (void) pthread_rwlock_rdlock(&cfp->cf_lock); if ((pp = fmd_conf_getparam(cfp, name)) != NULL) { ASSERT(pp->cp_formal->cf_ops == &fmd_conf_string); pp->cp_formal->cf_ops->co_get(pp, &s); } else (void) fmd_set_errno(EFMD_CONF_NOPROP); (void) pthread_rwlock_unlock(&cfp->cf_lock); if (s != NULL && s[0] == '\0') { (void) fmd_set_errno(EFMD_CONF_UNDEF); s = NULL; } return (s); } const fmd_conf_ops_t * fmd_conf_gettype(fmd_conf_t *cfp, const char *name) { const fmd_conf_param_t *pp; const fmd_conf_ops_t *ops = NULL; (void) pthread_rwlock_rdlock(&cfp->cf_lock); if ((pp = fmd_conf_getparam(cfp, name)) != NULL) { if ((ops = pp->cp_formal->cf_ops) == &fmd_conf_parent) { ops = fmd_conf_gettype(fmd.d_conf, pp->cp_formal->cf_default); } } else (void) fmd_set_errno(EFMD_CONF_NOPROP); (void) pthread_rwlock_unlock(&cfp->cf_lock); return (ops); } int fmd_conf_getprop(fmd_conf_t *cfp, const char *name, void *data) { const fmd_conf_param_t *pp; int err = 0; (void) pthread_rwlock_rdlock(&cfp->cf_lock); if ((pp = fmd_conf_getparam(cfp, name)) != NULL) pp->cp_formal->cf_ops->co_get(pp, data); else err = fmd_set_errno(EFMD_CONF_NOPROP); (void) pthread_rwlock_unlock(&cfp->cf_lock); return (err); } static int fmd_conf_setdefer(fmd_conf_t *cfp, const char *name, const char *value) { fmd_conf_defer_t *cdp; if (!(cfp->cf_flag & FMD_CONF_DEFER)) return (fmd_set_errno(EFMD_CONF_NODEFER)); (void) pthread_rwlock_wrlock(&cfp->cf_lock); for (cdp = cfp->cf_defer; cdp != NULL; cdp = cdp->cd_next) { if (strcmp(name, cdp->cd_name) == 0) { fmd_strfree(cdp->cd_value); cdp->cd_value = fmd_strdup(value, FMD_SLEEP); goto out; } } cdp = fmd_alloc(sizeof (fmd_conf_defer_t), FMD_SLEEP); cdp->cd_name = fmd_strdup(name, FMD_SLEEP); cdp->cd_value = fmd_strdup(value, FMD_SLEEP); cdp->cd_next = cfp->cf_defer; cfp->cf_defer = cdp; out: (void) pthread_rwlock_unlock(&cfp->cf_lock); return (0); } int fmd_conf_setprop(fmd_conf_t *cfp, const char *name, const char *value) { fmd_conf_param_t *pp; int err; if (strchr(name, ':') != NULL) return (fmd_conf_setdefer(cfp, name, value)); (void) pthread_rwlock_wrlock(&cfp->cf_lock); if ((pp = fmd_conf_getparam(cfp, name)) != NULL) err = pp->cp_formal->cf_ops->co_set(pp, value); else err = fmd_set_errno(EFMD_CONF_NOPROP); (void) pthread_rwlock_unlock(&cfp->cf_lock); return (err); } int fmd_conf_delprop(fmd_conf_t *cfp, const char *name, const char *value) { fmd_conf_param_t *pp; int err; (void) pthread_rwlock_wrlock(&cfp->cf_lock); if ((pp = fmd_conf_getparam(cfp, name)) != NULL) err = pp->cp_formal->cf_ops->co_del(pp, value); else err = fmd_set_errno(EFMD_CONF_NOPROP); (void) pthread_rwlock_unlock(&cfp->cf_lock); return (err); }