Print this page
7281 mdnsd needs to try harder to send goodbye requests
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/svc/startd/transition.c
+++ new/usr/src/cmd/svc/startd/transition.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
|
↓ open down ↓ |
13 lines elided |
↑ open up ↑ |
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 23 * Use is subject to license terms.
24 + *
25 + * Copyright 2016 RackTop Systems.
24 26 */
25 27
26 28
27 29 /*
28 30 * transition.c - Graph State Machine
29 31 *
30 32 * The graph state machine is implemented here, with a typical approach
31 33 * of a function per state. Separating the implementation allows more
32 34 * clarity into the actions taken on notification of state change, as well
33 35 * as a place for future expansion including hooks for configurable actions.
34 36 * All functions are called with dgraph_lock held.
35 37 *
36 38 * The start action for this state machine is not explicit. The states
37 39 * (ONLINE and DEGRADED) which need to know when they're entering the state
38 40 * due to a daemon restart implement this understanding by checking for
39 41 * transition from uninitialized. In the future, this would likely be better
40 42 * as an explicit start action instead of relying on an overloaded transition.
41 43 *
42 44 * All gt_enter functions use the same set of return codes.
43 45 * 0 success
44 46 * ECONNABORTED repository connection aborted
45 47 */
46 48
47 49 #include "startd.h"
48 50
49 51 static int
50 52 gt_running(restarter_instance_state_t state)
51 53 {
52 54 if (state == RESTARTER_STATE_ONLINE ||
53 55 state == RESTARTER_STATE_DEGRADED)
54 56 return (1);
55 57
56 58 return (0);
57 59 }
58 60
59 61 static int
60 62 gt_enter_uninit(scf_handle_t *h, graph_vertex_t *v,
61 63 restarter_instance_state_t old_state, restarter_error_t rerr)
62 64 {
63 65 int err;
64 66 scf_instance_t *inst;
65 67
66 68 /* Initialize instance by refreshing it. */
67 69
68 70 err = libscf_fmri_get_instance(h, v->gv_name, &inst);
69 71 switch (err) {
70 72 case 0:
71 73 break;
72 74
73 75 case ECONNABORTED:
74 76 return (ECONNABORTED);
75 77
76 78 case ENOENT:
77 79 return (0);
78 80
79 81 case EINVAL:
80 82 case ENOTSUP:
81 83 default:
82 84 bad_error("libscf_fmri_get_instance", err);
83 85 }
84 86
85 87 err = refresh_vertex(v, inst);
86 88 if (err == 0)
87 89 graph_enable_by_vertex(v, v->gv_flags & GV_ENABLED, 0);
88 90
89 91 scf_instance_destroy(inst);
90 92
91 93 /* If the service was running, propagate a stop event. */
92 94 if (gt_running(old_state)) {
93 95 log_framework(LOG_DEBUG, "Propagating stop of %s.\n",
94 96 v->gv_name);
95 97
96 98 graph_transition_propagate(v, PROPAGATE_STOP, rerr);
97 99 }
98 100
99 101 graph_transition_sulogin(RESTARTER_STATE_UNINIT, old_state);
100 102 return (0);
101 103 }
102 104
103 105 /* ARGSUSED */
104 106 static int
105 107 gt_enter_maint(scf_handle_t *h, graph_vertex_t *v,
106 108 restarter_instance_state_t old_state, restarter_error_t rerr)
107 109 {
108 110 int to_offline = v->gv_flags & GV_TOOFFLINE;
109 111
110 112 /*
111 113 * If the service was running, propagate a stop event. If the
112 114 * service was not running the maintenance transition may satisfy
113 115 * optional dependencies and should be propagated to determine
114 116 * whether new dependents are satisfiable.
115 117 * Instances that transition to maintenance and have the GV_TOOFFLINE
116 118 * flag are special because they can expose new subtree leaves so
117 119 * propagate the offline to the instance dependencies.
118 120 */
119 121
120 122 /* instance transitioning to maintenance is considered disabled */
121 123 v->gv_flags &= ~GV_TODISABLE;
122 124 v->gv_flags &= ~GV_TOOFFLINE;
123 125
124 126 if (gt_running(old_state)) {
125 127 /*
126 128 * Handle state change during instance disabling.
127 129 * Propagate offline to the new exposed leaves.
128 130 */
129 131 if (to_offline) {
|
↓ open down ↓ |
96 lines elided |
↑ open up ↑ |
130 132 log_framework(LOG_DEBUG, "%s removed from subtree\n",
131 133 v->gv_name);
132 134
133 135 graph_offline_subtree_leaves(v, (void *)h);
134 136 }
135 137
136 138 log_framework(LOG_DEBUG, "Propagating maintenance (stop) of "
137 139 "%s.\n", v->gv_name);
138 140
139 141 graph_transition_propagate(v, PROPAGATE_STOP, rerr);
142 +
143 + /*
144 + * The maintenance transition may satisfy optional_all/restart
145 + * dependencies and should be propagated to determine
146 + * whether new dependents are satisfiable.
147 + */
148 + graph_transition_propagate(v, PROPAGATE_SAT, rerr);
140 149 } else {
141 150 log_framework(LOG_DEBUG, "Propagating maintenance of %s.\n",
142 151 v->gv_name);
143 152
144 153 graph_transition_propagate(v, PROPAGATE_SAT, rerr);
145 154 }
146 155
147 156 graph_transition_sulogin(RESTARTER_STATE_MAINT, old_state);
148 157 return (0);
149 158 }
150 159
151 160 /* ARGSUSED */
152 161 static int
153 162 gt_enter_offline(scf_handle_t *h, graph_vertex_t *v,
154 163 restarter_instance_state_t old_state, restarter_error_t rerr)
155 164 {
156 165 int to_offline = v->gv_flags & GV_TOOFFLINE;
157 166
158 167 v->gv_flags &= ~GV_TOOFFLINE;
159 168
160 169 /*
161 170 * If the instance should be enabled, see if we can start it.
162 171 * Otherwise send a disable command.
163 172 * If a instance has the GV_TOOFFLINE flag set then it must
164 173 * remains offline until the disable process completes.
165 174 */
166 175 if (v->gv_flags & GV_ENABLED) {
167 176 if (to_offline == 0)
168 177 graph_start_if_satisfied(v);
169 178 } else {
170 179 if (gt_running(old_state) && v->gv_post_disable_f)
171 180 v->gv_post_disable_f();
172 181
173 182 vertex_send_event(v, RESTARTER_EVENT_TYPE_DISABLE);
174 183 }
175 184
176 185 /*
177 186 * If the service was running, propagate a stop event. If the
178 187 * service was not running the offline transition may satisfy
179 188 * optional dependencies and should be propagated to determine
180 189 * whether new dependents are satisfiable.
181 190 * Instances that transition to offline and have the GV_TOOFFLINE flag
182 191 * are special because they can expose new subtree leaves so propagate
183 192 * the offline to the instance dependencies.
184 193 */
185 194 if (gt_running(old_state)) {
186 195 /*
187 196 * Handle state change during instance disabling.
188 197 * Propagate offline to the new exposed leaves.
189 198 */
190 199 if (to_offline) {
191 200 log_framework(LOG_DEBUG, "%s removed from subtree\n",
192 201 v->gv_name);
193 202
194 203 graph_offline_subtree_leaves(v, (void *)h);
195 204 }
196 205
197 206 log_framework(LOG_DEBUG, "Propagating stop of %s.\n",
198 207 v->gv_name);
199 208
200 209 graph_transition_propagate(v, PROPAGATE_STOP, rerr);
201 210
202 211 /*
203 212 * The offline transition may satisfy require_any/restart
204 213 * dependencies and should be propagated to determine
205 214 * whether new dependents are satisfiable.
206 215 */
207 216 graph_transition_propagate(v, PROPAGATE_SAT, rerr);
208 217 } else {
209 218 log_framework(LOG_DEBUG, "Propagating offline of %s.\n",
210 219 v->gv_name);
211 220
212 221 graph_transition_propagate(v, PROPAGATE_SAT, rerr);
213 222 }
214 223
215 224 graph_transition_sulogin(RESTARTER_STATE_OFFLINE, old_state);
216 225 return (0);
217 226 }
218 227
219 228 /* ARGSUSED */
220 229 static int
221 230 gt_enter_disabled(scf_handle_t *h, graph_vertex_t *v,
222 231 restarter_instance_state_t old_state, restarter_error_t rerr)
223 232 {
224 233 int to_offline = v->gv_flags & GV_TOOFFLINE;
225 234
226 235 v->gv_flags &= ~GV_TODISABLE;
227 236 v->gv_flags &= ~GV_TOOFFLINE;
228 237
229 238 /*
230 239 * If the instance should be disabled, no problem. Otherwise,
231 240 * send an enable command, which should result in the instance
232 241 * moving to OFFLINE unless the instance is part of a subtree
233 242 * (non root) and in this case the result is unpredictable.
234 243 */
235 244 if (v->gv_flags & GV_ENABLED) {
236 245 vertex_send_event(v, RESTARTER_EVENT_TYPE_ENABLE);
237 246 } else if (gt_running(old_state) && v->gv_post_disable_f) {
238 247 v->gv_post_disable_f();
239 248 }
240 249
241 250 /*
242 251 * If the service was running, propagate this as a stop. If the
243 252 * service was not running the disabled transition may satisfy
244 253 * optional dependencies and should be propagated to determine
245 254 * whether new dependents are satisfiable.
246 255 */
247 256 if (gt_running(old_state)) {
248 257 /*
249 258 * We need to propagate the offline to new exposed leaves in
250 259 * case we've just disabled an instance that was part of a
251 260 * subtree.
252 261 */
253 262 if (to_offline) {
254 263 log_framework(LOG_DEBUG, "%s removed from subtree\n",
255 264 v->gv_name);
256 265
257 266 /*
258 267 * Handle state change during instance disabling.
259 268 * Propagate offline to the new exposed leaves.
|
↓ open down ↓ |
110 lines elided |
↑ open up ↑ |
260 269 */
261 270 graph_offline_subtree_leaves(v, (void *)h);
262 271 }
263 272
264 273
265 274 log_framework(LOG_DEBUG, "Propagating stop of %s.\n",
266 275 v->gv_name);
267 276
268 277 graph_transition_propagate(v, PROPAGATE_STOP, rerr);
269 278
279 + /*
280 + * The disable transition may satisfy optional_all/restart
281 + * dependencies and should be propagated to determine
282 + * whether new dependents are satisfiable.
283 + */
284 + graph_transition_propagate(v, PROPAGATE_SAT, rerr);
270 285 } else {
271 286 log_framework(LOG_DEBUG, "Propagating disable of %s.\n",
272 287 v->gv_name);
273 288
274 289 graph_transition_propagate(v, PROPAGATE_SAT, rerr);
275 290 }
276 291
277 292 graph_transition_sulogin(RESTARTER_STATE_DISABLED, old_state);
278 293 return (0);
279 294 }
280 295
281 296 static int
282 297 gt_internal_online_or_degraded(scf_handle_t *h, graph_vertex_t *v,
283 298 restarter_instance_state_t old_state, restarter_error_t rerr)
284 299 {
285 300 int r;
286 301
287 302 /*
288 303 * If the instance has just come up, update the start
289 304 * snapshot.
290 305 */
291 306 if (gt_running(old_state) == 0) {
292 307 /*
293 308 * Don't fire if we're just recovering state
294 309 * after a restart.
295 310 */
296 311 if (old_state != RESTARTER_STATE_UNINIT &&
297 312 v->gv_post_online_f)
298 313 v->gv_post_online_f();
299 314
300 315 r = libscf_snapshots_poststart(h, v->gv_name, B_TRUE);
301 316 switch (r) {
302 317 case 0:
303 318 case ENOENT:
304 319 /*
305 320 * If ENOENT, the instance must have been
306 321 * deleted. Pretend we were successful since
307 322 * we should get a delete event later.
308 323 */
309 324 break;
310 325
311 326 case ECONNABORTED:
312 327 return (ECONNABORTED);
313 328
314 329 case EACCES:
315 330 case ENOTSUP:
316 331 default:
317 332 bad_error("libscf_snapshots_poststart", r);
318 333 }
319 334 }
320 335
321 336 if (!(v->gv_flags & GV_ENABLED)) {
322 337 vertex_send_event(v, RESTARTER_EVENT_TYPE_DISABLE);
323 338 } else if (v->gv_flags & GV_TOOFFLINE) {
324 339 /*
325 340 * If the vertex has the GV_TOOFFLINE flag set then that's
326 341 * because the instance was transitioning from offline to
327 342 * online and the reverse disable algorithm doesn't offline
328 343 * those instances because it was already appearing offline.
329 344 * So do it now.
330 345 */
331 346 offline_vertex(v);
332 347 }
333 348
334 349 if (gt_running(old_state) == 0) {
335 350 log_framework(LOG_DEBUG, "Propagating start of %s.\n",
336 351 v->gv_name);
337 352
338 353 graph_transition_propagate(v, PROPAGATE_START, rerr);
339 354 } else if (rerr == RERR_REFRESH) {
340 355 /* For refresh we'll get a message sans state change */
341 356
342 357 log_framework(LOG_DEBUG, "Propagating refresh of %s.\n",
343 358 v->gv_name);
344 359
345 360 graph_transition_propagate(v, PROPAGATE_STOP, rerr);
346 361 }
347 362
348 363 return (0);
349 364 }
350 365
351 366 static int
352 367 gt_enter_online(scf_handle_t *h, graph_vertex_t *v,
353 368 restarter_instance_state_t old_state, restarter_error_t rerr)
354 369 {
355 370 int r;
356 371
357 372 r = gt_internal_online_or_degraded(h, v, old_state, rerr);
358 373 if (r != 0)
359 374 return (r);
360 375
361 376 graph_transition_sulogin(RESTARTER_STATE_ONLINE, old_state);
362 377 return (0);
363 378 }
364 379
365 380 static int
366 381 gt_enter_degraded(scf_handle_t *h, graph_vertex_t *v,
367 382 restarter_instance_state_t old_state, restarter_error_t rerr)
368 383 {
369 384 int r;
370 385
371 386 r = gt_internal_online_or_degraded(h, v, old_state, rerr);
372 387 if (r != 0)
373 388 return (r);
374 389
375 390 graph_transition_sulogin(RESTARTER_STATE_DEGRADED, old_state);
376 391 return (0);
377 392 }
378 393
379 394 /*
380 395 * gt_transition() implements the state transition for the graph
381 396 * state machine. It can return:
382 397 * 0 success
383 398 * ECONNABORTED repository connection aborted
384 399 *
385 400 * v->gv_state should be set to the state we're transitioning to before
386 401 * calling this function.
387 402 */
388 403 int
389 404 gt_transition(scf_handle_t *h, graph_vertex_t *v, restarter_error_t rerr,
390 405 restarter_instance_state_t old_state)
391 406 {
392 407 int err;
393 408 int lost_repository = 0;
394 409
395 410 /*
396 411 * If there's a common set of work to be done on exit from the
397 412 * old_state, include it as a separate set of functions here. For
398 413 * now there's no such work, so there are no gt_exit functions.
399 414 */
400 415
401 416 err = vertex_subgraph_dependencies_shutdown(h, v, old_state);
402 417 switch (err) {
403 418 case 0:
404 419 break;
405 420
406 421 case ECONNABORTED:
407 422 lost_repository = 1;
408 423 break;
409 424
410 425 default:
411 426 bad_error("vertex_subgraph_dependencies_shutdown", err);
412 427 }
413 428
414 429 /*
415 430 * Now call the appropriate gt_enter function for the new state.
416 431 */
417 432 switch (v->gv_state) {
418 433 case RESTARTER_STATE_UNINIT:
419 434 err = gt_enter_uninit(h, v, old_state, rerr);
420 435 break;
421 436
422 437 case RESTARTER_STATE_DISABLED:
423 438 err = gt_enter_disabled(h, v, old_state, rerr);
424 439 break;
425 440
426 441 case RESTARTER_STATE_OFFLINE:
427 442 err = gt_enter_offline(h, v, old_state, rerr);
428 443 break;
429 444
430 445 case RESTARTER_STATE_ONLINE:
431 446 err = gt_enter_online(h, v, old_state, rerr);
432 447 break;
433 448
434 449 case RESTARTER_STATE_DEGRADED:
435 450 err = gt_enter_degraded(h, v, old_state, rerr);
436 451 break;
437 452
438 453 case RESTARTER_STATE_MAINT:
439 454 err = gt_enter_maint(h, v, old_state, rerr);
440 455 break;
441 456
442 457 default:
443 458 /* Shouldn't be in an invalid state. */
444 459 #ifndef NDEBUG
445 460 uu_warn("%s:%d: Invalid state %d.\n", __FILE__, __LINE__,
446 461 v->gv_state);
447 462 #endif
448 463 abort();
449 464 }
450 465
451 466 switch (err) {
452 467 case 0:
453 468 break;
454 469
455 470 case ECONNABORTED:
456 471 lost_repository = 1;
457 472 break;
458 473
459 474 default:
460 475 #ifndef NDEBUG
461 476 uu_warn("%s:%d: "
462 477 "gt_enter_%s() failed with unexpected error %d.\n",
463 478 __FILE__, __LINE__, instance_state_str[v->gv_state], err);
464 479 #endif
465 480 abort();
466 481 }
467 482
468 483 return (lost_repository ? ECONNABORTED : 0);
469 484 }
|
↓ open down ↓ |
190 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX