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 /*
  28  * Disk & Indicator Monitor configuration file support routines
  29  */
  30 
  31 #include <sys/types.h>
  32 #include <sys/stat.h>
  33 #include <fcntl.h>
  34 #include <unistd.h>
  35 #include <string.h>
  36 #include <strings.h>
  37 #include <errno.h>
  38 #include <limits.h>
  39 #include <pthread.h>
  40 
  41 #include "disk_monitor.h"
  42 #include "util.h"
  43 #include "topo_gather.h"
  44 
  45 extern log_class_t g_verbose;
  46 
  47 const char *
  48 hotplug_state_string(hotplug_state_t state)
  49 {
  50         switch (state & ~HPS_FAULTED) {
  51         default:
  52         case HPS_UNKNOWN:
  53                 return ("Unknown");
  54         case HPS_ABSENT:
  55                 return ("Absent");
  56         case HPS_PRESENT:
  57                 return ("Present");
  58         case HPS_CONFIGURED:
  59                 return ("Configured");
  60         case HPS_UNCONFIGURED:
  61                 return ("Unconfigured");
  62         }
  63 }
  64 
  65 void
  66 conf_error_msg(conf_err_t err, char *buf, int buflen, void *arg)
  67 {
  68         switch (err) {
  69         case E_MULTIPLE_IND_LISTS_DEFINED:
  70                 (void) snprintf(buf, buflen, "Multiple Indicator lists "
  71                     "defined");
  72                 break;
  73         case E_MULTIPLE_INDRULE_LISTS_DEFINED:
  74                 (void) snprintf(buf, buflen, "Multiple Indicator rule lists "
  75                     "defined");
  76                 break;
  77         case E_INVALID_STATE_CHANGE:
  78                 (void) snprintf(buf, buflen, "Invalid state change");
  79                 break;
  80         case E_IND_MULTIPLY_DEFINED:
  81                 (void) snprintf(buf, buflen,
  82                     "Multiple Indicator definitions (name & state) detected");
  83                 break;
  84         case E_IND_ACTION_REDUNDANT:
  85                 (void) snprintf(buf, buflen, "Redundant Indicator actions "
  86                     "specified");
  87                 break;
  88         case E_IND_ACTION_CONFLICT:
  89                 (void) snprintf(buf, buflen, "Indicator action conflict (+/- "
  90                     "same Indicator) found");
  91                 break;
  92         case E_IND_MISSING_FAULT_ON:
  93                 (void) snprintf(buf, buflen, "Missing declaration of `+"
  94                     INDICATOR_FAULT_IDENTIFIER "'");
  95                 break;
  96         case E_IND_MISSING_FAULT_OFF:
  97                 (void) snprintf(buf, buflen, "Missing declaration of `-"
  98                     INDICATOR_FAULT_IDENTIFIER "'");
  99                 break;
 100         case E_INDRULE_REFERENCES_NONEXISTENT_IND_ACTION:
 101                 (void) snprintf(buf, buflen, "`%c%s': Undefined Indicator in "
 102                     BAY_IND_ACTION " property",
 103                     (((ind_action_t *)arg)->ind_state == INDICATOR_ON)
 104                     ? '+' : '-',
 105                     ((ind_action_t *)arg)->ind_name);
 106                 break;
 107         case E_DUPLICATE_STATE_TRANSITION:
 108                 (void) snprintf(buf, buflen, "Duplicate state transition "
 109                     "(%s -> %s)",
 110                     hotplug_state_string(((state_transition_t *)arg)->begin),
 111                     hotplug_state_string(((state_transition_t *)arg)->end));
 112                 break;
 113         default:
 114                 (void) snprintf(buf, buflen, "Unknown error");
 115                 break;
 116         }
 117 }
 118 
 119 static int
 120 string_to_integer(const char *prop, int *value)
 121 {
 122         long val;
 123 
 124         errno = 0;
 125 
 126         val = strtol(prop, NULL, 0);
 127 
 128         if (val == 0 && errno != 0)
 129                 return (-1);
 130         else if (val > INT_MAX || val < INT_MIN) {
 131                 errno = ERANGE;
 132                 return (-1);
 133         }
 134 
 135         if (value != NULL)
 136                 *value = (int)val;
 137 
 138         return (0);
 139 }
 140 
 141 const char *
 142 dm_prop_lookup(nvlist_t *props, const char *prop_name)
 143 {
 144         char *str;
 145 
 146         if (nvlist_lookup_string(props, prop_name, &str) == 0)
 147                 return ((const char *)str);
 148         else
 149                 return (NULL);
 150 }
 151 
 152 int
 153 dm_prop_lookup_int(nvlist_t *props, const char *prop_name, int *value)
 154 {
 155         const char *prop = dm_prop_lookup(props, prop_name);
 156 
 157         if (prop == NULL)
 158                 return (-1);
 159 
 160         return (string_to_integer(prop, value));
 161 }
 162 
 163 nvlist_t *
 164 namevalpr_to_nvlist(namevalpr_t *nvprp)
 165 {
 166         nvlist_t *nvlp = NULL;
 167 
 168         if (nvlist_alloc(&nvlp, NV_UNIQUE_NAME, 0) != 0) {
 169                 return (NULL);
 170         }
 171 
 172         if (nvlist_add_string(nvlp, nvprp->name, nvprp->value) != 0) {
 173                 nvlist_free(nvlp);
 174                 return (NULL);
 175         }
 176 
 177         return (nvlp);
 178 }
 179 
 180 indicator_t *
 181 new_indicator(ind_state_t lstate, char *namep, char *actionp)
 182 {
 183         indicator_t *newindicator =
 184             (indicator_t *)dmalloc(sizeof (indicator_t));
 185         newindicator->ind_state = lstate;
 186         newindicator->ind_name = namep ? dstrdup(namep) : NULL;
 187         newindicator->ind_instr_spec = actionp ? dstrdup(actionp) : NULL;
 188         newindicator->next = NULL;
 189         return (newindicator);
 190 }
 191 
 192 void
 193 link_indicator(indicator_t **first, indicator_t *to_add)
 194 {
 195         indicator_t *travptr;
 196         dm_assert(first != NULL);
 197 
 198         if (*first == NULL)
 199                 *first = to_add;
 200         else {
 201                 travptr = *first;
 202                 while (travptr->next != NULL) {
 203                         travptr = travptr->next;
 204                 }
 205                 travptr->next = to_add;
 206         }
 207 }
 208 
 209 void
 210 ind_free(indicator_t *indp)
 211 {
 212         indicator_t *nextp;
 213 
 214         while (indp != NULL) {
 215                 nextp = indp->next;
 216                 if (indp->ind_name)
 217                         dstrfree(indp->ind_name);
 218                 if (indp->ind_instr_spec)
 219                         dstrfree(indp->ind_instr_spec);
 220                 dfree(indp, sizeof (indicator_t));
 221                 indp = nextp;
 222         }
 223 }
 224 
 225 ind_action_t *
 226 new_indaction(ind_state_t state, char *namep)
 227 {
 228         ind_action_t *lap = (ind_action_t *)dmalloc(sizeof (ind_action_t));
 229         lap->ind_state = state;
 230         lap->ind_name = namep ? dstrdup(namep) : NULL;
 231         lap->next = NULL;
 232         return (lap);
 233 }
 234 
 235 void
 236 link_indaction(ind_action_t **first, ind_action_t *to_add)
 237 {
 238         ind_action_t *travptr;
 239         dm_assert(first != NULL);
 240 
 241         if (*first == NULL)
 242                 *first = to_add;
 243         else {
 244                 travptr = *first;
 245                 while (travptr->next != NULL) {
 246                         travptr = travptr->next;
 247                 }
 248                 travptr->next = to_add;
 249         }
 250 }
 251 
 252 void
 253 indaction_free(ind_action_t *lap)
 254 {
 255         ind_action_t *nextp;
 256 
 257         /* Free the whole list */
 258         while (lap != NULL) {
 259                 nextp = lap->next;
 260                 if (lap->ind_name)
 261                         dstrfree(lap->ind_name);
 262                 dfree(lap, sizeof (ind_action_t));
 263                 lap = nextp;
 264         }
 265 }
 266 
 267 indrule_t *
 268 new_indrule(state_transition_t *st, ind_action_t *actionp)
 269 {
 270         indrule_t *lrp = (indrule_t *)dmalloc(sizeof (indrule_t));
 271         if (st != NULL)
 272                 lrp->strans = *st;
 273         lrp->action_list = actionp;
 274         lrp->next = NULL;
 275         return (lrp);
 276 }
 277 
 278 void
 279 link_indrule(indrule_t **first, indrule_t *to_add)
 280 {
 281         indrule_t *travptr;
 282         dm_assert(first != NULL);
 283 
 284         if (*first == NULL)
 285                 *first = to_add;
 286         else {
 287                 travptr = *first;
 288                 while (travptr->next != NULL) {
 289                         travptr = travptr->next;
 290                 }
 291                 travptr->next = to_add;
 292         }
 293 }
 294 
 295 void
 296 indrule_free(indrule_t *lrp)
 297 {
 298         indrule_t *nextp;
 299 
 300         /* Free the whole list */
 301         while (lrp != NULL) {
 302                 nextp = lrp->next;
 303                 if (lrp->action_list)
 304                         indaction_free(lrp->action_list);
 305                 dfree(lrp, sizeof (indrule_t));
 306                 lrp = nextp;
 307         }
 308 }
 309 
 310 dm_fru_t *
 311 new_dmfru(char *manu, char *modl, char *firmrev, char *serno, uint64_t capa)
 312 {
 313         dm_fru_t *frup = (dm_fru_t *)dzmalloc(sizeof (dm_fru_t));
 314 
 315         bcopy(manu, frup->manuf, MIN(sizeof (frup->manuf), strlen(manu) + 1));
 316         bcopy(modl, frup->model, MIN(sizeof (frup->model), strlen(modl) + 1));
 317         bcopy(firmrev, frup->rev, MIN(sizeof (frup->rev), strlen(firmrev) + 1));
 318         bcopy(serno, frup->serial,
 319             MIN(sizeof (frup->serial), strlen(serno) + 1));
 320         frup->size_in_bytes = capa;
 321         return (frup);
 322 }
 323 
 324 void
 325 dmfru_free(dm_fru_t *frup)
 326 {
 327         dfree(frup, sizeof (dm_fru_t));
 328 }
 329 
 330 diskmon_t *
 331 new_diskmon(nvlist_t *app_props, indicator_t *indp, indrule_t *indrp,
 332     nvlist_t *nvlp)
 333 {
 334         diskmon_t *dmp = (diskmon_t *)dmalloc(sizeof (diskmon_t));
 335 
 336         if (nvlp != NULL)
 337                 dmp->props = nvlp;
 338         else
 339                 (void) nvlist_alloc(&dmp->props, NV_UNIQUE_NAME, 0);
 340 
 341         if (app_props)
 342                 dmp->app_props = app_props;
 343         else
 344                 (void) nvlist_alloc(&dmp->app_props, NV_UNIQUE_NAME, 0);
 345         dmp->ind_list = indp;
 346         dmp->indrule_list = indrp;
 347 
 348         dm_assert(pthread_mutex_init(&dmp->manager_mutex, NULL) == 0);
 349 
 350         dmp->state = HPS_UNKNOWN;
 351 
 352         dmp->initial_configuration = B_TRUE;
 353 
 354         dm_assert(pthread_mutex_init(&dmp->fault_indicator_mutex, NULL) == 0);
 355         dmp->fault_indicator_state = INDICATOR_UNKNOWN;
 356 
 357         dmp->configured_yet = B_FALSE;
 358         dmp->state_change_count = 0;
 359 
 360         dm_assert(pthread_mutex_init(&dmp->fru_mutex, NULL) == 0);
 361         dmp->frup = NULL;
 362 
 363         dmp->next = NULL;
 364         return (dmp);
 365 }
 366 
 367 void
 368 diskmon_free(diskmon_t *dmp)
 369 {
 370         diskmon_t *nextp;
 371 
 372         /* Free the whole list */
 373         while (dmp != NULL) {
 374                 nextp = dmp->next;
 375 

 376                 nvlist_free(dmp->props);
 377                 if (dmp->location)
 378                         dstrfree(dmp->location);
 379                 if (dmp->ind_list)
 380                         ind_free(dmp->ind_list);
 381                 if (dmp->indrule_list)
 382                         indrule_free(dmp->indrule_list);

 383                 nvlist_free(dmp->app_props);
 384                 if (dmp->frup)
 385                         dmfru_free(dmp->frup);
 386                 dfree(dmp, sizeof (diskmon_t));
 387 
 388                 dmp = nextp;
 389         }
 390 }
 391 
 392 static cfgdata_t *
 393 new_cfgdata(namevalpr_t *nvp, diskmon_t *dmp)
 394 {
 395         cfgdata_t *cdp = (cfgdata_t *)dzmalloc(sizeof (cfgdata_t));
 396 
 397         if (nvp != NULL)
 398                 cdp->props = namevalpr_to_nvlist(nvp);
 399         else if (nvlist_alloc(&cdp->props, NV_UNIQUE_NAME, 0) != 0) {
 400                 return (NULL);
 401         }
 402 
 403         if (dmp != NULL)
 404                 cdp->disk_list = dmp;
 405         return (cdp);
 406 
 407 }
 408 
 409 static void
 410 cfgdata_add_namevalpr(cfgdata_t *cfgp, namevalpr_t *nvp)
 411 {
 412         if (cfgp->props == NULL) {
 413                 (void) nvlist_alloc(&cfgp->props, NV_UNIQUE_NAME, 0);
 414         }
 415         (void) nvlist_add_string(cfgp->props, nvp->name, nvp->value);
 416 }
 417 
 418 void
 419 cfgdata_add_diskmon(cfgdata_t *cfgp, diskmon_t *dmp)
 420 {
 421         if (cfgp->disk_list == NULL) {
 422                 cfgp->disk_list = dmp;
 423         } else {
 424                 diskmon_t *disklist = cfgp->disk_list;
 425 
 426                 while (disklist->next != NULL)
 427                         disklist = disklist->next;
 428 
 429                 disklist->next = dmp;
 430         }
 431 }
 432 
 433 static void
 434 cfgdata_free(cfgdata_t *cdp)
 435 {
 436         nvlist_free(cdp->props);
 437         diskmon_free(cdp->disk_list);
 438         dfree(cdp, sizeof (cfgdata_t));
 439 }
 440 
 441 conf_err_t
 442 check_indactions(ind_action_t *indrp)
 443 {
 444         char *buf;
 445         conf_err_t rv = E_NO_ERROR;
 446         nvlist_t *nvp = NULL;
 447         int len;
 448 
 449         (void) nvlist_alloc(&nvp, NV_UNIQUE_NAME, 0);
 450 
 451         /*
 452          * Check indicator actions for conflicts
 453          */
 454         while (indrp != NULL && rv == E_NO_ERROR) {
 455                 len = strlen(indrp->ind_name) + 2;
 456                 buf = dmalloc(len);
 457                 (void) snprintf(buf, len, "%c%s",
 458                     indrp->ind_state == INDICATOR_ON ? '+' : '-',
 459                     indrp->ind_name);
 460                 switch (nvlist_lookup_boolean(nvp, buf)) {
 461                 case ENOENT:
 462                         (void) nvlist_add_boolean(nvp, buf);
 463                         break;
 464                 case 0:
 465                         rv = E_IND_ACTION_REDUNDANT;
 466                         break;
 467                 default:
 468                         break;
 469                 }
 470 
 471                 /* Look for the opposite action.  If found, that's an error */
 472                 (void) snprintf(buf, len, "%c%s",
 473                     indrp->ind_state == INDICATOR_ON ? '-' : '+',
 474                     indrp->ind_name);
 475                 switch (nvlist_lookup_boolean(nvp, buf)) {
 476                 case ENOENT:
 477                         break;
 478                 case 0:
 479                         rv = E_IND_ACTION_CONFLICT;
 480                         break;
 481                 default:
 482                         break;
 483                 }
 484                 dfree(buf, len);
 485                 indrp = indrp->next;
 486         }
 487 
 488         nvlist_free(nvp);
 489         return (rv);
 490 }
 491 
 492 conf_err_t
 493 check_inds(indicator_t *indp)
 494 {
 495         char *buf;
 496         conf_err_t rv = E_NO_ERROR;
 497         nvlist_t *nvp = NULL;
 498         int len;
 499         boolean_t fault_on = B_FALSE, fault_off = B_FALSE;
 500 
 501         (void) nvlist_alloc(&nvp, NV_UNIQUE_NAME, 0);
 502 
 503         /*
 504          * Check inds for multiple definitions (same identifier or same action)
 505          */
 506         while (indp != NULL && rv == E_NO_ERROR) {
 507                 len = strlen(indp->ind_name) + 2;
 508                 buf = dmalloc(len);
 509                 (void) snprintf(buf, len, "%c%s",
 510                     indp->ind_state == INDICATOR_ON ? '+' : '-',
 511                     indp->ind_name);
 512 
 513                 /* Keep track of the +/-FAULT for checking later */
 514                 if (strcasecmp(buf, "+" INDICATOR_FAULT_IDENTIFIER) == 0)
 515                         fault_on = B_TRUE;
 516                 else if (strcasecmp(buf, "-" INDICATOR_FAULT_IDENTIFIER) == 0)
 517                         fault_off = B_TRUE;
 518 
 519                 switch (nvlist_lookup_boolean(nvp, buf)) {
 520                 case ENOENT:
 521                         (void) nvlist_add_boolean(nvp, buf);
 522                         break;
 523                 case 0:
 524                         rv = E_IND_MULTIPLY_DEFINED;
 525                         break;
 526                 default:
 527                         break;
 528                 }
 529                 dfree(buf, len);
 530                 indp = indp->next;
 531         }
 532 
 533         /*
 534          * Make sure we have a -FAULT and +FAULT
 535          */
 536         if (!fault_on)
 537                 rv = E_IND_MISSING_FAULT_ON;
 538         else if (!fault_off)
 539                 rv = E_IND_MISSING_FAULT_OFF;
 540 
 541         nvlist_free(nvp);
 542         return (rv);
 543 }
 544 
 545 conf_err_t
 546 check_indrules(indrule_t *indrp, state_transition_t **offender)
 547 {
 548         char buf[32];
 549         conf_err_t rv = E_NO_ERROR;
 550         nvlist_t *nvp = NULL;
 551 
 552         /*
 553          * Ensure that no two rules have the same state transitions.
 554          */
 555 
 556         (void) nvlist_alloc(&nvp, NV_UNIQUE_NAME, 0);
 557 
 558         while (indrp != NULL && rv == E_NO_ERROR) {
 559                 (void) snprintf(buf, sizeof (buf), "%d-%d",
 560                     (int)indrp->strans.begin, (int)indrp->strans.end);
 561                 switch (nvlist_lookup_boolean(nvp, buf)) {
 562                 case 0:
 563                         *offender = &indrp->strans;
 564                         rv = E_DUPLICATE_STATE_TRANSITION;
 565                         break;
 566                 case ENOENT:
 567                         (void) nvlist_add_boolean(nvp, buf);
 568                         break;
 569                 default:
 570                         break;
 571                 }
 572                 indrp = indrp->next;
 573         }
 574 
 575         nvlist_free(nvp);
 576         return (rv);
 577 }
 578 
 579 
 580 conf_err_t
 581 check_consistent_ind_indrules(indicator_t *indp, indrule_t *indrp,
 582     ind_action_t **offender)
 583 {
 584         char *buf;
 585         conf_err_t rv = E_NO_ERROR;
 586         nvlist_t *nvp = NULL;
 587         ind_action_t *alp;
 588         int len;
 589 
 590         /*
 591          * Ensure that every indicator action referenced in each ruleset
 592          * exists in the indicator list given.
 593          */
 594 
 595         (void) nvlist_alloc(&nvp, NV_UNIQUE_NAME, 0);
 596 
 597         while (indp != NULL) {
 598                 len = strlen(indp->ind_name) + 2;
 599                 buf = dmalloc(len);
 600                 (void) snprintf(buf, len, "%c%s",
 601                     indp->ind_state == INDICATOR_ON ? '+' : '-',
 602                     indp->ind_name);
 603                 (void) nvlist_add_boolean(nvp, buf);
 604                 dfree(buf, len);
 605                 indp = indp->next;
 606         }
 607 
 608         while (indrp != NULL && rv == E_NO_ERROR) {
 609                 alp = indrp->action_list;
 610                 while (alp != NULL && rv == E_NO_ERROR) {
 611                         len = strlen(alp->ind_name) + 2;
 612                         buf = dmalloc(len);
 613                         (void) snprintf(buf, len, "%c%s",
 614                             alp->ind_state == INDICATOR_ON ? '+' : '-',
 615                             alp->ind_name);
 616 
 617                         switch (nvlist_lookup_boolean(nvp, buf)) {
 618                         case 0:         /* Normal case */
 619                                 break;
 620                         case ENOENT:
 621                                 *offender = alp;
 622                                 rv =
 623                                     E_INDRULE_REFERENCES_NONEXISTENT_IND_ACTION;
 624                                 break;
 625                         default:
 626                                 break;
 627                         }
 628                         dfree(buf, len);
 629                         alp = alp->next;
 630                 }
 631                 indrp = indrp->next;
 632         }
 633 
 634         nvlist_free(nvp);
 635         return (rv);
 636 }
 637 
 638 conf_err_t
 639 check_state_transition(hotplug_state_t s1, hotplug_state_t s2)
 640 {
 641         /*
 642          * The following are valid transitions:
 643          *
 644          * HPS_ABSENT -> HPS_PRESENT
 645          * HPS_ABSENT -> HPS_CONFIGURED
 646          * HPS_PRESENT -> HPS_CONFIGURED
 647          * HPS_PRESENT -> HPS_ABSENT
 648          * HPS_CONFIGURED -> HPS_UNCONFIGURED
 649          * HPS_CONFIGURED -> HPS_ABSENT
 650          * HPS_UNCONFIGURED -> HPS_ABSENT
 651          * HPS_UNCONFIGURED -> HPS_CONFIGURED
 652          *
 653          */
 654         if (s1 == HPS_ABSENT && s2 != HPS_PRESENT && s2 != HPS_CONFIGURED)
 655                 return (E_INVALID_STATE_CHANGE);
 656         else if (s1 == HPS_PRESENT && (s2 != HPS_CONFIGURED &&
 657             s2 != HPS_ABSENT))
 658                 return (E_INVALID_STATE_CHANGE);
 659         else if (s1 == HPS_CONFIGURED && (s2 != HPS_UNCONFIGURED &&
 660             s2 != HPS_ABSENT))
 661                 return (E_INVALID_STATE_CHANGE);
 662         else if (s1 == HPS_UNCONFIGURED && (s2 != HPS_ABSENT &&
 663             s2 != HPS_CONFIGURED))
 664                 return (E_INVALID_STATE_CHANGE);
 665         else
 666                 return (E_NO_ERROR);
 667 }
 668 
 669 static void
 670 print_inds(indicator_t *indp, FILE *fp, char *prefix)
 671 {
 672         char plusminus;
 673 
 674         (void) fprintf(fp, "%sindicators {\n", prefix);
 675         while (indp != NULL) {
 676                 plusminus = (indp->ind_state == INDICATOR_ON) ? '+' : '-';
 677                 (void) fprintf(fp, "%s\t%c%s = \"%s\"\n", prefix, plusminus,
 678                     indp->ind_name, indp->ind_instr_spec);
 679                 indp = indp->next;
 680         }
 681         (void) fprintf(fp, "%s}\n", prefix);
 682 }
 683 
 684 static void
 685 print_indrules(indrule_t *lrp, FILE *fp, char *prefix)
 686 {
 687         char plusminus;
 688         ind_action_t *lap;
 689 
 690         (void) fprintf(fp, "%sindicator_rules {\n", prefix);
 691         while (lrp != NULL) {
 692                 (void) fprintf(fp, "%s\t%12s -> %12s\t{ ", prefix,
 693                     hotplug_state_string(lrp->strans.begin),
 694                     hotplug_state_string(lrp->strans.end));
 695                 lap = lrp->action_list;
 696                 while (lap != NULL) {
 697                         plusminus = (lap->ind_state == INDICATOR_ON)
 698                             ? '+' : '-';
 699                         (void) fprintf(fp, "%c%s", plusminus, lap->ind_name);
 700                         lap = lap->next;
 701                         if (lap != NULL)
 702                                 (void) fprintf(fp, ", ");
 703                 }
 704                 (void) fprintf(fp, " }\n");
 705                 lrp = lrp->next;
 706         }
 707         (void) fprintf(fp, "%s}\n", prefix);
 708 }
 709 
 710 static void
 711 print_props(nvlist_t *nvlp, FILE *fp, char *prefix)
 712 {
 713         nvpair_t *nvp = nvlist_next_nvpair(nvlp, NULL);
 714         char *name, *str;
 715 
 716         while (nvp != NULL) {
 717                 dm_assert(nvpair_type(nvp) == DATA_TYPE_STRING);
 718                 name = nvpair_name(nvp);
 719                 (void) nvlist_lookup_string(nvlp, name, &str);
 720                 (void) fprintf(fp, "%s%s = \"%s\"\n", prefix, name, str);
 721                 nvp = nvlist_next_nvpair(nvlp, nvp);
 722         }
 723 }
 724 
 725 static void
 726 print_ap(nvlist_t *dpp, FILE *fp, char *prefix)
 727 {
 728         int len = strlen(prefix) + 2;
 729         char *buf = dmalloc(len);
 730 
 731         (void) snprintf(buf, len, "%s\t", prefix);
 732 
 733         (void) fprintf(fp, "%sap_props {\n", prefix);
 734         print_props(dpp, fp, buf);
 735         (void) fprintf(fp, "%s}\n", prefix);
 736 
 737         dfree(buf, len);
 738 }
 739 
 740 static void
 741 print_disks(diskmon_t *dmp, FILE *fp, char *prefix)
 742 {
 743         int len = strlen(prefix) + 2;
 744         char *buf = dmalloc(len);
 745 
 746         (void) snprintf(buf, len, "%s\t", prefix);
 747 
 748         while (dmp != NULL) {
 749                 (void) fprintf(fp, "%sdisk \"%s\" {\n", prefix, dmp->location);
 750                 if (dmp->props) {
 751                         print_props(dmp->props, fp, buf);
 752                 }
 753                 if (dmp->app_props) {
 754                         print_ap(dmp->app_props, fp, buf);
 755                 }
 756                 (void) fprintf(fp, "%s\n", prefix);
 757                 print_inds(dmp->ind_list, fp, buf);
 758                 (void) fprintf(fp, "%s\n", prefix);
 759                 print_indrules(dmp->indrule_list, fp, buf);
 760                 (void) fprintf(fp, "%s}\n", prefix);
 761 
 762                 if (dmp->next != NULL)
 763                         (void) fprintf(fp, "%s\n", prefix);
 764 
 765                 dmp = dmp->next;
 766         }
 767 
 768         dfree(buf, len);
 769 }
 770 
 771 static void
 772 print_cfgdata(cfgdata_t *cfgp, FILE *fp, char *prefix)
 773 {
 774         /* First, print the properties, then the disks */
 775 
 776         print_props(cfgp->props, fp, prefix);
 777         (void) fprintf(fp, "%s\n", prefix);
 778         print_disks(cfgp->disk_list, fp, prefix);
 779 }
 780 
 781 int
 782 config_init(void)
 783 {
 784         if (init_configuration_from_topo() == 0) {
 785                 config_data = new_cfgdata(NULL, NULL);
 786                 return (0);
 787         }
 788         return (-1);
 789 }
 790 
 791 int
 792 config_get(fmd_hdl_t *hdl, const fmd_prop_t *fmd_props)
 793 {
 794         int err, i = 0;
 795         char *str = NULL;
 796         namevalpr_t nvp;
 797         uint64_t u64;
 798         boolean_t intfound = B_FALSE, strfound = B_FALSE;
 799 #define INT64_BUF_LEN 128
 800         char buf[INT64_BUF_LEN];
 801 
 802         u64 = fmd_prop_get_int32(hdl, GLOBAL_PROP_LOG_LEVEL);
 803         g_verbose = (int)u64;
 804 
 805         err = update_configuration_from_topo(hdl, NULL);
 806 
 807         /* Pull in the properties from the DE configuration file */
 808         while (fmd_props[i].fmdp_name != NULL) {
 809 
 810                 nvp.name = (char *)fmd_props[i].fmdp_name;
 811 
 812                 switch (fmd_props[i].fmdp_type) {
 813                 case FMD_TYPE_UINT32:
 814                 case FMD_TYPE_INT32:
 815                         intfound = B_TRUE;
 816                         u64 = fmd_prop_get_int32(hdl, fmd_props[i].fmdp_name);
 817                         break;
 818                 case FMD_TYPE_UINT64:
 819                 case FMD_TYPE_INT64:
 820                         intfound = B_TRUE;
 821                         u64 = fmd_prop_get_int64(hdl, fmd_props[i].fmdp_name);
 822                         break;
 823                 case FMD_TYPE_STRING:
 824                         strfound = B_TRUE;
 825                         str = fmd_prop_get_string(hdl, fmd_props[i].fmdp_name);
 826                         break;
 827 
 828                 }
 829 
 830                 if (intfound) {
 831                         (void) snprintf(buf, INT64_BUF_LEN, "0x%llx", u64);
 832                         nvp.value = buf;
 833                         intfound = B_FALSE;
 834                 } else if (strfound) {
 835                         nvp.value = str;
 836                 }
 837 
 838                 log_msg(MM_CONF, "Adding property `%s' with value `%s'\n",
 839                     nvp.name, nvp.value);
 840 
 841                 cfgdata_add_namevalpr(config_data, &nvp);
 842 
 843                 if (strfound) {
 844                         strfound = B_FALSE;
 845                         fmd_prop_free_string(hdl, str);
 846                 }
 847 
 848 
 849                 i++;
 850         }
 851 
 852         if ((g_verbose & (MM_CONF|MM_OTHER)) == (MM_CONF|MM_OTHER))
 853                 print_cfgdata(config_data, stderr, "");
 854 
 855         return (err);
 856 }
 857 
 858 void
 859 config_fini(void)
 860 {
 861         fini_configuration_from_topo();
 862         cfgdata_free(config_data);
 863         config_data = NULL;
 864 }
 865 
 866 nvlist_t *
 867 dm_global_proplist(void)
 868 {
 869         return (config_data->props);
 870 }
--- EOF ---