patch cleanup
6659 nvlist_free(NULL) is a no-op

   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 2007 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26 
  27 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28 
  29 /*
  30  * Disk & Indicator Monitor configuration file support routines
  31  */
  32 
  33 #include <sys/types.h>
  34 #include <sys/stat.h>
  35 #include <fcntl.h>
  36 #include <unistd.h>
  37 #include <string.h>
  38 #include <strings.h>
  39 #include <errno.h>
  40 #include <limits.h>
  41 #include <pthread.h>
  42 
  43 #include "disk_monitor.h"
  44 #include "util.h"
  45 #include "topo_gather.h"
  46 
  47 extern log_class_t g_verbose;
  48 
  49 const char *
  50 hotplug_state_string(hotplug_state_t state)
  51 {
  52         switch (state & ~HPS_FAULTED) {
  53         default:
  54         case HPS_UNKNOWN:
  55                 return ("Unknown");
  56         case HPS_ABSENT:
  57                 return ("Absent");
  58         case HPS_PRESENT:
  59                 return ("Present");
  60         case HPS_CONFIGURED:
  61                 return ("Configured");
  62         case HPS_UNCONFIGURED:
  63                 return ("Unconfigured");
  64         }
  65 }
  66 
  67 void
  68 conf_error_msg(conf_err_t err, char *buf, int buflen, void *arg)
  69 {
  70         switch (err) {
  71         case E_MULTIPLE_IND_LISTS_DEFINED:
  72                 (void) snprintf(buf, buflen, "Multiple Indicator lists "
  73                     "defined");
  74                 break;
  75         case E_MULTIPLE_INDRULE_LISTS_DEFINED:
  76                 (void) snprintf(buf, buflen, "Multiple Indicator rule lists "
  77                     "defined");
  78                 break;
  79         case E_INVALID_STATE_CHANGE:
  80                 (void) snprintf(buf, buflen, "Invalid state change");
  81                 break;
  82         case E_IND_MULTIPLY_DEFINED:
  83                 (void) snprintf(buf, buflen,
  84                     "Multiple Indicator definitions (name & state) detected");
  85                 break;
  86         case E_IND_ACTION_REDUNDANT:
  87                 (void) snprintf(buf, buflen, "Redundant Indicator actions "
  88                     "specified");
  89                 break;
  90         case E_IND_ACTION_CONFLICT:
  91                 (void) snprintf(buf, buflen, "Indicator action conflict (+/- "
  92                     "same Indicator) found");
  93                 break;
  94         case E_IND_MISSING_FAULT_ON:
  95                 (void) snprintf(buf, buflen, "Missing declaration of `+"
  96                     INDICATOR_FAULT_IDENTIFIER "'");
  97                 break;
  98         case E_IND_MISSING_FAULT_OFF:
  99                 (void) snprintf(buf, buflen, "Missing declaration of `-"
 100                     INDICATOR_FAULT_IDENTIFIER "'");
 101                 break;
 102         case E_INDRULE_REFERENCES_NONEXISTENT_IND_ACTION:
 103                 (void) snprintf(buf, buflen, "`%c%s': Undefined Indicator in "
 104                     BAY_IND_ACTION " property",
 105                     (((ind_action_t *)arg)->ind_state == INDICATOR_ON)
 106                     ? '+' : '-',
 107                     ((ind_action_t *)arg)->ind_name);
 108                 break;
 109         case E_DUPLICATE_STATE_TRANSITION:
 110                 (void) snprintf(buf, buflen, "Duplicate state transition "
 111                     "(%s -> %s)",
 112                     hotplug_state_string(((state_transition_t *)arg)->begin),
 113                     hotplug_state_string(((state_transition_t *)arg)->end));
 114                 break;
 115         default:
 116                 (void) snprintf(buf, buflen, "Unknown error");
 117                 break;
 118         }
 119 }
 120 
 121 static int
 122 string_to_integer(const char *prop, int *value)
 123 {
 124         long val;
 125 
 126         errno = 0;
 127 
 128         val = strtol(prop, NULL, 0);
 129 
 130         if (val == 0 && errno != 0)
 131                 return (-1);
 132         else if (val > INT_MAX || val < INT_MIN) {
 133                 errno = ERANGE;
 134                 return (-1);
 135         }
 136 
 137         if (value != NULL)
 138                 *value = (int)val;
 139 
 140         return (0);
 141 }
 142 
 143 const char *
 144 dm_prop_lookup(nvlist_t *props, const char *prop_name)
 145 {
 146         char *str;
 147 
 148         if (nvlist_lookup_string(props, prop_name, &str) == 0)
 149                 return ((const char *)str);
 150         else
 151                 return (NULL);
 152 }
 153 
 154 int
 155 dm_prop_lookup_int(nvlist_t *props, const char *prop_name, int *value)
 156 {
 157         const char *prop = dm_prop_lookup(props, prop_name);
 158 
 159         if (prop == NULL)
 160                 return (-1);
 161 
 162         return (string_to_integer(prop, value));
 163 }
 164 
 165 nvlist_t *
 166 namevalpr_to_nvlist(namevalpr_t *nvprp)
 167 {
 168         nvlist_t *nvlp = NULL;
 169 
 170         if (nvlist_alloc(&nvlp, NV_UNIQUE_NAME, 0) != 0) {
 171                 return (NULL);
 172         }
 173 
 174         if (nvlist_add_string(nvlp, nvprp->name, nvprp->value) != 0) {
 175                 nvlist_free(nvlp);
 176                 return (NULL);
 177         }
 178 
 179         return (nvlp);
 180 }
 181 
 182 indicator_t *
 183 new_indicator(ind_state_t lstate, char *namep, char *actionp)
 184 {
 185         indicator_t *newindicator =
 186             (indicator_t *)dmalloc(sizeof (indicator_t));
 187         newindicator->ind_state = lstate;
 188         newindicator->ind_name = namep ? dstrdup(namep) : NULL;
 189         newindicator->ind_instr_spec = actionp ? dstrdup(actionp) : NULL;
 190         newindicator->next = NULL;
 191         return (newindicator);
 192 }
 193 
 194 void
 195 link_indicator(indicator_t **first, indicator_t *to_add)
 196 {
 197         indicator_t *travptr;
 198         dm_assert(first != NULL);
 199 
 200         if (*first == NULL)
 201                 *first = to_add;
 202         else {
 203                 travptr = *first;
 204                 while (travptr->next != NULL) {
 205                         travptr = travptr->next;
 206                 }
 207                 travptr->next = to_add;
 208         }
 209 }
 210 
 211 void
 212 ind_free(indicator_t *indp)
 213 {
 214         indicator_t *nextp;
 215 
 216         while (indp != NULL) {
 217                 nextp = indp->next;
 218                 if (indp->ind_name)
 219                         dstrfree(indp->ind_name);
 220                 if (indp->ind_instr_spec)
 221                         dstrfree(indp->ind_instr_spec);
 222                 dfree(indp, sizeof (indicator_t));
 223                 indp = nextp;
 224         }
 225 }
 226 
 227 ind_action_t *
 228 new_indaction(ind_state_t state, char *namep)
 229 {
 230         ind_action_t *lap = (ind_action_t *)dmalloc(sizeof (ind_action_t));
 231         lap->ind_state = state;
 232         lap->ind_name = namep ? dstrdup(namep) : NULL;
 233         lap->next = NULL;
 234         return (lap);
 235 }
 236 
 237 void
 238 link_indaction(ind_action_t **first, ind_action_t *to_add)
 239 {
 240         ind_action_t *travptr;
 241         dm_assert(first != NULL);
 242 
 243         if (*first == NULL)
 244                 *first = to_add;
 245         else {
 246                 travptr = *first;
 247                 while (travptr->next != NULL) {
 248                         travptr = travptr->next;
 249                 }
 250                 travptr->next = to_add;
 251         }
 252 }
 253 
 254 void
 255 indaction_free(ind_action_t *lap)
 256 {
 257         ind_action_t *nextp;
 258 
 259         /* Free the whole list */
 260         while (lap != NULL) {
 261                 nextp = lap->next;
 262                 if (lap->ind_name)
 263                         dstrfree(lap->ind_name);
 264                 dfree(lap, sizeof (ind_action_t));
 265                 lap = nextp;
 266         }
 267 }
 268 
 269 indrule_t *
 270 new_indrule(state_transition_t *st, ind_action_t *actionp)
 271 {
 272         indrule_t *lrp = (indrule_t *)dmalloc(sizeof (indrule_t));
 273         if (st != NULL)
 274                 lrp->strans = *st;
 275         lrp->action_list = actionp;
 276         lrp->next = NULL;
 277         return (lrp);
 278 }
 279 
 280 void
 281 link_indrule(indrule_t **first, indrule_t *to_add)
 282 {
 283         indrule_t *travptr;
 284         dm_assert(first != NULL);
 285 
 286         if (*first == NULL)
 287                 *first = to_add;
 288         else {
 289                 travptr = *first;
 290                 while (travptr->next != NULL) {
 291                         travptr = travptr->next;
 292                 }
 293                 travptr->next = to_add;
 294         }
 295 }
 296 
 297 void
 298 indrule_free(indrule_t *lrp)
 299 {
 300         indrule_t *nextp;
 301 
 302         /* Free the whole list */
 303         while (lrp != NULL) {
 304                 nextp = lrp->next;
 305                 if (lrp->action_list)
 306                         indaction_free(lrp->action_list);
 307                 dfree(lrp, sizeof (indrule_t));
 308                 lrp = nextp;
 309         }
 310 }
 311 
 312 dm_fru_t *
 313 new_dmfru(char *manu, char *modl, char *firmrev, char *serno, uint64_t capa)
 314 {
 315         dm_fru_t *frup = (dm_fru_t *)dzmalloc(sizeof (dm_fru_t));
 316 
 317         bcopy(manu, frup->manuf, MIN(sizeof (frup->manuf), strlen(manu) + 1));
 318         bcopy(modl, frup->model, MIN(sizeof (frup->model), strlen(modl) + 1));
 319         bcopy(firmrev, frup->rev, MIN(sizeof (frup->rev), strlen(firmrev) + 1));
 320         bcopy(serno, frup->serial,
 321             MIN(sizeof (frup->serial), strlen(serno) + 1));
 322         frup->size_in_bytes = capa;
 323         return (frup);
 324 }
 325 
 326 void
 327 dmfru_free(dm_fru_t *frup)
 328 {
 329         dfree(frup, sizeof (dm_fru_t));
 330 }
 331 
 332 diskmon_t *
 333 new_diskmon(nvlist_t *app_props, indicator_t *indp, indrule_t *indrp,
 334     nvlist_t *nvlp)
 335 {
 336         diskmon_t *dmp = (diskmon_t *)dmalloc(sizeof (diskmon_t));
 337 
 338         if (nvlp != NULL)
 339                 dmp->props = nvlp;
 340         else
 341                 (void) nvlist_alloc(&dmp->props, NV_UNIQUE_NAME, 0);
 342 
 343         if (app_props)
 344                 dmp->app_props = app_props;
 345         else
 346                 (void) nvlist_alloc(&dmp->app_props, NV_UNIQUE_NAME, 0);
 347         dmp->ind_list = indp;
 348         dmp->indrule_list = indrp;
 349 
 350         dm_assert(pthread_mutex_init(&dmp->manager_mutex, NULL) == 0);
 351 
 352         dmp->state = HPS_UNKNOWN;
 353 
 354         dmp->initial_configuration = B_TRUE;
 355 
 356         dm_assert(pthread_mutex_init(&dmp->fault_indicator_mutex, NULL) == 0);
 357         dmp->fault_indicator_state = INDICATOR_UNKNOWN;
 358 
 359         dmp->configured_yet = B_FALSE;
 360         dmp->state_change_count = 0;
 361 
 362         dm_assert(pthread_mutex_init(&dmp->fru_mutex, NULL) == 0);
 363         dmp->frup = NULL;
 364 
 365         dmp->next = NULL;
 366         return (dmp);
 367 }
 368 
 369 void
 370 diskmon_free(diskmon_t *dmp)
 371 {
 372         diskmon_t *nextp;
 373 
 374         /* Free the whole list */
 375         while (dmp != NULL) {
 376                 nextp = dmp->next;
 377 
 378                 if (dmp->props)
 379                         nvlist_free(dmp->props);
 380                 if (dmp->location)
 381                         dstrfree(dmp->location);
 382                 if (dmp->ind_list)
 383                         ind_free(dmp->ind_list);
 384                 if (dmp->indrule_list)
 385                         indrule_free(dmp->indrule_list);
 386                 if (dmp->app_props)
 387                         nvlist_free(dmp->app_props);
 388                 if (dmp->frup)
 389                         dmfru_free(dmp->frup);
 390                 dfree(dmp, sizeof (diskmon_t));
 391 
 392                 dmp = nextp;
 393         }
 394 }
 395 
 396 static cfgdata_t *
 397 new_cfgdata(namevalpr_t *nvp, diskmon_t *dmp)
 398 {
 399         cfgdata_t *cdp = (cfgdata_t *)dzmalloc(sizeof (cfgdata_t));
 400 
 401         if (nvp != NULL)
 402                 cdp->props = namevalpr_to_nvlist(nvp);
 403         else if (nvlist_alloc(&cdp->props, NV_UNIQUE_NAME, 0) != 0) {
 404                 return (NULL);
 405         }
 406 
 407         if (dmp != NULL)
 408                 cdp->disk_list = dmp;
 409         return (cdp);
 410 
 411 }
 412 
 413 static void
 414 cfgdata_add_namevalpr(cfgdata_t *cfgp, namevalpr_t *nvp)
 415 {
 416         if (cfgp->props == NULL) {
 417                 (void) nvlist_alloc(&cfgp->props, NV_UNIQUE_NAME, 0);
 418         }
 419         (void) nvlist_add_string(cfgp->props, nvp->name, nvp->value);
 420 }
 421 
 422 void
 423 cfgdata_add_diskmon(cfgdata_t *cfgp, diskmon_t *dmp)
 424 {
 425         if (cfgp->disk_list == NULL) {
 426                 cfgp->disk_list = dmp;
 427         } else {
 428                 diskmon_t *disklist = cfgp->disk_list;
 429 
 430                 while (disklist->next != NULL)
 431                         disklist = disklist->next;
 432 
 433                 disklist->next = dmp;
 434         }
 435 }
 436 
 437 static void
 438 cfgdata_free(cfgdata_t *cdp)
 439 {
 440         nvlist_free(cdp->props);
 441         diskmon_free(cdp->disk_list);
 442         dfree(cdp, sizeof (cfgdata_t));
 443 }
 444 
 445 conf_err_t
 446 check_indactions(ind_action_t *indrp)
 447 {
 448         char *buf;
 449         conf_err_t rv = E_NO_ERROR;
 450         nvlist_t *nvp = NULL;
 451         int len;
 452 
 453         (void) nvlist_alloc(&nvp, NV_UNIQUE_NAME, 0);
 454 
 455         /*
 456          * Check indicator actions for conflicts
 457          */
 458         while (indrp != NULL && rv == E_NO_ERROR) {
 459                 len = strlen(indrp->ind_name) + 2;
 460                 buf = dmalloc(len);
 461                 (void) snprintf(buf, len, "%c%s",
 462                     indrp->ind_state == INDICATOR_ON ? '+' : '-',
 463                     indrp->ind_name);
 464                 switch (nvlist_lookup_boolean(nvp, buf)) {
 465                 case ENOENT:
 466                         (void) nvlist_add_boolean(nvp, buf);
 467                         break;
 468                 case 0:
 469                         rv = E_IND_ACTION_REDUNDANT;
 470                         break;
 471                 default:
 472                         break;
 473                 }
 474 
 475                 /* Look for the opposite action.  If found, that's an error */
 476                 (void) snprintf(buf, len, "%c%s",
 477                     indrp->ind_state == INDICATOR_ON ? '-' : '+',
 478                     indrp->ind_name);
 479                 switch (nvlist_lookup_boolean(nvp, buf)) {
 480                 case ENOENT:
 481                         break;
 482                 case 0:
 483                         rv = E_IND_ACTION_CONFLICT;
 484                         break;
 485                 default:
 486                         break;
 487                 }
 488                 dfree(buf, len);
 489                 indrp = indrp->next;
 490         }
 491 
 492         nvlist_free(nvp);
 493         return (rv);
 494 }
 495 
 496 conf_err_t
 497 check_inds(indicator_t *indp)
 498 {
 499         char *buf;
 500         conf_err_t rv = E_NO_ERROR;
 501         nvlist_t *nvp = NULL;
 502         int len;
 503         boolean_t fault_on = B_FALSE, fault_off = B_FALSE;
 504 
 505         (void) nvlist_alloc(&nvp, NV_UNIQUE_NAME, 0);
 506 
 507         /*
 508          * Check inds for multiple definitions (same identifier or same action)
 509          */
 510         while (indp != NULL && rv == E_NO_ERROR) {
 511                 len = strlen(indp->ind_name) + 2;
 512                 buf = dmalloc(len);
 513                 (void) snprintf(buf, len, "%c%s",
 514                     indp->ind_state == INDICATOR_ON ? '+' : '-',
 515                     indp->ind_name);
 516 
 517                 /* Keep track of the +/-FAULT for checking later */
 518                 if (strcasecmp(buf, "+" INDICATOR_FAULT_IDENTIFIER) == 0)
 519                         fault_on = B_TRUE;
 520                 else if (strcasecmp(buf, "-" INDICATOR_FAULT_IDENTIFIER) == 0)
 521                         fault_off = B_TRUE;
 522 
 523                 switch (nvlist_lookup_boolean(nvp, buf)) {
 524                 case ENOENT:
 525                         (void) nvlist_add_boolean(nvp, buf);
 526                         break;
 527                 case 0:
 528                         rv = E_IND_MULTIPLY_DEFINED;
 529                         break;
 530                 default:
 531                         break;
 532                 }
 533                 dfree(buf, len);
 534                 indp = indp->next;
 535         }
 536 
 537         /*
 538          * Make sure we have a -FAULT and +FAULT
 539          */
 540         if (!fault_on)
 541                 rv = E_IND_MISSING_FAULT_ON;
 542         else if (!fault_off)
 543                 rv = E_IND_MISSING_FAULT_OFF;
 544 
 545         nvlist_free(nvp);
 546         return (rv);
 547 }
 548 
 549 conf_err_t
 550 check_indrules(indrule_t *indrp, state_transition_t **offender)
 551 {
 552         char buf[32];
 553         conf_err_t rv = E_NO_ERROR;
 554         nvlist_t *nvp = NULL;
 555 
 556         /*
 557          * Ensure that no two rules have the same state transitions.
 558          */
 559 
 560         (void) nvlist_alloc(&nvp, NV_UNIQUE_NAME, 0);
 561 
 562         while (indrp != NULL && rv == E_NO_ERROR) {
 563                 (void) snprintf(buf, sizeof (buf), "%d-%d",
 564                     (int)indrp->strans.begin, (int)indrp->strans.end);
 565                 switch (nvlist_lookup_boolean(nvp, buf)) {
 566                 case 0:
 567                         *offender = &indrp->strans;
 568                         rv = E_DUPLICATE_STATE_TRANSITION;
 569                         break;
 570                 case ENOENT:
 571                         (void) nvlist_add_boolean(nvp, buf);
 572                         break;
 573                 default:
 574                         break;
 575                 }
 576                 indrp = indrp->next;
 577         }
 578 
 579         nvlist_free(nvp);
 580         return (rv);
 581 }
 582 
 583 
 584 conf_err_t
 585 check_consistent_ind_indrules(indicator_t *indp, indrule_t *indrp,
 586     ind_action_t **offender)
 587 {
 588         char *buf;
 589         conf_err_t rv = E_NO_ERROR;
 590         nvlist_t *nvp = NULL;
 591         ind_action_t *alp;
 592         int len;
 593 
 594         /*
 595          * Ensure that every indicator action referenced in each ruleset
 596          * exists in the indicator list given.
 597          */
 598 
 599         (void) nvlist_alloc(&nvp, NV_UNIQUE_NAME, 0);
 600 
 601         while (indp != NULL) {
 602                 len = strlen(indp->ind_name) + 2;
 603                 buf = dmalloc(len);
 604                 (void) snprintf(buf, len, "%c%s",
 605                     indp->ind_state == INDICATOR_ON ? '+' : '-',
 606                     indp->ind_name);
 607                 (void) nvlist_add_boolean(nvp, buf);
 608                 dfree(buf, len);
 609                 indp = indp->next;
 610         }
 611 
 612         while (indrp != NULL && rv == E_NO_ERROR) {
 613                 alp = indrp->action_list;
 614                 while (alp != NULL && rv == E_NO_ERROR) {
 615                         len = strlen(alp->ind_name) + 2;
 616                         buf = dmalloc(len);
 617                         (void) snprintf(buf, len, "%c%s",
 618                             alp->ind_state == INDICATOR_ON ? '+' : '-',
 619                             alp->ind_name);
 620 
 621                         switch (nvlist_lookup_boolean(nvp, buf)) {
 622                         case 0:         /* Normal case */
 623                                 break;
 624                         case ENOENT:
 625                                 *offender = alp;
 626                                 rv =
 627                                     E_INDRULE_REFERENCES_NONEXISTENT_IND_ACTION;
 628                                 break;
 629                         default:
 630                                 break;
 631                         }
 632                         dfree(buf, len);
 633                         alp = alp->next;
 634                 }
 635                 indrp = indrp->next;
 636         }
 637 
 638         nvlist_free(nvp);
 639         return (rv);
 640 }
 641 
 642 conf_err_t
 643 check_state_transition(hotplug_state_t s1, hotplug_state_t s2)
 644 {
 645         /*
 646          * The following are valid transitions:
 647          *
 648          * HPS_ABSENT -> HPS_PRESENT
 649          * HPS_ABSENT -> HPS_CONFIGURED
 650          * HPS_PRESENT -> HPS_CONFIGURED
 651          * HPS_PRESENT -> HPS_ABSENT
 652          * HPS_CONFIGURED -> HPS_UNCONFIGURED
 653          * HPS_CONFIGURED -> HPS_ABSENT
 654          * HPS_UNCONFIGURED -> HPS_ABSENT
 655          * HPS_UNCONFIGURED -> HPS_CONFIGURED
 656          *
 657          */
 658         if (s1 == HPS_ABSENT && s2 != HPS_PRESENT && s2 != HPS_CONFIGURED)
 659                 return (E_INVALID_STATE_CHANGE);
 660         else if (s1 == HPS_PRESENT && (s2 != HPS_CONFIGURED &&
 661             s2 != HPS_ABSENT))
 662                 return (E_INVALID_STATE_CHANGE);
 663         else if (s1 == HPS_CONFIGURED && (s2 != HPS_UNCONFIGURED &&
 664             s2 != HPS_ABSENT))
 665                 return (E_INVALID_STATE_CHANGE);
 666         else if (s1 == HPS_UNCONFIGURED && (s2 != HPS_ABSENT &&
 667             s2 != HPS_CONFIGURED))
 668                 return (E_INVALID_STATE_CHANGE);
 669         else
 670                 return (E_NO_ERROR);
 671 }
 672 
 673 static void
 674 print_inds(indicator_t *indp, FILE *fp, char *prefix)
 675 {
 676         char plusminus;
 677 
 678         (void) fprintf(fp, "%sindicators {\n", prefix);
 679         while (indp != NULL) {
 680                 plusminus = (indp->ind_state == INDICATOR_ON) ? '+' : '-';
 681                 (void) fprintf(fp, "%s\t%c%s = \"%s\"\n", prefix, plusminus,
 682                     indp->ind_name, indp->ind_instr_spec);
 683                 indp = indp->next;
 684         }
 685         (void) fprintf(fp, "%s}\n", prefix);
 686 }
 687 
 688 static void
 689 print_indrules(indrule_t *lrp, FILE *fp, char *prefix)
 690 {
 691         char plusminus;
 692         ind_action_t *lap;
 693 
 694         (void) fprintf(fp, "%sindicator_rules {\n", prefix);
 695         while (lrp != NULL) {
 696                 (void) fprintf(fp, "%s\t%12s -> %12s\t{ ", prefix,
 697                     hotplug_state_string(lrp->strans.begin),
 698                     hotplug_state_string(lrp->strans.end));
 699                 lap = lrp->action_list;
 700                 while (lap != NULL) {
 701                         plusminus = (lap->ind_state == INDICATOR_ON)
 702                             ? '+' : '-';
 703                         (void) fprintf(fp, "%c%s", plusminus, lap->ind_name);
 704                         lap = lap->next;
 705                         if (lap != NULL)
 706                                 (void) fprintf(fp, ", ");
 707                 }
 708                 (void) fprintf(fp, " }\n");
 709                 lrp = lrp->next;
 710         }
 711         (void) fprintf(fp, "%s}\n", prefix);
 712 }
 713 
 714 static void
 715 print_props(nvlist_t *nvlp, FILE *fp, char *prefix)
 716 {
 717         nvpair_t *nvp = nvlist_next_nvpair(nvlp, NULL);
 718         char *name, *str;
 719 
 720         while (nvp != NULL) {
 721                 dm_assert(nvpair_type(nvp) == DATA_TYPE_STRING);
 722                 name = nvpair_name(nvp);
 723                 (void) nvlist_lookup_string(nvlp, name, &str);
 724                 (void) fprintf(fp, "%s%s = \"%s\"\n", prefix, name, str);
 725                 nvp = nvlist_next_nvpair(nvlp, nvp);
 726         }
 727 }
 728 
 729 static void
 730 print_ap(nvlist_t *dpp, FILE *fp, char *prefix)
 731 {
 732         int len = strlen(prefix) + 2;
 733         char *buf = dmalloc(len);
 734 
 735         (void) snprintf(buf, len, "%s\t", prefix);
 736 
 737         (void) fprintf(fp, "%sap_props {\n", prefix);
 738         print_props(dpp, fp, buf);
 739         (void) fprintf(fp, "%s}\n", prefix);
 740 
 741         dfree(buf, len);
 742 }
 743 
 744 static void
 745 print_disks(diskmon_t *dmp, FILE *fp, char *prefix)
 746 {
 747         int len = strlen(prefix) + 2;
 748         char *buf = dmalloc(len);
 749 
 750         (void) snprintf(buf, len, "%s\t", prefix);
 751 
 752         while (dmp != NULL) {
 753                 (void) fprintf(fp, "%sdisk \"%s\" {\n", prefix, dmp->location);
 754                 if (dmp->props) {
 755                         print_props(dmp->props, fp, buf);
 756                 }
 757                 if (dmp->app_props) {
 758                         print_ap(dmp->app_props, fp, buf);
 759                 }
 760                 (void) fprintf(fp, "%s\n", prefix);
 761                 print_inds(dmp->ind_list, fp, buf);
 762                 (void) fprintf(fp, "%s\n", prefix);
 763                 print_indrules(dmp->indrule_list, fp, buf);
 764                 (void) fprintf(fp, "%s}\n", prefix);
 765 
 766                 if (dmp->next != NULL)
 767                         (void) fprintf(fp, "%s\n", prefix);
 768 
 769                 dmp = dmp->next;
 770         }
 771 
 772         dfree(buf, len);
 773 }
 774 
 775 static void
 776 print_cfgdata(cfgdata_t *cfgp, FILE *fp, char *prefix)
 777 {
 778         /* First, print the properties, then the disks */
 779 
 780         print_props(cfgp->props, fp, prefix);
 781         (void) fprintf(fp, "%s\n", prefix);
 782         print_disks(cfgp->disk_list, fp, prefix);
 783 }
 784 
 785 int
 786 config_init(void)
 787 {
 788         if (init_configuration_from_topo() == 0) {
 789                 config_data = new_cfgdata(NULL, NULL);
 790                 return (0);
 791         }
 792         return (-1);
 793 }
 794 
 795 int
 796 config_get(fmd_hdl_t *hdl, const fmd_prop_t *fmd_props)
 797 {
 798         int err, i = 0;
 799         char *str = NULL;
 800         namevalpr_t nvp;
 801         uint64_t u64;
 802         boolean_t intfound = B_FALSE, strfound = B_FALSE;
 803 #define INT64_BUF_LEN 128
 804         char buf[INT64_BUF_LEN];
 805 
 806         u64 = fmd_prop_get_int32(hdl, GLOBAL_PROP_LOG_LEVEL);
 807         g_verbose = (int)u64;
 808 
 809         err = update_configuration_from_topo(hdl, NULL);
 810 
 811         /* Pull in the properties from the DE configuration file */
 812         while (fmd_props[i].fmdp_name != NULL) {
 813 
 814                 nvp.name = (char *)fmd_props[i].fmdp_name;
 815 
 816                 switch (fmd_props[i].fmdp_type) {
 817                 case FMD_TYPE_UINT32:
 818                 case FMD_TYPE_INT32:
 819                         intfound = B_TRUE;
 820                         u64 = fmd_prop_get_int32(hdl, fmd_props[i].fmdp_name);
 821                         break;
 822                 case FMD_TYPE_UINT64:
 823                 case FMD_TYPE_INT64:
 824                         intfound = B_TRUE;
 825                         u64 = fmd_prop_get_int64(hdl, fmd_props[i].fmdp_name);
 826                         break;
 827                 case FMD_TYPE_STRING:
 828                         strfound = B_TRUE;
 829                         str = fmd_prop_get_string(hdl, fmd_props[i].fmdp_name);
 830                         break;
 831 
 832                 }
 833 
 834                 if (intfound) {
 835                         (void) snprintf(buf, INT64_BUF_LEN, "0x%llx", u64);
 836                         nvp.value = buf;
 837                         intfound = B_FALSE;
 838                 } else if (strfound) {
 839                         nvp.value = str;
 840                 }
 841 
 842                 log_msg(MM_CONF, "Adding property `%s' with value `%s'\n",
 843                     nvp.name, nvp.value);
 844 
 845                 cfgdata_add_namevalpr(config_data, &nvp);
 846 
 847                 if (strfound) {
 848                         strfound = B_FALSE;
 849                         fmd_prop_free_string(hdl, str);
 850                 }
 851 
 852 
 853                 i++;
 854         }
 855 
 856         if ((g_verbose & (MM_CONF|MM_OTHER)) == (MM_CONF|MM_OTHER))
 857                 print_cfgdata(config_data, stderr, "");
 858 
 859         return (err);
 860 }
 861 
 862 void
 863 config_fini(void)
 864 {
 865         fini_configuration_from_topo();
 866         cfgdata_free(config_data);
 867         config_data = NULL;
 868 }
 869 
 870 nvlist_t *
 871 dm_global_proplist(void)
 872 {
 873         return (config_data->props);
 874 }
--- EOF ---