usr/src/cmd/fm/modules/common/eversholt/eft.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25
  26 #include <unistd.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <fm/fmd_api.h>
  30 #include <libnvpair.h>
  31 #include <fm/libtopo.h>
  32 #include "out.h"
  33 #include "stats.h"
  34 #include "alloc.h"
  35 #include "stable.h"
  36 #include "literals.h"
  37 #include "lut.h"
  38 #include "esclex.h"
  39 #include "tree.h"
  40 #include "ipath.h"
  41 #include "itree.h"
  42 #include "iexpr.h"
  43 #include "ptree.h"
  44 #include "check.h"
  45 #include "version.h"
  46 #include "fme.h"
  47 #include "eval.h"
  48 #include "config.h"
  49 #include "platform.h"
  50
  51 /*
  52  * eversholt diagnosis engine (eft.so) main entry points
  53  */
  54
  55 fmd_hdl_t *Hdl;         /* handle in global for platform.c */
  56
  57 int Debug = 1;  /* turn on here and let fmd_hdl_debug() decide if really on */
  58 hrtime_t Hesitate;      /* hesitation time in ns */
  59 char *Serd_Override;    /* override for Serd engines */
  60 int Verbose;
  61 int Estats;
  62 int Warn;       /* zero -- eft.so should not issue language warnings */
  63 char **Efts;
  64 int Max_fme;            /* Maximum number of open FMEs */
  65
  66 /* stuff exported by yacc-generated parsers */
  67 extern void yyparse(void);
  68 extern int yydebug;
  69
  70 extern struct lut *Dicts;
  71
  72 extern void literals_init(void);
  73 extern void literals_fini(void);
  74
  75 struct eftsubr {
  76         const char *prefix;
  77         void (*hdlr)(fmd_hdl_t *, fmd_event_t *, nvlist_t *, const char *);
  78 } eftsubrs[] = {
  79         { "ereport.",           fme_receive_external_report },
  80         { "list.repaired",      fme_receive_repair_list },
  81         { NULL,                 NULL }
  82 };
  83
  84 /*ARGSUSED*/
  85 static void
  86 eft_recv(fmd_hdl_t *hdl, fmd_event_t *ep, nvlist_t *nvl, const char *class)
  87 {
  88         struct eftsubr *sp = eftsubrs;
  89
  90         while (sp->prefix != NULL) {
  91                 if (strncmp(class, sp->prefix, strlen(sp->prefix)) == 0)
  92                         break;
  93                 sp++;
  94         }
  95
  96         if (sp->prefix != NULL) {
  97                 (sp->hdlr)(hdl, ep, nvl, class);
  98         } else {
  99                 out(O_DIE,
 100                     "eft_recv: event class \"%s\" does not match our "
 101                     "subscriptions", class);
 102         }
 103 }
 104
 105 /*ARGSUSED*/
 106 static void
 107 eft_timeout(fmd_hdl_t *hdl, id_t tid, void *arg)
 108 {
 109         out(O_ALTFP|O_STAMP,
 110             "\neft.so timer %ld fired with arg %p", tid, arg);
 111
 112         if (arg == NULL)
 113                 return;
 114
 115         fme_timer_fired(arg, tid);
 116 }
 117
 118 static void
 119 eft_close(fmd_hdl_t *hdl, fmd_case_t *fmcase)
 120 {
 121         out(O_ALTFP, "eft_close called for case %s",
 122             fmd_case_uuid(hdl, fmcase));
 123         fme_close_case(hdl, fmcase);
 124 }
 125
 126 /*
 127  * The "serd_override" property allows the N and T parameters of specified serd
 128  * engines to be overridden. The property is a string consisting of one or more
 129  * space separated triplets. Each triplet is of the form "name,N,T" where "name"
 130  * is the name of the serd engine and N and T are the new paremeters to use.
 131  * For example "serd.io.device.nonfatal,5,3h" would set the parameters for the
 132  * serd.io.device.nonfatal engine to 5 in 3 hours.
 133  */
 134 static const fmd_prop_t eft_props[] = {
 135         { "estats", FMD_TYPE_BOOL, "false" },
 136         { "hesitate", FMD_TYPE_INT64, "10000000000" },
 137         { "serd_override", FMD_TYPE_STRING, NULL },
 138         { "verbose", FMD_TYPE_INT32, "0" },
 139         { "warn", FMD_TYPE_BOOL, "false" },
 140         { "status", FMD_TYPE_STRING, NULL },
 141         { "maxfme", FMD_TYPE_INT32, "0" },
 142         { NULL, 0, NULL }
 143 };
 144
 145 /*ARGSUSED*/
 146 static void
 147 eft_topo_change(fmd_hdl_t *hdl, topo_hdl_t *thp)
 148 {
 149         fme_receive_topology_change();
 150 }
 151
 152 static const fmd_hdl_ops_t eft_ops = {
 153         eft_recv,       /* fmdo_recv */
 154         eft_timeout,    /* fmdo_timeout */
 155         eft_close,      /* fmdo_close */
 156         NULL,           /* fmdo_stats */
 157         NULL,           /* fmdo_gc */
 158         NULL,           /* fmdo_send */
 159         eft_topo_change /* fmdo_topo_change */
 160 };
 161
 162 #define xstr(s) str(s)
 163 #define str(s) #s
 164
 165 static const fmd_hdl_info_t fmd_info = {
 166         "eft diagnosis engine",
 167         xstr(VERSION_MAJOR) "." xstr(VERSION_MINOR),
 168         &eft_ops, eft_props
 169 };
 170
 171 /*
 172  * ename_strdup -- like strdup but ename comes in and class string goes out
 173  */
 174 static char *
 175 ename_strdup(struct node *np)
 176 {
 177         struct node *mynp;
 178         int len;
 179         char *buf;
 180
 181         /* calculate length of buffer required */
 182         len = 0;
 183         for (mynp = np; mynp; mynp = mynp->u.name.next)
 184                 len += strlen(mynp->u.name.s) + 1;      /* +1 for dot or NULL */
 185
 186         buf = MALLOC(len);
 187         buf[0] = '\0';
 188
 189         /* now build the string */
 190         while (np) {
 191                 (void) strcat(buf, np->u.name.s);
 192                 np = np->u.name.next;
 193                 if (np)
 194                         (void) strcat(buf, ".");
 195         }
 196
 197         return (buf);
 198 }
 199
 200 /*ARGSUSED*/
 201 static void
 202 dosubscribe(struct node *lhs, struct node *rhs, void *arg)
 203 {
 204         char *ename = ename_strdup(lhs);
 205
 206         fmd_hdl_subscribe(Hdl, ename);
 207         FREE(ename);
 208 }
 209
 210 /*ARGSUSED*/
 211 static void
 212 dodiscardprint(struct node *lhs, struct node *rhs, void *arg)
 213 {
 214         char *ename = (char *)lhs;
 215
 216         out(O_VERB, "allow silent discard_if_config_unknown: \"%s\"", ename);
 217 }
 218
 219 extern struct stats *Filecount;
 220
 221 /*
 222  * Call all of the _fini() routines to clean up the exiting DE
 223  */
 224 void
 225 call_finis(void)
 226 {
 227         platform_free_eft_files(Efts);
 228         Efts = NULL;
 229         platform_fini();
 230         fme_fini();
 231         itree_fini();
 232         ipath_fini();
 233         iexpr_fini();
 234         istat_fini();
 235         serd_fini();
 236         lex_free();
 237         check_fini();
 238         tree_fini();
 239         lut_fini();
 240         literals_fini();
 241         stable_fini();
 242         stats_fini();
 243         out_fini();
 244         alloc_fini();
 245 }
 246
 247 /*ARGSUSED*/
 248 static void
 249 doopendict(const char *lhs, void *rhs, void *arg)
 250 {
 251         out(O_VERB, "opendict: \"%s\"", lhs);
 252         fmd_hdl_opendict(Hdl, lhs);
 253 }
 254
 255 void
 256 _fmd_init(fmd_hdl_t *hdl)
 257 {
 258         fmd_case_t *casep = NULL;
 259         int count;
 260         char *fname;
 261
 262         (void) fmd_hdl_register(hdl, FMD_API_VERSION, &fmd_info);
 263
 264         /* keep handle for routines like out() which need it */
 265         Hdl = hdl;
 266
 267         /* set up out(O_ALTFP) first things so it is available for debug */
 268         alloc_init();
 269         out_init("eft");
 270         if ((fname = fmd_prop_get_string(hdl, "status")) != NULL) {
 271                 FILE *fp;
 272
 273                 if ((fp = fopen(fname, "a")) == NULL) {
 274                         fmd_prop_free_string(hdl, fname);
 275                         out(O_DIE|O_SYS, "status property file: %s", fname);
 276                 }
 277
 278                 (void) setlinebuf(fp);
 279                 out_altfp(fp);
 280
 281                 out(O_DEBUG, "appending status changes to \"%s\"", fname);
 282                 fmd_prop_free_string(hdl, fname);
 283
 284                 out(O_ALTFP|O_STAMP, "\neft.so startup");
 285         }
 286
 287
 288         Estats = fmd_prop_get_int32(hdl, "estats");
 289         stats_init(Estats);
 290
 291         stable_init(0);
 292         literals_init();
 293         platform_init();
 294         lut_init();
 295         tree_init();
 296         ipath_init();
 297         iexpr_init();
 298         Efts = platform_get_eft_files();
 299         lex_init(Efts, NULL, 0);
 300         check_init();
 301
 302         /*
 303          *  If we read no .eft files, we can't do any
 304          *  diagnosing, so we just unload ourselves
 305          */
 306         if (stats_counter_value(Filecount) == 0) {
 307                 (void) lex_fini();
 308                 call_finis();
 309                 fmd_hdl_debug(hdl, "no fault trees provided.");
 310                 fmd_hdl_unregister(hdl);
 311                 return;
 312         }
 313
 314         yyparse();
 315         (void) lex_fini();
 316         tree_report();
 317         if (count = out_errcount())
 318                 out(O_DIE, "%d language error%s encountered, exiting.",
 319                     OUTS(count));
 320
 321         /* subscribe to events we expect to consume */
 322         lut_walk(Ereportenames, (lut_cb)dosubscribe, NULL);
 323         lut_walk(Ereportenames_discard, (lut_cb)dodiscardprint, NULL);
 324
 325         /* subscribe to repair events so we can clear state on repair */
 326         fmd_hdl_subscribe(hdl, "list.repaired");
 327
 328         /* open dictionaries referenced by all .eft files */
 329         lut_walk(Dicts, (lut_cb)doopendict, NULL);
 330
 331         Verbose = fmd_prop_get_int32(hdl, "verbose");
 332         Warn = fmd_prop_get_int32(hdl, "warn");
 333         Hesitate = fmd_prop_get_int64(hdl, "hesitate");
 334         Serd_Override = fmd_prop_get_string(hdl, "serd_override");
 335         Max_fme = fmd_prop_get_int32(hdl, "maxfme");
 336
 337         out(O_DEBUG, "initialized, verbose %d warn %d maxfme %d",
 338             Verbose, Warn, Max_fme);
 339
 340         fme_istat_load(hdl);
 341         fme_serd_load(hdl);
 342
 343         out(O_VERB, "reconstituting any existing fmes");
 344         while ((casep = fmd_case_next(hdl, casep)) != NULL) {
 345                 fme_restart(hdl, casep);
 346         }
 347 }
 348
 349 /*ARGSUSED*/
 350 void
 351 _fmd_fini(fmd_hdl_t *hdl)
 352 {
 353         call_finis();
 354 }