mirror of
https://git.proxmox.com/git/mirror_corosync
synced 2025-07-25 09:13:26 +00:00
da6fce352b
Ability to in-memory storing of user data which survives between instances of process. Also ability needed ability for bi-directional communication between child and parent is added. git-svn-id: http://svn.fedorahosted.org/svn/corosync/trunk@2769 fd59a12c-fef9-0310-b244-a6a79926bd2f
701 lines
18 KiB
C
701 lines
18 KiB
C
/*
|
|
* Copyright (c) 2009 Red Hat, Inc.
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* Author: Jan Friesse (jfriesse@redhat.com)
|
|
*
|
|
* This software licensed under BSD license, the text of which follows:
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* - Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* - Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
* - Neither the name of the Red Hat, Inc. nor the names of its
|
|
* contributors may be used to endorse or promote products derived from this
|
|
* software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
|
* THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
/*
|
|
* Provides test of SAM API
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#include <sys/types.h>
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <corosync/corotypes.h>
|
|
#include <corosync/sam.h>
|
|
#include <signal.h>
|
|
#include <string.h>
|
|
#include <sys/wait.h>
|
|
|
|
static int test2_sig_delivered = 0;
|
|
static int test5_hc_cb_count = 0;
|
|
|
|
/*
|
|
* First test will just register SAM, with policy restart. First instance will
|
|
* sleep one second, send hc and sleep another 3 seconds. This should force restart.
|
|
* Second instance will sleep one second, send hc, stop hc and sleep 3 seconds.
|
|
* Then start hc again and sleep 3 seconds. This should force restart again.
|
|
* Last instance just calls initialize again. This should end with error.
|
|
* Then call start, followed by stop and start again. Finally, we will call finalize
|
|
* twice. One should succeed, second should fail. After this, we will call every function
|
|
* (none should succeed).
|
|
*/
|
|
static int test1 (void)
|
|
{
|
|
cs_error_t error;
|
|
unsigned int instance_id;
|
|
int i;
|
|
|
|
printf ("%s: initialize\n", __FUNCTION__);
|
|
error = sam_initialize (2000, SAM_RECOVERY_POLICY_RESTART);
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "Can't initialize SAM API. Error %d\n", error);
|
|
return 1;
|
|
}
|
|
printf ("%s: register\n", __FUNCTION__);
|
|
error = sam_register (&instance_id);
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "Can't register. Error %d\n", error);
|
|
return 1;
|
|
}
|
|
|
|
if (instance_id == 1 || instance_id == 2) {
|
|
printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
|
|
error = sam_start ();
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "Can't start hc. Error %d\n", error);
|
|
return 1;
|
|
}
|
|
|
|
for (i = 0; i < 10; i++) {
|
|
printf ("%s iid %d: sleep 1\n", __FUNCTION__, instance_id);
|
|
sleep (1);
|
|
|
|
printf ("%s iid %d: hc send\n", __FUNCTION__, instance_id);
|
|
error = sam_hc_send ();
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "Can't send hc. Error %d\n", error);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if (instance_id == 2) {
|
|
printf ("%s iid %d: stop\n", __FUNCTION__, instance_id);
|
|
error = sam_stop ();
|
|
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "Can't send hc. Error %d\n", error);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
printf ("%s iid %d: sleep 3\n", __FUNCTION__, instance_id);
|
|
sleep (3);
|
|
|
|
printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
|
|
error = sam_start ();
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "Can't start hc. Error %d\n", error);
|
|
return 1;
|
|
}
|
|
|
|
printf ("%s iid %d: sleep 3\n", __FUNCTION__, instance_id);
|
|
sleep (3);
|
|
return 0;
|
|
}
|
|
|
|
if (instance_id == 3) {
|
|
error = sam_initialize (2000, SAM_RECOVERY_POLICY_RESTART);
|
|
if (error == CS_OK) {
|
|
fprintf (stderr, "Can initialize SAM API after initialization");
|
|
return 1;
|
|
}
|
|
|
|
error = sam_start ();
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "Can't start hc. Error %d\n", error);
|
|
return 1;
|
|
}
|
|
error = sam_stop ();
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "Can't stop hc. Error %d\n", error);
|
|
return 1;
|
|
}
|
|
error = sam_finalize ();
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "Can't finalize sam. Error %d\n", error);
|
|
return 1;
|
|
}
|
|
error = sam_finalize ();
|
|
if (error == CS_OK) {
|
|
fprintf (stderr, "Can finalize sam after finalization!\n");
|
|
return 1;
|
|
}
|
|
|
|
if (sam_initialize (2, SAM_RECOVERY_POLICY_RESTART) == CS_OK ||
|
|
sam_start () == CS_OK || sam_stop () == CS_OK ||
|
|
sam_register (NULL) == CS_OK || sam_hc_send () == CS_OK ||
|
|
sam_hc_callback_register (NULL) == CS_OK) {
|
|
|
|
fprintf (stderr, "Can call one of function after finalization!\n");
|
|
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
static void test2_signal (int sig) {
|
|
printf ("%s\n", __FUNCTION__);
|
|
|
|
test2_sig_delivered = 1;
|
|
}
|
|
|
|
/*
|
|
* This tests recovery policy quit and callback.
|
|
*/
|
|
static int test2 (void) {
|
|
cs_error_t error;
|
|
unsigned int instance_id;
|
|
|
|
printf ("%s: initialize\n", __FUNCTION__);
|
|
error = sam_initialize (2000, SAM_RECOVERY_POLICY_QUIT);
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "Can't initialize SAM API. Error %d\n", error);
|
|
return 1;
|
|
}
|
|
printf ("%s: register\n", __FUNCTION__);
|
|
error = sam_register (&instance_id);
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "Can't register. Error %d\n", error);
|
|
return 1;
|
|
}
|
|
|
|
if (instance_id == 1) {
|
|
signal (SIGTERM, test2_signal);
|
|
|
|
printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
|
|
error = sam_start ();
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "Can't start hc. Error %d\n", error);
|
|
return 1;
|
|
}
|
|
|
|
printf ("%s iid %d: sleep 1\n", __FUNCTION__, instance_id);
|
|
sleep (1);
|
|
|
|
printf ("%s iid %d: hc send\n", __FUNCTION__, instance_id);
|
|
error = sam_hc_send ();
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "Can't send hc. Error %d\n", error);
|
|
return 1;
|
|
}
|
|
|
|
|
|
printf ("%s iid %d: wait for delivery of signal\n", __FUNCTION__, instance_id);
|
|
while (!test2_sig_delivered) {
|
|
sleep (1);
|
|
}
|
|
|
|
printf ("%s iid %d: wait for real kill\n", __FUNCTION__, instance_id);
|
|
|
|
sleep (3);
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
/*
|
|
* Smoke test. Better to turn off coredump ;) This has no time limit, just restart process
|
|
* when it dies.
|
|
*/
|
|
static int test3 (void) {
|
|
cs_error_t error;
|
|
unsigned int instance_id;
|
|
int tmp1, tmp2, tmp3;
|
|
|
|
printf ("%s: initialize\n", __FUNCTION__);
|
|
error = sam_initialize (0, SAM_RECOVERY_POLICY_RESTART);
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "Can't initialize SAM API. Error %d\n", error);
|
|
return 1;
|
|
}
|
|
printf ("%s: register\n", __FUNCTION__);
|
|
error = sam_register (&instance_id);
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "Can't register. Error %d\n", error);
|
|
return 1;
|
|
}
|
|
|
|
if (instance_id < 100) {
|
|
printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
|
|
error = sam_start ();
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "Can't start hc. Error %d\n", error);
|
|
return 1;
|
|
}
|
|
|
|
printf ("%s iid %d: divide by zero\n", __FUNCTION__, instance_id);
|
|
tmp2 = rand ();
|
|
tmp3 = 0;
|
|
tmp1 = tmp2 / tmp3;
|
|
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/*
|
|
* Test sam_data_store, sam_data_restore and sam_data_getsize
|
|
*/
|
|
static int test4 (void)
|
|
{
|
|
size_t size;
|
|
cs_error_t err;
|
|
int i;
|
|
unsigned int instance_id;
|
|
char saved_data[128];
|
|
char saved_data2[128];
|
|
|
|
printf ("%s: sam_data_getsize 1\n", __FUNCTION__);
|
|
err = sam_data_getsize (&size);
|
|
if (err != CS_ERR_BAD_HANDLE) {
|
|
fprintf (stderr, "Test should return CS_ERR_BAD_HANDLE. Error returned %d\n", err);
|
|
return 1;
|
|
}
|
|
|
|
printf ("%s: sam_data_getsize 2\n", __FUNCTION__);
|
|
err = sam_data_getsize (NULL);
|
|
if (err != CS_ERR_INVALID_PARAM) {
|
|
fprintf (stderr, "Test should return CS_ERR_INVALID_PARAM. Error returned %d\n", err);
|
|
return 1;
|
|
}
|
|
|
|
printf ("%s: sam_data_store 1\n", __FUNCTION__);
|
|
err = sam_data_store (NULL, 0);
|
|
if (err != CS_ERR_BAD_HANDLE) {
|
|
fprintf (stderr, "Test should return CS_ERR_BAD_HANDLE. Error returned %d\n", err);
|
|
return 1;
|
|
}
|
|
|
|
printf ("%s: sam_data_restore 1\n", __FUNCTION__);
|
|
err = sam_data_restore (saved_data, sizeof (saved_data));
|
|
if (err != CS_ERR_BAD_HANDLE) {
|
|
fprintf (stderr, "Test should return CS_ERR_BAD_HANDLE. Error returned %d\n", err);
|
|
return 1;
|
|
}
|
|
|
|
printf ("%s: sam_initialize\n", __FUNCTION__);
|
|
err = sam_initialize (0, SAM_RECOVERY_POLICY_RESTART);
|
|
if (err != CS_OK) {
|
|
fprintf (stderr, "Can't initialize SAM API. Error %d\n", err);
|
|
return 1;
|
|
}
|
|
|
|
printf ("%s: sam_data_getsize 3\n", __FUNCTION__);
|
|
err = sam_data_getsize (&size);
|
|
if (err != CS_OK) {
|
|
fprintf (stderr, "Test should return CS_ERR_BAD_HANDLE. Error returned %d\n", err);
|
|
return 1;
|
|
}
|
|
if (size != 0) {
|
|
fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
|
|
return 1;
|
|
}
|
|
|
|
printf ("%s: sam_data_restore 2\n", __FUNCTION__);
|
|
err = sam_data_restore (NULL, sizeof (saved_data));
|
|
if (err != CS_ERR_INVALID_PARAM) {
|
|
fprintf (stderr, "Test should return CS_ERR_INVALID_PARAM. Error returned %d\n", err);
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Store some real data
|
|
*/
|
|
for (i = 0; i < sizeof (saved_data); i++) {
|
|
saved_data[i] = (char)(i + 5);
|
|
}
|
|
|
|
printf ("%s: sam_data_store 2\n", __FUNCTION__);
|
|
err = sam_data_store (saved_data, sizeof (saved_data));
|
|
if (err != CS_OK) {
|
|
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
|
|
return 1;
|
|
}
|
|
|
|
printf ("%s: sam_data_getsize 4\n", __FUNCTION__);
|
|
err = sam_data_getsize (&size);
|
|
if (err != CS_OK) {
|
|
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
|
|
return 1;
|
|
}
|
|
if (size != sizeof (saved_data)) {
|
|
fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
|
|
return 1;
|
|
}
|
|
|
|
printf ("%s: sam_data_restore 3\n", __FUNCTION__);
|
|
err = sam_data_restore (saved_data2, sizeof (saved_data2) - 1);
|
|
if (err != CS_ERR_INVALID_PARAM) {
|
|
fprintf (stderr, "Test should return CS_ERR_INVALID_PARAM. Error returned %d\n", err);
|
|
return 1;
|
|
}
|
|
|
|
printf ("%s: sam_data_restore 4\n", __FUNCTION__);
|
|
err = sam_data_restore (saved_data2, sizeof (saved_data2));
|
|
if (err != CS_OK) {
|
|
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
|
|
return 1;
|
|
}
|
|
|
|
if (memcmp (saved_data, saved_data2, sizeof (saved_data2)) != 0) {
|
|
fprintf (stderr, "Retored data are not same\n");
|
|
return 1;
|
|
}
|
|
|
|
memset (saved_data2, 0, sizeof (saved_data2));
|
|
|
|
printf ("%s: sam_data_store 3\n", __FUNCTION__);
|
|
err = sam_data_store (NULL, 1);
|
|
if (err != CS_OK) {
|
|
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
|
|
return 1;
|
|
}
|
|
|
|
printf ("%s: sam_data_getsize 5\n", __FUNCTION__);
|
|
err = sam_data_getsize (&size);
|
|
if (err != CS_OK) {
|
|
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
|
|
return 1;
|
|
}
|
|
if (size != 0) {
|
|
fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
|
|
return 1;
|
|
}
|
|
|
|
printf ("%s: sam_data_store 4\n", __FUNCTION__);
|
|
err = sam_data_store (saved_data, sizeof (saved_data));
|
|
if (err != CS_OK) {
|
|
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
|
|
return 1;
|
|
}
|
|
|
|
printf ("%s: register\n", __FUNCTION__);
|
|
err = sam_register (&instance_id);
|
|
if (err != CS_OK) {
|
|
fprintf (stderr, "Can't register. Error %d\n", err);
|
|
return 1;
|
|
}
|
|
|
|
if (instance_id == 1) {
|
|
printf ("%s iid %d: sam_start\n", __FUNCTION__, instance_id);
|
|
err = sam_start ();
|
|
if (err != CS_OK) {
|
|
fprintf (stderr, "Can't start hc. Error %d\n", err);
|
|
return 1;
|
|
}
|
|
|
|
printf ("%s iid %d: sam_data_getsize 6\n", __FUNCTION__, instance_id);
|
|
err = sam_data_getsize (&size);
|
|
if (err != CS_OK) {
|
|
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
|
|
return 1;
|
|
}
|
|
if (size != sizeof (saved_data2)) {
|
|
fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
|
|
return 1;
|
|
}
|
|
|
|
printf ("%s iid %d: sam_data_restore 5\n", __FUNCTION__, instance_id);
|
|
err = sam_data_restore (saved_data2, sizeof (saved_data2));
|
|
if (err != CS_OK) {
|
|
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
|
|
return 1;
|
|
}
|
|
|
|
if (memcmp (saved_data, saved_data2, sizeof (saved_data2)) != 0) {
|
|
fprintf (stderr, "Retored data are not same\n");
|
|
return 1;
|
|
}
|
|
|
|
for (i = 0; i < sizeof (saved_data); i++) {
|
|
saved_data[i] = (char)(i - 5);
|
|
}
|
|
|
|
printf ("%s iid %d: sam_data_store 5\n", __FUNCTION__, instance_id);
|
|
err = sam_data_store (saved_data, sizeof (saved_data) - 7);
|
|
if (err != CS_OK) {
|
|
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
|
|
return 1;
|
|
}
|
|
|
|
exit (1);
|
|
}
|
|
|
|
if (instance_id == 2) {
|
|
printf ("%s iid %d: sam_start\n", __FUNCTION__, instance_id);
|
|
err = sam_start ();
|
|
if (err != CS_OK) {
|
|
fprintf (stderr, "Can't start hc. Error %d\n", err);
|
|
return 1;
|
|
}
|
|
|
|
printf ("%s iid %d: sam_data_getsize 7\n", __FUNCTION__, instance_id);
|
|
err = sam_data_getsize (&size);
|
|
if (err != CS_OK) {
|
|
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
|
|
return 1;
|
|
}
|
|
if (size != sizeof (saved_data2) - 7) {
|
|
fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
|
|
return 1;
|
|
}
|
|
|
|
printf ("%s iid %d: sam_data_restore 6\n", __FUNCTION__, instance_id);
|
|
err = sam_data_restore (saved_data2, sizeof (saved_data2));
|
|
if (err != CS_OK) {
|
|
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
|
|
return 1;
|
|
}
|
|
|
|
for (i = 0; i < sizeof (saved_data); i++) {
|
|
saved_data[i] = (char)(i - 5);
|
|
}
|
|
|
|
if (memcmp (saved_data, saved_data2, sizeof (saved_data2) - 7) != 0) {
|
|
fprintf (stderr, "Retored data are not same\n");
|
|
return 1;
|
|
}
|
|
|
|
printf ("%s iid %d: sam_data_store 6\n", __FUNCTION__, instance_id);
|
|
err = sam_data_store (NULL, 0);
|
|
if (err != CS_OK) {
|
|
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
|
|
return 1;
|
|
}
|
|
|
|
exit (1);
|
|
}
|
|
|
|
if (instance_id == 3) {
|
|
printf ("%s iid %d: sam_data_getsize 8\n", __FUNCTION__, instance_id);
|
|
err = sam_data_getsize (&size);
|
|
if (err != CS_OK) {
|
|
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
|
|
return 1;
|
|
}
|
|
if (size != 0) {
|
|
fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
static int test5_hc_cb (void)
|
|
{
|
|
printf ("%s %d\n", __FUNCTION__, ++test5_hc_cb_count);
|
|
|
|
sam_data_store (&test5_hc_cb_count, sizeof (test5_hc_cb_count));
|
|
|
|
if (test5_hc_cb_count > 10)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
/*
|
|
* Test event driven healtchecking.
|
|
*/
|
|
static int test5 (void)
|
|
{
|
|
cs_error_t error;
|
|
unsigned int instance_id;
|
|
int hc_cb_count;
|
|
|
|
printf ("%s: initialize\n", __FUNCTION__);
|
|
error = sam_initialize (100, SAM_RECOVERY_POLICY_RESTART);
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "Can't initialize SAM API. Error %d\n", error);
|
|
return 1;
|
|
}
|
|
printf ("%s: register\n", __FUNCTION__);
|
|
error = sam_register (&instance_id);
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "Can't register. Error %d\n", error);
|
|
return 1;
|
|
}
|
|
|
|
if (instance_id == 1) {
|
|
printf ("%s iid %d: hc callback register\n", __FUNCTION__, instance_id);
|
|
error = sam_hc_callback_register (test5_hc_cb);
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "Can't register hc cb. Error %d\n", error);
|
|
return 1;
|
|
}
|
|
|
|
|
|
printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
|
|
error = sam_start ();
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "Can't start hc. Error %d\n", error);
|
|
return 1;
|
|
}
|
|
|
|
sleep (2);
|
|
|
|
printf ("%s iid %d: Failed. Wasn't killed.\n", __FUNCTION__, instance_id);
|
|
return 1;
|
|
}
|
|
|
|
if (instance_id == 2) {
|
|
error = sam_data_restore (&hc_cb_count, sizeof (hc_cb_count));
|
|
if (error != CS_OK) {
|
|
fprintf (stderr, "sam_data_restore should return CS_OK. Error returned %d\n", error);
|
|
return 1;
|
|
}
|
|
|
|
if (hc_cb_count != 11) {
|
|
fprintf (stderr, "%s iid %d: Premature killed. hc_cb_count should be 11 and it is %d\n",
|
|
__FUNCTION__, instance_id - 1, hc_cb_count);
|
|
return 1;
|
|
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
pid_t pid;
|
|
int err;
|
|
int stat;
|
|
int all_passed = 1;
|
|
|
|
pid = fork ();
|
|
|
|
if (pid == -1) {
|
|
fprintf (stderr, "Can't fork\n");
|
|
return 1;
|
|
}
|
|
|
|
if (pid == 0) {
|
|
return (test1 ());
|
|
}
|
|
|
|
waitpid (pid, &stat, 0);
|
|
|
|
fprintf (stderr, "test1 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
|
|
if (WEXITSTATUS (stat) != 0)
|
|
all_passed = 0;
|
|
|
|
pid = fork ();
|
|
|
|
if (pid == -1) {
|
|
fprintf (stderr, "Can't fork\n");
|
|
return 1;
|
|
}
|
|
|
|
if (pid == 0) {
|
|
err = test2 ();
|
|
|
|
return err;
|
|
}
|
|
|
|
waitpid (pid, &stat, 0);
|
|
|
|
fprintf (stderr, "test2 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
|
|
if (WEXITSTATUS (stat) != 0)
|
|
all_passed = 0;
|
|
|
|
pid = fork ();
|
|
|
|
if (pid == -1) {
|
|
fprintf (stderr, "Can't fork\n");
|
|
return 1;
|
|
}
|
|
|
|
if (pid == 0) {
|
|
return (test3 ());
|
|
}
|
|
|
|
waitpid (pid, &stat, 0);
|
|
|
|
fprintf (stderr, "test3 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
|
|
if (WEXITSTATUS (stat) != 0)
|
|
all_passed = 0;
|
|
|
|
pid = fork ();
|
|
|
|
if (pid == -1) {
|
|
fprintf (stderr, "Can't fork\n");
|
|
return 1;
|
|
}
|
|
|
|
if (pid == 0) {
|
|
return (test4 ());
|
|
}
|
|
|
|
waitpid (pid, &stat, 0);
|
|
|
|
fprintf (stderr, "test4 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
|
|
if (WEXITSTATUS (stat) != 0)
|
|
all_passed = 0;
|
|
|
|
pid = fork ();
|
|
|
|
if (pid == -1) {
|
|
fprintf (stderr, "Can't fork\n");
|
|
return 1;
|
|
}
|
|
|
|
if (pid == 0) {
|
|
err = test5 ();
|
|
|
|
return err;
|
|
}
|
|
|
|
waitpid (pid, &stat, 0);
|
|
fprintf (stderr, "test5 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
|
|
if (WEXITSTATUS (stat) != 0)
|
|
all_passed = 0;
|
|
|
|
if (all_passed)
|
|
fprintf (stderr, "All tests passed\n");
|
|
|
|
return (all_passed ? 0 : 1);
|
|
}
|