1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 23 /* 24 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 25 * Use is subject to license terms. 26 */ 27 28 #pragma ident "%Z%%M% %I% %E% SMI" 29 30 /* 31 * FMD Control Event Subsystem 32 * 33 * This file provides a simple and extensible subsystem for the processing of 34 * synchronous control events that can be received from the event transport 35 * and used to control the behavior of the fault manager itself. At present 36 * this feature is used for the implementation of simulation controls such as 37 * advancing the simulated clock using events sent by the fminject utility. 38 * Control events are assigned a class of the form "resource.fm.fmd.*" and 39 * are assigned a callback function defined in the _fmd_ctls[] table below. 40 * As control events are received by the event transport, they are assigned a 41 * special event type (ev_type = FMD_EVT_CTL) and the ev_data member is used 42 * to refer to a fmd_ctl_t data structure, managed by the functions below. 43 * 44 * Control events are implemented so that they are synchronous with respect to 45 * the rest of the fault manager event stream, which is usually asynchronous 46 * (that is, the transport dispatch thread and the module receive threads all 47 * execute in parallel). Synchronous processing is required for control events 48 * so that they can affect global state (e.g. the simulated clock) and ensure 49 * that the results of any state changes are seen by *all* subsequent events. 50 * 51 * To achieve synchronization, the event itself implements a thread barrier: 52 * the fmd_ctl_t maintains a reference count that mirrors the fmd_event_t 53 * reference count (which for ctls counts the number of modules the event 54 * was dispatched to). As each module receive thread dequeues the event, it 55 * calls fmd_event_rele() to discard the event, which calls fmd_ctl_rele(). 56 * fmd_ctl_rele() decrements the ctl's reference count but blocks there waiting 57 * for *all* other references to be released. When all threads have reached 58 * the barrier, the final caller of fmd_ctl_rele() executes the control event 59 * callback function and then wakes everyone else up. The transport dispatch 60 * thread, blocked in fmd_modhash_dispatch(), is typically this final caller. 61 */ 62 63 #include <strings.h> 64 #include <limits.h> 65 #include <signal.h> 66 67 #include <fmd_protocol.h> 68 #include <fmd_alloc.h> 69 #include <fmd_error.h> 70 #include <fmd_subr.h> 71 #include <fmd_time.h> 72 #include <fmd_module.h> 73 #include <fmd_thread.h> 74 #include <fmd_ctl.h> 75 76 #include <fmd.h> 77 78 static void 79 fmd_ctl_addhrt(nvlist_t *nvl) 80 { 81 int64_t delta = 0; 82 83 (void) nvlist_lookup_int64(nvl, FMD_CTL_ADDHRT_DELTA, &delta); 84 fmd_time_addhrtime(delta); 85 86 /* 87 * If the non-adjustable clock has reached the apocalypse, fmd(1M) 88 * should exit gracefully: queue a SIGTERM for the main thread. 89 */ 90 if (fmd_time_gethrtime() == INT64_MAX) 91 (void) pthread_kill(fmd.d_rmod->mod_thread->thr_tid, SIGTERM); 92 } 93 94 static void 95 fmd_ctl_inval(nvlist_t *nvl) 96 { 97 char *class = "<unknown>"; 98 99 (void) nvlist_lookup_string(nvl, FM_CLASS, &class); 100 fmd_error(EFMD_CTL_INVAL, "ignoring invalid control event %s\n", class); 101 } 102 103 /*ARGSUSED*/ 104 static void 105 fmd_ctl_pause(nvlist_t *nvl) 106 { 107 fmd_dprintf(FMD_DBG_DISP, "unpausing modules from ctl barrier\n"); 108 } 109 110 static const fmd_ctl_desc_t _fmd_ctls[] = { 111 { FMD_CTL_ADDHRT, FMD_CTL_ADDHRT_VERS1, fmd_ctl_addhrt }, 112 { NULL, UINT_MAX, fmd_ctl_inval } 113 }; 114 115 fmd_ctl_t * 116 fmd_ctl_init(nvlist_t *nvl) 117 { 118 fmd_ctl_t *cp = fmd_alloc(sizeof (fmd_ctl_t), FMD_SLEEP); 119 120 const fmd_ctl_desc_t *dp; 121 uint8_t vers; 122 char *class; 123 124 (void) pthread_mutex_init(&cp->ctl_lock, NULL); 125 (void) pthread_cond_init(&cp->ctl_cv, NULL); 126 127 cp->ctl_nvl = nvl; 128 cp->ctl_refs = 0; 129 130 if (nvl == NULL) { 131 cp->ctl_func = fmd_ctl_pause; 132 return (cp); 133 } 134 135 if (nvlist_lookup_string(nvl, FM_CLASS, &class) != 0 || 136 nvlist_lookup_uint8(nvl, FM_VERSION, &vers) != 0) 137 fmd_panic("ctl_init called with bad nvlist %p", (void *)nvl); 138 139 for (dp = _fmd_ctls; dp->cde_class != NULL; dp++) { 140 if (strcmp(class, dp->cde_class) == 0) 141 break; 142 } 143 144 cp->ctl_func = vers > dp->cde_vers ? &fmd_ctl_inval : dp->cde_func; 145 return (cp); 146 } 147 148 void 149 fmd_ctl_fini(fmd_ctl_t *cp) 150 { 151 fmd_free(cp, sizeof (fmd_ctl_t)); 152 } 153 154 /* 155 * Increment the ref count on the fmd_ctl_t to correspond to a reference to the 156 * fmd_event_t. This count is used to implement a barrier in fmd_ctl_rele(). 157 */ 158 void 159 fmd_ctl_hold(fmd_ctl_t *cp) 160 { 161 (void) pthread_mutex_lock(&cp->ctl_lock); 162 163 cp->ctl_refs++; 164 ASSERT(cp->ctl_refs != 0); 165 166 (void) pthread_mutex_unlock(&cp->ctl_lock); 167 } 168 169 /* 170 * Decrement the reference count on the fmd_ctl_t. If this rele() is the last 171 * one, then execute the callback function and release all the other callers. 172 * Otherwise enter a loop waiting on ctl_cv for other threads to call rele(). 173 */ 174 void 175 fmd_ctl_rele(fmd_ctl_t *cp) 176 { 177 (void) pthread_mutex_lock(&cp->ctl_lock); 178 179 ASSERT(cp->ctl_refs != 0); 180 cp->ctl_refs--; 181 182 if (cp->ctl_refs == 0) { 183 cp->ctl_func(cp->ctl_nvl); 184 (void) pthread_cond_broadcast(&cp->ctl_cv); 185 } else { 186 while (cp->ctl_refs != 0) 187 (void) pthread_cond_wait(&cp->ctl_cv, &cp->ctl_lock); 188 } 189 190 (void) pthread_mutex_unlock(&cp->ctl_lock); 191 } 192