17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 594501b61Sskamm * Common Development and Distribution License (the "License"). 694501b61Sskamm * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 203eae19d9Swesolows */ 213eae19d9Swesolows 223eae19d9Swesolows /* 23*7b209c2cSacruz * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate /* 307c478bd9Sstevel@tonic-gate * svcs - display attributes of service instances 317c478bd9Sstevel@tonic-gate * 327c478bd9Sstevel@tonic-gate * We have two output formats and six instance selection mechanisms. The 337c478bd9Sstevel@tonic-gate * primary output format is a line of attributes (selected by -o), possibly 347c478bd9Sstevel@tonic-gate * followed by process description lines (if -p is specified), for each 357c478bd9Sstevel@tonic-gate * instance selected. The columns available to display are described by the 367c478bd9Sstevel@tonic-gate * struct column columns array. The columns to actually display are kept in 377c478bd9Sstevel@tonic-gate * the opt_columns array as indicies into the columns array. The selection 387c478bd9Sstevel@tonic-gate * mechanisms available for this format are service FMRIs (selects all child 397c478bd9Sstevel@tonic-gate * instances), instance FMRIs, instance FMRI glob patterns, instances with 407c478bd9Sstevel@tonic-gate * a certain restarter (-R), dependencies of instances (-d), and dependents of 417c478bd9Sstevel@tonic-gate * instances (-D). Since the lines must be sorted (per -sS), we'll just stick 427c478bd9Sstevel@tonic-gate * each into a data structure and print them in order when we're done. To 437c478bd9Sstevel@tonic-gate * avoid listing the same instance twice (when -d and -D aren't given), we'll 447c478bd9Sstevel@tonic-gate * use a hash table of FMRIs to record that we've listed (added to the tree) 457c478bd9Sstevel@tonic-gate * an instance. 467c478bd9Sstevel@tonic-gate * 477c478bd9Sstevel@tonic-gate * The secondary output format (-l "long") is a paragraph of text for the 487c478bd9Sstevel@tonic-gate * services or instances selected. Not needing to be sorted, it's implemented 497c478bd9Sstevel@tonic-gate * by just calling print_detailed() for each FMRI given. 507c478bd9Sstevel@tonic-gate */ 517c478bd9Sstevel@tonic-gate 527c478bd9Sstevel@tonic-gate #include "svcs.h" 537c478bd9Sstevel@tonic-gate 547c478bd9Sstevel@tonic-gate /* Get the byteorder macros to ease sorting. */ 557c478bd9Sstevel@tonic-gate #include <sys/types.h> 567c478bd9Sstevel@tonic-gate #include <netinet/in.h> 577c478bd9Sstevel@tonic-gate #include <inttypes.h> 587c478bd9Sstevel@tonic-gate 597c478bd9Sstevel@tonic-gate #include <sys/contract.h> 607c478bd9Sstevel@tonic-gate #include <sys/ctfs.h> 617c478bd9Sstevel@tonic-gate #include <sys/stat.h> 627c478bd9Sstevel@tonic-gate 637c478bd9Sstevel@tonic-gate #include <assert.h> 647c478bd9Sstevel@tonic-gate #include <ctype.h> 657c478bd9Sstevel@tonic-gate #include <errno.h> 667c478bd9Sstevel@tonic-gate #include <fcntl.h> 677c478bd9Sstevel@tonic-gate #include <fnmatch.h> 687c478bd9Sstevel@tonic-gate #include <libcontract.h> 697c478bd9Sstevel@tonic-gate #include <libcontract_priv.h> 707c478bd9Sstevel@tonic-gate #include <libintl.h> 717c478bd9Sstevel@tonic-gate #include <libscf.h> 727c478bd9Sstevel@tonic-gate #include <libscf_priv.h> 737c478bd9Sstevel@tonic-gate #include <libuutil.h> 747c478bd9Sstevel@tonic-gate #include <locale.h> 757c478bd9Sstevel@tonic-gate #include <procfs.h> 767c478bd9Sstevel@tonic-gate #include <stdarg.h> 777c478bd9Sstevel@tonic-gate #include <stdio.h> 787c478bd9Sstevel@tonic-gate #include <stdlib.h> 797c478bd9Sstevel@tonic-gate #include <strings.h> 807c478bd9Sstevel@tonic-gate #include <time.h> 817c478bd9Sstevel@tonic-gate 827c478bd9Sstevel@tonic-gate 837c478bd9Sstevel@tonic-gate #ifndef TEXT_DOMAIN 847c478bd9Sstevel@tonic-gate #define TEXT_DOMAIN "SUNW_OST_OSCMD" 857c478bd9Sstevel@tonic-gate #endif /* TEXT_DOMAIN */ 867c478bd9Sstevel@tonic-gate 877c478bd9Sstevel@tonic-gate #define LEGACY_UNKNOWN "unknown" 887c478bd9Sstevel@tonic-gate 897c478bd9Sstevel@tonic-gate /* Flags for pg_get_single_val() */ 907c478bd9Sstevel@tonic-gate #define EMPTY_OK 0x01 917c478bd9Sstevel@tonic-gate #define MULTI_OK 0x02 927c478bd9Sstevel@tonic-gate 937c478bd9Sstevel@tonic-gate 947c478bd9Sstevel@tonic-gate /* 957c478bd9Sstevel@tonic-gate * An AVL-storable node for output lines and the keys to sort them by. 967c478bd9Sstevel@tonic-gate */ 977c478bd9Sstevel@tonic-gate struct avl_string { 987c478bd9Sstevel@tonic-gate uu_avl_node_t node; 997c478bd9Sstevel@tonic-gate char *key; 1007c478bd9Sstevel@tonic-gate char *str; 1017c478bd9Sstevel@tonic-gate }; 1027c478bd9Sstevel@tonic-gate 1037c478bd9Sstevel@tonic-gate /* 1047c478bd9Sstevel@tonic-gate * For lists of parsed restarter FMRIs. 1057c478bd9Sstevel@tonic-gate */ 1067c478bd9Sstevel@tonic-gate struct pfmri_list { 1077c478bd9Sstevel@tonic-gate const char *scope; 1087c478bd9Sstevel@tonic-gate const char *service; 1097c478bd9Sstevel@tonic-gate const char *instance; 1107c478bd9Sstevel@tonic-gate struct pfmri_list *next; 1117c478bd9Sstevel@tonic-gate }; 1127c478bd9Sstevel@tonic-gate 1137c478bd9Sstevel@tonic-gate 1147c478bd9Sstevel@tonic-gate /* 1157c478bd9Sstevel@tonic-gate * Globals 1167c478bd9Sstevel@tonic-gate */ 1177c478bd9Sstevel@tonic-gate scf_handle_t *h; 1187c478bd9Sstevel@tonic-gate static scf_propertygroup_t *g_pg; 1197c478bd9Sstevel@tonic-gate static scf_property_t *g_prop; 1207c478bd9Sstevel@tonic-gate static scf_value_t *g_val; 1217c478bd9Sstevel@tonic-gate 1227c478bd9Sstevel@tonic-gate static size_t line_sz; /* Bytes in the header line. */ 1237c478bd9Sstevel@tonic-gate static size_t sortkey_sz; /* Bytes in sort keys. */ 1247c478bd9Sstevel@tonic-gate static uu_avl_pool_t *lines_pool; 1257c478bd9Sstevel@tonic-gate static uu_avl_t *lines; /* Output lines. */ 1267c478bd9Sstevel@tonic-gate int exit_status; 1277c478bd9Sstevel@tonic-gate ssize_t max_scf_name_length; 1287c478bd9Sstevel@tonic-gate ssize_t max_scf_value_length; 1297c478bd9Sstevel@tonic-gate ssize_t max_scf_fmri_length; 1307c478bd9Sstevel@tonic-gate static time_t now; 1317c478bd9Sstevel@tonic-gate static struct pfmri_list *restarters = NULL; 1327c478bd9Sstevel@tonic-gate static int first_paragraph = 1; /* For -l mode. */ 1337c478bd9Sstevel@tonic-gate static char *common_name_buf; /* Sized for maximal length value. */ 1347c478bd9Sstevel@tonic-gate char *locale; /* Current locale. */ 1357c478bd9Sstevel@tonic-gate 13694501b61Sskamm /* 13794501b61Sskamm * Pathname storage for path generated from the fmri. 13894501b61Sskamm * Used for reading the ctid and (start) pid files for an inetd service. 13994501b61Sskamm */ 14094501b61Sskamm static char genfmri_filename[MAXPATHLEN] = ""; 14194501b61Sskamm 1427c478bd9Sstevel@tonic-gate /* Options */ 1437c478bd9Sstevel@tonic-gate static int *opt_columns = NULL; /* Indices into columns to display. */ 1447c478bd9Sstevel@tonic-gate static int opt_cnum = 0; 1457c478bd9Sstevel@tonic-gate static int opt_processes = 0; /* Print processes? */ 1467c478bd9Sstevel@tonic-gate static int *opt_sort = NULL; /* Indices into columns to sort. */ 1477c478bd9Sstevel@tonic-gate static int opt_snum = 0; 1487c478bd9Sstevel@tonic-gate static int opt_nstate_shown = 0; /* Will nstate be shown? */ 1497c478bd9Sstevel@tonic-gate static int opt_verbose = 0; 1507c478bd9Sstevel@tonic-gate 1517c478bd9Sstevel@tonic-gate /* Minimize string constants. */ 1527c478bd9Sstevel@tonic-gate static const char * const scf_property_state = SCF_PROPERTY_STATE; 1537c478bd9Sstevel@tonic-gate static const char * const scf_property_next_state = SCF_PROPERTY_NEXT_STATE; 1547c478bd9Sstevel@tonic-gate static const char * const scf_property_contract = SCF_PROPERTY_CONTRACT; 1557c478bd9Sstevel@tonic-gate 1567c478bd9Sstevel@tonic-gate 1577c478bd9Sstevel@tonic-gate /* 1587c478bd9Sstevel@tonic-gate * Utility functions 1597c478bd9Sstevel@tonic-gate */ 1607c478bd9Sstevel@tonic-gate 1617c478bd9Sstevel@tonic-gate /* 1627c478bd9Sstevel@tonic-gate * For unexpected libscf errors. The ending newline is necessary to keep 1637c478bd9Sstevel@tonic-gate * uu_die() from appending the errno error. 1647c478bd9Sstevel@tonic-gate */ 1657c478bd9Sstevel@tonic-gate #ifndef NDEBUG 1667c478bd9Sstevel@tonic-gate void 1677c478bd9Sstevel@tonic-gate do_scfdie(const char *file, int line) 1687c478bd9Sstevel@tonic-gate { 1697c478bd9Sstevel@tonic-gate uu_die(gettext("%s:%d: Unexpected libscf error: %s. Exiting.\n"), 1707c478bd9Sstevel@tonic-gate file, line, scf_strerror(scf_error())); 1717c478bd9Sstevel@tonic-gate } 1727c478bd9Sstevel@tonic-gate #else 1737c478bd9Sstevel@tonic-gate void 1747c478bd9Sstevel@tonic-gate scfdie(void) 1757c478bd9Sstevel@tonic-gate { 1767c478bd9Sstevel@tonic-gate uu_die(gettext("Unexpected libscf error: %s. Exiting.\n"), 1777c478bd9Sstevel@tonic-gate scf_strerror(scf_error())); 1787c478bd9Sstevel@tonic-gate } 1797c478bd9Sstevel@tonic-gate #endif 1807c478bd9Sstevel@tonic-gate 1817c478bd9Sstevel@tonic-gate void * 1827c478bd9Sstevel@tonic-gate safe_malloc(size_t sz) 1837c478bd9Sstevel@tonic-gate { 1847c478bd9Sstevel@tonic-gate void *ptr; 1857c478bd9Sstevel@tonic-gate 1867c478bd9Sstevel@tonic-gate ptr = malloc(sz); 1877c478bd9Sstevel@tonic-gate if (ptr == NULL) 1887c478bd9Sstevel@tonic-gate uu_die(gettext("Out of memory")); 1897c478bd9Sstevel@tonic-gate 1907c478bd9Sstevel@tonic-gate return (ptr); 1917c478bd9Sstevel@tonic-gate } 1927c478bd9Sstevel@tonic-gate 1937c478bd9Sstevel@tonic-gate char * 1947c478bd9Sstevel@tonic-gate safe_strdup(const char *str) 1957c478bd9Sstevel@tonic-gate { 1967c478bd9Sstevel@tonic-gate char *cp; 1977c478bd9Sstevel@tonic-gate 1987c478bd9Sstevel@tonic-gate cp = strdup(str); 1997c478bd9Sstevel@tonic-gate if (cp == NULL) 2007c478bd9Sstevel@tonic-gate uu_die(gettext("Out of memory.\n")); 2017c478bd9Sstevel@tonic-gate 2027c478bd9Sstevel@tonic-gate return (cp); 2037c478bd9Sstevel@tonic-gate } 2047c478bd9Sstevel@tonic-gate 2057c478bd9Sstevel@tonic-gate static void 2067c478bd9Sstevel@tonic-gate sanitize_locale(char *locale) 2077c478bd9Sstevel@tonic-gate { 2087c478bd9Sstevel@tonic-gate for (; *locale != '\0'; locale++) 2097c478bd9Sstevel@tonic-gate if (!isalnum(*locale)) 2107c478bd9Sstevel@tonic-gate *locale = '_'; 2117c478bd9Sstevel@tonic-gate } 2127c478bd9Sstevel@tonic-gate 2137c478bd9Sstevel@tonic-gate /* 2147c478bd9Sstevel@tonic-gate * FMRI hashtable. For uniquifing listings. 2157c478bd9Sstevel@tonic-gate */ 2167c478bd9Sstevel@tonic-gate 2177c478bd9Sstevel@tonic-gate struct ht_elem { 2187c478bd9Sstevel@tonic-gate const char *fmri; 2197c478bd9Sstevel@tonic-gate struct ht_elem *next; 2207c478bd9Sstevel@tonic-gate }; 2217c478bd9Sstevel@tonic-gate 2227c478bd9Sstevel@tonic-gate static struct ht_elem **ht_buckets; 2237c478bd9Sstevel@tonic-gate static uint_t ht_buckets_num; 2247c478bd9Sstevel@tonic-gate static uint_t ht_num; 2257c478bd9Sstevel@tonic-gate 2267c478bd9Sstevel@tonic-gate static void 2277c478bd9Sstevel@tonic-gate ht_init() 2287c478bd9Sstevel@tonic-gate { 2297c478bd9Sstevel@tonic-gate ht_buckets_num = 8; 2307c478bd9Sstevel@tonic-gate ht_buckets = safe_malloc(sizeof (*ht_buckets) * ht_buckets_num); 2317c478bd9Sstevel@tonic-gate bzero(ht_buckets, sizeof (*ht_buckets) * ht_buckets_num); 2327c478bd9Sstevel@tonic-gate ht_num = 0; 2337c478bd9Sstevel@tonic-gate } 2347c478bd9Sstevel@tonic-gate 2357c478bd9Sstevel@tonic-gate static uint_t 2367c478bd9Sstevel@tonic-gate ht_hash_fmri(const char *fmri) 2377c478bd9Sstevel@tonic-gate { 2387c478bd9Sstevel@tonic-gate uint_t h = 0, g; 2397c478bd9Sstevel@tonic-gate const char *p, *k; 2407c478bd9Sstevel@tonic-gate 2417c478bd9Sstevel@tonic-gate /* All FMRIs begin with svc:/, so skip that part. */ 2427c478bd9Sstevel@tonic-gate assert(strncmp(fmri, "svc:/", sizeof ("svc:/") - 1) == 0); 2437c478bd9Sstevel@tonic-gate k = fmri + sizeof ("svc:/") - 1; 2447c478bd9Sstevel@tonic-gate 2457c478bd9Sstevel@tonic-gate /* 2467c478bd9Sstevel@tonic-gate * Generic hash function from uts/common/os/modhash.c. 2477c478bd9Sstevel@tonic-gate */ 2487c478bd9Sstevel@tonic-gate for (p = k; *p != '\0'; ++p) { 2497c478bd9Sstevel@tonic-gate h = (h << 4) + *p; 2507c478bd9Sstevel@tonic-gate if ((g = (h & 0xf0000000)) != 0) { 2517c478bd9Sstevel@tonic-gate h ^= (g >> 24); 2527c478bd9Sstevel@tonic-gate h ^= g; 2537c478bd9Sstevel@tonic-gate } 2547c478bd9Sstevel@tonic-gate } 2557c478bd9Sstevel@tonic-gate 2567c478bd9Sstevel@tonic-gate return (h); 2577c478bd9Sstevel@tonic-gate } 2587c478bd9Sstevel@tonic-gate 2597c478bd9Sstevel@tonic-gate static void 2607c478bd9Sstevel@tonic-gate ht_grow() 2617c478bd9Sstevel@tonic-gate { 2627c478bd9Sstevel@tonic-gate uint_t new_ht_buckets_num; 2637c478bd9Sstevel@tonic-gate struct ht_elem **new_ht_buckets; 2647c478bd9Sstevel@tonic-gate int i; 2657c478bd9Sstevel@tonic-gate 2667c478bd9Sstevel@tonic-gate new_ht_buckets_num = ht_buckets_num * 2; 2677c478bd9Sstevel@tonic-gate assert(new_ht_buckets_num > ht_buckets_num); 2687c478bd9Sstevel@tonic-gate new_ht_buckets = 2697c478bd9Sstevel@tonic-gate safe_malloc(sizeof (*new_ht_buckets) * new_ht_buckets_num); 2707c478bd9Sstevel@tonic-gate bzero(new_ht_buckets, sizeof (*new_ht_buckets) * new_ht_buckets_num); 2717c478bd9Sstevel@tonic-gate 2727c478bd9Sstevel@tonic-gate for (i = 0; i < ht_buckets_num; ++i) { 2737c478bd9Sstevel@tonic-gate struct ht_elem *elem, *next; 2747c478bd9Sstevel@tonic-gate 2757c478bd9Sstevel@tonic-gate for (elem = ht_buckets[i]; elem != NULL; elem = next) { 2767c478bd9Sstevel@tonic-gate uint_t h; 2777c478bd9Sstevel@tonic-gate 2787c478bd9Sstevel@tonic-gate next = elem->next; 2797c478bd9Sstevel@tonic-gate 2807c478bd9Sstevel@tonic-gate h = ht_hash_fmri(elem->fmri); 2817c478bd9Sstevel@tonic-gate 2827c478bd9Sstevel@tonic-gate elem->next = 2837c478bd9Sstevel@tonic-gate new_ht_buckets[h & (new_ht_buckets_num - 1)]; 2847c478bd9Sstevel@tonic-gate new_ht_buckets[h & (new_ht_buckets_num - 1)] = elem; 2857c478bd9Sstevel@tonic-gate } 2867c478bd9Sstevel@tonic-gate } 2877c478bd9Sstevel@tonic-gate 2887c478bd9Sstevel@tonic-gate free(ht_buckets); 2897c478bd9Sstevel@tonic-gate 2907c478bd9Sstevel@tonic-gate ht_buckets = new_ht_buckets; 2917c478bd9Sstevel@tonic-gate ht_buckets_num = new_ht_buckets_num; 2927c478bd9Sstevel@tonic-gate } 2937c478bd9Sstevel@tonic-gate 2947c478bd9Sstevel@tonic-gate /* 2957c478bd9Sstevel@tonic-gate * Add an FMRI to the hash table. Returns 1 if it was already there, 2967c478bd9Sstevel@tonic-gate * 0 otherwise. 2977c478bd9Sstevel@tonic-gate */ 2987c478bd9Sstevel@tonic-gate static int 2997c478bd9Sstevel@tonic-gate ht_add(const char *fmri) 3007c478bd9Sstevel@tonic-gate { 3017c478bd9Sstevel@tonic-gate uint_t h; 3027c478bd9Sstevel@tonic-gate struct ht_elem *elem; 3037c478bd9Sstevel@tonic-gate 3047c478bd9Sstevel@tonic-gate h = ht_hash_fmri(fmri); 3057c478bd9Sstevel@tonic-gate 3067c478bd9Sstevel@tonic-gate elem = ht_buckets[h & (ht_buckets_num - 1)]; 3077c478bd9Sstevel@tonic-gate 3087c478bd9Sstevel@tonic-gate for (; elem != NULL; elem = elem->next) { 3097c478bd9Sstevel@tonic-gate if (strcmp(elem->fmri, fmri) == 0) 3107c478bd9Sstevel@tonic-gate return (1); 3117c478bd9Sstevel@tonic-gate } 3127c478bd9Sstevel@tonic-gate 3137c478bd9Sstevel@tonic-gate /* Grow when average chain length is over 3. */ 3147c478bd9Sstevel@tonic-gate if (ht_num > 3 * ht_buckets_num) 3157c478bd9Sstevel@tonic-gate ht_grow(); 3167c478bd9Sstevel@tonic-gate 3177c478bd9Sstevel@tonic-gate ++ht_num; 3187c478bd9Sstevel@tonic-gate 3197c478bd9Sstevel@tonic-gate elem = safe_malloc(sizeof (*elem)); 3207c478bd9Sstevel@tonic-gate elem->fmri = strdup(fmri); 3217c478bd9Sstevel@tonic-gate elem->next = ht_buckets[h & (ht_buckets_num - 1)]; 3227c478bd9Sstevel@tonic-gate ht_buckets[h & (ht_buckets_num - 1)] = elem; 3237c478bd9Sstevel@tonic-gate 3247c478bd9Sstevel@tonic-gate return (0); 3257c478bd9Sstevel@tonic-gate } 3267c478bd9Sstevel@tonic-gate 3277c478bd9Sstevel@tonic-gate 3287c478bd9Sstevel@tonic-gate 3297c478bd9Sstevel@tonic-gate /* 3307c478bd9Sstevel@tonic-gate * Convenience libscf wrapper functions. 3317c478bd9Sstevel@tonic-gate */ 3327c478bd9Sstevel@tonic-gate 3337c478bd9Sstevel@tonic-gate /* 3347c478bd9Sstevel@tonic-gate * Get the single value of the named property in the given property group, 3357c478bd9Sstevel@tonic-gate * which must have type ty, and put it in *vp. If ty is SCF_TYPE_ASTRING, vp 3367c478bd9Sstevel@tonic-gate * is taken to be a char **, and sz is the size of the buffer. sz is unused 3377c478bd9Sstevel@tonic-gate * otherwise. Return 0 on success, -1 if the property doesn't exist, has the 3387c478bd9Sstevel@tonic-gate * wrong type, or doesn't have a single value. If flags has EMPTY_OK, don't 3397c478bd9Sstevel@tonic-gate * complain if the property has no values (but return nonzero). If flags has 3407c478bd9Sstevel@tonic-gate * MULTI_OK and the property has multiple values, succeed with E2BIG. 3417c478bd9Sstevel@tonic-gate */ 3427c478bd9Sstevel@tonic-gate int 3437c478bd9Sstevel@tonic-gate pg_get_single_val(scf_propertygroup_t *pg, const char *propname, scf_type_t ty, 3447c478bd9Sstevel@tonic-gate void *vp, size_t sz, uint_t flags) 3457c478bd9Sstevel@tonic-gate { 3467c478bd9Sstevel@tonic-gate char *buf; 3477c478bd9Sstevel@tonic-gate size_t buf_sz; 3487c478bd9Sstevel@tonic-gate int ret = -1, r; 3497c478bd9Sstevel@tonic-gate boolean_t multi = B_FALSE; 3507c478bd9Sstevel@tonic-gate 3517c478bd9Sstevel@tonic-gate assert((flags & ~(EMPTY_OK | MULTI_OK)) == 0); 3527c478bd9Sstevel@tonic-gate 3537c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, propname, g_prop) == -1) { 3547c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 3557c478bd9Sstevel@tonic-gate scfdie(); 3567c478bd9Sstevel@tonic-gate 3577c478bd9Sstevel@tonic-gate goto out; 3587c478bd9Sstevel@tonic-gate } 3597c478bd9Sstevel@tonic-gate 3607c478bd9Sstevel@tonic-gate if (scf_property_is_type(g_prop, ty) != SCF_SUCCESS) { 3617c478bd9Sstevel@tonic-gate if (scf_error() == SCF_ERROR_TYPE_MISMATCH) 3627c478bd9Sstevel@tonic-gate goto misconfigured; 3637c478bd9Sstevel@tonic-gate scfdie(); 3647c478bd9Sstevel@tonic-gate } 3657c478bd9Sstevel@tonic-gate 3667c478bd9Sstevel@tonic-gate if (scf_property_get_value(g_prop, g_val) != SCF_SUCCESS) { 3677c478bd9Sstevel@tonic-gate switch (scf_error()) { 3687c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND: 3697c478bd9Sstevel@tonic-gate if (flags & EMPTY_OK) 3707c478bd9Sstevel@tonic-gate goto out; 3717c478bd9Sstevel@tonic-gate goto misconfigured; 3727c478bd9Sstevel@tonic-gate 3737c478bd9Sstevel@tonic-gate case SCF_ERROR_CONSTRAINT_VIOLATED: 3747c478bd9Sstevel@tonic-gate if (flags & MULTI_OK) { 3757c478bd9Sstevel@tonic-gate multi = B_TRUE; 3767c478bd9Sstevel@tonic-gate break; 3777c478bd9Sstevel@tonic-gate } 3787c478bd9Sstevel@tonic-gate goto misconfigured; 3797c478bd9Sstevel@tonic-gate 3803eae19d9Swesolows case SCF_ERROR_PERMISSION_DENIED: 3817c478bd9Sstevel@tonic-gate default: 3827c478bd9Sstevel@tonic-gate scfdie(); 3837c478bd9Sstevel@tonic-gate } 3847c478bd9Sstevel@tonic-gate } 3857c478bd9Sstevel@tonic-gate 3867c478bd9Sstevel@tonic-gate switch (ty) { 3877c478bd9Sstevel@tonic-gate case SCF_TYPE_ASTRING: 3887c478bd9Sstevel@tonic-gate r = scf_value_get_astring(g_val, vp, sz) > 0 ? SCF_SUCCESS : -1; 3897c478bd9Sstevel@tonic-gate break; 3907c478bd9Sstevel@tonic-gate 3917c478bd9Sstevel@tonic-gate case SCF_TYPE_BOOLEAN: 3927c478bd9Sstevel@tonic-gate r = scf_value_get_boolean(g_val, (uint8_t *)vp); 3937c478bd9Sstevel@tonic-gate break; 3947c478bd9Sstevel@tonic-gate 3957c478bd9Sstevel@tonic-gate case SCF_TYPE_COUNT: 3967c478bd9Sstevel@tonic-gate r = scf_value_get_count(g_val, (uint64_t *)vp); 3977c478bd9Sstevel@tonic-gate break; 3987c478bd9Sstevel@tonic-gate 3997c478bd9Sstevel@tonic-gate case SCF_TYPE_INTEGER: 4007c478bd9Sstevel@tonic-gate r = scf_value_get_integer(g_val, (int64_t *)vp); 4017c478bd9Sstevel@tonic-gate break; 4027c478bd9Sstevel@tonic-gate 4037c478bd9Sstevel@tonic-gate case SCF_TYPE_TIME: { 4047c478bd9Sstevel@tonic-gate int64_t sec; 4057c478bd9Sstevel@tonic-gate int32_t ns; 4067c478bd9Sstevel@tonic-gate r = scf_value_get_time(g_val, &sec, &ns); 4077c478bd9Sstevel@tonic-gate ((struct timeval *)vp)->tv_sec = sec; 4087c478bd9Sstevel@tonic-gate ((struct timeval *)vp)->tv_usec = ns / 1000; 4097c478bd9Sstevel@tonic-gate break; 4107c478bd9Sstevel@tonic-gate } 4117c478bd9Sstevel@tonic-gate 4127c478bd9Sstevel@tonic-gate case SCF_TYPE_USTRING: 4137c478bd9Sstevel@tonic-gate r = scf_value_get_ustring(g_val, vp, sz) > 0 ? SCF_SUCCESS : -1; 4147c478bd9Sstevel@tonic-gate break; 4157c478bd9Sstevel@tonic-gate 4167c478bd9Sstevel@tonic-gate default: 4177c478bd9Sstevel@tonic-gate #ifndef NDEBUG 4187c478bd9Sstevel@tonic-gate uu_warn("%s:%d: Unknown type %d.\n", __FILE__, __LINE__, ty); 4197c478bd9Sstevel@tonic-gate #endif 4207c478bd9Sstevel@tonic-gate abort(); 4217c478bd9Sstevel@tonic-gate } 4227c478bd9Sstevel@tonic-gate if (r != SCF_SUCCESS) 4237c478bd9Sstevel@tonic-gate scfdie(); 4247c478bd9Sstevel@tonic-gate 4257c478bd9Sstevel@tonic-gate ret = multi ? E2BIG : 0; 4267c478bd9Sstevel@tonic-gate goto out; 4277c478bd9Sstevel@tonic-gate 4287c478bd9Sstevel@tonic-gate misconfigured: 4297c478bd9Sstevel@tonic-gate buf_sz = max_scf_fmri_length + 1; 4307c478bd9Sstevel@tonic-gate buf = safe_malloc(buf_sz); 4317c478bd9Sstevel@tonic-gate if (scf_property_to_fmri(g_prop, buf, buf_sz) == -1) 4327c478bd9Sstevel@tonic-gate scfdie(); 4337c478bd9Sstevel@tonic-gate 4347c478bd9Sstevel@tonic-gate uu_warn(gettext("Property \"%s\" is misconfigured.\n"), buf); 4357c478bd9Sstevel@tonic-gate 4367c478bd9Sstevel@tonic-gate free(buf); 4377c478bd9Sstevel@tonic-gate 4387c478bd9Sstevel@tonic-gate out: 4397c478bd9Sstevel@tonic-gate return (ret); 4407c478bd9Sstevel@tonic-gate } 4417c478bd9Sstevel@tonic-gate 4427c478bd9Sstevel@tonic-gate static scf_snapshot_t * 4437c478bd9Sstevel@tonic-gate get_running_snapshot(scf_instance_t *inst) 4447c478bd9Sstevel@tonic-gate { 4457c478bd9Sstevel@tonic-gate scf_snapshot_t *snap; 4467c478bd9Sstevel@tonic-gate 4477c478bd9Sstevel@tonic-gate snap = scf_snapshot_create(h); 4487c478bd9Sstevel@tonic-gate if (snap == NULL) 4497c478bd9Sstevel@tonic-gate scfdie(); 4507c478bd9Sstevel@tonic-gate 4517c478bd9Sstevel@tonic-gate if (scf_instance_get_snapshot(inst, "running", snap) == 0) 4527c478bd9Sstevel@tonic-gate return (snap); 4537c478bd9Sstevel@tonic-gate 4547c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 4557c478bd9Sstevel@tonic-gate scfdie(); 4567c478bd9Sstevel@tonic-gate 4577c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap); 4587c478bd9Sstevel@tonic-gate return (NULL); 4597c478bd9Sstevel@tonic-gate } 4607c478bd9Sstevel@tonic-gate 4617c478bd9Sstevel@tonic-gate /* 4627c478bd9Sstevel@tonic-gate * As pg_get_single_val(), except look the property group up in an 4637c478bd9Sstevel@tonic-gate * instance. If "use_running" is set, and the running snapshot exists, 4647c478bd9Sstevel@tonic-gate * do a composed lookup there. Otherwise, do an (optionally composed) 4657c478bd9Sstevel@tonic-gate * lookup on the current values. Note that lookups using snapshots are 4667c478bd9Sstevel@tonic-gate * always composed. 4677c478bd9Sstevel@tonic-gate */ 4687c478bd9Sstevel@tonic-gate int 4697c478bd9Sstevel@tonic-gate inst_get_single_val(scf_instance_t *inst, const char *pgname, 4707c478bd9Sstevel@tonic-gate const char *propname, scf_type_t ty, void *vp, size_t sz, uint_t flags, 4717c478bd9Sstevel@tonic-gate int use_running, int composed) 4727c478bd9Sstevel@tonic-gate { 4737c478bd9Sstevel@tonic-gate scf_snapshot_t *snap = NULL; 4747c478bd9Sstevel@tonic-gate int r; 4757c478bd9Sstevel@tonic-gate 4767c478bd9Sstevel@tonic-gate if (use_running) 4777c478bd9Sstevel@tonic-gate snap = get_running_snapshot(inst); 4787c478bd9Sstevel@tonic-gate if (composed || use_running) 4797c478bd9Sstevel@tonic-gate r = scf_instance_get_pg_composed(inst, snap, pgname, g_pg); 4807c478bd9Sstevel@tonic-gate else 4817c478bd9Sstevel@tonic-gate r = scf_instance_get_pg(inst, pgname, g_pg); 4827c478bd9Sstevel@tonic-gate if (snap) 4837c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap); 4847c478bd9Sstevel@tonic-gate if (r == -1) 4857c478bd9Sstevel@tonic-gate return (-1); 4867c478bd9Sstevel@tonic-gate 4877c478bd9Sstevel@tonic-gate r = pg_get_single_val(g_pg, propname, ty, vp, sz, flags); 4887c478bd9Sstevel@tonic-gate 4897c478bd9Sstevel@tonic-gate return (r); 4907c478bd9Sstevel@tonic-gate } 4917c478bd9Sstevel@tonic-gate 4927c478bd9Sstevel@tonic-gate static int 4937c478bd9Sstevel@tonic-gate instance_enabled(scf_instance_t *inst, boolean_t temp) 4947c478bd9Sstevel@tonic-gate { 4957c478bd9Sstevel@tonic-gate uint8_t b; 4967c478bd9Sstevel@tonic-gate 4977c478bd9Sstevel@tonic-gate if (inst_get_single_val(inst, 4987c478bd9Sstevel@tonic-gate temp ? SCF_PG_GENERAL_OVR : SCF_PG_GENERAL, SCF_PROPERTY_ENABLED, 4997c478bd9Sstevel@tonic-gate SCF_TYPE_BOOLEAN, &b, 0, 0, 0, 0) != 0) 5007c478bd9Sstevel@tonic-gate return (-1); 5017c478bd9Sstevel@tonic-gate 5027c478bd9Sstevel@tonic-gate return (b ? 1 : 0); 5037c478bd9Sstevel@tonic-gate } 5047c478bd9Sstevel@tonic-gate 5057c478bd9Sstevel@tonic-gate /* 5067c478bd9Sstevel@tonic-gate * Get a string property from the restarter property group of the given 5077c478bd9Sstevel@tonic-gate * instance. Return an empty string on normal problems. 5087c478bd9Sstevel@tonic-gate */ 5097c478bd9Sstevel@tonic-gate static void 5107c478bd9Sstevel@tonic-gate get_restarter_string_prop(scf_instance_t *inst, const char *pname, 5117c478bd9Sstevel@tonic-gate char *buf, size_t buf_sz) 5127c478bd9Sstevel@tonic-gate { 5137c478bd9Sstevel@tonic-gate if (inst_get_single_val(inst, SCF_PG_RESTARTER, pname, 5147c478bd9Sstevel@tonic-gate SCF_TYPE_ASTRING, buf, buf_sz, 0, 0, 1) != 0) 5157c478bd9Sstevel@tonic-gate *buf = '\0'; 5167c478bd9Sstevel@tonic-gate } 5177c478bd9Sstevel@tonic-gate 5187c478bd9Sstevel@tonic-gate static int 5197c478bd9Sstevel@tonic-gate get_restarter_time_prop(scf_instance_t *inst, const char *pname, 5207c478bd9Sstevel@tonic-gate struct timeval *tvp, int ok_if_empty) 5217c478bd9Sstevel@tonic-gate { 5227c478bd9Sstevel@tonic-gate int r; 5237c478bd9Sstevel@tonic-gate 5247c478bd9Sstevel@tonic-gate r = inst_get_single_val(inst, SCF_PG_RESTARTER, pname, SCF_TYPE_TIME, 5257c478bd9Sstevel@tonic-gate tvp, NULL, ok_if_empty ? EMPTY_OK : 0, 0, 1); 5267c478bd9Sstevel@tonic-gate 5277c478bd9Sstevel@tonic-gate return (r == 0 ? 0 : -1); 5287c478bd9Sstevel@tonic-gate } 5297c478bd9Sstevel@tonic-gate 5307c478bd9Sstevel@tonic-gate static int 5317c478bd9Sstevel@tonic-gate get_restarter_count_prop(scf_instance_t *inst, const char *pname, uint64_t *cp, 5327c478bd9Sstevel@tonic-gate uint_t flags) 5337c478bd9Sstevel@tonic-gate { 5347c478bd9Sstevel@tonic-gate return (inst_get_single_val(inst, SCF_PG_RESTARTER, pname, 5357c478bd9Sstevel@tonic-gate SCF_TYPE_COUNT, cp, 0, flags, 0, 1)); 5367c478bd9Sstevel@tonic-gate } 5377c478bd9Sstevel@tonic-gate 5387c478bd9Sstevel@tonic-gate 5397c478bd9Sstevel@tonic-gate /* 5407c478bd9Sstevel@tonic-gate * Generic functions 5417c478bd9Sstevel@tonic-gate */ 5427c478bd9Sstevel@tonic-gate 54394501b61Sskamm /* 54494501b61Sskamm * Return an array of pids associated with the given contract id. 54594501b61Sskamm * Returned pids are added to the end of the pidsp array. 54694501b61Sskamm */ 54794501b61Sskamm static void 54894501b61Sskamm ctid_to_pids(uint64_t c, pid_t **pidsp, uint_t *np) 54994501b61Sskamm { 55094501b61Sskamm ct_stathdl_t ctst; 55194501b61Sskamm uint_t m; 55294501b61Sskamm int fd; 55394501b61Sskamm int r, err; 55494501b61Sskamm pid_t *pids; 55594501b61Sskamm 55694501b61Sskamm fd = contract_open(c, NULL, "status", O_RDONLY); 55794501b61Sskamm if (fd < 0) 55894501b61Sskamm return; 55994501b61Sskamm 56094501b61Sskamm err = ct_status_read(fd, CTD_ALL, &ctst); 56194501b61Sskamm if (err != 0) { 56294501b61Sskamm uu_warn(gettext("Could not read status of contract " 56394501b61Sskamm "%ld: %s.\n"), c, strerror(err)); 56494501b61Sskamm (void) close(fd); 56594501b61Sskamm return; 56694501b61Sskamm } 56794501b61Sskamm 56894501b61Sskamm (void) close(fd); 56994501b61Sskamm 57094501b61Sskamm r = ct_pr_status_get_members(ctst, &pids, &m); 57194501b61Sskamm assert(r == 0); 57294501b61Sskamm 57394501b61Sskamm if (m == 0) { 57494501b61Sskamm ct_status_free(ctst); 57594501b61Sskamm return; 57694501b61Sskamm } 57794501b61Sskamm 57894501b61Sskamm *pidsp = realloc(*pidsp, (*np + m) * sizeof (*pidsp)); 57994501b61Sskamm if (*pidsp == NULL) 58094501b61Sskamm uu_die(gettext("Out of memory")); 58194501b61Sskamm 58294501b61Sskamm bcopy(pids, *pidsp + *np, m * sizeof (*pids)); 58394501b61Sskamm *np += m; 58494501b61Sskamm 58594501b61Sskamm ct_status_free(ctst); 58694501b61Sskamm } 58794501b61Sskamm 5887c478bd9Sstevel@tonic-gate static int 5897c478bd9Sstevel@tonic-gate propvals_to_pids(scf_propertygroup_t *pg, const char *pname, pid_t **pidsp, 5907c478bd9Sstevel@tonic-gate uint_t *np, scf_property_t *prop, scf_value_t *val, scf_iter_t *iter) 5917c478bd9Sstevel@tonic-gate { 5927c478bd9Sstevel@tonic-gate scf_type_t ty; 5937c478bd9Sstevel@tonic-gate uint64_t c; 59494501b61Sskamm int r; 5957c478bd9Sstevel@tonic-gate 5967c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, pname, prop) != 0) { 5977c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 5987c478bd9Sstevel@tonic-gate scfdie(); 5997c478bd9Sstevel@tonic-gate 6007c478bd9Sstevel@tonic-gate return (ENOENT); 6017c478bd9Sstevel@tonic-gate } 6027c478bd9Sstevel@tonic-gate 6037c478bd9Sstevel@tonic-gate if (scf_property_type(prop, &ty) != 0) 6047c478bd9Sstevel@tonic-gate scfdie(); 6057c478bd9Sstevel@tonic-gate 6067c478bd9Sstevel@tonic-gate if (ty != SCF_TYPE_COUNT) 6077c478bd9Sstevel@tonic-gate return (EINVAL); 6087c478bd9Sstevel@tonic-gate 6097c478bd9Sstevel@tonic-gate if (scf_iter_property_values(iter, prop) != 0) 6107c478bd9Sstevel@tonic-gate scfdie(); 6117c478bd9Sstevel@tonic-gate 6127c478bd9Sstevel@tonic-gate for (;;) { 6137c478bd9Sstevel@tonic-gate r = scf_iter_next_value(iter, val); 6147c478bd9Sstevel@tonic-gate if (r == -1) 6157c478bd9Sstevel@tonic-gate scfdie(); 6167c478bd9Sstevel@tonic-gate if (r == 0) 6177c478bd9Sstevel@tonic-gate break; 6187c478bd9Sstevel@tonic-gate 6197c478bd9Sstevel@tonic-gate if (scf_value_get_count(val, &c) != 0) 6207c478bd9Sstevel@tonic-gate scfdie(); 6217c478bd9Sstevel@tonic-gate 62294501b61Sskamm ctid_to_pids(c, pidsp, np); 62394501b61Sskamm } 6247c478bd9Sstevel@tonic-gate 62594501b61Sskamm return (0); 62694501b61Sskamm } 6277c478bd9Sstevel@tonic-gate 62894501b61Sskamm /* 62994501b61Sskamm * Check if instance has general/restarter property that matches 63094501b61Sskamm * given string. Restarter string must be in canonified form. 63194501b61Sskamm * Returns 0 for success; -1 otherwise. 63294501b61Sskamm */ 63394501b61Sskamm static int 63494501b61Sskamm check_for_restarter(scf_instance_t *inst, const char *restarter) 63594501b61Sskamm { 63694501b61Sskamm char *fmri_buf; 63794501b61Sskamm char *fmri_buf_canonified = NULL; 63894501b61Sskamm int ret = -1; 6397c478bd9Sstevel@tonic-gate 64094501b61Sskamm if (inst == NULL) 64194501b61Sskamm return (-1); 6427c478bd9Sstevel@tonic-gate 64394501b61Sskamm /* Get restarter */ 64494501b61Sskamm fmri_buf = safe_malloc(max_scf_fmri_length + 1); 64594501b61Sskamm if (inst_get_single_val(inst, SCF_PG_GENERAL, 64694501b61Sskamm SCF_PROPERTY_RESTARTER, SCF_TYPE_ASTRING, fmri_buf, 64794501b61Sskamm max_scf_fmri_length + 1, 0, 0, 1) != 0) 64894501b61Sskamm goto out; 64994501b61Sskamm 65094501b61Sskamm fmri_buf_canonified = safe_malloc(max_scf_fmri_length + 1); 65194501b61Sskamm if (scf_canonify_fmri(fmri_buf, fmri_buf_canonified, 65294501b61Sskamm (max_scf_fmri_length + 1)) < 0) 65394501b61Sskamm goto out; 65494501b61Sskamm 65594501b61Sskamm if (strcmp(fmri_buf, restarter) == 0) 65694501b61Sskamm ret = 0; 65794501b61Sskamm 65894501b61Sskamm out: 65994501b61Sskamm free(fmri_buf); 66094501b61Sskamm if (fmri_buf_canonified) 66194501b61Sskamm free(fmri_buf_canonified); 66294501b61Sskamm return (ret); 66394501b61Sskamm } 66494501b61Sskamm 66594501b61Sskamm /* 66694501b61Sskamm * Common code that is used by ctids_by_restarter and pids_by_restarter. 66794501b61Sskamm * Checks for a common restarter and if one is available, it generates 66894501b61Sskamm * the appropriate filename using wip->fmri and stores that in the 66994501b61Sskamm * global genfmri_filename. 67094501b61Sskamm * 67194501b61Sskamm * Restarters currently supported are: svc:/network/inetd:default 67294501b61Sskamm * If a restarter specific action is available, then restarter_spec 67394501b61Sskamm * is set to 1. If a restarter specific action is not available, then 67494501b61Sskamm * restarter_spec is set to 0 and a -1 is returned. 67594501b61Sskamm * 67694501b61Sskamm * Returns: 67794501b61Sskamm * 0 if success: restarter specific action found and filename generated 67894501b61Sskamm * -1 if restarter specific action not found, 67994501b61Sskamm * if restarter specific action found but an error was encountered 68094501b61Sskamm * during the generation of the wip->fmri based filename 68194501b61Sskamm */ 68294501b61Sskamm static int 68394501b61Sskamm common_by_restarter(scf_instance_t *inst, const char *fmri, 68494501b61Sskamm int *restarter_specp) 68594501b61Sskamm { 68694501b61Sskamm int ret = -1; 68794501b61Sskamm int r; 68894501b61Sskamm 68994501b61Sskamm /* Check for inetd specific restarter */ 69094501b61Sskamm if (check_for_restarter(inst, "svc:/network/inetd:default") != 0) { 69194501b61Sskamm *restarter_specp = 0; 69294501b61Sskamm return (ret); 69394501b61Sskamm } 69494501b61Sskamm 69594501b61Sskamm *restarter_specp = 1; 69694501b61Sskamm 69794501b61Sskamm /* Get the ctid filename associated with this instance */ 69894501b61Sskamm r = gen_filenms_from_fmri(fmri, "ctid", genfmri_filename, NULL); 69994501b61Sskamm 70094501b61Sskamm switch (r) { 70194501b61Sskamm case 0: 70294501b61Sskamm break; 70394501b61Sskamm 70494501b61Sskamm case -1: 70594501b61Sskamm /* 70694501b61Sskamm * Unable to get filename from fmri. Print warning 70794501b61Sskamm * and return failure with no ctids. 70894501b61Sskamm */ 70994501b61Sskamm uu_warn(gettext("Unable to read contract ids for %s -- " 71094501b61Sskamm "FMRI is too long\n"), fmri); 71194501b61Sskamm return (ret); 71294501b61Sskamm 71394501b61Sskamm case -2: 71494501b61Sskamm /* 71594501b61Sskamm * The directory didn't exist, so no contracts. 71694501b61Sskamm * Return failure with no ctids. 71794501b61Sskamm */ 71894501b61Sskamm return (ret); 71994501b61Sskamm 72094501b61Sskamm default: 72194501b61Sskamm uu_warn(gettext("%s:%d: gen_filenms_from_fmri() failed with " 72294501b61Sskamm "unknown error %d\n"), __FILE__, __LINE__, r); 72394501b61Sskamm abort(); 72494501b61Sskamm } 72594501b61Sskamm 72694501b61Sskamm return (0); 72794501b61Sskamm 72894501b61Sskamm } 72994501b61Sskamm 73094501b61Sskamm /* 73194501b61Sskamm * Get or print a contract id using a restarter specific action. 73294501b61Sskamm * 73394501b61Sskamm * If the print_flag is not set, this routine gets the single contract 73494501b61Sskamm * id associated with this instance. 73594501b61Sskamm * If the print flag is set, then print each contract id found. 73694501b61Sskamm * 73794501b61Sskamm * Returns: 73894501b61Sskamm * 0 if success: restarter specific action found and used with no error 73994501b61Sskamm * -1 if restarter specific action not found 74094501b61Sskamm * -1 if restarter specific action found, but there was a failure 74194501b61Sskamm * -1 if print flag is not set and no contract id is found or multiple 74294501b61Sskamm * contract ids were found 74394501b61Sskamm * E2BIG if print flag is not set, MULTI_OK bit in flag is set and multiple 74494501b61Sskamm * contract ids were found 74594501b61Sskamm */ 74694501b61Sskamm static int 74794501b61Sskamm ctids_by_restarter(scf_walkinfo_t *wip, uint64_t *cp, int print_flag, 74894501b61Sskamm uint_t flags, int *restarter_specp, void (*callback_header)(), 74994501b61Sskamm void (*callback_ctid)(uint64_t)) 75094501b61Sskamm { 75194501b61Sskamm FILE *fp; 75294501b61Sskamm int ret = -1; 75394501b61Sskamm int fscanf_ret; 75494501b61Sskamm uint64_t cp2; 75594501b61Sskamm int rest_ret; 75694501b61Sskamm 75794501b61Sskamm /* Check if callbacks are needed and were passed in */ 75894501b61Sskamm if (print_flag) { 75994501b61Sskamm if ((callback_header == NULL) || (callback_ctid == NULL)) 76094501b61Sskamm return (ret); 76194501b61Sskamm } 76294501b61Sskamm 76394501b61Sskamm /* Check for restarter specific action and generation of filename */ 76494501b61Sskamm rest_ret = common_by_restarter(wip->inst, wip->fmri, restarter_specp); 76594501b61Sskamm if (rest_ret != 0) 76694501b61Sskamm return (rest_ret); 76794501b61Sskamm 76894501b61Sskamm /* 76994501b61Sskamm * If fopen fails, then ctid file hasn't been created yet. 77094501b61Sskamm * If print_flag is set, this is ok; otherwise fail. 77194501b61Sskamm */ 77294501b61Sskamm if ((fp = fopen(genfmri_filename, "r")) == NULL) { 77394501b61Sskamm if (print_flag) 77494501b61Sskamm return (0); 77594501b61Sskamm goto out; 77694501b61Sskamm } 77794501b61Sskamm 77894501b61Sskamm if (print_flag) { 77994501b61Sskamm /* 78094501b61Sskamm * Print all contract ids that are found. 78194501b61Sskamm * First callback to print ctid header. 78294501b61Sskamm */ 78394501b61Sskamm callback_header(); 78494501b61Sskamm 78594501b61Sskamm /* fscanf may not set errno, so be sure to clear it first */ 78694501b61Sskamm errno = 0; 78794501b61Sskamm while ((fscanf_ret = fscanf(fp, "%llu", cp)) == 1) { 78894501b61Sskamm /* Callback to print contract id */ 78994501b61Sskamm callback_ctid(*cp); 79094501b61Sskamm errno = 0; 79194501b61Sskamm } 79294501b61Sskamm /* EOF is not a failure when no errno. */ 79394501b61Sskamm if ((fscanf_ret != EOF) || (errno != 0)) { 79494501b61Sskamm uu_die(gettext("Unable to read ctid file for %s"), 79594501b61Sskamm wip->fmri); 79694501b61Sskamm } 79794501b61Sskamm (void) putchar('\n'); 79894501b61Sskamm ret = 0; 79994501b61Sskamm } else { 80094501b61Sskamm /* Must find 1 ctid or fail */ 80194501b61Sskamm if (fscanf(fp, "%llu", cp) == 1) { 80294501b61Sskamm /* If 2nd ctid found - fail */ 80394501b61Sskamm if (fscanf(fp, "%llu", &cp2) == 1) { 80494501b61Sskamm if (flags & MULTI_OK) 80594501b61Sskamm ret = E2BIG; 80694501b61Sskamm } else { 80794501b61Sskamm /* Success - found only 1 ctid */ 80894501b61Sskamm ret = 0; 80994501b61Sskamm } 8107c478bd9Sstevel@tonic-gate } 81194501b61Sskamm } 81294501b61Sskamm (void) fclose(fp); 8137c478bd9Sstevel@tonic-gate 81494501b61Sskamm out: 81594501b61Sskamm return (ret); 81694501b61Sskamm } 81794501b61Sskamm 81894501b61Sskamm /* 81994501b61Sskamm * Get the process ids associated with an instance using a restarter 82094501b61Sskamm * specific action. 82194501b61Sskamm * 82294501b61Sskamm * Returns: 82394501b61Sskamm * 0 if success: restarter specific action found and used with no error 82494501b61Sskamm * -1 restarter specific action not found or if failure 82594501b61Sskamm */ 82694501b61Sskamm static int 82794501b61Sskamm pids_by_restarter(scf_instance_t *inst, const char *fmri, 82894501b61Sskamm pid_t **pids, uint_t *np, int *restarter_specp) 82994501b61Sskamm { 83094501b61Sskamm uint64_t c; 83194501b61Sskamm FILE *fp; 83294501b61Sskamm int fscanf_ret; 83394501b61Sskamm int rest_ret; 8347c478bd9Sstevel@tonic-gate 83594501b61Sskamm /* Check for restarter specific action and generation of filename */ 83694501b61Sskamm rest_ret = common_by_restarter(inst, fmri, restarter_specp); 83794501b61Sskamm if (rest_ret != 0) 83894501b61Sskamm return (rest_ret); 8397c478bd9Sstevel@tonic-gate 84094501b61Sskamm /* 84194501b61Sskamm * If fopen fails with ENOENT then the ctid file hasn't been 84294501b61Sskamm * created yet so return success. 84394501b61Sskamm * For all other errors - fail with uu_die. 84494501b61Sskamm */ 84594501b61Sskamm if ((fp = fopen(genfmri_filename, "r")) == NULL) { 84694501b61Sskamm if (errno == ENOENT) 84794501b61Sskamm return (0); 84894501b61Sskamm uu_die(gettext("Unable to open ctid file for %s"), fmri); 84994501b61Sskamm } 85094501b61Sskamm 85194501b61Sskamm /* fscanf may not set errno, so be sure to clear it first */ 85294501b61Sskamm errno = 0; 85394501b61Sskamm while ((fscanf_ret = fscanf(fp, "%llu", &c)) == 1) { 85494501b61Sskamm if (c == 0) { 85594501b61Sskamm (void) fclose(fp); 85694501b61Sskamm uu_die(gettext("ctid file for %s has corrupt data"), 85794501b61Sskamm fmri); 85894501b61Sskamm } 85994501b61Sskamm ctid_to_pids(c, pids, np); 86094501b61Sskamm errno = 0; 86194501b61Sskamm } 86294501b61Sskamm /* EOF is not a failure when no errno. */ 86394501b61Sskamm if ((fscanf_ret != EOF) || (errno != 0)) { 86494501b61Sskamm uu_die(gettext("Unable to read ctid file for %s"), fmri); 8657c478bd9Sstevel@tonic-gate } 8667c478bd9Sstevel@tonic-gate 86794501b61Sskamm (void) fclose(fp); 8687c478bd9Sstevel@tonic-gate return (0); 8697c478bd9Sstevel@tonic-gate } 8707c478bd9Sstevel@tonic-gate 8717c478bd9Sstevel@tonic-gate static int 87294501b61Sskamm instance_processes(scf_instance_t *inst, const char *fmri, 87394501b61Sskamm pid_t **pids, uint_t *np) 8747c478bd9Sstevel@tonic-gate { 8757c478bd9Sstevel@tonic-gate scf_iter_t *iter; 8767c478bd9Sstevel@tonic-gate int ret; 87794501b61Sskamm int restarter_spec; 87894501b61Sskamm 87994501b61Sskamm /* Use the restarter specific get pids routine, if available. */ 88094501b61Sskamm ret = pids_by_restarter(inst, fmri, pids, np, &restarter_spec); 88194501b61Sskamm if (restarter_spec == 1) 88294501b61Sskamm return (ret); 8837c478bd9Sstevel@tonic-gate 8847c478bd9Sstevel@tonic-gate if ((iter = scf_iter_create(h)) == NULL) 8857c478bd9Sstevel@tonic-gate scfdie(); 8867c478bd9Sstevel@tonic-gate 8877c478bd9Sstevel@tonic-gate if (scf_instance_get_pg(inst, SCF_PG_RESTARTER, g_pg) == 0) { 8887c478bd9Sstevel@tonic-gate *pids = NULL; 8897c478bd9Sstevel@tonic-gate *np = 0; 8907c478bd9Sstevel@tonic-gate 8917c478bd9Sstevel@tonic-gate (void) propvals_to_pids(g_pg, scf_property_contract, pids, np, 8927c478bd9Sstevel@tonic-gate g_prop, g_val, iter); 8937c478bd9Sstevel@tonic-gate 8947c478bd9Sstevel@tonic-gate (void) propvals_to_pids(g_pg, SCF_PROPERTY_TRANSIENT_CONTRACT, 8957c478bd9Sstevel@tonic-gate pids, np, g_prop, g_val, iter); 8967c478bd9Sstevel@tonic-gate 8977c478bd9Sstevel@tonic-gate ret = 0; 8987c478bd9Sstevel@tonic-gate } else { 8997c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 9007c478bd9Sstevel@tonic-gate scfdie(); 9017c478bd9Sstevel@tonic-gate 9027c478bd9Sstevel@tonic-gate ret = -1; 9037c478bd9Sstevel@tonic-gate } 9047c478bd9Sstevel@tonic-gate 9057c478bd9Sstevel@tonic-gate scf_iter_destroy(iter); 9067c478bd9Sstevel@tonic-gate 9077c478bd9Sstevel@tonic-gate return (ret); 9087c478bd9Sstevel@tonic-gate } 9097c478bd9Sstevel@tonic-gate 9107c478bd9Sstevel@tonic-gate static int 9117c478bd9Sstevel@tonic-gate get_psinfo(pid_t pid, psinfo_t *psip) 9127c478bd9Sstevel@tonic-gate { 9137c478bd9Sstevel@tonic-gate char path[100]; 9147c478bd9Sstevel@tonic-gate int fd; 9157c478bd9Sstevel@tonic-gate 9167c478bd9Sstevel@tonic-gate (void) snprintf(path, sizeof (path), "/proc/%lu/psinfo", pid); 9177c478bd9Sstevel@tonic-gate 9187c478bd9Sstevel@tonic-gate fd = open64(path, O_RDONLY); 9197c478bd9Sstevel@tonic-gate if (fd < 0) 9207c478bd9Sstevel@tonic-gate return (-1); 9217c478bd9Sstevel@tonic-gate 9227c478bd9Sstevel@tonic-gate if (read(fd, psip, sizeof (*psip)) < 0) 9237c478bd9Sstevel@tonic-gate uu_die(gettext("Could not read info for process %lu"), pid); 9247c478bd9Sstevel@tonic-gate 9257c478bd9Sstevel@tonic-gate (void) close(fd); 9267c478bd9Sstevel@tonic-gate 9277c478bd9Sstevel@tonic-gate return (0); 9287c478bd9Sstevel@tonic-gate } 9297c478bd9Sstevel@tonic-gate 9307c478bd9Sstevel@tonic-gate 9317c478bd9Sstevel@tonic-gate 9327c478bd9Sstevel@tonic-gate /* 9337c478bd9Sstevel@tonic-gate * Column sprint and sortkey functions 9347c478bd9Sstevel@tonic-gate */ 9357c478bd9Sstevel@tonic-gate 9367c478bd9Sstevel@tonic-gate struct column { 9377c478bd9Sstevel@tonic-gate const char *name; 9387c478bd9Sstevel@tonic-gate int width; 9397c478bd9Sstevel@tonic-gate 9407c478bd9Sstevel@tonic-gate /* 9417c478bd9Sstevel@tonic-gate * This function should write the value for the column into buf, and 9427c478bd9Sstevel@tonic-gate * grow or allocate buf accordingly. It should always write at least 9437c478bd9Sstevel@tonic-gate * width bytes, blanking unused bytes with spaces. If the field is 9447c478bd9Sstevel@tonic-gate * greater than the column width we allow it to overlap other columns. 9457c478bd9Sstevel@tonic-gate * In particular, it shouldn't write any null bytes. (Though an extra 9467c478bd9Sstevel@tonic-gate * null byte past the end is currently tolerated.) If the property 9477c478bd9Sstevel@tonic-gate * group is non-NULL, then we are dealing with a legacy service. 9487c478bd9Sstevel@tonic-gate */ 9497c478bd9Sstevel@tonic-gate void (*sprint)(char **, scf_walkinfo_t *); 9507c478bd9Sstevel@tonic-gate 9517c478bd9Sstevel@tonic-gate int sortkey_width; 9527c478bd9Sstevel@tonic-gate 9537c478bd9Sstevel@tonic-gate /* 9547c478bd9Sstevel@tonic-gate * This function should write sortkey_width bytes into buf which will 9557c478bd9Sstevel@tonic-gate * cause memcmp() to sort it properly. (Unlike sprint() above, 9567c478bd9Sstevel@tonic-gate * however, an extra null byte may overrun the buffer.) The second 9577c478bd9Sstevel@tonic-gate * argument controls whether the results are sorted in forward or 9587c478bd9Sstevel@tonic-gate * reverse order. 9597c478bd9Sstevel@tonic-gate */ 9607c478bd9Sstevel@tonic-gate void (*get_sortkey)(char *, int, scf_walkinfo_t *); 9617c478bd9Sstevel@tonic-gate }; 9627c478bd9Sstevel@tonic-gate 9637c478bd9Sstevel@tonic-gate static void 9647c478bd9Sstevel@tonic-gate reverse_bytes(char *buf, size_t len) 9657c478bd9Sstevel@tonic-gate { 9667c478bd9Sstevel@tonic-gate int i; 9677c478bd9Sstevel@tonic-gate 9687c478bd9Sstevel@tonic-gate for (i = 0; i < len; ++i) 9697c478bd9Sstevel@tonic-gate buf[i] = ~buf[i]; 9707c478bd9Sstevel@tonic-gate } 9717c478bd9Sstevel@tonic-gate 9727c478bd9Sstevel@tonic-gate /* CTID */ 9737c478bd9Sstevel@tonic-gate #define CTID_COLUMN_WIDTH 6 9747c478bd9Sstevel@tonic-gate 9757c478bd9Sstevel@tonic-gate static void 9767c478bd9Sstevel@tonic-gate sprint_ctid(char **buf, scf_walkinfo_t *wip) 9777c478bd9Sstevel@tonic-gate { 9787c478bd9Sstevel@tonic-gate int r; 9797c478bd9Sstevel@tonic-gate uint64_t c; 9807c478bd9Sstevel@tonic-gate size_t newsize = (*buf ? strlen(*buf) : 0) + CTID_COLUMN_WIDTH + 2; 9817c478bd9Sstevel@tonic-gate char *newbuf = safe_malloc(newsize); 98294501b61Sskamm int restarter_spec; 9837c478bd9Sstevel@tonic-gate 98494501b61Sskamm /* 98594501b61Sskamm * Use the restarter specific get pids routine, if available. 98694501b61Sskamm * Only check for non-legacy services (wip->pg == 0). 98794501b61Sskamm */ 98894501b61Sskamm if (wip->pg != NULL) { 9897c478bd9Sstevel@tonic-gate r = pg_get_single_val(wip->pg, scf_property_contract, 9907c478bd9Sstevel@tonic-gate SCF_TYPE_COUNT, &c, 0, EMPTY_OK | MULTI_OK); 99194501b61Sskamm } else { 99294501b61Sskamm r = ctids_by_restarter(wip, &c, 0, MULTI_OK, &restarter_spec, 99394501b61Sskamm NULL, NULL); 99494501b61Sskamm if (restarter_spec == 0) { 99594501b61Sskamm /* No restarter specific routine */ 99694501b61Sskamm r = get_restarter_count_prop(wip->inst, 99794501b61Sskamm scf_property_contract, &c, EMPTY_OK | MULTI_OK); 99894501b61Sskamm } 99994501b61Sskamm } 10007c478bd9Sstevel@tonic-gate 10017c478bd9Sstevel@tonic-gate if (r == 0) 10027c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%*lu ", 10037c478bd9Sstevel@tonic-gate *buf ? *buf : "", CTID_COLUMN_WIDTH, (ctid_t)c); 10047c478bd9Sstevel@tonic-gate else if (r == E2BIG) 10057c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%*lu* ", 10067c478bd9Sstevel@tonic-gate *buf ? *buf : "", CTID_COLUMN_WIDTH - 1, (ctid_t)c); 10077c478bd9Sstevel@tonic-gate else 10087c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%*s ", 10097c478bd9Sstevel@tonic-gate *buf ? *buf : "", CTID_COLUMN_WIDTH, "-"); 10107c478bd9Sstevel@tonic-gate if (*buf) 10117c478bd9Sstevel@tonic-gate free(*buf); 10127c478bd9Sstevel@tonic-gate *buf = newbuf; 10137c478bd9Sstevel@tonic-gate } 10147c478bd9Sstevel@tonic-gate 10157c478bd9Sstevel@tonic-gate #define CTID_SORTKEY_WIDTH (sizeof (uint64_t)) 10167c478bd9Sstevel@tonic-gate 10177c478bd9Sstevel@tonic-gate static void 10187c478bd9Sstevel@tonic-gate sortkey_ctid(char *buf, int reverse, scf_walkinfo_t *wip) 10197c478bd9Sstevel@tonic-gate { 10207c478bd9Sstevel@tonic-gate int r; 10217c478bd9Sstevel@tonic-gate uint64_t c; 102294501b61Sskamm int restarter_spec; 10237c478bd9Sstevel@tonic-gate 102494501b61Sskamm /* 102594501b61Sskamm * Use the restarter specific get pids routine, if available. 102694501b61Sskamm * Only check for non-legacy services (wip->pg == 0). 102794501b61Sskamm */ 102894501b61Sskamm if (wip->pg != NULL) { 10297c478bd9Sstevel@tonic-gate r = pg_get_single_val(wip->pg, scf_property_contract, 10307c478bd9Sstevel@tonic-gate SCF_TYPE_COUNT, &c, 0, EMPTY_OK); 103194501b61Sskamm } else { 103294501b61Sskamm r = ctids_by_restarter(wip, &c, 0, MULTI_OK, &restarter_spec, 103394501b61Sskamm NULL, NULL); 103494501b61Sskamm if (restarter_spec == 0) { 103594501b61Sskamm /* No restarter specific routine */ 103694501b61Sskamm r = get_restarter_count_prop(wip->inst, 103794501b61Sskamm scf_property_contract, &c, EMPTY_OK); 103894501b61Sskamm } 103994501b61Sskamm } 10407c478bd9Sstevel@tonic-gate 10417c478bd9Sstevel@tonic-gate if (r == 0) { 10427c478bd9Sstevel@tonic-gate /* 10437c478bd9Sstevel@tonic-gate * Use the id itself, but it must be big-endian for this to 10447c478bd9Sstevel@tonic-gate * work. 10457c478bd9Sstevel@tonic-gate */ 10467c478bd9Sstevel@tonic-gate c = BE_64(c); 10477c478bd9Sstevel@tonic-gate 10487c478bd9Sstevel@tonic-gate bcopy(&c, buf, CTID_SORTKEY_WIDTH); 10497c478bd9Sstevel@tonic-gate } else { 10507c478bd9Sstevel@tonic-gate bzero(buf, CTID_SORTKEY_WIDTH); 10517c478bd9Sstevel@tonic-gate } 10527c478bd9Sstevel@tonic-gate 10537c478bd9Sstevel@tonic-gate if (reverse) 10547c478bd9Sstevel@tonic-gate reverse_bytes(buf, CTID_SORTKEY_WIDTH); 10557c478bd9Sstevel@tonic-gate } 10567c478bd9Sstevel@tonic-gate 10577c478bd9Sstevel@tonic-gate /* DESC */ 10587c478bd9Sstevel@tonic-gate #define DESC_COLUMN_WIDTH 100 10597c478bd9Sstevel@tonic-gate 10607c478bd9Sstevel@tonic-gate static void 10617c478bd9Sstevel@tonic-gate sprint_desc(char **buf, scf_walkinfo_t *wip) 10627c478bd9Sstevel@tonic-gate { 10637c478bd9Sstevel@tonic-gate char *x; 10647c478bd9Sstevel@tonic-gate size_t newsize; 10657c478bd9Sstevel@tonic-gate char *newbuf; 10667c478bd9Sstevel@tonic-gate 10677c478bd9Sstevel@tonic-gate if (common_name_buf == NULL) 10687c478bd9Sstevel@tonic-gate common_name_buf = safe_malloc(max_scf_value_length + 1); 10697c478bd9Sstevel@tonic-gate 10707c478bd9Sstevel@tonic-gate bzero(common_name_buf, max_scf_value_length + 1); 10717c478bd9Sstevel@tonic-gate 10727c478bd9Sstevel@tonic-gate if (wip->pg != NULL) { 10737c478bd9Sstevel@tonic-gate common_name_buf[0] = '-'; 10747c478bd9Sstevel@tonic-gate } else if (inst_get_single_val(wip->inst, SCF_PG_TM_COMMON_NAME, locale, 10757c478bd9Sstevel@tonic-gate SCF_TYPE_USTRING, common_name_buf, max_scf_value_length, 0, 10767c478bd9Sstevel@tonic-gate 1, 1) == -1 && 10777c478bd9Sstevel@tonic-gate inst_get_single_val(wip->inst, SCF_PG_TM_COMMON_NAME, "C", 10787c478bd9Sstevel@tonic-gate SCF_TYPE_USTRING, common_name_buf, max_scf_value_length, 0, 10797c478bd9Sstevel@tonic-gate 1, 1) == -1) { 10807c478bd9Sstevel@tonic-gate common_name_buf[0] = '-'; 10817c478bd9Sstevel@tonic-gate } 10827c478bd9Sstevel@tonic-gate 10837c478bd9Sstevel@tonic-gate /* 10847c478bd9Sstevel@tonic-gate * Collapse multi-line tm_common_name values into a single line. 10857c478bd9Sstevel@tonic-gate */ 10867c478bd9Sstevel@tonic-gate for (x = common_name_buf; *x != '\0'; x++) 10877c478bd9Sstevel@tonic-gate if (*x == '\n') 10887c478bd9Sstevel@tonic-gate *x = ' '; 10897c478bd9Sstevel@tonic-gate 10907c478bd9Sstevel@tonic-gate if (strlen(common_name_buf) > DESC_COLUMN_WIDTH) 10917c478bd9Sstevel@tonic-gate newsize = (*buf ? strlen(*buf) : 0) + 10927c478bd9Sstevel@tonic-gate strlen(common_name_buf) + 1; 10937c478bd9Sstevel@tonic-gate else 10947c478bd9Sstevel@tonic-gate newsize = (*buf ? strlen(*buf) : 0) + DESC_COLUMN_WIDTH + 1; 10957c478bd9Sstevel@tonic-gate newbuf = safe_malloc(newsize); 10967c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "", 10973eae19d9Swesolows DESC_COLUMN_WIDTH, common_name_buf); 10987c478bd9Sstevel@tonic-gate if (*buf) 10997c478bd9Sstevel@tonic-gate free(*buf); 11007c478bd9Sstevel@tonic-gate *buf = newbuf; 11017c478bd9Sstevel@tonic-gate } 11027c478bd9Sstevel@tonic-gate 11037c478bd9Sstevel@tonic-gate /* ARGSUSED */ 11047c478bd9Sstevel@tonic-gate static void 11057c478bd9Sstevel@tonic-gate sortkey_desc(char *buf, int reverse, scf_walkinfo_t *wip) 11067c478bd9Sstevel@tonic-gate { 11077c478bd9Sstevel@tonic-gate bzero(buf, DESC_COLUMN_WIDTH); 11087c478bd9Sstevel@tonic-gate } 11097c478bd9Sstevel@tonic-gate 11107c478bd9Sstevel@tonic-gate /* State columns (STATE, NSTATE, S, N, SN, STA, NSTA) */ 11117c478bd9Sstevel@tonic-gate 11127c478bd9Sstevel@tonic-gate static char 11137c478bd9Sstevel@tonic-gate state_to_char(const char *state) 11147c478bd9Sstevel@tonic-gate { 11157c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_UNINIT) == 0) 11167c478bd9Sstevel@tonic-gate return ('u'); 11177c478bd9Sstevel@tonic-gate 11187c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_OFFLINE) == 0) 11197c478bd9Sstevel@tonic-gate return ('0'); 11207c478bd9Sstevel@tonic-gate 11217c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_ONLINE) == 0) 11227c478bd9Sstevel@tonic-gate return ('1'); 11237c478bd9Sstevel@tonic-gate 11247c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_MAINT) == 0) 11257c478bd9Sstevel@tonic-gate return ('m'); 11267c478bd9Sstevel@tonic-gate 11277c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_DISABLED) == 0) 11287c478bd9Sstevel@tonic-gate return ('d'); 11297c478bd9Sstevel@tonic-gate 11307c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_DEGRADED) == 0) 11317c478bd9Sstevel@tonic-gate return ('D'); 11327c478bd9Sstevel@tonic-gate 11337c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_LEGACY) == 0) 11347c478bd9Sstevel@tonic-gate return ('L'); 11357c478bd9Sstevel@tonic-gate 11367c478bd9Sstevel@tonic-gate return ('?'); 11377c478bd9Sstevel@tonic-gate } 11387c478bd9Sstevel@tonic-gate 11397c478bd9Sstevel@tonic-gate /* Return true if inst is transitioning. */ 11407c478bd9Sstevel@tonic-gate static int 11417c478bd9Sstevel@tonic-gate transitioning(scf_instance_t *inst) 11427c478bd9Sstevel@tonic-gate { 11437c478bd9Sstevel@tonic-gate char nstate_name[MAX_SCF_STATE_STRING_SZ]; 11447c478bd9Sstevel@tonic-gate 11457c478bd9Sstevel@tonic-gate get_restarter_string_prop(inst, scf_property_next_state, nstate_name, 11467c478bd9Sstevel@tonic-gate sizeof (nstate_name)); 11477c478bd9Sstevel@tonic-gate 11487c478bd9Sstevel@tonic-gate return (state_to_char(nstate_name) != '?'); 11497c478bd9Sstevel@tonic-gate } 11507c478bd9Sstevel@tonic-gate 11517c478bd9Sstevel@tonic-gate /* ARGSUSED */ 11527c478bd9Sstevel@tonic-gate static void 11537c478bd9Sstevel@tonic-gate sortkey_states(const char *pname, char *buf, int reverse, scf_walkinfo_t *wip) 11547c478bd9Sstevel@tonic-gate { 11557c478bd9Sstevel@tonic-gate char state_name[MAX_SCF_STATE_STRING_SZ]; 11567c478bd9Sstevel@tonic-gate 11577c478bd9Sstevel@tonic-gate /* 11587c478bd9Sstevel@tonic-gate * Lower numbers are printed first, so these are arranged from least 11597c478bd9Sstevel@tonic-gate * interesting ("legacy run") to most interesting (unknown). 11607c478bd9Sstevel@tonic-gate */ 11617c478bd9Sstevel@tonic-gate if (wip->pg == NULL) { 11627c478bd9Sstevel@tonic-gate get_restarter_string_prop(wip->inst, pname, state_name, 11637c478bd9Sstevel@tonic-gate sizeof (state_name)); 11647c478bd9Sstevel@tonic-gate 11657c478bd9Sstevel@tonic-gate if (strcmp(state_name, SCF_STATE_STRING_ONLINE) == 0) 11667c478bd9Sstevel@tonic-gate *buf = 2; 11677c478bd9Sstevel@tonic-gate else if (strcmp(state_name, SCF_STATE_STRING_DEGRADED) == 0) 11687c478bd9Sstevel@tonic-gate *buf = 3; 11697c478bd9Sstevel@tonic-gate else if (strcmp(state_name, SCF_STATE_STRING_OFFLINE) == 0) 11707c478bd9Sstevel@tonic-gate *buf = 4; 11717c478bd9Sstevel@tonic-gate else if (strcmp(state_name, SCF_STATE_STRING_MAINT) == 0) 11727c478bd9Sstevel@tonic-gate *buf = 5; 11737c478bd9Sstevel@tonic-gate else if (strcmp(state_name, SCF_STATE_STRING_DISABLED) == 0) 11747c478bd9Sstevel@tonic-gate *buf = 1; 11757c478bd9Sstevel@tonic-gate else if (strcmp(state_name, SCF_STATE_STRING_UNINIT) == 0) 11767c478bd9Sstevel@tonic-gate *buf = 6; 11777c478bd9Sstevel@tonic-gate else 11787c478bd9Sstevel@tonic-gate *buf = 7; 11797c478bd9Sstevel@tonic-gate } else 11807c478bd9Sstevel@tonic-gate *buf = 0; 11817c478bd9Sstevel@tonic-gate 11827c478bd9Sstevel@tonic-gate if (reverse) 11837c478bd9Sstevel@tonic-gate *buf = 255 - *buf; 11847c478bd9Sstevel@tonic-gate } 11857c478bd9Sstevel@tonic-gate 11867c478bd9Sstevel@tonic-gate static void 11877c478bd9Sstevel@tonic-gate sprint_state(char **buf, scf_walkinfo_t *wip) 11887c478bd9Sstevel@tonic-gate { 11897c478bd9Sstevel@tonic-gate char state_name[MAX_SCF_STATE_STRING_SZ + 1]; 11907c478bd9Sstevel@tonic-gate size_t newsize; 11917c478bd9Sstevel@tonic-gate char *newbuf; 11927c478bd9Sstevel@tonic-gate 11937c478bd9Sstevel@tonic-gate if (wip->pg == NULL) { 11947c478bd9Sstevel@tonic-gate get_restarter_string_prop(wip->inst, scf_property_state, 11957c478bd9Sstevel@tonic-gate state_name, sizeof (state_name)); 11967c478bd9Sstevel@tonic-gate 11977c478bd9Sstevel@tonic-gate /* Don't print blank fields, to ease parsing. */ 11987c478bd9Sstevel@tonic-gate if (state_name[0] == '\0') { 11997c478bd9Sstevel@tonic-gate state_name[0] = '-'; 12007c478bd9Sstevel@tonic-gate state_name[1] = '\0'; 12017c478bd9Sstevel@tonic-gate } 12027c478bd9Sstevel@tonic-gate 12037c478bd9Sstevel@tonic-gate if (!opt_nstate_shown && transitioning(wip->inst)) { 12047c478bd9Sstevel@tonic-gate /* Append an asterisk if nstate is valid. */ 12057c478bd9Sstevel@tonic-gate (void) strcat(state_name, "*"); 12067c478bd9Sstevel@tonic-gate } 12077c478bd9Sstevel@tonic-gate } else 12087c478bd9Sstevel@tonic-gate (void) strcpy(state_name, SCF_STATE_STRING_LEGACY); 12097c478bd9Sstevel@tonic-gate 12107c478bd9Sstevel@tonic-gate newsize = (*buf ? strlen(*buf) : 0) + MAX_SCF_STATE_STRING_SZ + 2; 12117c478bd9Sstevel@tonic-gate newbuf = safe_malloc(newsize); 12127c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "", 12137c478bd9Sstevel@tonic-gate MAX_SCF_STATE_STRING_SZ + 1, state_name); 12147c478bd9Sstevel@tonic-gate 12157c478bd9Sstevel@tonic-gate if (*buf) 12167c478bd9Sstevel@tonic-gate free(*buf); 12177c478bd9Sstevel@tonic-gate *buf = newbuf; 12187c478bd9Sstevel@tonic-gate } 12197c478bd9Sstevel@tonic-gate 12207c478bd9Sstevel@tonic-gate static void 12217c478bd9Sstevel@tonic-gate sortkey_state(char *buf, int reverse, scf_walkinfo_t *wip) 12227c478bd9Sstevel@tonic-gate { 12237c478bd9Sstevel@tonic-gate sortkey_states(scf_property_state, buf, reverse, wip); 12247c478bd9Sstevel@tonic-gate } 12257c478bd9Sstevel@tonic-gate 12267c478bd9Sstevel@tonic-gate static void 12277c478bd9Sstevel@tonic-gate sprint_nstate(char **buf, scf_walkinfo_t *wip) 12287c478bd9Sstevel@tonic-gate { 12297c478bd9Sstevel@tonic-gate char next_state_name[MAX_SCF_STATE_STRING_SZ]; 12307c478bd9Sstevel@tonic-gate boolean_t blank = 0; 12317c478bd9Sstevel@tonic-gate size_t newsize; 12327c478bd9Sstevel@tonic-gate char *newbuf; 12337c478bd9Sstevel@tonic-gate 12347c478bd9Sstevel@tonic-gate if (wip->pg == NULL) { 12357c478bd9Sstevel@tonic-gate get_restarter_string_prop(wip->inst, scf_property_next_state, 12367c478bd9Sstevel@tonic-gate next_state_name, sizeof (next_state_name)); 12377c478bd9Sstevel@tonic-gate 12387c478bd9Sstevel@tonic-gate /* Don't print blank fields, to ease parsing. */ 12397c478bd9Sstevel@tonic-gate if (next_state_name[0] == '\0' || 12407c478bd9Sstevel@tonic-gate strcmp(next_state_name, SCF_STATE_STRING_NONE) == 0) 12417c478bd9Sstevel@tonic-gate blank = 1; 12427c478bd9Sstevel@tonic-gate } else 12437c478bd9Sstevel@tonic-gate blank = 1; 12447c478bd9Sstevel@tonic-gate 12457c478bd9Sstevel@tonic-gate if (blank) { 12467c478bd9Sstevel@tonic-gate next_state_name[0] = '-'; 12477c478bd9Sstevel@tonic-gate next_state_name[1] = '\0'; 12487c478bd9Sstevel@tonic-gate } 12497c478bd9Sstevel@tonic-gate 12507c478bd9Sstevel@tonic-gate newsize = (*buf ? strlen(*buf) : 0) + MAX_SCF_STATE_STRING_SZ + 1; 12517c478bd9Sstevel@tonic-gate newbuf = safe_malloc(newsize); 12527c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "", 12537c478bd9Sstevel@tonic-gate MAX_SCF_STATE_STRING_SZ - 1, next_state_name); 12547c478bd9Sstevel@tonic-gate if (*buf) 12557c478bd9Sstevel@tonic-gate free(*buf); 12567c478bd9Sstevel@tonic-gate *buf = newbuf; 12577c478bd9Sstevel@tonic-gate } 12587c478bd9Sstevel@tonic-gate 12597c478bd9Sstevel@tonic-gate static void 12607c478bd9Sstevel@tonic-gate sortkey_nstate(char *buf, int reverse, scf_walkinfo_t *wip) 12617c478bd9Sstevel@tonic-gate { 12627c478bd9Sstevel@tonic-gate sortkey_states(scf_property_next_state, buf, reverse, wip); 12637c478bd9Sstevel@tonic-gate } 12647c478bd9Sstevel@tonic-gate 12657c478bd9Sstevel@tonic-gate static void 12667c478bd9Sstevel@tonic-gate sprint_s(char **buf, scf_walkinfo_t *wip) 12677c478bd9Sstevel@tonic-gate { 12687c478bd9Sstevel@tonic-gate char tmp[3]; 12697c478bd9Sstevel@tonic-gate char state_name[MAX_SCF_STATE_STRING_SZ]; 12707c478bd9Sstevel@tonic-gate size_t newsize = (*buf ? strlen(*buf) : 0) + 4; 12717c478bd9Sstevel@tonic-gate char *newbuf = safe_malloc(newsize); 12727c478bd9Sstevel@tonic-gate 12737c478bd9Sstevel@tonic-gate if (wip->pg == NULL) { 12747c478bd9Sstevel@tonic-gate get_restarter_string_prop(wip->inst, scf_property_state, 12757c478bd9Sstevel@tonic-gate state_name, sizeof (state_name)); 12767c478bd9Sstevel@tonic-gate tmp[0] = state_to_char(state_name); 12777c478bd9Sstevel@tonic-gate 12787c478bd9Sstevel@tonic-gate if (!opt_nstate_shown && transitioning(wip->inst)) 12797c478bd9Sstevel@tonic-gate tmp[1] = '*'; 12807c478bd9Sstevel@tonic-gate else 12817c478bd9Sstevel@tonic-gate tmp[1] = ' '; 12827c478bd9Sstevel@tonic-gate } else { 12837c478bd9Sstevel@tonic-gate tmp[0] = 'L'; 12847c478bd9Sstevel@tonic-gate tmp[1] = ' '; 12857c478bd9Sstevel@tonic-gate } 12867c478bd9Sstevel@tonic-gate tmp[2] = ' '; 12877c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s", *buf ? *buf : "", 12887c478bd9Sstevel@tonic-gate 3, tmp); 12897c478bd9Sstevel@tonic-gate if (*buf) 12907c478bd9Sstevel@tonic-gate free(*buf); 12917c478bd9Sstevel@tonic-gate *buf = newbuf; 12927c478bd9Sstevel@tonic-gate } 12937c478bd9Sstevel@tonic-gate 12947c478bd9Sstevel@tonic-gate static void 12957c478bd9Sstevel@tonic-gate sprint_n(char **buf, scf_walkinfo_t *wip) 12967c478bd9Sstevel@tonic-gate { 12977c478bd9Sstevel@tonic-gate char tmp[2]; 12987c478bd9Sstevel@tonic-gate size_t newsize = (*buf ? strlen(*buf) : 0) + 3; 12997c478bd9Sstevel@tonic-gate char *newbuf = safe_malloc(newsize); 13007c478bd9Sstevel@tonic-gate char nstate_name[MAX_SCF_STATE_STRING_SZ]; 13017c478bd9Sstevel@tonic-gate 13027c478bd9Sstevel@tonic-gate if (wip->pg == NULL) { 13037c478bd9Sstevel@tonic-gate get_restarter_string_prop(wip->inst, scf_property_next_state, 13047c478bd9Sstevel@tonic-gate nstate_name, sizeof (nstate_name)); 13057c478bd9Sstevel@tonic-gate 13067c478bd9Sstevel@tonic-gate if (strcmp(nstate_name, SCF_STATE_STRING_NONE) == 0) 13077c478bd9Sstevel@tonic-gate tmp[0] = '-'; 13087c478bd9Sstevel@tonic-gate else 13097c478bd9Sstevel@tonic-gate tmp[0] = state_to_char(nstate_name); 13107c478bd9Sstevel@tonic-gate } else 13117c478bd9Sstevel@tonic-gate tmp[0] = '-'; 13127c478bd9Sstevel@tonic-gate 13137c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "", 13147c478bd9Sstevel@tonic-gate 2, tmp); 13157c478bd9Sstevel@tonic-gate if (*buf) 13167c478bd9Sstevel@tonic-gate free(*buf); 13177c478bd9Sstevel@tonic-gate *buf = newbuf; 13187c478bd9Sstevel@tonic-gate } 13197c478bd9Sstevel@tonic-gate 13207c478bd9Sstevel@tonic-gate static void 13217c478bd9Sstevel@tonic-gate sprint_sn(char **buf, scf_walkinfo_t *wip) 13227c478bd9Sstevel@tonic-gate { 13237c478bd9Sstevel@tonic-gate char tmp[3]; 13247c478bd9Sstevel@tonic-gate size_t newsize = (*buf ? strlen(*buf) : 0) + 4; 13257c478bd9Sstevel@tonic-gate char *newbuf = safe_malloc(newsize); 13267c478bd9Sstevel@tonic-gate char nstate_name[MAX_SCF_STATE_STRING_SZ]; 13277c478bd9Sstevel@tonic-gate char state_name[MAX_SCF_STATE_STRING_SZ]; 13287c478bd9Sstevel@tonic-gate 13297c478bd9Sstevel@tonic-gate if (wip->pg == NULL) { 13307c478bd9Sstevel@tonic-gate get_restarter_string_prop(wip->inst, scf_property_state, 13317c478bd9Sstevel@tonic-gate state_name, sizeof (state_name)); 13327c478bd9Sstevel@tonic-gate get_restarter_string_prop(wip->inst, scf_property_next_state, 13337c478bd9Sstevel@tonic-gate nstate_name, sizeof (nstate_name)); 13347c478bd9Sstevel@tonic-gate tmp[0] = state_to_char(state_name); 13357c478bd9Sstevel@tonic-gate 13367c478bd9Sstevel@tonic-gate if (strcmp(nstate_name, SCF_STATE_STRING_NONE) == 0) 13377c478bd9Sstevel@tonic-gate tmp[1] = '-'; 13387c478bd9Sstevel@tonic-gate else 13397c478bd9Sstevel@tonic-gate tmp[1] = state_to_char(nstate_name); 13407c478bd9Sstevel@tonic-gate } else { 13417c478bd9Sstevel@tonic-gate tmp[0] = 'L'; 13427c478bd9Sstevel@tonic-gate tmp[1] = '-'; 13437c478bd9Sstevel@tonic-gate } 13447c478bd9Sstevel@tonic-gate 13457c478bd9Sstevel@tonic-gate tmp[2] = ' '; 13467c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "", 13477c478bd9Sstevel@tonic-gate 3, tmp); 13487c478bd9Sstevel@tonic-gate if (*buf) 13497c478bd9Sstevel@tonic-gate free(*buf); 13507c478bd9Sstevel@tonic-gate *buf = newbuf; 13517c478bd9Sstevel@tonic-gate } 13527c478bd9Sstevel@tonic-gate 13537c478bd9Sstevel@tonic-gate /* ARGSUSED */ 13547c478bd9Sstevel@tonic-gate static void 13557c478bd9Sstevel@tonic-gate sortkey_sn(char *buf, int reverse, scf_walkinfo_t *wip) 13567c478bd9Sstevel@tonic-gate { 13577c478bd9Sstevel@tonic-gate sortkey_state(buf, reverse, wip); 13587c478bd9Sstevel@tonic-gate sortkey_nstate(buf + 1, reverse, wip); 13597c478bd9Sstevel@tonic-gate } 13607c478bd9Sstevel@tonic-gate 13617c478bd9Sstevel@tonic-gate static const char * 13627c478bd9Sstevel@tonic-gate state_abbrev(const char *state) 13637c478bd9Sstevel@tonic-gate { 13647c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_UNINIT) == 0) 13657c478bd9Sstevel@tonic-gate return ("UN"); 13667c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_OFFLINE) == 0) 13677c478bd9Sstevel@tonic-gate return ("OFF"); 13687c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_ONLINE) == 0) 13697c478bd9Sstevel@tonic-gate return ("ON"); 13707c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_MAINT) == 0) 13717c478bd9Sstevel@tonic-gate return ("MNT"); 13727c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_DISABLED) == 0) 13737c478bd9Sstevel@tonic-gate return ("DIS"); 13747c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_DEGRADED) == 0) 13757c478bd9Sstevel@tonic-gate return ("DGD"); 13767c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_LEGACY) == 0) 13777c478bd9Sstevel@tonic-gate return ("LRC"); 13787c478bd9Sstevel@tonic-gate 13797c478bd9Sstevel@tonic-gate return ("?"); 13807c478bd9Sstevel@tonic-gate } 13817c478bd9Sstevel@tonic-gate 13827c478bd9Sstevel@tonic-gate static void 13837c478bd9Sstevel@tonic-gate sprint_sta(char **buf, scf_walkinfo_t *wip) 13847c478bd9Sstevel@tonic-gate { 13857c478bd9Sstevel@tonic-gate char state_name[MAX_SCF_STATE_STRING_SZ]; 13867c478bd9Sstevel@tonic-gate char sta[5]; 13877c478bd9Sstevel@tonic-gate size_t newsize = (*buf ? strlen(*buf) : 0) + 6; 13887c478bd9Sstevel@tonic-gate char *newbuf = safe_malloc(newsize); 13897c478bd9Sstevel@tonic-gate 13907c478bd9Sstevel@tonic-gate if (wip->pg == NULL) 13917c478bd9Sstevel@tonic-gate get_restarter_string_prop(wip->inst, scf_property_state, 13927c478bd9Sstevel@tonic-gate state_name, sizeof (state_name)); 13937c478bd9Sstevel@tonic-gate else 13947c478bd9Sstevel@tonic-gate (void) strcpy(state_name, SCF_STATE_STRING_LEGACY); 13957c478bd9Sstevel@tonic-gate 13967c478bd9Sstevel@tonic-gate (void) strcpy(sta, state_abbrev(state_name)); 13977c478bd9Sstevel@tonic-gate 13987c478bd9Sstevel@tonic-gate if (wip->pg == NULL && !opt_nstate_shown && transitioning(wip->inst)) 13997c478bd9Sstevel@tonic-gate (void) strcat(sta, "*"); 14007c478bd9Sstevel@tonic-gate 14017c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-4s ", *buf ? *buf : "", sta); 14027c478bd9Sstevel@tonic-gate if (*buf) 14037c478bd9Sstevel@tonic-gate free(*buf); 14047c478bd9Sstevel@tonic-gate *buf = newbuf; 14057c478bd9Sstevel@tonic-gate } 14067c478bd9Sstevel@tonic-gate 14077c478bd9Sstevel@tonic-gate static void 14087c478bd9Sstevel@tonic-gate sprint_nsta(char **buf, scf_walkinfo_t *wip) 14097c478bd9Sstevel@tonic-gate { 14107c478bd9Sstevel@tonic-gate char state_name[MAX_SCF_STATE_STRING_SZ]; 14117c478bd9Sstevel@tonic-gate size_t newsize = (*buf ? strlen(*buf) : 0) + 6; 14127c478bd9Sstevel@tonic-gate char *newbuf = safe_malloc(newsize); 14137c478bd9Sstevel@tonic-gate 14147c478bd9Sstevel@tonic-gate if (wip->pg == NULL) 14157c478bd9Sstevel@tonic-gate get_restarter_string_prop(wip->inst, scf_property_next_state, 14167c478bd9Sstevel@tonic-gate state_name, sizeof (state_name)); 14177c478bd9Sstevel@tonic-gate else 14187c478bd9Sstevel@tonic-gate (void) strcpy(state_name, SCF_STATE_STRING_NONE); 14197c478bd9Sstevel@tonic-gate 14207c478bd9Sstevel@tonic-gate if (strcmp(state_name, SCF_STATE_STRING_NONE) == 0) 14217c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-4s ", *buf ? *buf : "", 14227c478bd9Sstevel@tonic-gate "-"); 14237c478bd9Sstevel@tonic-gate else 14247c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-4s ", *buf ? *buf : "", 14257c478bd9Sstevel@tonic-gate state_abbrev(state_name)); 14267c478bd9Sstevel@tonic-gate if (*buf) 14277c478bd9Sstevel@tonic-gate free(*buf); 14287c478bd9Sstevel@tonic-gate *buf = newbuf; 14297c478bd9Sstevel@tonic-gate } 14307c478bd9Sstevel@tonic-gate 14317c478bd9Sstevel@tonic-gate /* FMRI */ 14327c478bd9Sstevel@tonic-gate #define FMRI_COLUMN_WIDTH 50 14337c478bd9Sstevel@tonic-gate static void 14347c478bd9Sstevel@tonic-gate sprint_fmri(char **buf, scf_walkinfo_t *wip) 14357c478bd9Sstevel@tonic-gate { 14367c478bd9Sstevel@tonic-gate char *fmri_buf = safe_malloc(max_scf_fmri_length + 1); 14377c478bd9Sstevel@tonic-gate size_t newsize; 14387c478bd9Sstevel@tonic-gate char *newbuf; 14397c478bd9Sstevel@tonic-gate 14407c478bd9Sstevel@tonic-gate if (wip->pg == NULL) { 14417c478bd9Sstevel@tonic-gate if (scf_instance_to_fmri(wip->inst, fmri_buf, 14427c478bd9Sstevel@tonic-gate max_scf_fmri_length + 1) == -1) 14437c478bd9Sstevel@tonic-gate scfdie(); 14447c478bd9Sstevel@tonic-gate } else { 1445*7b209c2cSacruz (void) strcpy(fmri_buf, SCF_FMRI_LEGACY_PREFIX); 14467c478bd9Sstevel@tonic-gate if (pg_get_single_val(wip->pg, SCF_LEGACY_PROPERTY_NAME, 1447*7b209c2cSacruz SCF_TYPE_ASTRING, fmri_buf + 1448*7b209c2cSacruz sizeof (SCF_FMRI_LEGACY_PREFIX) - 1, 1449*7b209c2cSacruz max_scf_fmri_length + 1 - 1450*7b209c2cSacruz (sizeof (SCF_FMRI_LEGACY_PREFIX) - 1), 0) != 0) 14517c478bd9Sstevel@tonic-gate (void) strcat(fmri_buf, LEGACY_UNKNOWN); 14527c478bd9Sstevel@tonic-gate } 14537c478bd9Sstevel@tonic-gate 14547c478bd9Sstevel@tonic-gate if (strlen(fmri_buf) > FMRI_COLUMN_WIDTH) 14557c478bd9Sstevel@tonic-gate newsize = (*buf ? strlen(*buf) : 0) + strlen(fmri_buf) + 2; 14567c478bd9Sstevel@tonic-gate else 14577c478bd9Sstevel@tonic-gate newsize = (*buf ? strlen(*buf) : 0) + FMRI_COLUMN_WIDTH + 2; 14587c478bd9Sstevel@tonic-gate newbuf = safe_malloc(newsize); 14597c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "", 14607c478bd9Sstevel@tonic-gate FMRI_COLUMN_WIDTH, fmri_buf); 14617c478bd9Sstevel@tonic-gate free(fmri_buf); 14627c478bd9Sstevel@tonic-gate if (*buf) 14637c478bd9Sstevel@tonic-gate free(*buf); 14647c478bd9Sstevel@tonic-gate *buf = newbuf; 14657c478bd9Sstevel@tonic-gate } 14667c478bd9Sstevel@tonic-gate 14677c478bd9Sstevel@tonic-gate static void 14687c478bd9Sstevel@tonic-gate sortkey_fmri(char *buf, int reverse, scf_walkinfo_t *wip) 14697c478bd9Sstevel@tonic-gate { 14707c478bd9Sstevel@tonic-gate char *tmp = NULL; 14717c478bd9Sstevel@tonic-gate 14727c478bd9Sstevel@tonic-gate sprint_fmri(&tmp, wip); 14737c478bd9Sstevel@tonic-gate bcopy(tmp, buf, FMRI_COLUMN_WIDTH); 14747c478bd9Sstevel@tonic-gate free(tmp); 14757c478bd9Sstevel@tonic-gate if (reverse) 14767c478bd9Sstevel@tonic-gate reverse_bytes(buf, FMRI_COLUMN_WIDTH); 14777c478bd9Sstevel@tonic-gate } 14787c478bd9Sstevel@tonic-gate 14797c478bd9Sstevel@tonic-gate /* Component columns */ 14807c478bd9Sstevel@tonic-gate #define COMPONENT_COLUMN_WIDTH 20 14817c478bd9Sstevel@tonic-gate static void 14827c478bd9Sstevel@tonic-gate sprint_scope(char **buf, scf_walkinfo_t *wip) 14837c478bd9Sstevel@tonic-gate { 14847c478bd9Sstevel@tonic-gate char *scope_buf = safe_malloc(max_scf_name_length + 1); 14857c478bd9Sstevel@tonic-gate size_t newsize = (*buf ? strlen(*buf) : 0) + COMPONENT_COLUMN_WIDTH + 2; 14867c478bd9Sstevel@tonic-gate char *newbuf = safe_malloc(newsize); 14877c478bd9Sstevel@tonic-gate 14887c478bd9Sstevel@tonic-gate assert(wip->scope != NULL); 14897c478bd9Sstevel@tonic-gate 14907c478bd9Sstevel@tonic-gate if (scf_scope_get_name(wip->scope, scope_buf, max_scf_name_length) < 0) 14917c478bd9Sstevel@tonic-gate scfdie(); 14927c478bd9Sstevel@tonic-gate 14937c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "", 14947c478bd9Sstevel@tonic-gate COMPONENT_COLUMN_WIDTH, scope_buf); 14957c478bd9Sstevel@tonic-gate if (*buf) 14967c478bd9Sstevel@tonic-gate free(*buf); 14977c478bd9Sstevel@tonic-gate *buf = newbuf; 14987c478bd9Sstevel@tonic-gate free(scope_buf); 14997c478bd9Sstevel@tonic-gate } 15007c478bd9Sstevel@tonic-gate 15017c478bd9Sstevel@tonic-gate static void 15027c478bd9Sstevel@tonic-gate sortkey_scope(char *buf, int reverse, scf_walkinfo_t *wip) 15037c478bd9Sstevel@tonic-gate { 15047c478bd9Sstevel@tonic-gate char *tmp = NULL; 15057c478bd9Sstevel@tonic-gate 15067c478bd9Sstevel@tonic-gate sprint_scope(&tmp, wip); 15077c478bd9Sstevel@tonic-gate bcopy(tmp, buf, COMPONENT_COLUMN_WIDTH); 15087c478bd9Sstevel@tonic-gate free(tmp); 15097c478bd9Sstevel@tonic-gate if (reverse) 15107c478bd9Sstevel@tonic-gate reverse_bytes(buf, COMPONENT_COLUMN_WIDTH); 15117c478bd9Sstevel@tonic-gate } 15127c478bd9Sstevel@tonic-gate 15137c478bd9Sstevel@tonic-gate static void 15147c478bd9Sstevel@tonic-gate sprint_service(char **buf, scf_walkinfo_t *wip) 15157c478bd9Sstevel@tonic-gate { 15167c478bd9Sstevel@tonic-gate char *svc_buf = safe_malloc(max_scf_name_length + 1); 15177c478bd9Sstevel@tonic-gate char *newbuf; 15187c478bd9Sstevel@tonic-gate size_t newsize; 15197c478bd9Sstevel@tonic-gate 15207c478bd9Sstevel@tonic-gate if (wip->pg == NULL) { 15217c478bd9Sstevel@tonic-gate if (scf_service_get_name(wip->svc, svc_buf, 15227c478bd9Sstevel@tonic-gate max_scf_name_length + 1) < 0) 15237c478bd9Sstevel@tonic-gate scfdie(); 15247c478bd9Sstevel@tonic-gate } else { 15257c478bd9Sstevel@tonic-gate if (pg_get_single_val(wip->pg, "name", SCF_TYPE_ASTRING, 15267c478bd9Sstevel@tonic-gate svc_buf, max_scf_name_length + 1, EMPTY_OK) != 0) 15277c478bd9Sstevel@tonic-gate (void) strcpy(svc_buf, LEGACY_UNKNOWN); 15287c478bd9Sstevel@tonic-gate } 15297c478bd9Sstevel@tonic-gate 15307c478bd9Sstevel@tonic-gate 15317c478bd9Sstevel@tonic-gate if (strlen(svc_buf) > COMPONENT_COLUMN_WIDTH) 15327c478bd9Sstevel@tonic-gate newsize = (*buf ? strlen(*buf) : 0) + strlen(svc_buf) + 2; 15337c478bd9Sstevel@tonic-gate else 15347c478bd9Sstevel@tonic-gate newsize = (*buf ? strlen(*buf) : 0) + 15357c478bd9Sstevel@tonic-gate COMPONENT_COLUMN_WIDTH + 2; 15367c478bd9Sstevel@tonic-gate newbuf = safe_malloc(newsize); 15377c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "", 15387c478bd9Sstevel@tonic-gate COMPONENT_COLUMN_WIDTH, svc_buf); 15397c478bd9Sstevel@tonic-gate free(svc_buf); 15407c478bd9Sstevel@tonic-gate if (*buf) 15417c478bd9Sstevel@tonic-gate free(*buf); 15427c478bd9Sstevel@tonic-gate *buf = newbuf; 15437c478bd9Sstevel@tonic-gate } 15447c478bd9Sstevel@tonic-gate 15457c478bd9Sstevel@tonic-gate static void 15467c478bd9Sstevel@tonic-gate sortkey_service(char *buf, int reverse, scf_walkinfo_t *wip) 15477c478bd9Sstevel@tonic-gate { 15487c478bd9Sstevel@tonic-gate char *tmp = NULL; 15497c478bd9Sstevel@tonic-gate 15507c478bd9Sstevel@tonic-gate sprint_service(&tmp, wip); 15517c478bd9Sstevel@tonic-gate bcopy(tmp, buf, COMPONENT_COLUMN_WIDTH); 15527c478bd9Sstevel@tonic-gate free(tmp); 15537c478bd9Sstevel@tonic-gate if (reverse) 15547c478bd9Sstevel@tonic-gate reverse_bytes(buf, COMPONENT_COLUMN_WIDTH); 15557c478bd9Sstevel@tonic-gate } 15567c478bd9Sstevel@tonic-gate 15577c478bd9Sstevel@tonic-gate /* INST */ 15587c478bd9Sstevel@tonic-gate static void 15597c478bd9Sstevel@tonic-gate sprint_instance(char **buf, scf_walkinfo_t *wip) 15607c478bd9Sstevel@tonic-gate { 15617c478bd9Sstevel@tonic-gate char *tmp = safe_malloc(max_scf_name_length + 1); 15627c478bd9Sstevel@tonic-gate size_t newsize = (*buf ? strlen(*buf) : 0) + COMPONENT_COLUMN_WIDTH + 2; 15637c478bd9Sstevel@tonic-gate char *newbuf = safe_malloc(newsize); 15647c478bd9Sstevel@tonic-gate 15657c478bd9Sstevel@tonic-gate if (wip->pg == NULL) { 15667c478bd9Sstevel@tonic-gate if (scf_instance_get_name(wip->inst, tmp, 15677c478bd9Sstevel@tonic-gate max_scf_name_length + 1) < 0) 15687c478bd9Sstevel@tonic-gate scfdie(); 15697c478bd9Sstevel@tonic-gate } else { 15707c478bd9Sstevel@tonic-gate tmp[0] = '-'; 15717c478bd9Sstevel@tonic-gate tmp[1] = '\0'; 15727c478bd9Sstevel@tonic-gate } 15737c478bd9Sstevel@tonic-gate 15747c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "", 15757c478bd9Sstevel@tonic-gate COMPONENT_COLUMN_WIDTH, tmp); 15767c478bd9Sstevel@tonic-gate if (*buf) 15777c478bd9Sstevel@tonic-gate free(*buf); 15787c478bd9Sstevel@tonic-gate *buf = newbuf; 15797c478bd9Sstevel@tonic-gate free(tmp); 15807c478bd9Sstevel@tonic-gate } 15817c478bd9Sstevel@tonic-gate 15827c478bd9Sstevel@tonic-gate static void 15837c478bd9Sstevel@tonic-gate sortkey_instance(char *buf, int reverse, scf_walkinfo_t *wip) 15847c478bd9Sstevel@tonic-gate { 15857c478bd9Sstevel@tonic-gate char *tmp = NULL; 15867c478bd9Sstevel@tonic-gate 15877c478bd9Sstevel@tonic-gate sprint_instance(&tmp, wip); 15887c478bd9Sstevel@tonic-gate bcopy(tmp, buf, COMPONENT_COLUMN_WIDTH); 15897c478bd9Sstevel@tonic-gate free(tmp); 15907c478bd9Sstevel@tonic-gate if (reverse) 15917c478bd9Sstevel@tonic-gate reverse_bytes(buf, COMPONENT_COLUMN_WIDTH); 15927c478bd9Sstevel@tonic-gate } 15937c478bd9Sstevel@tonic-gate 15947c478bd9Sstevel@tonic-gate /* STIME */ 15957c478bd9Sstevel@tonic-gate #define STIME_COLUMN_WIDTH 8 15967c478bd9Sstevel@tonic-gate #define FORMAT_TIME "%k:%M:%S" 15977c478bd9Sstevel@tonic-gate #define FORMAT_DATE "%b_%d " 15987c478bd9Sstevel@tonic-gate #define FORMAT_YEAR "%Y " 15997c478bd9Sstevel@tonic-gate 16007c478bd9Sstevel@tonic-gate static void 16017c478bd9Sstevel@tonic-gate sprint_stime(char **buf, scf_walkinfo_t *wip) 16027c478bd9Sstevel@tonic-gate { 16037c478bd9Sstevel@tonic-gate int r; 16047c478bd9Sstevel@tonic-gate struct timeval tv; 16057c478bd9Sstevel@tonic-gate time_t then; 16067c478bd9Sstevel@tonic-gate struct tm *tm; 16077c478bd9Sstevel@tonic-gate char st_buf[STIME_COLUMN_WIDTH + 1]; 16087c478bd9Sstevel@tonic-gate size_t newsize = (*buf ? strlen(*buf) : 0) + STIME_COLUMN_WIDTH + 2; 16097c478bd9Sstevel@tonic-gate char *newbuf = safe_malloc(newsize); 16107c478bd9Sstevel@tonic-gate 16117c478bd9Sstevel@tonic-gate if (wip->pg == NULL) { 16127c478bd9Sstevel@tonic-gate r = get_restarter_time_prop(wip->inst, 16137c478bd9Sstevel@tonic-gate SCF_PROPERTY_STATE_TIMESTAMP, &tv, 0); 16147c478bd9Sstevel@tonic-gate } else { 16157c478bd9Sstevel@tonic-gate r = pg_get_single_val(wip->pg, SCF_PROPERTY_STATE_TIMESTAMP, 16167c478bd9Sstevel@tonic-gate SCF_TYPE_TIME, &tv, NULL, 0); 16177c478bd9Sstevel@tonic-gate } 16187c478bd9Sstevel@tonic-gate 16197c478bd9Sstevel@tonic-gate if (r != 0) { 16207c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s", *buf ? *buf : "", 16217c478bd9Sstevel@tonic-gate STIME_COLUMN_WIDTH + 1, "?"); 16227c478bd9Sstevel@tonic-gate return; 16237c478bd9Sstevel@tonic-gate } 16247c478bd9Sstevel@tonic-gate 16257c478bd9Sstevel@tonic-gate then = (time_t)tv.tv_sec; 16267c478bd9Sstevel@tonic-gate 16277c478bd9Sstevel@tonic-gate tm = localtime(&then); 16287c478bd9Sstevel@tonic-gate /* 16297c478bd9Sstevel@tonic-gate * Print time if started within the past 24 hours, print date 16307c478bd9Sstevel@tonic-gate * if within the past 12 months, print year if started greater than 16317c478bd9Sstevel@tonic-gate * 12 months ago. 16327c478bd9Sstevel@tonic-gate */ 16337c478bd9Sstevel@tonic-gate if (now - then < 24 * 60 * 60) 16347c478bd9Sstevel@tonic-gate (void) strftime(st_buf, sizeof (st_buf), gettext(FORMAT_TIME), 16353eae19d9Swesolows tm); 16367c478bd9Sstevel@tonic-gate else if (now - then < 12 * 30 * 24 * 60 * 60) 16377c478bd9Sstevel@tonic-gate (void) strftime(st_buf, sizeof (st_buf), gettext(FORMAT_DATE), 16383eae19d9Swesolows tm); 16397c478bd9Sstevel@tonic-gate else 16407c478bd9Sstevel@tonic-gate (void) strftime(st_buf, sizeof (st_buf), gettext(FORMAT_YEAR), 16413eae19d9Swesolows tm); 16427c478bd9Sstevel@tonic-gate 16437c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "", 16447c478bd9Sstevel@tonic-gate STIME_COLUMN_WIDTH + 1, st_buf); 16457c478bd9Sstevel@tonic-gate if (*buf) 16467c478bd9Sstevel@tonic-gate free(*buf); 16477c478bd9Sstevel@tonic-gate *buf = newbuf; 16487c478bd9Sstevel@tonic-gate } 16497c478bd9Sstevel@tonic-gate 16507c478bd9Sstevel@tonic-gate #define STIME_SORTKEY_WIDTH (sizeof (uint64_t) + sizeof (uint32_t)) 16517c478bd9Sstevel@tonic-gate 16527c478bd9Sstevel@tonic-gate /* ARGSUSED */ 16537c478bd9Sstevel@tonic-gate static void 16547c478bd9Sstevel@tonic-gate sortkey_stime(char *buf, int reverse, scf_walkinfo_t *wip) 16557c478bd9Sstevel@tonic-gate { 16567c478bd9Sstevel@tonic-gate struct timeval tv; 16577c478bd9Sstevel@tonic-gate int r; 16587c478bd9Sstevel@tonic-gate 16597c478bd9Sstevel@tonic-gate if (wip->pg == NULL) 16607c478bd9Sstevel@tonic-gate r = get_restarter_time_prop(wip->inst, 16617c478bd9Sstevel@tonic-gate SCF_PROPERTY_STATE_TIMESTAMP, &tv, 0); 16627c478bd9Sstevel@tonic-gate else 16637c478bd9Sstevel@tonic-gate r = pg_get_single_val(wip->pg, SCF_PROPERTY_STATE_TIMESTAMP, 16647c478bd9Sstevel@tonic-gate SCF_TYPE_TIME, &tv, NULL, 0); 16657c478bd9Sstevel@tonic-gate 16667c478bd9Sstevel@tonic-gate if (r == 0) { 16677c478bd9Sstevel@tonic-gate int64_t sec; 16687c478bd9Sstevel@tonic-gate int32_t us; 16697c478bd9Sstevel@tonic-gate 16707c478bd9Sstevel@tonic-gate /* Stick it straight into the buffer. */ 16717c478bd9Sstevel@tonic-gate sec = tv.tv_sec; 16727c478bd9Sstevel@tonic-gate us = tv.tv_usec; 16737c478bd9Sstevel@tonic-gate 16747c478bd9Sstevel@tonic-gate sec = BE_64(sec); 16757c478bd9Sstevel@tonic-gate us = BE_32(us); 16767c478bd9Sstevel@tonic-gate bcopy(&sec, buf, sizeof (sec)); 16777c478bd9Sstevel@tonic-gate bcopy(&us, buf + sizeof (sec), sizeof (us)); 16787c478bd9Sstevel@tonic-gate } else { 16797c478bd9Sstevel@tonic-gate bzero(buf, STIME_SORTKEY_WIDTH); 16807c478bd9Sstevel@tonic-gate } 16817c478bd9Sstevel@tonic-gate 16827c478bd9Sstevel@tonic-gate if (reverse) 16837c478bd9Sstevel@tonic-gate reverse_bytes(buf, STIME_SORTKEY_WIDTH); 16847c478bd9Sstevel@tonic-gate } 16857c478bd9Sstevel@tonic-gate 16867c478bd9Sstevel@tonic-gate 16877c478bd9Sstevel@tonic-gate /* 16887c478bd9Sstevel@tonic-gate * Information about columns which can be displayed. If you add something, 16897c478bd9Sstevel@tonic-gate * check MAX_COLUMN_NAME_LENGTH_STR & update description_of_column() below. 16907c478bd9Sstevel@tonic-gate */ 16917c478bd9Sstevel@tonic-gate static const struct column columns[] = { 16927c478bd9Sstevel@tonic-gate { "CTID", CTID_COLUMN_WIDTH, sprint_ctid, 16937c478bd9Sstevel@tonic-gate CTID_SORTKEY_WIDTH, sortkey_ctid }, 16947c478bd9Sstevel@tonic-gate { "DESC", DESC_COLUMN_WIDTH, sprint_desc, 16957c478bd9Sstevel@tonic-gate DESC_COLUMN_WIDTH, sortkey_desc }, 16967c478bd9Sstevel@tonic-gate { "FMRI", FMRI_COLUMN_WIDTH, sprint_fmri, 16977c478bd9Sstevel@tonic-gate FMRI_COLUMN_WIDTH, sortkey_fmri }, 16987c478bd9Sstevel@tonic-gate { "INST", COMPONENT_COLUMN_WIDTH, sprint_instance, 16997c478bd9Sstevel@tonic-gate COMPONENT_COLUMN_WIDTH, sortkey_instance }, 17007c478bd9Sstevel@tonic-gate { "N", 1, sprint_n, 1, sortkey_nstate }, 17017c478bd9Sstevel@tonic-gate { "NSTA", 4, sprint_nsta, 1, sortkey_nstate }, 17027c478bd9Sstevel@tonic-gate { "NSTATE", MAX_SCF_STATE_STRING_SZ - 1, sprint_nstate, 17037c478bd9Sstevel@tonic-gate 1, sortkey_nstate }, 17047c478bd9Sstevel@tonic-gate { "S", 2, sprint_s, 1, sortkey_state }, 17057c478bd9Sstevel@tonic-gate { "SCOPE", COMPONENT_COLUMN_WIDTH, sprint_scope, 17067c478bd9Sstevel@tonic-gate COMPONENT_COLUMN_WIDTH, sortkey_scope }, 17077c478bd9Sstevel@tonic-gate { "SN", 2, sprint_sn, 2, sortkey_sn }, 17087c478bd9Sstevel@tonic-gate { "SVC", COMPONENT_COLUMN_WIDTH, sprint_service, 17097c478bd9Sstevel@tonic-gate COMPONENT_COLUMN_WIDTH, sortkey_service }, 17107c478bd9Sstevel@tonic-gate { "STA", 4, sprint_sta, 1, sortkey_state }, 17117c478bd9Sstevel@tonic-gate { "STATE", MAX_SCF_STATE_STRING_SZ - 1 + 1, sprint_state, 17127c478bd9Sstevel@tonic-gate 1, sortkey_state }, 17137c478bd9Sstevel@tonic-gate { "STIME", STIME_COLUMN_WIDTH, sprint_stime, 17147c478bd9Sstevel@tonic-gate STIME_SORTKEY_WIDTH, sortkey_stime }, 17157c478bd9Sstevel@tonic-gate }; 17167c478bd9Sstevel@tonic-gate 17177c478bd9Sstevel@tonic-gate #define MAX_COLUMN_NAME_LENGTH_STR "6" 17187c478bd9Sstevel@tonic-gate 17197c478bd9Sstevel@tonic-gate static const int ncolumns = sizeof (columns) / sizeof (columns[0]); 17207c478bd9Sstevel@tonic-gate 17217c478bd9Sstevel@tonic-gate /* 17227c478bd9Sstevel@tonic-gate * Necessary thanks to gettext() & xgettext. 17237c478bd9Sstevel@tonic-gate */ 17247c478bd9Sstevel@tonic-gate static const char * 17257c478bd9Sstevel@tonic-gate description_of_column(int c) 17267c478bd9Sstevel@tonic-gate { 17277c478bd9Sstevel@tonic-gate const char *s = NULL; 17287c478bd9Sstevel@tonic-gate 17297c478bd9Sstevel@tonic-gate switch (c) { 17307c478bd9Sstevel@tonic-gate case 0: 17317c478bd9Sstevel@tonic-gate s = gettext("contract ID for service (see contract(4))"); 17327c478bd9Sstevel@tonic-gate break; 17337c478bd9Sstevel@tonic-gate case 1: 17347c478bd9Sstevel@tonic-gate s = gettext("human-readable description of the service"); 17357c478bd9Sstevel@tonic-gate break; 17367c478bd9Sstevel@tonic-gate case 2: 17377c478bd9Sstevel@tonic-gate s = gettext("Fault Managed Resource Identifier for service"); 17387c478bd9Sstevel@tonic-gate break; 17397c478bd9Sstevel@tonic-gate case 3: 17407c478bd9Sstevel@tonic-gate s = gettext("portion of the FMRI indicating service instance"); 17417c478bd9Sstevel@tonic-gate break; 17427c478bd9Sstevel@tonic-gate case 4: 17437c478bd9Sstevel@tonic-gate s = gettext("abbreviation for next state (if in transition)"); 17447c478bd9Sstevel@tonic-gate break; 17457c478bd9Sstevel@tonic-gate case 5: 17467c478bd9Sstevel@tonic-gate s = gettext("abbreviation for next state (if in transition)"); 17477c478bd9Sstevel@tonic-gate break; 17487c478bd9Sstevel@tonic-gate case 6: 17497c478bd9Sstevel@tonic-gate s = gettext("name for next state (if in transition)"); 17507c478bd9Sstevel@tonic-gate break; 17517c478bd9Sstevel@tonic-gate case 7: 17527c478bd9Sstevel@tonic-gate s = gettext("abbreviation for current state"); 17537c478bd9Sstevel@tonic-gate break; 17547c478bd9Sstevel@tonic-gate case 8: 17557c478bd9Sstevel@tonic-gate s = gettext("name for scope associated with service"); 17567c478bd9Sstevel@tonic-gate break; 17577c478bd9Sstevel@tonic-gate case 9: 17587c478bd9Sstevel@tonic-gate s = gettext("abbreviation for current state and next state"); 17597c478bd9Sstevel@tonic-gate break; 17607c478bd9Sstevel@tonic-gate case 10: 17617c478bd9Sstevel@tonic-gate s = gettext("portion of the FMRI representing service name"); 17627c478bd9Sstevel@tonic-gate break; 17637c478bd9Sstevel@tonic-gate case 11: 17647c478bd9Sstevel@tonic-gate s = gettext("abbreviation for current state"); 17657c478bd9Sstevel@tonic-gate break; 17667c478bd9Sstevel@tonic-gate case 12: 17677c478bd9Sstevel@tonic-gate s = gettext("name for current state"); 17687c478bd9Sstevel@tonic-gate break; 17697c478bd9Sstevel@tonic-gate case 13: 17707c478bd9Sstevel@tonic-gate s = gettext("time of last state change"); 17717c478bd9Sstevel@tonic-gate break; 17727c478bd9Sstevel@tonic-gate } 17737c478bd9Sstevel@tonic-gate 17747c478bd9Sstevel@tonic-gate assert(s != NULL); 17757c478bd9Sstevel@tonic-gate return (s); 17767c478bd9Sstevel@tonic-gate } 17777c478bd9Sstevel@tonic-gate 17787c478bd9Sstevel@tonic-gate 17797c478bd9Sstevel@tonic-gate static void 17807c478bd9Sstevel@tonic-gate print_usage(const char *progname, FILE *f, boolean_t do_exit) 17817c478bd9Sstevel@tonic-gate { 17827c478bd9Sstevel@tonic-gate (void) fprintf(f, gettext( 17837c478bd9Sstevel@tonic-gate "Usage: %1$s [-aHpv] [-o col[,col ... ]] [-R restarter] " 17847c478bd9Sstevel@tonic-gate "[-sS col] [<service> ...]\n" 17857c478bd9Sstevel@tonic-gate " %1$s -d | -D [-Hpv] [-o col[,col ... ]] [-sS col] " 17867c478bd9Sstevel@tonic-gate "[<service> ...]\n" 17877c478bd9Sstevel@tonic-gate " %1$s -l <service> ...\n" 17887c478bd9Sstevel@tonic-gate " %1$s -x [-v] [<service> ...]\n" 17897c478bd9Sstevel@tonic-gate " %1$s -?\n"), progname); 17907c478bd9Sstevel@tonic-gate 17917c478bd9Sstevel@tonic-gate if (do_exit) 17927c478bd9Sstevel@tonic-gate exit(UU_EXIT_USAGE); 17937c478bd9Sstevel@tonic-gate } 17947c478bd9Sstevel@tonic-gate 17957c478bd9Sstevel@tonic-gate #define argserr(progname) print_usage(progname, stderr, B_TRUE) 17967c478bd9Sstevel@tonic-gate 17977c478bd9Sstevel@tonic-gate static void 17987c478bd9Sstevel@tonic-gate print_help(const char *progname) 17997c478bd9Sstevel@tonic-gate { 18007c478bd9Sstevel@tonic-gate int i; 18017c478bd9Sstevel@tonic-gate 18027c478bd9Sstevel@tonic-gate print_usage(progname, stdout, B_FALSE); 18037c478bd9Sstevel@tonic-gate 18047c478bd9Sstevel@tonic-gate (void) printf(gettext("\n" 18057c478bd9Sstevel@tonic-gate "\t-a list all service instances rather than " 18067c478bd9Sstevel@tonic-gate "only those that are enabled\n" 18077c478bd9Sstevel@tonic-gate "\t-d list dependencies of the specified service(s)\n" 18087c478bd9Sstevel@tonic-gate "\t-D list dependents of the specified service(s)\n" 18097c478bd9Sstevel@tonic-gate "\t-H omit header line from output\n" 18107c478bd9Sstevel@tonic-gate "\t-l list detailed information about the specified service(s)\n" 18117c478bd9Sstevel@tonic-gate "\t-o list only the specified columns in the output\n" 18127c478bd9Sstevel@tonic-gate "\t-p list process IDs and names associated with each service\n" 18137c478bd9Sstevel@tonic-gate "\t-R list only those services with the specified restarter\n" 18147c478bd9Sstevel@tonic-gate "\t-s sort output in ascending order by the specified column(s)\n" 18157c478bd9Sstevel@tonic-gate "\t-S sort output in descending order by the specified column(s)\n" 18167c478bd9Sstevel@tonic-gate "\t-v list verbose information appropriate to the type of output\n" 18177c478bd9Sstevel@tonic-gate "\t-x explain the status of services that might require maintenance,\n" 18187c478bd9Sstevel@tonic-gate "\t or explain the status of the specified service(s)\n" 18197c478bd9Sstevel@tonic-gate "\n\t" 18207c478bd9Sstevel@tonic-gate "Services can be specified using an FMRI, abbreviation, or fnmatch(5)\n" 18217c478bd9Sstevel@tonic-gate "\tpattern, as shown in these examples for svc:/network/smtp:sendmail\n" 18227c478bd9Sstevel@tonic-gate "\n" 18237c478bd9Sstevel@tonic-gate "\t%1$s [opts] svc:/network/smtp:sendmail\n" 18247c478bd9Sstevel@tonic-gate "\t%1$s [opts] network/smtp:sendmail\n" 18257c478bd9Sstevel@tonic-gate "\t%1$s [opts] network/*mail\n" 18267c478bd9Sstevel@tonic-gate "\t%1$s [opts] network/smtp\n" 18277c478bd9Sstevel@tonic-gate "\t%1$s [opts] smtp:sendmail\n" 18287c478bd9Sstevel@tonic-gate "\t%1$s [opts] smtp\n" 18297c478bd9Sstevel@tonic-gate "\t%1$s [opts] sendmail\n" 18307c478bd9Sstevel@tonic-gate "\n\t" 18317c478bd9Sstevel@tonic-gate "Columns for output or sorting can be specified using these names:\n" 18327c478bd9Sstevel@tonic-gate "\n"), progname); 18337c478bd9Sstevel@tonic-gate 18347c478bd9Sstevel@tonic-gate for (i = 0; i < ncolumns; i++) { 18357c478bd9Sstevel@tonic-gate (void) printf("\t%-" MAX_COLUMN_NAME_LENGTH_STR "s %s\n", 18367c478bd9Sstevel@tonic-gate columns[i].name, description_of_column(i)); 18377c478bd9Sstevel@tonic-gate } 18387c478bd9Sstevel@tonic-gate } 18397c478bd9Sstevel@tonic-gate 18407c478bd9Sstevel@tonic-gate 18417c478bd9Sstevel@tonic-gate /* 18427c478bd9Sstevel@tonic-gate * A getsubopt()-like function which returns an index into the columns table. 18437c478bd9Sstevel@tonic-gate * On success, *optionp is set to point to the next sub-option, or the 18447c478bd9Sstevel@tonic-gate * terminating null if there are none. 18457c478bd9Sstevel@tonic-gate */ 18467c478bd9Sstevel@tonic-gate static int 18477c478bd9Sstevel@tonic-gate getcolumnopt(char **optionp) 18487c478bd9Sstevel@tonic-gate { 18497c478bd9Sstevel@tonic-gate char *str = *optionp, *cp; 18507c478bd9Sstevel@tonic-gate int i; 18517c478bd9Sstevel@tonic-gate 18527c478bd9Sstevel@tonic-gate assert(optionp != NULL); 18537c478bd9Sstevel@tonic-gate assert(*optionp != NULL); 18547c478bd9Sstevel@tonic-gate 18557c478bd9Sstevel@tonic-gate cp = strchr(*optionp, ','); 18567c478bd9Sstevel@tonic-gate if (cp != NULL) 18577c478bd9Sstevel@tonic-gate *cp = '\0'; 18587c478bd9Sstevel@tonic-gate 18597c478bd9Sstevel@tonic-gate for (i = 0; i < ncolumns; ++i) { 18607c478bd9Sstevel@tonic-gate if (strcasecmp(str, columns[i].name) == 0) { 18617c478bd9Sstevel@tonic-gate if (cp != NULL) 18627c478bd9Sstevel@tonic-gate *optionp = cp + 1; 18637c478bd9Sstevel@tonic-gate else 18647c478bd9Sstevel@tonic-gate *optionp = strchr(*optionp, '\0'); 18657c478bd9Sstevel@tonic-gate 18667c478bd9Sstevel@tonic-gate return (i); 18677c478bd9Sstevel@tonic-gate } 18687c478bd9Sstevel@tonic-gate } 18697c478bd9Sstevel@tonic-gate 18707c478bd9Sstevel@tonic-gate return (-1); 18717c478bd9Sstevel@tonic-gate } 18727c478bd9Sstevel@tonic-gate 18737c478bd9Sstevel@tonic-gate static void 18747c478bd9Sstevel@tonic-gate print_header() 18757c478bd9Sstevel@tonic-gate { 18767c478bd9Sstevel@tonic-gate int i; 18777c478bd9Sstevel@tonic-gate char *line_buf, *cp; 18787c478bd9Sstevel@tonic-gate 18797c478bd9Sstevel@tonic-gate line_buf = safe_malloc(line_sz); 18807c478bd9Sstevel@tonic-gate cp = line_buf; 18817c478bd9Sstevel@tonic-gate for (i = 0; i < opt_cnum; ++i) { 18827c478bd9Sstevel@tonic-gate const struct column * const colp = &columns[opt_columns[i]]; 18837c478bd9Sstevel@tonic-gate 18847c478bd9Sstevel@tonic-gate (void) snprintf(cp, colp->width + 1, "%-*s", colp->width, 18857c478bd9Sstevel@tonic-gate colp->name); 18867c478bd9Sstevel@tonic-gate cp += colp->width; 18877c478bd9Sstevel@tonic-gate *cp++ = ' '; 18887c478bd9Sstevel@tonic-gate } 18897c478bd9Sstevel@tonic-gate 18907c478bd9Sstevel@tonic-gate /* Trim the trailing whitespace */ 18917c478bd9Sstevel@tonic-gate --cp; 18927c478bd9Sstevel@tonic-gate while (*cp == ' ') 18937c478bd9Sstevel@tonic-gate --cp; 18947c478bd9Sstevel@tonic-gate *(cp+1) = '\0'; 18957c478bd9Sstevel@tonic-gate (void) puts(line_buf); 18967c478bd9Sstevel@tonic-gate 18977c478bd9Sstevel@tonic-gate free(line_buf); 18987c478bd9Sstevel@tonic-gate } 18997c478bd9Sstevel@tonic-gate 19007c478bd9Sstevel@tonic-gate 19017c478bd9Sstevel@tonic-gate 19027c478bd9Sstevel@tonic-gate /* 19037c478bd9Sstevel@tonic-gate * Long listing (-l) functions. 19047c478bd9Sstevel@tonic-gate */ 19057c478bd9Sstevel@tonic-gate 19067c478bd9Sstevel@tonic-gate static int 19077c478bd9Sstevel@tonic-gate pidcmp(const void *l, const void *r) 19087c478bd9Sstevel@tonic-gate { 19097c478bd9Sstevel@tonic-gate pid_t lp = *(pid_t *)l, rp = *(pid_t *)r; 19107c478bd9Sstevel@tonic-gate 19117c478bd9Sstevel@tonic-gate if (lp < rp) 19127c478bd9Sstevel@tonic-gate return (-1); 19137c478bd9Sstevel@tonic-gate if (lp > rp) 19147c478bd9Sstevel@tonic-gate return (1); 19157c478bd9Sstevel@tonic-gate return (0); 19167c478bd9Sstevel@tonic-gate } 19177c478bd9Sstevel@tonic-gate 19187c478bd9Sstevel@tonic-gate /* 19197c478bd9Sstevel@tonic-gate * This is the strlen() of the longest label ("description"), plus intercolumn 19207c478bd9Sstevel@tonic-gate * space. 19217c478bd9Sstevel@tonic-gate */ 19227c478bd9Sstevel@tonic-gate #define DETAILED_WIDTH (11 + 2) 19237c478bd9Sstevel@tonic-gate 192494501b61Sskamm /* 192594501b61Sskamm * Callback routine to print header for contract id. 192694501b61Sskamm * Called by ctids_by_restarter and print_detailed. 192794501b61Sskamm */ 192894501b61Sskamm static void 192994501b61Sskamm print_ctid_header() 193094501b61Sskamm { 193194501b61Sskamm (void) printf("%-*s", DETAILED_WIDTH, "contract_id"); 193294501b61Sskamm } 193394501b61Sskamm 193494501b61Sskamm /* 193594501b61Sskamm * Callback routine to print a contract id. 193694501b61Sskamm * Called by ctids_by_restarter and print_detailed. 193794501b61Sskamm */ 193894501b61Sskamm static void 193994501b61Sskamm print_ctid_detailed(uint64_t c) 194094501b61Sskamm { 194194501b61Sskamm (void) printf("%lu ", (ctid_t)c); 194294501b61Sskamm } 194394501b61Sskamm 19447c478bd9Sstevel@tonic-gate static void 194594501b61Sskamm detailed_list_processes(scf_walkinfo_t *wip) 19467c478bd9Sstevel@tonic-gate { 19477c478bd9Sstevel@tonic-gate uint64_t c; 19487c478bd9Sstevel@tonic-gate pid_t *pids; 19497c478bd9Sstevel@tonic-gate uint_t i, n; 19507c478bd9Sstevel@tonic-gate psinfo_t psi; 19517c478bd9Sstevel@tonic-gate 195294501b61Sskamm if (get_restarter_count_prop(wip->inst, scf_property_contract, &c, 19537c478bd9Sstevel@tonic-gate EMPTY_OK) != 0) 19547c478bd9Sstevel@tonic-gate return; 19557c478bd9Sstevel@tonic-gate 195694501b61Sskamm if (instance_processes(wip->inst, wip->fmri, &pids, &n) != 0) 19577c478bd9Sstevel@tonic-gate return; 19587c478bd9Sstevel@tonic-gate 19597c478bd9Sstevel@tonic-gate qsort(pids, n, sizeof (*pids), pidcmp); 19607c478bd9Sstevel@tonic-gate 19617c478bd9Sstevel@tonic-gate for (i = 0; i < n; ++i) { 19627c478bd9Sstevel@tonic-gate (void) printf("%-*s%lu", DETAILED_WIDTH, gettext("process"), 19637c478bd9Sstevel@tonic-gate pids[i]); 19647c478bd9Sstevel@tonic-gate 19657c478bd9Sstevel@tonic-gate if (get_psinfo(pids[i], &psi) == 0) 19667c478bd9Sstevel@tonic-gate (void) printf(" %.*s", PRARGSZ, psi.pr_psargs); 19677c478bd9Sstevel@tonic-gate 19687c478bd9Sstevel@tonic-gate (void) putchar('\n'); 19697c478bd9Sstevel@tonic-gate } 19707c478bd9Sstevel@tonic-gate 19717c478bd9Sstevel@tonic-gate free(pids); 19727c478bd9Sstevel@tonic-gate } 19737c478bd9Sstevel@tonic-gate 19747c478bd9Sstevel@tonic-gate /* 19757c478bd9Sstevel@tonic-gate * Determines the state of a dependency. If the FMRI specifies a file, then we 19767c478bd9Sstevel@tonic-gate * fake up a state based on whether we can access the file. 19777c478bd9Sstevel@tonic-gate */ 19787c478bd9Sstevel@tonic-gate static void 19797c478bd9Sstevel@tonic-gate get_fmri_state(char *fmri, char *state, size_t state_sz) 19807c478bd9Sstevel@tonic-gate { 19817c478bd9Sstevel@tonic-gate char *lfmri; 19827c478bd9Sstevel@tonic-gate const char *svc_name, *inst_name, *pg_name, *path; 19837c478bd9Sstevel@tonic-gate scf_service_t *svc; 19847c478bd9Sstevel@tonic-gate scf_instance_t *inst; 19857c478bd9Sstevel@tonic-gate scf_iter_t *iter; 19867c478bd9Sstevel@tonic-gate 19877c478bd9Sstevel@tonic-gate lfmri = safe_strdup(fmri); 19887c478bd9Sstevel@tonic-gate 19897c478bd9Sstevel@tonic-gate /* 19907c478bd9Sstevel@tonic-gate * Check for file:// dependencies 19917c478bd9Sstevel@tonic-gate */ 19927c478bd9Sstevel@tonic-gate if (scf_parse_file_fmri(lfmri, NULL, &path) == SCF_SUCCESS) { 19937c478bd9Sstevel@tonic-gate struct stat64 statbuf; 19947c478bd9Sstevel@tonic-gate const char *msg; 19957c478bd9Sstevel@tonic-gate 19967c478bd9Sstevel@tonic-gate if (stat64(path, &statbuf) == 0) 19977c478bd9Sstevel@tonic-gate msg = "online"; 19987c478bd9Sstevel@tonic-gate else if (errno == ENOENT) 19997c478bd9Sstevel@tonic-gate msg = "absent"; 20007c478bd9Sstevel@tonic-gate else 20017c478bd9Sstevel@tonic-gate msg = "unknown"; 20027c478bd9Sstevel@tonic-gate 20037c478bd9Sstevel@tonic-gate (void) strlcpy(state, msg, state_sz); 20047c478bd9Sstevel@tonic-gate return; 20057c478bd9Sstevel@tonic-gate } 20067c478bd9Sstevel@tonic-gate 20077c478bd9Sstevel@tonic-gate /* 20087c478bd9Sstevel@tonic-gate * scf_parse_file_fmri() may have overwritten part of the string, so 20097c478bd9Sstevel@tonic-gate * copy it back. 20107c478bd9Sstevel@tonic-gate */ 20117c478bd9Sstevel@tonic-gate (void) strcpy(lfmri, fmri); 20127c478bd9Sstevel@tonic-gate 20137c478bd9Sstevel@tonic-gate if (scf_parse_svc_fmri(lfmri, NULL, &svc_name, &inst_name, 20147c478bd9Sstevel@tonic-gate &pg_name, NULL) != SCF_SUCCESS) { 20157c478bd9Sstevel@tonic-gate free(lfmri); 20167c478bd9Sstevel@tonic-gate (void) strlcpy(state, "invalid", state_sz); 20177c478bd9Sstevel@tonic-gate return; 20187c478bd9Sstevel@tonic-gate } 20197c478bd9Sstevel@tonic-gate 20207c478bd9Sstevel@tonic-gate free(lfmri); 20217c478bd9Sstevel@tonic-gate 20227c478bd9Sstevel@tonic-gate if (svc_name == NULL || pg_name != NULL) { 20237c478bd9Sstevel@tonic-gate (void) strlcpy(state, "invalid", state_sz); 20247c478bd9Sstevel@tonic-gate return; 20257c478bd9Sstevel@tonic-gate } 20267c478bd9Sstevel@tonic-gate 20277c478bd9Sstevel@tonic-gate if (inst_name != NULL) { 20287c478bd9Sstevel@tonic-gate /* instance: get state */ 20297c478bd9Sstevel@tonic-gate inst = scf_instance_create(h); 20307c478bd9Sstevel@tonic-gate if (inst == NULL) 20317c478bd9Sstevel@tonic-gate scfdie(); 20327c478bd9Sstevel@tonic-gate 20337c478bd9Sstevel@tonic-gate if (scf_handle_decode_fmri(h, fmri, NULL, NULL, inst, NULL, 20347c478bd9Sstevel@tonic-gate NULL, SCF_DECODE_FMRI_EXACT) == SCF_SUCCESS) 20357c478bd9Sstevel@tonic-gate get_restarter_string_prop(inst, scf_property_state, 20367c478bd9Sstevel@tonic-gate state, state_sz); 20377c478bd9Sstevel@tonic-gate else { 20387c478bd9Sstevel@tonic-gate switch (scf_error()) { 20397c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT: 20407c478bd9Sstevel@tonic-gate (void) strlcpy(state, "invalid", state_sz); 20417c478bd9Sstevel@tonic-gate break; 20427c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND: 20437c478bd9Sstevel@tonic-gate (void) strlcpy(state, "absent", state_sz); 20447c478bd9Sstevel@tonic-gate break; 20457c478bd9Sstevel@tonic-gate 20467c478bd9Sstevel@tonic-gate default: 20477c478bd9Sstevel@tonic-gate scfdie(); 20487c478bd9Sstevel@tonic-gate } 20497c478bd9Sstevel@tonic-gate } 20507c478bd9Sstevel@tonic-gate 20517c478bd9Sstevel@tonic-gate scf_instance_destroy(inst); 20527c478bd9Sstevel@tonic-gate return; 20537c478bd9Sstevel@tonic-gate } 20547c478bd9Sstevel@tonic-gate 20557c478bd9Sstevel@tonic-gate /* 20567c478bd9Sstevel@tonic-gate * service: If only one instance, use that state. Otherwise, say 20577c478bd9Sstevel@tonic-gate * "multiple". 20587c478bd9Sstevel@tonic-gate */ 20597c478bd9Sstevel@tonic-gate if ((svc = scf_service_create(h)) == NULL || 20607c478bd9Sstevel@tonic-gate (inst = scf_instance_create(h)) == NULL || 20617c478bd9Sstevel@tonic-gate (iter = scf_iter_create(h)) == NULL) 20627c478bd9Sstevel@tonic-gate scfdie(); 20637c478bd9Sstevel@tonic-gate 20647c478bd9Sstevel@tonic-gate if (scf_handle_decode_fmri(h, fmri, NULL, svc, NULL, NULL, NULL, 20657c478bd9Sstevel@tonic-gate SCF_DECODE_FMRI_EXACT) != SCF_SUCCESS) { 20667c478bd9Sstevel@tonic-gate switch (scf_error()) { 20677c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT: 20687c478bd9Sstevel@tonic-gate (void) strlcpy(state, "invalid", state_sz); 20697c478bd9Sstevel@tonic-gate goto out; 20707c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND: 20717c478bd9Sstevel@tonic-gate (void) strlcpy(state, "absent", state_sz); 20727c478bd9Sstevel@tonic-gate goto out; 20737c478bd9Sstevel@tonic-gate 20747c478bd9Sstevel@tonic-gate default: 20757c478bd9Sstevel@tonic-gate scfdie(); 20767c478bd9Sstevel@tonic-gate } 20777c478bd9Sstevel@tonic-gate } 20787c478bd9Sstevel@tonic-gate 20797c478bd9Sstevel@tonic-gate if (scf_iter_service_instances(iter, svc) != SCF_SUCCESS) 20807c478bd9Sstevel@tonic-gate scfdie(); 20817c478bd9Sstevel@tonic-gate 20827c478bd9Sstevel@tonic-gate switch (scf_iter_next_instance(iter, inst)) { 20837c478bd9Sstevel@tonic-gate case 0: 20847c478bd9Sstevel@tonic-gate (void) strlcpy(state, "absent", state_sz); 20857c478bd9Sstevel@tonic-gate goto out; 20867c478bd9Sstevel@tonic-gate 20877c478bd9Sstevel@tonic-gate case 1: 20887c478bd9Sstevel@tonic-gate break; 20897c478bd9Sstevel@tonic-gate 20907c478bd9Sstevel@tonic-gate default: 20917c478bd9Sstevel@tonic-gate scfdie(); 20927c478bd9Sstevel@tonic-gate } 20937c478bd9Sstevel@tonic-gate 20947c478bd9Sstevel@tonic-gate /* Get the state in case this is the only instance. */ 20957c478bd9Sstevel@tonic-gate get_restarter_string_prop(inst, scf_property_state, state, state_sz); 20967c478bd9Sstevel@tonic-gate 20977c478bd9Sstevel@tonic-gate switch (scf_iter_next_instance(iter, inst)) { 20987c478bd9Sstevel@tonic-gate case 0: 20997c478bd9Sstevel@tonic-gate break; 21007c478bd9Sstevel@tonic-gate 21017c478bd9Sstevel@tonic-gate case 1: 21027c478bd9Sstevel@tonic-gate /* Nope, multiple instances. */ 21037c478bd9Sstevel@tonic-gate (void) strlcpy(state, "multiple", state_sz); 21047c478bd9Sstevel@tonic-gate goto out; 21057c478bd9Sstevel@tonic-gate 21067c478bd9Sstevel@tonic-gate default: 21077c478bd9Sstevel@tonic-gate scfdie(); 21087c478bd9Sstevel@tonic-gate } 21097c478bd9Sstevel@tonic-gate 21107c478bd9Sstevel@tonic-gate out: 21117c478bd9Sstevel@tonic-gate scf_iter_destroy(iter); 21127c478bd9Sstevel@tonic-gate scf_instance_destroy(inst); 21137c478bd9Sstevel@tonic-gate scf_service_destroy(svc); 21147c478bd9Sstevel@tonic-gate } 21157c478bd9Sstevel@tonic-gate 21167c478bd9Sstevel@tonic-gate static void 21177c478bd9Sstevel@tonic-gate print_detailed_dependency(scf_propertygroup_t *pg) 21187c478bd9Sstevel@tonic-gate { 21197c478bd9Sstevel@tonic-gate scf_property_t *eprop; 21207c478bd9Sstevel@tonic-gate scf_iter_t *iter; 21217c478bd9Sstevel@tonic-gate scf_type_t ty; 21227c478bd9Sstevel@tonic-gate char *val_buf; 21237c478bd9Sstevel@tonic-gate int i; 21247c478bd9Sstevel@tonic-gate 21257c478bd9Sstevel@tonic-gate if ((eprop = scf_property_create(h)) == NULL || 21267c478bd9Sstevel@tonic-gate (iter = scf_iter_create(h)) == NULL) 21277c478bd9Sstevel@tonic-gate scfdie(); 21287c478bd9Sstevel@tonic-gate 21297c478bd9Sstevel@tonic-gate val_buf = safe_malloc(max_scf_value_length + 1); 21307c478bd9Sstevel@tonic-gate 21317c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, SCF_PROPERTY_ENTITIES, eprop) != 21327c478bd9Sstevel@tonic-gate SCF_SUCCESS || 21337c478bd9Sstevel@tonic-gate scf_property_type(eprop, &ty) != SCF_SUCCESS || 21347c478bd9Sstevel@tonic-gate ty != SCF_TYPE_FMRI) 21357c478bd9Sstevel@tonic-gate return; 21367c478bd9Sstevel@tonic-gate 21377c478bd9Sstevel@tonic-gate (void) printf("%-*s", DETAILED_WIDTH, gettext("dependency")); 21387c478bd9Sstevel@tonic-gate 21397c478bd9Sstevel@tonic-gate /* Print the grouping */ 21407c478bd9Sstevel@tonic-gate if (pg_get_single_val(pg, SCF_PROPERTY_GROUPING, SCF_TYPE_ASTRING, 21417c478bd9Sstevel@tonic-gate val_buf, max_scf_value_length + 1, 0) == 0) 21427c478bd9Sstevel@tonic-gate (void) fputs(val_buf, stdout); 21437c478bd9Sstevel@tonic-gate else 21447c478bd9Sstevel@tonic-gate (void) putchar('?'); 21457c478bd9Sstevel@tonic-gate 21467c478bd9Sstevel@tonic-gate (void) putchar('/'); 21477c478bd9Sstevel@tonic-gate 21487c478bd9Sstevel@tonic-gate if (pg_get_single_val(pg, SCF_PROPERTY_RESTART_ON, SCF_TYPE_ASTRING, 21497c478bd9Sstevel@tonic-gate val_buf, max_scf_value_length + 1, 0) == 0) 21507c478bd9Sstevel@tonic-gate (void) fputs(val_buf, stdout); 21517c478bd9Sstevel@tonic-gate else 21527c478bd9Sstevel@tonic-gate (void) putchar('?'); 21537c478bd9Sstevel@tonic-gate 21547c478bd9Sstevel@tonic-gate /* Print the dependency entities. */ 21557c478bd9Sstevel@tonic-gate if (scf_iter_property_values(iter, eprop) == -1) 21567c478bd9Sstevel@tonic-gate scfdie(); 21577c478bd9Sstevel@tonic-gate 21587c478bd9Sstevel@tonic-gate while ((i = scf_iter_next_value(iter, g_val)) == 1) { 21597c478bd9Sstevel@tonic-gate char state[MAX_SCF_STATE_STRING_SZ]; 21607c478bd9Sstevel@tonic-gate 21617c478bd9Sstevel@tonic-gate if (scf_value_get_astring(g_val, val_buf, 21627c478bd9Sstevel@tonic-gate max_scf_value_length + 1) < 0) 21637c478bd9Sstevel@tonic-gate scfdie(); 21647c478bd9Sstevel@tonic-gate 21657c478bd9Sstevel@tonic-gate (void) putchar(' '); 21667c478bd9Sstevel@tonic-gate (void) fputs(val_buf, stdout); 21677c478bd9Sstevel@tonic-gate 21687c478bd9Sstevel@tonic-gate /* Print the state. */ 21697c478bd9Sstevel@tonic-gate state[0] = '-'; 21707c478bd9Sstevel@tonic-gate state[1] = '\0'; 21717c478bd9Sstevel@tonic-gate 21727c478bd9Sstevel@tonic-gate get_fmri_state(val_buf, state, sizeof (state)); 21737c478bd9Sstevel@tonic-gate 21747c478bd9Sstevel@tonic-gate (void) printf(" (%s)", state); 21757c478bd9Sstevel@tonic-gate } 21767c478bd9Sstevel@tonic-gate if (i == -1) 21777c478bd9Sstevel@tonic-gate scfdie(); 21787c478bd9Sstevel@tonic-gate 21797c478bd9Sstevel@tonic-gate (void) putchar('\n'); 21807c478bd9Sstevel@tonic-gate 21817c478bd9Sstevel@tonic-gate free(val_buf); 21827c478bd9Sstevel@tonic-gate scf_iter_destroy(iter); 21837c478bd9Sstevel@tonic-gate scf_property_destroy(eprop); 21847c478bd9Sstevel@tonic-gate } 21857c478bd9Sstevel@tonic-gate 21867c478bd9Sstevel@tonic-gate /* ARGSUSED */ 21877c478bd9Sstevel@tonic-gate static int 21887c478bd9Sstevel@tonic-gate print_detailed(void *unused, scf_walkinfo_t *wip) 21897c478bd9Sstevel@tonic-gate { 21907c478bd9Sstevel@tonic-gate scf_snapshot_t *snap; 21917c478bd9Sstevel@tonic-gate scf_propertygroup_t *rpg; 21927c478bd9Sstevel@tonic-gate scf_iter_t *pg_iter; 21937c478bd9Sstevel@tonic-gate 21947c478bd9Sstevel@tonic-gate char *buf; 21957c478bd9Sstevel@tonic-gate char *timebuf; 21967c478bd9Sstevel@tonic-gate size_t tbsz; 21977c478bd9Sstevel@tonic-gate int ret; 21987c478bd9Sstevel@tonic-gate uint64_t c; 21997c478bd9Sstevel@tonic-gate int temp, perm; 22007c478bd9Sstevel@tonic-gate struct timeval tv; 22017c478bd9Sstevel@tonic-gate time_t stime; 22027c478bd9Sstevel@tonic-gate struct tm *tmp; 220394501b61Sskamm int restarter_spec; 220494501b61Sskamm int restarter_ret; 22057c478bd9Sstevel@tonic-gate 22067c478bd9Sstevel@tonic-gate const char * const fmt = "%-*s%s\n"; 22077c478bd9Sstevel@tonic-gate 22087c478bd9Sstevel@tonic-gate assert(wip->pg == NULL); 22097c478bd9Sstevel@tonic-gate 22107c478bd9Sstevel@tonic-gate rpg = scf_pg_create(h); 22117c478bd9Sstevel@tonic-gate if (rpg == NULL) 22127c478bd9Sstevel@tonic-gate scfdie(); 22137c478bd9Sstevel@tonic-gate 22147c478bd9Sstevel@tonic-gate if (first_paragraph) 22157c478bd9Sstevel@tonic-gate first_paragraph = 0; 22167c478bd9Sstevel@tonic-gate else 22177c478bd9Sstevel@tonic-gate (void) putchar('\n'); 22187c478bd9Sstevel@tonic-gate 22197c478bd9Sstevel@tonic-gate buf = safe_malloc(max_scf_fmri_length + 1); 22207c478bd9Sstevel@tonic-gate 22217c478bd9Sstevel@tonic-gate if (scf_instance_to_fmri(wip->inst, buf, max_scf_fmri_length + 1) != -1) 22227c478bd9Sstevel@tonic-gate (void) printf(fmt, DETAILED_WIDTH, "fmri", buf); 22237c478bd9Sstevel@tonic-gate 22247c478bd9Sstevel@tonic-gate if (common_name_buf == NULL) 22257c478bd9Sstevel@tonic-gate common_name_buf = safe_malloc(max_scf_value_length + 1); 22267c478bd9Sstevel@tonic-gate 22277c478bd9Sstevel@tonic-gate if (inst_get_single_val(wip->inst, SCF_PG_TM_COMMON_NAME, locale, 22287c478bd9Sstevel@tonic-gate SCF_TYPE_USTRING, common_name_buf, max_scf_value_length, 0, 1, 1) 22297c478bd9Sstevel@tonic-gate == 0) 22307c478bd9Sstevel@tonic-gate (void) printf(fmt, DETAILED_WIDTH, gettext("name"), 22317c478bd9Sstevel@tonic-gate common_name_buf); 22327c478bd9Sstevel@tonic-gate else if (inst_get_single_val(wip->inst, SCF_PG_TM_COMMON_NAME, "C", 22337c478bd9Sstevel@tonic-gate SCF_TYPE_USTRING, common_name_buf, max_scf_value_length, 0, 1, 1) 22347c478bd9Sstevel@tonic-gate == 0) 22357c478bd9Sstevel@tonic-gate (void) printf(fmt, DETAILED_WIDTH, gettext("name"), 22367c478bd9Sstevel@tonic-gate common_name_buf); 22377c478bd9Sstevel@tonic-gate 22387c478bd9Sstevel@tonic-gate /* 22397c478bd9Sstevel@tonic-gate * Synthesize an 'enabled' property that hides the enabled_ovr 22407c478bd9Sstevel@tonic-gate * implementation from the user. If the service has been temporarily 22417c478bd9Sstevel@tonic-gate * set to a state other than its permanent value, alert the user with 22427c478bd9Sstevel@tonic-gate * a '(temporary)' message. 22437c478bd9Sstevel@tonic-gate */ 22447c478bd9Sstevel@tonic-gate perm = instance_enabled(wip->inst, B_FALSE); 22457c478bd9Sstevel@tonic-gate temp = instance_enabled(wip->inst, B_TRUE); 22467c478bd9Sstevel@tonic-gate if (temp != -1) { 22477c478bd9Sstevel@tonic-gate if (temp != perm) 22487c478bd9Sstevel@tonic-gate (void) printf(gettext("%-*s%s (temporary)\n"), 22497c478bd9Sstevel@tonic-gate DETAILED_WIDTH, gettext("enabled"), 22507c478bd9Sstevel@tonic-gate temp ? gettext("true") : gettext("false")); 22517c478bd9Sstevel@tonic-gate else 22527c478bd9Sstevel@tonic-gate (void) printf(fmt, DETAILED_WIDTH, 22537c478bd9Sstevel@tonic-gate gettext("enabled"), temp ? gettext("true") : 22547c478bd9Sstevel@tonic-gate gettext("false")); 22557c478bd9Sstevel@tonic-gate } else if (perm != -1) { 22567c478bd9Sstevel@tonic-gate (void) printf(fmt, DETAILED_WIDTH, gettext("enabled"), 22577c478bd9Sstevel@tonic-gate perm ? gettext("true") : gettext("false")); 22587c478bd9Sstevel@tonic-gate } 22597c478bd9Sstevel@tonic-gate 22607c478bd9Sstevel@tonic-gate /* 22617c478bd9Sstevel@tonic-gate * Property values may be longer than max_scf_fmri_length, but these 22627c478bd9Sstevel@tonic-gate * shouldn't be, so we'll just reuse buf. The user can use svcprop if 22637c478bd9Sstevel@tonic-gate * he suspects something fishy. 22647c478bd9Sstevel@tonic-gate */ 22657c478bd9Sstevel@tonic-gate if (scf_instance_get_pg(wip->inst, SCF_PG_RESTARTER, rpg) != 0) { 22667c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 22677c478bd9Sstevel@tonic-gate scfdie(); 22687c478bd9Sstevel@tonic-gate 22697c478bd9Sstevel@tonic-gate scf_pg_destroy(rpg); 22707c478bd9Sstevel@tonic-gate rpg = NULL; 22717c478bd9Sstevel@tonic-gate } 22727c478bd9Sstevel@tonic-gate 22737c478bd9Sstevel@tonic-gate if (rpg) { 22747c478bd9Sstevel@tonic-gate if (pg_get_single_val(rpg, scf_property_state, SCF_TYPE_ASTRING, 22757c478bd9Sstevel@tonic-gate buf, max_scf_fmri_length + 1, 0) == 0) 22767c478bd9Sstevel@tonic-gate (void) printf(fmt, DETAILED_WIDTH, gettext("state"), 22777c478bd9Sstevel@tonic-gate buf); 22787c478bd9Sstevel@tonic-gate 22797c478bd9Sstevel@tonic-gate if (pg_get_single_val(rpg, scf_property_next_state, 22807c478bd9Sstevel@tonic-gate SCF_TYPE_ASTRING, buf, max_scf_fmri_length + 1, 0) == 0) 22817c478bd9Sstevel@tonic-gate (void) printf(fmt, DETAILED_WIDTH, 22827c478bd9Sstevel@tonic-gate gettext("next_state"), buf); 22837c478bd9Sstevel@tonic-gate 22847c478bd9Sstevel@tonic-gate if (pg_get_single_val(rpg, SCF_PROPERTY_STATE_TIMESTAMP, 22857c478bd9Sstevel@tonic-gate SCF_TYPE_TIME, &tv, NULL, 0) == 0) { 22867c478bd9Sstevel@tonic-gate stime = tv.tv_sec; 22877c478bd9Sstevel@tonic-gate tmp = localtime(&stime); 22887c478bd9Sstevel@tonic-gate for (tbsz = 50; ; tbsz *= 2) { 22897c478bd9Sstevel@tonic-gate timebuf = safe_malloc(tbsz); 22907c478bd9Sstevel@tonic-gate if (strftime(timebuf, tbsz, NULL, tmp) != 0) 22917c478bd9Sstevel@tonic-gate break; 22927c478bd9Sstevel@tonic-gate free(timebuf); 22937c478bd9Sstevel@tonic-gate } 22947c478bd9Sstevel@tonic-gate (void) printf(fmt, DETAILED_WIDTH, 22957c478bd9Sstevel@tonic-gate gettext("state_time"), 22967c478bd9Sstevel@tonic-gate timebuf); 22977c478bd9Sstevel@tonic-gate free(timebuf); 22987c478bd9Sstevel@tonic-gate } 22997c478bd9Sstevel@tonic-gate 2300b7185059Srm if (pg_get_single_val(rpg, SCF_PROPERTY_ALT_LOGFILE, 2301b7185059Srm SCF_TYPE_ASTRING, buf, max_scf_fmri_length + 1, 0) == 0) 2302b7185059Srm (void) printf(fmt, DETAILED_WIDTH, 2303b7185059Srm gettext("alt_logfile"), buf); 23047c478bd9Sstevel@tonic-gate 2305b7185059Srm if (pg_get_single_val(rpg, SCF_PROPERTY_LOGFILE, 2306b7185059Srm SCF_TYPE_ASTRING, buf, max_scf_fmri_length + 1, 0) == 0) 2307b7185059Srm (void) printf(fmt, DETAILED_WIDTH, gettext("logfile"), 2308b7185059Srm buf); 2309b7185059Srm } 23107c478bd9Sstevel@tonic-gate 23117c478bd9Sstevel@tonic-gate if (inst_get_single_val(wip->inst, SCF_PG_GENERAL, 23127c478bd9Sstevel@tonic-gate SCF_PROPERTY_RESTARTER, SCF_TYPE_ASTRING, buf, 23137c478bd9Sstevel@tonic-gate max_scf_fmri_length + 1, 0, 0, 1) == 0) 23147c478bd9Sstevel@tonic-gate (void) printf(fmt, DETAILED_WIDTH, gettext("restarter"), buf); 23157c478bd9Sstevel@tonic-gate else 23167c478bd9Sstevel@tonic-gate (void) printf(fmt, DETAILED_WIDTH, gettext("restarter"), 23177c478bd9Sstevel@tonic-gate SCF_SERVICE_STARTD); 23187c478bd9Sstevel@tonic-gate 23197c478bd9Sstevel@tonic-gate free(buf); 23207c478bd9Sstevel@tonic-gate 232194501b61Sskamm /* 232294501b61Sskamm * Use the restarter specific routine to print the ctids, if available. 232394501b61Sskamm * If restarter specific action is available and it fails, then die. 232494501b61Sskamm */ 232594501b61Sskamm restarter_ret = ctids_by_restarter(wip, &c, 1, 0, 232694501b61Sskamm &restarter_spec, print_ctid_header, print_ctid_detailed); 232794501b61Sskamm if (restarter_spec == 1) { 232894501b61Sskamm if (restarter_ret != 0) 232994501b61Sskamm uu_die(gettext("Unable to get restarter for %s"), 233094501b61Sskamm wip->fmri); 233194501b61Sskamm goto restarter_common; 233294501b61Sskamm } 233394501b61Sskamm 23347c478bd9Sstevel@tonic-gate if (rpg) { 23357c478bd9Sstevel@tonic-gate scf_iter_t *iter; 23367c478bd9Sstevel@tonic-gate 23377c478bd9Sstevel@tonic-gate if ((iter = scf_iter_create(h)) == NULL) 23387c478bd9Sstevel@tonic-gate scfdie(); 23397c478bd9Sstevel@tonic-gate 23407c478bd9Sstevel@tonic-gate if (scf_pg_get_property(rpg, scf_property_contract, g_prop) == 23417c478bd9Sstevel@tonic-gate 0) { 23427c478bd9Sstevel@tonic-gate if (scf_property_is_type(g_prop, SCF_TYPE_COUNT) == 0) { 234394501b61Sskamm 234494501b61Sskamm /* Callback to print ctid header */ 234594501b61Sskamm print_ctid_header(); 23467c478bd9Sstevel@tonic-gate 23477c478bd9Sstevel@tonic-gate if (scf_iter_property_values(iter, g_prop) != 0) 23487c478bd9Sstevel@tonic-gate scfdie(); 23497c478bd9Sstevel@tonic-gate 23507c478bd9Sstevel@tonic-gate for (;;) { 23517c478bd9Sstevel@tonic-gate ret = scf_iter_next_value(iter, g_val); 23527c478bd9Sstevel@tonic-gate if (ret == -1) 23537c478bd9Sstevel@tonic-gate scfdie(); 23547c478bd9Sstevel@tonic-gate if (ret == 0) 23557c478bd9Sstevel@tonic-gate break; 23567c478bd9Sstevel@tonic-gate 23577c478bd9Sstevel@tonic-gate if (scf_value_get_count(g_val, &c) != 0) 23587c478bd9Sstevel@tonic-gate scfdie(); 235994501b61Sskamm 236094501b61Sskamm /* Callback to print contract id. */ 236194501b61Sskamm print_ctid_detailed(c); 23627c478bd9Sstevel@tonic-gate } 23637c478bd9Sstevel@tonic-gate 23647c478bd9Sstevel@tonic-gate (void) putchar('\n'); 23657c478bd9Sstevel@tonic-gate } else { 23667c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_TYPE_MISMATCH) 23677c478bd9Sstevel@tonic-gate scfdie(); 23687c478bd9Sstevel@tonic-gate } 23697c478bd9Sstevel@tonic-gate } else { 23707c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 23717c478bd9Sstevel@tonic-gate scfdie(); 23727c478bd9Sstevel@tonic-gate } 23737c478bd9Sstevel@tonic-gate 23747c478bd9Sstevel@tonic-gate scf_iter_destroy(iter); 23757c478bd9Sstevel@tonic-gate } else { 23767c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 23777c478bd9Sstevel@tonic-gate scfdie(); 23787c478bd9Sstevel@tonic-gate } 23797c478bd9Sstevel@tonic-gate 238094501b61Sskamm restarter_common: 23817c478bd9Sstevel@tonic-gate scf_pg_destroy(rpg); 23827c478bd9Sstevel@tonic-gate 23837c478bd9Sstevel@tonic-gate /* Dependencies. */ 23847c478bd9Sstevel@tonic-gate if ((pg_iter = scf_iter_create(h)) == NULL) 23857c478bd9Sstevel@tonic-gate scfdie(); 23867c478bd9Sstevel@tonic-gate 23877c478bd9Sstevel@tonic-gate snap = get_running_snapshot(wip->inst); 23887c478bd9Sstevel@tonic-gate 23897c478bd9Sstevel@tonic-gate if (scf_iter_instance_pgs_typed_composed(pg_iter, wip->inst, snap, 23907c478bd9Sstevel@tonic-gate SCF_GROUP_DEPENDENCY) != SCF_SUCCESS) 23917c478bd9Sstevel@tonic-gate scfdie(); 23927c478bd9Sstevel@tonic-gate 23937c478bd9Sstevel@tonic-gate while ((ret = scf_iter_next_pg(pg_iter, g_pg)) == 1) 23947c478bd9Sstevel@tonic-gate print_detailed_dependency(g_pg); 23957c478bd9Sstevel@tonic-gate if (ret == -1) 23967c478bd9Sstevel@tonic-gate scfdie(); 23977c478bd9Sstevel@tonic-gate 23987c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap); 23997c478bd9Sstevel@tonic-gate scf_iter_destroy(pg_iter); 24007c478bd9Sstevel@tonic-gate 24017c478bd9Sstevel@tonic-gate if (opt_processes) 240294501b61Sskamm detailed_list_processes(wip); 24037c478bd9Sstevel@tonic-gate 24047c478bd9Sstevel@tonic-gate return (0); 24057c478bd9Sstevel@tonic-gate } 24067c478bd9Sstevel@tonic-gate 24077c478bd9Sstevel@tonic-gate /* 24087c478bd9Sstevel@tonic-gate * Append a one-lined description of each process in inst's contract(s) and 24097c478bd9Sstevel@tonic-gate * return the augmented string. 24107c478bd9Sstevel@tonic-gate */ 24117c478bd9Sstevel@tonic-gate static char * 241294501b61Sskamm add_processes(scf_walkinfo_t *wip, char *line, scf_propertygroup_t *lpg) 24137c478bd9Sstevel@tonic-gate { 24147c478bd9Sstevel@tonic-gate pid_t *pids = NULL; 24157c478bd9Sstevel@tonic-gate uint_t i, n = 0; 24167c478bd9Sstevel@tonic-gate 24177c478bd9Sstevel@tonic-gate if (lpg == NULL) { 241894501b61Sskamm if (instance_processes(wip->inst, wip->fmri, &pids, &n) != 0) 24197c478bd9Sstevel@tonic-gate return (line); 24207c478bd9Sstevel@tonic-gate } else { 242194501b61Sskamm /* Legacy services */ 24227c478bd9Sstevel@tonic-gate scf_iter_t *iter; 24237c478bd9Sstevel@tonic-gate 24247c478bd9Sstevel@tonic-gate if ((iter = scf_iter_create(h)) == NULL) 24257c478bd9Sstevel@tonic-gate scfdie(); 24267c478bd9Sstevel@tonic-gate 24277c478bd9Sstevel@tonic-gate (void) propvals_to_pids(lpg, scf_property_contract, &pids, &n, 24287c478bd9Sstevel@tonic-gate g_prop, g_val, iter); 24297c478bd9Sstevel@tonic-gate 24307c478bd9Sstevel@tonic-gate scf_iter_destroy(iter); 24317c478bd9Sstevel@tonic-gate } 24327c478bd9Sstevel@tonic-gate 24337c478bd9Sstevel@tonic-gate if (n == 0) 24347c478bd9Sstevel@tonic-gate return (line); 24357c478bd9Sstevel@tonic-gate 24367c478bd9Sstevel@tonic-gate qsort(pids, n, sizeof (*pids), pidcmp); 24377c478bd9Sstevel@tonic-gate 24387c478bd9Sstevel@tonic-gate for (i = 0; i < n; ++i) { 24397c478bd9Sstevel@tonic-gate char *cp, stime[9]; 24407c478bd9Sstevel@tonic-gate psinfo_t psi; 24417c478bd9Sstevel@tonic-gate struct tm *tm; 24427c478bd9Sstevel@tonic-gate int len = 1 + 15 + 8 + 3 + 6 + 1 + PRFNSZ; 24437c478bd9Sstevel@tonic-gate 24447c478bd9Sstevel@tonic-gate if (get_psinfo(pids[i], &psi) != 0) 24457c478bd9Sstevel@tonic-gate continue; 24467c478bd9Sstevel@tonic-gate 24477c478bd9Sstevel@tonic-gate line = realloc(line, strlen(line) + len); 24487c478bd9Sstevel@tonic-gate if (line == NULL) 24497c478bd9Sstevel@tonic-gate uu_die(gettext("Out of memory.\n")); 24507c478bd9Sstevel@tonic-gate 24517c478bd9Sstevel@tonic-gate cp = strchr(line, '\0'); 24527c478bd9Sstevel@tonic-gate 24537c478bd9Sstevel@tonic-gate tm = localtime(&psi.pr_start.tv_sec); 24547c478bd9Sstevel@tonic-gate 24557c478bd9Sstevel@tonic-gate /* 24567c478bd9Sstevel@tonic-gate * Print time if started within the past 24 hours, print date 24577c478bd9Sstevel@tonic-gate * if within the past 12 months, print year if started greater 24587c478bd9Sstevel@tonic-gate * than 12 months ago. 24597c478bd9Sstevel@tonic-gate */ 24607c478bd9Sstevel@tonic-gate if (now - psi.pr_start.tv_sec < 24 * 60 * 60) 24613eae19d9Swesolows (void) strftime(stime, sizeof (stime), 24623eae19d9Swesolows gettext(FORMAT_TIME), tm); 24637c478bd9Sstevel@tonic-gate else if (now - psi.pr_start.tv_sec < 12 * 30 * 24 * 60 * 60) 24643eae19d9Swesolows (void) strftime(stime, sizeof (stime), 24653eae19d9Swesolows gettext(FORMAT_DATE), tm); 24667c478bd9Sstevel@tonic-gate else 24673eae19d9Swesolows (void) strftime(stime, sizeof (stime), 24683eae19d9Swesolows gettext(FORMAT_YEAR), tm); 24697c478bd9Sstevel@tonic-gate 24707c478bd9Sstevel@tonic-gate (void) snprintf(cp, len, "\n %-8s %6ld %.*s", 24717c478bd9Sstevel@tonic-gate stime, pids[i], PRFNSZ, psi.pr_fname); 24727c478bd9Sstevel@tonic-gate } 24737c478bd9Sstevel@tonic-gate 24747c478bd9Sstevel@tonic-gate free(pids); 24757c478bd9Sstevel@tonic-gate 24767c478bd9Sstevel@tonic-gate return (line); 24777c478bd9Sstevel@tonic-gate } 24787c478bd9Sstevel@tonic-gate 24797c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 24807c478bd9Sstevel@tonic-gate static int 24817c478bd9Sstevel@tonic-gate list_instance(void *unused, scf_walkinfo_t *wip) 24827c478bd9Sstevel@tonic-gate { 24837c478bd9Sstevel@tonic-gate struct avl_string *lp; 24847c478bd9Sstevel@tonic-gate char *cp; 24857c478bd9Sstevel@tonic-gate int i; 24867c478bd9Sstevel@tonic-gate uu_avl_index_t idx; 24877c478bd9Sstevel@tonic-gate 24887c478bd9Sstevel@tonic-gate /* 24897c478bd9Sstevel@tonic-gate * If the user has specified a restarter, check for a match first 24907c478bd9Sstevel@tonic-gate */ 24917c478bd9Sstevel@tonic-gate if (restarters != NULL) { 24927c478bd9Sstevel@tonic-gate struct pfmri_list *rest; 24937c478bd9Sstevel@tonic-gate int match; 24947c478bd9Sstevel@tonic-gate char *restarter_fmri; 24957c478bd9Sstevel@tonic-gate const char *scope_name, *svc_name, *inst_name, *pg_name; 24967c478bd9Sstevel@tonic-gate 24977c478bd9Sstevel@tonic-gate /* legacy services don't have restarters */ 24987c478bd9Sstevel@tonic-gate if (wip->pg != NULL) 24997c478bd9Sstevel@tonic-gate return (0); 25007c478bd9Sstevel@tonic-gate 25017c478bd9Sstevel@tonic-gate restarter_fmri = safe_malloc(max_scf_fmri_length + 1); 25027c478bd9Sstevel@tonic-gate 25037c478bd9Sstevel@tonic-gate if (inst_get_single_val(wip->inst, SCF_PG_GENERAL, 25047c478bd9Sstevel@tonic-gate SCF_PROPERTY_RESTARTER, SCF_TYPE_ASTRING, restarter_fmri, 25057c478bd9Sstevel@tonic-gate max_scf_fmri_length + 1, 0, 0, 1) != 0) 25067c478bd9Sstevel@tonic-gate (void) strcpy(restarter_fmri, SCF_SERVICE_STARTD); 25077c478bd9Sstevel@tonic-gate 25087c478bd9Sstevel@tonic-gate if (scf_parse_svc_fmri(restarter_fmri, &scope_name, &svc_name, 25097c478bd9Sstevel@tonic-gate &inst_name, &pg_name, NULL) != SCF_SUCCESS) { 25107c478bd9Sstevel@tonic-gate free(restarter_fmri); 25117c478bd9Sstevel@tonic-gate return (0); 25127c478bd9Sstevel@tonic-gate } 25137c478bd9Sstevel@tonic-gate 25147c478bd9Sstevel@tonic-gate match = 0; 25157c478bd9Sstevel@tonic-gate for (rest = restarters; rest != NULL; rest = rest->next) { 25167c478bd9Sstevel@tonic-gate if (strcmp(rest->scope, scope_name) == 0 && 25177c478bd9Sstevel@tonic-gate strcmp(rest->service, svc_name) == 0 && 25187c478bd9Sstevel@tonic-gate strcmp(rest->instance, inst_name) == 0) 25197c478bd9Sstevel@tonic-gate match = 1; 25207c478bd9Sstevel@tonic-gate } 25217c478bd9Sstevel@tonic-gate 25227c478bd9Sstevel@tonic-gate free(restarter_fmri); 25237c478bd9Sstevel@tonic-gate 25247c478bd9Sstevel@tonic-gate if (!match) 25257c478bd9Sstevel@tonic-gate return (0); 25267c478bd9Sstevel@tonic-gate } 25277c478bd9Sstevel@tonic-gate 25287c478bd9Sstevel@tonic-gate if (wip->pg == NULL && ht_buckets != NULL && ht_add(wip->fmri)) { 25297c478bd9Sstevel@tonic-gate /* It was already there. */ 25307c478bd9Sstevel@tonic-gate return (0); 25317c478bd9Sstevel@tonic-gate } 25327c478bd9Sstevel@tonic-gate 25337c478bd9Sstevel@tonic-gate lp = safe_malloc(sizeof (*lp)); 25347c478bd9Sstevel@tonic-gate 25357c478bd9Sstevel@tonic-gate lp->str = NULL; 25367c478bd9Sstevel@tonic-gate for (i = 0; i < opt_cnum; ++i) { 25377c478bd9Sstevel@tonic-gate columns[opt_columns[i]].sprint(&lp->str, wip); 25387c478bd9Sstevel@tonic-gate } 25397c478bd9Sstevel@tonic-gate cp = lp->str + strlen(lp->str); 25407c478bd9Sstevel@tonic-gate cp--; 25417c478bd9Sstevel@tonic-gate while (*cp == ' ') 25427c478bd9Sstevel@tonic-gate cp--; 25437c478bd9Sstevel@tonic-gate *(cp+1) = '\0'; 25447c478bd9Sstevel@tonic-gate 25457c478bd9Sstevel@tonic-gate /* If we're supposed to list the processes, too, do that now. */ 25467c478bd9Sstevel@tonic-gate if (opt_processes) 254794501b61Sskamm lp->str = add_processes(wip, lp->str, wip->pg); 25487c478bd9Sstevel@tonic-gate 25497c478bd9Sstevel@tonic-gate /* Create the sort key. */ 25507c478bd9Sstevel@tonic-gate cp = lp->key = safe_malloc(sortkey_sz); 25517c478bd9Sstevel@tonic-gate for (i = 0; i < opt_snum; ++i) { 25527c478bd9Sstevel@tonic-gate int j = opt_sort[i] & 0xff; 25537c478bd9Sstevel@tonic-gate 25547c478bd9Sstevel@tonic-gate assert(columns[j].get_sortkey != NULL); 25557c478bd9Sstevel@tonic-gate columns[j].get_sortkey(cp, opt_sort[i] & ~0xff, wip); 25567c478bd9Sstevel@tonic-gate cp += columns[j].sortkey_width; 25577c478bd9Sstevel@tonic-gate } 25587c478bd9Sstevel@tonic-gate 25597c478bd9Sstevel@tonic-gate /* Insert into AVL tree. */ 25607c478bd9Sstevel@tonic-gate uu_avl_node_init(lp, &lp->node, lines_pool); 25617c478bd9Sstevel@tonic-gate (void) uu_avl_find(lines, lp, NULL, &idx); 25627c478bd9Sstevel@tonic-gate uu_avl_insert(lines, lp, idx); 25637c478bd9Sstevel@tonic-gate 25647c478bd9Sstevel@tonic-gate return (0); 25657c478bd9Sstevel@tonic-gate } 25667c478bd9Sstevel@tonic-gate 25677c478bd9Sstevel@tonic-gate static int 25687c478bd9Sstevel@tonic-gate list_if_enabled(void *unused, scf_walkinfo_t *wip) 25697c478bd9Sstevel@tonic-gate { 25707c478bd9Sstevel@tonic-gate if (wip->pg != NULL || 25717c478bd9Sstevel@tonic-gate instance_enabled(wip->inst, B_FALSE) == 1 || 25727c478bd9Sstevel@tonic-gate instance_enabled(wip->inst, B_TRUE) == 1) 25737c478bd9Sstevel@tonic-gate return (list_instance(unused, wip)); 25747c478bd9Sstevel@tonic-gate 25757c478bd9Sstevel@tonic-gate return (0); 25767c478bd9Sstevel@tonic-gate } 25777c478bd9Sstevel@tonic-gate 25787c478bd9Sstevel@tonic-gate /* 25797c478bd9Sstevel@tonic-gate * Service FMRI selection: Lookup and call list_instance() for the instances. 25807c478bd9Sstevel@tonic-gate * Instance FMRI selection: Lookup and call list_instance(). 25817c478bd9Sstevel@tonic-gate * 25827c478bd9Sstevel@tonic-gate * Note: This is shoehorned into a walk_dependencies() callback prototype so 25837c478bd9Sstevel@tonic-gate * it can be used in list_dependencies. 25847c478bd9Sstevel@tonic-gate */ 25857c478bd9Sstevel@tonic-gate static int 25867c478bd9Sstevel@tonic-gate list_svc_or_inst_fmri(void *complain, scf_walkinfo_t *wip) 25877c478bd9Sstevel@tonic-gate { 25887c478bd9Sstevel@tonic-gate char *fmri; 25897c478bd9Sstevel@tonic-gate const char *svc_name, *inst_name, *pg_name, *save; 25907c478bd9Sstevel@tonic-gate scf_iter_t *iter; 25917c478bd9Sstevel@tonic-gate int ret; 25927c478bd9Sstevel@tonic-gate 25937c478bd9Sstevel@tonic-gate fmri = safe_strdup(wip->fmri); 25947c478bd9Sstevel@tonic-gate 25957c478bd9Sstevel@tonic-gate if (scf_parse_svc_fmri(fmri, NULL, &svc_name, &inst_name, &pg_name, 25967c478bd9Sstevel@tonic-gate NULL) != SCF_SUCCESS) { 25977c478bd9Sstevel@tonic-gate if (complain) 25987c478bd9Sstevel@tonic-gate uu_warn(gettext("FMRI \"%s\" is invalid.\n"), 25997c478bd9Sstevel@tonic-gate wip->fmri); 26007c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 26017c478bd9Sstevel@tonic-gate free(fmri); 26027c478bd9Sstevel@tonic-gate return (0); 26037c478bd9Sstevel@tonic-gate } 26047c478bd9Sstevel@tonic-gate 26057c478bd9Sstevel@tonic-gate /* 26067c478bd9Sstevel@tonic-gate * Yes, this invalidates *_name, but we only care whether they're NULL 26077c478bd9Sstevel@tonic-gate * or not. 26087c478bd9Sstevel@tonic-gate */ 26097c478bd9Sstevel@tonic-gate free(fmri); 26107c478bd9Sstevel@tonic-gate 26117c478bd9Sstevel@tonic-gate if (svc_name == NULL || pg_name != NULL) { 26127c478bd9Sstevel@tonic-gate if (complain) 26137c478bd9Sstevel@tonic-gate uu_warn(gettext("FMRI \"%s\" does not designate a " 26147c478bd9Sstevel@tonic-gate "service or instance.\n"), wip->fmri); 26157c478bd9Sstevel@tonic-gate return (0); 26167c478bd9Sstevel@tonic-gate } 26177c478bd9Sstevel@tonic-gate 26187c478bd9Sstevel@tonic-gate if (inst_name != NULL) { 26197c478bd9Sstevel@tonic-gate /* instance */ 26207c478bd9Sstevel@tonic-gate if (scf_handle_decode_fmri(h, wip->fmri, wip->scope, wip->svc, 26217c478bd9Sstevel@tonic-gate wip->inst, NULL, NULL, 0) != SCF_SUCCESS) { 26227c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 26237c478bd9Sstevel@tonic-gate scfdie(); 26247c478bd9Sstevel@tonic-gate 26257c478bd9Sstevel@tonic-gate if (complain) 26267c478bd9Sstevel@tonic-gate uu_warn(gettext( 26277c478bd9Sstevel@tonic-gate "Instance \"%s\" does not exist.\n"), 26287c478bd9Sstevel@tonic-gate wip->fmri); 26297c478bd9Sstevel@tonic-gate return (0); 26307c478bd9Sstevel@tonic-gate } 26317c478bd9Sstevel@tonic-gate 26327c478bd9Sstevel@tonic-gate return (list_instance(NULL, wip)); 26337c478bd9Sstevel@tonic-gate } 26347c478bd9Sstevel@tonic-gate 26357c478bd9Sstevel@tonic-gate /* service: Walk the instances. */ 26367c478bd9Sstevel@tonic-gate if (scf_handle_decode_fmri(h, wip->fmri, wip->scope, wip->svc, NULL, 26377c478bd9Sstevel@tonic-gate NULL, NULL, 0) != SCF_SUCCESS) { 26387c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 26397c478bd9Sstevel@tonic-gate scfdie(); 26407c478bd9Sstevel@tonic-gate 26417c478bd9Sstevel@tonic-gate if (complain) 26427c478bd9Sstevel@tonic-gate uu_warn(gettext("Service \"%s\" does not exist.\n"), 26437c478bd9Sstevel@tonic-gate wip->fmri); 26447c478bd9Sstevel@tonic-gate 26457c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 26467c478bd9Sstevel@tonic-gate 26477c478bd9Sstevel@tonic-gate return (0); 26487c478bd9Sstevel@tonic-gate } 26497c478bd9Sstevel@tonic-gate 26507c478bd9Sstevel@tonic-gate iter = scf_iter_create(h); 26517c478bd9Sstevel@tonic-gate if (iter == NULL) 26527c478bd9Sstevel@tonic-gate scfdie(); 26537c478bd9Sstevel@tonic-gate 26547c478bd9Sstevel@tonic-gate if (scf_iter_service_instances(iter, wip->svc) != SCF_SUCCESS) 26557c478bd9Sstevel@tonic-gate scfdie(); 26567c478bd9Sstevel@tonic-gate 26577c478bd9Sstevel@tonic-gate if ((fmri = malloc(max_scf_fmri_length + 1)) == NULL) { 26587c478bd9Sstevel@tonic-gate scf_iter_destroy(iter); 26597c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 26607c478bd9Sstevel@tonic-gate return (0); 26617c478bd9Sstevel@tonic-gate } 26627c478bd9Sstevel@tonic-gate 26637c478bd9Sstevel@tonic-gate save = wip->fmri; 26647c478bd9Sstevel@tonic-gate wip->fmri = fmri; 26657c478bd9Sstevel@tonic-gate while ((ret = scf_iter_next_instance(iter, wip->inst)) == 1) { 26667c478bd9Sstevel@tonic-gate if (scf_instance_to_fmri(wip->inst, fmri, 26677c478bd9Sstevel@tonic-gate max_scf_fmri_length + 1) <= 0) 26687c478bd9Sstevel@tonic-gate scfdie(); 26697c478bd9Sstevel@tonic-gate (void) list_instance(NULL, wip); 26707c478bd9Sstevel@tonic-gate } 26717c478bd9Sstevel@tonic-gate free(fmri); 26727c478bd9Sstevel@tonic-gate wip->fmri = save; 26737c478bd9Sstevel@tonic-gate if (ret == -1) 26747c478bd9Sstevel@tonic-gate scfdie(); 26757c478bd9Sstevel@tonic-gate 26767c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_OK; 26777c478bd9Sstevel@tonic-gate 26787c478bd9Sstevel@tonic-gate scf_iter_destroy(iter); 26797c478bd9Sstevel@tonic-gate 26807c478bd9Sstevel@tonic-gate return (0); 26817c478bd9Sstevel@tonic-gate } 26827c478bd9Sstevel@tonic-gate 26837c478bd9Sstevel@tonic-gate /* 26847c478bd9Sstevel@tonic-gate * Dependency selection: Straightforward since each instance lists the 26857c478bd9Sstevel@tonic-gate * services it depends on. 26867c478bd9Sstevel@tonic-gate */ 26877c478bd9Sstevel@tonic-gate 26887c478bd9Sstevel@tonic-gate static void 26897c478bd9Sstevel@tonic-gate walk_dependencies(scf_walkinfo_t *wip, scf_walk_callback callback, void *data) 26907c478bd9Sstevel@tonic-gate { 26917c478bd9Sstevel@tonic-gate scf_snapshot_t *snap; 26927c478bd9Sstevel@tonic-gate scf_iter_t *iter, *viter; 26937c478bd9Sstevel@tonic-gate int ret, vret; 26947c478bd9Sstevel@tonic-gate char *dep; 26957c478bd9Sstevel@tonic-gate 26967c478bd9Sstevel@tonic-gate assert(wip->inst != NULL); 26977c478bd9Sstevel@tonic-gate 26987c478bd9Sstevel@tonic-gate if ((iter = scf_iter_create(h)) == NULL || 26997c478bd9Sstevel@tonic-gate (viter = scf_iter_create(h)) == NULL) 27007c478bd9Sstevel@tonic-gate scfdie(); 27017c478bd9Sstevel@tonic-gate 27027c478bd9Sstevel@tonic-gate snap = get_running_snapshot(wip->inst); 27037c478bd9Sstevel@tonic-gate 27047c478bd9Sstevel@tonic-gate if (scf_iter_instance_pgs_typed_composed(iter, wip->inst, snap, 27057c478bd9Sstevel@tonic-gate SCF_GROUP_DEPENDENCY) != SCF_SUCCESS) 27067c478bd9Sstevel@tonic-gate scfdie(); 27077c478bd9Sstevel@tonic-gate 27087c478bd9Sstevel@tonic-gate dep = safe_malloc(max_scf_value_length + 1); 27097c478bd9Sstevel@tonic-gate 27107c478bd9Sstevel@tonic-gate while ((ret = scf_iter_next_pg(iter, g_pg)) == 1) { 27117c478bd9Sstevel@tonic-gate scf_type_t ty; 27127c478bd9Sstevel@tonic-gate 27137c478bd9Sstevel@tonic-gate /* Ignore exclude_any dependencies. */ 27147c478bd9Sstevel@tonic-gate if (scf_pg_get_property(g_pg, SCF_PROPERTY_GROUPING, g_prop) != 27157c478bd9Sstevel@tonic-gate SCF_SUCCESS) { 27167c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 27177c478bd9Sstevel@tonic-gate scfdie(); 27187c478bd9Sstevel@tonic-gate 27197c478bd9Sstevel@tonic-gate continue; 27207c478bd9Sstevel@tonic-gate } 27217c478bd9Sstevel@tonic-gate 27227c478bd9Sstevel@tonic-gate if (scf_property_type(g_prop, &ty) != SCF_SUCCESS) 27237c478bd9Sstevel@tonic-gate scfdie(); 27247c478bd9Sstevel@tonic-gate 27257c478bd9Sstevel@tonic-gate if (ty != SCF_TYPE_ASTRING) 27267c478bd9Sstevel@tonic-gate continue; 27277c478bd9Sstevel@tonic-gate 27287c478bd9Sstevel@tonic-gate if (scf_property_get_value(g_prop, g_val) != SCF_SUCCESS) { 27297c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_CONSTRAINT_VIOLATED) 27307c478bd9Sstevel@tonic-gate scfdie(); 27317c478bd9Sstevel@tonic-gate 27327c478bd9Sstevel@tonic-gate continue; 27337c478bd9Sstevel@tonic-gate } 27347c478bd9Sstevel@tonic-gate 27357c478bd9Sstevel@tonic-gate if (scf_value_get_astring(g_val, dep, 27367c478bd9Sstevel@tonic-gate max_scf_value_length + 1) < 0) 27377c478bd9Sstevel@tonic-gate scfdie(); 27387c478bd9Sstevel@tonic-gate 27397c478bd9Sstevel@tonic-gate if (strcmp(dep, SCF_DEP_EXCLUDE_ALL) == 0) 27407c478bd9Sstevel@tonic-gate continue; 27417c478bd9Sstevel@tonic-gate 27427c478bd9Sstevel@tonic-gate if (scf_pg_get_property(g_pg, SCF_PROPERTY_ENTITIES, g_prop) != 27437c478bd9Sstevel@tonic-gate SCF_SUCCESS) { 27447c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 27457c478bd9Sstevel@tonic-gate scfdie(); 27467c478bd9Sstevel@tonic-gate 27477c478bd9Sstevel@tonic-gate continue; 27487c478bd9Sstevel@tonic-gate } 27497c478bd9Sstevel@tonic-gate 27507c478bd9Sstevel@tonic-gate if (scf_iter_property_values(viter, g_prop) != SCF_SUCCESS) 27517c478bd9Sstevel@tonic-gate scfdie(); 27527c478bd9Sstevel@tonic-gate 27537c478bd9Sstevel@tonic-gate while ((vret = scf_iter_next_value(viter, g_val)) == 1) { 27547c478bd9Sstevel@tonic-gate if (scf_value_get_astring(g_val, dep, 27557c478bd9Sstevel@tonic-gate max_scf_value_length + 1) < 0) 27567c478bd9Sstevel@tonic-gate scfdie(); 27577c478bd9Sstevel@tonic-gate 27587c478bd9Sstevel@tonic-gate wip->fmri = dep; 27597c478bd9Sstevel@tonic-gate if (callback(data, wip) != 0) 27607c478bd9Sstevel@tonic-gate goto out; 27617c478bd9Sstevel@tonic-gate } 27627c478bd9Sstevel@tonic-gate if (vret == -1) 27637c478bd9Sstevel@tonic-gate scfdie(); 27647c478bd9Sstevel@tonic-gate } 27657c478bd9Sstevel@tonic-gate if (ret == -1) 27667c478bd9Sstevel@tonic-gate scfdie(); 27677c478bd9Sstevel@tonic-gate 27687c478bd9Sstevel@tonic-gate out: 27697c478bd9Sstevel@tonic-gate scf_iter_destroy(viter); 27707c478bd9Sstevel@tonic-gate scf_iter_destroy(iter); 27717c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap); 27727c478bd9Sstevel@tonic-gate } 27737c478bd9Sstevel@tonic-gate 27747c478bd9Sstevel@tonic-gate static int 27757c478bd9Sstevel@tonic-gate list_dependencies(void *data, scf_walkinfo_t *wip) 27767c478bd9Sstevel@tonic-gate { 27777c478bd9Sstevel@tonic-gate walk_dependencies(wip, list_svc_or_inst_fmri, data); 27787c478bd9Sstevel@tonic-gate return (0); 27797c478bd9Sstevel@tonic-gate } 27807c478bd9Sstevel@tonic-gate 27817c478bd9Sstevel@tonic-gate 27827c478bd9Sstevel@tonic-gate /* 27837c478bd9Sstevel@tonic-gate * Dependent selection: The "providing" service's or instance's FMRI is parsed 27847c478bd9Sstevel@tonic-gate * into the provider_* variables, the instances are walked, and any instance 27857c478bd9Sstevel@tonic-gate * which lists an FMRI which parses to these components is selected. This is 27867c478bd9Sstevel@tonic-gate * inefficient in the face of multiple operands, but that should be uncommon. 27877c478bd9Sstevel@tonic-gate */ 27887c478bd9Sstevel@tonic-gate 27897c478bd9Sstevel@tonic-gate static char *provider_scope; 27907c478bd9Sstevel@tonic-gate static char *provider_svc; 27917c478bd9Sstevel@tonic-gate static char *provider_inst; /* NULL for services */ 27927c478bd9Sstevel@tonic-gate 27937c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 27947c478bd9Sstevel@tonic-gate static int 27957c478bd9Sstevel@tonic-gate check_against_provider(void *arg, scf_walkinfo_t *wip) 27967c478bd9Sstevel@tonic-gate { 27977c478bd9Sstevel@tonic-gate char *cfmri; 27987c478bd9Sstevel@tonic-gate const char *scope_name, *svc_name, *inst_name, *pg_name; 27997c478bd9Sstevel@tonic-gate int *matchp = arg; 28007c478bd9Sstevel@tonic-gate 28017c478bd9Sstevel@tonic-gate cfmri = safe_strdup(wip->fmri); 28027c478bd9Sstevel@tonic-gate 28037c478bd9Sstevel@tonic-gate if (scf_parse_svc_fmri(cfmri, &scope_name, &svc_name, &inst_name, 28047c478bd9Sstevel@tonic-gate &pg_name, NULL) != SCF_SUCCESS) { 28057c478bd9Sstevel@tonic-gate free(cfmri); 28067c478bd9Sstevel@tonic-gate return (0); 28077c478bd9Sstevel@tonic-gate } 28087c478bd9Sstevel@tonic-gate 28097c478bd9Sstevel@tonic-gate if (svc_name == NULL || pg_name != NULL) { 28107c478bd9Sstevel@tonic-gate free(cfmri); 28117c478bd9Sstevel@tonic-gate return (0); 28127c478bd9Sstevel@tonic-gate } 28137c478bd9Sstevel@tonic-gate 28147c478bd9Sstevel@tonic-gate /* 28157c478bd9Sstevel@tonic-gate * If the user has specified an instance, then also match dependencies 28167c478bd9Sstevel@tonic-gate * on the service itself. 28177c478bd9Sstevel@tonic-gate */ 28187c478bd9Sstevel@tonic-gate *matchp = (strcmp(provider_scope, scope_name) == 0 && 28197c478bd9Sstevel@tonic-gate strcmp(provider_svc, svc_name) == 0 && 28207c478bd9Sstevel@tonic-gate (provider_inst == NULL ? (inst_name == NULL) : 28217c478bd9Sstevel@tonic-gate (inst_name == NULL || strcmp(provider_inst, inst_name) == 0))); 28227c478bd9Sstevel@tonic-gate 28237c478bd9Sstevel@tonic-gate free(cfmri); 28247c478bd9Sstevel@tonic-gate 28257c478bd9Sstevel@tonic-gate /* Stop on matches. */ 28267c478bd9Sstevel@tonic-gate return (*matchp); 28277c478bd9Sstevel@tonic-gate } 28287c478bd9Sstevel@tonic-gate 28297c478bd9Sstevel@tonic-gate static int 28307c478bd9Sstevel@tonic-gate list_if_dependent(void *unused, scf_walkinfo_t *wip) 28317c478bd9Sstevel@tonic-gate { 28327c478bd9Sstevel@tonic-gate /* Only proceed if this instance depends on provider_*. */ 28337c478bd9Sstevel@tonic-gate int match = 0; 28347c478bd9Sstevel@tonic-gate 28357c478bd9Sstevel@tonic-gate (void) walk_dependencies(wip, check_against_provider, &match); 28367c478bd9Sstevel@tonic-gate 28377c478bd9Sstevel@tonic-gate if (match) 28387c478bd9Sstevel@tonic-gate return (list_instance(unused, wip)); 28397c478bd9Sstevel@tonic-gate 28407c478bd9Sstevel@tonic-gate return (0); 28417c478bd9Sstevel@tonic-gate } 28427c478bd9Sstevel@tonic-gate 28437c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 28447c478bd9Sstevel@tonic-gate static int 28457c478bd9Sstevel@tonic-gate list_dependents(void *unused, scf_walkinfo_t *wip) 28467c478bd9Sstevel@tonic-gate { 28477c478bd9Sstevel@tonic-gate char *save; 28487c478bd9Sstevel@tonic-gate int ret; 28497c478bd9Sstevel@tonic-gate 28507c478bd9Sstevel@tonic-gate if (scf_scope_get_name(wip->scope, provider_scope, 28517c478bd9Sstevel@tonic-gate max_scf_fmri_length) <= 0 || 28527c478bd9Sstevel@tonic-gate scf_service_get_name(wip->svc, provider_svc, 28537c478bd9Sstevel@tonic-gate max_scf_fmri_length) <= 0) 28547c478bd9Sstevel@tonic-gate scfdie(); 28557c478bd9Sstevel@tonic-gate 28567c478bd9Sstevel@tonic-gate save = provider_inst; 28577c478bd9Sstevel@tonic-gate if (wip->inst == NULL) 28587c478bd9Sstevel@tonic-gate provider_inst = NULL; 28597c478bd9Sstevel@tonic-gate else if (scf_instance_get_name(wip->inst, provider_inst, 28607c478bd9Sstevel@tonic-gate max_scf_fmri_length) <= 0) 28617c478bd9Sstevel@tonic-gate scfdie(); 28627c478bd9Sstevel@tonic-gate 28637c478bd9Sstevel@tonic-gate ret = scf_walk_fmri(h, 0, NULL, 0, list_if_dependent, NULL, NULL, 28647c478bd9Sstevel@tonic-gate uu_warn); 28657c478bd9Sstevel@tonic-gate 28667c478bd9Sstevel@tonic-gate provider_inst = save; 28677c478bd9Sstevel@tonic-gate 28687c478bd9Sstevel@tonic-gate return (ret); 28697c478bd9Sstevel@tonic-gate } 28707c478bd9Sstevel@tonic-gate 28717c478bd9Sstevel@tonic-gate /* 28727c478bd9Sstevel@tonic-gate * main() & helpers 28737c478bd9Sstevel@tonic-gate */ 28747c478bd9Sstevel@tonic-gate 28757c478bd9Sstevel@tonic-gate static void 28767c478bd9Sstevel@tonic-gate add_sort_column(const char *col, int reverse) 28777c478bd9Sstevel@tonic-gate { 28787c478bd9Sstevel@tonic-gate int i; 28797c478bd9Sstevel@tonic-gate 28807c478bd9Sstevel@tonic-gate ++opt_snum; 28817c478bd9Sstevel@tonic-gate 28827c478bd9Sstevel@tonic-gate opt_sort = realloc(opt_sort, opt_snum * sizeof (*opt_sort)); 28837c478bd9Sstevel@tonic-gate if (opt_sort == NULL) 28847c478bd9Sstevel@tonic-gate uu_die(gettext("Too many sort criteria: out of memory.\n")); 28857c478bd9Sstevel@tonic-gate 28867c478bd9Sstevel@tonic-gate for (i = 0; i < ncolumns; ++i) { 28877c478bd9Sstevel@tonic-gate if (strcasecmp(col, columns[i].name) == 0) 28887c478bd9Sstevel@tonic-gate break; 28897c478bd9Sstevel@tonic-gate } 28907c478bd9Sstevel@tonic-gate 28917c478bd9Sstevel@tonic-gate if (i < ncolumns) 28927c478bd9Sstevel@tonic-gate opt_sort[opt_snum - 1] = (reverse ? i | 0x100 : i); 28937c478bd9Sstevel@tonic-gate else 28947c478bd9Sstevel@tonic-gate uu_die(gettext("Unrecognized sort column \"%s\".\n"), col); 28957c478bd9Sstevel@tonic-gate 28967c478bd9Sstevel@tonic-gate sortkey_sz += columns[i].sortkey_width; 28977c478bd9Sstevel@tonic-gate } 28987c478bd9Sstevel@tonic-gate 28997c478bd9Sstevel@tonic-gate static void 29007c478bd9Sstevel@tonic-gate add_restarter(const char *fmri) 29017c478bd9Sstevel@tonic-gate { 29027c478bd9Sstevel@tonic-gate char *cfmri; 29037c478bd9Sstevel@tonic-gate const char *pg_name; 29047c478bd9Sstevel@tonic-gate struct pfmri_list *rest; 29057c478bd9Sstevel@tonic-gate 29067c478bd9Sstevel@tonic-gate cfmri = safe_strdup(fmri); 29077c478bd9Sstevel@tonic-gate rest = safe_malloc(sizeof (*rest)); 29087c478bd9Sstevel@tonic-gate 29097c478bd9Sstevel@tonic-gate if (scf_parse_svc_fmri(cfmri, &rest->scope, &rest->service, 29107c478bd9Sstevel@tonic-gate &rest->instance, &pg_name, NULL) != SCF_SUCCESS) 29117c478bd9Sstevel@tonic-gate uu_die(gettext("Restarter FMRI \"%s\" is invalid.\n"), fmri); 29127c478bd9Sstevel@tonic-gate 29137c478bd9Sstevel@tonic-gate if (rest->instance == NULL || pg_name != NULL) 29147c478bd9Sstevel@tonic-gate uu_die(gettext("Restarter FMRI \"%s\" does not designate an " 29157c478bd9Sstevel@tonic-gate "instance.\n"), fmri); 29167c478bd9Sstevel@tonic-gate 29177c478bd9Sstevel@tonic-gate rest->next = restarters; 29187c478bd9Sstevel@tonic-gate restarters = rest; 29197c478bd9Sstevel@tonic-gate return; 29207c478bd9Sstevel@tonic-gate 29217c478bd9Sstevel@tonic-gate err: 29227c478bd9Sstevel@tonic-gate free(cfmri); 29237c478bd9Sstevel@tonic-gate free(rest); 29247c478bd9Sstevel@tonic-gate } 29257c478bd9Sstevel@tonic-gate 29267c478bd9Sstevel@tonic-gate /* ARGSUSED */ 29277c478bd9Sstevel@tonic-gate static int 29287c478bd9Sstevel@tonic-gate line_cmp(const void *l_arg, const void *r_arg, void *private) 29297c478bd9Sstevel@tonic-gate { 29307c478bd9Sstevel@tonic-gate const struct avl_string *l = l_arg; 29317c478bd9Sstevel@tonic-gate const struct avl_string *r = r_arg; 29327c478bd9Sstevel@tonic-gate 29337c478bd9Sstevel@tonic-gate return (memcmp(l->key, r->key, sortkey_sz)); 29347c478bd9Sstevel@tonic-gate } 29357c478bd9Sstevel@tonic-gate 29367c478bd9Sstevel@tonic-gate /* ARGSUSED */ 29377c478bd9Sstevel@tonic-gate static int 29387c478bd9Sstevel@tonic-gate print_line(void *e, void *private) 29397c478bd9Sstevel@tonic-gate { 29407c478bd9Sstevel@tonic-gate struct avl_string *lp = e; 29417c478bd9Sstevel@tonic-gate 29427c478bd9Sstevel@tonic-gate (void) puts(lp->str); 29437c478bd9Sstevel@tonic-gate 29447c478bd9Sstevel@tonic-gate return (UU_WALK_NEXT); 29457c478bd9Sstevel@tonic-gate } 29467c478bd9Sstevel@tonic-gate 29477c478bd9Sstevel@tonic-gate int 29487c478bd9Sstevel@tonic-gate main(int argc, char **argv) 29497c478bd9Sstevel@tonic-gate { 29507c478bd9Sstevel@tonic-gate char opt, opt_mode; 29517c478bd9Sstevel@tonic-gate int i, n; 29527c478bd9Sstevel@tonic-gate char *columns_str = NULL; 29537c478bd9Sstevel@tonic-gate char *cp; 29547c478bd9Sstevel@tonic-gate const char *progname; 29557c478bd9Sstevel@tonic-gate int err; 29567c478bd9Sstevel@tonic-gate 29577c478bd9Sstevel@tonic-gate int show_all = 0; 29587c478bd9Sstevel@tonic-gate int show_header = 1; 29597c478bd9Sstevel@tonic-gate 29607c478bd9Sstevel@tonic-gate const char * const options = "aHpvo:R:s:S:dDl?x"; 29617c478bd9Sstevel@tonic-gate 29627c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 29637c478bd9Sstevel@tonic-gate 29647c478bd9Sstevel@tonic-gate locale = setlocale(LC_MESSAGES, ""); 29657c478bd9Sstevel@tonic-gate if (locale) { 29667c478bd9Sstevel@tonic-gate locale = safe_strdup(locale); 29677c478bd9Sstevel@tonic-gate sanitize_locale(locale); 29687c478bd9Sstevel@tonic-gate } 29697c478bd9Sstevel@tonic-gate 29707c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 29717c478bd9Sstevel@tonic-gate progname = uu_setpname(argv[0]); 29727c478bd9Sstevel@tonic-gate 29737c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_OK; 29747c478bd9Sstevel@tonic-gate 29757c478bd9Sstevel@tonic-gate max_scf_name_length = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH); 29767c478bd9Sstevel@tonic-gate max_scf_value_length = scf_limit(SCF_LIMIT_MAX_VALUE_LENGTH); 29777c478bd9Sstevel@tonic-gate max_scf_fmri_length = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH); 29787c478bd9Sstevel@tonic-gate 29797c478bd9Sstevel@tonic-gate if (max_scf_name_length == -1 || max_scf_value_length == -1 || 29807c478bd9Sstevel@tonic-gate max_scf_fmri_length == -1) 29817c478bd9Sstevel@tonic-gate scfdie(); 29827c478bd9Sstevel@tonic-gate 29837c478bd9Sstevel@tonic-gate now = time(NULL); 29847c478bd9Sstevel@tonic-gate assert(now != -1); 29857c478bd9Sstevel@tonic-gate 29867c478bd9Sstevel@tonic-gate /* 29877c478bd9Sstevel@tonic-gate * opt_mode is the mode of operation. 0 for plain, 'd' for 29887c478bd9Sstevel@tonic-gate * dependencies, 'D' for dependents, and 'l' for detailed (long). We 29897c478bd9Sstevel@tonic-gate * need to know now so we know which options are valid. 29907c478bd9Sstevel@tonic-gate */ 29917c478bd9Sstevel@tonic-gate opt_mode = 0; 29927c478bd9Sstevel@tonic-gate while ((opt = getopt(argc, argv, options)) != -1) { 29937c478bd9Sstevel@tonic-gate switch (opt) { 29947c478bd9Sstevel@tonic-gate case '?': 29957c478bd9Sstevel@tonic-gate if (optopt == '?') { 29967c478bd9Sstevel@tonic-gate print_help(progname); 29977c478bd9Sstevel@tonic-gate return (UU_EXIT_OK); 29987c478bd9Sstevel@tonic-gate } else { 29997c478bd9Sstevel@tonic-gate argserr(progname); 30007c478bd9Sstevel@tonic-gate /* NOTREACHED */ 30017c478bd9Sstevel@tonic-gate } 30027c478bd9Sstevel@tonic-gate 30037c478bd9Sstevel@tonic-gate case 'd': 30047c478bd9Sstevel@tonic-gate case 'D': 30057c478bd9Sstevel@tonic-gate case 'l': 30067c478bd9Sstevel@tonic-gate if (opt_mode != 0) 30077c478bd9Sstevel@tonic-gate argserr(progname); 30087c478bd9Sstevel@tonic-gate 30097c478bd9Sstevel@tonic-gate opt_mode = opt; 30107c478bd9Sstevel@tonic-gate break; 30117c478bd9Sstevel@tonic-gate 30127c478bd9Sstevel@tonic-gate case 'x': 30137c478bd9Sstevel@tonic-gate if (opt_mode != 0) 30147c478bd9Sstevel@tonic-gate argserr(progname); 30157c478bd9Sstevel@tonic-gate 30167c478bd9Sstevel@tonic-gate opt_mode = opt; 30177c478bd9Sstevel@tonic-gate break; 30187c478bd9Sstevel@tonic-gate 30197c478bd9Sstevel@tonic-gate default: 30207c478bd9Sstevel@tonic-gate break; 30217c478bd9Sstevel@tonic-gate } 30227c478bd9Sstevel@tonic-gate } 30237c478bd9Sstevel@tonic-gate 30247c478bd9Sstevel@tonic-gate sortkey_sz = 0; 30257c478bd9Sstevel@tonic-gate 30267c478bd9Sstevel@tonic-gate optind = 1; /* Reset getopt() */ 30277c478bd9Sstevel@tonic-gate while ((opt = getopt(argc, argv, options)) != -1) { 30287c478bd9Sstevel@tonic-gate switch (opt) { 30297c478bd9Sstevel@tonic-gate case 'a': 30307c478bd9Sstevel@tonic-gate if (opt_mode != 0) 30317c478bd9Sstevel@tonic-gate argserr(progname); 30327c478bd9Sstevel@tonic-gate show_all = 1; 30337c478bd9Sstevel@tonic-gate break; 30347c478bd9Sstevel@tonic-gate 30357c478bd9Sstevel@tonic-gate case 'H': 30367c478bd9Sstevel@tonic-gate if (opt_mode == 'l' || opt_mode == 'x') 30377c478bd9Sstevel@tonic-gate argserr(progname); 30387c478bd9Sstevel@tonic-gate show_header = 0; 30397c478bd9Sstevel@tonic-gate break; 30407c478bd9Sstevel@tonic-gate 30417c478bd9Sstevel@tonic-gate case 'p': 30427c478bd9Sstevel@tonic-gate if (opt_mode == 'x') 30437c478bd9Sstevel@tonic-gate argserr(progname); 30447c478bd9Sstevel@tonic-gate opt_processes = 1; 30457c478bd9Sstevel@tonic-gate break; 30467c478bd9Sstevel@tonic-gate 30477c478bd9Sstevel@tonic-gate case 'v': 30487c478bd9Sstevel@tonic-gate if (opt_mode == 'l') 30497c478bd9Sstevel@tonic-gate argserr(progname); 30507c478bd9Sstevel@tonic-gate opt_verbose = 1; 30517c478bd9Sstevel@tonic-gate break; 30527c478bd9Sstevel@tonic-gate 30537c478bd9Sstevel@tonic-gate case 'o': 30547c478bd9Sstevel@tonic-gate if (opt_mode == 'l' || opt_mode == 'x') 30557c478bd9Sstevel@tonic-gate argserr(progname); 30567c478bd9Sstevel@tonic-gate columns_str = optarg; 30577c478bd9Sstevel@tonic-gate break; 30587c478bd9Sstevel@tonic-gate 30597c478bd9Sstevel@tonic-gate case 'R': 30607c478bd9Sstevel@tonic-gate if (opt_mode != 0 || opt_mode == 'x') 30617c478bd9Sstevel@tonic-gate argserr(progname); 30627c478bd9Sstevel@tonic-gate 30637c478bd9Sstevel@tonic-gate add_restarter(optarg); 30647c478bd9Sstevel@tonic-gate break; 30657c478bd9Sstevel@tonic-gate 30667c478bd9Sstevel@tonic-gate case 's': 30677c478bd9Sstevel@tonic-gate case 'S': 30687c478bd9Sstevel@tonic-gate if (opt_mode != 0) 30697c478bd9Sstevel@tonic-gate argserr(progname); 30707c478bd9Sstevel@tonic-gate 30717c478bd9Sstevel@tonic-gate add_sort_column(optarg, optopt == 'S'); 30727c478bd9Sstevel@tonic-gate break; 30737c478bd9Sstevel@tonic-gate 30747c478bd9Sstevel@tonic-gate case 'd': 30757c478bd9Sstevel@tonic-gate case 'D': 30767c478bd9Sstevel@tonic-gate case 'l': 30777c478bd9Sstevel@tonic-gate case 'x': 30787c478bd9Sstevel@tonic-gate assert(opt_mode == optopt); 30797c478bd9Sstevel@tonic-gate break; 30807c478bd9Sstevel@tonic-gate 30817c478bd9Sstevel@tonic-gate case '?': 30827c478bd9Sstevel@tonic-gate argserr(progname); 30837c478bd9Sstevel@tonic-gate /* NOTREACHED */ 30847c478bd9Sstevel@tonic-gate 30857c478bd9Sstevel@tonic-gate default: 30867c478bd9Sstevel@tonic-gate assert(0); 30877c478bd9Sstevel@tonic-gate abort(); 30887c478bd9Sstevel@tonic-gate } 30897c478bd9Sstevel@tonic-gate } 30907c478bd9Sstevel@tonic-gate 30917c478bd9Sstevel@tonic-gate /* 30927c478bd9Sstevel@tonic-gate * -a is only meaningful when given no arguments 30937c478bd9Sstevel@tonic-gate */ 30947c478bd9Sstevel@tonic-gate if (show_all && optind != argc) 30957c478bd9Sstevel@tonic-gate uu_warn(gettext("-a ignored when used with arguments.\n")); 30967c478bd9Sstevel@tonic-gate 30977c478bd9Sstevel@tonic-gate h = scf_handle_create(SCF_VERSION); 30987c478bd9Sstevel@tonic-gate if (h == NULL) 30997c478bd9Sstevel@tonic-gate scfdie(); 31007c478bd9Sstevel@tonic-gate 31017c478bd9Sstevel@tonic-gate if (scf_handle_bind(h) == -1) 31027c478bd9Sstevel@tonic-gate uu_die(gettext("Could not bind to repository server: %s. " 31037c478bd9Sstevel@tonic-gate "Exiting.\n"), scf_strerror(scf_error())); 31047c478bd9Sstevel@tonic-gate 31057c478bd9Sstevel@tonic-gate if ((g_pg = scf_pg_create(h)) == NULL || 31067c478bd9Sstevel@tonic-gate (g_prop = scf_property_create(h)) == NULL || 31077c478bd9Sstevel@tonic-gate (g_val = scf_value_create(h)) == NULL) 31087c478bd9Sstevel@tonic-gate scfdie(); 31097c478bd9Sstevel@tonic-gate 31107c478bd9Sstevel@tonic-gate argc -= optind; 31117c478bd9Sstevel@tonic-gate argv += optind; 31127c478bd9Sstevel@tonic-gate 31137c478bd9Sstevel@tonic-gate /* 31147c478bd9Sstevel@tonic-gate * If we're in long mode, take care of it now before we deal with the 31157c478bd9Sstevel@tonic-gate * sorting and the columns, since we won't use them anyway. 31167c478bd9Sstevel@tonic-gate */ 31177c478bd9Sstevel@tonic-gate if (opt_mode == 'l') { 31187c478bd9Sstevel@tonic-gate if (argc == 0) 31197c478bd9Sstevel@tonic-gate argserr(progname); 31207c478bd9Sstevel@tonic-gate 31217c478bd9Sstevel@tonic-gate if ((err = scf_walk_fmri(h, argc, argv, SCF_WALK_MULTIPLE, 31227c478bd9Sstevel@tonic-gate print_detailed, NULL, &exit_status, uu_warn)) != 0) { 31237c478bd9Sstevel@tonic-gate uu_warn(gettext("failed to iterate over " 31247c478bd9Sstevel@tonic-gate "instances: %s\n"), scf_strerror(err)); 31257c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 31267c478bd9Sstevel@tonic-gate } 31277c478bd9Sstevel@tonic-gate 31287c478bd9Sstevel@tonic-gate return (exit_status); 31297c478bd9Sstevel@tonic-gate } 31307c478bd9Sstevel@tonic-gate 31317c478bd9Sstevel@tonic-gate if (opt_mode == 'x') { 31327c478bd9Sstevel@tonic-gate explain(opt_verbose, argc, argv); 31337c478bd9Sstevel@tonic-gate 31347c478bd9Sstevel@tonic-gate return (exit_status); 31357c478bd9Sstevel@tonic-gate } 31367c478bd9Sstevel@tonic-gate 31377c478bd9Sstevel@tonic-gate 31387c478bd9Sstevel@tonic-gate if (opt_snum == 0) { 31397c478bd9Sstevel@tonic-gate /* Default sort. */ 31407c478bd9Sstevel@tonic-gate add_sort_column("state", 0); 31417c478bd9Sstevel@tonic-gate add_sort_column("stime", 0); 31427c478bd9Sstevel@tonic-gate add_sort_column("fmri", 0); 31437c478bd9Sstevel@tonic-gate } 31447c478bd9Sstevel@tonic-gate 31457c478bd9Sstevel@tonic-gate if (columns_str == NULL) { 31467c478bd9Sstevel@tonic-gate if (!opt_verbose) 31477c478bd9Sstevel@tonic-gate columns_str = safe_strdup("state,stime,fmri"); 31487c478bd9Sstevel@tonic-gate else 31497c478bd9Sstevel@tonic-gate columns_str = 31507c478bd9Sstevel@tonic-gate safe_strdup("state,nstate,stime,ctid,fmri"); 31517c478bd9Sstevel@tonic-gate } 31527c478bd9Sstevel@tonic-gate 31537c478bd9Sstevel@tonic-gate /* Decode columns_str into opt_columns. */ 31547c478bd9Sstevel@tonic-gate line_sz = 0; 31557c478bd9Sstevel@tonic-gate 31567c478bd9Sstevel@tonic-gate opt_cnum = 1; 31577c478bd9Sstevel@tonic-gate for (cp = columns_str; *cp != '\0'; ++cp) 31587c478bd9Sstevel@tonic-gate if (*cp == ',') 31597c478bd9Sstevel@tonic-gate ++opt_cnum; 31607c478bd9Sstevel@tonic-gate 31617c478bd9Sstevel@tonic-gate opt_columns = malloc(opt_cnum * sizeof (*opt_columns)); 31627c478bd9Sstevel@tonic-gate if (opt_columns == NULL) 31637c478bd9Sstevel@tonic-gate uu_die(gettext("Too many columns.\n")); 31647c478bd9Sstevel@tonic-gate 31657c478bd9Sstevel@tonic-gate for (n = 0; *columns_str != '\0'; ++n) { 31667c478bd9Sstevel@tonic-gate i = getcolumnopt(&columns_str); 31677c478bd9Sstevel@tonic-gate if (i == -1) 31687c478bd9Sstevel@tonic-gate uu_die(gettext("Unknown column \"%s\".\n"), 31697c478bd9Sstevel@tonic-gate columns_str); 31707c478bd9Sstevel@tonic-gate 31717c478bd9Sstevel@tonic-gate if (strcmp(columns[i].name, "N") == 0 || 31727c478bd9Sstevel@tonic-gate strcmp(columns[i].name, "SN") == 0 || 31737c478bd9Sstevel@tonic-gate strcmp(columns[i].name, "NSTA") == 0 || 31747c478bd9Sstevel@tonic-gate strcmp(columns[i].name, "NSTATE") == 0) 31757c478bd9Sstevel@tonic-gate opt_nstate_shown = 1; 31767c478bd9Sstevel@tonic-gate 31777c478bd9Sstevel@tonic-gate opt_columns[n] = i; 31787c478bd9Sstevel@tonic-gate line_sz += columns[i].width + 1; 31797c478bd9Sstevel@tonic-gate } 31807c478bd9Sstevel@tonic-gate 31817c478bd9Sstevel@tonic-gate 31827c478bd9Sstevel@tonic-gate if ((lines_pool = uu_avl_pool_create("lines_pool", 31837c478bd9Sstevel@tonic-gate sizeof (struct avl_string), offsetof(struct avl_string, node), 31847c478bd9Sstevel@tonic-gate line_cmp, UU_AVL_DEBUG)) == NULL || 31857c478bd9Sstevel@tonic-gate (lines = uu_avl_create(lines_pool, NULL, 0)) == NULL) 31867c478bd9Sstevel@tonic-gate uu_die(gettext("Unexpected libuutil error: %s. Exiting.\n"), 31877c478bd9Sstevel@tonic-gate uu_strerror(uu_error())); 31887c478bd9Sstevel@tonic-gate 31897c478bd9Sstevel@tonic-gate switch (opt_mode) { 31907c478bd9Sstevel@tonic-gate case 0: 31917c478bd9Sstevel@tonic-gate ht_init(); 31927c478bd9Sstevel@tonic-gate 31937c478bd9Sstevel@tonic-gate /* Always show all FMRIs when given arguments or restarters */ 31947c478bd9Sstevel@tonic-gate if (argc != 0 || restarters != NULL) 31957c478bd9Sstevel@tonic-gate show_all = 1; 31967c478bd9Sstevel@tonic-gate 31977c478bd9Sstevel@tonic-gate if ((err = scf_walk_fmri(h, argc, argv, 31987c478bd9Sstevel@tonic-gate SCF_WALK_MULTIPLE | SCF_WALK_LEGACY, 31997c478bd9Sstevel@tonic-gate show_all ? list_instance : list_if_enabled, NULL, 32007c478bd9Sstevel@tonic-gate &exit_status, uu_warn)) != 0) { 32017c478bd9Sstevel@tonic-gate uu_warn(gettext("failed to iterate over " 32027c478bd9Sstevel@tonic-gate "instances: %s\n"), scf_strerror(err)); 32037c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 32047c478bd9Sstevel@tonic-gate } 32057c478bd9Sstevel@tonic-gate break; 32067c478bd9Sstevel@tonic-gate 32077c478bd9Sstevel@tonic-gate case 'd': 32087c478bd9Sstevel@tonic-gate if (argc == 0) 32097c478bd9Sstevel@tonic-gate argserr(progname); 32107c478bd9Sstevel@tonic-gate 32117c478bd9Sstevel@tonic-gate if ((err = scf_walk_fmri(h, argc, argv, 32127c478bd9Sstevel@tonic-gate SCF_WALK_MULTIPLE, list_dependencies, NULL, 32137c478bd9Sstevel@tonic-gate &exit_status, uu_warn)) != 0) { 32147c478bd9Sstevel@tonic-gate uu_warn(gettext("failed to iterate over " 32157c478bd9Sstevel@tonic-gate "instances: %s\n"), scf_strerror(err)); 32167c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 32177c478bd9Sstevel@tonic-gate } 32187c478bd9Sstevel@tonic-gate break; 32197c478bd9Sstevel@tonic-gate 32207c478bd9Sstevel@tonic-gate case 'D': 32217c478bd9Sstevel@tonic-gate if (argc == 0) 32227c478bd9Sstevel@tonic-gate argserr(progname); 32237c478bd9Sstevel@tonic-gate 32247c478bd9Sstevel@tonic-gate provider_scope = safe_malloc(max_scf_fmri_length); 32257c478bd9Sstevel@tonic-gate provider_svc = safe_malloc(max_scf_fmri_length); 32267c478bd9Sstevel@tonic-gate provider_inst = safe_malloc(max_scf_fmri_length); 32277c478bd9Sstevel@tonic-gate 32287c478bd9Sstevel@tonic-gate if ((err = scf_walk_fmri(h, argc, argv, 32297c478bd9Sstevel@tonic-gate SCF_WALK_MULTIPLE | SCF_WALK_SERVICE, 32307c478bd9Sstevel@tonic-gate list_dependents, NULL, &exit_status, uu_warn)) != 0) { 32317c478bd9Sstevel@tonic-gate uu_warn(gettext("failed to iterate over " 32327c478bd9Sstevel@tonic-gate "instances: %s\n"), scf_strerror(err)); 32337c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 32347c478bd9Sstevel@tonic-gate } 32357c478bd9Sstevel@tonic-gate 32367c478bd9Sstevel@tonic-gate free(provider_scope); 32377c478bd9Sstevel@tonic-gate free(provider_svc); 32387c478bd9Sstevel@tonic-gate free(provider_inst); 32397c478bd9Sstevel@tonic-gate break; 32407c478bd9Sstevel@tonic-gate 32417c478bd9Sstevel@tonic-gate default: 32427c478bd9Sstevel@tonic-gate assert(0); 32437c478bd9Sstevel@tonic-gate abort(); 32447c478bd9Sstevel@tonic-gate } 32457c478bd9Sstevel@tonic-gate 32467c478bd9Sstevel@tonic-gate if (show_header) 32477c478bd9Sstevel@tonic-gate print_header(); 32487c478bd9Sstevel@tonic-gate 32497c478bd9Sstevel@tonic-gate (void) uu_avl_walk(lines, print_line, NULL, 0); 32507c478bd9Sstevel@tonic-gate 32517c478bd9Sstevel@tonic-gate return (exit_status); 32527c478bd9Sstevel@tonic-gate } 3253