This source file includes following definitions.
- set_result_from_svc_action
- log_action
- append_config_arg
- make_args
- stonith__destroy_action
- stonith__action_result
- stonith__action_create
- update_remaining_timeout
- stonith__result2rc
- stonith__legacy2status
- stonith__xe_set_result
- stonith__find_xe_with_result
- stonith__xe_get_result
- stonith_action_async_done
- stonith_action_async_forked
- internal_stonith_action_execute
- stonith__execute_async
- stonith__execute
1
2
3
4
5
6
7
8
9
10 #include <crm_internal.h>
11
12 #include <stdbool.h>
13 #include <stdlib.h>
14 #include <stdio.h>
15 #include <string.h>
16 #include <libgen.h>
17 #include <inttypes.h>
18 #include <sys/types.h>
19 #include <glib.h>
20
21 #include <crm/crm.h>
22 #include <crm/stonith-ng.h>
23 #include <crm/fencing/internal.h>
24 #include <crm/msg_xml.h>
25 #include <crm/services_internal.h>
26
27 #include "fencing_private.h"
28
29 struct stonith_action_s {
30
31 char *agent;
32 char *action;
33 GHashTable *args;
34 int timeout;
35 bool async;
36 void *userdata;
37 void (*done_cb) (int pid, const pcmk__action_result_t *result,
38 void *user_data);
39 void (*fork_cb) (int pid, void *user_data);
40
41 svc_action_t *svc_action;
42
43
44 time_t initial_start_time;
45 int tries;
46 int remaining_timeout;
47 int max_retries;
48
49 int pid;
50 pcmk__action_result_t result;
51 };
52
53 static int internal_stonith_action_execute(stonith_action_t *action);
54 static void log_action(stonith_action_t *action, pid_t pid);
55
56
57
58
59
60
61
62
63 static void
64 set_result_from_svc_action(stonith_action_t *action, svc_action_t *svc_action)
65 {
66 pcmk__set_result(&(action->result), svc_action->rc, svc_action->status,
67 services__exit_reason(svc_action));
68 pcmk__set_result_output(&(action->result),
69 services__grab_stdout(svc_action),
70 services__grab_stderr(svc_action));
71 }
72
73 static void
74 log_action(stonith_action_t *action, pid_t pid)
75 {
76
77
78
79 if (action->result.action_stderr != NULL) {
80
81 char *prefix = crm_strdup_printf("%s[%d] stderr:", action->agent, pid);
82
83 crm_log_output(LOG_WARNING, prefix, action->result.action_stderr);
84 free(prefix);
85 }
86 }
87
88 static void
89 append_config_arg(gpointer key, gpointer value, gpointer user_data)
90 {
91
92
93
94
95
96 if (!pcmk__str_eq(key, STONITH_ATTR_ACTION_OP, pcmk__str_casei)
97 && !pcmk_stonith_param(key)
98 && (strstr(key, CRM_META) == NULL)
99 && !pcmk__str_eq(key, "crm_feature_set", pcmk__str_casei)) {
100
101 crm_trace("Passing %s=%s with fence action",
102 (const char *) key, (const char *) (value? value : ""));
103 g_hash_table_insert((GHashTable *) user_data,
104 strdup(key), strdup(value? value : ""));
105 }
106 }
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122 static GHashTable *
123 make_args(const char *agent, const char *action, const char *target,
124 uint32_t target_nodeid, GHashTable *device_args,
125 GHashTable *port_map, const char *host_arg)
126 {
127 GHashTable *arg_list = NULL;
128 const char *value = NULL;
129
130 CRM_CHECK(action != NULL, return NULL);
131
132 arg_list = pcmk__strkey_table(free, free);
133
134
135 if (device_args) {
136 char buffer[512];
137
138 snprintf(buffer, sizeof(buffer), "pcmk_%s_action", action);
139 value = g_hash_table_lookup(device_args, buffer);
140 if (value) {
141 crm_debug("Substituting '%s' for fence action %s targeting %s",
142 value, action, pcmk__s(target, "no node"));
143 action = value;
144 }
145 }
146 g_hash_table_insert(arg_list, strdup(STONITH_ATTR_ACTION_OP),
147 strdup(action));
148
149
150
151
152 if ((target != NULL) && (device_args != NULL)) {
153 const char *param = NULL;
154
155
156
157
158 g_hash_table_insert(arg_list, strdup("nodename"), strdup(target));
159
160
161 if (target_nodeid != 0) {
162 char *nodeid = crm_strdup_printf("%" PRIu32, target_nodeid);
163
164
165 crm_info("Passing '%s' as nodeid with fence action '%s' targeting %s",
166 nodeid, action, pcmk__s(target, "no node"));
167 g_hash_table_insert(arg_list, strdup("nodeid"), nodeid);
168 }
169
170
171 param = g_hash_table_lookup(device_args, PCMK_STONITH_HOST_ARGUMENT);
172 if (!pcmk__str_eq(agent, "fence_legacy", pcmk__str_none)
173 && !pcmk__str_eq(param, PCMK__VALUE_NONE, pcmk__str_casei)) {
174
175 if (param == NULL) {
176
177
178
179 param = (host_arg == NULL)? "port" : host_arg;
180 }
181 value = g_hash_table_lookup(device_args, param);
182
183 if (pcmk__str_eq(value, "dynamic",
184 pcmk__str_casei|pcmk__str_null_matches)) {
185
186
187
188 const char *alias = NULL;
189
190 if (port_map) {
191 alias = g_hash_table_lookup(port_map, target);
192 }
193 if (alias == NULL) {
194 alias = target;
195 }
196 crm_debug("Passing %s='%s' with fence action %s targeting %s",
197 param, alias, action, pcmk__s(target, "no node"));
198 g_hash_table_insert(arg_list, strdup(param), strdup(alias));
199 }
200 }
201 }
202
203 if (device_args) {
204 g_hash_table_foreach(device_args, append_config_arg, arg_list);
205 }
206
207 return arg_list;
208 }
209
210
211
212
213
214
215
216 void
217 stonith__destroy_action(stonith_action_t *action)
218 {
219 if (action) {
220 free(action->agent);
221 if (action->args) {
222 g_hash_table_destroy(action->args);
223 }
224 free(action->action);
225 if (action->svc_action) {
226 services_action_free(action->svc_action);
227 }
228 pcmk__reset_result(&(action->result));
229 free(action);
230 }
231 }
232
233
234
235
236
237
238
239
240
241 pcmk__action_result_t *
242 stonith__action_result(stonith_action_t *action)
243 {
244 return (action == NULL)? NULL : &(action->result);
245 }
246
247 #define FAILURE_MAX_RETRIES 2
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264 stonith_action_t *
265 stonith__action_create(const char *agent, const char *action_name,
266 const char *target, uint32_t target_nodeid,
267 int timeout_sec, GHashTable *device_args,
268 GHashTable *port_map, const char *host_arg)
269 {
270 stonith_action_t *action = calloc(1, sizeof(stonith_action_t));
271
272 CRM_ASSERT(action != NULL);
273
274 action->args = make_args(agent, action_name, target, target_nodeid,
275 device_args, port_map, host_arg);
276 crm_debug("Preparing '%s' action targeting %s using agent %s",
277 action_name, pcmk__s(target, "no node"), agent);
278 action->agent = strdup(agent);
279 action->action = strdup(action_name);
280 action->timeout = action->remaining_timeout = timeout_sec;
281 action->max_retries = FAILURE_MAX_RETRIES;
282
283 pcmk__set_result(&(action->result), PCMK_OCF_UNKNOWN, PCMK_EXEC_UNKNOWN,
284 "Initialization bug in fencing library");
285
286 if (device_args) {
287 char buffer[512];
288 const char *value = NULL;
289
290 snprintf(buffer, sizeof(buffer), "pcmk_%s_retries", action_name);
291 value = g_hash_table_lookup(device_args, buffer);
292
293 if (value) {
294 action->max_retries = atoi(value);
295 }
296 }
297
298 return action;
299 }
300
301 static gboolean
302 update_remaining_timeout(stonith_action_t * action)
303 {
304 int diff = time(NULL) - action->initial_start_time;
305
306 if (action->tries >= action->max_retries) {
307 crm_info("Attempted to execute agent %s (%s) the maximum number of times (%d) allowed",
308 action->agent, action->action, action->max_retries);
309 action->remaining_timeout = 0;
310 } else if ((action->result.execution_status != PCMK_EXEC_TIMEOUT)
311 && (diff < (action->timeout * 0.7))) {
312
313
314 action->remaining_timeout = action->timeout - diff;
315 } else {
316 action->remaining_timeout = 0;
317 }
318 return action->remaining_timeout ? TRUE : FALSE;
319 }
320
321
322
323
324
325
326
327
328
329 int
330 stonith__result2rc(const pcmk__action_result_t *result)
331 {
332 if (pcmk__result_ok(result)) {
333 return pcmk_rc_ok;
334 }
335
336 switch (result->execution_status) {
337 case PCMK_EXEC_PENDING: return EINPROGRESS;
338 case PCMK_EXEC_CANCELLED: return ECANCELED;
339 case PCMK_EXEC_TIMEOUT: return ETIME;
340 case PCMK_EXEC_NOT_INSTALLED: return ENOENT;
341 case PCMK_EXEC_NOT_SUPPORTED: return EOPNOTSUPP;
342 case PCMK_EXEC_NOT_CONNECTED: return ENOTCONN;
343 case PCMK_EXEC_NO_FENCE_DEVICE: return ENODEV;
344 case PCMK_EXEC_NO_SECRETS: return EACCES;
345
346
347
348
349
350
351 case PCMK_EXEC_INVALID:
352 switch (result->exit_status) {
353 case CRM_EX_INVALID_PARAM: return EINVAL;
354 case CRM_EX_INSUFFICIENT_PRIV: return EACCES;
355 case CRM_EX_PROTOCOL: return EPROTO;
356
357
358
359
360
361
362 case CRM_EX_EXPIRED: return EHOSTUNREACH;
363 default: break;
364 }
365 break;
366
367 default:
368 break;
369 }
370
371
372
373 if (result->action_stderr == NULL) {
374 return ENODATA;
375
376 } else if (strcasestr(result->action_stderr, "timed out")
377 || strcasestr(result->action_stderr, "timeout")) {
378 return ETIME;
379
380 } else if (strcasestr(result->action_stderr, "unrecognised action")
381 || strcasestr(result->action_stderr, "unrecognized action")
382 || strcasestr(result->action_stderr, "unsupported action")) {
383 return EOPNOTSUPP;
384 }
385
386
387 return pcmk_rc_error;
388 }
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403 int
404 stonith__legacy2status(int rc)
405 {
406 if (rc >= 0) {
407 return PCMK_EXEC_DONE;
408 }
409 switch (-rc) {
410 case EACCES: return PCMK_EXEC_NO_SECRETS;
411 case ECANCELED: return PCMK_EXEC_CANCELLED;
412 case EHOSTUNREACH: return PCMK_EXEC_INVALID;
413 case EINPROGRESS: return PCMK_EXEC_PENDING;
414 case ENODEV: return PCMK_EXEC_NO_FENCE_DEVICE;
415 case ENOENT: return PCMK_EXEC_NOT_INSTALLED;
416 case ENOTCONN: return PCMK_EXEC_NOT_CONNECTED;
417 case EOPNOTSUPP: return PCMK_EXEC_NOT_SUPPORTED;
418 case EPROTO: return PCMK_EXEC_INVALID;
419 case EPROTONOSUPPORT: return PCMK_EXEC_NOT_SUPPORTED;
420 case ETIME: return PCMK_EXEC_TIMEOUT;
421 case ETIMEDOUT: return PCMK_EXEC_TIMEOUT;
422 default: return PCMK_EXEC_ERROR;
423 }
424 }
425
426
427
428
429
430
431
432
433 void
434 stonith__xe_set_result(xmlNode *xml, const pcmk__action_result_t *result)
435 {
436 int exit_status = CRM_EX_OK;
437 enum pcmk_exec_status execution_status = PCMK_EXEC_DONE;
438 const char *exit_reason = NULL;
439 const char *action_stdout = NULL;
440 int rc = pcmk_ok;
441
442 CRM_CHECK(xml != NULL, return);
443
444 if (result != NULL) {
445 exit_status = result->exit_status;
446 execution_status = result->execution_status;
447 exit_reason = result->exit_reason;
448 action_stdout = result->action_stdout;
449 rc = pcmk_rc2legacy(stonith__result2rc(result));
450 }
451
452 crm_xml_add_int(xml, XML_LRM_ATTR_OPSTATUS, (int) execution_status);
453 crm_xml_add_int(xml, XML_LRM_ATTR_RC, exit_status);
454 crm_xml_add(xml, XML_LRM_ATTR_EXIT_REASON, exit_reason);
455 crm_xml_add(xml, F_STONITH_OUTPUT, action_stdout);
456
457
458
459
460
461 crm_xml_add_int(xml, F_STONITH_RC, rc);
462 }
463
464
465
466
467
468
469
470
471
472 xmlNode *
473 stonith__find_xe_with_result(xmlNode *xml)
474 {
475 xmlNode *match = get_xpath_object("//@" XML_LRM_ATTR_RC, xml, LOG_NEVER);
476
477 if (match == NULL) {
478
479
480
481 match = get_xpath_object("//@" F_STONITH_RC, xml, LOG_ERR);
482 }
483 return match;
484 }
485
486
487
488
489
490
491
492
493 void
494 stonith__xe_get_result(const xmlNode *xml, pcmk__action_result_t *result)
495 {
496 int exit_status = CRM_EX_OK;
497 int execution_status = PCMK_EXEC_DONE;
498 const char *exit_reason = NULL;
499 char *action_stdout = NULL;
500
501 CRM_CHECK((xml != NULL) && (result != NULL), return);
502
503 exit_reason = crm_element_value(xml, XML_LRM_ATTR_EXIT_REASON);
504 action_stdout = crm_element_value_copy(xml, F_STONITH_OUTPUT);
505
506
507 if ((crm_element_value_int(xml, XML_LRM_ATTR_RC, &exit_status) < 0)
508 || (crm_element_value_int(xml, XML_LRM_ATTR_OPSTATUS,
509 &execution_status) < 0)) {
510 int rc = pcmk_ok;
511 exit_status = CRM_EX_ERROR;
512
513
514
515
516 if (crm_element_value_int(xml, F_STONITH_RC, &rc) == 0) {
517 if ((rc == pcmk_ok) || (rc == -EINPROGRESS)) {
518 exit_status = CRM_EX_OK;
519 }
520 execution_status = stonith__legacy2status(rc);
521 exit_reason = pcmk_strerror(rc);
522
523 } else {
524 execution_status = PCMK_EXEC_ERROR;
525 exit_reason = "Fencer reply contained neither a full result "
526 "nor a legacy return code (bug?)";
527 }
528 }
529 pcmk__set_result(result, exit_status, execution_status, exit_reason);
530 pcmk__set_result_output(result, action_stdout, NULL);
531 }
532
533 static void
534 stonith_action_async_done(svc_action_t *svc_action)
535 {
536 stonith_action_t *action = (stonith_action_t *) svc_action->cb_data;
537
538 set_result_from_svc_action(action, svc_action);
539 svc_action->params = NULL;
540 log_action(action, action->pid);
541
542 if (!pcmk__result_ok(&(action->result))
543 && update_remaining_timeout(action)) {
544
545 int rc = internal_stonith_action_execute(action);
546 if (rc == pcmk_ok) {
547 return;
548 }
549 }
550
551 if (action->done_cb) {
552 action->done_cb(action->pid, &(action->result), action->userdata);
553 }
554
555 action->svc_action = NULL;
556 stonith__destroy_action(action);
557 }
558
559 static void
560 stonith_action_async_forked(svc_action_t *svc_action)
561 {
562 stonith_action_t *action = (stonith_action_t *) svc_action->cb_data;
563
564 action->pid = svc_action->pid;
565 action->svc_action = svc_action;
566
567 if (action->fork_cb) {
568 (action->fork_cb) (svc_action->pid, action->userdata);
569 }
570
571 pcmk__set_result(&(action->result), PCMK_OCF_UNKNOWN, PCMK_EXEC_PENDING,
572 NULL);
573
574 crm_trace("Child process %d performing action '%s' successfully forked",
575 action->pid, action->action);
576 }
577
578 static int
579 internal_stonith_action_execute(stonith_action_t * action)
580 {
581 int rc = -EPROTO;
582 int is_retry = 0;
583 svc_action_t *svc_action = NULL;
584 static int stonith_sequence = 0;
585 char *buffer = NULL;
586
587 CRM_CHECK(action != NULL, return -EINVAL);
588
589 if ((action->action == NULL) || (action->args == NULL)
590 || (action->agent == NULL)) {
591 pcmk__set_result(&(action->result), PCMK_OCF_UNKNOWN_ERROR,
592 PCMK_EXEC_ERROR_FATAL, "Bug in fencing library");
593 return -EINVAL;
594 }
595
596 if (!action->tries) {
597 action->initial_start_time = time(NULL);
598 }
599 action->tries++;
600
601 if (action->tries > 1) {
602 crm_info("Attempt %d to execute %s (%s). remaining timeout is %d",
603 action->tries, action->agent, action->action, action->remaining_timeout);
604 is_retry = 1;
605 }
606
607 buffer = crm_strdup_printf(PCMK__FENCE_BINDIR "/%s",
608 basename(action->agent));
609 svc_action = services_action_create_generic(buffer, NULL);
610 free(buffer);
611
612 if (svc_action->rc != PCMK_OCF_UNKNOWN) {
613 set_result_from_svc_action(action, svc_action);
614 services_action_free(svc_action);
615 return -E2BIG;
616 }
617
618 svc_action->timeout = 1000 * action->remaining_timeout;
619 svc_action->standard = strdup(PCMK_RESOURCE_CLASS_STONITH);
620 svc_action->id = crm_strdup_printf("%s_%s_%dof%d", basename(action->agent),
621 action->action, action->tries,
622 action->max_retries);
623 svc_action->agent = strdup(action->agent);
624 svc_action->sequence = stonith_sequence++;
625 svc_action->params = action->args;
626 svc_action->cb_data = (void *) action;
627 svc_action->flags = pcmk__set_flags_as(__func__, __LINE__,
628 LOG_TRACE, "Action",
629 svc_action->id, svc_action->flags,
630 SVC_ACTION_NON_BLOCKED,
631 "SVC_ACTION_NON_BLOCKED");
632
633
634 if (is_retry) {
635 pcmk__reset_result(&(action->result));
636 sleep(1);
637 }
638
639 if (action->async) {
640
641 CRM_LOG_ASSERT(services_action_async_fork_notify(svc_action,
642 &stonith_action_async_done,
643 &stonith_action_async_forked));
644 return pcmk_ok;
645
646 } else if (services_action_sync(svc_action)) {
647 rc = pcmk_ok;
648
649 } else {
650 rc = -ECONNABORTED;
651 }
652
653 set_result_from_svc_action(action, svc_action);
654 svc_action->params = NULL;
655 services_action_free(svc_action);
656 return rc;
657 }
658
659
660
661
662
663
664
665
666
667
668
669
670 int
671 stonith__execute_async(stonith_action_t * action, void *userdata,
672 void (*done) (int pid,
673 const pcmk__action_result_t *result,
674 void *user_data),
675 void (*fork_cb) (int pid, void *user_data))
676 {
677 if (!action) {
678 return -EINVAL;
679 }
680
681 action->userdata = userdata;
682 action->done_cb = done;
683 action->fork_cb = fork_cb;
684 action->async = true;
685
686 return internal_stonith_action_execute(action);
687 }
688
689
690
691
692
693
694
695
696
697 int
698 stonith__execute(stonith_action_t *action)
699 {
700 int rc = pcmk_ok;
701
702 CRM_CHECK(action != NULL, return -EINVAL);
703
704
705 do {
706 rc = internal_stonith_action_execute(action);
707 } while ((rc != pcmk_ok) && update_remaining_timeout(action));
708
709 return rc;
710 }