自学教程：C++ tst_brk函数代码示例

static void assert_test_fn(void){	int cnt = 0;	if (tst_test->test)		cnt++;	if (tst_test->test_all)		cnt++;	if (tst_test->sample)		cnt++;	if (!cnt)		tst_brk(TBROK, "No test function speficied");	if (cnt != 1)		tst_brk(TBROK, "You can define only one test function");	if (tst_test->test && !tst_test->tcnt)		tst_brk(TBROK, "Number of tests (tcnt) must not be > 0");	if (!tst_test->test && tst_test->tcnt)		tst_brk(TBROK, "You can define tcnt only for test()");}

static int init_key(char *name, int cmd){	int n;	int sec = 1;	n = add_key("keyring", name, NULL, 0, KEY_SPEC_THREAD_KEYRING);	if (n == -1)		tst_brk(TBROK | TERRNO, "add_key() failed");	if (cmd == KEYCTL_REVOKE) {		if (keyctl(cmd, n) == -1) {			tst_brk(TBROK | TERRNO,	"failed to revoke a key");		}	}	if (cmd == KEYCTL_SET_TIMEOUT) {		if (keyctl(cmd, n, sec) == -1) {			tst_brk(TBROK | TERRNO,				"failed to set timeout for a key");		}		sleep(sec + 1);	}	return n;}

static void setup(void){	int ret;	SAFE_MKDIR(mntpoint, DIR_MODE);	SAFE_MOUNT(tst_device->dev, mntpoint, tst_device->fs_type, 0, NULL);	mount_flag = 1;	sprintf(fname, "%s/tfile_%d", mntpoint, getpid());	fd = SAFE_OPEN(fname, O_RDWR | O_CREAT, 0700);	ret = write(fd, fname, 1);	if (ret == -1) {		tst_brk(TBROK | TERRNO,			 "write(%d, %s, 1) failed", fd, fname);	}	/* close the file we have open */	SAFE_CLOSE(fd);	fd_notify = myinotify_init();	if (fd_notify < 0) {		if (errno == ENOSYS)			tst_brk(TCONF,				"inotify is not configured in this kernel.");		else			tst_brk(TBROK | TERRNO,				"inotify_init failed");	}	tst_umount(mntpoint);	mount_flag = 0;}

static void caid_flags_setup(void){	int attr, ret;	fd = SAFE_OPEN(TESTDIR_FLAGGED, O_RDONLY | O_DIRECTORY);	ret = ioctl(fd, FS_IOC_GETFLAGS, &attr);	if (ret < 0) {		if (errno == ENOTTY)			tst_brk(TCONF | TERRNO, "FS_IOC_GETFLAGS not supported");		/* ntfs3g fuse fs returns wrong errno for unimplemented ioctls */		if (!strcmp(tst_device->fs_type, "ntfs")) {			tst_brk(TCONF | TERRNO,				"ntfs3g does not support FS_IOC_GETFLAGS");		}		tst_brk(TBROK | TERRNO, "ioctl(%i, FS_IOC_GETFLAGS, ...)", fd);	}	attr |= FS_COMPR_FL | FS_APPEND_FL | FS_IMMUTABLE_FL | FS_NODUMP_FL;	ret = ioctl(fd, FS_IOC_SETFLAGS, &attr);	if (ret < 0) {		if (errno == EOPNOTSUPP)			tst_brk(TCONF, "Flags not supported");		tst_brk(TBROK | TERRNO, "ioctl(%i, FS_IOC_SETFLAGS, %i)", fd, attr);	}	clear_flags = 1;}

static void run(void){	pid_t pid;	int status;retry:	pid = SAFE_FORK();	if (!pid) {		setup_cgroup_paths(getpid());		child();	}	setup_cgroup_paths(pid);	SAFE_WAIT(&status);	cleanup();	/*	 * Rarely cgroup OOM kills both children not only the one that allocates	 * memory in loop, hence we retry here if that happens.	 */	if (WIFSIGNALED(status)) {		tst_res(TINFO, "Both children killed, retrying...");		goto retry;	}	if (WIFEXITED(status) && WEXITSTATUS(status) == TCONF)		tst_brk(TCONF, "MADV_FREE is not supported");	if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)		tst_brk(TBROK, "Child %s", tst_strstatus(status));}

static void run_tests(void){	unsigned int i;	struct results saved_results;	if (!tst_test->test) {		saved_results = *results;		tst_test->test_all();		if (getpid() != main_pid) {			exit(0);		}		reap_children();		if (results_equal(&saved_results, results))			tst_brk(TBROK, "Test haven't reported results!");		return;	}	for (i = 0; i < tst_test->tcnt; i++) {		saved_results = *results;		tst_test->test(i);		if (getpid() != main_pid) {			exit(0);		}		reap_children();		if (results_equal(&saved_results, results))			tst_brk(TBROK, "Test %i haven't reported results!", i);	}}

/* Warning: *DO NOT* use this function in child */unsigned int get_a_numa_node(void){	unsigned int nd1, nd2;	int ret;	ret = get_allowed_nodes(0, 2, &nd1, &nd2);	switch (ret) {	case 0:		break;	case -3:		tst_brk(TCONF, "requires a NUMA system.");	default:		tst_brk(TBROK | TERRNO, "1st get_allowed_nodes");	}	ret = get_allowed_nodes(NH_MEMS | NH_CPUS, 1, &nd1);	switch (ret) {	case 0:		tst_res(TINFO, "get node%u.", nd1);		return nd1;	case -3:		tst_brk(TCONF, "requires a NUMA system that has "			 "at least one node with both memory and CPU "			 "available.");	default:		tst_brk(TBROK | TERRNO, "2nd get_allowed_nodes");	}	/* not reached */	abort();}

int range_is_mapped(unsigned long low, unsigned long high){	FILE *fp;	fp = fopen("/proc/self/maps", "r");	if (fp == NULL)		tst_brk(TBROK | TERRNO, "Failed to open /proc/self/maps.");	while (!feof(fp)) {		unsigned long start, end;		int ret;		ret = fscanf(fp, "%lx-%lx %*[^/n]/n", &start, &end);		if (ret != 2) {			fclose(fp);			tst_brk(TBROK | TERRNO, "Couldn't parse /proc/self/maps line.");		}		if ((start >= low) && (start < high)) {			fclose(fp);			return 1;		}		if ((end >= low) && (end < high)) {			fclose(fp);			return 1;		}	}	fclose(fp);	return 0;}

static void parse_mtest_options(char *str_chunksize, int *chunksize,		char *str_maxbytes, long *maxbytes,		char *str_maxpercent, int *maxpercent){	if (str_chunksize)		if (tst_parse_int(str_chunksize, chunksize, 1, INT_MAX))			tst_brk(TBROK, "Invalid chunksize '%s'", str_chunksize);	if (str_maxbytes) {		if (tst_parse_long(str_maxbytes, maxbytes, 1, LONG_MAX)) {			tst_brk(TBROK, "Invalid maxbytes '%s'", str_maxbytes);		} else if (str_maxpercent) {			tst_brk(TBROK, "ERROR: -b option cannot be used with -p "					"option at the same time");		}		alloc_maxbytes = (unsigned long long)maxbytes;	}	if (str_maxpercent) {		if (tst_parse_int(str_maxpercent, maxpercent, 1, 99)) {			tst_brk(TBROK, "Invalid maxpercent '%s'", str_maxpercent);		} else if (str_maxbytes) {			tst_brk(TBROK, "ERROR: -p option cannot be used with -b "					"option at the same time");		}	}}

static void verify_epoll_create1(void){	int fd, coe;	fd = tst_syscall(__NR_epoll_create1, 0);	if (fd == -1)		tst_brk(TFAIL | TERRNO, "epoll_create1(0) failed");	coe = SAFE_FCNTL(fd, F_GETFD);	if (coe & FD_CLOEXEC)		tst_brk(TFAIL, "flags=0 set close-on-exec flag");	SAFE_CLOSE(fd);	fd = tst_syscall(__NR_epoll_create1, EPOLL_CLOEXEC);	if (fd == -1)		tst_brk(TFAIL | TERRNO, "epoll_create1(EPOLL_CLOEXEC) failed");	coe = SAFE_FCNTL(fd, F_GETFD);	if ((coe & FD_CLOEXEC) == 0)		tst_brk(TFAIL, "flags=EPOLL_CLOEXEC didn't set close-on-exec");	SAFE_CLOSE(fd);	tst_res(TPASS, "epoll_create1(EPOLL_CLOEXEC) PASSED");}

void run(void){	int i;	struct crypto_user_alg a = {		.cru_driver_name = "pcrypt(authenc(hmac(sha256-generic),cbc(aes-generic)))",		.cru_type = CRYPTO_ALG_TYPE_AEAD,		.cru_mask = CRYPTO_ALG_TYPE_MASK,	};	for (i = 0; i < ATTEMPTS; ++i) {		TEST(tst_crypto_add_alg(&ses, &a));		if (TST_RET && TST_RET == -ENOENT) {			tst_brk(TCONF | TRERRNO,				"pcrypt, hmac, sha256, cbc or aes not supported");		}		if (TST_RET && TST_RET != -EEXIST)			tst_brk(TBROK | TRERRNO, "add_alg");		TEST(tst_crypto_del_alg(&ses, &a));		if (TST_RET)			tst_brk(TBROK | TRERRNO, "del_alg");	}	tst_res(TPASS, "Nothing bad appears to have happened");}void cleanup(void){	tst_crypto_close(&ses);}

static void setup(void){	int memnode, ret;	if (!is_numa(NULL, NH_MEMS, 1))		tst_brk(TCONF, "requires NUMA with at least 1 node");	overcommit = get_sys_tune("overcommit_memory");	set_sys_tune("overcommit_memory", 1, 1);	mount_mem("cpuset", "cpuset", NULL, CPATH, CPATH_NEW);	cpuset_mounted = 1;	/*	 * Some nodes do not contain memory, so use	 * get_allowed_nodes(NH_MEMS) to get a memory	 * node. This operation also applies to Non-NUMA	 * systems.	 */	ret = get_allowed_nodes(NH_MEMS, 1, &memnode);	if (ret < 0)		tst_brk(TBROK, "Failed to get a memory node "			      "using get_allowed_nodes()");	write_cpusets(memnode);}

static void check_swapping(void){	int status, i;	long swap_free_now, swapped;	/* wait child stop */	SAFE_WAITPID(pid, &status, WUNTRACED);	if (!WIFSTOPPED(status))		tst_brk(TBROK, "child was not stopped.");	/* Still occupying memory, loop for a while */	i = 0;	while (i < 10) {		swap_free_now = SAFE_READ_MEMINFO("SwapFree:");		sleep(1);		if (abs(swap_free_now - SAFE_READ_MEMINFO("SwapFree:")) < 512)			break;		i++;	}	swap_free_now = SAFE_READ_MEMINFO("SwapFree:");	swapped = swap_free_init - swap_free_now;	if (swapped > mem_over_max) {		kill(pid, SIGCONT);		tst_brk(TFAIL, "heavy swapping detected: "				"%ld MB swapped.", swapped / 1024);	}	tst_res(TPASS, "no heavy swapping detected, %ld MB swapped.",		 swapped / 1024);	kill(pid, SIGCONT);	/* wait child exit */	SAFE_WAITPID(pid, &status, 0);}

static void setup(void){	if (tst_parse_int(str_reads, &reads, 1, INT_MAX))		tst_brk(TBROK,			"Invalid reads (-r) argument: '%s'", str_reads);	if (tst_parse_long(str_max_workers, &max_workers, 1, LONG_MAX)) {		tst_brk(TBROK,			"Invalid max workers (-w) argument: '%s'",			str_max_workers);	}	if (tst_parse_long(str_worker_count, &worker_count, 1, LONG_MAX)) {		tst_brk(TBROK,			"Invalid worker count (-W) argument: '%s'",			str_worker_count);	}	if (!root_dir)		tst_brk(TBROK, "The directory argument (-d) is required");	if (!worker_count)		worker_count = MIN(MAX(tst_ncpus() - 1, 1), max_workers);	workers = SAFE_MALLOC(worker_count * sizeof(*workers));}

void test_chmod(void){	struct stat stat_buf;	/*	 * Call chmod(2) with specified mode argument	 * (sticky-bit set) on testfile.	 */	TEST(chmod(TESTFILE, PERMS));	if (TST_RET == -1) {		tst_brk(TFAIL | TTERRNO, "chmod(%s, %#o) failed",				TESTFILE, PERMS);	}	if (stat(TESTFILE, &stat_buf) == -1) {		tst_brk(TFAIL | TTERRNO, "stat failed");	}	/* Check for expected mode permissions */	if ((stat_buf.st_mode & PERMS) == PERMS) {		tst_res(TPASS, "Functionality of chmod(%s, %#o) successful",				TESTFILE, PERMS);	} else {		tst_res(TFAIL, "%s: Incorrect modes 0%03o; expected 0%03o",				TESTFILE, stat_buf.st_mode, PERMS);	}}

static void setup(void){	check_hugepage();	hugepagesize = SAFE_READ_MEMINFO("Hugepagesize:") * 1024;	init_sys_sz_paths();	if (opt_sysfs) {		path = path_sys_sz_huge;		pathover = path_sys_sz_over;	} else {		path = PATH_PROC_HUGE;		pathover = PATH_PROC_OVER;	}	if (opt_alloc) {		size = atoi(opt_alloc);		length = (size + size * 0.5) * 2;	}	if (opt_shmid) {		SAFE_FILE_SCANF(PATH_SHMMAX, "%llu", &shmmax);		if (shmmax < (unsigned long long)(length / 2 * hugepagesize)) {			restore_shmmax = 1;			SAFE_FILE_PRINTF(PATH_SHMMAX, "%ld",					(length / 2 * hugepagesize));		}	}	SAFE_FILE_SCANF(path, "%ld", &nr_hugepages);	tst_res(TINFO, "original nr_hugepages is %ld", nr_hugepages);	/* Reset. */	SAFE_FILE_PRINTF(path, "%ld", size);	restore_nr_hgpgs = 1;	if (access(pathover, F_OK)) {		tst_brk(TCONF, "file %s does not exist in the system",			pathover);	}	SAFE_FILE_SCANF(pathover, "%ld", &nr_overcommit_hugepages);	tst_res(TINFO, "original nr_overcommit_hugepages is %ld",		nr_overcommit_hugepages);	/* Reset. */	SAFE_FILE_PRINTF(pathover, "%ld", size);	restore_overcomm_hgpgs = 1;	SAFE_MKDIR(MOUNT_DIR, 0700);	SAFE_MOUNT(NULL, MOUNT_DIR, "hugetlbfs", 0, NULL);	mounted = 1;	if (opt_shmid) {		/* Use /proc/meminfo to generate an IPC key. */		key = ftok(PATH_MEMINFO, strlen(PATH_MEMINFO));		if (key == -1)			tst_brk(TBROK | TERRNO, "ftok");	}}

/* * Fatal error handler */static void io_error(const char *func, int rc){	if (rc == -ENOSYS)		tst_brk(TCONF, "AIO not in this kernel/n");	else if (rc < 0)		tst_brk(TFAIL, "%s: %s/n", func, strerror(-rc));	else		tst_brk(TFAIL, "%s: error %d/n", func, rc);}

static void drop_cap_sys_admin(void){	cap_value_t cap_value[] = { CAP_SYS_ADMIN };	cap_t cap = cap_get_proc();	if (!cap)		tst_brk(TBROK | TERRNO, "cap_get_proc failed");	if (cap_set_flag(cap, CAP_EFFECTIVE, 1, cap_value, CAP_CLEAR))		tst_brk(TBROK | TERRNO, "cap_set_flag failed");	if (cap_set_proc(cap))		tst_brk(TBROK | TERRNO, "cap_set_proc failed");}

static int has_file(const char *fname, int required){	struct stat buf;	if (stat(fname, &buf) == -1) {		if (errno != ENOENT)			tst_brk(TBROK | TERRNO, "stat %s", fname);		if (required)			tst_brk(TCONF, "%s not available", fname);		return 0;	}	return 1;}

void tst_flush(void){	int rval;	rval = fflush(stderr);	if (rval != 0)		tst_brk(TBROK | TERRNO, "fflush(stderr) failed");	rval = fflush(stderr);	if (rval != 0)		tst_brk(TBROK | TERRNO, "fflush(stdout) failed");}

static void vmsplice_test(void){	int pipes[2];	long written;	int ret;	int fd_out;	struct iovec v;	loff_t offset;	v.iov_base = buffer;	v.iov_len = TEST_BLOCK_SIZE;	fd_out = SAFE_OPEN(TESTFILE, O_WRONLY | O_CREAT | O_TRUNC, 0644);	SAFE_PIPE(pipes);	struct pollfd pfd = {.fd = pipes[1], .events = POLLOUT};	offset = 0;	while (v.iov_len) {		/*		 * in a real app you'd be more clever with poll of course,		 * here we are basically just blocking on output room and		 * not using the free time for anything interesting.		 */		if (poll(&pfd, 1, -1) < 0)			tst_brk(TBROK | TERRNO, "poll() failed");		written = vmsplice(pipes[1], &v, 1, 0);		if (written < 0) {			tst_brk(TBROK | TERRNO, "vmsplice() failed");		} else {			if (written == 0) {				break;			} else {				v.iov_base += written;				v.iov_len -= written;			}		}		ret = splice(pipes[0], NULL, fd_out, &offset, written, 0);		if (ret < 0)			tst_brk(TBROK | TERRNO, "splice() failed");		//printf("offset = %lld/n", (long long)offset);	}	SAFE_CLOSE(pipes[0]);	SAFE_CLOSE(pipes[1]);	SAFE_CLOSE(fd_out);	check_file();}

int main(int argc, char *argv[]){	tst_reinit();	if (argc != 2)		tst_brk(TFAIL, "argc is %d, expected 2", argc);	if (strcmp(argv[1], "canary"))		tst_brk(TFAIL, "argv[1] is %s, expected 'canary'", argv[1]);	tst_res(TPASS, "%s executed", argv[0]);	return 0;}

static void create_ksm_child(int child_num, int size, int unit,		       struct ksm_merge_data *ksm_merge_data){	int j, total_unit;	char **memory;	/* The total units in all */	total_unit = size / unit;	/* Apply for the space for memory */	memory = SAFE_MALLOC(total_unit * sizeof(char *));	for (j = 0; j < total_unit; j++) {		memory[j] = SAFE_MMAP(NULL, unit * MB, PROT_READ|PROT_WRITE,			MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);#ifdef HAVE_MADV_MERGEABLE		if (madvise(memory[j], unit * MB, MADV_MERGEABLE) == -1)			tst_brk(TBROK|TERRNO, "madvise");#endif	}	tst_res(TINFO, "child %d stops.", child_num);	if (raise(SIGSTOP) == -1)		tst_brk(TBROK|TERRNO, "kill");	fflush(stdout);	for (j = 0; j < 4; j++) {		ksm_child_memset(child_num, size, total_unit,				  ksm_merge_data[j], memory);		fflush(stdout);		tst_res(TINFO, "child %d stops.", child_num);		if (raise(SIGSTOP) == -1)			tst_brk(TBROK|TERRNO, "kill");		if (ksm_merge_data[j].mergeable_size < size * MB) {			verify(memory, 'e', child_num, total_unit - 1,				total_unit, unit * MB - 1, unit * MB);			verify(memory, ksm_merge_data[j].data, child_num,				0, total_unit, 0, unit * MB - 1);		} else {			verify(memory, ksm_merge_data[j].data, child_num,				0, total_unit, 0, unit * MB);		}	}	tst_res(TINFO, "child %d finished.", child_num);}

static void setup(void){	epfd = epoll_create(2);	if (epfd == -1)		tst_brk(TBROK | TERRNO, "fail to create epoll instance");	SAFE_PIPE(fd);	events[0].data.fd = fd[0];	events[1].data.fd = fd[1];	TEST(epoll_ctl(epfd, EPOLL_CTL_ADD, fd[0], &events[0]));	if (TEST_RETURN == -1)		tst_brk(TFAIL | TTERRNO, "epoll_ctl() fails to init");}

static void run_targets(const char *dirname, char *cfile, pid_t tid){	int i, k, fd;	char subdir[PATH_MAX] = {0};	char *output_file;	char buf[11];	const char *const cmd_run[] = {cfile, NULL};	SAFE_ASPRINTF(&output_file, "%s/cmd.out", dirname);	/* run each binary */	for (i = 0; i < dirs_num; ++i) {		for (k = 0; k < file_num; ++k) {			snprintf(cfile, PATH_MAX, "%s%s/%d.%d.%d",				 dirname, subdir, tid, i, k);			tst_run_cmd(cmd_run, output_file, NULL, 0);			fd = SAFE_OPEN(output_file, O_RDONLY);			SAFE_READ(1, fd, buf, 11);			if (strncmp(buf, "hello world", 11))				tst_brk(TFAIL, "command printed wrong message");			SAFE_CLOSE(fd);		}		strcat(subdir, "/dir");	}	free(output_file);}

static void alloc_and_check(long size, int expect_result){	int result;	/* try to alloc size kB memory */	result = heavy_malloc(size);	switch (expect_result) {	case EXPECT_PASS:		if (result == 0)			tst_res(TPASS, "alloc passed as expected");		else			tst_res(TFAIL, "alloc failed, expected to pass");		break;	case EXPECT_FAIL:		if (result != 0)			tst_res(TPASS, "alloc failed as expected");		else			tst_res(TFAIL, "alloc passed, expected to fail");		break;	default:		tst_brk(TBROK, "Invaild numbler parameter: %d",			 expect_result);	}}

static void overcommit_memory_test(void){#if __WORDSIZE == 32	tst_brk(TCONF, "test is not designed for 32-bit system.");#endif	/* start to test overcommit_memory=2 */	set_sys_tune("overcommit_memory", 2, 1);	update_mem_commit();	alloc_and_check(commit_left * 2, EXPECT_FAIL);	alloc_and_check(commit_limit, EXPECT_FAIL);	update_mem_commit();	alloc_and_check(commit_left / 2, EXPECT_PASS);	/* start to test overcommit_memory=0 */	set_sys_tune("overcommit_memory", 0, 1);	update_mem();	alloc_and_check(free_total / 2, EXPECT_PASS);	update_mem();	alloc_and_check(free_total * 2, EXPECT_FAIL);	alloc_and_check(sum_total, EXPECT_FAIL);	/* start to test overcommit_memory=1 */	set_sys_tune("overcommit_memory", 1, 1);	alloc_and_check(sum_total / 2, EXPECT_PASS);	alloc_and_check(sum_total, EXPECT_PASS);	alloc_and_check(sum_total * 2, EXPECT_PASS);}

static void check_mark(char *file, unsigned long long flag, char *flagstr,		       int expect, void (*test_event)(char *)){	if (fanotify_mark(fd_notify, FAN_MARK_ADD | flag, FAN_OPEN, AT_FDCWD,			    file) != expect) {		tst_res(TFAIL,		    "fanotify_mark (%d, FAN_MARK_ADD | %s, FAN_OPEN, AT_FDCWD, "		    "'%s') %s", fd_notify, flagstr, file, expect_str_fail(expect));	} else {		tst_res(TPASS,		    "fanotify_mark (%d, FAN_MARK_ADD | %s, FAN_OPEN, AT_FDCWD, "		    "'%s') %s", fd_notify, flagstr, file, expect_str_pass(expect));		/* If we expected failure there's nothing to clean up */		if (expect == -1)			return;		if (test_event)			test_event(file);		if (fanotify_mark(fd_notify, FAN_MARK_REMOVE | flag,				    FAN_OPEN, AT_FDCWD, file) < 0) {			tst_brk(TBROK | TERRNO,			    "fanotify_mark (%d, FAN_MARK_REMOVE | %s, "			    "FAN_OPEN, AT_FDCWD, '%s') failed",			    fd_notify, flagstr, file);		}	}}

static void setup(void){	struct sysinfo sys_buf;	sysinfo(&sys_buf);	if (sys_buf.totalram < 2L * GB_SZ)		tst_brk(TCONF, "Test requires more than 2GB of RAM");	if (sys_buf.totalram > 100L * GB_SZ)		tst_brk(TCONF, "System RAM is too large, skip test");	dst_max = sys_buf.totalram / GB_SZ;	tst_res(TINFO, "dst_max = %ld", dst_max);	pg_sz = getpagesize();}

static void setup(void){	struct sigaction sigptr;	page_sz = getpagesize();	/*	 * Used as hint for mmap thread, so it doesn't interfere	 * with other potential (temporary) mappings from libc	 */	distant_area = SAFE_MMAP(0, DISTANT_MMAP_SIZE, PROT_WRITE | PROT_READ,			MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);	SAFE_MUNMAP(distant_area, (size_t)DISTANT_MMAP_SIZE);	distant_area += DISTANT_MMAP_SIZE / 2;	if (tst_parse_float(str_exec_time, &exec_time, 0, FLT_MAX)) {		tst_brk(TBROK, "Invalid number for exec_time '%s'",			str_exec_time);	}	sigptr.sa_sigaction = sig_handler;	sigemptyset(&sigptr.sa_mask);	sigptr.sa_flags = SA_SIGINFO | SA_NODEFER;	SAFE_SIGACTION(SIGSEGV, &sigptr, NULL);	tst_set_timeout((int)(exec_time * 3600));}