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 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 * Copyright 2020 Joyent, Inc. 26 */ 27 28 /* 29 * Service state explanation. For select services, display a description, the 30 * state, and possibly why the service is in that state, what's causing it to 31 * be in that state, and what other services it is keeping offline (impact). 32 * 33 * Explaining states other than offline is easy. For maintenance and 34 * degraded, we just use the auxiliary state. For offline, we must determine 35 * which dependencies are unsatisfied and recurse. If a causal service is not 36 * offline, then a svcptr to it is added to the offline service's causes list. 37 * If a causal service is offline, then we recurse to determine its causes and 38 * merge them into the causes list of the service in question (see 39 * add_causes()). Note that by adding a self-pointing svcptr to the causes 40 * lists of services which are not offline or are offline for unknown reasons, 41 * we can always merge the unsatisfied dependency's causes into the 42 * dependent's list. 43 * 44 * Computing an impact list is more involved because the dependencies in the 45 * repository are unidirectional; it requires determining the causes of all 46 * offline services. For each unsatisfied dependency of an offline service, 47 * a svcptr to the dependent is added to the dependency's impact_dependents 48 * list (see add_causes()). determine_impact() uses the lists to build an 49 * impact list. The direct dependency is used so that a path from the 50 * affected service to the causal service can be constructed (see 51 * print_dependency_reasons()). 52 * 53 * Because we always need at least impact counts, we always run 54 * determine_causes() on all services. 55 * 56 * If no arguments are given, we must select the services which are causing 57 * other services to be offline. We do so by adding services which are not 58 * running for any reason other than another service to the g_causes list in 59 * determine_causes(). 60 * 61 * Since all services must be examined, and their states may be consulted 62 * a lot, it is important that we only read volatile data (like states) from 63 * the repository once. add_instance() reads data for an instance from the 64 * repository into an inst_t and puts it into the "services" cache, which is 65 * organized as a hash table of svc_t's, each of which has a list of inst_t's. 66 */ 67 68 #include "svcs.h" 69 70 #include <sys/stat.h> 71 #include <sys/wait.h> 72 73 #include <assert.h> 74 #include <errno.h> 75 #include <libintl.h> 76 #include <libuutil.h> 77 #include <libscf.h> 78 #include <libscf_priv.h> 79 #include <string.h> 80 #include <stdio.h> 81 #include <stdlib.h> 82 #include <time.h> 83 84 85 #define DC_DISABLED "SMF-8000-05" 86 #define DC_TEMPDISABLED "SMF-8000-1S" 87 #define DC_RSTRINVALID "SMF-8000-2A" 88 #define DC_RSTRABSENT "SMF-8000-3P" 89 #define DC_UNINIT "SMF-8000-4D" 90 #define DC_RSTRDEAD "SMF-8000-5H" 91 #define DC_ADMINMAINT "SMF-8000-63" 92 #define DC_SVCREQMAINT "SMF-8000-R4" 93 #define DC_REPTFAIL "SMF-8000-7Y" 94 #define DC_METHFAIL "SMF-8000-8Q" 95 #define DC_NONE "SMF-8000-9C" 96 #define DC_UNKNOWN "SMF-8000-AR" 97 #define DC_STARTING "SMF-8000-C4" 98 #define DC_ADMINDEGR "SMF-8000-DX" 99 #define DC_DEPABSENT "SMF-8000-E2" 100 #define DC_DEPRUNNING "SMF-8000-FJ" 101 #define DC_DEPOTHER "SMF-8000-GE" 102 #define DC_DEPCYCLE "SMF-8000-HP" 103 #define DC_INVALIDDEP "SMF-8000-JA" 104 #define DC_STARTFAIL "SMF-8000-KS" 105 #define DC_TOOQUICKLY "SMF-8000-L5" 106 #define DC_INVALIDSTATE "SMF-8000-N3" 107 #define DC_TRANSITION "SMF-8000-PH" 108 109 #define DEFAULT_MAN_PATH "/usr/share/man" 110 111 #define AUX_STATE_INVALID "invalid_aux_state" 112 113 #define uu_list_append(lst, e) uu_list_insert_before(lst, NULL, e) 114 115 #define bad_error(func, err) \ 116 uu_panic("%s:%d: %s() failed with unknown error %d.\n", \ 117 __FILE__, __LINE__, func, err); 118 119 typedef struct { 120 const char *svcname; 121 const char *instname; 122 123 /* restarter pg properties */ 124 char state[MAX_SCF_STATE_STRING_SZ]; 125 char next_state[MAX_SCF_STATE_STRING_SZ]; 126 struct timeval stime; 127 const char *aux_state; 128 const char *aux_fmri; 129 int64_t start_method_waitstatus; 130 131 uint8_t enabled; 132 int temporary; 133 const char *restarter; 134 uu_list_t *dependencies; /* list of dependency_group's */ 135 136 char comment[SCF_COMMENT_MAX_LENGTH]; 137 138 int active; /* In use? (cycle detection) */ 139 int restarter_bad; 140 const char *summary; 141 uu_list_t *baddeps; /* list of dependency's */ 142 uu_list_t *causes; /* list of svcptrs */ 143 uu_list_t *impact_dependents; /* list of svcptrs */ 144 uu_list_t *impact; /* list of svcptrs */ 145 146 uu_list_node_t node; 147 } inst_t; 148 149 typedef struct service { 150 const char *svcname; 151 uu_list_t *instances; 152 struct service *next; 153 } svc_t; 154 155 struct svcptr { 156 inst_t *svcp; 157 inst_t *next_hop; 158 uu_list_node_t node; 159 }; 160 161 struct dependency_group { 162 enum { DGG_REQALL, DGG_REQANY, DGG_OPTALL, DGG_EXCALL } grouping; 163 const char *type; 164 uu_list_t *entities; /* List of struct dependency's */ 165 uu_list_node_t node; 166 }; 167 168 struct dependency { 169 const char *fmri; 170 uu_list_node_t node; 171 }; 172 173 /* Hash table of service names -> svc_t's */ 174 #define SVC_HASH_NBUCKETS 256 175 #define SVC_HASH_MASK (SVC_HASH_NBUCKETS - 1) 176 177 static svc_t **services; 178 179 static uu_list_pool_t *insts, *svcptrs, *depgroups, *deps; 180 static uu_list_t *g_causes; /* list of svcptrs */ 181 182 static scf_scope_t *g_local_scope; 183 static scf_service_t *g_svc; 184 static scf_instance_t *g_inst; 185 static scf_snapshot_t *g_snap; 186 static scf_propertygroup_t *g_pg; 187 static scf_property_t *g_prop; 188 static scf_value_t *g_val; 189 static scf_iter_t *g_iter, *g_viter; 190 static char *g_fmri, *g_value; 191 static size_t g_fmri_sz, g_value_sz; 192 static const char *g_msgbase = "http://illumos.org/msg/"; 193 194 static char *emsg_nomem; 195 static char *emsg_invalid_dep; 196 197 extern scf_handle_t *h; 198 extern char *g_zonename; 199 200 /* ARGSUSED */ 201 static int 202 svcptr_compare(struct svcptr *a, struct svcptr *b, void *data) 203 { 204 return (b->svcp - a->svcp); 205 } 206 207 static uint32_t 208 hash_name(const char *name) 209 { 210 uint32_t h = 0, g; 211 const char *p; 212 213 for (p = name; *p != '\0'; ++p) { 214 h = (h << 4) + *p; 215 if ((g = (h & 0xf0000000)) != 0) { 216 h ^= (g >> 24); 217 h ^= g; 218 } 219 } 220 221 return (h); 222 } 223 224 static void 225 x_init(void) 226 { 227 emsg_nomem = gettext("Out of memory.\n"); 228 emsg_invalid_dep = 229 gettext("svc:/%s:%s has invalid dependency \"%s\".\n"); 230 231 services = calloc(SVC_HASH_NBUCKETS, sizeof (*services)); 232 if (services == NULL) 233 uu_die(emsg_nomem); 234 235 insts = uu_list_pool_create("insts", sizeof (inst_t), 236 offsetof(inst_t, node), NULL, UU_LIST_POOL_DEBUG); 237 svcptrs = uu_list_pool_create("svcptrs", sizeof (struct svcptr), 238 offsetof(struct svcptr, node), (uu_compare_fn_t *)svcptr_compare, 239 UU_LIST_POOL_DEBUG); 240 depgroups = uu_list_pool_create("depgroups", 241 sizeof (struct dependency_group), 242 offsetof(struct dependency_group, node), NULL, UU_LIST_POOL_DEBUG); 243 deps = uu_list_pool_create("deps", sizeof (struct dependency), 244 offsetof(struct dependency, node), NULL, UU_LIST_POOL_DEBUG); 245 g_causes = uu_list_create(svcptrs, NULL, UU_LIST_DEBUG); 246 if (insts == NULL || svcptrs == NULL || depgroups == NULL || 247 deps == NULL || g_causes == NULL) 248 uu_die(emsg_nomem); 249 250 if ((g_local_scope = scf_scope_create(h)) == NULL || 251 (g_svc = scf_service_create(h)) == NULL || 252 (g_inst = scf_instance_create(h)) == NULL || 253 (g_snap = scf_snapshot_create(h)) == NULL || 254 (g_pg = scf_pg_create(h)) == NULL || 255 (g_prop = scf_property_create(h)) == NULL || 256 (g_val = scf_value_create(h)) == NULL || 257 (g_iter = scf_iter_create(h)) == NULL || 258 (g_viter = scf_iter_create(h)) == NULL) 259 scfdie(); 260 261 if (scf_handle_get_scope(h, SCF_SCOPE_LOCAL, g_local_scope) != 0) 262 scfdie(); 263 264 g_fmri_sz = max_scf_fmri_length + 1; 265 g_fmri = safe_malloc(g_fmri_sz); 266 267 g_value_sz = max_scf_value_length + 1; 268 g_value = safe_malloc(g_value_sz); 269 } 270 271 /* 272 * Repository loading routines. 273 */ 274 275 /* 276 * Returns 277 * 0 - success 278 * ECANCELED - inst was deleted 279 * EINVAL - inst is invalid 280 */ 281 static int 282 load_dependencies(inst_t *svcp, scf_instance_t *inst) 283 { 284 scf_snapshot_t *snap; 285 struct dependency_group *dg; 286 struct dependency *d; 287 int r; 288 289 assert(svcp->dependencies == NULL); 290 svcp->dependencies = uu_list_create(depgroups, svcp, UU_LIST_DEBUG); 291 if (svcp->dependencies == NULL) 292 uu_die(emsg_nomem); 293 294 if (scf_instance_get_snapshot(inst, "running", g_snap) == 0) { 295 snap = g_snap; 296 } else { 297 if (scf_error() != SCF_ERROR_NOT_FOUND) 298 scfdie(); 299 300 snap = NULL; 301 } 302 303 if (scf_iter_instance_pgs_typed_composed(g_iter, inst, snap, 304 SCF_GROUP_DEPENDENCY) != 0) { 305 if (scf_error() != SCF_ERROR_DELETED) 306 scfdie(); 307 return (ECANCELED); 308 } 309 310 for (;;) { 311 r = scf_iter_next_pg(g_iter, g_pg); 312 if (r == 0) 313 break; 314 if (r != 1) { 315 if (scf_error() != SCF_ERROR_DELETED) 316 scfdie(); 317 return (ECANCELED); 318 } 319 320 dg = safe_malloc(sizeof (*dg)); 321 (void) memset(dg, 0, sizeof (*dg)); 322 dg->entities = uu_list_create(deps, dg, UU_LIST_DEBUG); 323 if (dg->entities == NULL) 324 uu_die(emsg_nomem); 325 326 if (pg_get_single_val(g_pg, SCF_PROPERTY_GROUPING, 327 SCF_TYPE_ASTRING, g_value, g_value_sz, 0) != 0) 328 return (EINVAL); 329 330 if (strcmp(g_value, "require_all") == 0) 331 dg->grouping = DGG_REQALL; 332 else if (strcmp(g_value, "require_any") == 0) 333 dg->grouping = DGG_REQANY; 334 else if (strcmp(g_value, "optional_all") == 0) 335 dg->grouping = DGG_OPTALL; 336 else if (strcmp(g_value, "exclude_all") == 0) 337 dg->grouping = DGG_EXCALL; 338 else { 339 (void) fprintf(stderr, gettext("svc:/%s:%s has " 340 "dependency with unknown type \"%s\".\n"), 341 svcp->svcname, svcp->instname, g_value); 342 return (EINVAL); 343 } 344 345 if (pg_get_single_val(g_pg, SCF_PROPERTY_TYPE, SCF_TYPE_ASTRING, 346 g_value, g_value_sz, 0) != 0) 347 return (EINVAL); 348 dg->type = safe_strdup(g_value); 349 350 if (scf_pg_get_property(g_pg, SCF_PROPERTY_ENTITIES, g_prop) != 351 0) { 352 switch (scf_error()) { 353 case SCF_ERROR_NOT_FOUND: 354 (void) fprintf(stderr, gettext("svc:/%s:%s has " 355 "dependency without an entities " 356 "property.\n"), svcp->svcname, 357 svcp->instname); 358 return (EINVAL); 359 360 case SCF_ERROR_DELETED: 361 return (ECANCELED); 362 363 default: 364 scfdie(); 365 } 366 } 367 368 if (scf_iter_property_values(g_viter, g_prop) != 0) { 369 if (scf_error() != SCF_ERROR_DELETED) 370 scfdie(); 371 return (ECANCELED); 372 } 373 374 for (;;) { 375 r = scf_iter_next_value(g_viter, g_val); 376 if (r == 0) 377 break; 378 if (r != 1) { 379 if (scf_error() != SCF_ERROR_DELETED) 380 scfdie(); 381 return (ECANCELED); 382 } 383 384 d = safe_malloc(sizeof (*d)); 385 d->fmri = safe_malloc(max_scf_fmri_length + 1); 386 387 if (scf_value_get_astring(g_val, (char *)d->fmri, 388 max_scf_fmri_length + 1) < 0) 389 scfdie(); 390 391 uu_list_node_init(d, &d->node, deps); 392 (void) uu_list_append(dg->entities, d); 393 } 394 395 uu_list_node_init(dg, &dg->node, depgroups); 396 r = uu_list_append(svcp->dependencies, dg); 397 assert(r == 0); 398 } 399 400 return (0); 401 } 402 403 static void 404 add_instance(const char *svcname, const char *instname, scf_instance_t *inst) 405 { 406 inst_t *instp; 407 svc_t *svcp; 408 int ovr_set = 0; 409 uint8_t i; 410 uint32_t h; 411 int r; 412 413 h = hash_name(svcname) & SVC_HASH_MASK; 414 for (svcp = services[h]; svcp != NULL; svcp = svcp->next) { 415 if (strcmp(svcp->svcname, svcname) == 0) 416 break; 417 } 418 419 if (svcp == NULL) { 420 svcp = safe_malloc(sizeof (*svcp)); 421 svcp->svcname = safe_strdup(svcname); 422 svcp->instances = uu_list_create(insts, svcp, UU_LIST_DEBUG); 423 if (svcp->instances == NULL) 424 uu_die(emsg_nomem); 425 svcp->next = services[h]; 426 services[h] = svcp; 427 } 428 429 instp = safe_malloc(sizeof (*instp)); 430 (void) memset(instp, 0, sizeof (*instp)); 431 instp->svcname = svcp->svcname; 432 instp->instname = safe_strdup(instname); 433 instp->impact_dependents = 434 uu_list_create(svcptrs, instp, UU_LIST_DEBUG); 435 if (instp->impact_dependents == NULL) 436 uu_die(emsg_nomem); 437 438 if (scf_instance_get_pg(inst, SCF_PG_RESTARTER, g_pg) != 0) { 439 switch (scf_error()) { 440 case SCF_ERROR_DELETED: 441 return; 442 443 case SCF_ERROR_NOT_FOUND: 444 (void) fprintf(stderr, gettext("svc:/%s:%s has no " 445 "\"%s\" property group; ignoring.\n"), 446 instp->svcname, instp->instname, SCF_PG_RESTARTER); 447 return; 448 449 default: 450 scfdie(); 451 } 452 } 453 454 if (pg_get_single_val(g_pg, SCF_PROPERTY_STATE, SCF_TYPE_ASTRING, 455 (void *)instp->state, sizeof (instp->state), 0) != 0) 456 return; 457 458 if (pg_get_single_val(g_pg, SCF_PROPERTY_NEXT_STATE, SCF_TYPE_ASTRING, 459 (void *)instp->next_state, sizeof (instp->next_state), 0) != 0) 460 return; 461 462 if (pg_get_single_val(g_pg, SCF_PROPERTY_STATE_TIMESTAMP, 463 SCF_TYPE_TIME, &instp->stime, 0, 0) != 0) 464 return; 465 466 /* restarter may not set aux_state, allow to continue in that case */ 467 if (pg_get_single_val(g_pg, SCF_PROPERTY_AUX_STATE, SCF_TYPE_ASTRING, 468 g_fmri, g_fmri_sz, 0) == 0) 469 instp->aux_state = safe_strdup(g_fmri); 470 else 471 instp->aux_state = safe_strdup(AUX_STATE_INVALID); 472 473 (void) pg_get_single_val(g_pg, SCF_PROPERTY_START_METHOD_WAITSTATUS, 474 SCF_TYPE_INTEGER, &instp->start_method_waitstatus, 0, 0); 475 476 /* Get the optional auxiliary_fmri */ 477 if (pg_get_single_val(g_pg, SCF_PROPERTY_AUX_FMRI, SCF_TYPE_ASTRING, 478 g_fmri, g_fmri_sz, 0) == 0) 479 instp->aux_fmri = safe_strdup(g_fmri); 480 481 if (scf_instance_get_pg(inst, SCF_PG_GENERAL_OVR, g_pg) == 0) { 482 if (pg_get_single_val(g_pg, SCF_PROPERTY_ENABLED, 483 SCF_TYPE_BOOLEAN, &instp->enabled, 0, 0) == 0) 484 ovr_set = 1; 485 (void) pg_get_single_val(g_pg, SCF_PROPERTY_COMMENT, 486 SCF_TYPE_ASTRING, instp->comment, 487 sizeof (instp->comment), EMPTY_OK); 488 } else { 489 switch (scf_error()) { 490 case SCF_ERROR_NOT_FOUND: 491 break; 492 493 case SCF_ERROR_DELETED: 494 return; 495 496 default: 497 scfdie(); 498 } 499 } 500 501 if (scf_instance_get_pg_composed(inst, NULL, SCF_PG_GENERAL, g_pg) != 502 0) { 503 switch (scf_error()) { 504 case SCF_ERROR_DELETED: 505 case SCF_ERROR_NOT_FOUND: 506 return; 507 508 default: 509 scfdie(); 510 } 511 } 512 513 if (pg_get_single_val(g_pg, SCF_PROPERTY_ENABLED, SCF_TYPE_BOOLEAN, 514 &i, 0, 0) != 0) 515 return; 516 517 if (ovr_set) { 518 instp->temporary = (instp->enabled != i); 519 } else { 520 instp->enabled = i; 521 instp->temporary = 0; 522 } 523 524 if (!instp->temporary) { 525 (void) pg_get_single_val(g_pg, SCF_PROPERTY_COMMENT, 526 SCF_TYPE_ASTRING, instp->comment, 527 sizeof (instp->comment), EMPTY_OK); 528 } 529 530 if (pg_get_single_val(g_pg, SCF_PROPERTY_RESTARTER, SCF_TYPE_ASTRING, 531 g_fmri, g_fmri_sz, 0) == 0) 532 instp->restarter = safe_strdup(g_fmri); 533 else 534 instp->restarter = SCF_SERVICE_STARTD; 535 536 if (strcmp(instp->state, SCF_STATE_STRING_OFFLINE) == 0 && 537 load_dependencies(instp, inst) != 0) 538 return; 539 540 uu_list_node_init(instp, &instp->node, insts); 541 r = uu_list_append(svcp->instances, instp); 542 assert(r == 0); 543 } 544 545 static void 546 load_services(void) 547 { 548 scf_iter_t *siter, *iiter; 549 int r; 550 char *svcname, *instname; 551 552 if ((siter = scf_iter_create(h)) == NULL || 553 (iiter = scf_iter_create(h)) == NULL) 554 scfdie(); 555 556 svcname = safe_malloc(max_scf_name_length + 1); 557 instname = safe_malloc(max_scf_name_length + 1); 558 559 if (scf_iter_scope_services(siter, g_local_scope) != 0) 560 scfdie(); 561 562 for (;;) { 563 r = scf_iter_next_service(siter, g_svc); 564 if (r == 0) 565 break; 566 if (r != 1) 567 scfdie(); 568 569 if (scf_service_get_name(g_svc, svcname, 570 max_scf_name_length + 1) < 0) { 571 if (scf_error() != SCF_ERROR_DELETED) 572 scfdie(); 573 continue; 574 } 575 576 if (scf_iter_service_instances(iiter, g_svc) != 0) { 577 if (scf_error() != SCF_ERROR_DELETED) 578 scfdie(); 579 continue; 580 } 581 582 for (;;) { 583 r = scf_iter_next_instance(iiter, g_inst); 584 if (r == 0) 585 break; 586 if (r != 1) { 587 if (scf_error() != SCF_ERROR_DELETED) 588 scfdie(); 589 break; 590 } 591 592 if (scf_instance_get_name(g_inst, instname, 593 max_scf_name_length + 1) < 0) { 594 if (scf_error() != SCF_ERROR_DELETED) 595 scfdie(); 596 continue; 597 } 598 599 add_instance(svcname, instname, g_inst); 600 } 601 } 602 603 free(svcname); 604 free(instname); 605 scf_iter_destroy(siter); 606 scf_iter_destroy(iiter); 607 } 608 609 /* 610 * Dependency analysis routines. 611 */ 612 613 static void 614 add_svcptr(uu_list_t *lst, inst_t *svcp) 615 { 616 struct svcptr *spp; 617 uu_list_index_t idx; 618 int r; 619 620 spp = safe_malloc(sizeof (*spp)); 621 spp->svcp = svcp; 622 spp->next_hop = NULL; 623 624 if (uu_list_find(lst, spp, NULL, &idx) != NULL) { 625 free(spp); 626 return; 627 } 628 629 uu_list_node_init(spp, &spp->node, svcptrs); 630 r = uu_list_append(lst, spp); 631 assert(r == 0); 632 } 633 634 static int determine_causes(inst_t *, void *); 635 636 /* 637 * Determine the causes of src and add them to the causes list of dst. 638 * Returns ELOOP if src is active, and 0 otherwise. 639 */ 640 static int 641 add_causes(inst_t *dst, inst_t *src) 642 { 643 struct svcptr *spp, *copy; 644 uu_list_index_t idx; 645 646 if (determine_causes(src, (void *)1) != UU_WALK_NEXT) { 647 /* Dependency cycle. */ 648 (void) fprintf(stderr, " svc:/%s:%s\n", dst->svcname, 649 dst->instname); 650 return (ELOOP); 651 } 652 653 add_svcptr(src->impact_dependents, dst); 654 655 for (spp = uu_list_first(src->causes); 656 spp != NULL; 657 spp = uu_list_next(src->causes, spp)) { 658 if (uu_list_find(dst->causes, spp, NULL, &idx) != NULL) 659 continue; 660 661 copy = safe_malloc(sizeof (*copy)); 662 copy->svcp = spp->svcp; 663 copy->next_hop = src; 664 uu_list_node_init(copy, ©->node, svcptrs); 665 uu_list_insert(dst->causes, copy, idx); 666 667 add_svcptr(g_causes, spp->svcp); 668 } 669 670 return (0); 671 } 672 673 static int 674 inst_running(inst_t *ip) 675 { 676 return (strcmp(ip->state, SCF_STATE_STRING_ONLINE) == 0 || 677 strcmp(ip->state, SCF_STATE_STRING_DEGRADED) == 0); 678 } 679 680 static int 681 inst_running_or_maint(inst_t *ip) 682 { 683 return (inst_running(ip) || 684 strcmp(ip->state, SCF_STATE_STRING_MAINT) == 0); 685 } 686 687 static svc_t * 688 get_svc(const char *sn) 689 { 690 uint32_t h; 691 svc_t *svcp; 692 693 h = hash_name(sn) & SVC_HASH_MASK; 694 695 for (svcp = services[h]; svcp != NULL; svcp = svcp->next) { 696 if (strcmp(svcp->svcname, sn) == 0) 697 break; 698 } 699 700 return (svcp); 701 } 702 703 /* ARGSUSED */ 704 static inst_t * 705 get_inst(svc_t *svcp, const char *in) 706 { 707 inst_t *instp; 708 709 for (instp = uu_list_first(svcp->instances); 710 instp != NULL; 711 instp = uu_list_next(svcp->instances, instp)) { 712 if (strcmp(instp->instname, in) == 0) 713 return (instp); 714 } 715 716 return (NULL); 717 } 718 719 static int 720 get_fmri(const char *fmri, svc_t **spp, inst_t **ipp) 721 { 722 const char *sn, *in; 723 svc_t *sp; 724 inst_t *ip; 725 726 if (strlcpy(g_fmri, fmri, g_fmri_sz) >= g_fmri_sz) 727 return (EINVAL); 728 729 if (scf_parse_svc_fmri(g_fmri, NULL, &sn, &in, NULL, NULL) != 0) 730 return (EINVAL); 731 732 if (sn == NULL) 733 return (EINVAL); 734 735 sp = get_svc(sn); 736 if (sp == NULL) 737 return (ENOENT); 738 739 if (in != NULL) { 740 ip = get_inst(sp, in); 741 if (ip == NULL) 742 return (ENOENT); 743 } 744 745 if (spp != NULL) 746 *spp = sp; 747 if (ipp != NULL) 748 *ipp = ((in == NULL) ? NULL : ip); 749 750 return (0); 751 } 752 753 static int 754 process_reqall(inst_t *svcp, struct dependency_group *dg) 755 { 756 uu_list_walk_t *walk; 757 struct dependency *d; 758 int r, svcrunning; 759 svc_t *sp; 760 inst_t *ip; 761 762 walk = uu_list_walk_start(dg->entities, UU_WALK_ROBUST); 763 if (walk == NULL) 764 uu_die(emsg_nomem); 765 766 while ((d = uu_list_walk_next(walk)) != NULL) { 767 r = get_fmri(d->fmri, &sp, &ip); 768 switch (r) { 769 case EINVAL: 770 /* LINTED */ 771 (void) fprintf(stderr, emsg_invalid_dep, svcp->svcname, 772 svcp->instname, d->fmri); 773 continue; 774 775 case ENOENT: 776 uu_list_remove(dg->entities, d); 777 r = uu_list_append(svcp->baddeps, d); 778 assert(r == 0); 779 continue; 780 781 case 0: 782 break; 783 784 default: 785 bad_error("get_fmri", r); 786 } 787 788 if (ip != NULL) { 789 if (inst_running(ip)) 790 continue; 791 r = add_causes(svcp, ip); 792 if (r != 0) { 793 assert(r == ELOOP); 794 return (r); 795 } 796 continue; 797 } 798 799 svcrunning = 0; 800 801 for (ip = uu_list_first(sp->instances); 802 ip != NULL; 803 ip = uu_list_next(sp->instances, ip)) { 804 if (inst_running(ip)) 805 svcrunning = 1; 806 } 807 808 if (!svcrunning) { 809 for (ip = uu_list_first(sp->instances); 810 ip != NULL; 811 ip = uu_list_next(sp->instances, ip)) { 812 r = add_causes(svcp, ip); 813 if (r != 0) { 814 assert(r == ELOOP); 815 uu_list_walk_end(walk); 816 return (r); 817 } 818 } 819 } 820 } 821 822 uu_list_walk_end(walk); 823 return (0); 824 } 825 826 static int 827 process_reqany(inst_t *svcp, struct dependency_group *dg) 828 { 829 svc_t *sp; 830 inst_t *ip; 831 struct dependency *d; 832 int r; 833 uu_list_walk_t *walk; 834 835 for (d = uu_list_first(dg->entities); 836 d != NULL; 837 d = uu_list_next(dg->entities, d)) { 838 r = get_fmri(d->fmri, &sp, &ip); 839 switch (r) { 840 case 0: 841 break; 842 843 case EINVAL: 844 /* LINTED */ 845 (void) fprintf(stderr, emsg_invalid_dep, svcp->svcname, 846 svcp->instname, d->fmri); 847 continue; 848 849 case ENOENT: 850 continue; 851 852 default: 853 bad_error("eval_svc_dep", r); 854 } 855 856 if (ip != NULL) { 857 if (inst_running(ip)) 858 return (0); 859 continue; 860 } 861 862 for (ip = uu_list_first(sp->instances); 863 ip != NULL; 864 ip = uu_list_next(sp->instances, ip)) { 865 if (inst_running(ip)) 866 return (0); 867 } 868 } 869 870 /* 871 * The dependency group is not satisfied. Add all unsatisfied members 872 * to the cause list. 873 */ 874 875 walk = uu_list_walk_start(dg->entities, UU_WALK_ROBUST); 876 if (walk == NULL) 877 uu_die(emsg_nomem); 878 879 while ((d = uu_list_walk_next(walk)) != NULL) { 880 r = get_fmri(d->fmri, &sp, &ip); 881 switch (r) { 882 case 0: 883 break; 884 885 case ENOENT: 886 uu_list_remove(dg->entities, d); 887 r = uu_list_append(svcp->baddeps, d); 888 assert(r == 0); 889 continue; 890 891 case EINVAL: 892 /* Should have caught above. */ 893 default: 894 bad_error("eval_svc_dep", r); 895 } 896 897 if (ip != NULL) { 898 if (inst_running(ip)) 899 continue; 900 r = add_causes(svcp, ip); 901 if (r != 0) { 902 assert(r == ELOOP); 903 return (r); 904 } 905 continue; 906 } 907 908 for (ip = uu_list_first(sp->instances); 909 ip != NULL; 910 ip = uu_list_next(sp->instances, ip)) { 911 if (inst_running(ip)) 912 continue; 913 r = add_causes(svcp, ip); 914 if (r != 0) { 915 assert(r == ELOOP); 916 return (r); 917 } 918 } 919 } 920 921 return (0); 922 } 923 924 static int 925 process_optall(inst_t *svcp, struct dependency_group *dg) 926 { 927 uu_list_walk_t *walk; 928 struct dependency *d; 929 int r; 930 inst_t *ip; 931 svc_t *sp; 932 933 walk = uu_list_walk_start(dg->entities, UU_WALK_ROBUST); 934 if (walk == NULL) 935 uu_die(emsg_nomem); 936 937 while ((d = uu_list_walk_next(walk)) != NULL) { 938 r = get_fmri(d->fmri, &sp, &ip); 939 940 switch (r) { 941 case 0: 942 break; 943 944 case EINVAL: 945 /* LINTED */ 946 (void) fprintf(stderr, emsg_invalid_dep, svcp->svcname, 947 svcp->instname, d->fmri); 948 continue; 949 950 case ENOENT: 951 continue; 952 953 default: 954 bad_error("get_fmri", r); 955 } 956 957 if (ip != NULL) { 958 if ((ip->enabled != 0) && !inst_running_or_maint(ip)) { 959 r = add_causes(svcp, ip); 960 if (r != 0) { 961 assert(r == ELOOP); 962 uu_list_walk_end(walk); 963 return (r); 964 } 965 } 966 continue; 967 } 968 969 for (ip = uu_list_first(sp->instances); 970 ip != NULL; 971 ip = uu_list_next(sp->instances, ip)) { 972 if ((ip->enabled != 0) && !inst_running_or_maint(ip)) { 973 r = add_causes(svcp, ip); 974 if (r != 0) { 975 assert(r == ELOOP); 976 uu_list_walk_end(walk); 977 return (r); 978 } 979 } 980 } 981 } 982 983 uu_list_walk_end(walk); 984 return (0); 985 } 986 987 static int 988 process_excall(inst_t *svcp, struct dependency_group *dg) 989 { 990 struct dependency *d; 991 int r; 992 svc_t *sp; 993 inst_t *ip; 994 995 for (d = uu_list_first(dg->entities); 996 d != NULL; 997 d = uu_list_next(dg->entities, d)) { 998 r = get_fmri(d->fmri, &sp, &ip); 999 1000 switch (r) { 1001 case 0: 1002 break; 1003 1004 case EINVAL: 1005 /* LINTED */ 1006 (void) fprintf(stderr, emsg_invalid_dep, svcp->svcname, 1007 svcp->instname, d->fmri); 1008 continue; 1009 1010 case ENOENT: 1011 continue; 1012 1013 default: 1014 bad_error("eval_svc_dep", r); 1015 } 1016 1017 if (ip != NULL) { 1018 if (inst_running(ip)) { 1019 r = add_causes(svcp, ip); 1020 if (r != 0) { 1021 assert(r == ELOOP); 1022 return (r); 1023 } 1024 } 1025 continue; 1026 } 1027 1028 for (ip = uu_list_first(sp->instances); 1029 ip != NULL; 1030 ip = uu_list_next(sp->instances, ip)) { 1031 if (inst_running(ip)) { 1032 r = add_causes(svcp, ip); 1033 if (r != 0) { 1034 assert(r == ELOOP); 1035 return (r); 1036 } 1037 } 1038 } 1039 } 1040 1041 return (0); 1042 } 1043 1044 static int 1045 process_svc_dg(inst_t *svcp, struct dependency_group *dg) 1046 { 1047 switch (dg->grouping) { 1048 case DGG_REQALL: 1049 return (process_reqall(svcp, dg)); 1050 1051 case DGG_REQANY: 1052 return (process_reqany(svcp, dg)); 1053 1054 case DGG_OPTALL: 1055 return (process_optall(svcp, dg)); 1056 1057 case DGG_EXCALL: 1058 return (process_excall(svcp, dg)); 1059 1060 default: 1061 #ifndef NDEBUG 1062 (void) fprintf(stderr, 1063 "%s:%d: Unknown dependency grouping %d.\n", __FILE__, 1064 __LINE__, dg->grouping); 1065 #endif 1066 abort(); 1067 /* NOTREACHED */ 1068 } 1069 } 1070 1071 /* 1072 * Returns 1073 * EINVAL - fmri is not a valid FMRI 1074 * 0 - the file indicated by fmri is missing 1075 * 1 - the file indicated by fmri is present 1076 */ 1077 static int 1078 eval_file_dep(const char *fmri) 1079 { 1080 const char *path; 1081 struct stat st; 1082 1083 if (strncmp(fmri, "file:", sizeof ("file:") - 1) != 0) 1084 return (EINVAL); 1085 1086 path = fmri + (sizeof ("file:") - 1); 1087 1088 if (path[0] != '/') 1089 return (EINVAL); 1090 1091 if (path[1] == '/') { 1092 path += 2; 1093 if (strncmp(path, "localhost/", sizeof ("localhost/") - 1) == 0) 1094 path += sizeof ("localhost") - 1; 1095 else if (path[0] != '/') 1096 return (EINVAL); 1097 } 1098 1099 return (stat(path, &st) == 0 ? 1 : 0); 1100 } 1101 1102 static void 1103 process_file_dg(inst_t *svcp, struct dependency_group *dg) 1104 { 1105 uu_list_walk_t *walk; 1106 struct dependency *d, **deps; 1107 int r, i = 0, any_satisfied = 0; 1108 1109 if (dg->grouping == DGG_REQANY) { 1110 deps = calloc(uu_list_numnodes(dg->entities), sizeof (*deps)); 1111 if (deps == NULL) 1112 uu_die(emsg_nomem); 1113 } 1114 1115 walk = uu_list_walk_start(dg->entities, UU_WALK_ROBUST); 1116 if (walk == NULL) 1117 uu_die(emsg_nomem); 1118 1119 while ((d = uu_list_walk_next(walk)) != NULL) { 1120 r = eval_file_dep(d->fmri); 1121 if (r == EINVAL) { 1122 /* LINTED */ 1123 (void) fprintf(stderr, emsg_invalid_dep, svcp->svcname, 1124 svcp->instname, d->fmri); 1125 continue; 1126 } 1127 1128 assert(r == 0 || r == 1); 1129 1130 switch (dg->grouping) { 1131 case DGG_REQALL: 1132 case DGG_OPTALL: 1133 if (r == 0) { 1134 uu_list_remove(dg->entities, d); 1135 r = uu_list_append(svcp->baddeps, d); 1136 assert(r == 0); 1137 } 1138 break; 1139 1140 case DGG_REQANY: 1141 if (r == 1) 1142 any_satisfied = 1; 1143 else 1144 deps[i++] = d; 1145 break; 1146 1147 case DGG_EXCALL: 1148 if (r == 1) { 1149 uu_list_remove(dg->entities, d); 1150 r = uu_list_append(svcp->baddeps, d); 1151 assert(r == 0); 1152 } 1153 break; 1154 1155 default: 1156 #ifndef NDEBUG 1157 (void) fprintf(stderr, "%s:%d: Unknown grouping %d.\n", 1158 __FILE__, __LINE__, dg->grouping); 1159 #endif 1160 abort(); 1161 } 1162 } 1163 1164 uu_list_walk_end(walk); 1165 1166 if (dg->grouping != DGG_REQANY) 1167 return; 1168 1169 if (!any_satisfied) { 1170 while (--i >= 0) { 1171 uu_list_remove(dg->entities, deps[i]); 1172 r = uu_list_append(svcp->baddeps, deps[i]); 1173 assert(r == 0); 1174 } 1175 } 1176 1177 free(deps); 1178 } 1179 1180 /* 1181 * Populate the causes list of svcp. This function should not return with 1182 * causes empty. 1183 */ 1184 static int 1185 determine_causes(inst_t *svcp, void *canfailp) 1186 { 1187 struct dependency_group *dg; 1188 int r; 1189 1190 if (svcp->active) { 1191 (void) fprintf(stderr, gettext("Dependency cycle detected:\n" 1192 " svc:/%s:%s\n"), svcp->svcname, svcp->instname); 1193 return ((int)canfailp != 0 ? UU_WALK_ERROR : UU_WALK_NEXT); 1194 } 1195 1196 if (svcp->causes != NULL) 1197 return (UU_WALK_NEXT); 1198 1199 svcp->causes = uu_list_create(svcptrs, svcp, UU_LIST_DEBUG); 1200 svcp->baddeps = uu_list_create(deps, svcp, UU_LIST_DEBUG); 1201 if (svcp->causes == NULL || svcp->baddeps == NULL) 1202 uu_die(emsg_nomem); 1203 1204 if (inst_running(svcp) || 1205 strcmp(svcp->state, SCF_STATE_STRING_UNINIT) == 0) { 1206 /* 1207 * If we're running, add a self-pointer in case we're 1208 * excluding another service. 1209 */ 1210 add_svcptr(svcp->causes, svcp); 1211 return (UU_WALK_NEXT); 1212 } 1213 1214 if (strcmp(svcp->state, SCF_STATE_STRING_MAINT) == 0) { 1215 add_svcptr(svcp->causes, svcp); 1216 add_svcptr(g_causes, svcp); 1217 return (UU_WALK_NEXT); 1218 } 1219 1220 if (strcmp(svcp->state, SCF_STATE_STRING_DISABLED) == 0) { 1221 add_svcptr(svcp->causes, svcp); 1222 if (svcp->enabled != 0) 1223 add_svcptr(g_causes, svcp); 1224 1225 return (UU_WALK_NEXT); 1226 } 1227 1228 if (strcmp(svcp->state, SCF_STATE_STRING_OFFLINE) != 0) { 1229 (void) fprintf(stderr, 1230 gettext("svc:/%s:%s has invalid state \"%s\".\n"), 1231 svcp->svcname, svcp->instname, svcp->state); 1232 add_svcptr(svcp->causes, svcp); 1233 add_svcptr(g_causes, svcp); 1234 return (UU_WALK_NEXT); 1235 } 1236 1237 if (strcmp(svcp->next_state, SCF_STATE_STRING_NONE) != 0) { 1238 add_svcptr(svcp->causes, svcp); 1239 add_svcptr(g_causes, svcp); 1240 return (UU_WALK_NEXT); 1241 } 1242 1243 svcp->active = 1; 1244 1245 /* 1246 * Dependency analysis can add elements to our baddeps list (absent 1247 * dependency, unsatisfied file dependency), or to our cause list 1248 * (unsatisfied dependency). 1249 */ 1250 for (dg = uu_list_first(svcp->dependencies); 1251 dg != NULL; 1252 dg = uu_list_next(svcp->dependencies, dg)) { 1253 if (strcmp(dg->type, "path") == 0) { 1254 process_file_dg(svcp, dg); 1255 } else if (strcmp(dg->type, "service") == 0) { 1256 int r; 1257 1258 r = process_svc_dg(svcp, dg); 1259 if (r != 0) { 1260 assert(r == ELOOP); 1261 svcp->active = 0; 1262 return ((int)canfailp != 0 ? 1263 UU_WALK_ERROR : UU_WALK_NEXT); 1264 } 1265 } else { 1266 (void) fprintf(stderr, gettext("svc:/%s:%s has " 1267 "dependency group with invalid type \"%s\".\n"), 1268 svcp->svcname, svcp->instname, dg->type); 1269 } 1270 } 1271 1272 if (uu_list_numnodes(svcp->causes) == 0) { 1273 if (uu_list_numnodes(svcp->baddeps) > 0) { 1274 add_svcptr(g_causes, svcp); 1275 add_svcptr(svcp->causes, svcp); 1276 } else { 1277 inst_t *restarter; 1278 1279 r = get_fmri(svcp->restarter, NULL, &restarter); 1280 if (r == 0 && !inst_running(restarter)) { 1281 r = add_causes(svcp, restarter); 1282 if (r != 0) { 1283 assert(r == ELOOP); 1284 svcp->active = 0; 1285 return ((int)canfailp != 0 ? 1286 UU_WALK_ERROR : UU_WALK_NEXT); 1287 } 1288 } else { 1289 svcp->restarter_bad = r; 1290 add_svcptr(svcp->causes, svcp); 1291 add_svcptr(g_causes, svcp); 1292 } 1293 } 1294 } 1295 1296 assert(uu_list_numnodes(svcp->causes) > 0); 1297 1298 svcp->active = 0; 1299 return (UU_WALK_NEXT); 1300 } 1301 1302 static void 1303 determine_all_causes(void) 1304 { 1305 svc_t *svcp; 1306 int i; 1307 1308 for (i = 0; i < SVC_HASH_NBUCKETS; ++i) { 1309 for (svcp = services[i]; svcp != NULL; svcp = svcp->next) 1310 (void) uu_list_walk(svcp->instances, 1311 (uu_walk_fn_t *)determine_causes, 0, 0); 1312 } 1313 } 1314 1315 /* 1316 * Returns 1317 * 0 - success 1318 * ELOOP - dependency cycle detected 1319 */ 1320 static int 1321 determine_impact(inst_t *ip) 1322 { 1323 struct svcptr *idsp, *spp, *copy; 1324 uu_list_index_t idx; 1325 1326 if (ip->active) { 1327 (void) fprintf(stderr, gettext("Dependency cycle detected:\n" 1328 " svc:/%s:%s\n"), ip->svcname, ip->instname); 1329 return (ELOOP); 1330 } 1331 1332 if (ip->impact != NULL) 1333 return (0); 1334 1335 ip->impact = uu_list_create(svcptrs, ip, UU_LIST_DEBUG); 1336 if (ip->impact == NULL) 1337 uu_die(emsg_nomem); 1338 ip->active = 1; 1339 1340 for (idsp = uu_list_first(ip->impact_dependents); 1341 idsp != NULL; 1342 idsp = uu_list_next(ip->impact_dependents, idsp)) { 1343 if (determine_impact(idsp->svcp) != 0) { 1344 (void) fprintf(stderr, " svc:/%s:%s\n", 1345 ip->svcname, ip->instname); 1346 return (ELOOP); 1347 } 1348 1349 add_svcptr(ip->impact, idsp->svcp); 1350 1351 for (spp = uu_list_first(idsp->svcp->impact); 1352 spp != NULL; 1353 spp = uu_list_next(idsp->svcp->impact, spp)) { 1354 if (uu_list_find(ip->impact, spp, NULL, &idx) != NULL) 1355 continue; 1356 1357 copy = safe_malloc(sizeof (*copy)); 1358 copy->svcp = spp->svcp; 1359 copy->next_hop = NULL; 1360 uu_list_node_init(copy, ©->node, svcptrs); 1361 uu_list_insert(ip->impact, copy, idx); 1362 } 1363 } 1364 1365 ip->active = 0; 1366 return (0); 1367 } 1368 1369 /* 1370 * Printing routines. 1371 */ 1372 1373 static void 1374 check_msgbase(void) 1375 { 1376 if (scf_handle_decode_fmri(h, SCF_SERVICE_STARTD, NULL, NULL, g_inst, 1377 NULL, NULL, SCF_DECODE_FMRI_EXACT) != 0) { 1378 if (scf_error() != SCF_ERROR_NOT_FOUND) 1379 scfdie(); 1380 1381 return; 1382 } 1383 1384 if (scf_instance_get_pg_composed(g_inst, NULL, "msg", g_pg) != 0) { 1385 switch (scf_error()) { 1386 case SCF_ERROR_NOT_FOUND: 1387 case SCF_ERROR_DELETED: 1388 return; 1389 1390 default: 1391 scfdie(); 1392 } 1393 } 1394 1395 if (scf_pg_get_property(g_pg, "base", g_prop) != 0) { 1396 switch (scf_error()) { 1397 case SCF_ERROR_NOT_FOUND: 1398 case SCF_ERROR_DELETED: 1399 return; 1400 1401 default: 1402 scfdie(); 1403 } 1404 } 1405 1406 if (scf_property_get_value(g_prop, g_val) != 0) { 1407 switch (scf_error()) { 1408 case SCF_ERROR_NOT_FOUND: 1409 case SCF_ERROR_CONSTRAINT_VIOLATED: 1410 case SCF_ERROR_PERMISSION_DENIED: 1411 g_msgbase = NULL; 1412 return; 1413 1414 case SCF_ERROR_DELETED: 1415 return; 1416 1417 default: 1418 scfdie(); 1419 } 1420 } 1421 1422 if (scf_value_get_astring(g_val, g_value, g_value_sz) < 0) { 1423 if (scf_error() != SCF_ERROR_TYPE_MISMATCH) 1424 scfdie(); 1425 return; 1426 } 1427 1428 g_msgbase = safe_strdup(g_value); 1429 } 1430 1431 static void 1432 determine_summary(inst_t *ip) 1433 { 1434 if (ip->summary != NULL) 1435 return; 1436 1437 if (inst_running(ip)) { 1438 ip->summary = gettext("is running."); 1439 return; 1440 } 1441 1442 if (strcmp(ip->state, SCF_STATE_STRING_UNINIT) == 0) { 1443 ip->summary = gettext("is uninitialized."); 1444 } else if (strcmp(ip->state, SCF_STATE_STRING_DISABLED) == 0) { 1445 if (!ip->temporary) 1446 ip->summary = gettext("is disabled."); 1447 else 1448 ip->summary = gettext("is temporarily disabled."); 1449 } else if (strcmp(ip->state, SCF_STATE_STRING_OFFLINE) == 0) { 1450 if (uu_list_numnodes(ip->baddeps) != 0) 1451 ip->summary = gettext("has missing dependencies."); 1452 else if (strcmp(ip->next_state, SCF_STATE_STRING_ONLINE) == 0) 1453 ip->summary = gettext("is starting."); 1454 else 1455 ip->summary = gettext("is offline."); 1456 } else if (strcmp(ip->state, SCF_STATE_STRING_MAINT) == 0) { 1457 if (strcmp(ip->aux_state, "administrative_request") == 0) { 1458 ip->summary = gettext("was taken down for maintenace " 1459 "by an administrator."); 1460 } else if (strcmp(ip->aux_state, "dependency_cycle") == 0) { 1461 ip->summary = gettext("completed a dependency cycle."); 1462 } else if (strcmp(ip->aux_state, "fault_threshold_reached") == 1463 0) { 1464 ip->summary = gettext("is not running because " 1465 "a method failed repeatedly."); 1466 } else if (strcmp(ip->aux_state, "invalid_dependency") == 0) { 1467 ip->summary = gettext("has an invalid dependency."); 1468 } else if (strcmp(ip->aux_state, "invalid_restarter") == 0) { 1469 ip->summary = gettext("has an invalid restarter."); 1470 } else if (strcmp(ip->aux_state, "method_failed") == 0) { 1471 ip->summary = gettext("is not running because " 1472 "a method failed."); 1473 } else if (strcmp(ip->aux_state, "none") == 0) { 1474 ip->summary = 1475 gettext("is not running for an unknown reason."); 1476 } else if (strcmp(ip->aux_state, "restarting_too_quickly") == 1477 0) { 1478 ip->summary = gettext("was restarting too quickly."); 1479 } else { 1480 ip->summary = gettext("requires maintenance."); 1481 } 1482 } else { 1483 ip->summary = gettext("is in an invalid state."); 1484 } 1485 } 1486 1487 static void 1488 print_method_failure(const inst_t *ip, const char **dcp) 1489 { 1490 char buf[50]; 1491 int stat = ip->start_method_waitstatus; 1492 1493 if (stat != 0) { 1494 if (WIFEXITED(stat)) { 1495 if (WEXITSTATUS(stat) == SMF_EXIT_ERR_CONFIG) { 1496 (void) strlcpy(buf, gettext( 1497 "exited with $SMF_EXIT_ERR_CONFIG"), 1498 sizeof (buf)); 1499 } else if (WEXITSTATUS(stat) == SMF_EXIT_ERR_FATAL) { 1500 (void) strlcpy(buf, gettext( 1501 "exited with $SMF_EXIT_ERR_FATAL"), 1502 sizeof (buf)); 1503 } else { 1504 (void) snprintf(buf, sizeof (buf), 1505 gettext("exited with status %d"), 1506 WEXITSTATUS(stat)); 1507 } 1508 } else if (WIFSIGNALED(stat)) { 1509 if (WCOREDUMP(stat)) { 1510 if (strsignal(WTERMSIG(stat)) != NULL) 1511 (void) snprintf(buf, sizeof (buf), 1512 gettext("dumped core on %s (%d)"), 1513 strsignal(WTERMSIG(stat)), 1514 WTERMSIG(stat)); 1515 else 1516 (void) snprintf(buf, sizeof (buf), 1517 gettext("dumped core signal %d"), 1518 WTERMSIG(stat)); 1519 } else { 1520 if (strsignal(WTERMSIG(stat)) != NULL) { 1521 (void) snprintf(buf, sizeof (buf), 1522 gettext("died on %s (%d)"), 1523 strsignal(WTERMSIG(stat)), 1524 WTERMSIG(stat)); 1525 } else { 1526 (void) snprintf(buf, sizeof (buf), 1527 gettext("died on signal %d"), 1528 WTERMSIG(stat)); 1529 } 1530 } 1531 } else { 1532 goto fail; 1533 } 1534 1535 if (strcmp(ip->aux_state, "fault_threshold_reached") != 0) 1536 (void) printf(gettext("Reason: Start method %s.\n"), 1537 buf); 1538 else 1539 (void) printf(gettext("Reason: " 1540 "Start method failed repeatedly, last %s.\n"), buf); 1541 *dcp = DC_STARTFAIL; 1542 } else { 1543 fail: 1544 if (strcmp(ip->aux_state, "fault_threshold_reached") == 0) 1545 (void) puts(gettext( 1546 "Reason: Method failed repeatedly.")); 1547 else 1548 (void) puts(gettext("Reason: Method failed.")); 1549 *dcp = DC_METHFAIL; 1550 } 1551 } 1552 1553 static void 1554 print_dependency_reasons(const inst_t *svcp, int verbose) 1555 { 1556 struct dependency *d; 1557 struct svcptr *spp; 1558 const char *dc; 1559 1560 /* 1561 * If we couldn't determine why the service is offline, then baddeps 1562 * will be empty and causes will have a pointer to self. 1563 */ 1564 if (uu_list_numnodes(svcp->baddeps) == 0 && 1565 uu_list_numnodes(svcp->causes) == 1) { 1566 spp = uu_list_first(svcp->causes); 1567 if (spp->svcp == svcp) { 1568 switch (svcp->restarter_bad) { 1569 case 0: 1570 (void) puts(gettext("Reason: Unknown.")); 1571 dc = DC_UNKNOWN; 1572 break; 1573 1574 case EINVAL: 1575 (void) printf(gettext("Reason: " 1576 "Restarter \"%s\" is invalid.\n"), 1577 svcp->restarter); 1578 dc = DC_RSTRINVALID; 1579 break; 1580 1581 case ENOENT: 1582 (void) printf(gettext("Reason: " 1583 "Restarter \"%s\" does not exist.\n"), 1584 svcp->restarter); 1585 dc = DC_RSTRABSENT; 1586 break; 1587 1588 default: 1589 #ifndef NDEBUG 1590 (void) fprintf(stderr, "%s:%d: Bad " 1591 "restarter_bad value %d. Aborting.\n", 1592 __FILE__, __LINE__, svcp->restarter_bad); 1593 #endif 1594 abort(); 1595 } 1596 1597 if (g_msgbase) 1598 (void) printf(gettext(" See: %s%s\n"), 1599 g_msgbase, dc); 1600 return; 1601 } 1602 } 1603 1604 for (d = uu_list_first(svcp->baddeps); 1605 d != NULL; 1606 d = uu_list_next(svcp->baddeps, d)) { 1607 (void) printf(gettext("Reason: Dependency %s is absent.\n"), 1608 d->fmri); 1609 if (g_msgbase) 1610 (void) printf(gettext(" See: %s%s\n"), g_msgbase, 1611 DC_DEPABSENT); 1612 } 1613 1614 for (spp = uu_list_first(svcp->causes); 1615 spp != NULL && spp->svcp != svcp; 1616 spp = uu_list_next(svcp->causes, spp)) { 1617 determine_summary(spp->svcp); 1618 1619 if (inst_running(spp->svcp)) { 1620 (void) printf(gettext("Reason: " 1621 "Service svc:/%s:%s is running.\n"), 1622 spp->svcp->svcname, spp->svcp->instname); 1623 dc = DC_DEPRUNNING; 1624 } else { 1625 if (snprintf(NULL, 0, 1626 gettext("Reason: Service svc:/%s:%s %s"), 1627 spp->svcp->svcname, spp->svcp->instname, 1628 spp->svcp->summary) <= 80) { 1629 (void) printf(gettext( 1630 "Reason: Service svc:/%s:%s %s\n"), 1631 spp->svcp->svcname, spp->svcp->instname, 1632 spp->svcp->summary); 1633 } else { 1634 (void) printf(gettext( 1635 "Reason: Service svc:/%s:%s\n" 1636 " %s\n"), spp->svcp->svcname, 1637 spp->svcp->instname, spp->svcp->summary); 1638 } 1639 1640 dc = DC_DEPOTHER; 1641 } 1642 1643 if (g_msgbase != NULL) 1644 (void) printf(gettext(" See: %s%s\n"), g_msgbase, dc); 1645 1646 if (verbose) { 1647 inst_t *pp; 1648 int indent; 1649 1650 (void) printf(gettext(" Path: svc:/%s:%s\n"), 1651 svcp->svcname, svcp->instname); 1652 1653 indent = 1; 1654 for (pp = spp->next_hop; ; ) { 1655 struct svcptr *tmp; 1656 1657 (void) printf(gettext("%6s %*ssvc:/%s:%s\n"), 1658 "", indent++ * 2, "", pp->svcname, 1659 pp->instname); 1660 1661 if (pp == spp->svcp) 1662 break; 1663 1664 /* set pp to next_hop of cause with same svcp */ 1665 tmp = uu_list_find(pp->causes, spp, NULL, NULL); 1666 pp = tmp->next_hop; 1667 } 1668 } 1669 } 1670 } 1671 1672 static void 1673 print_logs(scf_instance_t *inst) 1674 { 1675 if (scf_instance_get_pg(inst, SCF_PG_RESTARTER, g_pg) != 0) 1676 return; 1677 1678 if (pg_get_single_val(g_pg, SCF_PROPERTY_ALT_LOGFILE, 1679 SCF_TYPE_ASTRING, (void *)g_value, g_value_sz, 0) == 0) 1680 (void) printf(gettext(" See: %s\n"), g_value); 1681 1682 if (pg_get_single_val(g_pg, SCF_PROPERTY_LOGFILE, 1683 SCF_TYPE_ASTRING, (void *)g_value, g_value_sz, 0) == 0) 1684 (void) printf(gettext(" See: %s\n"), g_value); 1685 } 1686 1687 static void 1688 print_aux_fmri_logs(const char *fmri) 1689 { 1690 scf_instance_t *scf_inst = scf_instance_create(h); 1691 if (scf_inst == NULL) 1692 return; 1693 1694 if (scf_handle_decode_fmri(h, fmri, NULL, NULL, scf_inst, 1695 NULL, NULL, SCF_DECODE_FMRI_EXACT) == 0) 1696 print_logs(scf_inst); 1697 1698 scf_instance_destroy(scf_inst); 1699 } 1700 1701 static void 1702 print_reasons(const inst_t *svcp, int verbose) 1703 { 1704 int r; 1705 const char *dc = NULL; 1706 1707 if (strcmp(svcp->state, SCF_STATE_STRING_ONLINE) == 0) 1708 return; 1709 1710 if (strcmp(svcp->state, SCF_STATE_STRING_UNINIT) == 0) { 1711 inst_t *rsp; 1712 1713 r = get_fmri(svcp->restarter, NULL, &rsp); 1714 switch (r) { 1715 case 0: 1716 if (rsp != NULL) 1717 break; 1718 /* FALLTHROUGH */ 1719 1720 case EINVAL: 1721 (void) printf(gettext("Reason: " 1722 "Restarter \"%s\" is invalid.\n"), svcp->restarter); 1723 dc = DC_RSTRINVALID; 1724 goto diagcode; 1725 1726 case ENOENT: 1727 (void) printf(gettext("Reason: " 1728 "Restarter \"%s\" does not exist.\n"), 1729 svcp->restarter); 1730 dc = DC_RSTRABSENT; 1731 goto diagcode; 1732 1733 default: 1734 bad_error("get_fmri", r); 1735 } 1736 1737 if (inst_running(rsp)) { 1738 (void) printf(gettext("Reason: Restarter %s " 1739 "has not initialized service state.\n"), 1740 svcp->restarter); 1741 dc = DC_UNINIT; 1742 } else { 1743 (void) printf(gettext( 1744 "Reason: Restarter %s is not running.\n"), 1745 svcp->restarter); 1746 dc = DC_RSTRDEAD; 1747 } 1748 1749 } else if (strcmp(svcp->state, SCF_STATE_STRING_DISABLED) == 0) { 1750 if (!svcp->temporary) { 1751 if (svcp->comment[0] != '\0') { 1752 (void) printf(gettext("Reason: Disabled by " 1753 "an administrator: %s\n"), svcp->comment); 1754 } else { 1755 (void) printf(gettext("Reason: Disabled by " 1756 "an administrator.\n")); 1757 } 1758 dc = DC_DISABLED; 1759 } else { 1760 if (svcp->comment[0] != '\0') { 1761 (void) printf(gettext("Reason: Temporarily " 1762 "disabled by an administrator: %s\n"), 1763 svcp->comment); 1764 } else { 1765 (void) printf(gettext("Reason: Temporarily " 1766 "disabled by an administrator.\n")); 1767 } 1768 dc = DC_TEMPDISABLED; 1769 } 1770 1771 } else if (strcmp(svcp->state, SCF_STATE_STRING_MAINT) == 0) { 1772 if (strcmp(svcp->aux_state, "administrative_request") == 0) { 1773 (void) puts(gettext("Reason: " 1774 "Maintenance requested by an administrator.")); 1775 dc = DC_ADMINMAINT; 1776 } else if (strcmp(svcp->aux_state, "dependency_cycle") == 0) { 1777 (void) puts(gettext( 1778 "Reason: Completes a dependency cycle.")); 1779 dc = DC_DEPCYCLE; 1780 } else if (strcmp(svcp->aux_state, "fault_threshold_reached") == 1781 0) { 1782 print_method_failure(svcp, &dc); 1783 } else if (strcmp(svcp->aux_state, "service_request") == 0) { 1784 if (svcp->aux_fmri) { 1785 (void) printf(gettext("Reason: Maintenance " 1786 "requested by \"%s\"\n"), svcp->aux_fmri); 1787 print_aux_fmri_logs(svcp->aux_fmri); 1788 } else { 1789 (void) puts(gettext("Reason: Maintenance " 1790 "requested by another service.")); 1791 } 1792 dc = DC_SVCREQMAINT; 1793 } else if (strcmp(svcp->aux_state, "invalid_dependency") == 0) { 1794 (void) puts(gettext("Reason: Has invalid dependency.")); 1795 dc = DC_INVALIDDEP; 1796 } else if (strcmp(svcp->aux_state, "invalid_restarter") == 0) { 1797 (void) printf(gettext("Reason: Restarter \"%s\" is " 1798 "invalid.\n"), svcp->restarter); 1799 dc = DC_RSTRINVALID; 1800 } else if (strcmp(svcp->aux_state, "method_failed") == 0) { 1801 print_method_failure(svcp, &dc); 1802 } else if (strcmp(svcp->aux_state, "restarting_too_quickly") == 1803 0) { 1804 (void) puts(gettext("Reason: Restarting too quickly.")); 1805 dc = DC_TOOQUICKLY; 1806 } else if (strcmp(svcp->aux_state, "none") == 0) { 1807 (void) printf(gettext( 1808 "Reason: Restarter %s gave no explanation.\n"), 1809 svcp->restarter); 1810 dc = DC_NONE; 1811 } else { 1812 (void) puts(gettext("Reason: Unknown.")); 1813 dc = DC_UNKNOWN; 1814 } 1815 1816 } else if (strcmp(svcp->state, SCF_STATE_STRING_OFFLINE) == 0) { 1817 if (strcmp(svcp->next_state, SCF_STATE_STRING_ONLINE) == 0) { 1818 (void) puts(gettext( 1819 "Reason: Start method is running.")); 1820 dc = DC_STARTING; 1821 } else if (strcmp(svcp->next_state, SCF_STATE_STRING_NONE) == 1822 0) { 1823 print_dependency_reasons(svcp, verbose); 1824 /* Function prints diagcodes. */ 1825 return; 1826 } else { 1827 (void) printf(gettext( 1828 "Reason: Transitioning to state %s.\n"), 1829 svcp->next_state); 1830 dc = DC_TRANSITION; 1831 } 1832 1833 } else if (strcmp(svcp->state, SCF_STATE_STRING_DEGRADED) == 0) { 1834 (void) puts(gettext("Reason: Degraded by an administrator.")); 1835 dc = DC_ADMINDEGR; 1836 1837 } else { 1838 (void) printf(gettext("Reason: Not in valid state (%s).\n"), 1839 svcp->state); 1840 dc = DC_INVALIDSTATE; 1841 } 1842 1843 diagcode: 1844 if (g_msgbase != NULL) 1845 (void) printf(gettext(" See: %s%s\n"), g_msgbase, dc); 1846 } 1847 1848 static void 1849 print_manpage(int verbose) 1850 { 1851 static char *title = NULL; 1852 static char *section = NULL; 1853 1854 if (title == NULL) { 1855 title = safe_malloc(g_value_sz); 1856 section = safe_malloc(g_value_sz); 1857 } 1858 1859 if (pg_get_single_val(g_pg, SCF_PROPERTY_TM_TITLE, SCF_TYPE_ASTRING, 1860 (void *)title, g_value_sz, 0) != 0) 1861 return; 1862 1863 if (pg_get_single_val(g_pg, SCF_PROPERTY_TM_SECTION, 1864 SCF_TYPE_ASTRING, (void *)section, g_value_sz, 0) != 0) 1865 return; 1866 1867 if (!verbose) { 1868 (void) printf(gettext(" See: %s(%s)\n"), title, section); 1869 return; 1870 } 1871 1872 if (pg_get_single_val(g_pg, SCF_PROPERTY_TM_MANPATH, SCF_TYPE_ASTRING, 1873 (void *)g_value, g_value_sz, 0) != 0) 1874 return; 1875 1876 if (strcmp(g_value, ":default") == 0) { 1877 assert(sizeof (DEFAULT_MAN_PATH) < g_value_sz); 1878 (void) strcpy(g_value, DEFAULT_MAN_PATH); 1879 } 1880 1881 (void) printf(gettext(" See: man -M %s -s %s %s\n"), g_value, 1882 section, title); 1883 } 1884 1885 static void 1886 print_doclink() 1887 { 1888 static char *uri = NULL; 1889 1890 if (uri == NULL) { 1891 uri = safe_malloc(g_value_sz); 1892 } 1893 1894 if (pg_get_single_val(g_pg, SCF_PROPERTY_TM_URI, SCF_TYPE_ASTRING, 1895 (void *)uri, g_value_sz, 0) != 0) 1896 return; 1897 1898 (void) printf(gettext(" See: %s\n"), uri); 1899 } 1900 1901 1902 /* 1903 * Returns 1904 * 0 - success 1905 * 1 - inst was deleted 1906 */ 1907 static int 1908 print_docs(scf_instance_t *inst, int verbose) 1909 { 1910 scf_snapshot_t *snap; 1911 int r; 1912 1913 if (scf_instance_get_snapshot(inst, "running", g_snap) != 0) { 1914 switch (scf_error()) { 1915 case SCF_ERROR_NOT_FOUND: 1916 break; 1917 1918 case SCF_ERROR_DELETED: 1919 return (1); 1920 1921 default: 1922 scfdie(); 1923 } 1924 1925 snap = NULL; 1926 } else { 1927 snap = g_snap; 1928 } 1929 1930 if (scf_iter_instance_pgs_typed_composed(g_iter, inst, snap, 1931 SCF_GROUP_TEMPLATE) != 0) { 1932 if (scf_error() != SCF_ERROR_DELETED) 1933 scfdie(); 1934 1935 return (1); 1936 } 1937 1938 for (;;) { 1939 r = scf_iter_next_pg(g_iter, g_pg); 1940 if (r == 0) 1941 break; 1942 if (r != 1) { 1943 if (scf_error() != SCF_ERROR_DELETED) 1944 scfdie(); 1945 1946 return (1); 1947 } 1948 1949 if (scf_pg_get_name(g_pg, g_fmri, g_fmri_sz) < 0) { 1950 if (scf_error() != SCF_ERROR_DELETED) 1951 scfdie(); 1952 1953 continue; 1954 } 1955 1956 if (strncmp(g_fmri, SCF_PG_TM_MAN_PREFIX, 1957 strlen(SCF_PG_TM_MAN_PREFIX)) == 0) { 1958 print_manpage(verbose); 1959 continue; 1960 } 1961 1962 if (strncmp(g_fmri, SCF_PG_TM_DOC_PREFIX, 1963 strlen(SCF_PG_TM_DOC_PREFIX)) == 0) { 1964 print_doclink(); 1965 continue; 1966 } 1967 } 1968 return (0); 1969 } 1970 1971 static int first = 1; 1972 1973 /* 1974 * Explain why the given service is in the state it's in. 1975 */ 1976 static void 1977 print_service(inst_t *svcp, int verbose) 1978 { 1979 struct svcptr *spp; 1980 time_t stime; 1981 char *timebuf; 1982 size_t tbsz; 1983 struct tm *tmp; 1984 int deleted = 0; 1985 1986 if (first) 1987 first = 0; 1988 else 1989 (void) putchar('\n'); 1990 1991 (void) printf(gettext("svc:/%s:%s"), svcp->svcname, svcp->instname); 1992 1993 if (scf_scope_get_service(g_local_scope, svcp->svcname, g_svc) != 0) { 1994 if (scf_error() != SCF_ERROR_NOT_FOUND) 1995 scfdie(); 1996 deleted = 1; 1997 } else if (scf_service_get_instance(g_svc, svcp->instname, g_inst) != 1998 0) { 1999 if (scf_error() != SCF_ERROR_NOT_FOUND) 2000 scfdie(); 2001 deleted = 1; 2002 } 2003 2004 if (!deleted) { 2005 if (inst_get_single_val(g_inst, SCF_PG_TM_COMMON_NAME, locale, 2006 SCF_TYPE_USTRING, g_value, g_value_sz, 0, 0, 1) == 0) 2007 /* EMPTY */; 2008 else if (inst_get_single_val(g_inst, SCF_PG_TM_COMMON_NAME, "C", 2009 SCF_TYPE_USTRING, g_value, g_value_sz, 0, 0, 1) != 0) 2010 (void) strcpy(g_value, "?"); 2011 2012 (void) printf(gettext(" (%s)\n"), g_value); 2013 } else { 2014 (void) putchar('\n'); 2015 } 2016 2017 if (g_zonename != NULL) 2018 (void) printf(gettext(" Zone: %s\n"), g_zonename); 2019 2020 stime = svcp->stime.tv_sec; 2021 tmp = localtime(&stime); 2022 2023 for (tbsz = 50; ; tbsz *= 2) { 2024 timebuf = safe_malloc(tbsz); 2025 if (strftime(timebuf, tbsz, NULL, tmp) != 0) 2026 break; 2027 free(timebuf); 2028 } 2029 2030 (void) printf(gettext(" State: %s since %s\n"), svcp->state, timebuf); 2031 2032 free(timebuf); 2033 2034 /* Reasons */ 2035 print_reasons(svcp, verbose); 2036 2037 if (!deleted) 2038 deleted = print_docs(g_inst, verbose); 2039 if (!deleted) 2040 print_logs(g_inst); 2041 2042 (void) determine_impact(svcp); 2043 2044 switch (uu_list_numnodes(svcp->impact)) { 2045 case 0: 2046 if (inst_running(svcp)) 2047 (void) puts(gettext("Impact: None.")); 2048 else 2049 (void) puts(gettext( 2050 "Impact: This service is not running.")); 2051 break; 2052 2053 case 1: 2054 if (!verbose) 2055 (void) puts(gettext("Impact: 1 dependent service " 2056 "is not running. (Use -v for list.)")); 2057 else 2058 (void) puts(gettext( 2059 "Impact: 1 dependent service is not running:")); 2060 break; 2061 2062 default: 2063 if (!verbose) 2064 (void) printf(gettext("Impact: %d dependent services " 2065 "are not running. (Use -v for list.)\n"), 2066 uu_list_numnodes(svcp->impact)); 2067 else 2068 (void) printf(gettext( 2069 "Impact: %d dependent services are not running:\n"), 2070 uu_list_numnodes(svcp->impact)); 2071 } 2072 2073 if (verbose) { 2074 for (spp = uu_list_first(svcp->impact); 2075 spp != NULL; 2076 spp = uu_list_next(svcp->impact, spp)) 2077 (void) printf(gettext(" svc:/%s:%s\n"), 2078 spp->svcp->svcname, spp->svcp->instname); 2079 } 2080 } 2081 2082 /* 2083 * Top level routine. 2084 */ 2085 2086 static int 2087 impact_compar(const void *a, const void *b) 2088 { 2089 int n, m; 2090 2091 n = uu_list_numnodes((*(inst_t **)a)->impact); 2092 m = uu_list_numnodes((*(inst_t **)b)->impact); 2093 2094 return (m - n); 2095 } 2096 2097 static int 2098 print_service_cb(void *verbose, scf_walkinfo_t *wip) 2099 { 2100 int r; 2101 inst_t *ip; 2102 2103 assert(wip->pg == NULL); 2104 2105 r = get_fmri(wip->fmri, NULL, &ip); 2106 assert(r != EINVAL); 2107 if (r == ENOENT) 2108 return (0); 2109 2110 assert(r == 0); 2111 assert(ip != NULL); 2112 2113 print_service(ip, (int)verbose); 2114 2115 return (0); 2116 } 2117 2118 void 2119 explain(int verbose, int argc, char **argv) 2120 { 2121 /* 2122 * Initialize globals. If we have been called before (e.g., for a 2123 * different zone), this will clobber the previous globals -- keeping 2124 * with the proud svcs(1) tradition of not bothering to ever clean 2125 * anything up. 2126 */ 2127 x_init(); 2128 2129 /* Walk the graph and populate services with inst_t's */ 2130 load_services(); 2131 2132 /* Populate causes for services. */ 2133 determine_all_causes(); 2134 2135 if (argc > 0) { 2136 scf_error_t err; 2137 2138 check_msgbase(); 2139 2140 /* Call print_service() for each operand. */ 2141 2142 err = scf_walk_fmri(h, argc, argv, SCF_WALK_MULTIPLE, 2143 print_service_cb, (void *)verbose, &exit_status, uu_warn); 2144 if (err != 0) { 2145 uu_warn(gettext( 2146 "failed to iterate over instances: %s\n"), 2147 scf_strerror(err)); 2148 exit_status = UU_EXIT_FATAL; 2149 } 2150 } else { 2151 struct svcptr *spp; 2152 int n, i; 2153 inst_t **ary; 2154 2155 /* Sort g_causes. */ 2156 2157 n = uu_list_numnodes(g_causes); 2158 if (n == 0) 2159 return; 2160 2161 check_msgbase(); 2162 2163 ary = calloc(n, sizeof (*ary)); 2164 if (ary == NULL) 2165 uu_die(emsg_nomem); 2166 2167 i = 0; 2168 for (spp = uu_list_first(g_causes); 2169 spp != NULL; 2170 spp = uu_list_next(g_causes, spp)) { 2171 (void) determine_impact(spp->svcp); 2172 ary[i++] = spp->svcp; 2173 } 2174 2175 qsort(ary, n, sizeof (*ary), impact_compar); 2176 2177 /* Call print_service() for each service. */ 2178 2179 for (i = 0; i < n; ++i) 2180 print_service(ary[i], verbose); 2181 } 2182 } 2183