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

int main(int argc, char **argv){	int fd, child_fd, pid;	test_init(argc, argv);	fd = child_fd = open(filename, O_CREAT | O_RDWR, 0600);	if (fd < 0) {		pr_perror("No file");		return -1;	}	flock(fd, LOCK_EX);	pid = fork();	if (pid == 0) {		test_waitsig();		exit(0);	}	close(fd);	fd = open(filename, O_RDONLY);	if (fd < 0) {		pr_perror("No file 2");		kill(pid, SIGTERM);		waitpid(pid, NULL, 0);		return -1;	}	if (flock(fd, LOCK_EX | LOCK_NB) == 0) {		pr_perror("Bogus locks");		kill(pid, SIGTERM);		waitpid(pid, NULL, 0);		return -1;	}	test_daemon();	test_waitsig();	if (check_file_locks(pid, fd, child_fd) > 0)		pass();	else		fail("Flock file locks check failed");	kill(pid, SIGTERM);	waitpid(pid, NULL, 0);	close(fd);	unlink(filename);	return 0;}

int main(int argc, char **argv){	char *start_addr, *addr1, *addr2;	test_init(argc, argv);	start_addr = mmap(NULL, PAGE_SIZE * 10, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);	if (start_addr == MAP_FAILED) {		err("Can't mal a new region");		return 1;	}	munmap(start_addr, PAGE_SIZE * 10);	addr1 = mmap(start_addr + PAGE_SIZE * 5, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE | MAP_GROWSDOWN, -1, 0);	addr2 = mmap(start_addr + PAGE_SIZE * 3, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE | MAP_GROWSDOWN, -1, 0);	err("%p %p/n", addr1, addr2);	test_daemon();	test_waitsig();	pass();	return 0;}

int main(int argc, char **argv){    int fd, fd2;    test_init(argc, argv);    fd = open(filename, O_CREAT | O_RDWR, 0600);    if (fd < 0) {        pr_perror("No file");        return -1;    }    fd2 = open(filename, O_RDWR);    if (fd2 < 0) {        pr_perror("No file2");        return -1;    }    flock(fd, LOCK_SH);    test_daemon();    test_waitsig();    if (flock(fd2, LOCK_SH) == 0)        pass();    else        fail("Flock file locks check failed (%d)", errno);    close(fd);    close(fd2);    unlink(filename);    return 0;}

int main(int argc, char **argv){	char *env;	test_init(argc, argv);	if (setenv(envname, test_author, 1)) {		pr_perror("Can't set env var /"%s/" to /"%s/"", envname, test_author);		exit(1);	}	test_daemon();	test_waitsig();	env = getenv(envname);	if (!env) {		fail("can't get env var /"%s/": %m/n", envname);		goto out;	}	if (strcmp(env, test_author))		fail("%s != %s/n", env, test_author);	else		pass();out:	return 0;}

int main(int argc, char **argv){	int sks[2], ret;	char buf[1024];	test_init(argc, argv);	if (socketpair(PF_UNIX, SOCK_DGRAM | SOCK_NONBLOCK, 0, sks) < 0) {		pr_perror("socketpair");		return 1;	}	if (write(sks[1], MSG, sizeof(MSG)) != sizeof(MSG)) {		pr_perror("write");		return 1;	}	close(sks[1]);	test_daemon();	test_waitsig();	ret = read(sks[0], buf, sizeof(MSG));	buf[ret > 0 ? ret : 0] = 0;	if (ret != sizeof(MSG)) {		fail("%d: %s", ret, buf);		return 1;	}	pass();	return 0;}

int main(int argc, char **argv){	int ret;	lo.dir = LO_CONF_DIR_PATH;	def.dir = DEF_CONF_DIR_PATH;	test_init(argc, argv);	ret = for_each_option_do(save_and_set, &lo);	if (ret < 0)		return -1;	ret = for_each_option_do(save_and_set, &def);	if (ret < 0)		return -1;	test_daemon();	test_waitsig();	ret = for_each_option_do(check_and_restore, &lo);	if (ret < 0)		return -1;	ret = for_each_option_do(check_and_restore, &def);	if (ret < 0)		return -1;	pass();	return 0;}

int main(int argc, char **argv){	test_init(argc, argv);	if (mount("/proc/sys/", "/proc/sys", NULL, MS_BIND, NULL)) {		pr_perror("Unable to bind-mount  /proc/sys");		return 1;	}	if (mount("/proc/sys/net", "/proc/sys/net", NULL, MS_BIND, NULL)) {		pr_perror("Unable to bind-mount /proc/sys/net");		return 1;	}	if (mount("/proc/sys/", "/proc/sys", NULL, MS_RDONLY|MS_BIND|MS_REMOUNT, NULL)) {		pr_perror("Unable to remount  /proc/sys");		return 1;	}	test_daemon();	test_waitsig();	if (access("/proc/sys/net/unix/max_dgram_qlen", W_OK)) {		fail("Unable to access /proc/sys/net/core/wmem_max");		return 1;	}	if (access("/proc/sys/kernel/pid_max", W_OK) != -1 || errno != EROFS) {		fail("Unable to access /proc/sys/kernel/pid_max");		return 1;	}	pass();	return 0;}

int main(int argc, char ** argv){	int fdmaster, fdslave;	pid_t jobs[JOBS_MAX] = {};	test_init(argc, argv);	if (num_jobs > JOBS_MAX) {		err("%d jobs is too many", num_jobs);		exit(1);	}	if (make_pty_pair(&fdmaster, &fdslave) < 0) {		err("can't make pty pair: %m");		exit(1);	}	sleep(30);	if (start_jobs(jobs, num_jobs, fdmaster, fdslave)) {		err("failed to start jobs");		exit(1);	}	test_daemon();	test_waitsig();	if (finish_jobs(jobs, num_jobs, fdmaster, fdslave))		fail("failed to finish jobs");	else		pass();	return 0;}

int main(int argc, char **argv){	int fd, ret = 1;	char buf[1024], fname[PATH_MAX];	test_init(argc, argv);	mkdir(dirname, 0700);	if (mount("none", dirname, "tmpfs", MS_RDONLY, "") < 0) {		fail("Can't mount tmpfs");		return 1;	}	snprintf(fname, sizeof(buf), "%s/test.file", dirname);	test_daemon();	test_waitsig();	fd = open(fname, O_RDWR | O_CREAT, 0777);	if (fd >= 0 || errno != EROFS) {		pr_perror("open failed -> %d", fd);		goto err;	}	pass();	ret = 0;err:	umount2(dirname, MNT_DETACH);	rmdir(dirname);	return ret;}

static int test_fn(int argc, char **argv){	char cmd[128];	if (system("iptables -A INPUT -t filter --protocol icmp -j DROP")) {		pr_perror("Can't set input rule");		return -1;	}	sprintf(cmd, "iptables -L > pre-%s", filename);	if (system(cmd)) {		pr_perror("Can't save iptables");		return -1;	}	test_daemon();	test_waitsig();	sprintf(cmd, "iptables -L > post-%s", filename);	if (system(cmd)) {		fail("Can't get iptables");		return -1;	}	sprintf(cmd, "diff pre-%s post-%s", filename, filename);	if (system(cmd)) {		fail("Iptables differ");		return -1;	}	pass();	return 0;}

int main(int argc, char **argv){	char *val;	int max_nr = 1024, i;	val = getenv("ZDTM_THREAD_BOMB");	if (val)		max_nr = atoi(val);	test_msg("%d/n", max_nr);	test_init(argc, argv);	for (i = 0; i < max_nr; i++) {		pthread_t p;		pthread_create(&p, NULL, thread_fn, NULL);	}	test_daemon();	test_waitsig();	pass();	return 0;}

int main(int argc, char **argv){	test_init(argc, argv);	unsigned char *mem;	test_msg("Alloc huge VMA/n");	mem = (void *)mmap(NULL, (10L << 30), PROT_READ | PROT_WRITE,			   MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);	if ((void *)mem == MAP_FAILED) {		pr_perror("mmap failed");		return -1;	}	mem[4L << 30] = 1;	mem[8L << 30] = 2;	test_daemon();	test_waitsig();	test_msg("Testing restored data/n");	if (mem[4L << 30] != 1 || mem[8L << 30] != 2) {		fail("Data corrupted!/n");		exit(1);	}	pass();	return 0;}

int main(int argc, char **argv){	int fd_rd = -1, fd_wr = -1;	test_init(argc, argv);	snprintf(filename_rd, sizeof(filename_rd), "%s.0", filename);	snprintf(filename_wr, sizeof(filename_wr), "%s.1", filename);	if (open_files(&fd_rd, &fd_wr)) {		pr_err("Can't open files/n");		return -1;	}	if (fcntl(fd_rd, F_SETLEASE, F_RDLCK) < 0 ||		fcntl(fd_wr, F_SETLEASE, F_WRLCK) < 0) {		pr_perror("Can't set leases/n");		close_files(fd_rd, fd_wr);		return -1;	}	test_daemon();	test_waitsig();	if (check_lease_type(fd_rd, F_RDLCK))		fail("Read lease check failed/n");	else if (check_lease_type(fd_wr, F_WRLCK))		fail("Write lease check failed/n");	else		pass();	close_files(fd_rd, fd_wr);	return 0;}

int main(int argc, char **argv){	int rv, i;	int counter = 0;	test_init(argc, argv);	if (scale > MAX_SCALE) {		err("Too many children specified/n");		exit(-1);	}	if (signal(SIGUSR2, do_stop) == SIG_ERR) {		err("Can't setup handler/n");		exit(-1);	}	for (i = 0; i < scale; i++) {		rv = test_fork();		if (rv == -1) {			err("Can't fork/n");			killall();			exit(-1);		}		if (rv == 0)			chew_some_file(i);		pids[i] = rv;	}	test_daemon();	test_waitsig();	killall();	for (i = 0; i < scale; i++) {		if (waitpid(pids[i], &rv, 0) == -1) {			fail("Can't wipe up the kid/n");			counter++;			continue;		}		if (!WIFEXITED(rv)) {			fail("Kid was killed/n");			counter++;		} else {			rv = WEXITSTATUS(rv);			if (rv < MAX_EXIT_CODE_VAL && rv > SUCCESS) {				fail("Kid failed: %s (%d)/n",						kids_fail_reasons[rv], rv);				counter++;			} else if (rv != SUCCESS) {				fail("Unknow exitcode from kid: %d/n", rv);				counter++;			}		}	}	if (counter == 0)		pass();	return 0;}

int main(int argc, char **argv){	pid_t pid;	test_init(argc, argv);	pid = fork();	if (pid < 0) {		fail("fork() failed");		return -1;	}	if (pid == 0) {		test_msg("child is %d/n", pid);		/* Child process just sleeps until it is killed. All we need		 * here is a process to open the mountinfo of. */		while(1)			sleep(10);	} else {		int fd, ret;		char path[PATH_MAX];		pid_t result;		sprintf(path, "/proc/%d/mountinfo", pid);		fd = open(path, O_RDONLY);		if (fd < 0) {			fail("failed to open fd");			return -1;		}		/* no matter what, we should kill the child */		kill(pid, SIGKILL);		result = waitpid(pid, NULL, 0);		if (result < 0) {			fail("failed waitpid()");			return -1;		}		if (fd < 0) {			fail("failed opening %s", path);			return -1;		}		test_daemon();		test_waitsig();		ret = fcntl(fd, F_GETFD);		close(fd);		if (ret) {			fail("bad fd after restore");			return -1;		}	}	pass();	return 0;}

int main(int argc, char **argv){	int i;	pthread_t thr[num_threads];	pthread_mutex_t m;	test_init(argc, argv);	if (num_threads > MAX_NUM_THREADS) {		err("%d threads it too much. max is %d/n",				num_threads, MAX_NUM_THREADS);		goto out;	}	pthread_mutex_init(&m, NULL);	pthread_mutex_lock(&m);	for (i = 0; i < num_threads; i++)		if (pthread_create(&thr[i], NULL, thread_fn, &m)) {			err("Can't create %d'th thread/n", i + 1);			goto out_kill;		}	kid_passed = 0;	test_daemon();	test_waitsig();	sleep(1);	if (kid_passed != 0)		fail("some kids broke through/n");	pthread_mutex_unlock(&m);	for (i = 0; i < num_threads; i++)		pthread_join(thr[i], NULL);	if (pthread_mutex_trylock(&m)) {		if (errno == EBUSY)			fail("kids left my mutex locked/n");		else			err("kids spoiled my mutex/n");	}	if (kid_passed != num_threads)		fail("some kids died during migration/n");	pass();out:	return 0;out_kill:	for (i--; i >= 0; i--) {		pthread_kill(thr[i], SIGKILL);		pthread_join(thr[i], NULL);	}	goto out;}

int main(int argc, char **argv){	int fd;	char path[256];	test_init(argc, argv);	if (snprintf(path, sizeof(path), "%s/foo", dirname) >= sizeof(path)) {		pr_perror("directory name /"%s/"is too long", dirname);		exit(1);	}	if (mkdir(dirname, 0700)) {		pr_perror("can't make directory %s", dirname);		exit(1);	}	fd = open(path, O_RDWR | O_CREAT | O_TRUNC, 0644);	if (fd < 0) {		pr_perror("can't open %s", path);		goto rmdir;	}	if (mount("rien", dirname, "tmpfs", 0, 0) < 0) {		pr_perror("can't mount tmpfs over %s", dirname);		goto cleanup;	}	test_daemon();	test_waitsig();	if (umount(dirname) < 0) {		fail("can't umount %s: %m", dirname);		goto cleanup;	}	if (close(fd) < 0) {		fail("can't close %s: %m", path);		goto unlink;	}	if (unlink(path) < 0) {		fail("can't unlink %s: %m", path);		goto rmdir;	}	pass();	goto rmdir;cleanup:	close(fd);unlink:	unlink(path);rmdir:	rmdir(dirname);	return 0;}

int main(int argc, char **argv){	int fd, pf[2], pid;	test_init(argc, argv);	pipe(pf);	fd = open(filename, O_CREAT | O_RDWR, 0600);	if (fd < 0) {		err("No file");		return -1;	}	flock(fd, LOCK_EX);	pid = fork();	if (pid == 0) {		close(pf[1]);		read(pf[0], &pid, sizeof(pid));		exit(0);	}	close(pf[0]);	close(fd);	fd = open(filename, O_RDONLY);	if (fd < 0) {		err("No file 2");		close(pf[1]);		waitpid(pid, NULL, 0);		return -1;	}	if (flock(fd, LOCK_EX | LOCK_NB) == 0) {		err("Bogus locks");		close(pf[1]);		waitpid(pid, NULL, 0);		return -1;	}	test_daemon();	test_waitsig();	if (check_file_locks(pid, fd))		pass();	else		fail("Flock file locks check failed");	close(pf[1]);	waitpid(pid, NULL, 0);	close(fd);	unlink(filename);	return 0;}

int main(int argc, char **argv){	char *start_addr, *fake_grow_down, *test_addr, *grow_down;	test_init(argc, argv);	start_addr = mmap(NULL, PAGE_SIZE * 10, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);	if (start_addr == MAP_FAILED) {		err("Can't mal a new region");		return 1;	}	munmap(start_addr, PAGE_SIZE * 10);	fake_grow_down = mmap(start_addr + PAGE_SIZE * 5, PAGE_SIZE,			 PROT_READ | PROT_WRITE,			 MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED | MAP_GROWSDOWN, -1, 0);	if (fake_grow_down == MAP_FAILED) {		err("Can't mal a new region");		return 1;	}	fake_grow_down[0] = 'c';	*(fake_grow_down - 1) = 'b';	/* overlap the guard page of fake_grow_down */	test_addr = mmap(start_addr + PAGE_SIZE * 3, PAGE_SIZE,			 PROT_READ | PROT_WRITE,			 MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED, -1, 0);	if (test_addr == MAP_FAILED) {		err("Can't mal a new region");		return 1;	}	grow_down = mmap(start_addr + PAGE_SIZE * 2, PAGE_SIZE,			 PROT_READ | PROT_WRITE,			 MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED | MAP_GROWSDOWN, -1, 0);	if (grow_down == MAP_FAILED) {		err("Can't mal a new region");		return 1;	}	test_daemon();	test_waitsig();	munmap(test_addr, PAGE_SIZE);	if (fake_grow_down[0] != 'c' || *(fake_grow_down - 1) != 'b') {		fail("%c %c/n", fake_grow_down[0], *(fake_grow_down - 1));		return 1;	}	grow_down[0] = 'z';	*(grow_down - 1) = 'x';	pass();	return 0;}

int main(int argc, char **argv){	int sk[2], p[2];#define MSG "HELLO"	char buf[8]; /* bigger than the MSG to check boundaries */	test_init(argc, argv);	if (socketpair(PF_UNIX, SOCK_DGRAM, 0, sk) < 0) {		pr_perror("Can't make unix pair");		exit(1);	}	if (pipe(p) < 0) {		pr_perror("Can't make pipe");		exit(1);	}	if (send_fd(sk[0], p[0], p[1]) < 0) {		pr_perror("Can't send descriptor");		exit(1);	}	close(p[0]);	close(p[1]);	p[0] = p[1] = -1;	test_daemon();	test_waitsig();	if (recv_fd(sk[1], &p[0], &p[1]) < 0) {		fail("Can't recv pipes back");		goto out;	}	if (write(p[1], MSG, sizeof(MSG)) != sizeof(MSG)) {		fail("Pipe write-broken");		goto out;	}	if (read(p[0], buf, sizeof(buf)) != sizeof(MSG)) {		fail("Pipe read-broken");		goto out;	}	if (strcmp(buf, MSG)) {		buf[sizeof(buf) - 1] = '/0';		fail("Pipe read-broken (%s)", buf);		goto out;	}	pass();out:	return 0;}

static int child3(void *_arg){	test_waitsig();	if (close(TEST_FD) != -1) {		fail("%d is exist/n", TEST_FD);		return 1;	}	return 0;}

int main(int argc, char ** argv){	test_init(argc, argv);	test_daemon();	test_waitsig();	pass();	return 0;}

int main(int argc, char *argv[]){	char cmdline_orig[4096];	char cmdline[4096];	char env_orig[4096];	char env[4096];	char auxv_orig[1024];	char auxv[1024];	memset(cmdline_orig,	0, sizeof(cmdline_orig));	memset(cmdline,		0, sizeof(cmdline));	memset(env_orig,	0, sizeof(env_orig));	memset(env,		0, sizeof(env));	memset(auxv_orig,	0, sizeof(auxv_orig));	memset(auxv,		0, sizeof(auxv));	test_init(argc, argv);	read_from_proc("/proc/self/cmdline", cmdline_orig, sizeof(cmdline_orig));	read_from_proc("/proc/self/environ", env_orig, sizeof(env_orig));	read_from_proc("/proc/self/auxv", auxv_orig, sizeof(auxv_orig));	test_msg("old cmdline: %s/n", cmdline_orig);	test_msg("old environ: %s/n", env_orig);	test_daemon();	test_waitsig();	read_from_proc("/proc/self/cmdline", cmdline, sizeof(cmdline));	read_from_proc("/proc/self/environ", env, sizeof(env));	read_from_proc("/proc/self/auxv", auxv, sizeof(auxv));	test_msg("new cmdline: %s/n", cmdline);	test_msg("new environ: %s/n", env);	if (strncmp(cmdline_orig, cmdline, sizeof(cmdline_orig))) {		fail("cmdline corrupted on restore");		exit(1);	}	if (strncmp(env_orig, env, sizeof(env_orig))) {		fail("envirion corrupted on restore");		exit(1);	}	if (memcmp(auxv_orig, auxv, sizeof(auxv_orig))) {		fail("auxv corrupted on restore");		exit(1);	}	pass();	return 0;}

int main(int argc, char ** argv){	char src[PATH_MAX], dst[PATH_MAX], *root;	char *dname = "/tmp/zdtm_ext_auto.XXXXXX";	int status;	pid_t pid;	root = getenv("ZDTM_ROOT");	if (root == NULL) {		pr_perror("root");		return 1;	}	sprintf(dst, "%s/ext_mounts", getenv("ZDTM_ROOT"));	if (strcmp(getenv("ZDTM_NEWNS"), "1"))		goto test;	pid = fork();	if (pid < 0)		return 1;	if (pid == 0) {		test_ext_init(argc, argv);		mkdir(dname, 755);		sprintf(src, "%s/test", dname);		if (mount("zdtm_auto_ext_mnt", dname, "tmpfs", 0, NULL)) {			pr_perror("mount");			return 1;		}		mkdir(src, 755);		mkdir(dst, 755);		if (mount(src, dst, NULL, MS_BIND, NULL)) {			pr_perror("bind");			return 1;		}		return 0;	}	wait(&status);	if (status != 0)		return 1;test:	test_init(argc, argv);	test_daemon();	test_waitsig();	pass();	return 0;}

int main(int argc, char ** argv){	int sk, skc;	int ret, len;	char path[PATH_MAX];	struct sockaddr_un addr;	socklen_t addrlen;	test_init(argc, argv);	sk = socket(AF_UNIX, SOCK_STREAM, 0);	if (sk == -1) {		pr_perror("socket");		return 1;	}	skc = socket(AF_UNIX, SOCK_STREAM, 0);	if (skc == -1) {		pr_perror("socket");		return 1;	}	len = snprintf(path, sizeof(path), "X/zdtm-%s-%d/X", argv[0], getpid());	addr.sun_family = AF_UNIX;	strncpy(addr.sun_path, path, sizeof(addr.sun_path));	addrlen = sizeof(addr.sun_family) + len;	addr.sun_path[0] = 0;	addr.sun_path[len - 1] = 0;	ret = bind(sk, (struct sockaddr *) &addr, addrlen);	if (ret) {		fail("bind/n");		return 1;	}	test_daemon();	test_waitsig();	if (listen(sk, 1) == -1) {		pr_perror("listen");		return 1;	}	if (connect(skc, (struct sockaddr *) &addr, addrlen) == -1) {		fail("Unable to connect");		return 1;	}	pass();	return 0;}

int main(int argc, char ** argv){	char dst[PATH_MAX];	if (strcmp(getenv("ZDTM_NEWNS"), "1"))		goto test;	if (unshare(CLONE_NEWNS)) {		pr_perror("unshare");		return 1;	}	sprintf(dst, "%s/%s", get_current_dir_name(), dirname);	if (mkdir(dst, 755) < 0) {		pr_perror("mkdir");		return 1;	}	if (mount("/sys/kernel/debug", dst, NULL, MS_BIND | MS_REC, NULL)) {		rmdir(dst);		pr_perror("mount");		return 1;	}	/* trigger the tracefs mount */	strcat(dst, "/tracing/README");	if (access(dst, F_OK) < 0) {		umount(dst);		rmdir(dst);		pr_perror("access");		return 1;	}test:	test_init(argc, argv);	test_daemon();	test_waitsig();	sprintf(dst, "%s/%s/tracing/README", get_current_dir_name(), dirname);	/* EACCES is what we expect, since users can't actually /see/ this	 * filesystem, but CRIU needs to know how to remount it, so the restore	 * should succeed	 */	if (access(dst, F_OK) < 0 && errno != EACCES) {		fail("couldn't access tracefs at %s", dst);		return 1;	}	pass();	return 0;}

static int child2(void *_arg){	char buf[10];	test_waitsig();	if (read(TEST_FD, buf, sizeof(TEST_STRING)) != sizeof(TEST_STRING)) {		err("Unable to read from %d/n", TEST_FD);		return 1;	}	return 0;}

int main(int argc, char **argv){	char *start_addr, *grow_down;	test_init(argc, argv);	start_addr = mmap(NULL, PAGE_SIZE * 10, PROT_READ | PROT_WRITE,					MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);	if (start_addr == MAP_FAILED) {		pr_perror("Can't mal a new region");		return 1;	}	munmap(start_addr, PAGE_SIZE * 10);	grow_down = mmap(start_addr + PAGE_SIZE * 3, PAGE_SIZE * 3,			 PROT_READ | PROT_WRITE,			 MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED | MAP_GROWSDOWN, -1, 0);	if (grow_down == MAP_FAILED) {		pr_perror("Can't mal a new region");		return 1;	}	grow_down[0 * PAGE_SIZE] = 'x';	grow_down[1 * PAGE_SIZE] = 'y';	grow_down[2 * PAGE_SIZE] = 'z';	/*	 * Split the grow-down vma on three parts.	 * Only the irst one will have a guard page	 */	if (mprotect(grow_down + PAGE_SIZE, PAGE_SIZE, PROT_READ)) {		pr_perror("Can't change set protection on a region of memory");		return 1;	}	test_daemon();	test_waitsig();	test_msg("%c %c %c/n", grow_down[0 * PAGE_SIZE],		 grow_down[1 * PAGE_SIZE], grow_down[2 * PAGE_SIZE]);	if (grow_down[0 * PAGE_SIZE] != 'x')		return 1;	if (grow_down[1 * PAGE_SIZE] != 'y')		return 1;	if (grow_down[2 * PAGE_SIZE] != 'z')		return 1;	pass();	return 0;}

int main(int argc, char ** argv){	void *start;	int fd, i;	test_init(argc, argv);	fd = open(filename, O_RDWR | O_CREAT, 0666);	if (fd < 0)		return 1;	ftruncate(fd, 4096);	start = mmap(0, 4096 * TEST_SIZE * 4, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);	if (start == MAP_FAILED)		return 1;	for (i = 0; i < TEST_SIZE; i++) {		int *addr;		addr = mmap(start + i * 3 * 4096, 4096,				PROT_READ | PROT_WRITE,				MAP_PRIVATE | MAP_FILE | MAP_FIXED, fd, 0);		if (addr == MAP_FAILED)			return 1;		addr[0] = i * 2;		addr = mmap(start + (i * 3 + 1) * 4096, 4096,				PROT_READ | PROT_WRITE,				MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);		if (addr == MAP_FAILED)			return 1;		addr[0] = i;	}	test_daemon();	test_waitsig();	for (i = 0; i < TEST_SIZE; i++) {		int *addr;		addr = start + i * 3 * 4096;		if (addr[0] != i * 2)			fail();		addr = start + (i * 3  + 1) * 4096;		if (addr[0] != i)			fail();	}	pass();	return 0;}

int main(int argc, char **argv){	int ret = -1;	char path[PATH_MAX];	test_init(argc, argv);	if (mount_and_add(cgname, "test") < 0)		return -1;	sprintf(path, "%s/%s/test", dirname, cgname);	if (chownmod(path, O_DIRECTORY) < 0)		goto out_umount;	sprintf(path, "%s/%s/test/notify_on_release", dirname, cgname);	if (chownmod(path, O_RDWR) < 0)		goto out_umount;	sprintf(path, "%s/%s/test/cgroup.procs", dirname, cgname);	if (chownmod(path, O_RDWR) < 0)		goto out_umount;	test_daemon();	test_waitsig();	sprintf(path, "%s/%s/test", dirname, cgname);	if (checkperms(path) < 0)		goto out_umount;	sprintf(path, "%s/%s/test/notify_on_release", dirname, cgname);	if (checkperms(path) < 0)		goto out_umount;	sprintf(path, "%s/%s/test/cgroup.procs", dirname, cgname);	if (checkperms(path) < 0)		goto out_umount;	pass();	ret = 0;out_umount:	sprintf(path, "%s/%s/test", dirname, cgname);	rmdir(path);	sprintf(path, "%s/%s", dirname, cgname);	umount(path);	rmdir(path);	rmdir(dirname);	return ret;}