470 lines
10 KiB
C
470 lines
10 KiB
C
/*
|
|
* Copyright (c) Wipro Technologies Ltd, 2002. All Rights Reserved.
|
|
* Copyright (c) 2012 Wanlong Gao <gaowanlong@cn.fujitsu.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of version 2 of the GNU General Public License as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it would be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
*/
|
|
/*
|
|
* TEST1
|
|
* -----
|
|
* Call clone() with all resources shared.
|
|
*
|
|
* CHILD:
|
|
* modify the shared resources
|
|
* return 1 on success
|
|
* PARENT:
|
|
* wait for child to finish
|
|
* verify that the shared resourses are modified
|
|
* return 1 on success
|
|
* If parent & child returns successfully
|
|
* test passed
|
|
* else
|
|
* test failed
|
|
*
|
|
* TEST2
|
|
* -----
|
|
* Call clone() with no resources shared.
|
|
*
|
|
* CHILD:
|
|
* modify the resources in child's address space
|
|
* return 1 on success
|
|
* PARENT:
|
|
* wait for child to finish
|
|
* verify that the parent's resourses are not modified
|
|
* return 1 on success
|
|
* If parent & child returns successfully
|
|
* test passed
|
|
* else
|
|
* test failed
|
|
*/
|
|
|
|
#if defined UCLINUX && !__THROW
|
|
/* workaround for libc bug */
|
|
#define __THROW
|
|
#endif
|
|
|
|
#define _GNU_SOURCE
|
|
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <sys/wait.h>
|
|
#include <sys/types.h>
|
|
#include <sys/syscall.h>
|
|
#include <sched.h>
|
|
#include "test.h"
|
|
#include "safe_macros.h"
|
|
|
|
#define FLAG_ALL (CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|SIGCHLD)
|
|
#define FLAG_NONE SIGCHLD
|
|
#define PARENT_VALUE 1
|
|
#define CHILD_VALUE 2
|
|
#define TRUE 1
|
|
#define FALSE 0
|
|
|
|
#include "clone_platform.h"
|
|
|
|
static void setup(void);
|
|
static int test_setup(void);
|
|
static void cleanup(void);
|
|
static void test_cleanup(void);
|
|
static int child_fn();
|
|
static int parent_test1(void);
|
|
static int parent_test2(void);
|
|
static int test_VM(void);
|
|
static int test_FS(void);
|
|
static int test_FILES(void);
|
|
static int test_SIG(void);
|
|
static int modified_VM(void);
|
|
static int modified_FS(void);
|
|
static int modified_FILES(void);
|
|
static int modified_SIG(void);
|
|
static void sig_child_defined_handler(int);
|
|
static void sig_default_handler();
|
|
|
|
static int fd_parent;
|
|
static char file_name[25];
|
|
static int parent_variable;
|
|
static char cwd_parent[FILENAME_MAX];
|
|
static int parent_got_signal, child_pid;
|
|
|
|
char *TCID = "clone02";
|
|
|
|
struct test_case_t {
|
|
int flags;
|
|
int (*parent_fn) ();
|
|
} test_cases[] = {
|
|
{
|
|
FLAG_ALL, parent_test1}, {
|
|
FLAG_NONE, parent_test2}
|
|
};
|
|
|
|
int TST_TOTAL = sizeof(test_cases) / sizeof(test_cases[0]);
|
|
|
|
int main(int ac, char **av)
|
|
{
|
|
|
|
int lc;
|
|
void *child_stack;
|
|
int status, i;
|
|
|
|
tst_parse_opts(ac, av, NULL, NULL);
|
|
|
|
setup();
|
|
|
|
child_stack = malloc(CHILD_STACK_SIZE);
|
|
if (child_stack == NULL)
|
|
tst_brkm(TBROK, cleanup, "Cannot allocate stack for child");
|
|
|
|
for (lc = 0; TEST_LOOPING(lc); lc++) {
|
|
tst_count = 0;
|
|
|
|
for (i = 0; i < TST_TOTAL; ++i) {
|
|
if (test_setup() != 0) {
|
|
tst_resm(TWARN, "test_setup() failed,"
|
|
"skipping this test case");
|
|
continue;
|
|
}
|
|
|
|
/* Test the system call */
|
|
TEST(ltp_clone(test_cases[i].flags, child_fn, NULL,
|
|
CHILD_STACK_SIZE, child_stack));
|
|
|
|
/* check return code */
|
|
if (TEST_RETURN == -1) {
|
|
tst_resm(TFAIL | TTERRNO, "clone() failed");
|
|
/* Cleanup & continue with next test case */
|
|
test_cleanup();
|
|
continue;
|
|
}
|
|
|
|
/* Wait for child to finish */
|
|
if ((wait(&status)) == -1) {
|
|
tst_resm(TWARN | TERRNO,
|
|
"wait failed; skipping testcase");
|
|
/* Cleanup & continue with next test case */
|
|
test_cleanup();
|
|
continue;
|
|
}
|
|
|
|
if (WTERMSIG(status))
|
|
tst_resm(TWARN, "child exitied with signal %d",
|
|
WTERMSIG(status));
|
|
|
|
/*
|
|
* Check the return value from child function and
|
|
* parent function. If both functions returned
|
|
* successfully, test passed, else failed
|
|
*/
|
|
if (WIFEXITED(status) && WEXITSTATUS(status) == 0 &&
|
|
test_cases[i].parent_fn())
|
|
tst_resm(TPASS, "Test Passed");
|
|
else
|
|
tst_resm(TFAIL, "Test Failed");
|
|
|
|
/* Do test specific cleanup */
|
|
test_cleanup();
|
|
}
|
|
}
|
|
|
|
free(child_stack);
|
|
|
|
cleanup();
|
|
tst_exit();
|
|
}
|
|
|
|
static void setup(void)
|
|
{
|
|
tst_sig(FORK, DEF_HANDLER, cleanup);
|
|
TEST_PAUSE;
|
|
tst_tmpdir();
|
|
|
|
/* Get unique file name for each child process */
|
|
if ((sprintf(file_name, "parent_file_%ld", syscall(__NR_gettid))) <= 0)
|
|
tst_brkm(TBROK | TERRNO, cleanup, "sprintf() failed");
|
|
}
|
|
|
|
static void cleanup(void)
|
|
{
|
|
if (unlink(file_name) == -1)
|
|
tst_resm(TWARN | TERRNO, "unlink(%s) failed", file_name);
|
|
tst_rmdir();
|
|
}
|
|
|
|
static int test_setup(void)
|
|
{
|
|
|
|
struct sigaction def_act;
|
|
|
|
/* Save current working directory of parent */
|
|
if (getcwd(cwd_parent, sizeof(cwd_parent)) == NULL) {
|
|
tst_resm(TWARN | TERRNO, "getcwd() failed in test_setup()");
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* Set value for parent_variable in parent, which will be
|
|
* changed by child in test_VM(), for testing CLONE_VM flag
|
|
*/
|
|
parent_variable = PARENT_VALUE;
|
|
|
|
/*
|
|
* Open file from parent, which will be closed by
|
|
* child in test_FILES(), used for testing CLONE_FILES flag
|
|
*/
|
|
fd_parent = open(file_name, O_CREAT | O_RDWR, 0777);
|
|
if (fd_parent == -1) {
|
|
tst_resm(TWARN | TERRNO, "open() failed in test_setup()");
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* set parent_got_signal to FALSE, used for testing
|
|
* CLONE_SIGHAND flag
|
|
*/
|
|
parent_got_signal = FALSE;
|
|
|
|
/* Setup signal handler for SIGUSR2 */
|
|
def_act.sa_handler = sig_default_handler;
|
|
def_act.sa_flags = SA_RESTART;
|
|
sigemptyset(&def_act.sa_mask);
|
|
|
|
if (sigaction(SIGUSR2, &def_act, NULL) == -1) {
|
|
tst_resm(TWARN | TERRNO, "sigaction() failed in test_setup()");
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void test_cleanup(void)
|
|
{
|
|
|
|
/* Restore parent's working directory */
|
|
SAFE_CHDIR(cleanup, cwd_parent);
|
|
|
|
}
|
|
|
|
static int child_fn(void)
|
|
{
|
|
|
|
/* save child pid */
|
|
child_pid = syscall(__NR_gettid);
|
|
|
|
if (test_VM() == 0 && test_FILES() == 0 && test_FS() == 0 &&
|
|
test_SIG() == 0)
|
|
_exit(0);
|
|
_exit(1);
|
|
}
|
|
|
|
static int parent_test1(void)
|
|
{
|
|
|
|
/*
|
|
* For first test case (with all flags set), all resources are
|
|
* shared between parent and child. So whatever changes made by
|
|
* child should get reflected in parent also. modified_*()
|
|
* functions check this. All of them should return 1 for
|
|
* parent_test1() to return 1
|
|
*/
|
|
|
|
if (modified_VM() && modified_FILES() && modified_FS() &&
|
|
modified_SIG())
|
|
return 0;
|
|
return -1;
|
|
}
|
|
|
|
static int parent_test2(void)
|
|
{
|
|
|
|
/*
|
|
* For second test case (with no resouce shared), all of the
|
|
* modified_*() functions should return 0 for parent_test2()
|
|
* to return 1
|
|
*/
|
|
if (modified_VM() || modified_FILES() || modified_FS() ||
|
|
modified_SIG())
|
|
return 0;
|
|
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* test_VM() - function to change parent_variable from child's
|
|
* address space. If CLONE_VM flag is set, child shares
|
|
* the memory space with parent so this will be visible
|
|
* to parent also.
|
|
*/
|
|
|
|
static int test_VM(void)
|
|
{
|
|
parent_variable = CHILD_VALUE;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* test_FILES() - This function closes a file descriptor opened by
|
|
* parent. If CLONE_FILES flag is set, the parent and
|
|
* the child process share the same file descriptor
|
|
* table. so this affects the parent also
|
|
*/
|
|
static int test_FILES(void)
|
|
{
|
|
if (close(fd_parent) == -1) {
|
|
tst_resm(TWARN | TERRNO, "close failed in test_FILES");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* test_FS() - This function changes the current working directory
|
|
* of the child process. If CLONE_FS flag is set, this
|
|
* will be visible to parent also.
|
|
*/
|
|
static int test_FS(void)
|
|
{
|
|
char *test_tmpdir;
|
|
int rval;
|
|
|
|
test_tmpdir = tst_get_tmpdir();
|
|
if (test_tmpdir == NULL) {
|
|
tst_resm(TWARN | TERRNO, "tst_get_tmpdir failed");
|
|
rval = -1;
|
|
} else if (chdir(test_tmpdir) == -1) {
|
|
tst_resm(TWARN | TERRNO, "chdir failed in test_FS");
|
|
rval = -1;
|
|
} else {
|
|
rval = 0;
|
|
}
|
|
|
|
free(test_tmpdir);
|
|
return rval;
|
|
}
|
|
|
|
/*
|
|
* test_SIG() - This function changes the signal handler for SIGUSR2
|
|
* signal for child. If CLONE_SIGHAND flag is set, this
|
|
* affects parent also.
|
|
*/
|
|
static int test_SIG(void)
|
|
{
|
|
|
|
struct sigaction new_act;
|
|
|
|
new_act.sa_handler = sig_child_defined_handler;
|
|
new_act.sa_flags = SA_RESTART;
|
|
sigemptyset(&new_act.sa_mask);
|
|
|
|
/* Set signal handler to sig_child_defined_handler */
|
|
if (sigaction(SIGUSR2, &new_act, NULL) == -1) {
|
|
tst_resm(TWARN | TERRNO, "signal failed in test_SIG");
|
|
return -1;
|
|
}
|
|
|
|
/* Send SIGUSR2 signal to parent */
|
|
if (kill(getppid(), SIGUSR2) == -1) {
|
|
tst_resm(TWARN | TERRNO, "kill failed in test_SIG");
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* modified_VM() - This function is called by parent process to check
|
|
* whether child's modification to parent_variable
|
|
* is visible to parent
|
|
*/
|
|
|
|
static int modified_VM(void)
|
|
{
|
|
|
|
if (parent_variable == CHILD_VALUE)
|
|
/* child has modified parent_variable */
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* modified_FILES() - This function checks for file descriptor table
|
|
* modifications done by child
|
|
*/
|
|
static int modified_FILES(void)
|
|
{
|
|
char buff[20];
|
|
|
|
if (((read(fd_parent, buff, sizeof(buff))) == -1) && (errno == EBADF))
|
|
/* Child has closed this file descriptor */
|
|
return 1;
|
|
|
|
/* close fd_parent */
|
|
if ((close(fd_parent)) == -1)
|
|
tst_resm(TWARN | TERRNO, "close() failed in modified_FILES()");
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* modified_FS() - This function checks parent's current working directory
|
|
* to see whether its modified by child or not.
|
|
*/
|
|
static int modified_FS(void)
|
|
{
|
|
char cwd[FILENAME_MAX];
|
|
|
|
if ((getcwd(cwd, sizeof(cwd))) == NULL)
|
|
tst_resm(TWARN | TERRNO, "getcwd() failed");
|
|
|
|
if (!(strcmp(cwd, cwd_parent)))
|
|
/* cwd hasn't changed */
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* modified_SIG() - This function checks whether child has changed
|
|
* parent's signal handler for signal, SIGUSR2
|
|
*/
|
|
static int modified_SIG(void)
|
|
{
|
|
|
|
if (parent_got_signal)
|
|
/*
|
|
* parent came through sig_child_defined_handler()
|
|
* this means child has changed parent's handler
|
|
*/
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* sig_child_defined_handler() - Signal handler installed by child
|
|
*/
|
|
static void sig_child_defined_handler(int pid)
|
|
{
|
|
if ((syscall(__NR_gettid)) == child_pid)
|
|
/* Child got signal, give warning */
|
|
tst_resm(TWARN, "Child got SIGUSR2 signal");
|
|
else
|
|
parent_got_signal = TRUE;
|
|
}
|
|
|
|
/* sig_default_handler() - Default handler for parent */
|
|
static void sig_default_handler(void)
|
|
{
|
|
}
|