corosync  2.3.5
sam.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2009-2011 Red Hat, Inc.
3  *
4  * All rights reserved.
5  *
6  * Author: Jan Friesse (jfriesse@redhat.com)
7  *
8  * This software licensed under BSD license, the text of which follows:
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions are met:
12  *
13  * - Redistributions of source code must retain the above copyright notice,
14  * this list of conditions and the following disclaimer.
15  * - Redistributions in binary form must reproduce the above copyright notice,
16  * this list of conditions and the following disclaimer in the documentation
17  * and/or other materials provided with the distribution.
18  * - Neither the name of the Red Hat, Inc. nor the names of its
19  * contributors may be used to endorse or promote products derived from this
20  * software without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
26  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
32  * THE POSSIBILITY OF SUCH DAMAGE.
33  */
34 
35 /*
36  * Provides a SAM API
37  */
38 
39 #include <config.h>
40 
41 #include <limits.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <unistd.h>
45 #include <sys/time.h>
46 #include <sys/types.h>
47 #include <sys/socket.h>
48 #include <errno.h>
49 
50 #include <corosync/corotypes.h>
51 #include <qb/qbipcc.h>
52 #include <corosync/corodefs.h>
53 #include <corosync/cmap.h>
54 #include <corosync/hdb.h>
55 #include <corosync/quorum.h>
56 
57 #include <corosync/sam.h>
58 
59 #include "util.h"
60 
61 #include <stdio.h>
62 #include <sys/wait.h>
63 #include <signal.h>
64 
65 #define SAM_CMAP_S_FAILED "failed"
66 #define SAM_CMAP_S_REGISTERED "stopped"
67 #define SAM_CMAP_S_STARTED "running"
68 #define SAM_CMAP_S_Q_WAIT "waiting for quorum"
69 
70 #define SAM_RP_MASK_Q(pol) (pol & (~SAM_RECOVERY_POLICY_QUORUM))
71 #define SAM_RP_MASK_C(pol) (pol & (~SAM_RECOVERY_POLICY_CMAP))
72 #define SAM_RP_MASK(pol) (pol & (~(SAM_RECOVERY_POLICY_QUORUM | SAM_RECOVERY_POLICY_CMAP)))
73 
80 };
81 
89 };
90 
94 };
95 
101 };
102 
108 };
109 
110 static struct {
114  unsigned int instance_id;
120 
122  pthread_t cb_thread;
125 
126  void *user_data;
129 
130  pthread_mutex_t lock;
131 
133  uint32_t quorate;
135 
138 } sam_internal_data;
139 
140 extern const char *__progname;
141 
142 static cs_error_t sam_cmap_update_key (enum sam_cmap_key_t key, const char *value)
143 {
144  cs_error_t err;
145  const char *svalue;
146  uint64_t hc_period, last_hc;
147  const char *ssvalue[] = { [SAM_RECOVERY_POLICY_QUIT] = "quit", [SAM_RECOVERY_POLICY_RESTART] = "restart" };
148  char key_name[CMAP_KEYNAME_MAXLEN];
149 
150  switch (key) {
152  svalue = ssvalue[SAM_RP_MASK (sam_internal_data.recovery_policy)];
153 
154  snprintf(key_name, CMAP_KEYNAME_MAXLEN, "%s%s", sam_internal_data.cmap_pid_path,
155  "recovery");
156  if ((err = cmap_set_string(sam_internal_data.cmap_handle, key_name, svalue)) != CS_OK) {
157  goto exit_error;
158  }
159  break;
161  hc_period = sam_internal_data.time_interval;
162 
163  snprintf(key_name, CMAP_KEYNAME_MAXLEN, "%s%s", sam_internal_data.cmap_pid_path,
164  "poll_period");
165  if ((err = cmap_set_uint64(sam_internal_data.cmap_handle, key_name, hc_period)) != CS_OK) {
166  goto exit_error;
167  }
168  break;
170  last_hc = cs_timestamp_get();
171 
172  snprintf(key_name, CMAP_KEYNAME_MAXLEN, "%s%s", sam_internal_data.cmap_pid_path,
173  "last_updated");
174  if ((err = cmap_set_uint64(sam_internal_data.cmap_handle, key_name, last_hc)) != CS_OK) {
175  goto exit_error;
176  }
177  break;
178  case SAM_CMAP_KEY_STATE:
179  svalue = value;
180  snprintf(key_name, CMAP_KEYNAME_MAXLEN, "%s%s", sam_internal_data.cmap_pid_path,
181  "state");
182  if ((err = cmap_set_string(sam_internal_data.cmap_handle, key_name, svalue)) != CS_OK) {
183  goto exit_error;
184  }
185  break;
186  }
187 
188  return (CS_OK);
189 
190 exit_error:
191  return (err);
192 }
193 
194 static cs_error_t sam_cmap_destroy_pid_path (void)
195 {
196  cmap_iter_handle_t iter;
197  cs_error_t err;
198  char key_name[CMAP_KEYNAME_MAXLEN];
199 
200  err = cmap_iter_init(sam_internal_data.cmap_handle, sam_internal_data.cmap_pid_path, &iter);
201  if (err != CS_OK) {
202  goto error_exit;
203  }
204 
205  while ((err = cmap_iter_next(sam_internal_data.cmap_handle, iter, key_name, NULL, NULL)) == CS_OK) {
206  cmap_delete(sam_internal_data.cmap_handle, key_name);
207  }
208 
209  err = cmap_iter_finalize(sam_internal_data.cmap_handle, iter);
210 
211 error_exit:
212  return (err);
213 }
214 
215 static cs_error_t sam_cmap_register (void)
216 {
217  cs_error_t err;
219 
220  if ((err = cmap_initialize (&cmap_handle)) != CS_OK) {
221  return (err);
222  }
223 
224  snprintf(sam_internal_data.cmap_pid_path, CMAP_KEYNAME_MAXLEN, "resources.process.%d.", getpid());
225 
226  sam_internal_data.cmap_handle = cmap_handle;
227 
228  if ((err = sam_cmap_update_key (SAM_CMAP_KEY_RECOVERY, NULL)) != CS_OK) {
229  goto destroy_finalize_error;
230  }
231 
232  if ((err = sam_cmap_update_key (SAM_CMAP_KEY_HC_PERIOD, NULL)) != CS_OK) {
233  goto destroy_finalize_error;
234  }
235 
236  return (CS_OK);
237 
238 destroy_finalize_error:
239  sam_cmap_destroy_pid_path ();
240  cmap_finalize (cmap_handle);
241  return (err);
242 }
243 
244 static void quorum_notification_fn (
245  quorum_handle_t handle,
246  uint32_t quorate,
247  uint64_t ring_id,
248  uint32_t view_list_entries,
249  uint32_t *view_list)
250 {
251  sam_internal_data.quorate = quorate;
252 }
253 
255  int time_interval,
257 {
258  quorum_callbacks_t quorum_callbacks;
259  uint32_t quorum_type;
260  cs_error_t err;
261 
262  if (sam_internal_data.internal_status != SAM_INTERNAL_STATUS_NOT_INITIALIZED) {
263  return (CS_ERR_BAD_HANDLE);
264  }
265 
266  if (SAM_RP_MASK (recovery_policy) != SAM_RECOVERY_POLICY_QUIT &&
267  SAM_RP_MASK (recovery_policy) != SAM_RECOVERY_POLICY_RESTART) {
268  return (CS_ERR_INVALID_PARAM);
269  }
270 
271  if (recovery_policy & SAM_RECOVERY_POLICY_QUORUM) {
272  /*
273  * Initialize quorum
274  */
275  quorum_callbacks.quorum_notify_fn = quorum_notification_fn;
276  if ((err = quorum_initialize (&sam_internal_data.quorum_handle, &quorum_callbacks, &quorum_type)) != CS_OK) {
277  goto exit_error;
278  }
279 
280  if ((err = quorum_trackstart (sam_internal_data.quorum_handle, CS_TRACK_CHANGES)) != CS_OK) {
281  goto exit_error_quorum;
282  }
283 
284  if ((err = quorum_fd_get (sam_internal_data.quorum_handle, &sam_internal_data.quorum_fd)) != CS_OK) {
285  goto exit_error_quorum;
286  }
287 
288  /*
289  * Dispatch initial quorate state
290  */
291  if ((err = quorum_dispatch (sam_internal_data.quorum_handle, CS_DISPATCH_ONE)) != CS_OK) {
292  goto exit_error_quorum;
293  }
294  }
295  sam_internal_data.recovery_policy = recovery_policy;
296 
297  sam_internal_data.time_interval = time_interval;
298 
299  sam_internal_data.internal_status = SAM_INTERNAL_STATUS_INITIALIZED;
300 
301  sam_internal_data.warn_signal = SIGTERM;
302 
303  sam_internal_data.am_i_child = 0;
304 
305  sam_internal_data.user_data = NULL;
306  sam_internal_data.user_data_size = 0;
307  sam_internal_data.user_data_allocated = 0;
308 
309  pthread_mutex_init (&sam_internal_data.lock, NULL);
310 
311  return (CS_OK);
312 
313 exit_error_quorum:
314  quorum_finalize (sam_internal_data.quorum_handle);
315 exit_error:
316  return (err);
317 }
318 
319 /*
320  * Wrapper on top of write(2) function. It handles EAGAIN and EINTR states and sends whole buffer if possible.
321  */
322 static size_t sam_safe_write (
323  int d,
324  const void *buf,
325  size_t nbyte)
326 {
327  ssize_t bytes_write;
328  ssize_t tmp_bytes_write;
329 
330  bytes_write = 0;
331 
332  do {
333  tmp_bytes_write = write (d, (const char *)buf + bytes_write,
334  (nbyte - bytes_write > SSIZE_MAX) ? SSIZE_MAX : nbyte - bytes_write);
335 
336  if (tmp_bytes_write == -1) {
337  if (!(errno == EAGAIN || errno == EINTR))
338  return -1;
339  } else {
340  bytes_write += tmp_bytes_write;
341  }
342  } while (bytes_write != nbyte);
343 
344  return (bytes_write);
345 }
346 
347 /*
348  * Wrapper on top of read(2) function. It handles EAGAIN and EINTR states and reads whole buffer if possible.
349  */
350 static size_t sam_safe_read (
351  int d,
352  void *buf,
353  size_t nbyte)
354 {
355  ssize_t bytes_read;
356  ssize_t tmp_bytes_read;
357 
358  bytes_read = 0;
359 
360  do {
361  tmp_bytes_read = read (d, (char *)buf + bytes_read,
362  (nbyte - bytes_read > SSIZE_MAX) ? SSIZE_MAX : nbyte - bytes_read);
363 
364  if (tmp_bytes_read == -1) {
365  if (!(errno == EAGAIN || errno == EINTR))
366  return -1;
367  } else {
368  bytes_read += tmp_bytes_read;
369  }
370 
371  } while (bytes_read != nbyte && tmp_bytes_read != 0);
372 
373  return (bytes_read);
374 }
375 
376 static cs_error_t sam_read_reply (
377  int child_fd_in)
378 {
379  char reply;
380  cs_error_t err;
381 
382  if (sam_safe_read (sam_internal_data.child_fd_in, &reply, sizeof (reply)) != sizeof (reply)) {
383  return (CS_ERR_LIBRARY);
384  }
385 
386  switch (reply) {
387  case SAM_REPLY_ERROR:
388  /*
389  * Read error and return that
390  */
391  if (sam_safe_read (sam_internal_data.child_fd_in, &err, sizeof (err)) != sizeof (err)) {
392  return (CS_ERR_LIBRARY);
393  }
394 
395  return (err);
396  break;
397  case SAM_REPLY_OK:
398  /*
399  * Everything correct
400  */
401  break;
402  default:
403  return (CS_ERR_LIBRARY);
404  break;
405  }
406 
407  return (CS_OK);
408 }
409 
411 {
412  if (size == NULL) {
413  return (CS_ERR_INVALID_PARAM);
414  }
415 
416  if (sam_internal_data.internal_status != SAM_INTERNAL_STATUS_INITIALIZED &&
417  sam_internal_data.internal_status != SAM_INTERNAL_STATUS_REGISTERED &&
418  sam_internal_data.internal_status != SAM_INTERNAL_STATUS_STARTED) {
419 
420  return (CS_ERR_BAD_HANDLE);
421  }
422 
423  pthread_mutex_lock (&sam_internal_data.lock);
424 
425  *size = sam_internal_data.user_data_size;
426 
427  pthread_mutex_unlock (&sam_internal_data.lock);
428 
429  return (CS_OK);
430 }
431 
433  void *data,
434  size_t size)
435 {
436  cs_error_t err;
437 
438  err = CS_OK;
439 
440  if (data == NULL) {
441  return (CS_ERR_INVALID_PARAM);
442  }
443 
444  if (sam_internal_data.internal_status != SAM_INTERNAL_STATUS_INITIALIZED &&
445  sam_internal_data.internal_status != SAM_INTERNAL_STATUS_REGISTERED &&
446  sam_internal_data.internal_status != SAM_INTERNAL_STATUS_STARTED) {
447 
448  return (CS_ERR_BAD_HANDLE);
449  }
450 
451  pthread_mutex_lock (&sam_internal_data.lock);
452 
453  if (sam_internal_data.user_data_size == 0) {
454  err = CS_OK;
455 
456  goto error_unlock;
457  }
458 
459  if (size < sam_internal_data.user_data_size) {
460  err = CS_ERR_INVALID_PARAM;
461 
462  goto error_unlock;
463  }
464 
465  memcpy (data, sam_internal_data.user_data, sam_internal_data.user_data_size);
466 
467  pthread_mutex_unlock (&sam_internal_data.lock);
468 
469  return (CS_OK);
470 
471 error_unlock:
472  pthread_mutex_unlock (&sam_internal_data.lock);
473 
474  return (err);
475 }
476 
478  const void *data,
479  size_t size)
480 {
481  cs_error_t err;
482  char command;
483  char *new_data;
484 
485  if (sam_internal_data.internal_status != SAM_INTERNAL_STATUS_INITIALIZED &&
486  sam_internal_data.internal_status != SAM_INTERNAL_STATUS_REGISTERED &&
487  sam_internal_data.internal_status != SAM_INTERNAL_STATUS_STARTED) {
488 
489  return (CS_ERR_BAD_HANDLE);
490  }
491 
492 
493  if (data == NULL) {
494  size = 0;
495  }
496 
497  pthread_mutex_lock (&sam_internal_data.lock);
498 
499  if (sam_internal_data.am_i_child) {
500  /*
501  * We are child so we must send data to parent
502  */
503  command = SAM_COMMAND_DATA_STORE;
504  if (sam_safe_write (sam_internal_data.child_fd_out, &command, sizeof (command)) != sizeof (command)) {
505  err = CS_ERR_LIBRARY;
506 
507  goto error_unlock;
508  }
509 
510  if (sam_safe_write (sam_internal_data.child_fd_out, &size, sizeof (size)) != sizeof (size)) {
511  err = CS_ERR_LIBRARY;
512 
513  goto error_unlock;
514  }
515 
516  if (data != NULL && sam_safe_write (sam_internal_data.child_fd_out, data, size) != size) {
517  err = CS_ERR_LIBRARY;
518 
519  goto error_unlock;
520  }
521 
522  /*
523  * And wait for reply
524  */
525  if ((err = sam_read_reply (sam_internal_data.child_fd_in)) != CS_OK) {
526  goto error_unlock;
527  }
528  }
529 
530  /*
531  * We are parent or we received OK reply from parent -> do required action
532  */
533  if (data == NULL) {
534  free (sam_internal_data.user_data);
535  sam_internal_data.user_data = NULL;
536  sam_internal_data.user_data_allocated = 0;
537  sam_internal_data.user_data_size = 0;
538  } else {
539  if (sam_internal_data.user_data_allocated < size) {
540  if ((new_data = realloc (sam_internal_data.user_data, size)) == NULL) {
541  err = CS_ERR_NO_MEMORY;
542 
543  goto error_unlock;
544  }
545 
546  sam_internal_data.user_data_allocated = size;
547  } else {
548  new_data = sam_internal_data.user_data;
549  }
550  sam_internal_data.user_data = new_data;
551  sam_internal_data.user_data_size = size;
552 
553  memcpy (sam_internal_data.user_data, data, size);
554  }
555 
556  pthread_mutex_unlock (&sam_internal_data.lock);
557 
558  return (CS_OK);
559 
560 error_unlock:
561  pthread_mutex_unlock (&sam_internal_data.lock);
562 
563  return (err);
564 }
565 
567 {
568  char command;
569  cs_error_t err;
570  sam_recovery_policy_t recpol;
571 
572  if (sam_internal_data.internal_status != SAM_INTERNAL_STATUS_REGISTERED) {
573  return (CS_ERR_BAD_HANDLE);
574  }
575 
576  recpol = sam_internal_data.recovery_policy;
577 
578  if (recpol & SAM_RECOVERY_POLICY_QUORUM || recpol & SAM_RECOVERY_POLICY_CMAP) {
579  pthread_mutex_lock (&sam_internal_data.lock);
580  }
581 
582  command = SAM_COMMAND_START;
583 
584  if (sam_safe_write (sam_internal_data.child_fd_out, &command, sizeof (command)) != sizeof (command)) {
585  if (recpol & SAM_RECOVERY_POLICY_QUORUM || recpol & SAM_RECOVERY_POLICY_CMAP) {
586  pthread_mutex_unlock (&sam_internal_data.lock);
587  }
588 
589  return (CS_ERR_LIBRARY);
590  }
591 
592  if (recpol & SAM_RECOVERY_POLICY_QUORUM || recpol & SAM_RECOVERY_POLICY_CMAP) {
593  /*
594  * Wait for parent reply
595  */
596  if ((err = sam_read_reply (sam_internal_data.child_fd_in)) != CS_OK) {
597  pthread_mutex_unlock (&sam_internal_data.lock);
598 
599  return (err);
600  }
601 
602  pthread_mutex_unlock (&sam_internal_data.lock);
603  }
604 
605  if (sam_internal_data.hc_callback)
606  if (sam_safe_write (sam_internal_data.cb_wpipe_fd, &command, sizeof (command)) != sizeof (command))
607  return (CS_ERR_LIBRARY);
608 
609  sam_internal_data.internal_status = SAM_INTERNAL_STATUS_STARTED;
610 
611  return (CS_OK);
612 }
613 
615 {
616  char command;
617  cs_error_t err;
618 
619  if (sam_internal_data.internal_status != SAM_INTERNAL_STATUS_STARTED) {
620  return (CS_ERR_BAD_HANDLE);
621  }
622 
623  command = SAM_COMMAND_STOP;
624 
625  if (sam_internal_data.recovery_policy & SAM_RECOVERY_POLICY_CMAP) {
626  pthread_mutex_lock (&sam_internal_data.lock);
627  }
628 
629  if (sam_safe_write (sam_internal_data.child_fd_out, &command, sizeof (command)) != sizeof (command)) {
630  if (sam_internal_data.recovery_policy & SAM_RECOVERY_POLICY_CMAP) {
631  pthread_mutex_unlock (&sam_internal_data.lock);
632  }
633 
634  return (CS_ERR_LIBRARY);
635  }
636 
637  if (sam_internal_data.recovery_policy & SAM_RECOVERY_POLICY_CMAP) {
638  /*
639  * Wait for parent reply
640  */
641  if ((err = sam_read_reply (sam_internal_data.child_fd_in)) != CS_OK) {
642  pthread_mutex_unlock (&sam_internal_data.lock);
643 
644  return (err);
645  }
646 
647  pthread_mutex_unlock (&sam_internal_data.lock);
648  }
649 
650  if (sam_internal_data.hc_callback)
651  if (sam_safe_write (sam_internal_data.cb_wpipe_fd, &command, sizeof (command)) != sizeof (command))
652  return (CS_ERR_LIBRARY);
653 
654  sam_internal_data.internal_status = SAM_INTERNAL_STATUS_REGISTERED;
655 
656  return (CS_OK);
657 }
658 
660 {
661  char command;
662 
663  if (sam_internal_data.internal_status != SAM_INTERNAL_STATUS_STARTED) {
664  return (CS_ERR_BAD_HANDLE);
665  }
666 
667  command = SAM_COMMAND_HB;
668 
669  if (sam_safe_write (sam_internal_data.child_fd_out, &command, sizeof (command)) != sizeof (command))
670  return (CS_ERR_LIBRARY);
671 
672  return (CS_OK);
673 }
674 
676 {
677  cs_error_t error;
678 
679  if (sam_internal_data.internal_status != SAM_INTERNAL_STATUS_INITIALIZED &&
680  sam_internal_data.internal_status != SAM_INTERNAL_STATUS_REGISTERED &&
681  sam_internal_data.internal_status != SAM_INTERNAL_STATUS_STARTED) {
682  return (CS_ERR_BAD_HANDLE);
683  }
684 
685  if (sam_internal_data.internal_status == SAM_INTERNAL_STATUS_STARTED) {
686  error = sam_stop ();
687  if (error != CS_OK)
688  goto exit_error;
689  }
690 
691  sam_internal_data.internal_status = SAM_INTERNAL_STATUS_FINALIZED;
692 
693  free (sam_internal_data.user_data);
694 
695 exit_error:
696  return (CS_OK);
697 }
698 
700 {
701  char command;
702 
703  if (sam_internal_data.internal_status != SAM_INTERNAL_STATUS_STARTED &&
704  sam_internal_data.internal_status != SAM_INTERNAL_STATUS_REGISTERED) {
705  return (CS_ERR_BAD_HANDLE);
706  }
707 
708  if (!(sam_internal_data.recovery_policy & SAM_RECOVERY_POLICY_CMAP)) {
709  return (CS_ERR_INVALID_PARAM);
710  }
711 
712  command = SAM_COMMAND_MARK_FAILED;
713 
714  if (sam_safe_write (sam_internal_data.child_fd_out, &command, sizeof (command)) != sizeof (command))
715  return (CS_ERR_LIBRARY);
716 
717  return (CS_OK);
718 }
719 
721 {
722  char command;
723  cs_error_t err;
724 
725  if (sam_internal_data.internal_status != SAM_INTERNAL_STATUS_INITIALIZED &&
726  sam_internal_data.internal_status != SAM_INTERNAL_STATUS_REGISTERED &&
727  sam_internal_data.internal_status != SAM_INTERNAL_STATUS_STARTED) {
728  return (CS_ERR_BAD_HANDLE);
729  }
730 
731  pthread_mutex_lock (&sam_internal_data.lock);
732 
733  if (sam_internal_data.am_i_child) {
734  /*
735  * We are child so we must send data to parent
736  */
737  command = SAM_COMMAND_WARN_SIGNAL_SET;
738  if (sam_safe_write (sam_internal_data.child_fd_out, &command, sizeof (command)) != sizeof (command)) {
739  err = CS_ERR_LIBRARY;
740 
741  goto error_unlock;
742  }
743 
744  if (sam_safe_write (sam_internal_data.child_fd_out, &warn_signal, sizeof (warn_signal)) !=
745  sizeof (warn_signal)) {
746  err = CS_ERR_LIBRARY;
747 
748  goto error_unlock;
749  }
750 
751  /*
752  * And wait for reply
753  */
754  if ((err = sam_read_reply (sam_internal_data.child_fd_in)) != CS_OK) {
755  goto error_unlock;
756  }
757  }
758 
759  /*
760  * We are parent or we received OK reply from parent -> do required action
761  */
762  sam_internal_data.warn_signal = warn_signal;
763 
764  pthread_mutex_unlock (&sam_internal_data.lock);
765 
766  return (CS_OK);
767 
768 error_unlock:
769  pthread_mutex_unlock (&sam_internal_data.lock);
770 
771  return (err);
772 }
773 
774 static cs_error_t sam_parent_reply_send (
775  cs_error_t err,
776  int parent_fd_in,
777  int parent_fd_out)
778 {
779  char reply;
780 
781  if (err == CS_OK) {
782  reply = SAM_REPLY_OK;
783 
784  if (sam_safe_write (parent_fd_out, &reply, sizeof (reply)) != sizeof (reply)) {
785  err = CS_ERR_LIBRARY;
786  goto error_reply;
787  }
788 
789  return (CS_OK);
790  }
791 
792 error_reply:
793  reply = SAM_REPLY_ERROR;
794  if (sam_safe_write (parent_fd_out, &reply, sizeof (reply)) != sizeof (reply)) {
795  return (CS_ERR_LIBRARY);
796  }
797  if (sam_safe_write (parent_fd_out, &err, sizeof (err)) != sizeof (err)) {
798  return (CS_ERR_LIBRARY);
799  }
800 
801  return (err);
802 }
803 
804 
805 static cs_error_t sam_parent_warn_signal_set (
806  int parent_fd_in,
807  int parent_fd_out)
808 {
809  int warn_signal;
810  cs_error_t err;
811 
812  err = CS_OK;
813 
814  if (sam_safe_read (parent_fd_in, &warn_signal, sizeof (warn_signal)) != sizeof (warn_signal)) {
815  err = CS_ERR_LIBRARY;
816  goto error_reply;
817  }
818 
819  err = sam_warn_signal_set (warn_signal);
820  if (err != CS_OK) {
821  goto error_reply;
822  }
823 
824 
825  return (sam_parent_reply_send (CS_OK, parent_fd_in, parent_fd_out));
826 
827 error_reply:
828  return (sam_parent_reply_send (err, parent_fd_in, parent_fd_out));
829 }
830 
831 static cs_error_t sam_parent_wait_for_quorum (
832  int parent_fd_in,
833  int parent_fd_out)
834 {
835  cs_error_t err;
836  struct pollfd pfds[2];
837  int poll_err;
838 
839  if (sam_internal_data.recovery_policy & SAM_RECOVERY_POLICY_CMAP) {
840  if ((err = sam_cmap_update_key (SAM_CMAP_KEY_STATE, SAM_CMAP_S_Q_WAIT)) != CS_OK) {
841  goto error_reply;
842  }
843  }
844 
845  /*
846  * Update current quorum
847  */
848  if ((err = quorum_dispatch (sam_internal_data.quorum_handle, CS_DISPATCH_ALL)) != CS_OK) {
849  goto error_reply;
850  }
851 
852  /*
853  * Wait for quorum
854  */
855  while (!sam_internal_data.quorate) {
856  pfds[0].fd = parent_fd_in;
857  pfds[0].events = 0;
858  pfds[0].revents = 0;
859 
860  pfds[1].fd = sam_internal_data.quorum_fd;
861  pfds[1].events = POLLIN;
862  pfds[1].revents = 0;
863 
864  poll_err = poll (pfds, 2, -1);
865 
866  if (poll_err == -1) {
867  /*
868  * Error in poll
869  * If it is EINTR, continue, otherwise QUIT
870  */
871  if (errno != EINTR) {
872  err = CS_ERR_LIBRARY;
873  goto error_reply;
874  }
875  }
876 
877  if (pfds[0].revents != 0) {
878  if (pfds[0].revents == POLLERR || pfds[0].revents == POLLHUP ||pfds[0].revents == POLLNVAL) {
879  /*
880  * Child has exited
881  */
882  return (CS_OK);
883  }
884  }
885 
886  if (pfds[1].revents != 0) {
887  if ((err = quorum_dispatch (sam_internal_data.quorum_handle, CS_DISPATCH_ONE)) != CS_OK) {
888  goto error_reply;
889  }
890  }
891  }
892 
893  if (sam_internal_data.recovery_policy & SAM_RECOVERY_POLICY_CMAP) {
894  if ((err = sam_cmap_update_key (SAM_CMAP_KEY_STATE, SAM_CMAP_S_STARTED)) != CS_OK) {
895  goto error_reply;
896  }
897  }
898 
899  return (sam_parent_reply_send (CS_OK, parent_fd_in, parent_fd_out));
900 
901 error_reply:
902  if (sam_internal_data.recovery_policy & SAM_RECOVERY_POLICY_CMAP) {
903  sam_cmap_update_key (SAM_CMAP_KEY_STATE, SAM_CMAP_S_REGISTERED);
904  }
905 
906  return (sam_parent_reply_send (err, parent_fd_in, parent_fd_out));
907 }
908 
909 static cs_error_t sam_parent_cmap_state_set (
910  int parent_fd_in,
911  int parent_fd_out,
912  int state)
913 {
914  cs_error_t err;
915  const char *state_s;
916 
917  if (state == 1) {
918  state_s = SAM_CMAP_S_STARTED;
919  } else {
920  state_s = SAM_CMAP_S_REGISTERED;
921  }
922 
923  if ((err = sam_cmap_update_key (SAM_CMAP_KEY_STATE, state_s)) != CS_OK) {
924  goto error_reply;
925  }
926 
927  return (sam_parent_reply_send (CS_OK, parent_fd_in, parent_fd_out));
928 
929 error_reply:
930  return (sam_parent_reply_send (err, parent_fd_in, parent_fd_out));
931 }
932 
933 static cs_error_t sam_parent_kill_child (
934  int *action,
935  pid_t child_pid)
936 {
937  /*
938  * Kill child process
939  */
940  if (!sam_internal_data.term_send) {
941  /*
942  * We didn't send warn_signal yet.
943  */
944  kill (child_pid, sam_internal_data.warn_signal);
945 
946  sam_internal_data.term_send = 1;
947  } else {
948  /*
949  * We sent child warning. Now, we will not be so nice
950  */
951  kill (child_pid, SIGKILL);
952  *action = SAM_PARENT_ACTION_RECOVERY;
953  }
954 
955  return (CS_OK);
956 }
957 
958 static cs_error_t sam_parent_mark_child_failed (
959  int *action,
960  pid_t child_pid)
961 {
962  sam_recovery_policy_t recpol;
963 
964  recpol = sam_internal_data.recovery_policy;
965 
966  sam_internal_data.term_send = 1;
967  sam_internal_data.recovery_policy = SAM_RECOVERY_POLICY_QUIT |
968  (SAM_RP_MASK_C (recpol) ? SAM_RECOVERY_POLICY_CMAP : 0) |
969  (SAM_RP_MASK_Q (recpol) ? SAM_RECOVERY_POLICY_QUORUM : 0);
970 
971  return (sam_parent_kill_child (action, child_pid));
972 }
973 
974 static cs_error_t sam_parent_data_store (
975  int parent_fd_in,
976  int parent_fd_out)
977 {
978  char *user_data;
979  ssize_t size;
980  cs_error_t err;
981 
982  err = CS_OK;
983  user_data = NULL;
984 
985  if (sam_safe_read (parent_fd_in, &size, sizeof (size)) != sizeof (size)) {
986  err = CS_ERR_LIBRARY;
987  goto error_reply;
988  }
989 
990  if (size > 0) {
991  user_data = malloc (size);
992  if (user_data == NULL) {
993  err = CS_ERR_NO_MEMORY;
994  goto error_reply;
995  }
996 
997  if (sam_safe_read (parent_fd_in, user_data, size) != size) {
998  err = CS_ERR_LIBRARY;
999  goto free_error_reply;
1000  }
1001  }
1002 
1003  err = sam_data_store (user_data, size);
1004  if (err != CS_OK) {
1005  goto free_error_reply;
1006  }
1007 
1008  free (user_data);
1009 
1010  return (sam_parent_reply_send (CS_OK, parent_fd_in, parent_fd_out));
1011 
1012 free_error_reply:
1013  free (user_data);
1014 error_reply:
1015  return (sam_parent_reply_send (err, parent_fd_in, parent_fd_out));
1016 }
1017 
1018 static enum sam_parent_action_t sam_parent_handler (
1019  int parent_fd_in,
1020  int parent_fd_out,
1021  pid_t child_pid)
1022 {
1023  int poll_error;
1024  int action;
1025  int status;
1026  ssize_t bytes_read;
1027  char command;
1028  int time_interval;
1029  struct pollfd pfds[2];
1030  nfds_t nfds;
1031  cs_error_t err;
1032  sam_recovery_policy_t recpol;
1033 
1034  status = 0;
1035 
1036  action = SAM_PARENT_ACTION_CONTINUE;
1037  recpol = sam_internal_data.recovery_policy;
1038 
1039  while (action == SAM_PARENT_ACTION_CONTINUE) {
1040  pfds[0].fd = parent_fd_in;
1041  pfds[0].events = POLLIN;
1042  pfds[0].revents = 0;
1043  nfds = 1;
1044 
1045  if (status == 1 && sam_internal_data.time_interval != 0) {
1046  time_interval = sam_internal_data.time_interval;
1047  } else {
1048  time_interval = -1;
1049  }
1050 
1051  if (recpol & SAM_RECOVERY_POLICY_QUORUM) {
1052  pfds[nfds].fd = sam_internal_data.quorum_fd;
1053  pfds[nfds].events = POLLIN;
1054  pfds[nfds].revents = 0;
1055  nfds++;
1056  }
1057 
1058  poll_error = poll (pfds, nfds, time_interval);
1059 
1060  if (poll_error == -1) {
1061  /*
1062  * Error in poll
1063  * If it is EINTR, continue, otherwise QUIT
1064  */
1065  if (errno != EINTR) {
1066  action = SAM_PARENT_ACTION_ERROR;
1067  }
1068  }
1069 
1070  if (poll_error == 0) {
1071  /*
1072  * Time limit expires
1073  */
1074  if (status == 0) {
1075  action = SAM_PARENT_ACTION_QUIT;
1076  } else {
1077  sam_parent_kill_child (&action, child_pid);
1078  }
1079  }
1080 
1081  if (poll_error > 0) {
1082  if (pfds[0].revents != 0) {
1083  /*
1084  * We have EOF or command in pipe
1085  */
1086  bytes_read = sam_safe_read (parent_fd_in, &command, 1);
1087 
1088  if (bytes_read == 0) {
1089  /*
1090  * Handle EOF -> Take recovery action or quit if sam_start wasn't called
1091  */
1092  if (status == 0)
1093  action = SAM_PARENT_ACTION_QUIT;
1094  else
1095  action = SAM_PARENT_ACTION_RECOVERY;
1096 
1097  continue;
1098  }
1099 
1100  if (bytes_read == -1) {
1101  action = SAM_PARENT_ACTION_ERROR;
1102  goto action_exit;
1103  }
1104 
1105  if (recpol & SAM_RECOVERY_POLICY_CMAP) {
1106  sam_cmap_update_key (SAM_CMAP_KEY_LAST_HC, NULL);
1107  }
1108 
1109  /*
1110  * We have read command
1111  */
1112  switch (command) {
1113  case SAM_COMMAND_START:
1114  if (status == 0) {
1115  /*
1116  * Not started yet
1117  */
1118  if (recpol & SAM_RECOVERY_POLICY_QUORUM) {
1119  if (sam_parent_wait_for_quorum (parent_fd_in,
1120  parent_fd_out) != CS_OK) {
1121  continue;
1122  }
1123  }
1124 
1125  if (recpol & SAM_RECOVERY_POLICY_CMAP) {
1126  if (sam_parent_cmap_state_set (parent_fd_in,
1127  parent_fd_out, 1) != CS_OK) {
1128  continue;
1129  }
1130  }
1131 
1132  status = 1;
1133  }
1134  break;
1135  case SAM_COMMAND_STOP:
1136  if (status == 1) {
1137  /*
1138  * Started
1139  */
1140  if (recpol & SAM_RECOVERY_POLICY_CMAP) {
1141  if (sam_parent_cmap_state_set (parent_fd_in,
1142  parent_fd_out, 0) != CS_OK) {
1143  continue;
1144  }
1145  }
1146 
1147  status = 0;
1148  }
1149  break;
1151  sam_parent_data_store (parent_fd_in, parent_fd_out);
1152  break;
1154  sam_parent_warn_signal_set (parent_fd_in, parent_fd_out);
1155  break;
1157  status = 1;
1158  sam_parent_mark_child_failed (&action, child_pid);
1159  break;
1160  }
1161  } /* if (pfds[0].revents != 0) */
1162 
1163  if ((sam_internal_data.recovery_policy & SAM_RECOVERY_POLICY_QUORUM) &&
1164  pfds[1].revents != 0) {
1165  /*
1166  * Handle quorum change
1167  */
1168  err = quorum_dispatch (sam_internal_data.quorum_handle, CS_DISPATCH_ALL);
1169 
1170  if (status == 1 &&
1171  (!sam_internal_data.quorate || (err != CS_ERR_TRY_AGAIN && err != CS_OK))) {
1172  sam_parent_kill_child (&action, child_pid);
1173  }
1174  }
1175  } /* select_error > 0 */
1176  } /* action == SAM_PARENT_ACTION_CONTINUE */
1177 
1178 action_exit:
1179  return action;
1180 }
1181 
1183  unsigned int *instance_id)
1184 {
1185  cs_error_t error;
1186  pid_t pid;
1187  int pipe_error;
1188  int pipe_fd_out[2], pipe_fd_in[2];
1189  enum sam_parent_action_t action, old_action;
1190  int child_status;
1191  sam_recovery_policy_t recpol;
1192 
1193  if (sam_internal_data.internal_status != SAM_INTERNAL_STATUS_INITIALIZED) {
1194  return (CS_ERR_BAD_HANDLE);
1195  }
1196 
1197  recpol = sam_internal_data.recovery_policy;
1198 
1199  if (recpol & SAM_RECOVERY_POLICY_CMAP) {
1200  /*
1201  * Register to cmap
1202  */
1203  if ((error = sam_cmap_register ()) != CS_OK) {
1204  goto error_exit;
1205  }
1206  }
1207 
1208  error = CS_OK;
1209 
1210  while (1) {
1211  if ((pipe_error = pipe (pipe_fd_out)) != 0) {
1212  error = CS_ERR_LIBRARY;
1213  goto error_exit;
1214  }
1215 
1216  if ((pipe_error = pipe (pipe_fd_in)) != 0) {
1217  close (pipe_fd_out[0]);
1218  close (pipe_fd_out[1]);
1219 
1220  error = CS_ERR_LIBRARY;
1221  goto error_exit;
1222  }
1223 
1224  if (recpol & SAM_RECOVERY_POLICY_CMAP) {
1225  if ((error = sam_cmap_update_key (SAM_CMAP_KEY_STATE, SAM_CMAP_S_REGISTERED)) != CS_OK) {
1226  goto error_exit;
1227  }
1228  }
1229 
1230  sam_internal_data.instance_id++;
1231 
1232  sam_internal_data.term_send = 0;
1233 
1234  pid = fork ();
1235 
1236  if (pid == -1) {
1237  /*
1238  * Fork error
1239  */
1240  sam_internal_data.instance_id--;
1241 
1242  error = CS_ERR_LIBRARY;
1243  goto error_exit;
1244  }
1245 
1246  if (pid == 0) {
1247  /*
1248  * Child process
1249  */
1250  close (pipe_fd_out[0]);
1251  close (pipe_fd_in[1]);
1252 
1253  sam_internal_data.child_fd_out = pipe_fd_out[1];
1254  sam_internal_data.child_fd_in = pipe_fd_in[0];
1255 
1256  if (instance_id)
1257  *instance_id = sam_internal_data.instance_id;
1258 
1259  sam_internal_data.am_i_child = 1;
1260  sam_internal_data.internal_status = SAM_INTERNAL_STATUS_REGISTERED;
1261 
1262  pthread_mutex_init (&sam_internal_data.lock, NULL);
1263 
1264  goto error_exit;
1265  } else {
1266  /*
1267  * Parent process
1268  */
1269  close (pipe_fd_out[1]);
1270  close (pipe_fd_in[0]);
1271 
1272  action = sam_parent_handler (pipe_fd_out[0], pipe_fd_in[1], pid);
1273 
1274  close (pipe_fd_out[0]);
1275  close (pipe_fd_in[1]);
1276 
1277  if (action == SAM_PARENT_ACTION_ERROR) {
1278  error = CS_ERR_LIBRARY;
1279  goto error_exit;
1280  }
1281 
1282  /*
1283  * We really don't like zombies
1284  */
1285  while (waitpid (pid, &child_status, 0) == -1 && errno == EINTR)
1286  ;
1287 
1288  old_action = action;
1289 
1290  if (action == SAM_PARENT_ACTION_RECOVERY) {
1291  if (SAM_RP_MASK (sam_internal_data.recovery_policy) == SAM_RECOVERY_POLICY_QUIT)
1292  action = SAM_PARENT_ACTION_QUIT;
1293  }
1294 
1295 
1296  if (action == SAM_PARENT_ACTION_QUIT) {
1297  if (recpol & SAM_RECOVERY_POLICY_QUORUM) {
1298  quorum_finalize (sam_internal_data.quorum_handle);
1299  }
1300 
1301  if (recpol & SAM_RECOVERY_POLICY_CMAP) {
1302  if (old_action == SAM_PARENT_ACTION_RECOVERY) {
1303  /*
1304  * Mark as failed
1305  */
1306  sam_cmap_update_key (SAM_CMAP_KEY_STATE, SAM_CMAP_S_FAILED);
1307  } else {
1308  sam_cmap_destroy_pid_path ();
1309  }
1310  }
1311 
1312  exit (WEXITSTATUS (child_status));
1313  }
1314 
1315 
1316  }
1317  }
1318 
1319 error_exit:
1320  return (error);
1321 }
1322 
1323 static void *hc_callback_thread (void *unused_param)
1324 {
1325  int poll_error;
1326  int status;
1327  ssize_t bytes_readed;
1328  char command;
1329  int time_interval, tmp_time_interval;
1330  int counter;
1331  struct pollfd pfds;
1332 
1333  status = 0;
1334  counter = 0;
1335 
1336  time_interval = sam_internal_data.time_interval >> 2;
1337 
1338  while (1) {
1339  pfds.fd = sam_internal_data.cb_rpipe_fd;
1340  pfds.events = POLLIN;
1341  pfds.revents = 0;
1342 
1343  if (status == 1) {
1344  tmp_time_interval = time_interval;
1345  } else {
1346  tmp_time_interval = -1;
1347  }
1348 
1349  poll_error = poll (&pfds, 1, tmp_time_interval);
1350 
1351  if (poll_error == 0) {
1352  if (sam_hc_send () == CS_OK) {
1353  counter++;
1354  }
1355 
1356  if (counter >= 4) {
1357  if (sam_internal_data.hc_callback () != 0) {
1358  status = 3;
1359  }
1360 
1361  counter = 0;
1362  }
1363  }
1364 
1365  if (poll_error > 0) {
1366  bytes_readed = sam_safe_read (sam_internal_data.cb_rpipe_fd, &command, 1);
1367 
1368  if (bytes_readed > 0) {
1369  if (status == 0 && command == SAM_COMMAND_START)
1370  status = 1;
1371 
1372  if (status == 1 && command == SAM_COMMAND_STOP)
1373  status = 0;
1374 
1375  }
1376  }
1377  }
1378 
1379  /*
1380  * This makes compiler happy, it's same as return (NULL);
1381  */
1382  return (unused_param);
1383 }
1384 
1386 {
1387  cs_error_t error = CS_OK;
1388  pthread_attr_t thread_attr;
1389  int pipe_error;
1390  int pipe_fd[2];
1391 
1392  if (sam_internal_data.internal_status != SAM_INTERNAL_STATUS_REGISTERED) {
1393  return (CS_ERR_BAD_HANDLE);
1394  }
1395 
1396  if (sam_internal_data.time_interval == 0) {
1397  return (CS_ERR_INVALID_PARAM);
1398  }
1399 
1400  if (sam_internal_data.cb_registered) {
1401  sam_internal_data.hc_callback = cb;
1402 
1403  return (CS_OK);
1404  }
1405 
1406  /*
1407  * We know, this is first registration
1408  */
1409 
1410  if (cb == NULL) {
1411  return (CS_ERR_INVALID_PARAM);
1412  }
1413 
1414  pipe_error = pipe (pipe_fd);
1415 
1416  if (pipe_error != 0) {
1417  /*
1418  * Pipe creation error
1419  */
1420  error = CS_ERR_LIBRARY;
1421  goto error_exit;
1422  }
1423 
1424  sam_internal_data.cb_rpipe_fd = pipe_fd[0];
1425  sam_internal_data.cb_wpipe_fd = pipe_fd[1];
1426 
1427  /*
1428  * Create thread attributes
1429  */
1430  error = pthread_attr_init (&thread_attr);
1431  if (error != 0) {
1432  error = CS_ERR_LIBRARY;
1433  goto error_close_fd_exit;
1434  }
1435 
1436 
1437  pthread_attr_setdetachstate (&thread_attr, PTHREAD_CREATE_DETACHED);
1438  pthread_attr_setstacksize (&thread_attr, 32768);
1439 
1440  /*
1441  * Create thread
1442  */
1443  error = pthread_create (&sam_internal_data.cb_thread, &thread_attr, hc_callback_thread, NULL);
1444 
1445  if (error != 0) {
1446  error = CS_ERR_LIBRARY;
1447  goto error_attr_destroy_exit;
1448  }
1449 
1450  /*
1451  * Cleanup
1452  */
1453  pthread_attr_destroy(&thread_attr);
1454 
1455  sam_internal_data.cb_registered = 1;
1456  sam_internal_data.hc_callback = cb;
1457 
1458  return (CS_OK);
1459 
1460 error_attr_destroy_exit:
1461  pthread_attr_destroy(&thread_attr);
1462 error_close_fd_exit:
1463  sam_internal_data.cb_rpipe_fd = sam_internal_data.cb_wpipe_fd = 0;
1464  close (pipe_fd[0]);
1465  close (pipe_fd[1]);
1466 error_exit:
1467  return (error);
1468 }
cs_error_t cmap_set_uint64(cmap_handle_t handle, const char *key_name, uint64_t value)
Definition: lib/cmap.c:440
int child_fd_out
Definition: sam.c:115
int time_interval
Definition: sam.c:111
enum sam_internal_status_t internal_status
Definition: sam.c:113
uint32_t value
#define SAM_RP_MASK_Q(pol)
Definition: sam.c:70
#define SAM_RP_MASK(pol)
Definition: sam.c:72
cs_error_t sam_hc_callback_register(sam_hc_callback_t cb)
Register healtcheck callback.
Definition: sam.c:1385
sam_hc_callback_t hc_callback
Definition: sam.c:121
unsigned int instance_id
Definition: sam.c:114
#define SAM_CMAP_S_STARTED
Definition: sam.c:67
cs_error_t quorum_dispatch(quorum_handle_t handle, cs_dispatch_flags_t dispatch_types)
Dispatch messages and configuration changes.
Definition: lib/quorum.c:351
cs_error_t cmap_iter_next(cmap_handle_t handle, cmap_iter_handle_t iter_handle, char key_name[], size_t *value_len, cmap_value_types_t *type)
Return next item in iterator iter.
Definition: lib/cmap.c:836
int cb_registered
Definition: sam.c:124
cmap_handle_t cmap_handle
Definition: sam.c:136
cs_error_t cmap_initialize(cmap_handle_t *handle)
Create a new cmap connection.
Definition: lib/cmap.c:90
const char * __progname
int term_send
Definition: sam.c:117
cs_error_t sam_initialize(int time_interval, sam_recovery_policy_t recovery_policy)
Create a new SAM connection.
Definition: sam.c:254
quorum_handle_t quorum_handle
Definition: sam.c:132
#define CMAP_KEYNAME_MAXLEN
Definition: cmap.h:69
pthread_t cb_thread
Definition: sam.c:122
cs_error_t cmap_iter_init(cmap_handle_t handle, const char *prefix, cmap_iter_handle_t *cmap_iter_handle)
Initialize iterator with given prefix.
Definition: lib/cmap.c:781
int(* sam_hc_callback_t)(void)
Callback definition for event driven checking.
Definition: sam.h:56
int am_i_child
Definition: sam.c:119
#define SAM_CMAP_S_REGISTERED
Definition: sam.c:66
cs_error_t sam_finalize(void)
Close the SAM handle.
Definition: sam.c:675
sam_recovery_policy_t recovery_policy
Definition: sam.c:112
cs_error_t cmap_iter_finalize(cmap_handle_t handle, cmap_iter_handle_t iter_handle)
Finalize iterator.
Definition: lib/cmap.c:894
#define CS_TRACK_CHANGES
Definition: corotypes.h:75
cs_error_t sam_register(unsigned int *instance_id)
Register application.
Definition: sam.c:1182
cs_error_t sam_hc_send(void)
Send healthcheck confirmation.
Definition: sam.c:659
#define SAM_CMAP_S_Q_WAIT
Definition: sam.c:68
size_t user_data_allocated
Definition: sam.c:128
sam_cmap_key_t
Definition: sam.c:103
cs_error_t sam_mark_failed(void)
Marks child as failed.
Definition: sam.c:699
pthread_mutex_t lock
Definition: sam.c:130
void * user_data
Definition: sam.c:126
char cmap_pid_path[CMAP_KEYNAME_MAXLEN]
Definition: sam.c:137
size_t user_data_size
Definition: sam.c:127
cs_error_t
Definition: corotypes.h:78
sam_internal_status_t
Definition: sam.c:74
int cb_wpipe_fd
Definition: sam.c:123
cs_error_t sam_data_getsize(size_t *size)
Return size of stored data.
Definition: sam.c:410
cs_error_t cmap_set_string(cmap_handle_t handle, const char *key_name, const char *value)
Definition: lib/cmap.c:455
cs_error_t sam_stop(void)
Stop healthchecking.
Definition: sam.c:614
uint32_t quorate
Definition: sam.c:133
uint64_t quorum_handle_t
sam_reply_t
Definition: sam.c:91
cs_error_t sam_data_store(const void *data, size_t size)
Store user data.
Definition: sam.c:477
cs_error_t sam_warn_signal_set(int warn_signal)
Set warning signal to be send.
Definition: sam.c:720
cs_error_t cmap_delete(cmap_handle_t handle, const char *key_name)
Deletes key from cmap database.
Definition: lib/cmap.c:465
int cb_rpipe_fd
Definition: sam.c:123
int warn_signal
Definition: sam.c:118
cs_error_t sam_data_restore(void *data, size_t size)
Return stored data.
Definition: sam.c:432
uint64_t cmap_iter_handle_t
Definition: cmap.h:59
cs_error_t quorum_fd_get(quorum_handle_t handle, int *fd)
Get a file descriptor on which to poll.
Definition: lib/quorum.c:212
quorum_notification_fn_t quorum_notify_fn
int child_fd_in
Definition: sam.c:116
sam_recovery_policy_t
Definition: sam.h:43
sam_command_t
Definition: sam.c:82
cs_error_t quorum_trackstart(quorum_handle_t handle, unsigned int flags)
Track node and quorum changes.
Definition: lib/quorum.c:271
cs_error_t cmap_finalize(cmap_handle_t handle)
Close the cmap handle.
Definition: lib/cmap.c:131
int quorum_fd
Definition: sam.c:134
struct memb_ring_id ring_id
Definition: totemsrp.c:64
cs_error_t quorum_finalize(quorum_handle_t handle)
Close the quorum handle.
Definition: lib/quorum.c:142
#define SAM_CMAP_S_FAILED
Definition: sam.c:65
cs_error_t sam_start(void)
Start healthchecking.
Definition: sam.c:566
#define SAM_RP_MASK_C(pol)
Definition: sam.c:71
uint64_t cmap_handle_t
Definition: cmap.h:54
cs_error_t quorum_initialize(quorum_handle_t *handle, quorum_callbacks_t *callbacks, uint32_t *quorum_type)
Create a new quorum connection.
Definition: lib/quorum.c:69
sam_parent_action_t
Definition: sam.c:96