Lines Matching defs:inst
83 * inst->ri_lock
91 * inst->ri_lock
96 * inst->ri_queue_lock
151 reset_start_times(restarter_inst_t *inst)
153 inst->ri_start_index = 0;
154 bzero(inst->ri_start_time, sizeof (inst->ri_start_time));
187 restarter_inst_t *inst;
190 inst = uu_list_find(instance_list.ril_instance_list, &id, NULL, NULL);
191 if (inst != NULL)
192 MUTEX_LOCK(&inst->ri_lock);
195 if (inst != NULL) {
196 while (inst->ri_method_thread != 0 &&
197 !pthread_equal(inst->ri_method_thread, pthread_self())) {
198 ++inst->ri_method_waiters;
199 (void) pthread_cond_wait(&inst->ri_method_cv,
200 &inst->ri_lock);
201 assert(inst->ri_method_waiters > 0);
202 --inst->ri_method_waiters;
206 return (inst);
213 restarter_inst_t *inst;
220 inst = uu_list_find(instance_list.ril_instance_list, &id, NULL, NULL);
221 if (inst != NULL)
222 MUTEX_LOCK(&inst->ri_queue_lock);
225 return (inst);
249 check_contract(restarter_inst_t *inst, boolean_t primary,
255 ctidp = primary ? &inst->ri_i.i_primary_ctid :
256 &inst->ri_i.i_transient_ctid;
290 "for %s from repository.\n", *ctidp, inst->ri_i.i_fmri);
306 * If the inst is already in the restarter list, return its id. If the inst
317 restarter_inst_t *inst;
340 inst = uu_list_find(instance_list.ril_instance_list, &id, NULL,
342 if (inst != NULL) {
349 inst = startd_zalloc(sizeof (restarter_inst_t));
350 inst->ri_utmpx_prefix = startd_alloc(max_scf_value_size);
351 inst->ri_utmpx_prefix[0] = '\0';
353 inst->ri_i.i_fmri = startd_alloc(strlen(name) + 1);
354 (void) strcpy((char *)inst->ri_i.i_fmri, name);
356 inst->ri_queue = startd_list_create(restarter_queue_pool, inst, 0);
362 inst->ri_id = (id != -1 ? id : dict_insert(name));
364 special_online_hooks_get(name, &inst->ri_pre_online_hook,
365 &inst->ri_post_online_hook, &inst->ri_post_offline_hook);
376 if (inst->ri_logstem != NULL)
377 startd_free(inst->ri_logstem, PATH_MAX);
378 if (inst->ri_common_name != NULL)
379 free(inst->ri_common_name);
380 if (inst->ri_C_common_name != NULL)
381 free(inst->ri_C_common_name);
383 inst->ri_logstem = NULL;
384 inst->ri_common_name = NULL;
385 inst->ri_C_common_name = NULL;
432 inst->ri_logstem = startd_alloc(PATH_MAX);
433 (void) snprintf(inst->ri_logstem, PATH_MAX, "%s%s", logfilebuf,
494 inst->ri_i.i_state = ps->ps_state = state;
495 inst->ri_i.i_next_state = ps->ps_state_next =
499 graph_protocol_send_event(inst->ri_i.i_fmri,
507 switch (libscf_get_startd_properties(scf_inst, snap, &inst->ri_flags,
508 &inst->ri_utmpx_prefix)) {
527 inst->ri_flags = RINST_CONTRACT;
536 &inst->ri_common_name, &inst->ri_C_common_name);
541 if (inst->ri_common_name != NULL) {
542 char *tmp = safe_strdup(inst->ri_common_name);
543 startd_free(inst->ri_common_name, max_scf_value_size);
544 inst->ri_common_name = tmp;
547 if (inst->ri_C_common_name != NULL) {
548 char *tmp = safe_strdup(inst->ri_C_common_name);
549 startd_free(inst->ri_C_common_name, max_scf_value_size);
550 inst->ri_C_common_name = tmp;
573 switch (libscf_read_method_ids(h, scf_inst, inst->ri_i.i_fmri,
574 &inst->ri_i.i_primary_ctid, &inst->ri_i.i_transient_ctid,
591 if (inst->ri_i.i_primary_ctid >= 1) {
592 contract_hash_store(inst->ri_i.i_primary_ctid, inst->ri_id);
594 switch (check_contract(inst, B_TRUE, scf_inst)) {
611 if (inst->ri_i.i_transient_ctid >= 1) {
612 switch (check_contract(inst, B_FALSE, scf_inst)) {
630 (void) pthread_mutex_init(&inst->ri_lock, &mutex_attrs);
631 (void) pthread_mutex_init(&inst->ri_queue_lock, &mutex_attrs);
632 MUTEX_LOCK(&inst->ri_lock);
633 MUTEX_LOCK(&inst->ri_queue_lock);
635 (void) pthread_cond_init(&inst->ri_method_cv, NULL);
637 uu_list_node_init(inst, &inst->ri_link, restarter_instance_pool);
638 uu_list_insert(instance_list.ril_instance_list, inst, idx);
642 (inst->ri_flags & RINST_STYLE_MASK) == RINST_WAIT) {
644 ret = wait_register(start_pid, inst->ri_i.i_fmri, 0, 1);
654 inst->ri_i.i_fmri, start_pid);
659 (void) stop_instance(h, inst, RSTOP_EXIT);
667 (void) restarter_instance_update_states(h, inst, state,
671 service_style(inst->ri_flags));
673 MUTEX_UNLOCK(&inst->ri_queue_lock);
674 MUTEX_UNLOCK(&inst->ri_lock);
696 startd_free((void *)inst->ri_i.i_fmri, strlen(inst->ri_i.i_fmri) + 1);
697 uu_list_destroy(inst->ri_queue);
698 if (inst->ri_logstem != NULL)
699 startd_free(inst->ri_logstem, PATH_MAX);
700 if (inst->ri_common_name != NULL)
701 free(inst->ri_common_name);
702 if (inst->ri_C_common_name != NULL)
703 free(inst->ri_C_common_name);
704 startd_free(inst->ri_utmpx_prefix, max_scf_value_size);
705 startd_free(inst, sizeof (restarter_inst_t));
778 instance_is_wait_style(restarter_inst_t *inst)
780 assert(MUTEX_HELD(&inst->ri_lock));
781 return ((inst->ri_flags & RINST_STYLE_MASK) == RINST_WAIT);
790 instance_is_transient_style(restarter_inst_t *inst)
792 assert(MUTEX_HELD(&inst->ri_lock));
793 return ((inst->ri_flags & RINST_STYLE_MASK) == RINST_TRANSIENT);
801 instance_in_transition(restarter_inst_t *inst)
803 assert(MUTEX_HELD(&inst->ri_lock));
804 if (inst->ri_i.i_next_state == RESTARTER_STATE_NONE)
813 instance_started(restarter_inst_t *inst)
817 assert(MUTEX_HELD(&inst->ri_lock));
819 if (inst->ri_i.i_state == RESTARTER_STATE_ONLINE ||
820 inst->ri_i.i_state == RESTARTER_STATE_DEGRADED)
912 restarter_inst_t *inst;
916 inst = inst_lookup_by_name(fmri);
917 if (inst == NULL)
920 inst->ri_flags |= flag;
922 MUTEX_UNLOCK(&inst->ri_lock);
928 restarter_inst_t *inst;
933 for (inst = uu_list_first(instance_list.ril_instance_list);
934 inst != NULL;
935 inst = uu_list_next(instance_list.ril_instance_list, inst)) {
939 MUTEX_LOCK(&inst->ri_lock);
942 * This is where we'd check inst->ri_method_thread and if it
944 * executing a method for inst. Doing so with the instance_list
949 fmri = inst->ri_i.i_fmri;
951 if (inst->ri_flags & RINST_RETAKE_RUNNING) {
962 inst->ri_flags &= ~RINST_RETAKE_RUNNING;
967 if (inst->ri_flags & RINST_RETAKE_START) {
972 inst->ri_flags &= ~RINST_RETAKE_START;
984 MUTEX_UNLOCK(&inst->ri_lock);
1024 * -1 - inst is in transition
1027 stop_instance(scf_handle_t *local_handle, restarter_inst_t *inst,
1037 assert(MUTEX_HELD(&inst->ri_lock));
1038 assert(inst->ri_method_thread == 0);
1095 if (inst->ri_i.i_state == RESTARTER_STATE_MAINT ||
1096 inst->ri_i.i_state == RESTARTER_STATE_DISABLED) {
1099 inst->ri_i.i_fmri);
1104 if (instance_started(inst) == 0) {
1106 inst->ri_i.i_fmri);
1110 if (instance_in_transition(inst)) {
1114 inst->ri_i.i_fmri);
1118 log_instance(inst, B_TRUE, "Stopping because %s.", cp);
1121 "%s: Instance stopping because %s.\n", inst->ri_i.i_fmri, cp);
1123 if (instance_is_wait_style(inst) &&
1132 inst, inst->ri_i.i_state, RESTARTER_STATE_OFFLINE, re,
1152 (void) update_fault_count(inst, FAULT_COUNT_INCR);
1153 if (method_rate_critical(inst)) {
1154 log_instance(inst, B_TRUE, "Failing too "
1159 (void) update_fault_count(inst, FAULT_COUNT_RESET);
1160 reset_start_times(inst);
1163 if (inst->ri_i.i_primary_ctid != 0) {
1164 inst->ri_m_inst =
1166 inst->ri_mi_deleted = B_FALSE;
1168 libscf_reget_instance(inst);
1169 method_remove_contract(inst, B_TRUE, B_TRUE);
1171 scf_instance_destroy(inst->ri_m_inst);
1172 inst->ri_m_inst = NULL;
1176 inst, inst->ri_i.i_next_state, RESTARTER_STATE_NONE, re,
1188 } else if (instance_is_wait_style(inst) && re == RERR_RESTART) {
1196 wait_ignore_by_fmri(inst->ri_i.i_fmri);
1211 new_state = inst->ri_i.i_enabled ?
1214 switch (err = restarter_instance_update_states(local_handle, inst,
1215 inst->ri_i.i_state, new_state, RERR_NONE, reason)) {
1226 info->sf_id = inst->ri_id;
1230 inst->ri_method_thread = startd_thread_create(method_thread, info);
1264 scf_instance_t *inst;
1316 switch (r = libscf_fmri_get_instance(h, rip->ri_i.i_fmri, &inst)) {
1335 r = restarter_remove_contract(inst, ctid, RESTARTER_CONTRACT_PRIMARY);
1352 scf_instance_destroy(inst);
1373 scf_instance_destroy(inst);
1378 * Set inst->ri_i.i_enabled. Expects 'e' to be _ENABLE, _DISABLE, or
1379 * _ADMIN_DISABLE. If the event is _ENABLE and inst is uninitialized or
1381 * _ADMIN_DISABLE, make sure inst will move to disabled.
1388 enable_inst(scf_handle_t *h, restarter_inst_t *inst,
1396 assert(MUTEX_HELD(&inst->ri_lock));
1400 assert(instance_in_transition(inst) == 0);
1402 state = inst->ri_i.i_state;
1405 inst->ri_i.i_enabled = 1;
1414 log_instance(inst, B_FALSE, "Enabled.");
1416 inst->ri_i.i_fmri);
1427 (void) restarter_instance_update_states(h, inst,
1433 inst->ri_i.i_fmri);
1436 inst->ri_i.i_enabled = 0;
1441 r = stop_instance(h, inst, RSTOP_DISABLE);
1446 if (inst->ri_i.i_primary_ctid != 0) {
1447 inst->ri_m_inst = safe_scf_instance_create(h);
1448 inst->ri_mi_deleted = B_FALSE;
1450 libscf_reget_instance(inst);
1451 method_remove_contract(inst, B_TRUE, B_TRUE);
1453 scf_instance_destroy(inst->ri_m_inst);
1456 log_instance(inst, B_FALSE, "Disabled.");
1458 inst->ri_i.i_fmri);
1469 (void) restarter_instance_update_states(h, inst,
1487 unmaintain_instance(h, inst, RUNMAINT_DISABLE);
1493 "unknown state %d.\n", inst->ri_i.i_fmri, state);
1503 start_instance(scf_handle_t *local_handle, restarter_inst_t *inst,
1509 assert(MUTEX_HELD(&inst->ri_lock));
1510 assert(instance_in_transition(inst) == 0);
1511 assert(inst->ri_method_thread == 0);
1514 inst->ri_i.i_fmri);
1529 if (inst->ri_i.i_state == RESTARTER_STATE_MAINT ||
1530 inst->ri_i.i_state == RESTARTER_STATE_DISABLED ||
1531 inst->ri_i.i_enabled == 0) {
1534 inst->ri_i.i_fmri);
1539 if (instance_started(inst) == 1) {
1542 inst->ri_i.i_fmri);
1546 log_framework(LOG_DEBUG, "%s: starting instance.\n", inst->ri_i.i_fmri);
1548 (void) restarter_instance_update_states(local_handle, inst,
1549 inst->ri_i.i_state, RESTARTER_STATE_ONLINE, RERR_NONE, new_reason);
1553 info->sf_id = inst->ri_id;
1557 inst->ri_method_thread = startd_thread_create(method_thread, info);
1563 scf_instance_t *inst;
1566 if (libscf_fmri_get_instance(h, rip->ri_i.i_fmri, &inst))
1569 ret = restarter_inst_ractions_from_tty(inst);
1571 scf_instance_destroy(inst);
1578 scf_instance_t *inst;
1581 if (libscf_fmri_get_instance(h, rip->ri_i.i_fmri, &inst))
1584 if (restarter_inst_dump(inst) == 1)
1587 scf_instance_destroy(inst);
1673 scf_instance_t *inst;
1685 r = libscf_fmri_get_instance(h, rip->ri_i.i_fmri, &inst);
1704 snap = libscf_get_running_snapshot(inst);
1706 r = libscf_get_startd_properties(inst, snap, &rip->ri_flags,
1715 scf_instance_destroy(inst);
1747 scf_instance_destroy(inst);
1786 restarter_inst_t *inst;
1792 * Grab the inst lock -- this waits until any outstanding
1795 inst = inst_lookup_by_name(fmri);
1796 if (inst == NULL) {
1801 assert(instance_in_transition(inst) == 0);
1807 (void) enable_inst(h, inst, event);
1811 if (enable_inst(h, inst, event) == 0)
1812 reset_start_times(inst);
1816 restarter_delete_inst(inst);
1817 inst = NULL;
1821 reset_start_times(inst);
1824 (void) stop_instance(h, inst, RSTOP_DEPENDENCY);
1828 start_instance(h, inst, event->riq_reason);
1832 maintain_instance(h, inst, 0,
1837 maintain_instance(h, inst, 0,
1842 if (event_from_tty(h, inst) == 0)
1843 maintain_instance(h, inst, 0,
1846 maintain_instance(h, inst, 0,
1851 if (event_from_tty(h, inst) == 0)
1852 maintain_instance(h, inst, 1,
1855 maintain_instance(h, inst, 1,
1860 unmaintain_instance(h, inst, RUNMAINT_CLEAR);
1861 reset_start_times(inst);
1865 refresh_instance(h, inst);
1871 event_names[event->riq_type], inst->ri_i.i_fmri);
1875 if (!instance_started(inst)) {
1878 inst->ri_i.i_fmri);
1884 if (restart_dump(h, inst)) {
1886 inst->ri_i.i_primary_ctid, SIGABRT,
1887 inst->ri_i.i_fmri);
1888 } else if (stop_instance(h, inst,
1890 reset_start_times(inst);
1904 assert(inst != NULL);
1905 MUTEX_UNLOCK(&inst->ri_lock);
2100 restarter_inst_t *inst;
2107 inst = inst_lookup_by_id(id);
2108 if (inst != NULL) {
2115 if (ctid != inst->ri_i.i_primary_ctid) {
2116 MUTEX_UNLOCK(&inst->ri_lock);
2117 inst = NULL;
2120 return (inst);
2128 contract_action(scf_handle_t *h, restarter_inst_t *inst, ctid_t id,
2131 const char *fmri = inst->ri_i.i_fmri;
2133 assert(MUTEX_HELD(&inst->ri_lock));
2139 if (inst->ri_i.i_primary_ctid > 0 &&
2140 inst->ri_i.i_primary_ctid_stopped)
2155 assert(instance_in_transition(inst) == 0);
2157 if (instance_is_wait_style(inst)) {
2172 (void) stop_instance(h, inst, RSTOP_EXIT);
2175 (void) stop_instance(h, inst, RSTOP_CORE);
2178 (void) stop_instance(h, inst, RSTOP_SIGNAL);
2181 (void) stop_instance(h, inst, RSTOP_HWERR);
2234 restarter_inst_t *inst;
2283 inst = NULL;
2285 (inst = contract_to_inst(ctid)) == NULL) {
2312 if (inst == NULL)
2313 inst = contract_to_inst(ctid);
2314 if (inst == NULL) {
2326 inst->ri_i.i_fmri);
2328 contract_action(local_handle, inst, ctid, type);
2330 MUTEX_UNLOCK(&inst->ri_lock);
2378 is_timeout_ovr(restarter_inst_t *inst)
2383 if (strcmp(inst->ri_i.i_fmri, timeout_ovr_svcs[i]) == 0) {
2384 log_instance(inst, B_TRUE, "Timeout override by "
2429 timeout_insert(restarter_inst_t *inst, ctid_t cid, uint64_t timeout_sec)
2435 assert(MUTEX_HELD(&inst->ri_lock));
2444 log_instance(inst, B_TRUE, "timeout_seconds too large, "
2455 entry->te_fmri = safe_strdup(inst->ri_i.i_fmri);
2456 entry->te_logstem = safe_strdup(inst->ri_logstem);
2465 assert(inst->ri_timeout == NULL);
2466 inst->ri_timeout = entry;
2476 timeout_remove(restarter_inst_t *inst, ctid_t cid)
2478 assert(MUTEX_HELD(&inst->ri_lock));
2480 if (inst->ri_timeout == NULL)
2483 assert(inst->ri_timeout->te_ctid == cid);
2486 uu_list_remove(timeouts->tq_list, inst->ri_timeout);
2489 free(inst->ri_timeout->te_fmri);
2490 free(inst->ri_timeout->te_logstem);
2491 startd_free(inst->ri_timeout, sizeof (timeout_entry_t));
2492 inst->ri_timeout = NULL;