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 521d7f835Sgm149974 * Common Development and Distribution License (the "License"). 621d7f835Sgm149974 * 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 */ 2153f3aea0SRoger A. Faulkner 227c478bd9Sstevel@tonic-gate /* 238b55d351SSean Wilcox * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved. 24609a0c4bSGarrett D'Amore * Copyright (c) 2012, Joyent, Inc. All rights reserved. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate /* 287c478bd9Sstevel@tonic-gate * restarter.c - service manipulation 297c478bd9Sstevel@tonic-gate * 307c478bd9Sstevel@tonic-gate * This component manages services whose restarter is svc.startd, the standard 317c478bd9Sstevel@tonic-gate * restarter. It translates restarter protocol events from the graph engine 327c478bd9Sstevel@tonic-gate * into actions on processes, as a delegated restarter would do. 337c478bd9Sstevel@tonic-gate * 347c478bd9Sstevel@tonic-gate * The master restarter manages a number of always-running threads: 357c478bd9Sstevel@tonic-gate * - restarter event thread: events from the graph engine 367c478bd9Sstevel@tonic-gate * - timeout thread: thread to fire queued timeouts 377c478bd9Sstevel@tonic-gate * - contract thread: thread to handle contract events 387c478bd9Sstevel@tonic-gate * - wait thread: thread to handle wait-based services 397c478bd9Sstevel@tonic-gate * 407c478bd9Sstevel@tonic-gate * The other threads are created as-needed: 417c478bd9Sstevel@tonic-gate * - per-instance method threads 427c478bd9Sstevel@tonic-gate * - per-instance event processing threads 437c478bd9Sstevel@tonic-gate * 447c478bd9Sstevel@tonic-gate * The interaction of all threads must result in the following conditions 457c478bd9Sstevel@tonic-gate * being satisfied (on a per-instance basis): 467c478bd9Sstevel@tonic-gate * - restarter events must be processed in order 477c478bd9Sstevel@tonic-gate * - method execution must be serialized 487c478bd9Sstevel@tonic-gate * - instance delete must be held until outstanding methods are complete 497c478bd9Sstevel@tonic-gate * - contract events shouldn't be processed while a method is running 507c478bd9Sstevel@tonic-gate * - timeouts should fire even when a method is running 517c478bd9Sstevel@tonic-gate * 527c478bd9Sstevel@tonic-gate * Service instances are represented by restarter_inst_t's and are kept in the 537c478bd9Sstevel@tonic-gate * instance_list list. 547c478bd9Sstevel@tonic-gate * 557c478bd9Sstevel@tonic-gate * Service States 567c478bd9Sstevel@tonic-gate * The current state of a service instance is kept in 577c478bd9Sstevel@tonic-gate * restarter_inst_t->ri_i.i_state. If transition to a new state could take 587c478bd9Sstevel@tonic-gate * some time, then before we effect the transition we set 597c478bd9Sstevel@tonic-gate * restarter_inst_t->ri_i.i_next_state to the target state, and afterwards we 607c478bd9Sstevel@tonic-gate * rotate i_next_state to i_state and set i_next_state to 617c478bd9Sstevel@tonic-gate * RESTARTER_STATE_NONE. So usually i_next_state is _NONE when ri_lock is not 627c478bd9Sstevel@tonic-gate * held. The exception is when we launch methods, which are done with 637c478bd9Sstevel@tonic-gate * a separate thread. To keep any other threads from grabbing ri_lock before 647c478bd9Sstevel@tonic-gate * method_thread() does, we set ri_method_thread to the thread id of the 657c478bd9Sstevel@tonic-gate * method thread, and when it is nonzero any thread with a different thread id 667c478bd9Sstevel@tonic-gate * waits on ri_method_cv. 677c478bd9Sstevel@tonic-gate * 687c478bd9Sstevel@tonic-gate * Method execution is serialized by blocking on ri_method_cv in 697c478bd9Sstevel@tonic-gate * inst_lookup_by_id() and waiting for a 0 value of ri_method_thread. This 707c478bd9Sstevel@tonic-gate * also prevents the instance structure from being deleted until all 717c478bd9Sstevel@tonic-gate * outstanding operations such as method_thread() have finished. 727c478bd9Sstevel@tonic-gate * 737c478bd9Sstevel@tonic-gate * Lock ordering: 747c478bd9Sstevel@tonic-gate * 757c478bd9Sstevel@tonic-gate * dgraph_lock [can be held when taking:] 767c478bd9Sstevel@tonic-gate * utmpx_lock 777c478bd9Sstevel@tonic-gate * dictionary->dict_lock 787c478bd9Sstevel@tonic-gate * st->st_load_lock 797c478bd9Sstevel@tonic-gate * wait_info_lock 807c478bd9Sstevel@tonic-gate * ru->restarter_update_lock 817c478bd9Sstevel@tonic-gate * restarter_queue->rpeq_lock 827c478bd9Sstevel@tonic-gate * instance_list.ril_lock 837c478bd9Sstevel@tonic-gate * inst->ri_lock 847c478bd9Sstevel@tonic-gate * st->st_configd_live_lock 857c478bd9Sstevel@tonic-gate * 867c478bd9Sstevel@tonic-gate * instance_list.ril_lock 877c478bd9Sstevel@tonic-gate * graph_queue->gpeq_lock 887c478bd9Sstevel@tonic-gate * gu->gu_lock 897c478bd9Sstevel@tonic-gate * st->st_configd_live_lock 907c478bd9Sstevel@tonic-gate * dictionary->dict_lock 917c478bd9Sstevel@tonic-gate * inst->ri_lock 927c478bd9Sstevel@tonic-gate * graph_queue->gpeq_lock 937c478bd9Sstevel@tonic-gate * gu->gu_lock 947c478bd9Sstevel@tonic-gate * tu->tu_lock 957c478bd9Sstevel@tonic-gate * tq->tq_lock 967c478bd9Sstevel@tonic-gate * inst->ri_queue_lock 977c478bd9Sstevel@tonic-gate * wait_info_lock 987c478bd9Sstevel@tonic-gate * bp->cb_lock 997c478bd9Sstevel@tonic-gate * utmpx_lock 1007c478bd9Sstevel@tonic-gate * 1017c478bd9Sstevel@tonic-gate * single_user_thread_lock 1027c478bd9Sstevel@tonic-gate * wait_info_lock 1037c478bd9Sstevel@tonic-gate * utmpx_lock 1047c478bd9Sstevel@tonic-gate * 1057c478bd9Sstevel@tonic-gate * gu_freeze_lock 1067c478bd9Sstevel@tonic-gate * 1077c478bd9Sstevel@tonic-gate * logbuf_mutex nests inside pretty much everything. 1087c478bd9Sstevel@tonic-gate */ 1097c478bd9Sstevel@tonic-gate 1107c478bd9Sstevel@tonic-gate #include <sys/contract/process.h> 1117c478bd9Sstevel@tonic-gate #include <sys/ctfs.h> 1127c478bd9Sstevel@tonic-gate #include <sys/stat.h> 1137c478bd9Sstevel@tonic-gate #include <sys/time.h> 1147c478bd9Sstevel@tonic-gate #include <sys/types.h> 1157c478bd9Sstevel@tonic-gate #include <sys/uio.h> 1167c478bd9Sstevel@tonic-gate #include <sys/wait.h> 1177c478bd9Sstevel@tonic-gate #include <assert.h> 1187c478bd9Sstevel@tonic-gate #include <errno.h> 1197c478bd9Sstevel@tonic-gate #include <fcntl.h> 1207c478bd9Sstevel@tonic-gate #include <libcontract.h> 1217c478bd9Sstevel@tonic-gate #include <libcontract_priv.h> 1227c478bd9Sstevel@tonic-gate #include <libintl.h> 1237c478bd9Sstevel@tonic-gate #include <librestart.h> 1247c478bd9Sstevel@tonic-gate #include <librestart_priv.h> 1257c478bd9Sstevel@tonic-gate #include <libuutil.h> 1267c478bd9Sstevel@tonic-gate #include <limits.h> 1277c478bd9Sstevel@tonic-gate #include <poll.h> 1287c478bd9Sstevel@tonic-gate #include <port.h> 1297c478bd9Sstevel@tonic-gate #include <pthread.h> 1307c478bd9Sstevel@tonic-gate #include <stdarg.h> 1317c478bd9Sstevel@tonic-gate #include <stdio.h> 1327c478bd9Sstevel@tonic-gate #include <strings.h> 1337c478bd9Sstevel@tonic-gate #include <unistd.h> 1347c478bd9Sstevel@tonic-gate 1357c478bd9Sstevel@tonic-gate #include "startd.h" 1367c478bd9Sstevel@tonic-gate #include "protocol.h" 1377c478bd9Sstevel@tonic-gate 1387c478bd9Sstevel@tonic-gate static uu_list_pool_t *restarter_instance_pool; 1397c478bd9Sstevel@tonic-gate static restarter_instance_list_t instance_list; 1407c478bd9Sstevel@tonic-gate 1417c478bd9Sstevel@tonic-gate static uu_list_pool_t *restarter_queue_pool; 1427c478bd9Sstevel@tonic-gate 14316ba0facSSean Wilcox /* 14416ba0facSSean Wilcox * Function used to reset the restart times for an instance, when 14516ba0facSSean Wilcox * an administrative task comes along and essentially makes the times 14616ba0facSSean Wilcox * in this array ineffective. 14716ba0facSSean Wilcox */ 14816ba0facSSean Wilcox static void 14916ba0facSSean Wilcox reset_start_times(restarter_inst_t *inst) 15016ba0facSSean Wilcox { 15116ba0facSSean Wilcox inst->ri_start_index = 0; 15216ba0facSSean Wilcox bzero(inst->ri_start_time, sizeof (inst->ri_start_time)); 15316ba0facSSean Wilcox } 15416ba0facSSean Wilcox 1557c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1567c478bd9Sstevel@tonic-gate static int 1577c478bd9Sstevel@tonic-gate restarter_instance_compare(const void *lc_arg, const void *rc_arg, 1587c478bd9Sstevel@tonic-gate void *private) 1597c478bd9Sstevel@tonic-gate { 1607c478bd9Sstevel@tonic-gate int lc_id = ((const restarter_inst_t *)lc_arg)->ri_id; 1617c478bd9Sstevel@tonic-gate int rc_id = *(int *)rc_arg; 1627c478bd9Sstevel@tonic-gate 1637c478bd9Sstevel@tonic-gate if (lc_id > rc_id) 1647c478bd9Sstevel@tonic-gate return (1); 1657c478bd9Sstevel@tonic-gate if (lc_id < rc_id) 1667c478bd9Sstevel@tonic-gate return (-1); 1677c478bd9Sstevel@tonic-gate return (0); 1687c478bd9Sstevel@tonic-gate } 1697c478bd9Sstevel@tonic-gate 1707c478bd9Sstevel@tonic-gate static restarter_inst_t * 1717c478bd9Sstevel@tonic-gate inst_lookup_by_name(const char *name) 1727c478bd9Sstevel@tonic-gate { 1737c478bd9Sstevel@tonic-gate int id; 1747c478bd9Sstevel@tonic-gate 1757c478bd9Sstevel@tonic-gate id = dict_lookup_byname(name); 1767c478bd9Sstevel@tonic-gate if (id == -1) 1777c478bd9Sstevel@tonic-gate return (NULL); 1787c478bd9Sstevel@tonic-gate 1797c478bd9Sstevel@tonic-gate return (inst_lookup_by_id(id)); 1807c478bd9Sstevel@tonic-gate } 1817c478bd9Sstevel@tonic-gate 1827c478bd9Sstevel@tonic-gate restarter_inst_t * 1837c478bd9Sstevel@tonic-gate inst_lookup_by_id(int id) 1847c478bd9Sstevel@tonic-gate { 1857c478bd9Sstevel@tonic-gate restarter_inst_t *inst; 1867c478bd9Sstevel@tonic-gate 1877c478bd9Sstevel@tonic-gate MUTEX_LOCK(&instance_list.ril_lock); 1887c478bd9Sstevel@tonic-gate inst = uu_list_find(instance_list.ril_instance_list, &id, NULL, NULL); 1897c478bd9Sstevel@tonic-gate if (inst != NULL) 1907c478bd9Sstevel@tonic-gate MUTEX_LOCK(&inst->ri_lock); 1917c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&instance_list.ril_lock); 1927c478bd9Sstevel@tonic-gate 1937c478bd9Sstevel@tonic-gate if (inst != NULL) { 1947c478bd9Sstevel@tonic-gate while (inst->ri_method_thread != 0 && 1957c478bd9Sstevel@tonic-gate !pthread_equal(inst->ri_method_thread, pthread_self())) { 1967c478bd9Sstevel@tonic-gate ++inst->ri_method_waiters; 1977c478bd9Sstevel@tonic-gate (void) pthread_cond_wait(&inst->ri_method_cv, 1987c478bd9Sstevel@tonic-gate &inst->ri_lock); 1997c478bd9Sstevel@tonic-gate assert(inst->ri_method_waiters > 0); 2007c478bd9Sstevel@tonic-gate --inst->ri_method_waiters; 2017c478bd9Sstevel@tonic-gate } 2027c478bd9Sstevel@tonic-gate } 2037c478bd9Sstevel@tonic-gate 2047c478bd9Sstevel@tonic-gate return (inst); 2057c478bd9Sstevel@tonic-gate } 2067c478bd9Sstevel@tonic-gate 2077c478bd9Sstevel@tonic-gate static restarter_inst_t * 2087c478bd9Sstevel@tonic-gate inst_lookup_queue(const char *name) 2097c478bd9Sstevel@tonic-gate { 2107c478bd9Sstevel@tonic-gate int id; 2117c478bd9Sstevel@tonic-gate restarter_inst_t *inst; 2127c478bd9Sstevel@tonic-gate 2137c478bd9Sstevel@tonic-gate id = dict_lookup_byname(name); 2147c478bd9Sstevel@tonic-gate if (id == -1) 2157c478bd9Sstevel@tonic-gate return (NULL); 2167c478bd9Sstevel@tonic-gate 2177c478bd9Sstevel@tonic-gate MUTEX_LOCK(&instance_list.ril_lock); 2187c478bd9Sstevel@tonic-gate inst = uu_list_find(instance_list.ril_instance_list, &id, NULL, NULL); 2197c478bd9Sstevel@tonic-gate if (inst != NULL) 2207c478bd9Sstevel@tonic-gate MUTEX_LOCK(&inst->ri_queue_lock); 2217c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&instance_list.ril_lock); 2227c478bd9Sstevel@tonic-gate 2237c478bd9Sstevel@tonic-gate return (inst); 2247c478bd9Sstevel@tonic-gate } 2257c478bd9Sstevel@tonic-gate 2267c478bd9Sstevel@tonic-gate const char * 2277c478bd9Sstevel@tonic-gate service_style(int flags) 2287c478bd9Sstevel@tonic-gate { 2297c478bd9Sstevel@tonic-gate switch (flags & RINST_STYLE_MASK) { 2307c478bd9Sstevel@tonic-gate case RINST_CONTRACT: return ("contract"); 2317c478bd9Sstevel@tonic-gate case RINST_TRANSIENT: return ("transient"); 2327c478bd9Sstevel@tonic-gate case RINST_WAIT: return ("wait"); 2337c478bd9Sstevel@tonic-gate 2347c478bd9Sstevel@tonic-gate default: 2357c478bd9Sstevel@tonic-gate #ifndef NDEBUG 2367c478bd9Sstevel@tonic-gate uu_warn("%s:%d: Bad flags 0x%x.\n", __FILE__, __LINE__, flags); 2377c478bd9Sstevel@tonic-gate #endif 2387c478bd9Sstevel@tonic-gate abort(); 2397c478bd9Sstevel@tonic-gate /* NOTREACHED */ 2407c478bd9Sstevel@tonic-gate } 2417c478bd9Sstevel@tonic-gate } 2427c478bd9Sstevel@tonic-gate 2437c478bd9Sstevel@tonic-gate /* 2447c478bd9Sstevel@tonic-gate * Fails with ECONNABORTED or ECANCELED. 2457c478bd9Sstevel@tonic-gate */ 2467c478bd9Sstevel@tonic-gate static int 2477c478bd9Sstevel@tonic-gate check_contract(restarter_inst_t *inst, boolean_t primary, 2487c478bd9Sstevel@tonic-gate scf_instance_t *scf_inst) 2497c478bd9Sstevel@tonic-gate { 2507c478bd9Sstevel@tonic-gate ctid_t *ctidp; 2517c478bd9Sstevel@tonic-gate int fd, r; 2527c478bd9Sstevel@tonic-gate 2537c478bd9Sstevel@tonic-gate ctidp = primary ? &inst->ri_i.i_primary_ctid : 2547c478bd9Sstevel@tonic-gate &inst->ri_i.i_transient_ctid; 2557c478bd9Sstevel@tonic-gate 2567c478bd9Sstevel@tonic-gate assert(*ctidp >= 1); 2577c478bd9Sstevel@tonic-gate 2587c478bd9Sstevel@tonic-gate fd = contract_open(*ctidp, NULL, "status", O_RDONLY); 2597c478bd9Sstevel@tonic-gate if (fd >= 0) { 2607c478bd9Sstevel@tonic-gate r = close(fd); 2617c478bd9Sstevel@tonic-gate assert(r == 0); 2627c478bd9Sstevel@tonic-gate return (0); 2637c478bd9Sstevel@tonic-gate } 2647c478bd9Sstevel@tonic-gate 2657c478bd9Sstevel@tonic-gate r = restarter_remove_contract(scf_inst, *ctidp, primary ? 2667c478bd9Sstevel@tonic-gate RESTARTER_CONTRACT_PRIMARY : RESTARTER_CONTRACT_TRANSIENT); 2677c478bd9Sstevel@tonic-gate switch (r) { 2687c478bd9Sstevel@tonic-gate case 0: 2697c478bd9Sstevel@tonic-gate case ECONNABORTED: 2707c478bd9Sstevel@tonic-gate case ECANCELED: 2717c478bd9Sstevel@tonic-gate *ctidp = 0; 2727c478bd9Sstevel@tonic-gate return (r); 2737c478bd9Sstevel@tonic-gate 2747c478bd9Sstevel@tonic-gate case ENOMEM: 2757c478bd9Sstevel@tonic-gate uu_die("Out of memory\n"); 2767c478bd9Sstevel@tonic-gate /* NOTREACHED */ 2777c478bd9Sstevel@tonic-gate 2787c478bd9Sstevel@tonic-gate case EPERM: 2797c478bd9Sstevel@tonic-gate uu_die("Insufficient privilege.\n"); 2807c478bd9Sstevel@tonic-gate /* NOTREACHED */ 2817c478bd9Sstevel@tonic-gate 2827c478bd9Sstevel@tonic-gate case EACCES: 2837c478bd9Sstevel@tonic-gate uu_die("Repository backend access denied.\n"); 2847c478bd9Sstevel@tonic-gate /* NOTREACHED */ 2857c478bd9Sstevel@tonic-gate 2867c478bd9Sstevel@tonic-gate case EROFS: 2877c478bd9Sstevel@tonic-gate log_error(LOG_INFO, "Could not remove unusable contract id %ld " 2887c478bd9Sstevel@tonic-gate "for %s from repository.\n", *ctidp, inst->ri_i.i_fmri); 2897c478bd9Sstevel@tonic-gate return (0); 2907c478bd9Sstevel@tonic-gate 2917c478bd9Sstevel@tonic-gate case EINVAL: 2927c478bd9Sstevel@tonic-gate case EBADF: 2937c478bd9Sstevel@tonic-gate default: 2947c478bd9Sstevel@tonic-gate assert(0); 2957c478bd9Sstevel@tonic-gate abort(); 2967c478bd9Sstevel@tonic-gate /* NOTREACHED */ 2977c478bd9Sstevel@tonic-gate } 2987c478bd9Sstevel@tonic-gate } 2997c478bd9Sstevel@tonic-gate 3007c478bd9Sstevel@tonic-gate static int stop_instance(scf_handle_t *, restarter_inst_t *, stop_cause_t); 3017c478bd9Sstevel@tonic-gate 3027c478bd9Sstevel@tonic-gate /* 3037c478bd9Sstevel@tonic-gate * int restarter_insert_inst(scf_handle_t *, char *) 3047c478bd9Sstevel@tonic-gate * If the inst is already in the restarter list, return its id. If the inst 3057c478bd9Sstevel@tonic-gate * is not in the restarter list, initialize a restarter_inst_t, initialize its 3067c478bd9Sstevel@tonic-gate * states, insert it into the list, and return 0. 3077c478bd9Sstevel@tonic-gate * 3087c478bd9Sstevel@tonic-gate * Fails with 3097c478bd9Sstevel@tonic-gate * ENOENT - name is not in the repository 3107c478bd9Sstevel@tonic-gate */ 3117c478bd9Sstevel@tonic-gate static int 3127c478bd9Sstevel@tonic-gate restarter_insert_inst(scf_handle_t *h, const char *name) 3137c478bd9Sstevel@tonic-gate { 3147c478bd9Sstevel@tonic-gate int id, r; 3157c478bd9Sstevel@tonic-gate restarter_inst_t *inst; 3167c478bd9Sstevel@tonic-gate uu_list_index_t idx; 3177c478bd9Sstevel@tonic-gate scf_service_t *scf_svc; 3187c478bd9Sstevel@tonic-gate scf_instance_t *scf_inst; 31992175b8eSrm88369 scf_snapshot_t *snap = NULL; 3207c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg; 3217c478bd9Sstevel@tonic-gate char *svc_name, *inst_name; 3227c478bd9Sstevel@tonic-gate char logfilebuf[PATH_MAX]; 3237c478bd9Sstevel@tonic-gate char *c; 3247c478bd9Sstevel@tonic-gate boolean_t do_commit_states; 3257c478bd9Sstevel@tonic-gate restarter_instance_state_t state, next_state; 3267c478bd9Sstevel@tonic-gate protocol_states_t *ps; 3277c478bd9Sstevel@tonic-gate pid_t start_pid; 328f6e214c7SGavin Maltby restarter_str_t reason = restarter_str_insert_in_graph; 3297c478bd9Sstevel@tonic-gate 3307c478bd9Sstevel@tonic-gate MUTEX_LOCK(&instance_list.ril_lock); 3317c478bd9Sstevel@tonic-gate 3327c478bd9Sstevel@tonic-gate /* 3337c478bd9Sstevel@tonic-gate * We don't use inst_lookup_by_name() here because we want the lookup 3347c478bd9Sstevel@tonic-gate * & insert to be atomic. 3357c478bd9Sstevel@tonic-gate */ 3367c478bd9Sstevel@tonic-gate id = dict_lookup_byname(name); 3377c478bd9Sstevel@tonic-gate if (id != -1) { 3387c478bd9Sstevel@tonic-gate inst = uu_list_find(instance_list.ril_instance_list, &id, NULL, 3397c478bd9Sstevel@tonic-gate &idx); 3407c478bd9Sstevel@tonic-gate if (inst != NULL) { 3417c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&instance_list.ril_lock); 3427c478bd9Sstevel@tonic-gate return (0); 3437c478bd9Sstevel@tonic-gate } 3447c478bd9Sstevel@tonic-gate } 3457c478bd9Sstevel@tonic-gate 3467c478bd9Sstevel@tonic-gate /* Allocate an instance */ 3477c478bd9Sstevel@tonic-gate inst = startd_zalloc(sizeof (restarter_inst_t)); 3487c478bd9Sstevel@tonic-gate inst->ri_utmpx_prefix = startd_alloc(max_scf_value_size); 3497c478bd9Sstevel@tonic-gate inst->ri_utmpx_prefix[0] = '\0'; 3507c478bd9Sstevel@tonic-gate 3517c478bd9Sstevel@tonic-gate inst->ri_i.i_fmri = startd_alloc(strlen(name) + 1); 3527c478bd9Sstevel@tonic-gate (void) strcpy((char *)inst->ri_i.i_fmri, name); 3537c478bd9Sstevel@tonic-gate 3547c478bd9Sstevel@tonic-gate inst->ri_queue = startd_list_create(restarter_queue_pool, inst, 0); 3557c478bd9Sstevel@tonic-gate 3567c478bd9Sstevel@tonic-gate /* 3577c478bd9Sstevel@tonic-gate * id shouldn't be -1 since we use the same dictionary as graph.c, but 3587c478bd9Sstevel@tonic-gate * just in case. 3597c478bd9Sstevel@tonic-gate */ 3607c478bd9Sstevel@tonic-gate inst->ri_id = (id != -1 ? id : dict_insert(name)); 3617c478bd9Sstevel@tonic-gate 3627c478bd9Sstevel@tonic-gate special_online_hooks_get(name, &inst->ri_pre_online_hook, 3637c478bd9Sstevel@tonic-gate &inst->ri_post_online_hook, &inst->ri_post_offline_hook); 3647c478bd9Sstevel@tonic-gate 3657c478bd9Sstevel@tonic-gate scf_svc = safe_scf_service_create(h); 3667c478bd9Sstevel@tonic-gate scf_inst = safe_scf_instance_create(h); 3677c478bd9Sstevel@tonic-gate pg = safe_scf_pg_create(h); 3687c478bd9Sstevel@tonic-gate svc_name = startd_alloc(max_scf_name_size); 3697c478bd9Sstevel@tonic-gate inst_name = startd_alloc(max_scf_name_size); 3707c478bd9Sstevel@tonic-gate 3717c478bd9Sstevel@tonic-gate rep_retry: 37292175b8eSrm88369 if (snap != NULL) 37392175b8eSrm88369 scf_snapshot_destroy(snap); 37492175b8eSrm88369 if (inst->ri_logstem != NULL) 37592175b8eSrm88369 startd_free(inst->ri_logstem, PATH_MAX); 37692175b8eSrm88369 if (inst->ri_common_name != NULL) 377*c8faf4ecSJerry Jelinek free(inst->ri_common_name); 37892175b8eSrm88369 if (inst->ri_C_common_name != NULL) 379*c8faf4ecSJerry Jelinek free(inst->ri_C_common_name); 38092175b8eSrm88369 snap = NULL; 38192175b8eSrm88369 inst->ri_logstem = NULL; 38292175b8eSrm88369 inst->ri_common_name = NULL; 38392175b8eSrm88369 inst->ri_C_common_name = NULL; 38492175b8eSrm88369 3857c478bd9Sstevel@tonic-gate if (scf_handle_decode_fmri(h, name, NULL, scf_svc, scf_inst, NULL, 3867c478bd9Sstevel@tonic-gate NULL, SCF_DECODE_FMRI_EXACT) != 0) { 3877c478bd9Sstevel@tonic-gate switch (scf_error()) { 3887c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN: 3897c478bd9Sstevel@tonic-gate libscf_handle_rebind(h); 3907c478bd9Sstevel@tonic-gate goto rep_retry; 3917c478bd9Sstevel@tonic-gate 3927c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND: 39392175b8eSrm88369 goto deleted; 3947c478bd9Sstevel@tonic-gate } 3957c478bd9Sstevel@tonic-gate 3967c478bd9Sstevel@tonic-gate uu_die("Can't decode FMRI %s: %s\n", name, 3977c478bd9Sstevel@tonic-gate scf_strerror(scf_error())); 3987c478bd9Sstevel@tonic-gate } 3997c478bd9Sstevel@tonic-gate 4007c478bd9Sstevel@tonic-gate /* 4017c478bd9Sstevel@tonic-gate * If there's no running snapshot, then we execute using the editing 4027c478bd9Sstevel@tonic-gate * snapshot. Pending snapshots will be taken later. 4037c478bd9Sstevel@tonic-gate */ 4047c478bd9Sstevel@tonic-gate snap = libscf_get_running_snapshot(scf_inst); 4057c478bd9Sstevel@tonic-gate 4067c478bd9Sstevel@tonic-gate if ((scf_service_get_name(scf_svc, svc_name, max_scf_name_size) < 0) || 4077c478bd9Sstevel@tonic-gate (scf_instance_get_name(scf_inst, inst_name, max_scf_name_size) < 4087c478bd9Sstevel@tonic-gate 0)) { 4097c478bd9Sstevel@tonic-gate switch (scf_error()) { 4107c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET: 4117c478bd9Sstevel@tonic-gate break; 4127c478bd9Sstevel@tonic-gate 4137c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN: 4147c478bd9Sstevel@tonic-gate libscf_handle_rebind(h); 4157c478bd9Sstevel@tonic-gate goto rep_retry; 4167c478bd9Sstevel@tonic-gate 4177c478bd9Sstevel@tonic-gate default: 4187c478bd9Sstevel@tonic-gate assert(0); 4197c478bd9Sstevel@tonic-gate abort(); 4207c478bd9Sstevel@tonic-gate } 4217c478bd9Sstevel@tonic-gate 4227c478bd9Sstevel@tonic-gate goto deleted; 4237c478bd9Sstevel@tonic-gate } 4247c478bd9Sstevel@tonic-gate 4251855af6bSlianep (void) snprintf(logfilebuf, PATH_MAX, "%s:%s", svc_name, inst_name); 4261855af6bSlianep for (c = logfilebuf; *c != '\0'; c++) 4271855af6bSlianep if (*c == '/') 4281855af6bSlianep *c = '-'; 4291855af6bSlianep 4301855af6bSlianep inst->ri_logstem = startd_alloc(PATH_MAX); 4311855af6bSlianep (void) snprintf(inst->ri_logstem, PATH_MAX, "%s%s", logfilebuf, 4321855af6bSlianep LOG_SUFFIX); 4331855af6bSlianep 4347c478bd9Sstevel@tonic-gate /* 4357c478bd9Sstevel@tonic-gate * If the restarter group is missing, use uninit/none. Otherwise, 4367c478bd9Sstevel@tonic-gate * we're probably being restarted & don't want to mess up the states 4377c478bd9Sstevel@tonic-gate * that are there. 4387c478bd9Sstevel@tonic-gate */ 4397c478bd9Sstevel@tonic-gate state = RESTARTER_STATE_UNINIT; 4407c478bd9Sstevel@tonic-gate next_state = RESTARTER_STATE_NONE; 4417c478bd9Sstevel@tonic-gate 4427c478bd9Sstevel@tonic-gate r = scf_instance_get_pg(scf_inst, SCF_PG_RESTARTER, pg); 4437c478bd9Sstevel@tonic-gate if (r != 0) { 4447c478bd9Sstevel@tonic-gate switch (scf_error()) { 4457c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN: 4467c478bd9Sstevel@tonic-gate libscf_handle_rebind(h); 4477c478bd9Sstevel@tonic-gate goto rep_retry; 4487c478bd9Sstevel@tonic-gate 4497c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET: 4507c478bd9Sstevel@tonic-gate goto deleted; 4517c478bd9Sstevel@tonic-gate 4527c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND: 4537c478bd9Sstevel@tonic-gate /* 4547c478bd9Sstevel@tonic-gate * This shouldn't happen since the graph engine should 4557c478bd9Sstevel@tonic-gate * have initialized the state to uninitialized/none if 4567c478bd9Sstevel@tonic-gate * there was no restarter pg. In case somebody 4577c478bd9Sstevel@tonic-gate * deleted it, though.... 4587c478bd9Sstevel@tonic-gate */ 4597c478bd9Sstevel@tonic-gate do_commit_states = B_TRUE; 4607c478bd9Sstevel@tonic-gate break; 4617c478bd9Sstevel@tonic-gate 4627c478bd9Sstevel@tonic-gate default: 4637c478bd9Sstevel@tonic-gate assert(0); 4647c478bd9Sstevel@tonic-gate abort(); 4657c478bd9Sstevel@tonic-gate } 4667c478bd9Sstevel@tonic-gate } else { 4677c478bd9Sstevel@tonic-gate r = libscf_read_states(pg, &state, &next_state); 4687c478bd9Sstevel@tonic-gate if (r != 0) { 4697c478bd9Sstevel@tonic-gate do_commit_states = B_TRUE; 4707c478bd9Sstevel@tonic-gate } else { 4717c478bd9Sstevel@tonic-gate if (next_state != RESTARTER_STATE_NONE) { 4727c478bd9Sstevel@tonic-gate /* 4737c478bd9Sstevel@tonic-gate * Force next_state to _NONE since we 4747c478bd9Sstevel@tonic-gate * don't look for method processes. 4757c478bd9Sstevel@tonic-gate */ 4767c478bd9Sstevel@tonic-gate next_state = RESTARTER_STATE_NONE; 4777c478bd9Sstevel@tonic-gate do_commit_states = B_TRUE; 4787c478bd9Sstevel@tonic-gate } else { 4797c478bd9Sstevel@tonic-gate /* 480f6e214c7SGavin Maltby * The reason for transition will depend on 481f6e214c7SGavin Maltby * state. 482f6e214c7SGavin Maltby */ 483f6e214c7SGavin Maltby if (st->st_initial == 0) 484f6e214c7SGavin Maltby reason = restarter_str_startd_restart; 485f6e214c7SGavin Maltby else if (state == RESTARTER_STATE_MAINT) 486f6e214c7SGavin Maltby reason = restarter_str_bad_repo_state; 487f6e214c7SGavin Maltby /* 4887c478bd9Sstevel@tonic-gate * Inform the restarter of our state without 4897c478bd9Sstevel@tonic-gate * changing the STIME in the repository. 4907c478bd9Sstevel@tonic-gate */ 4917c478bd9Sstevel@tonic-gate ps = startd_alloc(sizeof (*ps)); 4927c478bd9Sstevel@tonic-gate inst->ri_i.i_state = ps->ps_state = state; 4937c478bd9Sstevel@tonic-gate inst->ri_i.i_next_state = ps->ps_state_next = 4947c478bd9Sstevel@tonic-gate next_state; 495f6e214c7SGavin Maltby ps->ps_reason = reason; 4967c478bd9Sstevel@tonic-gate 4977c478bd9Sstevel@tonic-gate graph_protocol_send_event(inst->ri_i.i_fmri, 4987c478bd9Sstevel@tonic-gate GRAPH_UPDATE_STATE_CHANGE, ps); 4997c478bd9Sstevel@tonic-gate 5007c478bd9Sstevel@tonic-gate do_commit_states = B_FALSE; 5017c478bd9Sstevel@tonic-gate } 5027c478bd9Sstevel@tonic-gate } 5037c478bd9Sstevel@tonic-gate } 5047c478bd9Sstevel@tonic-gate 5057c478bd9Sstevel@tonic-gate switch (libscf_get_startd_properties(scf_inst, snap, &inst->ri_flags, 5067c478bd9Sstevel@tonic-gate &inst->ri_utmpx_prefix)) { 5077c478bd9Sstevel@tonic-gate case 0: 5087c478bd9Sstevel@tonic-gate break; 5097c478bd9Sstevel@tonic-gate 5107c478bd9Sstevel@tonic-gate case ECONNABORTED: 5117c478bd9Sstevel@tonic-gate libscf_handle_rebind(h); 5127c478bd9Sstevel@tonic-gate goto rep_retry; 5137c478bd9Sstevel@tonic-gate 5147c478bd9Sstevel@tonic-gate case ECANCELED: 5157c478bd9Sstevel@tonic-gate goto deleted; 5167c478bd9Sstevel@tonic-gate 5177c478bd9Sstevel@tonic-gate case ENOENT: 5187c478bd9Sstevel@tonic-gate /* 5197c478bd9Sstevel@tonic-gate * This is odd, because the graph engine should have required 5207c478bd9Sstevel@tonic-gate * the general property group. So we'll just use default 5217c478bd9Sstevel@tonic-gate * flags in anticipation of the graph engine sending us 5227c478bd9Sstevel@tonic-gate * REMOVE_INSTANCE when it finds out that the general property 5237c478bd9Sstevel@tonic-gate * group has been deleted. 5247c478bd9Sstevel@tonic-gate */ 5257c478bd9Sstevel@tonic-gate inst->ri_flags = RINST_CONTRACT; 5267c478bd9Sstevel@tonic-gate break; 5277c478bd9Sstevel@tonic-gate 5287c478bd9Sstevel@tonic-gate default: 5297c478bd9Sstevel@tonic-gate assert(0); 5307c478bd9Sstevel@tonic-gate abort(); 5317c478bd9Sstevel@tonic-gate } 5327c478bd9Sstevel@tonic-gate 5333dd94f79SBryan Cantrill r = libscf_get_template_values(scf_inst, snap, 5343dd94f79SBryan Cantrill &inst->ri_common_name, &inst->ri_C_common_name); 5353dd94f79SBryan Cantrill 5363dd94f79SBryan Cantrill /* 5373dd94f79SBryan Cantrill * Copy our names to smaller buffers to reduce our memory footprint. 5383dd94f79SBryan Cantrill */ 5393dd94f79SBryan Cantrill if (inst->ri_common_name != NULL) { 5403dd94f79SBryan Cantrill char *tmp = safe_strdup(inst->ri_common_name); 5413dd94f79SBryan Cantrill startd_free(inst->ri_common_name, max_scf_value_size); 5423dd94f79SBryan Cantrill inst->ri_common_name = tmp; 5433dd94f79SBryan Cantrill } 5443dd94f79SBryan Cantrill 5453dd94f79SBryan Cantrill if (inst->ri_C_common_name != NULL) { 5463dd94f79SBryan Cantrill char *tmp = safe_strdup(inst->ri_C_common_name); 5473dd94f79SBryan Cantrill startd_free(inst->ri_C_common_name, max_scf_value_size); 5483dd94f79SBryan Cantrill inst->ri_C_common_name = tmp; 5493dd94f79SBryan Cantrill } 5503dd94f79SBryan Cantrill 5513dd94f79SBryan Cantrill switch (r) { 5527c478bd9Sstevel@tonic-gate case 0: 5537c478bd9Sstevel@tonic-gate break; 5547c478bd9Sstevel@tonic-gate 5557c478bd9Sstevel@tonic-gate case ECONNABORTED: 5567c478bd9Sstevel@tonic-gate libscf_handle_rebind(h); 5577c478bd9Sstevel@tonic-gate goto rep_retry; 5587c478bd9Sstevel@tonic-gate 5597c478bd9Sstevel@tonic-gate case ECANCELED: 5607c478bd9Sstevel@tonic-gate goto deleted; 5617c478bd9Sstevel@tonic-gate 5627c478bd9Sstevel@tonic-gate case ECHILD: 5637c478bd9Sstevel@tonic-gate case ENOENT: 5647c478bd9Sstevel@tonic-gate break; 5657c478bd9Sstevel@tonic-gate 5667c478bd9Sstevel@tonic-gate default: 5677c478bd9Sstevel@tonic-gate assert(0); 5687c478bd9Sstevel@tonic-gate abort(); 5697c478bd9Sstevel@tonic-gate } 5707c478bd9Sstevel@tonic-gate 5717c478bd9Sstevel@tonic-gate switch (libscf_read_method_ids(h, scf_inst, inst->ri_i.i_fmri, 5727c478bd9Sstevel@tonic-gate &inst->ri_i.i_primary_ctid, &inst->ri_i.i_transient_ctid, 5737c478bd9Sstevel@tonic-gate &start_pid)) { 5747c478bd9Sstevel@tonic-gate case 0: 5757c478bd9Sstevel@tonic-gate break; 5767c478bd9Sstevel@tonic-gate 5777c478bd9Sstevel@tonic-gate case ECONNABORTED: 5787c478bd9Sstevel@tonic-gate libscf_handle_rebind(h); 5797c478bd9Sstevel@tonic-gate goto rep_retry; 5807c478bd9Sstevel@tonic-gate 5817c478bd9Sstevel@tonic-gate case ECANCELED: 5827c478bd9Sstevel@tonic-gate goto deleted; 5837c478bd9Sstevel@tonic-gate 5847c478bd9Sstevel@tonic-gate default: 5857c478bd9Sstevel@tonic-gate assert(0); 5867c478bd9Sstevel@tonic-gate abort(); 5877c478bd9Sstevel@tonic-gate } 5887c478bd9Sstevel@tonic-gate 5897c478bd9Sstevel@tonic-gate if (inst->ri_i.i_primary_ctid >= 1) { 5907c478bd9Sstevel@tonic-gate contract_hash_store(inst->ri_i.i_primary_ctid, inst->ri_id); 5917c478bd9Sstevel@tonic-gate 5927c478bd9Sstevel@tonic-gate switch (check_contract(inst, B_TRUE, scf_inst)) { 5937c478bd9Sstevel@tonic-gate case 0: 5947c478bd9Sstevel@tonic-gate break; 5957c478bd9Sstevel@tonic-gate 5967c478bd9Sstevel@tonic-gate case ECONNABORTED: 5977c478bd9Sstevel@tonic-gate libscf_handle_rebind(h); 5987c478bd9Sstevel@tonic-gate goto rep_retry; 5997c478bd9Sstevel@tonic-gate 6007c478bd9Sstevel@tonic-gate case ECANCELED: 6017c478bd9Sstevel@tonic-gate goto deleted; 6027c478bd9Sstevel@tonic-gate 6037c478bd9Sstevel@tonic-gate default: 6047c478bd9Sstevel@tonic-gate assert(0); 6057c478bd9Sstevel@tonic-gate abort(); 6067c478bd9Sstevel@tonic-gate } 6077c478bd9Sstevel@tonic-gate } 6087c478bd9Sstevel@tonic-gate 6097c478bd9Sstevel@tonic-gate if (inst->ri_i.i_transient_ctid >= 1) { 6107c478bd9Sstevel@tonic-gate switch (check_contract(inst, B_FALSE, scf_inst)) { 6117c478bd9Sstevel@tonic-gate case 0: 6127c478bd9Sstevel@tonic-gate break; 6137c478bd9Sstevel@tonic-gate 6147c478bd9Sstevel@tonic-gate case ECONNABORTED: 6157c478bd9Sstevel@tonic-gate libscf_handle_rebind(h); 6167c478bd9Sstevel@tonic-gate goto rep_retry; 6177c478bd9Sstevel@tonic-gate 6187c478bd9Sstevel@tonic-gate case ECANCELED: 6197c478bd9Sstevel@tonic-gate goto deleted; 6207c478bd9Sstevel@tonic-gate 6217c478bd9Sstevel@tonic-gate default: 6227c478bd9Sstevel@tonic-gate assert(0); 6237c478bd9Sstevel@tonic-gate abort(); 6247c478bd9Sstevel@tonic-gate } 6257c478bd9Sstevel@tonic-gate } 6267c478bd9Sstevel@tonic-gate 6277c478bd9Sstevel@tonic-gate /* No more failures we live through, so add it to the list. */ 6287c478bd9Sstevel@tonic-gate (void) pthread_mutex_init(&inst->ri_lock, &mutex_attrs); 6297c478bd9Sstevel@tonic-gate (void) pthread_mutex_init(&inst->ri_queue_lock, &mutex_attrs); 6307c478bd9Sstevel@tonic-gate MUTEX_LOCK(&inst->ri_lock); 6317c478bd9Sstevel@tonic-gate MUTEX_LOCK(&inst->ri_queue_lock); 6327c478bd9Sstevel@tonic-gate 6337c478bd9Sstevel@tonic-gate (void) pthread_cond_init(&inst->ri_method_cv, NULL); 6347c478bd9Sstevel@tonic-gate 6357c478bd9Sstevel@tonic-gate uu_list_node_init(inst, &inst->ri_link, restarter_instance_pool); 6367c478bd9Sstevel@tonic-gate uu_list_insert(instance_list.ril_instance_list, inst, idx); 6377c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&instance_list.ril_lock); 6387c478bd9Sstevel@tonic-gate 6397c478bd9Sstevel@tonic-gate if (start_pid != -1 && 6407c478bd9Sstevel@tonic-gate (inst->ri_flags & RINST_STYLE_MASK) == RINST_WAIT) { 6417c478bd9Sstevel@tonic-gate int ret; 6427c478bd9Sstevel@tonic-gate ret = wait_register(start_pid, inst->ri_i.i_fmri, 0, 1); 6437c478bd9Sstevel@tonic-gate if (ret == -1) { 6447c478bd9Sstevel@tonic-gate /* 6457c478bd9Sstevel@tonic-gate * Implication: if we can't reregister the 6467c478bd9Sstevel@tonic-gate * instance, we will start another one. Two 6477c478bd9Sstevel@tonic-gate * instances may or may not result in a resource 6487c478bd9Sstevel@tonic-gate * conflict. 6497c478bd9Sstevel@tonic-gate */ 6507c478bd9Sstevel@tonic-gate log_error(LOG_WARNING, 6517c478bd9Sstevel@tonic-gate "%s: couldn't reregister %ld for wait\n", 6527c478bd9Sstevel@tonic-gate inst->ri_i.i_fmri, start_pid); 6537c478bd9Sstevel@tonic-gate } else if (ret == 1) { 6547c478bd9Sstevel@tonic-gate /* 6557c478bd9Sstevel@tonic-gate * Leading PID has exited. 6567c478bd9Sstevel@tonic-gate */ 6577c478bd9Sstevel@tonic-gate (void) stop_instance(h, inst, RSTOP_EXIT); 6587c478bd9Sstevel@tonic-gate } 6597c478bd9Sstevel@tonic-gate } 6607c478bd9Sstevel@tonic-gate 6617c478bd9Sstevel@tonic-gate 6627c478bd9Sstevel@tonic-gate scf_pg_destroy(pg); 6637c478bd9Sstevel@tonic-gate 6647c478bd9Sstevel@tonic-gate if (do_commit_states) 6657c478bd9Sstevel@tonic-gate (void) restarter_instance_update_states(h, inst, state, 666f6e214c7SGavin Maltby next_state, RERR_NONE, reason); 6677c478bd9Sstevel@tonic-gate 6687c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, "%s is a %s-style service\n", name, 6697c478bd9Sstevel@tonic-gate service_style(inst->ri_flags)); 6707c478bd9Sstevel@tonic-gate 6717c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&inst->ri_queue_lock); 6727c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&inst->ri_lock); 6737c478bd9Sstevel@tonic-gate 6747c478bd9Sstevel@tonic-gate startd_free(svc_name, max_scf_name_size); 6757c478bd9Sstevel@tonic-gate startd_free(inst_name, max_scf_name_size); 6767c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap); 6777c478bd9Sstevel@tonic-gate scf_instance_destroy(scf_inst); 6787c478bd9Sstevel@tonic-gate scf_service_destroy(scf_svc); 6797c478bd9Sstevel@tonic-gate 6807c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, "%s: inserted instance into restarter list\n", 6817c478bd9Sstevel@tonic-gate name); 6827c478bd9Sstevel@tonic-gate 6837c478bd9Sstevel@tonic-gate return (0); 68492175b8eSrm88369 68592175b8eSrm88369 deleted: 68692175b8eSrm88369 MUTEX_UNLOCK(&instance_list.ril_lock); 68792175b8eSrm88369 startd_free(inst_name, max_scf_name_size); 68892175b8eSrm88369 startd_free(svc_name, max_scf_name_size); 68992175b8eSrm88369 if (snap != NULL) 69092175b8eSrm88369 scf_snapshot_destroy(snap); 69192175b8eSrm88369 scf_pg_destroy(pg); 69292175b8eSrm88369 scf_instance_destroy(scf_inst); 69392175b8eSrm88369 scf_service_destroy(scf_svc); 69492175b8eSrm88369 startd_free((void *)inst->ri_i.i_fmri, strlen(inst->ri_i.i_fmri) + 1); 69592175b8eSrm88369 uu_list_destroy(inst->ri_queue); 69692175b8eSrm88369 if (inst->ri_logstem != NULL) 69792175b8eSrm88369 startd_free(inst->ri_logstem, PATH_MAX); 69892175b8eSrm88369 if (inst->ri_common_name != NULL) 699*c8faf4ecSJerry Jelinek free(inst->ri_common_name); 70092175b8eSrm88369 if (inst->ri_C_common_name != NULL) 701*c8faf4ecSJerry Jelinek free(inst->ri_C_common_name); 70292175b8eSrm88369 startd_free(inst->ri_utmpx_prefix, max_scf_value_size); 70392175b8eSrm88369 startd_free(inst, sizeof (restarter_inst_t)); 70492175b8eSrm88369 return (ENOENT); 7057c478bd9Sstevel@tonic-gate } 7067c478bd9Sstevel@tonic-gate 7077c478bd9Sstevel@tonic-gate static void 7087c478bd9Sstevel@tonic-gate restarter_delete_inst(restarter_inst_t *ri) 7097c478bd9Sstevel@tonic-gate { 7107c478bd9Sstevel@tonic-gate int id; 7117c478bd9Sstevel@tonic-gate restarter_inst_t *rip; 7127c478bd9Sstevel@tonic-gate void *cookie = NULL; 7137c478bd9Sstevel@tonic-gate restarter_instance_qentry_t *e; 7147c478bd9Sstevel@tonic-gate 71553f3aea0SRoger A. Faulkner assert(MUTEX_HELD(&ri->ri_lock)); 7167c478bd9Sstevel@tonic-gate 7177c478bd9Sstevel@tonic-gate /* 7187c478bd9Sstevel@tonic-gate * Must drop the instance lock so we can pick up the instance_list 7197c478bd9Sstevel@tonic-gate * lock & remove the instance. 7207c478bd9Sstevel@tonic-gate */ 7217c478bd9Sstevel@tonic-gate id = ri->ri_id; 7227c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&ri->ri_lock); 7237c478bd9Sstevel@tonic-gate 7247c478bd9Sstevel@tonic-gate MUTEX_LOCK(&instance_list.ril_lock); 7257c478bd9Sstevel@tonic-gate 7267c478bd9Sstevel@tonic-gate rip = uu_list_find(instance_list.ril_instance_list, &id, NULL, NULL); 7277c478bd9Sstevel@tonic-gate if (rip == NULL) { 7287c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&instance_list.ril_lock); 7297c478bd9Sstevel@tonic-gate return; 7307c478bd9Sstevel@tonic-gate } 7317c478bd9Sstevel@tonic-gate 7327c478bd9Sstevel@tonic-gate assert(ri == rip); 7337c478bd9Sstevel@tonic-gate 7347c478bd9Sstevel@tonic-gate uu_list_remove(instance_list.ril_instance_list, ri); 7357c478bd9Sstevel@tonic-gate 7367c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, "%s: deleted instance from restarter list\n", 7377c478bd9Sstevel@tonic-gate ri->ri_i.i_fmri); 7387c478bd9Sstevel@tonic-gate 7397c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&instance_list.ril_lock); 7407c478bd9Sstevel@tonic-gate 7417c478bd9Sstevel@tonic-gate /* 7427c478bd9Sstevel@tonic-gate * We can lock the instance without holding the instance_list lock 7437c478bd9Sstevel@tonic-gate * since we removed the instance from the list. 7447c478bd9Sstevel@tonic-gate */ 7457c478bd9Sstevel@tonic-gate MUTEX_LOCK(&ri->ri_lock); 7467c478bd9Sstevel@tonic-gate MUTEX_LOCK(&ri->ri_queue_lock); 7477c478bd9Sstevel@tonic-gate 7487c478bd9Sstevel@tonic-gate if (ri->ri_i.i_primary_ctid >= 1) 7497c478bd9Sstevel@tonic-gate contract_hash_remove(ri->ri_i.i_primary_ctid); 7507c478bd9Sstevel@tonic-gate 7517c478bd9Sstevel@tonic-gate while (ri->ri_method_thread != 0 || ri->ri_method_waiters > 0) 7527c478bd9Sstevel@tonic-gate (void) pthread_cond_wait(&ri->ri_method_cv, &ri->ri_lock); 7537c478bd9Sstevel@tonic-gate 7547c478bd9Sstevel@tonic-gate while ((e = uu_list_teardown(ri->ri_queue, &cookie)) != NULL) 7557c478bd9Sstevel@tonic-gate startd_free(e, sizeof (*e)); 7567c478bd9Sstevel@tonic-gate uu_list_destroy(ri->ri_queue); 7577c478bd9Sstevel@tonic-gate 7587c478bd9Sstevel@tonic-gate startd_free((void *)ri->ri_i.i_fmri, strlen(ri->ri_i.i_fmri) + 1); 7591855af6bSlianep startd_free(ri->ri_logstem, PATH_MAX); 7603ba60fe0Srm88369 if (ri->ri_common_name != NULL) 761*c8faf4ecSJerry Jelinek free(ri->ri_common_name); 7623ba60fe0Srm88369 if (ri->ri_C_common_name != NULL) 763*c8faf4ecSJerry Jelinek free(ri->ri_C_common_name); 7647c478bd9Sstevel@tonic-gate startd_free(ri->ri_utmpx_prefix, max_scf_value_size); 7657c478bd9Sstevel@tonic-gate (void) pthread_mutex_destroy(&ri->ri_lock); 7667c478bd9Sstevel@tonic-gate (void) pthread_mutex_destroy(&ri->ri_queue_lock); 7677c478bd9Sstevel@tonic-gate startd_free(ri, sizeof (restarter_inst_t)); 7687c478bd9Sstevel@tonic-gate } 7697c478bd9Sstevel@tonic-gate 7707c478bd9Sstevel@tonic-gate /* 7717c478bd9Sstevel@tonic-gate * instance_is_wait_style() 7727c478bd9Sstevel@tonic-gate * 7737c478bd9Sstevel@tonic-gate * Returns 1 if the given instance is a "wait-style" service instance. 7747c478bd9Sstevel@tonic-gate */ 7757c478bd9Sstevel@tonic-gate int 7767c478bd9Sstevel@tonic-gate instance_is_wait_style(restarter_inst_t *inst) 7777c478bd9Sstevel@tonic-gate { 77853f3aea0SRoger A. Faulkner assert(MUTEX_HELD(&inst->ri_lock)); 7797c478bd9Sstevel@tonic-gate return ((inst->ri_flags & RINST_STYLE_MASK) == RINST_WAIT); 7807c478bd9Sstevel@tonic-gate } 7817c478bd9Sstevel@tonic-gate 7827c478bd9Sstevel@tonic-gate /* 7837c478bd9Sstevel@tonic-gate * instance_is_transient_style() 7847c478bd9Sstevel@tonic-gate * 7857c478bd9Sstevel@tonic-gate * Returns 1 if the given instance is a transient service instance. 7867c478bd9Sstevel@tonic-gate */ 7877c478bd9Sstevel@tonic-gate int 7887c478bd9Sstevel@tonic-gate instance_is_transient_style(restarter_inst_t *inst) 7897c478bd9Sstevel@tonic-gate { 79053f3aea0SRoger A. Faulkner assert(MUTEX_HELD(&inst->ri_lock)); 7917c478bd9Sstevel@tonic-gate return ((inst->ri_flags & RINST_STYLE_MASK) == RINST_TRANSIENT); 7927c478bd9Sstevel@tonic-gate } 7937c478bd9Sstevel@tonic-gate 7947c478bd9Sstevel@tonic-gate /* 7957c478bd9Sstevel@tonic-gate * instance_in_transition() 7967c478bd9Sstevel@tonic-gate * Returns 1 if instance is in transition, 0 if not 7977c478bd9Sstevel@tonic-gate */ 7987c478bd9Sstevel@tonic-gate int 7997c478bd9Sstevel@tonic-gate instance_in_transition(restarter_inst_t *inst) 8007c478bd9Sstevel@tonic-gate { 80153f3aea0SRoger A. Faulkner assert(MUTEX_HELD(&inst->ri_lock)); 8027c478bd9Sstevel@tonic-gate if (inst->ri_i.i_next_state == RESTARTER_STATE_NONE) 8037c478bd9Sstevel@tonic-gate return (0); 8047c478bd9Sstevel@tonic-gate return (1); 8057c478bd9Sstevel@tonic-gate } 8067c478bd9Sstevel@tonic-gate 8077c478bd9Sstevel@tonic-gate /* 80821d7f835Sgm149974 * returns 1 if instance is already started, 0 if not 80921d7f835Sgm149974 */ 81021d7f835Sgm149974 static int 81121d7f835Sgm149974 instance_started(restarter_inst_t *inst) 81221d7f835Sgm149974 { 81321d7f835Sgm149974 int ret; 81421d7f835Sgm149974 81553f3aea0SRoger A. Faulkner assert(MUTEX_HELD(&inst->ri_lock)); 81621d7f835Sgm149974 81721d7f835Sgm149974 if (inst->ri_i.i_state == RESTARTER_STATE_ONLINE || 81821d7f835Sgm149974 inst->ri_i.i_state == RESTARTER_STATE_DEGRADED) 81921d7f835Sgm149974 ret = 1; 82021d7f835Sgm149974 else 82121d7f835Sgm149974 ret = 0; 82221d7f835Sgm149974 82321d7f835Sgm149974 return (ret); 82421d7f835Sgm149974 } 82521d7f835Sgm149974 82621d7f835Sgm149974 /* 8277c478bd9Sstevel@tonic-gate * Returns 8287c478bd9Sstevel@tonic-gate * 0 - success 8297c478bd9Sstevel@tonic-gate * ECONNRESET - success, but h was rebound 8307c478bd9Sstevel@tonic-gate */ 8317c478bd9Sstevel@tonic-gate int 8327c478bd9Sstevel@tonic-gate restarter_instance_update_states(scf_handle_t *h, restarter_inst_t *ri, 8337c478bd9Sstevel@tonic-gate restarter_instance_state_t new_state, 834f6e214c7SGavin Maltby restarter_instance_state_t new_state_next, restarter_error_t err, 835f6e214c7SGavin Maltby restarter_str_t reason) 8367c478bd9Sstevel@tonic-gate { 8377c478bd9Sstevel@tonic-gate protocol_states_t *states; 8387c478bd9Sstevel@tonic-gate int e; 8397c478bd9Sstevel@tonic-gate uint_t retry_count = 0, msecs = ALLOC_DELAY; 8407c478bd9Sstevel@tonic-gate boolean_t rebound = B_FALSE; 84121d7f835Sgm149974 int prev_state_online; 84221d7f835Sgm149974 int state_online; 8437c478bd9Sstevel@tonic-gate 84453f3aea0SRoger A. Faulkner assert(MUTEX_HELD(&ri->ri_lock)); 8457c478bd9Sstevel@tonic-gate 84621d7f835Sgm149974 prev_state_online = instance_started(ri); 84721d7f835Sgm149974 8487c478bd9Sstevel@tonic-gate retry: 8497c478bd9Sstevel@tonic-gate e = _restarter_commit_states(h, &ri->ri_i, new_state, new_state_next, 850f6e214c7SGavin Maltby restarter_get_str_short(reason)); 8517c478bd9Sstevel@tonic-gate switch (e) { 8527c478bd9Sstevel@tonic-gate case 0: 8537c478bd9Sstevel@tonic-gate break; 8547c478bd9Sstevel@tonic-gate 8557c478bd9Sstevel@tonic-gate case ENOMEM: 8567c478bd9Sstevel@tonic-gate ++retry_count; 8577c478bd9Sstevel@tonic-gate if (retry_count < ALLOC_RETRY) { 8587c478bd9Sstevel@tonic-gate (void) poll(NULL, 0, msecs); 8597c478bd9Sstevel@tonic-gate msecs *= ALLOC_DELAY_MULT; 8607c478bd9Sstevel@tonic-gate goto retry; 8617c478bd9Sstevel@tonic-gate } 8627c478bd9Sstevel@tonic-gate 8637c478bd9Sstevel@tonic-gate /* Like startd_alloc(). */ 8647c478bd9Sstevel@tonic-gate uu_die("Insufficient memory.\n"); 8657c478bd9Sstevel@tonic-gate /* NOTREACHED */ 8667c478bd9Sstevel@tonic-gate 8677c478bd9Sstevel@tonic-gate case ECONNABORTED: 8687c478bd9Sstevel@tonic-gate libscf_handle_rebind(h); 8697c478bd9Sstevel@tonic-gate rebound = B_TRUE; 8707c478bd9Sstevel@tonic-gate goto retry; 8717c478bd9Sstevel@tonic-gate 8727c478bd9Sstevel@tonic-gate case EPERM: 8737c478bd9Sstevel@tonic-gate case EACCES: 8747c478bd9Sstevel@tonic-gate case EROFS: 8757c478bd9Sstevel@tonic-gate log_error(LOG_NOTICE, "Could not commit state change for %s " 8767c478bd9Sstevel@tonic-gate "to repository: %s.\n", ri->ri_i.i_fmri, strerror(e)); 8777c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 8787c478bd9Sstevel@tonic-gate 8797c478bd9Sstevel@tonic-gate case ENOENT: 8807c478bd9Sstevel@tonic-gate ri->ri_i.i_state = new_state; 8817c478bd9Sstevel@tonic-gate ri->ri_i.i_next_state = new_state_next; 8827c478bd9Sstevel@tonic-gate break; 8837c478bd9Sstevel@tonic-gate 8847c478bd9Sstevel@tonic-gate case EINVAL: 8857c478bd9Sstevel@tonic-gate default: 8867c478bd9Sstevel@tonic-gate bad_error("_restarter_commit_states", e); 8877c478bd9Sstevel@tonic-gate } 8887c478bd9Sstevel@tonic-gate 8897c478bd9Sstevel@tonic-gate states = startd_alloc(sizeof (protocol_states_t)); 8907c478bd9Sstevel@tonic-gate states->ps_state = new_state; 8917c478bd9Sstevel@tonic-gate states->ps_state_next = new_state_next; 8927c478bd9Sstevel@tonic-gate states->ps_err = err; 893f6e214c7SGavin Maltby states->ps_reason = reason; 8947c478bd9Sstevel@tonic-gate graph_protocol_send_event(ri->ri_i.i_fmri, GRAPH_UPDATE_STATE_CHANGE, 8957c478bd9Sstevel@tonic-gate (void *)states); 8967c478bd9Sstevel@tonic-gate 89721d7f835Sgm149974 state_online = instance_started(ri); 89821d7f835Sgm149974 89921d7f835Sgm149974 if (prev_state_online && !state_online) 90021d7f835Sgm149974 ri->ri_post_offline_hook(); 90121d7f835Sgm149974 else if (!prev_state_online && state_online) 9027c478bd9Sstevel@tonic-gate ri->ri_post_online_hook(); 9037c478bd9Sstevel@tonic-gate 9047c478bd9Sstevel@tonic-gate return (rebound ? ECONNRESET : 0); 9057c478bd9Sstevel@tonic-gate } 9067c478bd9Sstevel@tonic-gate 9077c478bd9Sstevel@tonic-gate void 9087c478bd9Sstevel@tonic-gate restarter_mark_pending_snapshot(const char *fmri, uint_t flag) 9097c478bd9Sstevel@tonic-gate { 9107c478bd9Sstevel@tonic-gate restarter_inst_t *inst; 9117c478bd9Sstevel@tonic-gate 9127c478bd9Sstevel@tonic-gate assert(flag == RINST_RETAKE_RUNNING || flag == RINST_RETAKE_START); 9137c478bd9Sstevel@tonic-gate 9147c478bd9Sstevel@tonic-gate inst = inst_lookup_by_name(fmri); 9157c478bd9Sstevel@tonic-gate if (inst == NULL) 9167c478bd9Sstevel@tonic-gate return; 9177c478bd9Sstevel@tonic-gate 9187c478bd9Sstevel@tonic-gate inst->ri_flags |= flag; 9197c478bd9Sstevel@tonic-gate 9207c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&inst->ri_lock); 9217c478bd9Sstevel@tonic-gate } 9227c478bd9Sstevel@tonic-gate 9237c478bd9Sstevel@tonic-gate static void 9247c478bd9Sstevel@tonic-gate restarter_take_pending_snapshots(scf_handle_t *h) 9257c478bd9Sstevel@tonic-gate { 9267c478bd9Sstevel@tonic-gate restarter_inst_t *inst; 9277c478bd9Sstevel@tonic-gate int r; 9287c478bd9Sstevel@tonic-gate 9297c478bd9Sstevel@tonic-gate MUTEX_LOCK(&instance_list.ril_lock); 9307c478bd9Sstevel@tonic-gate 9317c478bd9Sstevel@tonic-gate for (inst = uu_list_first(instance_list.ril_instance_list); 9327c478bd9Sstevel@tonic-gate inst != NULL; 9337c478bd9Sstevel@tonic-gate inst = uu_list_next(instance_list.ril_instance_list, inst)) { 9347c478bd9Sstevel@tonic-gate const char *fmri; 9357c478bd9Sstevel@tonic-gate scf_instance_t *sinst = NULL; 9367c478bd9Sstevel@tonic-gate 9377c478bd9Sstevel@tonic-gate MUTEX_LOCK(&inst->ri_lock); 9387c478bd9Sstevel@tonic-gate 9397c478bd9Sstevel@tonic-gate /* 9407c478bd9Sstevel@tonic-gate * This is where we'd check inst->ri_method_thread and if it 9417c478bd9Sstevel@tonic-gate * were nonzero we'd wait in anticipation of another thread 9427c478bd9Sstevel@tonic-gate * executing a method for inst. Doing so with the instance_list 9437c478bd9Sstevel@tonic-gate * locked, though, leads to deadlock. Since taking a snapshot 9447c478bd9Sstevel@tonic-gate * during that window won't hurt anything, we'll just continue. 9457c478bd9Sstevel@tonic-gate */ 9467c478bd9Sstevel@tonic-gate 9477c478bd9Sstevel@tonic-gate fmri = inst->ri_i.i_fmri; 9487c478bd9Sstevel@tonic-gate 9497c478bd9Sstevel@tonic-gate if (inst->ri_flags & RINST_RETAKE_RUNNING) { 9507c478bd9Sstevel@tonic-gate scf_snapshot_t *rsnap; 9517c478bd9Sstevel@tonic-gate 9527c478bd9Sstevel@tonic-gate (void) libscf_fmri_get_instance(h, fmri, &sinst); 9537c478bd9Sstevel@tonic-gate 9547c478bd9Sstevel@tonic-gate rsnap = libscf_get_or_make_running_snapshot(sinst, 9557c478bd9Sstevel@tonic-gate fmri, B_FALSE); 9567c478bd9Sstevel@tonic-gate 9577c478bd9Sstevel@tonic-gate scf_instance_destroy(sinst); 9587c478bd9Sstevel@tonic-gate 9597c478bd9Sstevel@tonic-gate if (rsnap != NULL) 9607c478bd9Sstevel@tonic-gate inst->ri_flags &= ~RINST_RETAKE_RUNNING; 9617c478bd9Sstevel@tonic-gate 9627c478bd9Sstevel@tonic-gate scf_snapshot_destroy(rsnap); 9637c478bd9Sstevel@tonic-gate } 9647c478bd9Sstevel@tonic-gate 9657c478bd9Sstevel@tonic-gate if (inst->ri_flags & RINST_RETAKE_START) { 9667c478bd9Sstevel@tonic-gate switch (r = libscf_snapshots_poststart(h, fmri, 9677c478bd9Sstevel@tonic-gate B_FALSE)) { 9687c478bd9Sstevel@tonic-gate case 0: 9697c478bd9Sstevel@tonic-gate case ENOENT: 9707c478bd9Sstevel@tonic-gate inst->ri_flags &= ~RINST_RETAKE_START; 9717c478bd9Sstevel@tonic-gate break; 9727c478bd9Sstevel@tonic-gate 9737c478bd9Sstevel@tonic-gate case ECONNABORTED: 9747c478bd9Sstevel@tonic-gate break; 9757c478bd9Sstevel@tonic-gate 9767c478bd9Sstevel@tonic-gate case EACCES: 9777c478bd9Sstevel@tonic-gate default: 9787c478bd9Sstevel@tonic-gate bad_error("libscf_snapshots_poststart", r); 9797c478bd9Sstevel@tonic-gate } 9807c478bd9Sstevel@tonic-gate } 9817c478bd9Sstevel@tonic-gate 9827c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&inst->ri_lock); 9837c478bd9Sstevel@tonic-gate } 9847c478bd9Sstevel@tonic-gate 9857c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&instance_list.ril_lock); 9867c478bd9Sstevel@tonic-gate } 9877c478bd9Sstevel@tonic-gate 9887c478bd9Sstevel@tonic-gate /* ARGSUSED */ 9897c478bd9Sstevel@tonic-gate void * 9907c478bd9Sstevel@tonic-gate restarter_post_fsminimal_thread(void *unused) 9917c478bd9Sstevel@tonic-gate { 9927c478bd9Sstevel@tonic-gate scf_handle_t *h; 9937c478bd9Sstevel@tonic-gate int r; 9947c478bd9Sstevel@tonic-gate 9957c478bd9Sstevel@tonic-gate h = libscf_handle_create_bound_loop(); 9967c478bd9Sstevel@tonic-gate 9977c478bd9Sstevel@tonic-gate for (;;) { 9987c478bd9Sstevel@tonic-gate r = libscf_create_self(h); 9997c478bd9Sstevel@tonic-gate if (r == 0) 10007c478bd9Sstevel@tonic-gate break; 10017c478bd9Sstevel@tonic-gate 10027c478bd9Sstevel@tonic-gate assert(r == ECONNABORTED); 10037c478bd9Sstevel@tonic-gate libscf_handle_rebind(h); 10047c478bd9Sstevel@tonic-gate } 10057c478bd9Sstevel@tonic-gate 10067c478bd9Sstevel@tonic-gate restarter_take_pending_snapshots(h); 10077c478bd9Sstevel@tonic-gate 10087c478bd9Sstevel@tonic-gate (void) scf_handle_unbind(h); 10097c478bd9Sstevel@tonic-gate scf_handle_destroy(h); 10107c478bd9Sstevel@tonic-gate 10117c478bd9Sstevel@tonic-gate return (NULL); 10127c478bd9Sstevel@tonic-gate } 10137c478bd9Sstevel@tonic-gate 10147c478bd9Sstevel@tonic-gate /* 10157c478bd9Sstevel@tonic-gate * int stop_instance() 10167c478bd9Sstevel@tonic-gate * 10177c478bd9Sstevel@tonic-gate * Stop the instance identified by the instance given as the second argument, 10187c478bd9Sstevel@tonic-gate * for the cause stated. 10197c478bd9Sstevel@tonic-gate * 10207c478bd9Sstevel@tonic-gate * Returns 10217c478bd9Sstevel@tonic-gate * 0 - success 10227c478bd9Sstevel@tonic-gate * -1 - inst is in transition 10237c478bd9Sstevel@tonic-gate */ 10247c478bd9Sstevel@tonic-gate static int 10257c478bd9Sstevel@tonic-gate stop_instance(scf_handle_t *local_handle, restarter_inst_t *inst, 10267c478bd9Sstevel@tonic-gate stop_cause_t cause) 10277c478bd9Sstevel@tonic-gate { 10287c478bd9Sstevel@tonic-gate fork_info_t *info; 10297c478bd9Sstevel@tonic-gate const char *cp; 10307c478bd9Sstevel@tonic-gate int err; 10317c478bd9Sstevel@tonic-gate restarter_error_t re; 1032f6e214c7SGavin Maltby restarter_str_t reason; 10337c478bd9Sstevel@tonic-gate 103453f3aea0SRoger A. Faulkner assert(MUTEX_HELD(&inst->ri_lock)); 10357c478bd9Sstevel@tonic-gate assert(inst->ri_method_thread == 0); 10367c478bd9Sstevel@tonic-gate 10377c478bd9Sstevel@tonic-gate switch (cause) { 10387c478bd9Sstevel@tonic-gate case RSTOP_EXIT: 10397c478bd9Sstevel@tonic-gate re = RERR_RESTART; 1040f6e214c7SGavin Maltby reason = restarter_str_ct_ev_exit; 10417c478bd9Sstevel@tonic-gate cp = "all processes in service exited"; 10427c478bd9Sstevel@tonic-gate break; 10437c478bd9Sstevel@tonic-gate case RSTOP_CORE: 10447c478bd9Sstevel@tonic-gate re = RERR_FAULT; 1045f6e214c7SGavin Maltby reason = restarter_str_ct_ev_core; 10467c478bd9Sstevel@tonic-gate cp = "process dumped core"; 10477c478bd9Sstevel@tonic-gate break; 10487c478bd9Sstevel@tonic-gate case RSTOP_SIGNAL: 10497c478bd9Sstevel@tonic-gate re = RERR_FAULT; 1050f6e214c7SGavin Maltby reason = restarter_str_ct_ev_signal; 10517c478bd9Sstevel@tonic-gate cp = "process received fatal signal from outside the service"; 10527c478bd9Sstevel@tonic-gate break; 10537c478bd9Sstevel@tonic-gate case RSTOP_HWERR: 10547c478bd9Sstevel@tonic-gate re = RERR_FAULT; 1055f6e214c7SGavin Maltby reason = restarter_str_ct_ev_hwerr; 10567c478bd9Sstevel@tonic-gate cp = "process killed due to uncorrectable hardware error"; 10577c478bd9Sstevel@tonic-gate break; 10587c478bd9Sstevel@tonic-gate case RSTOP_DEPENDENCY: 10597c478bd9Sstevel@tonic-gate re = RERR_RESTART; 1060f6e214c7SGavin Maltby reason = restarter_str_dependency_activity; 10617c478bd9Sstevel@tonic-gate cp = "dependency activity requires stop"; 10627c478bd9Sstevel@tonic-gate break; 10637c478bd9Sstevel@tonic-gate case RSTOP_DISABLE: 10647c478bd9Sstevel@tonic-gate re = RERR_RESTART; 1065f6e214c7SGavin Maltby reason = restarter_str_disable_request; 10667c478bd9Sstevel@tonic-gate cp = "service disabled"; 10677c478bd9Sstevel@tonic-gate break; 10687c478bd9Sstevel@tonic-gate case RSTOP_RESTART: 10697c478bd9Sstevel@tonic-gate re = RERR_RESTART; 1070f6e214c7SGavin Maltby reason = restarter_str_restart_request; 10717c478bd9Sstevel@tonic-gate cp = "service restarting"; 10727c478bd9Sstevel@tonic-gate break; 10737c478bd9Sstevel@tonic-gate default: 10747c478bd9Sstevel@tonic-gate #ifndef NDEBUG 10757c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "Unknown cause %d at %s:%d.\n", 10767c478bd9Sstevel@tonic-gate cause, __FILE__, __LINE__); 10777c478bd9Sstevel@tonic-gate #endif 10787c478bd9Sstevel@tonic-gate abort(); 10797c478bd9Sstevel@tonic-gate } 10807c478bd9Sstevel@tonic-gate 10817c478bd9Sstevel@tonic-gate /* Services in the disabled and maintenance state are ignored */ 10827c478bd9Sstevel@tonic-gate if (inst->ri_i.i_state == RESTARTER_STATE_MAINT || 10837c478bd9Sstevel@tonic-gate inst->ri_i.i_state == RESTARTER_STATE_DISABLED) { 10847c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, 10857c478bd9Sstevel@tonic-gate "%s: stop_instance -> is maint/disabled\n", 10867c478bd9Sstevel@tonic-gate inst->ri_i.i_fmri); 10877c478bd9Sstevel@tonic-gate return (0); 10887c478bd9Sstevel@tonic-gate } 10897c478bd9Sstevel@tonic-gate 10907c478bd9Sstevel@tonic-gate /* Already stopped instances are left alone */ 10917c478bd9Sstevel@tonic-gate if (instance_started(inst) == 0) { 10927c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, "Restarter: %s is already stopped.\n", 10937c478bd9Sstevel@tonic-gate inst->ri_i.i_fmri); 10947c478bd9Sstevel@tonic-gate return (0); 10957c478bd9Sstevel@tonic-gate } 10967c478bd9Sstevel@tonic-gate 10977c478bd9Sstevel@tonic-gate if (instance_in_transition(inst)) { 10987c478bd9Sstevel@tonic-gate /* requeue event by returning -1 */ 10997c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, 11007c478bd9Sstevel@tonic-gate "Restarter: Not stopping %s, in transition.\n", 11017c478bd9Sstevel@tonic-gate inst->ri_i.i_fmri); 11027c478bd9Sstevel@tonic-gate return (-1); 11037c478bd9Sstevel@tonic-gate } 11047c478bd9Sstevel@tonic-gate 11057c478bd9Sstevel@tonic-gate log_instance(inst, B_TRUE, "Stopping because %s.", cp); 11067c478bd9Sstevel@tonic-gate 11077c478bd9Sstevel@tonic-gate log_framework(re == RERR_FAULT ? LOG_INFO : LOG_DEBUG, 11087c478bd9Sstevel@tonic-gate "%s: Instance stopping because %s.\n", inst->ri_i.i_fmri, cp); 11097c478bd9Sstevel@tonic-gate 11107c478bd9Sstevel@tonic-gate if (instance_is_wait_style(inst) && cause == RSTOP_EXIT) { 11117c478bd9Sstevel@tonic-gate /* 11127c478bd9Sstevel@tonic-gate * No need to stop instance, as child has exited; remove 11137c478bd9Sstevel@tonic-gate * contract and move the instance to the offline state. 11147c478bd9Sstevel@tonic-gate */ 11157c478bd9Sstevel@tonic-gate switch (err = restarter_instance_update_states(local_handle, 11167c478bd9Sstevel@tonic-gate inst, inst->ri_i.i_state, RESTARTER_STATE_OFFLINE, re, 1117f6e214c7SGavin Maltby reason)) { 11187c478bd9Sstevel@tonic-gate case 0: 11197c478bd9Sstevel@tonic-gate case ECONNRESET: 11207c478bd9Sstevel@tonic-gate break; 11217c478bd9Sstevel@tonic-gate 11227c478bd9Sstevel@tonic-gate default: 11237c478bd9Sstevel@tonic-gate bad_error("restarter_instance_update_states", err); 11247c478bd9Sstevel@tonic-gate } 11257c478bd9Sstevel@tonic-gate 11267c478bd9Sstevel@tonic-gate (void) update_fault_count(inst, FAULT_COUNT_RESET); 1127c238c833SSean Wilcox reset_start_times(inst); 11287c478bd9Sstevel@tonic-gate 11297c478bd9Sstevel@tonic-gate if (inst->ri_i.i_primary_ctid != 0) { 11307c478bd9Sstevel@tonic-gate inst->ri_m_inst = 11317c478bd9Sstevel@tonic-gate safe_scf_instance_create(local_handle); 11327c478bd9Sstevel@tonic-gate inst->ri_mi_deleted = B_FALSE; 11337c478bd9Sstevel@tonic-gate 11347c478bd9Sstevel@tonic-gate libscf_reget_instance(inst); 11357c478bd9Sstevel@tonic-gate method_remove_contract(inst, B_TRUE, B_TRUE); 11367c478bd9Sstevel@tonic-gate 11377c478bd9Sstevel@tonic-gate scf_instance_destroy(inst->ri_m_inst); 11387c478bd9Sstevel@tonic-gate inst->ri_m_inst = NULL; 11397c478bd9Sstevel@tonic-gate } 11407c478bd9Sstevel@tonic-gate 11417c478bd9Sstevel@tonic-gate switch (err = restarter_instance_update_states(local_handle, 11427c478bd9Sstevel@tonic-gate inst, inst->ri_i.i_next_state, RESTARTER_STATE_NONE, re, 1143f6e214c7SGavin Maltby reason)) { 11447c478bd9Sstevel@tonic-gate case 0: 11457c478bd9Sstevel@tonic-gate case ECONNRESET: 11467c478bd9Sstevel@tonic-gate break; 11477c478bd9Sstevel@tonic-gate 11487c478bd9Sstevel@tonic-gate default: 11497c478bd9Sstevel@tonic-gate bad_error("restarter_instance_update_states", err); 11507c478bd9Sstevel@tonic-gate } 11517c478bd9Sstevel@tonic-gate 11527c478bd9Sstevel@tonic-gate return (0); 115363c7f71bSrm88369 } else if (instance_is_wait_style(inst) && re == RERR_RESTART) { 115463c7f71bSrm88369 /* 115563c7f71bSrm88369 * Stopping a wait service through means other than the pid 115663c7f71bSrm88369 * exiting should keep wait_thread() from restarting the 115763c7f71bSrm88369 * service, by removing it from the wait list. 115863c7f71bSrm88369 * We cannot remove it right now otherwise the process will 115963c7f71bSrm88369 * end up <defunct> so mark it to be ignored. 116063c7f71bSrm88369 */ 116163c7f71bSrm88369 wait_ignore_by_fmri(inst->ri_i.i_fmri); 11627c478bd9Sstevel@tonic-gate } 11637c478bd9Sstevel@tonic-gate 11647c478bd9Sstevel@tonic-gate switch (err = restarter_instance_update_states(local_handle, inst, 11657c478bd9Sstevel@tonic-gate inst->ri_i.i_state, inst->ri_i.i_enabled ? RESTARTER_STATE_OFFLINE : 1166f6e214c7SGavin Maltby RESTARTER_STATE_DISABLED, RERR_NONE, reason)) { 11677c478bd9Sstevel@tonic-gate case 0: 11687c478bd9Sstevel@tonic-gate case ECONNRESET: 11697c478bd9Sstevel@tonic-gate break; 11707c478bd9Sstevel@tonic-gate 11717c478bd9Sstevel@tonic-gate default: 11727c478bd9Sstevel@tonic-gate bad_error("restarter_instance_update_states", err); 11737c478bd9Sstevel@tonic-gate } 11747c478bd9Sstevel@tonic-gate 11757c478bd9Sstevel@tonic-gate info = startd_zalloc(sizeof (fork_info_t)); 11767c478bd9Sstevel@tonic-gate 11777c478bd9Sstevel@tonic-gate info->sf_id = inst->ri_id; 11787c478bd9Sstevel@tonic-gate info->sf_method_type = METHOD_STOP; 11797c478bd9Sstevel@tonic-gate info->sf_event_type = re; 1180f6e214c7SGavin Maltby info->sf_reason = reason; 11817c478bd9Sstevel@tonic-gate inst->ri_method_thread = startd_thread_create(method_thread, info); 11827c478bd9Sstevel@tonic-gate 11837c478bd9Sstevel@tonic-gate return (0); 11847c478bd9Sstevel@tonic-gate } 11857c478bd9Sstevel@tonic-gate 11867c478bd9Sstevel@tonic-gate /* 11877c478bd9Sstevel@tonic-gate * Returns 11887c478bd9Sstevel@tonic-gate * ENOENT - fmri is not in instance_list 11897c478bd9Sstevel@tonic-gate * 0 - success 11907c478bd9Sstevel@tonic-gate * ECONNRESET - success, though handle was rebound 11917c478bd9Sstevel@tonic-gate * -1 - instance is in transition 11927c478bd9Sstevel@tonic-gate */ 11937c478bd9Sstevel@tonic-gate int 11947c478bd9Sstevel@tonic-gate stop_instance_fmri(scf_handle_t *h, const char *fmri, uint_t flags) 11957c478bd9Sstevel@tonic-gate { 11967c478bd9Sstevel@tonic-gate restarter_inst_t *rip; 11977c478bd9Sstevel@tonic-gate int r; 11987c478bd9Sstevel@tonic-gate 11997c478bd9Sstevel@tonic-gate rip = inst_lookup_by_name(fmri); 12007c478bd9Sstevel@tonic-gate if (rip == NULL) 12017c478bd9Sstevel@tonic-gate return (ENOENT); 12027c478bd9Sstevel@tonic-gate 12037c478bd9Sstevel@tonic-gate r = stop_instance(h, rip, flags); 12047c478bd9Sstevel@tonic-gate 12057c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&rip->ri_lock); 12067c478bd9Sstevel@tonic-gate 12077c478bd9Sstevel@tonic-gate return (r); 12087c478bd9Sstevel@tonic-gate } 12097c478bd9Sstevel@tonic-gate 12107c478bd9Sstevel@tonic-gate static void 12117c478bd9Sstevel@tonic-gate unmaintain_instance(scf_handle_t *h, restarter_inst_t *rip, 12127c478bd9Sstevel@tonic-gate unmaint_cause_t cause) 12137c478bd9Sstevel@tonic-gate { 12147c478bd9Sstevel@tonic-gate ctid_t ctid; 12157c478bd9Sstevel@tonic-gate scf_instance_t *inst; 12167c478bd9Sstevel@tonic-gate int r; 12177c478bd9Sstevel@tonic-gate uint_t tries = 0, msecs = ALLOC_DELAY; 12187c478bd9Sstevel@tonic-gate const char *cp; 1219f6e214c7SGavin Maltby restarter_str_t reason; 12207c478bd9Sstevel@tonic-gate 122153f3aea0SRoger A. Faulkner assert(MUTEX_HELD(&rip->ri_lock)); 12227c478bd9Sstevel@tonic-gate 12237c478bd9Sstevel@tonic-gate if (rip->ri_i.i_state != RESTARTER_STATE_MAINT) { 12247c478bd9Sstevel@tonic-gate log_error(LOG_DEBUG, "Restarter: " 12257c478bd9Sstevel@tonic-gate "Ignoring maintenance off command because %s is not in the " 12267c478bd9Sstevel@tonic-gate "maintenance state.\n", rip->ri_i.i_fmri); 12277c478bd9Sstevel@tonic-gate return; 12287c478bd9Sstevel@tonic-gate } 12297c478bd9Sstevel@tonic-gate 12307c478bd9Sstevel@tonic-gate switch (cause) { 12317c478bd9Sstevel@tonic-gate case RUNMAINT_CLEAR: 12327c478bd9Sstevel@tonic-gate cp = "clear requested"; 1233f6e214c7SGavin Maltby reason = restarter_str_clear_request; 12347c478bd9Sstevel@tonic-gate break; 12357c478bd9Sstevel@tonic-gate case RUNMAINT_DISABLE: 12367c478bd9Sstevel@tonic-gate cp = "disable requested"; 1237f6e214c7SGavin Maltby reason = restarter_str_disable_request; 12387c478bd9Sstevel@tonic-gate break; 12397c478bd9Sstevel@tonic-gate default: 12407c478bd9Sstevel@tonic-gate #ifndef NDEBUG 12417c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "Uncaught case for %d at %s:%d.\n", 12427c478bd9Sstevel@tonic-gate cause, __FILE__, __LINE__); 12437c478bd9Sstevel@tonic-gate #endif 12447c478bd9Sstevel@tonic-gate abort(); 12457c478bd9Sstevel@tonic-gate } 12467c478bd9Sstevel@tonic-gate 12477c478bd9Sstevel@tonic-gate log_instance(rip, B_TRUE, "Leaving maintenance because %s.", 12487c478bd9Sstevel@tonic-gate cp); 12497c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, "%s: Instance leaving maintenance because " 12507c478bd9Sstevel@tonic-gate "%s.\n", rip->ri_i.i_fmri, cp); 12517c478bd9Sstevel@tonic-gate 12527c478bd9Sstevel@tonic-gate (void) restarter_instance_update_states(h, rip, RESTARTER_STATE_UNINIT, 1253f6e214c7SGavin Maltby RESTARTER_STATE_NONE, RERR_RESTART, reason); 12547c478bd9Sstevel@tonic-gate 12557c478bd9Sstevel@tonic-gate /* 12567c478bd9Sstevel@tonic-gate * If we did ADMIN_MAINT_ON_IMMEDIATE, then there might still be 12577c478bd9Sstevel@tonic-gate * a primary contract. 12587c478bd9Sstevel@tonic-gate */ 12597c478bd9Sstevel@tonic-gate if (rip->ri_i.i_primary_ctid == 0) 12607c478bd9Sstevel@tonic-gate return; 12617c478bd9Sstevel@tonic-gate 12627c478bd9Sstevel@tonic-gate ctid = rip->ri_i.i_primary_ctid; 12637c478bd9Sstevel@tonic-gate contract_abandon(ctid); 12647c478bd9Sstevel@tonic-gate rip->ri_i.i_primary_ctid = 0; 12657c478bd9Sstevel@tonic-gate 12667c478bd9Sstevel@tonic-gate rep_retry: 12677c478bd9Sstevel@tonic-gate switch (r = libscf_fmri_get_instance(h, rip->ri_i.i_fmri, &inst)) { 12687c478bd9Sstevel@tonic-gate case 0: 12697c478bd9Sstevel@tonic-gate break; 12707c478bd9Sstevel@tonic-gate 12717c478bd9Sstevel@tonic-gate case ECONNABORTED: 12727c478bd9Sstevel@tonic-gate libscf_handle_rebind(h); 12737c478bd9Sstevel@tonic-gate goto rep_retry; 12747c478bd9Sstevel@tonic-gate 12757c478bd9Sstevel@tonic-gate case ENOENT: 12767c478bd9Sstevel@tonic-gate /* Must have been deleted. */ 12777c478bd9Sstevel@tonic-gate return; 12787c478bd9Sstevel@tonic-gate 12797c478bd9Sstevel@tonic-gate case EINVAL: 12807c478bd9Sstevel@tonic-gate case ENOTSUP: 12817c478bd9Sstevel@tonic-gate default: 12827c478bd9Sstevel@tonic-gate bad_error("libscf_handle_rebind", r); 12837c478bd9Sstevel@tonic-gate } 12847c478bd9Sstevel@tonic-gate 12857c478bd9Sstevel@tonic-gate again: 12867c478bd9Sstevel@tonic-gate r = restarter_remove_contract(inst, ctid, RESTARTER_CONTRACT_PRIMARY); 12877c478bd9Sstevel@tonic-gate switch (r) { 12887c478bd9Sstevel@tonic-gate case 0: 12897c478bd9Sstevel@tonic-gate break; 12907c478bd9Sstevel@tonic-gate 12917c478bd9Sstevel@tonic-gate case ENOMEM: 12927c478bd9Sstevel@tonic-gate ++tries; 12937c478bd9Sstevel@tonic-gate if (tries < ALLOC_RETRY) { 12947c478bd9Sstevel@tonic-gate (void) poll(NULL, 0, msecs); 12957c478bd9Sstevel@tonic-gate msecs *= ALLOC_DELAY_MULT; 12967c478bd9Sstevel@tonic-gate goto again; 12977c478bd9Sstevel@tonic-gate } 12987c478bd9Sstevel@tonic-gate 12997c478bd9Sstevel@tonic-gate uu_die("Insufficient memory.\n"); 13007c478bd9Sstevel@tonic-gate /* NOTREACHED */ 13017c478bd9Sstevel@tonic-gate 13027c478bd9Sstevel@tonic-gate case ECONNABORTED: 13037c478bd9Sstevel@tonic-gate scf_instance_destroy(inst); 13047c478bd9Sstevel@tonic-gate libscf_handle_rebind(h); 13057c478bd9Sstevel@tonic-gate goto rep_retry; 13067c478bd9Sstevel@tonic-gate 13077c478bd9Sstevel@tonic-gate case ECANCELED: 13087c478bd9Sstevel@tonic-gate break; 13097c478bd9Sstevel@tonic-gate 13107c478bd9Sstevel@tonic-gate case EPERM: 13117c478bd9Sstevel@tonic-gate case EACCES: 13127c478bd9Sstevel@tonic-gate case EROFS: 13137c478bd9Sstevel@tonic-gate log_error(LOG_INFO, 13147c478bd9Sstevel@tonic-gate "Could not remove contract id %lu for %s (%s).\n", ctid, 13157c478bd9Sstevel@tonic-gate rip->ri_i.i_fmri, strerror(r)); 13167c478bd9Sstevel@tonic-gate break; 13177c478bd9Sstevel@tonic-gate 13187c478bd9Sstevel@tonic-gate case EINVAL: 13197c478bd9Sstevel@tonic-gate case EBADF: 13207c478bd9Sstevel@tonic-gate default: 13217c478bd9Sstevel@tonic-gate bad_error("restarter_remove_contract", r); 13227c478bd9Sstevel@tonic-gate } 13237c478bd9Sstevel@tonic-gate 13247c478bd9Sstevel@tonic-gate scf_instance_destroy(inst); 13257c478bd9Sstevel@tonic-gate } 13267c478bd9Sstevel@tonic-gate 13277c478bd9Sstevel@tonic-gate /* 13287c478bd9Sstevel@tonic-gate * enable_inst() 13297c478bd9Sstevel@tonic-gate * Set inst->ri_i.i_enabled. Expects 'e' to be _ENABLE, _DISABLE, or 13307c478bd9Sstevel@tonic-gate * _ADMIN_DISABLE. If the event is _ENABLE and inst is uninitialized or 13317c478bd9Sstevel@tonic-gate * disabled, move it to offline. If the event is _DISABLE or 13327c478bd9Sstevel@tonic-gate * _ADMIN_DISABLE, make sure inst will move to disabled. 13337c478bd9Sstevel@tonic-gate * 13347c478bd9Sstevel@tonic-gate * Returns 13357c478bd9Sstevel@tonic-gate * 0 - success 13367c478bd9Sstevel@tonic-gate * ECONNRESET - h was rebound 13377c478bd9Sstevel@tonic-gate */ 13387c478bd9Sstevel@tonic-gate static int 1339f6e214c7SGavin Maltby enable_inst(scf_handle_t *h, restarter_inst_t *inst, 1340f6e214c7SGavin Maltby restarter_instance_qentry_t *riq) 13417c478bd9Sstevel@tonic-gate { 13427c478bd9Sstevel@tonic-gate restarter_instance_state_t state; 1343f6e214c7SGavin Maltby restarter_event_type_t e = riq->riq_type; 1344f6e214c7SGavin Maltby restarter_str_t reason = restarter_str_per_configuration; 13457c478bd9Sstevel@tonic-gate int r; 13467c478bd9Sstevel@tonic-gate 134753f3aea0SRoger A. Faulkner assert(MUTEX_HELD(&inst->ri_lock)); 13487c478bd9Sstevel@tonic-gate assert(e == RESTARTER_EVENT_TYPE_ADMIN_DISABLE || 13497c478bd9Sstevel@tonic-gate e == RESTARTER_EVENT_TYPE_DISABLE || 13507c478bd9Sstevel@tonic-gate e == RESTARTER_EVENT_TYPE_ENABLE); 13517c478bd9Sstevel@tonic-gate assert(instance_in_transition(inst) == 0); 13527c478bd9Sstevel@tonic-gate 13537c478bd9Sstevel@tonic-gate state = inst->ri_i.i_state; 13547c478bd9Sstevel@tonic-gate 13557c478bd9Sstevel@tonic-gate if (e == RESTARTER_EVENT_TYPE_ENABLE) { 13567c478bd9Sstevel@tonic-gate inst->ri_i.i_enabled = 1; 13577c478bd9Sstevel@tonic-gate 13587c478bd9Sstevel@tonic-gate if (state == RESTARTER_STATE_UNINIT || 13597c478bd9Sstevel@tonic-gate state == RESTARTER_STATE_DISABLED) { 13607c478bd9Sstevel@tonic-gate /* 13617c478bd9Sstevel@tonic-gate * B_FALSE: Don't log an error if the log_instance() 13627c478bd9Sstevel@tonic-gate * fails because it will fail on the miniroot before 13637c478bd9Sstevel@tonic-gate * install-discovery runs. 13647c478bd9Sstevel@tonic-gate */ 13657c478bd9Sstevel@tonic-gate log_instance(inst, B_FALSE, "Enabled."); 13667c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, "%s: Instance enabled.\n", 13677c478bd9Sstevel@tonic-gate inst->ri_i.i_fmri); 1368f6e214c7SGavin Maltby 1369f6e214c7SGavin Maltby /* 1370f6e214c7SGavin Maltby * If we are coming from DISABLED, it was obviously an 1371f6e214c7SGavin Maltby * enable request. If we are coming from UNINIT, it may 1372f6e214c7SGavin Maltby * have been a sevice in MAINT that was cleared. 1373f6e214c7SGavin Maltby */ 1374f6e214c7SGavin Maltby if (riq->riq_reason == restarter_str_clear_request) 1375f6e214c7SGavin Maltby reason = restarter_str_clear_request; 1376f6e214c7SGavin Maltby else if (state == RESTARTER_STATE_DISABLED) 1377f6e214c7SGavin Maltby reason = restarter_str_enable_request; 13787c478bd9Sstevel@tonic-gate (void) restarter_instance_update_states(h, inst, 13797c478bd9Sstevel@tonic-gate RESTARTER_STATE_OFFLINE, RESTARTER_STATE_NONE, 1380f6e214c7SGavin Maltby RERR_NONE, reason); 13817c478bd9Sstevel@tonic-gate } else { 13827c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, "Restarter: " 13837c478bd9Sstevel@tonic-gate "Not changing state of %s for enable command.\n", 13847c478bd9Sstevel@tonic-gate inst->ri_i.i_fmri); 13857c478bd9Sstevel@tonic-gate } 13867c478bd9Sstevel@tonic-gate } else { 13877c478bd9Sstevel@tonic-gate inst->ri_i.i_enabled = 0; 13887c478bd9Sstevel@tonic-gate 13897c478bd9Sstevel@tonic-gate switch (state) { 13907c478bd9Sstevel@tonic-gate case RESTARTER_STATE_ONLINE: 13917c478bd9Sstevel@tonic-gate case RESTARTER_STATE_DEGRADED: 13927c478bd9Sstevel@tonic-gate r = stop_instance(h, inst, RSTOP_DISABLE); 13937c478bd9Sstevel@tonic-gate return (r == ECONNRESET ? 0 : r); 13947c478bd9Sstevel@tonic-gate 13957c478bd9Sstevel@tonic-gate case RESTARTER_STATE_OFFLINE: 13967c478bd9Sstevel@tonic-gate case RESTARTER_STATE_UNINIT: 13977c478bd9Sstevel@tonic-gate if (inst->ri_i.i_primary_ctid != 0) { 13987c478bd9Sstevel@tonic-gate inst->ri_m_inst = safe_scf_instance_create(h); 13997c478bd9Sstevel@tonic-gate inst->ri_mi_deleted = B_FALSE; 14007c478bd9Sstevel@tonic-gate 14017c478bd9Sstevel@tonic-gate libscf_reget_instance(inst); 14027c478bd9Sstevel@tonic-gate method_remove_contract(inst, B_TRUE, B_TRUE); 14037c478bd9Sstevel@tonic-gate 14047c478bd9Sstevel@tonic-gate scf_instance_destroy(inst->ri_m_inst); 14057c478bd9Sstevel@tonic-gate } 14067c478bd9Sstevel@tonic-gate /* B_FALSE: See log_instance(..., "Enabled."); above */ 14077c478bd9Sstevel@tonic-gate log_instance(inst, B_FALSE, "Disabled."); 14087c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, "%s: Instance disabled.\n", 14097c478bd9Sstevel@tonic-gate inst->ri_i.i_fmri); 1410f6e214c7SGavin Maltby 1411f6e214c7SGavin Maltby /* 1412f6e214c7SGavin Maltby * If we are coming from OFFLINE, it was obviously a 1413f6e214c7SGavin Maltby * disable request. But if we are coming from 1414f6e214c7SGavin Maltby * UNINIT, it may have been a disable request for a 1415f6e214c7SGavin Maltby * service in MAINT. 1416f6e214c7SGavin Maltby */ 1417f6e214c7SGavin Maltby if (riq->riq_reason == restarter_str_disable_request || 1418f6e214c7SGavin Maltby state == RESTARTER_STATE_OFFLINE) 1419f6e214c7SGavin Maltby reason = restarter_str_disable_request; 14207c478bd9Sstevel@tonic-gate (void) restarter_instance_update_states(h, inst, 14217c478bd9Sstevel@tonic-gate RESTARTER_STATE_DISABLED, RESTARTER_STATE_NONE, 1422f6e214c7SGavin Maltby RERR_RESTART, reason); 14237c478bd9Sstevel@tonic-gate return (0); 14247c478bd9Sstevel@tonic-gate 14257c478bd9Sstevel@tonic-gate case RESTARTER_STATE_DISABLED: 14267c478bd9Sstevel@tonic-gate break; 14277c478bd9Sstevel@tonic-gate 14287c478bd9Sstevel@tonic-gate case RESTARTER_STATE_MAINT: 14297c478bd9Sstevel@tonic-gate /* 14307c478bd9Sstevel@tonic-gate * We only want to pull the instance out of maintenance 14317c478bd9Sstevel@tonic-gate * if the disable is on adminstrative request. The 14327c478bd9Sstevel@tonic-gate * graph engine sends _DISABLE events whenever a 14337c478bd9Sstevel@tonic-gate * service isn't in the disabled state, and we don't 14347c478bd9Sstevel@tonic-gate * want to pull the service out of maintenance if, 14357c478bd9Sstevel@tonic-gate * for example, it is there due to a dependency cycle. 14367c478bd9Sstevel@tonic-gate */ 14377c478bd9Sstevel@tonic-gate if (e == RESTARTER_EVENT_TYPE_ADMIN_DISABLE) 14387c478bd9Sstevel@tonic-gate unmaintain_instance(h, inst, RUNMAINT_DISABLE); 14397c478bd9Sstevel@tonic-gate break; 14407c478bd9Sstevel@tonic-gate 14417c478bd9Sstevel@tonic-gate default: 14427c478bd9Sstevel@tonic-gate #ifndef NDEBUG 14437c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "Restarter instance %s has " 14447c478bd9Sstevel@tonic-gate "unknown state %d.\n", inst->ri_i.i_fmri, state); 14457c478bd9Sstevel@tonic-gate #endif 14467c478bd9Sstevel@tonic-gate abort(); 14477c478bd9Sstevel@tonic-gate } 14487c478bd9Sstevel@tonic-gate } 14497c478bd9Sstevel@tonic-gate 14507c478bd9Sstevel@tonic-gate return (0); 14517c478bd9Sstevel@tonic-gate } 14527c478bd9Sstevel@tonic-gate 14537c478bd9Sstevel@tonic-gate static void 1454f6e214c7SGavin Maltby start_instance(scf_handle_t *local_handle, restarter_inst_t *inst, 1455f6e214c7SGavin Maltby int32_t reason) 14567c478bd9Sstevel@tonic-gate { 14577c478bd9Sstevel@tonic-gate fork_info_t *info; 1458f6e214c7SGavin Maltby restarter_str_t new_reason; 14597c478bd9Sstevel@tonic-gate 146053f3aea0SRoger A. Faulkner assert(MUTEX_HELD(&inst->ri_lock)); 14617c478bd9Sstevel@tonic-gate assert(instance_in_transition(inst) == 0); 14627c478bd9Sstevel@tonic-gate assert(inst->ri_method_thread == 0); 14637c478bd9Sstevel@tonic-gate 14647c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, "%s: trying to start instance\n", 14657c478bd9Sstevel@tonic-gate inst->ri_i.i_fmri); 14667c478bd9Sstevel@tonic-gate 1467f6e214c7SGavin Maltby /* 1468f6e214c7SGavin Maltby * We want to keep the original reason for restarts and clear actions 1469f6e214c7SGavin Maltby */ 1470f6e214c7SGavin Maltby switch (reason) { 1471f6e214c7SGavin Maltby case restarter_str_restart_request: 1472f6e214c7SGavin Maltby case restarter_str_clear_request: 1473f6e214c7SGavin Maltby new_reason = reason; 1474f6e214c7SGavin Maltby break; 1475f6e214c7SGavin Maltby default: 1476f6e214c7SGavin Maltby new_reason = restarter_str_dependencies_satisfied; 1477f6e214c7SGavin Maltby } 1478f6e214c7SGavin Maltby 14797c478bd9Sstevel@tonic-gate /* Services in the disabled and maintenance state are ignored */ 14807c478bd9Sstevel@tonic-gate if (inst->ri_i.i_state == RESTARTER_STATE_MAINT || 14817c478bd9Sstevel@tonic-gate inst->ri_i.i_state == RESTARTER_STATE_DISABLED || 14827c478bd9Sstevel@tonic-gate inst->ri_i.i_enabled == 0) { 14837c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, 14847c478bd9Sstevel@tonic-gate "%s: start_instance -> is maint/disabled\n", 14857c478bd9Sstevel@tonic-gate inst->ri_i.i_fmri); 14867c478bd9Sstevel@tonic-gate return; 14877c478bd9Sstevel@tonic-gate } 14887c478bd9Sstevel@tonic-gate 14897c478bd9Sstevel@tonic-gate /* Already started instances are left alone */ 14907c478bd9Sstevel@tonic-gate if (instance_started(inst) == 1) { 14917c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, 14927c478bd9Sstevel@tonic-gate "%s: start_instance -> is already started\n", 14937c478bd9Sstevel@tonic-gate inst->ri_i.i_fmri); 14947c478bd9Sstevel@tonic-gate return; 14957c478bd9Sstevel@tonic-gate } 14967c478bd9Sstevel@tonic-gate 14977c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, "%s: starting instance.\n", inst->ri_i.i_fmri); 14987c478bd9Sstevel@tonic-gate 14997c478bd9Sstevel@tonic-gate (void) restarter_instance_update_states(local_handle, inst, 1500f6e214c7SGavin Maltby inst->ri_i.i_state, RESTARTER_STATE_ONLINE, RERR_NONE, new_reason); 15017c478bd9Sstevel@tonic-gate 15027c478bd9Sstevel@tonic-gate info = startd_zalloc(sizeof (fork_info_t)); 15037c478bd9Sstevel@tonic-gate 15047c478bd9Sstevel@tonic-gate info->sf_id = inst->ri_id; 15057c478bd9Sstevel@tonic-gate info->sf_method_type = METHOD_START; 15067c478bd9Sstevel@tonic-gate info->sf_event_type = RERR_NONE; 1507f6e214c7SGavin Maltby info->sf_reason = new_reason; 15087c478bd9Sstevel@tonic-gate inst->ri_method_thread = startd_thread_create(method_thread, info); 15097c478bd9Sstevel@tonic-gate } 15107c478bd9Sstevel@tonic-gate 1511eb1a3463STruong Nguyen static int 1512eb1a3463STruong Nguyen event_from_tty(scf_handle_t *h, restarter_inst_t *rip) 1513eb1a3463STruong Nguyen { 1514eb1a3463STruong Nguyen scf_instance_t *inst; 1515eb1a3463STruong Nguyen int ret = 0; 1516eb1a3463STruong Nguyen 1517eb1a3463STruong Nguyen if (libscf_fmri_get_instance(h, rip->ri_i.i_fmri, &inst)) 1518eb1a3463STruong Nguyen return (-1); 1519eb1a3463STruong Nguyen 1520eb1a3463STruong Nguyen ret = restarter_inst_ractions_from_tty(inst); 1521eb1a3463STruong Nguyen 1522eb1a3463STruong Nguyen scf_instance_destroy(inst); 1523eb1a3463STruong Nguyen return (ret); 1524eb1a3463STruong Nguyen } 1525eb1a3463STruong Nguyen 15267c478bd9Sstevel@tonic-gate static void 15277c478bd9Sstevel@tonic-gate maintain_instance(scf_handle_t *h, restarter_inst_t *rip, int immediate, 1528f6e214c7SGavin Maltby restarter_str_t reason) 15297c478bd9Sstevel@tonic-gate { 15307c478bd9Sstevel@tonic-gate fork_info_t *info; 1531eb1a3463STruong Nguyen scf_instance_t *scf_inst = NULL; 15327c478bd9Sstevel@tonic-gate 153353f3aea0SRoger A. Faulkner assert(MUTEX_HELD(&rip->ri_lock)); 1534f6e214c7SGavin Maltby assert(reason != restarter_str_none); 15357c478bd9Sstevel@tonic-gate assert(rip->ri_method_thread == 0); 15367c478bd9Sstevel@tonic-gate 1537f6e214c7SGavin Maltby log_instance(rip, B_TRUE, "Stopping for maintenance due to %s.", 1538f6e214c7SGavin Maltby restarter_get_str_short(reason)); 15397c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, "%s: stopping for maintenance due to %s.\n", 1540f6e214c7SGavin Maltby rip->ri_i.i_fmri, restarter_get_str_short(reason)); 15417c478bd9Sstevel@tonic-gate 15427c478bd9Sstevel@tonic-gate /* Services in the maintenance state are ignored */ 15437c478bd9Sstevel@tonic-gate if (rip->ri_i.i_state == RESTARTER_STATE_MAINT) { 15447c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, 15457c478bd9Sstevel@tonic-gate "%s: maintain_instance -> is already in maintenance\n", 15467c478bd9Sstevel@tonic-gate rip->ri_i.i_fmri); 15477c478bd9Sstevel@tonic-gate return; 15487c478bd9Sstevel@tonic-gate } 15497c478bd9Sstevel@tonic-gate 1550eb1a3463STruong Nguyen /* 1551f6e214c7SGavin Maltby * If reason state is restarter_str_service_request and 1552eb1a3463STruong Nguyen * restarter_actions/auxiliary_fmri property is set with a valid fmri, 1553eb1a3463STruong Nguyen * copy the fmri to restarter/auxiliary_fmri so svcs -x can use. 1554eb1a3463STruong Nguyen */ 1555f6e214c7SGavin Maltby if (reason == restarter_str_service_request && 1556f6e214c7SGavin Maltby libscf_fmri_get_instance(h, rip->ri_i.i_fmri, &scf_inst) == 0) { 1557eb1a3463STruong Nguyen if (restarter_inst_validate_ractions_aux_fmri(scf_inst) == 0) { 1558eb1a3463STruong Nguyen if (restarter_inst_set_aux_fmri(scf_inst)) 1559eb1a3463STruong Nguyen log_framework(LOG_DEBUG, "%s: " 1560eb1a3463STruong Nguyen "restarter_inst_set_aux_fmri failed: ", 1561eb1a3463STruong Nguyen rip->ri_i.i_fmri); 1562eb1a3463STruong Nguyen } else { 1563eb1a3463STruong Nguyen log_framework(LOG_DEBUG, "%s: " 1564eb1a3463STruong Nguyen "restarter_inst_validate_ractions_aux_fmri " 1565eb1a3463STruong Nguyen "failed: ", rip->ri_i.i_fmri); 1566eb1a3463STruong Nguyen 1567eb1a3463STruong Nguyen if (restarter_inst_reset_aux_fmri(scf_inst)) 1568eb1a3463STruong Nguyen log_framework(LOG_DEBUG, "%s: " 1569eb1a3463STruong Nguyen "restarter_inst_reset_aux_fmri failed: ", 1570eb1a3463STruong Nguyen rip->ri_i.i_fmri); 1571eb1a3463STruong Nguyen } 1572eb1a3463STruong Nguyen scf_instance_destroy(scf_inst); 1573eb1a3463STruong Nguyen } 1574eb1a3463STruong Nguyen 15757c478bd9Sstevel@tonic-gate if (immediate || !instance_started(rip)) { 15767c478bd9Sstevel@tonic-gate if (rip->ri_i.i_primary_ctid != 0) { 15777c478bd9Sstevel@tonic-gate rip->ri_m_inst = safe_scf_instance_create(h); 15787c478bd9Sstevel@tonic-gate rip->ri_mi_deleted = B_FALSE; 15797c478bd9Sstevel@tonic-gate 15807c478bd9Sstevel@tonic-gate libscf_reget_instance(rip); 15817c478bd9Sstevel@tonic-gate method_remove_contract(rip, B_TRUE, B_TRUE); 15827c478bd9Sstevel@tonic-gate 15837c478bd9Sstevel@tonic-gate scf_instance_destroy(rip->ri_m_inst); 15847c478bd9Sstevel@tonic-gate } 15857c478bd9Sstevel@tonic-gate 15867c478bd9Sstevel@tonic-gate (void) restarter_instance_update_states(h, rip, 15877c478bd9Sstevel@tonic-gate RESTARTER_STATE_MAINT, RESTARTER_STATE_NONE, RERR_RESTART, 1588f6e214c7SGavin Maltby reason); 15897c478bd9Sstevel@tonic-gate return; 15907c478bd9Sstevel@tonic-gate } 15917c478bd9Sstevel@tonic-gate 15927c478bd9Sstevel@tonic-gate (void) restarter_instance_update_states(h, rip, rip->ri_i.i_state, 1593f6e214c7SGavin Maltby RESTARTER_STATE_MAINT, RERR_NONE, reason); 15947c478bd9Sstevel@tonic-gate 159599b44c3bSlianep log_transition(rip, MAINT_REQUESTED); 159699b44c3bSlianep 15977c478bd9Sstevel@tonic-gate info = startd_zalloc(sizeof (*info)); 15987c478bd9Sstevel@tonic-gate info->sf_id = rip->ri_id; 15997c478bd9Sstevel@tonic-gate info->sf_method_type = METHOD_STOP; 16007c478bd9Sstevel@tonic-gate info->sf_event_type = RERR_RESTART; 1601f6e214c7SGavin Maltby info->sf_reason = reason; 16027c478bd9Sstevel@tonic-gate rip->ri_method_thread = startd_thread_create(method_thread, info); 16037c478bd9Sstevel@tonic-gate } 16047c478bd9Sstevel@tonic-gate 16057c478bd9Sstevel@tonic-gate static void 16067c478bd9Sstevel@tonic-gate refresh_instance(scf_handle_t *h, restarter_inst_t *rip) 16077c478bd9Sstevel@tonic-gate { 16087c478bd9Sstevel@tonic-gate scf_instance_t *inst; 16097c478bd9Sstevel@tonic-gate scf_snapshot_t *snap; 16107c478bd9Sstevel@tonic-gate fork_info_t *info; 16117c478bd9Sstevel@tonic-gate int r; 16127c478bd9Sstevel@tonic-gate 161353f3aea0SRoger A. Faulkner assert(MUTEX_HELD(&rip->ri_lock)); 16147c478bd9Sstevel@tonic-gate 16157c478bd9Sstevel@tonic-gate log_instance(rip, B_TRUE, "Rereading configuration."); 16167c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, "%s: rereading configuration.\n", 16177c478bd9Sstevel@tonic-gate rip->ri_i.i_fmri); 16187c478bd9Sstevel@tonic-gate 16197c478bd9Sstevel@tonic-gate rep_retry: 16207c478bd9Sstevel@tonic-gate r = libscf_fmri_get_instance(h, rip->ri_i.i_fmri, &inst); 16217c478bd9Sstevel@tonic-gate switch (r) { 16227c478bd9Sstevel@tonic-gate case 0: 16237c478bd9Sstevel@tonic-gate break; 16247c478bd9Sstevel@tonic-gate 16257c478bd9Sstevel@tonic-gate case ECONNABORTED: 16267c478bd9Sstevel@tonic-gate libscf_handle_rebind(h); 16277c478bd9Sstevel@tonic-gate goto rep_retry; 16287c478bd9Sstevel@tonic-gate 16297c478bd9Sstevel@tonic-gate case ENOENT: 16307c478bd9Sstevel@tonic-gate /* Must have been deleted. */ 16317c478bd9Sstevel@tonic-gate return; 16327c478bd9Sstevel@tonic-gate 16337c478bd9Sstevel@tonic-gate case EINVAL: 16347c478bd9Sstevel@tonic-gate case ENOTSUP: 16357c478bd9Sstevel@tonic-gate default: 16367c478bd9Sstevel@tonic-gate bad_error("libscf_fmri_get_instance", r); 16377c478bd9Sstevel@tonic-gate } 16387c478bd9Sstevel@tonic-gate 16397c478bd9Sstevel@tonic-gate snap = libscf_get_running_snapshot(inst); 16407c478bd9Sstevel@tonic-gate 16417c478bd9Sstevel@tonic-gate r = libscf_get_startd_properties(inst, snap, &rip->ri_flags, 16427c478bd9Sstevel@tonic-gate &rip->ri_utmpx_prefix); 16437c478bd9Sstevel@tonic-gate switch (r) { 16447c478bd9Sstevel@tonic-gate case 0: 16457c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, "%s is a %s-style service\n", 16467c478bd9Sstevel@tonic-gate rip->ri_i.i_fmri, service_style(rip->ri_flags)); 16477c478bd9Sstevel@tonic-gate break; 16487c478bd9Sstevel@tonic-gate 16497c478bd9Sstevel@tonic-gate case ECONNABORTED: 16507c478bd9Sstevel@tonic-gate scf_instance_destroy(inst); 16517c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap); 16527c478bd9Sstevel@tonic-gate libscf_handle_rebind(h); 16537c478bd9Sstevel@tonic-gate goto rep_retry; 16547c478bd9Sstevel@tonic-gate 16557c478bd9Sstevel@tonic-gate case ECANCELED: 16567c478bd9Sstevel@tonic-gate case ENOENT: 16577c478bd9Sstevel@tonic-gate /* Succeed in anticipation of REMOVE_INSTANCE. */ 16587c478bd9Sstevel@tonic-gate break; 16597c478bd9Sstevel@tonic-gate 16607c478bd9Sstevel@tonic-gate default: 16617c478bd9Sstevel@tonic-gate bad_error("libscf_get_startd_properties", r); 16627c478bd9Sstevel@tonic-gate } 16637c478bd9Sstevel@tonic-gate 16647c478bd9Sstevel@tonic-gate if (instance_started(rip)) { 16657c478bd9Sstevel@tonic-gate /* Refresh does not change the state. */ 16667c478bd9Sstevel@tonic-gate (void) restarter_instance_update_states(h, rip, 1667f6e214c7SGavin Maltby rip->ri_i.i_state, rip->ri_i.i_state, RERR_NONE, 1668f6e214c7SGavin Maltby restarter_str_refresh); 16697c478bd9Sstevel@tonic-gate 16707c478bd9Sstevel@tonic-gate info = startd_zalloc(sizeof (*info)); 16717c478bd9Sstevel@tonic-gate info->sf_id = rip->ri_id; 16727c478bd9Sstevel@tonic-gate info->sf_method_type = METHOD_REFRESH; 16737c478bd9Sstevel@tonic-gate info->sf_event_type = RERR_REFRESH; 1674f6e214c7SGavin Maltby info->sf_reason = NULL; 16757c478bd9Sstevel@tonic-gate 16767c478bd9Sstevel@tonic-gate assert(rip->ri_method_thread == 0); 16777c478bd9Sstevel@tonic-gate rip->ri_method_thread = 16787c478bd9Sstevel@tonic-gate startd_thread_create(method_thread, info); 16797c478bd9Sstevel@tonic-gate } 16807c478bd9Sstevel@tonic-gate 16817c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap); 16827c478bd9Sstevel@tonic-gate scf_instance_destroy(inst); 16837c478bd9Sstevel@tonic-gate } 16847c478bd9Sstevel@tonic-gate 16857c478bd9Sstevel@tonic-gate const char *event_names[] = { "INVALID", "ADD_INSTANCE", "REMOVE_INSTANCE", 16867c478bd9Sstevel@tonic-gate "ENABLE", "DISABLE", "ADMIN_DEGRADED", "ADMIN_REFRESH", 16877c478bd9Sstevel@tonic-gate "ADMIN_RESTART", "ADMIN_MAINT_OFF", "ADMIN_MAINT_ON", 16887c478bd9Sstevel@tonic-gate "ADMIN_MAINT_ON_IMMEDIATE", "STOP", "START", "DEPENDENCY_CYCLE", 1689c238c833SSean Wilcox "INVALID_DEPENDENCY", "ADMIN_DISABLE", "STOP_RESET" 16907c478bd9Sstevel@tonic-gate }; 16917c478bd9Sstevel@tonic-gate 16927c478bd9Sstevel@tonic-gate /* 16937c478bd9Sstevel@tonic-gate * void *restarter_process_events() 16947c478bd9Sstevel@tonic-gate * 16957c478bd9Sstevel@tonic-gate * Called in a separate thread to process the events on an instance's 16967c478bd9Sstevel@tonic-gate * queue. Empties the queue completely, and tries to keep the thread 16977c478bd9Sstevel@tonic-gate * around for a little while after the queue is empty to save on 16987c478bd9Sstevel@tonic-gate * startup costs. 16997c478bd9Sstevel@tonic-gate */ 17007c478bd9Sstevel@tonic-gate static void * 17017c478bd9Sstevel@tonic-gate restarter_process_events(void *arg) 17027c478bd9Sstevel@tonic-gate { 17037c478bd9Sstevel@tonic-gate scf_handle_t *h; 17047c478bd9Sstevel@tonic-gate restarter_instance_qentry_t *event; 17057c478bd9Sstevel@tonic-gate restarter_inst_t *rip; 17067c478bd9Sstevel@tonic-gate char *fmri = (char *)arg; 17077c478bd9Sstevel@tonic-gate struct timespec to; 17087c478bd9Sstevel@tonic-gate 17097c478bd9Sstevel@tonic-gate assert(fmri != NULL); 17107c478bd9Sstevel@tonic-gate 17117c478bd9Sstevel@tonic-gate h = libscf_handle_create_bound_loop(); 17127c478bd9Sstevel@tonic-gate 17137c478bd9Sstevel@tonic-gate /* grab the queue lock */ 17147c478bd9Sstevel@tonic-gate rip = inst_lookup_queue(fmri); 17157c478bd9Sstevel@tonic-gate if (rip == NULL) 17167c478bd9Sstevel@tonic-gate goto out; 17177c478bd9Sstevel@tonic-gate 17187c478bd9Sstevel@tonic-gate again: 17197c478bd9Sstevel@tonic-gate 17207c478bd9Sstevel@tonic-gate while ((event = uu_list_first(rip->ri_queue)) != NULL) { 17217c478bd9Sstevel@tonic-gate restarter_inst_t *inst; 17227c478bd9Sstevel@tonic-gate 17237c478bd9Sstevel@tonic-gate /* drop the queue lock */ 17247c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&rip->ri_queue_lock); 17257c478bd9Sstevel@tonic-gate 17267c478bd9Sstevel@tonic-gate /* 17277c478bd9Sstevel@tonic-gate * Grab the inst lock -- this waits until any outstanding 17287c478bd9Sstevel@tonic-gate * method finishes running. 17297c478bd9Sstevel@tonic-gate */ 17307c478bd9Sstevel@tonic-gate inst = inst_lookup_by_name(fmri); 17317c478bd9Sstevel@tonic-gate if (inst == NULL) { 17327c478bd9Sstevel@tonic-gate /* Getting deleted in the middle isn't an error. */ 17337c478bd9Sstevel@tonic-gate goto cont; 17347c478bd9Sstevel@tonic-gate } 17357c478bd9Sstevel@tonic-gate 17367c478bd9Sstevel@tonic-gate assert(instance_in_transition(inst) == 0); 17377c478bd9Sstevel@tonic-gate 17387c478bd9Sstevel@tonic-gate /* process the event */ 17397c478bd9Sstevel@tonic-gate switch (event->riq_type) { 17407c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ENABLE: 17417c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_DISABLE: 1742f6e214c7SGavin Maltby (void) enable_inst(h, inst, event); 17437c478bd9Sstevel@tonic-gate break; 17447c478bd9Sstevel@tonic-gate 174516ba0facSSean Wilcox case RESTARTER_EVENT_TYPE_ADMIN_DISABLE: 1746f6e214c7SGavin Maltby if (enable_inst(h, inst, event) == 0) 174716ba0facSSean Wilcox reset_start_times(inst); 174816ba0facSSean Wilcox break; 174916ba0facSSean Wilcox 17507c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_REMOVE_INSTANCE: 17517c478bd9Sstevel@tonic-gate restarter_delete_inst(inst); 17527c478bd9Sstevel@tonic-gate inst = NULL; 17537c478bd9Sstevel@tonic-gate goto cont; 17547c478bd9Sstevel@tonic-gate 175516ba0facSSean Wilcox case RESTARTER_EVENT_TYPE_STOP_RESET: 175616ba0facSSean Wilcox reset_start_times(inst); 175716ba0facSSean Wilcox /* FALLTHROUGH */ 17587c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_STOP: 17597c478bd9Sstevel@tonic-gate (void) stop_instance(h, inst, RSTOP_DEPENDENCY); 17607c478bd9Sstevel@tonic-gate break; 17617c478bd9Sstevel@tonic-gate 17627c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_START: 1763f6e214c7SGavin Maltby start_instance(h, inst, event->riq_reason); 17647c478bd9Sstevel@tonic-gate break; 17657c478bd9Sstevel@tonic-gate 17667c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_DEPENDENCY_CYCLE: 1767f6e214c7SGavin Maltby maintain_instance(h, inst, 0, 1768f6e214c7SGavin Maltby restarter_str_dependency_cycle); 17697c478bd9Sstevel@tonic-gate break; 17707c478bd9Sstevel@tonic-gate 17717c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_INVALID_DEPENDENCY: 1772f6e214c7SGavin Maltby maintain_instance(h, inst, 0, 1773f6e214c7SGavin Maltby restarter_str_invalid_dependency); 17747c478bd9Sstevel@tonic-gate break; 17757c478bd9Sstevel@tonic-gate 17767c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_MAINT_ON: 1777eb1a3463STruong Nguyen if (event_from_tty(h, inst) == 0) 1778eb1a3463STruong Nguyen maintain_instance(h, inst, 0, 1779f6e214c7SGavin Maltby restarter_str_service_request); 1780eb1a3463STruong Nguyen else 1781eb1a3463STruong Nguyen maintain_instance(h, inst, 0, 1782f6e214c7SGavin Maltby restarter_str_administrative_request); 17837c478bd9Sstevel@tonic-gate break; 17847c478bd9Sstevel@tonic-gate 17857c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_MAINT_ON_IMMEDIATE: 1786eb1a3463STruong Nguyen if (event_from_tty(h, inst) == 0) 1787eb1a3463STruong Nguyen maintain_instance(h, inst, 1, 1788f6e214c7SGavin Maltby restarter_str_service_request); 1789eb1a3463STruong Nguyen else 1790eb1a3463STruong Nguyen maintain_instance(h, inst, 1, 1791f6e214c7SGavin Maltby restarter_str_administrative_request); 17927c478bd9Sstevel@tonic-gate break; 17937c478bd9Sstevel@tonic-gate 17947c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_MAINT_OFF: 17957c478bd9Sstevel@tonic-gate unmaintain_instance(h, inst, RUNMAINT_CLEAR); 17968b55d351SSean Wilcox reset_start_times(inst); 17977c478bd9Sstevel@tonic-gate break; 17987c478bd9Sstevel@tonic-gate 17997c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_REFRESH: 18007c478bd9Sstevel@tonic-gate refresh_instance(h, inst); 18017c478bd9Sstevel@tonic-gate break; 18027c478bd9Sstevel@tonic-gate 18037c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_DEGRADED: 18047c478bd9Sstevel@tonic-gate log_framework(LOG_WARNING, "Restarter: " 18057c478bd9Sstevel@tonic-gate "%s command (for %s) unimplemented.\n", 18067c478bd9Sstevel@tonic-gate event_names[event->riq_type], inst->ri_i.i_fmri); 18077c478bd9Sstevel@tonic-gate break; 18087c478bd9Sstevel@tonic-gate 18097c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_RESTART: 18107c478bd9Sstevel@tonic-gate if (!instance_started(inst)) { 18117c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, "Restarter: " 18127c478bd9Sstevel@tonic-gate "Not restarting %s; not running.\n", 18137c478bd9Sstevel@tonic-gate inst->ri_i.i_fmri); 18147c478bd9Sstevel@tonic-gate } else { 18157c478bd9Sstevel@tonic-gate /* 18167c478bd9Sstevel@tonic-gate * Stop the instance. If it can be restarted, 18177c478bd9Sstevel@tonic-gate * the graph engine will send a new event. 18187c478bd9Sstevel@tonic-gate */ 181916ba0facSSean Wilcox if (stop_instance(h, inst, RSTOP_RESTART) == 0) 182016ba0facSSean Wilcox reset_start_times(inst); 18217c478bd9Sstevel@tonic-gate } 18227c478bd9Sstevel@tonic-gate break; 18237c478bd9Sstevel@tonic-gate 18247c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADD_INSTANCE: 18257c478bd9Sstevel@tonic-gate default: 18267c478bd9Sstevel@tonic-gate #ifndef NDEBUG 18277c478bd9Sstevel@tonic-gate uu_warn("%s:%d: Bad restarter event %d. " 18287c478bd9Sstevel@tonic-gate "Aborting.\n", __FILE__, __LINE__, event->riq_type); 18297c478bd9Sstevel@tonic-gate #endif 18307c478bd9Sstevel@tonic-gate abort(); 18317c478bd9Sstevel@tonic-gate } 18327c478bd9Sstevel@tonic-gate 18337c478bd9Sstevel@tonic-gate assert(inst != NULL); 18347c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&inst->ri_lock); 18357c478bd9Sstevel@tonic-gate 18367c478bd9Sstevel@tonic-gate cont: 18377c478bd9Sstevel@tonic-gate /* grab the queue lock */ 18387c478bd9Sstevel@tonic-gate rip = inst_lookup_queue(fmri); 18397c478bd9Sstevel@tonic-gate if (rip == NULL) 18407c478bd9Sstevel@tonic-gate goto out; 18417c478bd9Sstevel@tonic-gate 18427c478bd9Sstevel@tonic-gate /* delete the event */ 18437c478bd9Sstevel@tonic-gate uu_list_remove(rip->ri_queue, event); 18447c478bd9Sstevel@tonic-gate startd_free(event, sizeof (restarter_instance_qentry_t)); 18457c478bd9Sstevel@tonic-gate } 18467c478bd9Sstevel@tonic-gate 18477c478bd9Sstevel@tonic-gate assert(rip != NULL); 18487c478bd9Sstevel@tonic-gate 18497c478bd9Sstevel@tonic-gate /* 18507c478bd9Sstevel@tonic-gate * Try to preserve the thread for a little while for future use. 18517c478bd9Sstevel@tonic-gate */ 18527c478bd9Sstevel@tonic-gate to.tv_sec = 3; 18537c478bd9Sstevel@tonic-gate to.tv_nsec = 0; 18547c478bd9Sstevel@tonic-gate (void) pthread_cond_reltimedwait_np(&rip->ri_queue_cv, 18557c478bd9Sstevel@tonic-gate &rip->ri_queue_lock, &to); 18567c478bd9Sstevel@tonic-gate 18577c478bd9Sstevel@tonic-gate if (uu_list_first(rip->ri_queue) != NULL) 18587c478bd9Sstevel@tonic-gate goto again; 18597c478bd9Sstevel@tonic-gate 18607c478bd9Sstevel@tonic-gate rip->ri_queue_thread = 0; 18617c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&rip->ri_queue_lock); 18623dd94f79SBryan Cantrill 18637c478bd9Sstevel@tonic-gate out: 18647c478bd9Sstevel@tonic-gate (void) scf_handle_unbind(h); 18657c478bd9Sstevel@tonic-gate scf_handle_destroy(h); 18667c478bd9Sstevel@tonic-gate free(fmri); 18677c478bd9Sstevel@tonic-gate return (NULL); 18687c478bd9Sstevel@tonic-gate } 18697c478bd9Sstevel@tonic-gate 18707c478bd9Sstevel@tonic-gate static int 18717c478bd9Sstevel@tonic-gate is_admin_event(restarter_event_type_t t) { 18727c478bd9Sstevel@tonic-gate 18737c478bd9Sstevel@tonic-gate switch (t) { 18747c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_MAINT_ON: 18757c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_MAINT_ON_IMMEDIATE: 18767c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_MAINT_OFF: 18777c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_REFRESH: 18787c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_DEGRADED: 18797c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_RESTART: 18807c478bd9Sstevel@tonic-gate return (1); 18817c478bd9Sstevel@tonic-gate default: 18827c478bd9Sstevel@tonic-gate return (0); 18837c478bd9Sstevel@tonic-gate } 18847c478bd9Sstevel@tonic-gate } 18857c478bd9Sstevel@tonic-gate 18867c478bd9Sstevel@tonic-gate static void 18877c478bd9Sstevel@tonic-gate restarter_queue_event(restarter_inst_t *ri, restarter_protocol_event_t *e) 18887c478bd9Sstevel@tonic-gate { 18897c478bd9Sstevel@tonic-gate restarter_instance_qentry_t *qe; 18907c478bd9Sstevel@tonic-gate int r; 18917c478bd9Sstevel@tonic-gate 189253f3aea0SRoger A. Faulkner assert(MUTEX_HELD(&ri->ri_queue_lock)); 189353f3aea0SRoger A. Faulkner assert(!MUTEX_HELD(&ri->ri_lock)); 18947c478bd9Sstevel@tonic-gate 18957c478bd9Sstevel@tonic-gate qe = startd_zalloc(sizeof (restarter_instance_qentry_t)); 18967c478bd9Sstevel@tonic-gate qe->riq_type = e->rpe_type; 1897f6e214c7SGavin Maltby qe->riq_reason = e->rpe_reason; 18987c478bd9Sstevel@tonic-gate 18997c478bd9Sstevel@tonic-gate uu_list_node_init(qe, &qe->riq_link, restarter_queue_pool); 19007c478bd9Sstevel@tonic-gate r = uu_list_insert_before(ri->ri_queue, NULL, qe); 19017c478bd9Sstevel@tonic-gate assert(r == 0); 19027c478bd9Sstevel@tonic-gate } 19037c478bd9Sstevel@tonic-gate 19047c478bd9Sstevel@tonic-gate /* 19057c478bd9Sstevel@tonic-gate * void *restarter_event_thread() 19067c478bd9Sstevel@tonic-gate * 19077c478bd9Sstevel@tonic-gate * Handle incoming graph events by placing them on a per-instance 19087c478bd9Sstevel@tonic-gate * queue. We can't lock the main part of the instance structure, so 19097c478bd9Sstevel@tonic-gate * just modify the seprarately locked event queue portion. 19107c478bd9Sstevel@tonic-gate */ 19117c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 19127c478bd9Sstevel@tonic-gate static void * 19137c478bd9Sstevel@tonic-gate restarter_event_thread(void *unused) 19147c478bd9Sstevel@tonic-gate { 19157c478bd9Sstevel@tonic-gate scf_handle_t *h; 19167c478bd9Sstevel@tonic-gate 19177c478bd9Sstevel@tonic-gate /* 19187c478bd9Sstevel@tonic-gate * This is a new thread, and thus, gets its own handle 19197c478bd9Sstevel@tonic-gate * to the repository. 19207c478bd9Sstevel@tonic-gate */ 19217c478bd9Sstevel@tonic-gate h = libscf_handle_create_bound_loop(); 19227c478bd9Sstevel@tonic-gate 19237c478bd9Sstevel@tonic-gate MUTEX_LOCK(&ru->restarter_update_lock); 19247c478bd9Sstevel@tonic-gate 19257c478bd9Sstevel@tonic-gate /*CONSTCOND*/ 19267c478bd9Sstevel@tonic-gate while (1) { 19277c478bd9Sstevel@tonic-gate restarter_protocol_event_t *e; 19287c478bd9Sstevel@tonic-gate 19297c478bd9Sstevel@tonic-gate while (ru->restarter_update_wakeup == 0) 19307c478bd9Sstevel@tonic-gate (void) pthread_cond_wait(&ru->restarter_update_cv, 19317c478bd9Sstevel@tonic-gate &ru->restarter_update_lock); 19327c478bd9Sstevel@tonic-gate 19337c478bd9Sstevel@tonic-gate ru->restarter_update_wakeup = 0; 19347c478bd9Sstevel@tonic-gate 19357c478bd9Sstevel@tonic-gate while ((e = restarter_event_dequeue()) != NULL) { 19367c478bd9Sstevel@tonic-gate restarter_inst_t *rip; 19377c478bd9Sstevel@tonic-gate char *fmri; 19387c478bd9Sstevel@tonic-gate 19397c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&ru->restarter_update_lock); 19407c478bd9Sstevel@tonic-gate 19417c478bd9Sstevel@tonic-gate /* 19427c478bd9Sstevel@tonic-gate * ADD_INSTANCE is special: there's likely no 19437c478bd9Sstevel@tonic-gate * instance structure yet, so we need to handle the 19447c478bd9Sstevel@tonic-gate * addition synchronously. 19457c478bd9Sstevel@tonic-gate */ 19467c478bd9Sstevel@tonic-gate switch (e->rpe_type) { 19477c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADD_INSTANCE: 19487c478bd9Sstevel@tonic-gate if (restarter_insert_inst(h, e->rpe_inst) != 0) 19497c478bd9Sstevel@tonic-gate log_error(LOG_INFO, "Restarter: " 19507c478bd9Sstevel@tonic-gate "Could not add %s.\n", e->rpe_inst); 19517c478bd9Sstevel@tonic-gate 19527c478bd9Sstevel@tonic-gate MUTEX_LOCK(&st->st_load_lock); 19537c478bd9Sstevel@tonic-gate if (--st->st_load_instances == 0) 19547c478bd9Sstevel@tonic-gate (void) pthread_cond_broadcast( 19557c478bd9Sstevel@tonic-gate &st->st_load_cv); 19567c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&st->st_load_lock); 19577c478bd9Sstevel@tonic-gate 19587c478bd9Sstevel@tonic-gate goto nolookup; 19597c478bd9Sstevel@tonic-gate } 19607c478bd9Sstevel@tonic-gate 19617c478bd9Sstevel@tonic-gate /* 19627c478bd9Sstevel@tonic-gate * Lookup the instance, locking only the event queue. 19637c478bd9Sstevel@tonic-gate * Can't grab ri_lock here because it might be held 19647c478bd9Sstevel@tonic-gate * by a long-running method. 19657c478bd9Sstevel@tonic-gate */ 19667c478bd9Sstevel@tonic-gate rip = inst_lookup_queue(e->rpe_inst); 19677c478bd9Sstevel@tonic-gate if (rip == NULL) { 19687c478bd9Sstevel@tonic-gate log_error(LOG_INFO, "Restarter: " 19697c478bd9Sstevel@tonic-gate "Ignoring %s command for unknown service " 19707c478bd9Sstevel@tonic-gate "%s.\n", event_names[e->rpe_type], 19717c478bd9Sstevel@tonic-gate e->rpe_inst); 19727c478bd9Sstevel@tonic-gate goto nolookup; 19737c478bd9Sstevel@tonic-gate } 19747c478bd9Sstevel@tonic-gate 19757c478bd9Sstevel@tonic-gate /* Keep ADMIN events from filling up the queue. */ 19767c478bd9Sstevel@tonic-gate if (is_admin_event(e->rpe_type) && 19777c478bd9Sstevel@tonic-gate uu_list_numnodes(rip->ri_queue) > 19787c478bd9Sstevel@tonic-gate RINST_QUEUE_THRESHOLD) { 19797c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&rip->ri_queue_lock); 19807c478bd9Sstevel@tonic-gate log_instance(rip, B_TRUE, "Instance event " 19817c478bd9Sstevel@tonic-gate "queue overflow. Dropping administrative " 19827c478bd9Sstevel@tonic-gate "request."); 19837c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, "%s: Instance event " 19847c478bd9Sstevel@tonic-gate "queue overflow. Dropping administrative " 19857c478bd9Sstevel@tonic-gate "request.\n", rip->ri_i.i_fmri); 19867c478bd9Sstevel@tonic-gate goto nolookup; 19877c478bd9Sstevel@tonic-gate } 19887c478bd9Sstevel@tonic-gate 19897c478bd9Sstevel@tonic-gate /* Now add the event to the instance queue. */ 19907c478bd9Sstevel@tonic-gate restarter_queue_event(rip, e); 19917c478bd9Sstevel@tonic-gate 19927c478bd9Sstevel@tonic-gate if (rip->ri_queue_thread == 0) { 19937c478bd9Sstevel@tonic-gate /* 19947c478bd9Sstevel@tonic-gate * Start a thread if one isn't already 19957c478bd9Sstevel@tonic-gate * running. 19967c478bd9Sstevel@tonic-gate */ 19977c478bd9Sstevel@tonic-gate fmri = safe_strdup(e->rpe_inst); 19987c478bd9Sstevel@tonic-gate rip->ri_queue_thread = startd_thread_create( 19997c478bd9Sstevel@tonic-gate restarter_process_events, (void *)fmri); 20007c478bd9Sstevel@tonic-gate } else { 20017c478bd9Sstevel@tonic-gate /* 20027c478bd9Sstevel@tonic-gate * Signal the existing thread that there's 20037c478bd9Sstevel@tonic-gate * a new event. 20047c478bd9Sstevel@tonic-gate */ 20057c478bd9Sstevel@tonic-gate (void) pthread_cond_broadcast( 20067c478bd9Sstevel@tonic-gate &rip->ri_queue_cv); 20077c478bd9Sstevel@tonic-gate } 20087c478bd9Sstevel@tonic-gate 20097c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&rip->ri_queue_lock); 20107c478bd9Sstevel@tonic-gate nolookup: 20117c478bd9Sstevel@tonic-gate restarter_event_release(e); 20127c478bd9Sstevel@tonic-gate 20137c478bd9Sstevel@tonic-gate MUTEX_LOCK(&ru->restarter_update_lock); 20147c478bd9Sstevel@tonic-gate } 20157c478bd9Sstevel@tonic-gate } 20167c478bd9Sstevel@tonic-gate 20177c478bd9Sstevel@tonic-gate /* 20187c478bd9Sstevel@tonic-gate * Unreachable for now -- there's currently no graceful cleanup 20197c478bd9Sstevel@tonic-gate * called on exit(). 20207c478bd9Sstevel@tonic-gate */ 20217c478bd9Sstevel@tonic-gate (void) scf_handle_unbind(h); 20227c478bd9Sstevel@tonic-gate scf_handle_destroy(h); 20237c478bd9Sstevel@tonic-gate return (NULL); 20247c478bd9Sstevel@tonic-gate } 20257c478bd9Sstevel@tonic-gate 20267c478bd9Sstevel@tonic-gate static restarter_inst_t * 20277c478bd9Sstevel@tonic-gate contract_to_inst(ctid_t ctid) 20287c478bd9Sstevel@tonic-gate { 20297c478bd9Sstevel@tonic-gate restarter_inst_t *inst; 20307c478bd9Sstevel@tonic-gate int id; 20317c478bd9Sstevel@tonic-gate 20327c478bd9Sstevel@tonic-gate id = lookup_inst_by_contract(ctid); 20337c478bd9Sstevel@tonic-gate if (id == -1) 20347c478bd9Sstevel@tonic-gate return (NULL); 20357c478bd9Sstevel@tonic-gate 20367c478bd9Sstevel@tonic-gate inst = inst_lookup_by_id(id); 20377c478bd9Sstevel@tonic-gate if (inst != NULL) { 20387c478bd9Sstevel@tonic-gate /* 20397c478bd9Sstevel@tonic-gate * Since ri_lock isn't held by the contract id lookup, this 20407c478bd9Sstevel@tonic-gate * instance may have been restarted and now be in a new 20417c478bd9Sstevel@tonic-gate * contract, making the old contract no longer valid for this 20427c478bd9Sstevel@tonic-gate * instance. 20437c478bd9Sstevel@tonic-gate */ 20447c478bd9Sstevel@tonic-gate if (ctid != inst->ri_i.i_primary_ctid) { 20457c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&inst->ri_lock); 20467c478bd9Sstevel@tonic-gate inst = NULL; 20477c478bd9Sstevel@tonic-gate } 20487c478bd9Sstevel@tonic-gate } 20497c478bd9Sstevel@tonic-gate return (inst); 20507c478bd9Sstevel@tonic-gate } 20517c478bd9Sstevel@tonic-gate 20527c478bd9Sstevel@tonic-gate /* 20537c478bd9Sstevel@tonic-gate * void contract_action() 20547c478bd9Sstevel@tonic-gate * Take action on contract events. 20557c478bd9Sstevel@tonic-gate */ 20567c478bd9Sstevel@tonic-gate static void 20577c478bd9Sstevel@tonic-gate contract_action(scf_handle_t *h, restarter_inst_t *inst, ctid_t id, 20587c478bd9Sstevel@tonic-gate uint32_t type) 20597c478bd9Sstevel@tonic-gate { 20607c478bd9Sstevel@tonic-gate const char *fmri = inst->ri_i.i_fmri; 20617c478bd9Sstevel@tonic-gate 206253f3aea0SRoger A. Faulkner assert(MUTEX_HELD(&inst->ri_lock)); 20637c478bd9Sstevel@tonic-gate 20647c478bd9Sstevel@tonic-gate /* 20657c478bd9Sstevel@tonic-gate * If startd has stopped this contract, there is no need to 20667c478bd9Sstevel@tonic-gate * stop it again. 20677c478bd9Sstevel@tonic-gate */ 20687c478bd9Sstevel@tonic-gate if (inst->ri_i.i_primary_ctid > 0 && 20697c478bd9Sstevel@tonic-gate inst->ri_i.i_primary_ctid_stopped) 20707c478bd9Sstevel@tonic-gate return; 20717c478bd9Sstevel@tonic-gate 20727c478bd9Sstevel@tonic-gate if ((type & (CT_PR_EV_EMPTY | CT_PR_EV_CORE | CT_PR_EV_SIGNAL 20737c478bd9Sstevel@tonic-gate | CT_PR_EV_HWERR)) == 0) { 20747c478bd9Sstevel@tonic-gate /* 20757c478bd9Sstevel@tonic-gate * There shouldn't be other events, since that's not how we set 20767c478bd9Sstevel@tonic-gate * the terms. Thus, just log an error and drive on. 20777c478bd9Sstevel@tonic-gate */ 20787c478bd9Sstevel@tonic-gate log_framework(LOG_NOTICE, 20797c478bd9Sstevel@tonic-gate "%s: contract %ld received unexpected critical event " 20807c478bd9Sstevel@tonic-gate "(%d)\n", fmri, id, type); 20817c478bd9Sstevel@tonic-gate return; 20827c478bd9Sstevel@tonic-gate } 20837c478bd9Sstevel@tonic-gate 20847c478bd9Sstevel@tonic-gate assert(instance_in_transition(inst) == 0); 20857c478bd9Sstevel@tonic-gate 20867c478bd9Sstevel@tonic-gate if (instance_is_wait_style(inst)) { 20877c478bd9Sstevel@tonic-gate /* 20887c478bd9Sstevel@tonic-gate * We ignore all events; if they impact the 20897c478bd9Sstevel@tonic-gate * process we're monitoring, then the 20907c478bd9Sstevel@tonic-gate * wait_thread will stop the instance. 20917c478bd9Sstevel@tonic-gate */ 20927c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, 20937c478bd9Sstevel@tonic-gate "%s: ignoring contract event on wait-style service\n", 20947c478bd9Sstevel@tonic-gate fmri); 20957c478bd9Sstevel@tonic-gate } else { 20967c478bd9Sstevel@tonic-gate /* 20977c478bd9Sstevel@tonic-gate * A CT_PR_EV_EMPTY event is an RSTOP_EXIT request. 20987c478bd9Sstevel@tonic-gate */ 20997c478bd9Sstevel@tonic-gate switch (type) { 21007c478bd9Sstevel@tonic-gate case CT_PR_EV_EMPTY: 21017c478bd9Sstevel@tonic-gate (void) stop_instance(h, inst, RSTOP_EXIT); 21027c478bd9Sstevel@tonic-gate break; 21037c478bd9Sstevel@tonic-gate case CT_PR_EV_CORE: 21047c478bd9Sstevel@tonic-gate (void) stop_instance(h, inst, RSTOP_CORE); 21057c478bd9Sstevel@tonic-gate break; 21067c478bd9Sstevel@tonic-gate case CT_PR_EV_SIGNAL: 21077c478bd9Sstevel@tonic-gate (void) stop_instance(h, inst, RSTOP_SIGNAL); 21087c478bd9Sstevel@tonic-gate break; 21097c478bd9Sstevel@tonic-gate case CT_PR_EV_HWERR: 21107c478bd9Sstevel@tonic-gate (void) stop_instance(h, inst, RSTOP_HWERR); 21117c478bd9Sstevel@tonic-gate break; 21127c478bd9Sstevel@tonic-gate } 21137c478bd9Sstevel@tonic-gate } 21147c478bd9Sstevel@tonic-gate } 21157c478bd9Sstevel@tonic-gate 21167c478bd9Sstevel@tonic-gate /* 21177c478bd9Sstevel@tonic-gate * void *restarter_contract_event_thread(void *) 21187c478bd9Sstevel@tonic-gate * Listens to the process contract bundle for critical events, taking action 21197c478bd9Sstevel@tonic-gate * on events from contracts we know we are responsible for. 21207c478bd9Sstevel@tonic-gate */ 21217c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 21227c478bd9Sstevel@tonic-gate static void * 21237c478bd9Sstevel@tonic-gate restarter_contracts_event_thread(void *unused) 21247c478bd9Sstevel@tonic-gate { 21257c478bd9Sstevel@tonic-gate int fd, err; 21267c478bd9Sstevel@tonic-gate scf_handle_t *local_handle; 21277c478bd9Sstevel@tonic-gate 21287c478bd9Sstevel@tonic-gate /* 21297c478bd9Sstevel@tonic-gate * Await graph load completion. That is, stop here, until we've scanned 21307c478bd9Sstevel@tonic-gate * the repository for contract - instance associations. 21317c478bd9Sstevel@tonic-gate */ 21327c478bd9Sstevel@tonic-gate MUTEX_LOCK(&st->st_load_lock); 21337c478bd9Sstevel@tonic-gate while (!(st->st_load_complete && st->st_load_instances == 0)) 21347c478bd9Sstevel@tonic-gate (void) pthread_cond_wait(&st->st_load_cv, &st->st_load_lock); 21357c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&st->st_load_lock); 21367c478bd9Sstevel@tonic-gate 21377c478bd9Sstevel@tonic-gate /* 21387c478bd9Sstevel@tonic-gate * This is a new thread, and thus, gets its own handle 21397c478bd9Sstevel@tonic-gate * to the repository. 21407c478bd9Sstevel@tonic-gate */ 21417c478bd9Sstevel@tonic-gate if ((local_handle = libscf_handle_create_bound(SCF_VERSION)) == NULL) 21427c478bd9Sstevel@tonic-gate uu_die("Unable to bind a new repository handle: %s\n", 21437c478bd9Sstevel@tonic-gate scf_strerror(scf_error())); 21447c478bd9Sstevel@tonic-gate 21457c478bd9Sstevel@tonic-gate fd = open64(CTFS_ROOT "/process/pbundle", O_RDONLY); 21467c478bd9Sstevel@tonic-gate if (fd == -1) 21477c478bd9Sstevel@tonic-gate uu_die("process bundle open failed"); 21487c478bd9Sstevel@tonic-gate 21497c478bd9Sstevel@tonic-gate /* 21507c478bd9Sstevel@tonic-gate * Make sure we get all events (including those generated by configd 21517c478bd9Sstevel@tonic-gate * before this thread was started). 21527c478bd9Sstevel@tonic-gate */ 21537c478bd9Sstevel@tonic-gate err = ct_event_reset(fd); 21547c478bd9Sstevel@tonic-gate assert(err == 0); 21557c478bd9Sstevel@tonic-gate 21567c478bd9Sstevel@tonic-gate for (;;) { 21577c478bd9Sstevel@tonic-gate int efd, sfd; 21587c478bd9Sstevel@tonic-gate ct_evthdl_t ev; 21597c478bd9Sstevel@tonic-gate uint32_t type; 21607c478bd9Sstevel@tonic-gate ctevid_t evid; 21617c478bd9Sstevel@tonic-gate ct_stathdl_t status; 21627c478bd9Sstevel@tonic-gate ctid_t ctid; 21637c478bd9Sstevel@tonic-gate restarter_inst_t *inst; 21647c478bd9Sstevel@tonic-gate uint64_t cookie; 21657c478bd9Sstevel@tonic-gate 21667c478bd9Sstevel@tonic-gate if (err = ct_event_read_critical(fd, &ev)) { 21677c478bd9Sstevel@tonic-gate log_error(LOG_WARNING, 21687c478bd9Sstevel@tonic-gate "Error reading next contract event: %s", 21697c478bd9Sstevel@tonic-gate strerror(err)); 21707c478bd9Sstevel@tonic-gate continue; 21717c478bd9Sstevel@tonic-gate } 21727c478bd9Sstevel@tonic-gate 21737c478bd9Sstevel@tonic-gate evid = ct_event_get_evid(ev); 21747c478bd9Sstevel@tonic-gate ctid = ct_event_get_ctid(ev); 21757c478bd9Sstevel@tonic-gate type = ct_event_get_type(ev); 21767c478bd9Sstevel@tonic-gate 21777c478bd9Sstevel@tonic-gate /* Fetch cookie. */ 21787c478bd9Sstevel@tonic-gate if ((sfd = contract_open(ctid, "process", "status", O_RDONLY)) 21797c478bd9Sstevel@tonic-gate < 0) { 21807c478bd9Sstevel@tonic-gate ct_event_free(ev); 21817c478bd9Sstevel@tonic-gate continue; 21827c478bd9Sstevel@tonic-gate } 21837c478bd9Sstevel@tonic-gate 21847c478bd9Sstevel@tonic-gate if (err = ct_status_read(sfd, CTD_COMMON, &status)) { 21857c478bd9Sstevel@tonic-gate log_framework(LOG_WARNING, "Could not get status for " 21867c478bd9Sstevel@tonic-gate "contract %ld: %s\n", ctid, strerror(err)); 21877c478bd9Sstevel@tonic-gate 21887c478bd9Sstevel@tonic-gate startd_close(sfd); 21897c478bd9Sstevel@tonic-gate ct_event_free(ev); 21907c478bd9Sstevel@tonic-gate continue; 21917c478bd9Sstevel@tonic-gate } 21927c478bd9Sstevel@tonic-gate 21937c478bd9Sstevel@tonic-gate cookie = ct_status_get_cookie(status); 21947c478bd9Sstevel@tonic-gate 2195dfe57350Sjeanm log_framework(LOG_DEBUG, "Received event %d for ctid %ld " 2196dfe57350Sjeanm "cookie %lld\n", type, ctid, cookie); 2197dfe57350Sjeanm 21987c478bd9Sstevel@tonic-gate ct_status_free(status); 21997c478bd9Sstevel@tonic-gate 22007c478bd9Sstevel@tonic-gate startd_close(sfd); 22017c478bd9Sstevel@tonic-gate 22027c478bd9Sstevel@tonic-gate /* 22037c478bd9Sstevel@tonic-gate * svc.configd(1M) restart handling performed by the 22047c478bd9Sstevel@tonic-gate * fork_configd_thread. We don't acknowledge, as that thread 22057c478bd9Sstevel@tonic-gate * will do so. 22067c478bd9Sstevel@tonic-gate */ 22077c478bd9Sstevel@tonic-gate if (cookie == CONFIGD_COOKIE) { 22087c478bd9Sstevel@tonic-gate ct_event_free(ev); 22097c478bd9Sstevel@tonic-gate continue; 22107c478bd9Sstevel@tonic-gate } 22117c478bd9Sstevel@tonic-gate 2212dfe57350Sjeanm inst = NULL; 2213dfe57350Sjeanm if (storing_contract != 0 && 2214dfe57350Sjeanm (inst = contract_to_inst(ctid)) == NULL) { 2215dfe57350Sjeanm /* 2216dfe57350Sjeanm * This can happen for two reasons: 2217dfe57350Sjeanm * - method_run() has not yet stored the 2218dfe57350Sjeanm * the contract into the internal hash table. 2219dfe57350Sjeanm * - we receive an EMPTY event for an abandoned 2220dfe57350Sjeanm * contract. 2221dfe57350Sjeanm * If there is any contract in the process of 2222dfe57350Sjeanm * being stored into the hash table then re-read 2223dfe57350Sjeanm * the event later. 2224dfe57350Sjeanm */ 2225dfe57350Sjeanm log_framework(LOG_DEBUG, 2226dfe57350Sjeanm "Reset event %d for unknown " 2227dfe57350Sjeanm "contract id %ld\n", type, ctid); 2228dfe57350Sjeanm 2229dfe57350Sjeanm /* don't go too fast */ 2230dfe57350Sjeanm (void) poll(NULL, 0, 100); 2231dfe57350Sjeanm 2232dfe57350Sjeanm (void) ct_event_reset(fd); 2233dfe57350Sjeanm ct_event_free(ev); 2234dfe57350Sjeanm continue; 2235dfe57350Sjeanm } 2236dfe57350Sjeanm 2237dfe57350Sjeanm /* 2238dfe57350Sjeanm * Do not call contract_to_inst() again if first 2239dfe57350Sjeanm * call succeeded. 2240dfe57350Sjeanm */ 2241dfe57350Sjeanm if (inst == NULL) 22427c478bd9Sstevel@tonic-gate inst = contract_to_inst(ctid); 22437c478bd9Sstevel@tonic-gate if (inst == NULL) { 22447c478bd9Sstevel@tonic-gate /* 22457c478bd9Sstevel@tonic-gate * This can happen if we receive an EMPTY 22467c478bd9Sstevel@tonic-gate * event for an abandoned contract. 22477c478bd9Sstevel@tonic-gate */ 22487c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, 22497c478bd9Sstevel@tonic-gate "Received event %d for unknown contract id " 22507c478bd9Sstevel@tonic-gate "%ld\n", type, ctid); 22517c478bd9Sstevel@tonic-gate } else { 22527c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, 22537c478bd9Sstevel@tonic-gate "Received event %d for contract id " 22547c478bd9Sstevel@tonic-gate "%ld (%s)\n", type, ctid, 22557c478bd9Sstevel@tonic-gate inst->ri_i.i_fmri); 22567c478bd9Sstevel@tonic-gate 22577c478bd9Sstevel@tonic-gate contract_action(local_handle, inst, ctid, type); 22587c478bd9Sstevel@tonic-gate 22597c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&inst->ri_lock); 22607c478bd9Sstevel@tonic-gate } 22617c478bd9Sstevel@tonic-gate 22627c478bd9Sstevel@tonic-gate efd = contract_open(ct_event_get_ctid(ev), "process", "ctl", 22637c478bd9Sstevel@tonic-gate O_WRONLY); 22647c478bd9Sstevel@tonic-gate if (efd != -1) { 22657c478bd9Sstevel@tonic-gate (void) ct_ctl_ack(efd, evid); 22667c478bd9Sstevel@tonic-gate startd_close(efd); 22677c478bd9Sstevel@tonic-gate } 22687c478bd9Sstevel@tonic-gate 22697c478bd9Sstevel@tonic-gate ct_event_free(ev); 22707c478bd9Sstevel@tonic-gate 22717c478bd9Sstevel@tonic-gate } 22727c478bd9Sstevel@tonic-gate 22737c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 22747c478bd9Sstevel@tonic-gate return (NULL); 22757c478bd9Sstevel@tonic-gate } 22767c478bd9Sstevel@tonic-gate 22777c478bd9Sstevel@tonic-gate /* 22787c478bd9Sstevel@tonic-gate * Timeout queue, processed by restarter_timeouts_event_thread(). 22797c478bd9Sstevel@tonic-gate */ 22807c478bd9Sstevel@tonic-gate timeout_queue_t *timeouts; 22817c478bd9Sstevel@tonic-gate static uu_list_pool_t *timeout_pool; 22827c478bd9Sstevel@tonic-gate 22837c478bd9Sstevel@tonic-gate typedef struct timeout_update { 22847c478bd9Sstevel@tonic-gate pthread_mutex_t tu_lock; 22857c478bd9Sstevel@tonic-gate pthread_cond_t tu_cv; 22867c478bd9Sstevel@tonic-gate int tu_wakeup; 22877c478bd9Sstevel@tonic-gate } timeout_update_t; 22887c478bd9Sstevel@tonic-gate 22897c478bd9Sstevel@tonic-gate timeout_update_t *tu; 22907c478bd9Sstevel@tonic-gate 22917c478bd9Sstevel@tonic-gate static const char *timeout_ovr_svcs[] = { 22927c478bd9Sstevel@tonic-gate "svc:/system/manifest-import:default", 22937c478bd9Sstevel@tonic-gate "svc:/network/initial:default", 22947c478bd9Sstevel@tonic-gate "svc:/network/service:default", 22957c478bd9Sstevel@tonic-gate "svc:/system/rmtmpfiles:default", 22967c478bd9Sstevel@tonic-gate "svc:/network/loopback:default", 22977c478bd9Sstevel@tonic-gate "svc:/network/physical:default", 22987c478bd9Sstevel@tonic-gate "svc:/system/device/local:default", 22997c478bd9Sstevel@tonic-gate "svc:/system/metainit:default", 23007c478bd9Sstevel@tonic-gate "svc:/system/filesystem/usr:default", 23017c478bd9Sstevel@tonic-gate "svc:/system/filesystem/minimal:default", 23027c478bd9Sstevel@tonic-gate "svc:/system/filesystem/local:default", 23037c478bd9Sstevel@tonic-gate NULL 23047c478bd9Sstevel@tonic-gate }; 23057c478bd9Sstevel@tonic-gate 23067c478bd9Sstevel@tonic-gate int 23077c478bd9Sstevel@tonic-gate is_timeout_ovr(restarter_inst_t *inst) 23087c478bd9Sstevel@tonic-gate { 23097c478bd9Sstevel@tonic-gate int i; 23107c478bd9Sstevel@tonic-gate 23117c478bd9Sstevel@tonic-gate for (i = 0; timeout_ovr_svcs[i] != NULL; ++i) { 23127c478bd9Sstevel@tonic-gate if (strcmp(inst->ri_i.i_fmri, timeout_ovr_svcs[i]) == 0) { 23137c478bd9Sstevel@tonic-gate log_instance(inst, B_TRUE, "Timeout override by " 23145ca87c7fSlianep "svc.startd. Using infinite timeout."); 23157c478bd9Sstevel@tonic-gate return (1); 23167c478bd9Sstevel@tonic-gate } 23177c478bd9Sstevel@tonic-gate } 23187c478bd9Sstevel@tonic-gate 23197c478bd9Sstevel@tonic-gate return (0); 23207c478bd9Sstevel@tonic-gate } 23217c478bd9Sstevel@tonic-gate 23227c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 23237c478bd9Sstevel@tonic-gate static int 23247c478bd9Sstevel@tonic-gate timeout_compare(const void *lc_arg, const void *rc_arg, void *private) 23257c478bd9Sstevel@tonic-gate { 23267c478bd9Sstevel@tonic-gate hrtime_t t1 = ((const timeout_entry_t *)lc_arg)->te_timeout; 23277c478bd9Sstevel@tonic-gate hrtime_t t2 = ((const timeout_entry_t *)rc_arg)->te_timeout; 23287c478bd9Sstevel@tonic-gate 23297c478bd9Sstevel@tonic-gate if (t1 > t2) 23307c478bd9Sstevel@tonic-gate return (1); 23317c478bd9Sstevel@tonic-gate else if (t1 < t2) 23327c478bd9Sstevel@tonic-gate return (-1); 23337c478bd9Sstevel@tonic-gate return (0); 23347c478bd9Sstevel@tonic-gate } 23357c478bd9Sstevel@tonic-gate 23367c478bd9Sstevel@tonic-gate void 23377c478bd9Sstevel@tonic-gate timeout_init() 23387c478bd9Sstevel@tonic-gate { 23397c478bd9Sstevel@tonic-gate timeouts = startd_zalloc(sizeof (timeout_queue_t)); 23407c478bd9Sstevel@tonic-gate 23417c478bd9Sstevel@tonic-gate (void) pthread_mutex_init(&timeouts->tq_lock, &mutex_attrs); 23427c478bd9Sstevel@tonic-gate 23437c478bd9Sstevel@tonic-gate timeout_pool = startd_list_pool_create("timeouts", 23447c478bd9Sstevel@tonic-gate sizeof (timeout_entry_t), offsetof(timeout_entry_t, te_link), 23457c478bd9Sstevel@tonic-gate timeout_compare, UU_LIST_POOL_DEBUG); 23467c478bd9Sstevel@tonic-gate assert(timeout_pool != NULL); 23477c478bd9Sstevel@tonic-gate 23487c478bd9Sstevel@tonic-gate timeouts->tq_list = startd_list_create(timeout_pool, 23497c478bd9Sstevel@tonic-gate timeouts, UU_LIST_SORTED); 23507c478bd9Sstevel@tonic-gate assert(timeouts->tq_list != NULL); 23517c478bd9Sstevel@tonic-gate 23527c478bd9Sstevel@tonic-gate tu = startd_zalloc(sizeof (timeout_update_t)); 23537c478bd9Sstevel@tonic-gate (void) pthread_cond_init(&tu->tu_cv, NULL); 23547c478bd9Sstevel@tonic-gate (void) pthread_mutex_init(&tu->tu_lock, &mutex_attrs); 23557c478bd9Sstevel@tonic-gate } 23567c478bd9Sstevel@tonic-gate 23577c478bd9Sstevel@tonic-gate void 23587c478bd9Sstevel@tonic-gate timeout_insert(restarter_inst_t *inst, ctid_t cid, uint64_t timeout_sec) 23597c478bd9Sstevel@tonic-gate { 23607c478bd9Sstevel@tonic-gate hrtime_t now, timeout; 23617c478bd9Sstevel@tonic-gate timeout_entry_t *entry; 23627c478bd9Sstevel@tonic-gate uu_list_index_t idx; 23637c478bd9Sstevel@tonic-gate 236453f3aea0SRoger A. Faulkner assert(MUTEX_HELD(&inst->ri_lock)); 23657c478bd9Sstevel@tonic-gate 23667c478bd9Sstevel@tonic-gate now = gethrtime(); 23677c478bd9Sstevel@tonic-gate 23687c478bd9Sstevel@tonic-gate /* 23697c478bd9Sstevel@tonic-gate * If we overflow LLONG_MAX, we're never timing out anyways, so 23707c478bd9Sstevel@tonic-gate * just return. 23717c478bd9Sstevel@tonic-gate */ 23727c478bd9Sstevel@tonic-gate if (timeout_sec >= (LLONG_MAX - now) / 1000000000LL) { 23737c478bd9Sstevel@tonic-gate log_instance(inst, B_TRUE, "timeout_seconds too large, " 23747c478bd9Sstevel@tonic-gate "treating as infinite."); 23757c478bd9Sstevel@tonic-gate return; 23767c478bd9Sstevel@tonic-gate } 23777c478bd9Sstevel@tonic-gate 23787c478bd9Sstevel@tonic-gate /* hrtime is in nanoseconds. Convert timeout_sec. */ 23797c478bd9Sstevel@tonic-gate timeout = now + (timeout_sec * 1000000000LL); 23807c478bd9Sstevel@tonic-gate 23817c478bd9Sstevel@tonic-gate entry = startd_alloc(sizeof (timeout_entry_t)); 23827c478bd9Sstevel@tonic-gate entry->te_timeout = timeout; 23837c478bd9Sstevel@tonic-gate entry->te_ctid = cid; 23847c478bd9Sstevel@tonic-gate entry->te_fmri = safe_strdup(inst->ri_i.i_fmri); 23857c478bd9Sstevel@tonic-gate entry->te_logstem = safe_strdup(inst->ri_logstem); 23867c478bd9Sstevel@tonic-gate entry->te_fired = 0; 23877c478bd9Sstevel@tonic-gate /* Insert the calculated timeout time onto the queue. */ 23887c478bd9Sstevel@tonic-gate MUTEX_LOCK(&timeouts->tq_lock); 23897c478bd9Sstevel@tonic-gate (void) uu_list_find(timeouts->tq_list, entry, NULL, &idx); 23907c478bd9Sstevel@tonic-gate uu_list_node_init(entry, &entry->te_link, timeout_pool); 23917c478bd9Sstevel@tonic-gate uu_list_insert(timeouts->tq_list, entry, idx); 23927c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&timeouts->tq_lock); 23937c478bd9Sstevel@tonic-gate 23947c478bd9Sstevel@tonic-gate assert(inst->ri_timeout == NULL); 23957c478bd9Sstevel@tonic-gate inst->ri_timeout = entry; 23967c478bd9Sstevel@tonic-gate 23977c478bd9Sstevel@tonic-gate MUTEX_LOCK(&tu->tu_lock); 23987c478bd9Sstevel@tonic-gate tu->tu_wakeup = 1; 23997c478bd9Sstevel@tonic-gate (void) pthread_cond_broadcast(&tu->tu_cv); 24007c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&tu->tu_lock); 24017c478bd9Sstevel@tonic-gate } 24027c478bd9Sstevel@tonic-gate 24037c478bd9Sstevel@tonic-gate 24047c478bd9Sstevel@tonic-gate void 24057c478bd9Sstevel@tonic-gate timeout_remove(restarter_inst_t *inst, ctid_t cid) 24067c478bd9Sstevel@tonic-gate { 240753f3aea0SRoger A. Faulkner assert(MUTEX_HELD(&inst->ri_lock)); 24087c478bd9Sstevel@tonic-gate 24097c478bd9Sstevel@tonic-gate if (inst->ri_timeout == NULL) 24107c478bd9Sstevel@tonic-gate return; 24117c478bd9Sstevel@tonic-gate 24127c478bd9Sstevel@tonic-gate assert(inst->ri_timeout->te_ctid == cid); 24137c478bd9Sstevel@tonic-gate 24147c478bd9Sstevel@tonic-gate MUTEX_LOCK(&timeouts->tq_lock); 24157c478bd9Sstevel@tonic-gate uu_list_remove(timeouts->tq_list, inst->ri_timeout); 24167c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&timeouts->tq_lock); 24177c478bd9Sstevel@tonic-gate 24187c478bd9Sstevel@tonic-gate free(inst->ri_timeout->te_fmri); 24197c478bd9Sstevel@tonic-gate free(inst->ri_timeout->te_logstem); 24207c478bd9Sstevel@tonic-gate startd_free(inst->ri_timeout, sizeof (timeout_entry_t)); 24217c478bd9Sstevel@tonic-gate inst->ri_timeout = NULL; 24227c478bd9Sstevel@tonic-gate } 24237c478bd9Sstevel@tonic-gate 24247c478bd9Sstevel@tonic-gate static int 24257c478bd9Sstevel@tonic-gate timeout_now() 24267c478bd9Sstevel@tonic-gate { 24277c478bd9Sstevel@tonic-gate timeout_entry_t *e; 24287c478bd9Sstevel@tonic-gate hrtime_t now; 24297c478bd9Sstevel@tonic-gate int ret; 24307c478bd9Sstevel@tonic-gate 24317c478bd9Sstevel@tonic-gate now = gethrtime(); 24327c478bd9Sstevel@tonic-gate 24337c478bd9Sstevel@tonic-gate /* 24347c478bd9Sstevel@tonic-gate * Walk through the (sorted) timeouts list. While the timeout 24357c478bd9Sstevel@tonic-gate * at the head of the list is <= the current time, kill the 24367c478bd9Sstevel@tonic-gate * method. 24377c478bd9Sstevel@tonic-gate */ 24387c478bd9Sstevel@tonic-gate MUTEX_LOCK(&timeouts->tq_lock); 24397c478bd9Sstevel@tonic-gate 24407c478bd9Sstevel@tonic-gate for (e = uu_list_first(timeouts->tq_list); 24417c478bd9Sstevel@tonic-gate e != NULL && e->te_timeout <= now; 24427c478bd9Sstevel@tonic-gate e = uu_list_next(timeouts->tq_list, e)) { 24437c478bd9Sstevel@tonic-gate log_framework(LOG_WARNING, "%s: Method or service exit timed " 24447c478bd9Sstevel@tonic-gate "out. Killing contract %ld.\n", e->te_fmri, e->te_ctid); 24457c478bd9Sstevel@tonic-gate log_instance_fmri(e->te_fmri, e->te_logstem, B_TRUE, 24465ca87c7fSlianep "Method or service exit timed out. Killing contract %ld.", 24477c478bd9Sstevel@tonic-gate e->te_ctid); 24487c478bd9Sstevel@tonic-gate e->te_fired = 1; 24497c478bd9Sstevel@tonic-gate (void) contract_kill(e->te_ctid, SIGKILL, e->te_fmri); 24507c478bd9Sstevel@tonic-gate } 24517c478bd9Sstevel@tonic-gate 24527c478bd9Sstevel@tonic-gate if (uu_list_numnodes(timeouts->tq_list) > 0) 24537c478bd9Sstevel@tonic-gate ret = 0; 24547c478bd9Sstevel@tonic-gate else 24557c478bd9Sstevel@tonic-gate ret = -1; 24567c478bd9Sstevel@tonic-gate 24577c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&timeouts->tq_lock); 24587c478bd9Sstevel@tonic-gate 24597c478bd9Sstevel@tonic-gate return (ret); 24607c478bd9Sstevel@tonic-gate } 24617c478bd9Sstevel@tonic-gate 24627c478bd9Sstevel@tonic-gate /* 24637c478bd9Sstevel@tonic-gate * void *restarter_timeouts_event_thread(void *) 24647c478bd9Sstevel@tonic-gate * Responsible for monitoring the method timeouts. This thread must 24657c478bd9Sstevel@tonic-gate * be started before any methods are called. 24667c478bd9Sstevel@tonic-gate */ 24677c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 24687c478bd9Sstevel@tonic-gate static void * 24697c478bd9Sstevel@tonic-gate restarter_timeouts_event_thread(void *unused) 24707c478bd9Sstevel@tonic-gate { 24717c478bd9Sstevel@tonic-gate /* 24727c478bd9Sstevel@tonic-gate * Timeouts are entered on a priority queue, which is processed by 24737c478bd9Sstevel@tonic-gate * this thread. As timeouts are specified in seconds, we'll do 24747c478bd9Sstevel@tonic-gate * the necessary processing every second, as long as the queue 24757c478bd9Sstevel@tonic-gate * is not empty. 24767c478bd9Sstevel@tonic-gate */ 24777c478bd9Sstevel@tonic-gate 24787c478bd9Sstevel@tonic-gate /*CONSTCOND*/ 24797c478bd9Sstevel@tonic-gate while (1) { 24807c478bd9Sstevel@tonic-gate /* 24817c478bd9Sstevel@tonic-gate * As long as the timeout list isn't empty, process it 24827c478bd9Sstevel@tonic-gate * every second. 24837c478bd9Sstevel@tonic-gate */ 24847c478bd9Sstevel@tonic-gate if (timeout_now() == 0) { 24857c478bd9Sstevel@tonic-gate (void) sleep(1); 24867c478bd9Sstevel@tonic-gate continue; 24877c478bd9Sstevel@tonic-gate } 24887c478bd9Sstevel@tonic-gate 24897c478bd9Sstevel@tonic-gate /* The list is empty, wait until we have more timeouts. */ 24907c478bd9Sstevel@tonic-gate MUTEX_LOCK(&tu->tu_lock); 24917c478bd9Sstevel@tonic-gate 24927c478bd9Sstevel@tonic-gate while (tu->tu_wakeup == 0) 24937c478bd9Sstevel@tonic-gate (void) pthread_cond_wait(&tu->tu_cv, &tu->tu_lock); 24947c478bd9Sstevel@tonic-gate 24957c478bd9Sstevel@tonic-gate tu->tu_wakeup = 0; 24967c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&tu->tu_lock); 24977c478bd9Sstevel@tonic-gate } 24987c478bd9Sstevel@tonic-gate 24997c478bd9Sstevel@tonic-gate return (NULL); 25007c478bd9Sstevel@tonic-gate } 25017c478bd9Sstevel@tonic-gate 25027c478bd9Sstevel@tonic-gate void 25037c478bd9Sstevel@tonic-gate restarter_start() 25047c478bd9Sstevel@tonic-gate { 25057c478bd9Sstevel@tonic-gate (void) startd_thread_create(restarter_timeouts_event_thread, NULL); 25067c478bd9Sstevel@tonic-gate (void) startd_thread_create(restarter_event_thread, NULL); 25077c478bd9Sstevel@tonic-gate (void) startd_thread_create(restarter_contracts_event_thread, NULL); 25087c478bd9Sstevel@tonic-gate (void) startd_thread_create(wait_thread, NULL); 25097c478bd9Sstevel@tonic-gate } 25107c478bd9Sstevel@tonic-gate 25117c478bd9Sstevel@tonic-gate 25127c478bd9Sstevel@tonic-gate void 25137c478bd9Sstevel@tonic-gate restarter_init() 25147c478bd9Sstevel@tonic-gate { 25157c478bd9Sstevel@tonic-gate restarter_instance_pool = startd_list_pool_create("restarter_instances", 25167c478bd9Sstevel@tonic-gate sizeof (restarter_inst_t), offsetof(restarter_inst_t, 25177c478bd9Sstevel@tonic-gate ri_link), restarter_instance_compare, UU_LIST_POOL_DEBUG); 25187c478bd9Sstevel@tonic-gate (void) memset(&instance_list, 0, sizeof (instance_list)); 25197c478bd9Sstevel@tonic-gate 25207c478bd9Sstevel@tonic-gate (void) pthread_mutex_init(&instance_list.ril_lock, &mutex_attrs); 25217c478bd9Sstevel@tonic-gate instance_list.ril_instance_list = startd_list_create( 25227c478bd9Sstevel@tonic-gate restarter_instance_pool, &instance_list, UU_LIST_SORTED); 25237c478bd9Sstevel@tonic-gate 25247c478bd9Sstevel@tonic-gate restarter_queue_pool = startd_list_pool_create( 25257c478bd9Sstevel@tonic-gate "restarter_instance_queue", sizeof (restarter_instance_qentry_t), 25267c478bd9Sstevel@tonic-gate offsetof(restarter_instance_qentry_t, riq_link), NULL, 25277c478bd9Sstevel@tonic-gate UU_LIST_POOL_DEBUG); 25287c478bd9Sstevel@tonic-gate 25297c478bd9Sstevel@tonic-gate contract_list_pool = startd_list_pool_create( 25307c478bd9Sstevel@tonic-gate "contract_list", sizeof (contract_entry_t), 25317c478bd9Sstevel@tonic-gate offsetof(contract_entry_t, ce_link), NULL, 25327c478bd9Sstevel@tonic-gate UU_LIST_POOL_DEBUG); 25337c478bd9Sstevel@tonic-gate contract_hash_init(); 25347c478bd9Sstevel@tonic-gate 25357c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, "Initialized restarter\n"); 25367c478bd9Sstevel@tonic-gate } 2537