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