testcases/kernel/syscalls/ipc/shmctl/shmctl01.c

/*
 *
 *   Copyright (c) International Business Machines  Corp., 2001
 *
 *   This program is free software;  you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 *   the GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program;  if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/*
 * NAME
 *	shmctl01.c
 *
 * DESCRIPTION
 *	shmctl01 - test the IPC_STAT, IPC_SET and IPC_RMID commands as
 *		   they are used with shmctl()
 *
 * ALGORITHM
 *	loop if that option was specified
 *	create a shared memory segment with read and write permission
 *	set up any test case specific conditions
 *	call shmctl() using the TEST macro
 *	check the return code
 *	  if failure, issue a FAIL message.
 *	otherwise,
 *	  if doing functionality testing
 *		call the correct test function
 *	  	if the conditions are correct,
 *			issue a PASS message
 *		otherwise
 *			issue a FAIL message
 *	  otherwise
 *	    issue a PASS message
 *	call cleanup
 *
 * USAGE:  <for command-line>
 *  shmctl01 [-c n] [-f] [-i n] [-I x] [-P x] [-t]
 *     where,  -c n : Run n copies concurrently.
 *             -f   : Turn off functionality Testing.
 *	       -i n : Execute test n times.
 *	       -I x : Execute test for x seconds.
 *	       -P x : Pause for x seconds between iterations.
 *	       -t   : Turn on syscall timing.
 *
 * HISTORY
 *	03/2001 - Written by Wayne Boyer
 *      02/04/2008 Renaud Lottiaux (Renaud.Lottiaux@kerlabs.com)
 *      - Fix concurrency issue. Replace the sleep used for synchronization
 *        with the new pipe based synchronization functions.
 *
 * RESTRICTIONS
 *	none
 */

#include "ipcshm.h"
#include "libtestsuite.h"

char *TCID = "shmctl01";

int shm_id_1 = -1;
struct shmid_ds buf;
long save_time;

#define FIRST	0
#define SECOND	1
int stat_time;			/* set to either FIRST or SECOND for IPC_STAT tests */

void *set_shared;

#define N_ATTACH	4

pid_t pid_arr[N_ATTACH];
int sync_pipes[2];

/*
 * These are the various setup and check functions for the commands
 * that we are checking.
 */

/* Setup, cleanup and check routines for IPC_STAT */
void stat_setup(void), func_stat(void);
void stat_cleanup(void);

/* Setup and check routines for IPC_SET */
void set_setup(void), func_set(void);

/* Check routine for IPC_RMID */
void func_rmid(void);

/* Child function */
void do_child(void);

struct test_case_t {
	int cmd;		/* the command to test */
	void (*func_test) ();	/* the test function */
	void (*func_setup) ();	/* the setup function if necessary */
} TC[] = {

	{
	IPC_STAT, func_stat, stat_setup},
#ifndef UCLINUX
	    /* The second test is not applicable to uClinux; shared memory segments
	       are detached on exec(), so cannot be passed to uClinux children. */
	{
	IPC_STAT, func_stat, stat_setup},
#endif
	{
	IPC_SET, func_set, set_setup}, {
	IPC_RMID, func_rmid, NULL}
};

int TST_TOTAL = (sizeof(TC) / sizeof(*TC));

#define NEWMODE	0066

#ifdef UCLINUX
#define PIPE_NAME	"shmctl01"
static char *argv0;
#endif

static int stat_i;		/* Shared between do_child and stat_setup */

int main(int ac, char **av)
{
	int lc;			/* loop counter */
	char *msg;		/* message returned from parse_opts */
	int i;
	void check_functionality(void);

	/* parse standard options */
	if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
#ifdef UCLINUX
	argv0 = av[0];
	maybe_run_child(do_child, "ddd", &stat_i, &stat_time, &shm_id_1);
#endif

	setup();		/* global setup */

	/* The following loop checks looping state if -i option given */

	for (lc = 0; TEST_LOOPING(lc); lc++) {
		/* reset Tst_count in case we are looping */
		Tst_count = 0;

		/* initialize stat_time */
		stat_time = FIRST;

		/*
		 * Create a shared memory segment with read and write
		 * permissions.  Do this here instead of in setup()
		 * so that looping (-i) will work correctly.
		 */
		if ((shm_id_1 = shmget(shmkey, SHM_SIZE, IPC_CREAT | IPC_EXCL |
				       SHM_RW)) == -1) {
			tst_brkm(TBROK, cleanup, "couldn't create the shared"
				 " memory segment");
		}

		/* loop through the test cases */
		for (i = 0; i < TST_TOTAL; i++) {

			/*
			 * if needed, set up any required conditions by
			 * calling the appropriate setup function
			 */
			if (TC[i].func_setup != NULL) {
				(*TC[i].func_setup) ();
			}

			/*
			 * Use TEST macro to make the call
			 */

			TEST(shmctl(shm_id_1, TC[i].cmd, &buf));

			if (TEST_RETURN == -1) {
				tst_resm(TFAIL, "%s call failed - errno "
					 "= %d : %s", TCID, TEST_ERRNO,
					 strerror(TEST_ERRNO));
				continue;
			}
			if (STD_FUNCTIONAL_TEST) {
				(*TC[i].func_test) ();
			} else {
				tst_resm(TPASS, "call succeeded");

				/* now perform command related cleanup */
				switch (TC[i].cmd) {
				case IPC_STAT:
					stat_cleanup();
					break;
				case IPC_RMID:
					shm_id_1 = -1;
					break;
				}
			}
		}
	}

	cleanup();

	tst_exit();
}

/*
 * set_shmat() - Attach the shared memory and return the pointer.  Use
 *		 this seperate routine to avoid code duplication in
 *		 stat_setup() below.
 */
void *set_shmat()
{
	void *rval;

	/* attach the shared memory */
	rval = shmat(shm_id_1, 0, 0);

	/*
	 * if shmat() fails, the only thing we can do is
	 * print a message to that effect.
	 */
	if (rval == (void *)-1) {
		tst_resm(TBROK, "shmat() failed - %s", strerror(errno));
		cleanup();
	}

	return rval;
}

/*
 * stat_setup() - Set up for the IPC_STAT command with shmctl().
 *		  Make things interesting by forking some children
 *		  that will either attach or inherit the shared memory.
 */
void stat_setup()
{
	void *set_shmat();
	pid_t pid;

	/*
	 * The first time through, let the children attach the memory.
	 * The second time through, attach the memory first and let
	 * the children inherit the memory.
	 */

	if (stat_time == SECOND) {
		/*
		 * use the global "set_shared" variable here so that
		 * it can be removed in the stat_func() routine.
		 */
		set_shared = set_shmat();
	}

	tst_flush();
	for (stat_i = 0; stat_i < N_ATTACH; stat_i++) {
		if (sync_pipe_create(sync_pipes, PIPE_NAME) == -1)
			tst_brkm(TBROK, cleanup, "sync_pipe_create failed");

		if ((pid = FORK_OR_VFORK()) == -1) {
			tst_brkm(TBROK, cleanup, "could not fork");
		}

		if (pid == 0) {	/* child */
#ifdef UCLINUX
			if (self_exec(argv0, "ddd", stat_i, stat_time,
				      shm_id_1) < 0) {
				tst_brkm(TBROK, cleanup, "could not self_exec");
			}
#else
			do_child();
#endif

		} else {	/* parent */
			/* save the child's pid for cleanup later */
			pid_arr[stat_i] = pid;
			if (sync_pipe_wait(sync_pipes) == -1)
				tst_brkm(TBROK, cleanup,
					 "sync_pipe_wait failed");

			if (sync_pipe_close(sync_pipes, PIPE_NAME) == -1)
				tst_brkm(TBROK, cleanup,
					 "sync_pipe_close failed");
		}
	}
	/* Wait 1 second to be sure all sons are in the pause function. */
	sleep(1);
}

/*
 * do_child
 */
void do_child()
{
	int rval;
	void *test;

#ifdef UCLINUX
	if (sync_pipe_create(sync_pipes, PIPE_NAME) == -1)
		tst_brkm(TBROK, cleanup, "sync_pipe_create failed");
#endif

	if (stat_time == FIRST) {
		test = set_shmat();
	} else {
		test = set_shared;
	}

	if (sync_pipe_notify(sync_pipes) == -1)
		tst_brkm(TBROK, cleanup, "sync_pipe_notify failed");
#ifdef UCLINUX
	if (sync_pipe_close(sync_pipes, NULL) == -1)
#else
	if (sync_pipe_close(sync_pipes, PIPE_NAME) == -1)
#endif
		tst_brkm(TBROK, cleanup, "sync_pipe_close failed");

	/* do an assignement for fun */
	memcpy(test, &stat_i, sizeof(stat_i));

	/* pause until we get a signal from stat_cleanup() */
	rval = pause();

	/* now we're back - detach the memory and exit */
	if (shmdt(test) == -1) {
		tst_resm(TBROK, "shmdt() failed - %d", errno);
	}
	tst_exit();
}

/*
 * func_stat() - check the functionality of the IPC_STAT command with shmctl()
 *		 by looking at the pid of the creator, the segement size,
 *		 the number of attaches and the mode.
 */
void func_stat()
{
	int fail = 0;
	pid_t pid;

	/* check perm, pid, nattach and size */

	pid = getpid();

	if (buf.shm_cpid != pid) {
		tst_resm(TFAIL, "creator pid is incorrect");
		fail = 1;
	}

	if (!fail && buf.shm_segsz != SHM_SIZE) {
		tst_resm(TFAIL, "segment size is incorrect");
		fail = 1;
	}

	/*
	 * The first time through, only the children attach the memory, so
	 * the attaches equal N_ATTACH + stat_time (0).  The second time
	 * through, the parent attaches the memory and the children inherit
	 * that memory so the attaches equal N_ATTACH + stat_time (1).
	 */
	if (!fail && buf.shm_nattch != N_ATTACH + stat_time) {
		tst_resm(TFAIL, "# of attaches is incorrect - %ld",
			 buf.shm_nattch);
		fail = 1;
	}

	/* use MODE_MASK to make sure we are comparing the last 9 bits */
	if (!fail && (buf.shm_perm.mode & MODE_MASK) != ((SHM_RW) & MODE_MASK)) {
		tst_resm(TFAIL, "segment mode is incorrect");
		fail = 1;
	}

	stat_cleanup();

	/* save the change time for use in the next test */
	save_time = buf.shm_ctime;

	if (fail) {
		return;
	}

	tst_resm(TPASS, "pid, size, # of attaches and mode are correct "
		 "- pass #%d", stat_time);
}

/*
 * stat_cleanup() - signal the children to clean up after themselves and
 *		    have the parent make dessert, er, um, make that remove
 *		    the shared memory that is no longer needed.
 */
void stat_cleanup()
{
	int i;

	/* wake up the childern so they can detach the memory and exit */
	for (i = 0; i < N_ATTACH; i++) {
		if (kill(pid_arr[i], SIGUSR1) == -1) {
			tst_brkm(TBROK, cleanup, "kill failed");
		}
	}

	/* remove the parent's shared memory the second time through */
	if (stat_time == SECOND) {
		if (shmdt(set_shared) == -1) {
			tst_resm(TINFO, "shmdt() failed");
		}
	}

	for (i = 0; i < N_ATTACH; i++) {
		if (waitpid(pid_arr[i], NULL, 0) == -1)
			tst_brkm(TBROK, cleanup, "waitpid failed");
	}

	stat_time++;
}

/*
 * set_setup() - set up for the IPC_SET command with shmctl()
 */
void set_setup()
{
	/* set up a new mode for the shared memory segment */
	buf.shm_perm.mode = SHM_RW | NEWMODE;

	/* sleep for one second to get a different shm_ctime value */
	sleep(1);
}

/*
 * func_set() - check the functionality of the IPC_SET command with shmctl()
 */
void func_set()
{
	int fail = 0;

	/* first stat the shared memory to get the new data */
	if (shmctl(shm_id_1, IPC_STAT, &buf) == -1) {
		tst_resm(TBROK, "stat failed in func_set()");
		return;
	}

	if ((buf.shm_perm.mode & MODE_MASK) != ((SHM_RW | NEWMODE) & MODE_MASK)) {
		tst_resm(TFAIL, "new mode is incorrect");
		fail = 1;
	}

	if (!fail && save_time >= buf.shm_ctime) {
		tst_resm(TFAIL, "change time is incorrect");
		fail = 1;
	}

	if (fail) {
		return;
	}

	tst_resm(TPASS, "new mode and change time are correct");
}

/*
 * func_rmid() - check the functionality of the IPC_RMID command with shmctl()
 */
void func_rmid()
{
	/* Do another shmctl() - we should get EINVAL */
	if (shmctl(shm_id_1, IPC_STAT, &buf) != -1) {
		tst_brkm(TBROK, cleanup, "shmctl succeeded on expected fail");
	}

	if (errno != EINVAL) {
		tst_resm(TFAIL, "returned unexpected errno %d", errno);
	} else {
		tst_resm(TPASS, "shared memory appears to be removed");
	}

	shm_id_1 = -1;
}

/*
 * sighandler() - handle signals, in this case SIGUSR1 is the only one expected
 */
void sighandler(sig)
{
	if (sig != SIGUSR1)
		tst_resm(TBROK, "received unexpected signal %d", sig);
}

void setup(void)
{

	tst_sig(FORK, sighandler, cleanup);

	TEST_PAUSE;

	/*
	 * Create a temporary directory and cd into it.
	 * This helps to ensure that a unique msgkey is created.
	 * See ../lib/libipc.c for more information.
	 */
	tst_tmpdir();

	/* get an IPC resource key */
	shmkey = getipckey();
}

/*
 * cleanup() - performs all the ONE TIME cleanup for this test at completion
 * 	       or premature exit.
 */
void cleanup(void)
{
	/* if it exists, remove the shared memory segment */
	rm_shm(shm_id_1);

	tst_rmdir();

	/*
	 * print timing stats if that option was specified.
	 * print errno log if that option was specified.
	 */
	TEST_CLEANUP;

}