Commit aa803771 authored by Joe Perches's avatar Joe Perches Committed by Shuah Khan
Browse files

tools: Avoid comma separated statements 



Use semicolons and braces.

Signed-off-by: default avatarJoe Perches <joe@perches.com>
Signed-off-by: default avatarShuah Khan <skhan@linuxfoundation.org>
parent c8bd596f

tools/lib/subcmd/help.c

+6 −4
Original line number Diff line number Diff line
@@ -65,12 +65,14 @@ void exclude_cmds(struct cmdnames *cmds, struct cmdnames *excludes) 
	ci = cj = ei = 0;

	while (ci < cmds->cnt && ei < excludes->cnt) {

		cmp = strcmp(cmds->names[ci]->name, excludes->names[ei]->name);

		if (cmp < 0)

		if (cmp < 0) {

			cmds->names[cj++] = cmds->names[ci++];

		else if (cmp == 0)

			ci++, ei++;

		else if (cmp > 0)

		} else if (cmp == 0) {

			ci++;

			ei++;

		} else if (cmp > 0) {

			ei++;

		}

	}



	while (ci < cmds->cnt)

tools/power/cpupower/utils/cpufreq-set.c

+9 −5
Original line number Diff line number Diff line
@@ -99,13 +99,17 @@ static unsigned long string_to_frequency(const char *str) 
		continue;



	if (str[cp] == '.') {

		while (power > -1 && isdigit(str[cp+1]))

			cp++, power--;

		while (power > -1 && isdigit(str[cp+1])) {

			cp++;

			power--;

		}

	if (power >= -1)	/* not enough => pad */

	}

	if (power >= -1) {		/* not enough => pad */

		pad = power + 1;

	else			/* to much => strip */

		pad = 0, cp += power + 1;

	} else {			/* too much => strip */

		pad = 0;

		cp += power + 1;

	}

	/* check bounds */

	if (cp <= 0 || cp + pad > NORM_FREQ_LEN - 1)

		return 0;

tools/testing/selftests/vm/gup_benchmark.c

+12 −6
Original line number Diff line number Diff line
@@ -105,12 +105,16 @@ int main(int argc, char **argv) 
		gup.flags |= FOLL_WRITE;



	fd = open("/sys/kernel/debug/gup_benchmark", O_RDWR);

	if (fd == -1)

		perror("open"), exit(1);

	if (fd == -1) {

		perror("open");

		exit(1);

	}



	p = mmap(NULL, size, PROT_READ | PROT_WRITE, flags, filed, 0);

	if (p == MAP_FAILED)

		perror("mmap"), exit(1);

	if (p == MAP_FAILED) {

		perror("mmap");

		exit(1);

	}

	gup.addr = (unsigned long)p;



	if (thp == 1)
@@ -123,8 +127,10 @@ int main(int argc, char **argv) 


	for (i = 0; i < repeats; i++) {

		gup.size = size;

		if (ioctl(fd, cmd, &gup))

			perror("ioctl"), exit(1);

		if (ioctl(fd, cmd, &gup)) {

			perror("ioctl");

			exit(1);

		}



		printf("Time: get:%lld put:%lld us", gup.get_delta_usec,

			gup.put_delta_usec);

tools/testing/selftests/vm/userfaultfd.c

+183 −113
Original line number Diff line number Diff line
@@ -227,8 +227,10 @@ static void hugetlb_allocate_area(void **alloc_area) 
				  huge_fd, *alloc_area == area_src ? 0 :

				  nr_pages * page_size);

		if (area_alias == MAP_FAILED) {

			if (munmap(*alloc_area, nr_pages * page_size) < 0)

				perror("hugetlb munmap"), exit(1);

			if (munmap(*alloc_area, nr_pages * page_size) < 0) {

				perror("hugetlb munmap");

				exit(1);

			}

			*alloc_area = NULL;

			return;

		}
@@ -337,9 +339,10 @@ static void wp_range(int ufd, __u64 start, __u64 len, bool wp) 
	/* Undo write-protect, do wakeup after that */

	prms.mode = wp ? UFFDIO_WRITEPROTECT_MODE_WP : 0;



	if (ioctl(ufd, UFFDIO_WRITEPROTECT, &prms))

		fprintf(stderr, "clear WP failed for address 0x%Lx\n",

			start), exit(1);

	if (ioctl(ufd, UFFDIO_WRITEPROTECT, &prms)) {

		fprintf(stderr, "clear WP failed for address 0x%Lx\n", start);

		exit(1);

	}

}



static void *locking_thread(void *arg)
@@ -359,8 +362,10 @@ static void *locking_thread(void *arg) 
			seed += cpu;

		bzero(&rand, sizeof(rand));

		bzero(&randstate, sizeof(randstate));

		if (initstate_r(seed, randstate, sizeof(randstate), &rand))

			fprintf(stderr, "srandom_r error\n"), exit(1);

		if (initstate_r(seed, randstate, sizeof(randstate), &rand)) {

			fprintf(stderr, "srandom_r error\n");

			exit(1);

		}

	} else {

		page_nr = -bounces;

		if (!(bounces & BOUNCE_RACINGFAULTS))
@@ -369,12 +374,16 @@ static void *locking_thread(void *arg) 


	while (!finished) {

		if (bounces & BOUNCE_RANDOM) {

			if (random_r(&rand, &rand_nr))

				fprintf(stderr, "random_r 1 error\n"), exit(1);

			if (random_r(&rand, &rand_nr)) {

				fprintf(stderr, "random_r 1 error\n");

				exit(1);

			}

			page_nr = rand_nr;

			if (sizeof(page_nr) > sizeof(rand_nr)) {

				if (random_r(&rand, &rand_nr))

					fprintf(stderr, "random_r 2 error\n"), exit(1);

				if (random_r(&rand, &rand_nr)) {

					fprintf(stderr, "random_r 2 error\n");

					exit(1);

				}

				page_nr |= (((unsigned long) rand_nr) << 16) <<

					   16;

			}
@@ -385,11 +394,13 @@ static void *locking_thread(void *arg) 
		start = time(NULL);

		if (bounces & BOUNCE_VERIFY) {

			count = *area_count(area_dst, page_nr);

			if (!count)

			if (!count) {

				fprintf(stderr,

					"page_nr %lu wrong count %Lu %Lu\n",

					page_nr, count,

					count_verify[page_nr]), exit(1);

					count_verify[page_nr]);

				exit(1);

			}





			/*
@@ -401,11 +412,12 @@ static void *locking_thread(void *arg) 
			 */

#if 1

			if (!my_bcmp(area_dst + page_nr * page_size, zeropage,

				     page_size))

				     page_size)) {

				fprintf(stderr,

					"my_bcmp page_nr %lu wrong count %Lu %Lu\n",

					page_nr, count,

					count_verify[page_nr]), exit(1);

					page_nr, count, count_verify[page_nr]);

				exit(1);

			}

#else

			unsigned long loops;
@@ -437,7 +449,7 @@ static void *locking_thread(void *arg) 
			fprintf(stderr,

				"page_nr %lu memory corruption %Lu %Lu\n",

				page_nr, count,

				count_verify[page_nr]), exit(1);

				count_verify[page_nr]); exit(1);

		}

		count++;

		*area_count(area_dst, page_nr) = count_verify[page_nr] = count;
@@ -461,12 +473,14 @@ static void retry_copy_page(int ufd, struct uffdio_copy *uffdio_copy, 
				     offset);

	if (ioctl(ufd, UFFDIO_COPY, uffdio_copy)) {

		/* real retval in ufdio_copy.copy */

		if (uffdio_copy->copy != -EEXIST)

		if (uffdio_copy->copy != -EEXIST) {

			fprintf(stderr, "UFFDIO_COPY retry error %Ld\n",

				uffdio_copy->copy), exit(1);

				uffdio_copy->copy);

			exit(1);

		}

	} else {

		fprintf(stderr,	"UFFDIO_COPY retry unexpected %Ld\n",

			uffdio_copy->copy), exit(1);

			uffdio_copy->copy); exit(1);

	}

}
@@ -474,9 +488,10 @@ static int __copy_page(int ufd, unsigned long offset, bool retry) 
{

	struct uffdio_copy uffdio_copy;



	if (offset >= nr_pages * page_size)

		fprintf(stderr, "unexpected offset %lu\n",

			offset), exit(1);

	if (offset >= nr_pages * page_size) {

		fprintf(stderr, "unexpected offset %lu\n", offset);

		exit(1);

	}

	uffdio_copy.dst = (unsigned long) area_dst + offset;

	uffdio_copy.src = (unsigned long) area_src + offset;

	uffdio_copy.len = page_size;
@@ -487,12 +502,14 @@ static int __copy_page(int ufd, unsigned long offset, bool retry) 
	uffdio_copy.copy = 0;

	if (ioctl(ufd, UFFDIO_COPY, &uffdio_copy)) {

		/* real retval in ufdio_copy.copy */

		if (uffdio_copy.copy != -EEXIST)

		if (uffdio_copy.copy != -EEXIST) {

			fprintf(stderr, "UFFDIO_COPY error %Ld\n",

				uffdio_copy.copy), exit(1);

				uffdio_copy.copy);

			exit(1);

		}

	} else if (uffdio_copy.copy != page_size) {

		fprintf(stderr, "UFFDIO_COPY unexpected copy %Ld\n",

			uffdio_copy.copy), exit(1);

			uffdio_copy.copy); exit(1);

	} else {

		if (test_uffdio_copy_eexist && retry) {

			test_uffdio_copy_eexist = false;
@@ -521,11 +538,11 @@ static int uffd_read_msg(int ufd, struct uffd_msg *msg) 
		if (ret < 0) {

			if (errno == EAGAIN)

				return 1;

			else

				perror("blocking read error"), exit(1);

			perror("blocking read error");

		} else {

			fprintf(stderr, "short read\n"), exit(1);

			fprintf(stderr, "short read\n");

		}

		exit(1);

	}



	return 0;
@@ -536,9 +553,10 @@ static void uffd_handle_page_fault(struct uffd_msg *msg, 
{

	unsigned long offset;



	if (msg->event != UFFD_EVENT_PAGEFAULT)

		fprintf(stderr, "unexpected msg event %u\n",

			msg->event), exit(1);

	if (msg->event != UFFD_EVENT_PAGEFAULT) {

		fprintf(stderr, "unexpected msg event %u\n", msg->event);

		exit(1);

	}



	if (msg->arg.pagefault.flags & UFFD_PAGEFAULT_FLAG_WP) {

		wp_range(uffd, msg->arg.pagefault.address, page_size, false);
@@ -546,8 +564,10 @@ static void uffd_handle_page_fault(struct uffd_msg *msg, 
	} else {

		/* Missing page faults */

		if (bounces & BOUNCE_VERIFY &&

		    msg->arg.pagefault.flags & UFFD_PAGEFAULT_FLAG_WRITE)

			fprintf(stderr, "unexpected write fault\n"), exit(1);

		    msg->arg.pagefault.flags & UFFD_PAGEFAULT_FLAG_WRITE) {

			fprintf(stderr, "unexpected write fault\n");

			exit(1);

		}



		offset = (char *)(unsigned long)msg->arg.pagefault.address - area_dst;

		offset &= ~(page_size-1);
@@ -574,25 +594,32 @@ static void *uffd_poll_thread(void *arg) 


	for (;;) {

		ret = poll(pollfd, 2, -1);

		if (!ret)

			fprintf(stderr, "poll error %d\n", ret), exit(1);

		if (ret < 0)

			perror("poll"), exit(1);

		if (!ret) {

			fprintf(stderr, "poll error %d\n", ret);

			exit(1);

		}

		if (ret < 0) {

			perror("poll");

			exit(1);

		}

		if (pollfd[1].revents & POLLIN) {

			if (read(pollfd[1].fd, &tmp_chr, 1) != 1)

				fprintf(stderr, "read pipefd error\n"),

			if (read(pollfd[1].fd, &tmp_chr, 1) != 1) {

				fprintf(stderr, "read pipefd error\n");

				exit(1);

			}

			break;

		}

		if (!(pollfd[0].revents & POLLIN))

		if (!(pollfd[0].revents & POLLIN)) {

			fprintf(stderr, "pollfd[0].revents %d\n",

				pollfd[0].revents), exit(1);

				pollfd[0].revents);

			exit(1);

		}

		if (uffd_read_msg(uffd, &msg))

			continue;

		switch (msg.event) {

		default:

			fprintf(stderr, "unexpected msg event %u\n",

				msg.event), exit(1);

				msg.event); exit(1);

			break;

		case UFFD_EVENT_PAGEFAULT:

			uffd_handle_page_fault(&msg, stats);
@@ -606,8 +633,10 @@ static void *uffd_poll_thread(void *arg) 
			uffd_reg.range.start = msg.arg.remove.start;

			uffd_reg.range.len = msg.arg.remove.end -

				msg.arg.remove.start;

			if (ioctl(uffd, UFFDIO_UNREGISTER, &uffd_reg.range))

				fprintf(stderr, "remove failure\n"), exit(1);

			if (ioctl(uffd, UFFDIO_UNREGISTER, &uffd_reg.range)) {

				fprintf(stderr, "remove failure\n");

				exit(1);

			}

			break;

		case UFFD_EVENT_REMAP:

			area_dst = (char *)(unsigned long)msg.arg.remap.to;
@@ -879,8 +908,10 @@ static int faulting_process(int signal_test) 


	area_dst = mremap(area_dst, nr_pages * page_size,  nr_pages * page_size,

			  MREMAP_MAYMOVE | MREMAP_FIXED, area_src);

	if (area_dst == MAP_FAILED)

		perror("mremap"), exit(1);

	if (area_dst == MAP_FAILED) {

		perror("mremap");

		exit(1);

	}



	for (; nr < nr_pages; nr++) {

		count = *area_count(area_dst, nr);
@@ -888,7 +919,7 @@ static int faulting_process(int signal_test) 
			fprintf(stderr,

				"nr %lu memory corruption %Lu %Lu\n",

				nr, count,

				count_verify[nr]), exit(1);

				count_verify[nr]); exit(1);

		}

		/*

		 * Trigger write protection if there is by writting
@@ -901,8 +932,10 @@ static int faulting_process(int signal_test) 
		return 1;



	for (nr = 0; nr < nr_pages; nr++) {

		if (my_bcmp(area_dst + nr * page_size, zeropage, page_size))

			fprintf(stderr, "nr %lu is not zero\n", nr), exit(1);

		if (my_bcmp(area_dst + nr * page_size, zeropage, page_size)) {

			fprintf(stderr, "nr %lu is not zero\n", nr);

			exit(1);

		}

	}



	return 0;
@@ -916,12 +949,14 @@ static void retry_uffdio_zeropage(int ufd, 
				     uffdio_zeropage->range.len,

				     offset);

	if (ioctl(ufd, UFFDIO_ZEROPAGE, uffdio_zeropage)) {

		if (uffdio_zeropage->zeropage != -EEXIST)

		if (uffdio_zeropage->zeropage != -EEXIST) {

			fprintf(stderr, "UFFDIO_ZEROPAGE retry error %Ld\n",

				uffdio_zeropage->zeropage), exit(1);

				uffdio_zeropage->zeropage);

			exit(1);

		}

	} else {

		fprintf(stderr, "UFFDIO_ZEROPAGE retry unexpected %Ld\n",

			uffdio_zeropage->zeropage), exit(1);

			uffdio_zeropage->zeropage); exit(1);

	}

}
@@ -933,9 +968,10 @@ static int __uffdio_zeropage(int ufd, unsigned long offset, bool retry) 


	has_zeropage = uffd_test_ops->expected_ioctls & (1 << _UFFDIO_ZEROPAGE);



	if (offset >= nr_pages * page_size)

		fprintf(stderr, "unexpected offset %lu\n",

			offset), exit(1);

	if (offset >= nr_pages * page_size) {

		fprintf(stderr, "unexpected offset %lu\n", offset);

		exit(1);

	}

	uffdio_zeropage.range.start = (unsigned long) area_dst + offset;

	uffdio_zeropage.range.len = page_size;

	uffdio_zeropage.mode = 0;
@@ -943,22 +979,26 @@ static int __uffdio_zeropage(int ufd, unsigned long offset, bool retry) 
	if (ret) {

		/* real retval in ufdio_zeropage.zeropage */

		if (has_zeropage) {

			if (uffdio_zeropage.zeropage == -EEXIST)

				fprintf(stderr, "UFFDIO_ZEROPAGE -EEXIST\n"),

			if (uffdio_zeropage.zeropage == -EEXIST) {

				fprintf(stderr, "UFFDIO_ZEROPAGE -EEXIST\n");

				exit(1);

			else

			} else {

				fprintf(stderr, "UFFDIO_ZEROPAGE error %Ld\n",

					uffdio_zeropage.zeropage), exit(1);

					uffdio_zeropage.zeropage);

				exit(1);

			}

		} else {

			if (uffdio_zeropage.zeropage != -EINVAL)

			if (uffdio_zeropage.zeropage != -EINVAL) {

				fprintf(stderr,

					"UFFDIO_ZEROPAGE not -EINVAL %Ld\n",

					uffdio_zeropage.zeropage), exit(1);

					uffdio_zeropage.zeropage);

				exit(1);

			}

		}

	} else if (has_zeropage) {

		if (uffdio_zeropage.zeropage != page_size) {

			fprintf(stderr, "UFFDIO_ZEROPAGE unexpected %Ld\n",

				uffdio_zeropage.zeropage), exit(1);

				uffdio_zeropage.zeropage); exit(1);

		} else {

			if (test_uffdio_zeropage_eexist && retry) {

				test_uffdio_zeropage_eexist = false;
@@ -970,7 +1010,7 @@ static int __uffdio_zeropage(int ufd, unsigned long offset, bool retry) 
	} else {

		fprintf(stderr,

			"UFFDIO_ZEROPAGE succeeded %Ld\n",

			uffdio_zeropage.zeropage), exit(1);

			uffdio_zeropage.zeropage); exit(1);

	}



	return 0;
@@ -1000,19 +1040,24 @@ static int userfaultfd_zeropage_test(void) 
	uffdio_register.mode = UFFDIO_REGISTER_MODE_MISSING;

	if (test_uffdio_wp)

		uffdio_register.mode |= UFFDIO_REGISTER_MODE_WP;

	if (ioctl(uffd, UFFDIO_REGISTER, &uffdio_register))

		fprintf(stderr, "register failure\n"), exit(1);

	if (ioctl(uffd, UFFDIO_REGISTER, &uffdio_register)) {

		fprintf(stderr, "register failure\n");

		exit(1);

	}



	expected_ioctls = uffd_test_ops->expected_ioctls;

	if ((uffdio_register.ioctls & expected_ioctls) !=

	    expected_ioctls)

	    expected_ioctls) {

		fprintf(stderr,

			"unexpected missing ioctl for anon memory\n"),

			"unexpected missing ioctl for anon memory\n");

		exit(1);

	}



	if (uffdio_zeropage(uffd, 0)) {

		if (my_bcmp(area_dst, zeropage, page_size))

			fprintf(stderr, "zeropage is not zero\n"), exit(1);

		if (my_bcmp(area_dst, zeropage, page_size)) {

			fprintf(stderr, "zeropage is not zero\n");

			exit(1);

		}

	}



	close(uffd);
@@ -1047,32 +1092,41 @@ static int userfaultfd_events_test(void) 
	uffdio_register.mode = UFFDIO_REGISTER_MODE_MISSING;

	if (test_uffdio_wp)

		uffdio_register.mode |= UFFDIO_REGISTER_MODE_WP;

	if (ioctl(uffd, UFFDIO_REGISTER, &uffdio_register))

		fprintf(stderr, "register failure\n"), exit(1);

	if (ioctl(uffd, UFFDIO_REGISTER, &uffdio_register)) {

		fprintf(stderr, "register failure\n");

		exit(1);

	}



	expected_ioctls = uffd_test_ops->expected_ioctls;

	if ((uffdio_register.ioctls & expected_ioctls) !=

	    expected_ioctls)

		fprintf(stderr,

			"unexpected missing ioctl for anon memory\n"),

	if ((uffdio_register.ioctls & expected_ioctls) != expected_ioctls) {

		fprintf(stderr, "unexpected missing ioctl for anon memory\n");

		exit(1);

	}



	if (pthread_create(&uffd_mon, &attr, uffd_poll_thread, &stats))

		perror("uffd_poll_thread create"), exit(1);

	if (pthread_create(&uffd_mon, &attr, uffd_poll_thread, &stats)) {

		perror("uffd_poll_thread create");

		exit(1);

	}



	pid = fork();

	if (pid < 0)

		perror("fork"), exit(1);

	if (pid < 0) {

		perror("fork");

		exit(1);

	}



	if (!pid)

		return faulting_process(0);



	waitpid(pid, &err, 0);

	if (err)

		fprintf(stderr, "faulting process failed\n"), exit(1);

	if (err) {

		fprintf(stderr, "faulting process failed\n");

		exit(1);

	}



	if (write(pipefd[1], &c, sizeof(c)) != sizeof(c))

		perror("pipe write"), exit(1);

	if (write(pipefd[1], &c, sizeof(c)) != sizeof(c)) {

		perror("pipe write");

		exit(1);

	}

	if (pthread_join(uffd_mon, NULL))

		return 1;
@@ -1110,38 +1164,49 @@ static int userfaultfd_sig_test(void) 
	uffdio_register.mode = UFFDIO_REGISTER_MODE_MISSING;

	if (test_uffdio_wp)

		uffdio_register.mode |= UFFDIO_REGISTER_MODE_WP;

	if (ioctl(uffd, UFFDIO_REGISTER, &uffdio_register))

		fprintf(stderr, "register failure\n"), exit(1);

	if (ioctl(uffd, UFFDIO_REGISTER, &uffdio_register)) {

		fprintf(stderr, "register failure\n");

		exit(1);

	}



	expected_ioctls = uffd_test_ops->expected_ioctls;

	if ((uffdio_register.ioctls & expected_ioctls) !=

	    expected_ioctls)

		fprintf(stderr,

			"unexpected missing ioctl for anon memory\n"),

	if ((uffdio_register.ioctls & expected_ioctls) != expected_ioctls) {

		fprintf(stderr, "unexpected missing ioctl for anon memory\n");

		exit(1);

	}



	if (faulting_process(1))

		fprintf(stderr, "faulting process failed\n"), exit(1);

	if (faulting_process(1)) {

		fprintf(stderr, "faulting process failed\n");

		exit(1);

	}



	if (uffd_test_ops->release_pages(area_dst))

		return 1;



	if (pthread_create(&uffd_mon, &attr, uffd_poll_thread, &stats))

		perror("uffd_poll_thread create"), exit(1);

	if (pthread_create(&uffd_mon, &attr, uffd_poll_thread, &stats)) {

		perror("uffd_poll_thread create");

		exit(1);

	}



	pid = fork();

	if (pid < 0)

		perror("fork"), exit(1);

	if (pid < 0) {

		perror("fork");

		exit(1);

	}



	if (!pid)

		exit(faulting_process(2));



	waitpid(pid, &err, 0);

	if (err)

		fprintf(stderr, "faulting process failed\n"), exit(1);

	if (err) {

		fprintf(stderr, "faulting process failed\n");

		exit(1);

	}



	if (write(pipefd[1], &c, sizeof(c)) != sizeof(c))

		perror("pipe write"), exit(1);

	if (write(pipefd[1], &c, sizeof(c)) != sizeof(c)) {

		perror("pipe write");

		exit(1);

	}

	if (pthread_join(uffd_mon, (void **)&userfaults))

		return 1;
@@ -1395,7 +1460,7 @@ static void set_test_type(const char *type) 
		test_type = TEST_SHMEM;

		uffd_test_ops = &shmem_uffd_test_ops;

	} else {

		fprintf(stderr, "Unknown test type: %s\n", type), exit(1);

		fprintf(stderr, "Unknown test type: %s\n", type); exit(1);

	}



	if (test_type == TEST_HUGETLB)
@@ -1403,12 +1468,15 @@ static void set_test_type(const char *type) 
	else

		page_size = sysconf(_SC_PAGE_SIZE);



	if (!page_size)

		fprintf(stderr, "Unable to determine page size\n"),

	if (!page_size) {

		fprintf(stderr, "Unable to determine page size\n");

		exit(2);

	}

	if ((unsigned long) area_count(NULL, 0) + sizeof(unsigned long long) * 2

	    > page_size)

		fprintf(stderr, "Impossible to run this test\n"), exit(2);

	    > page_size) {

		fprintf(stderr, "Impossible to run this test\n");

		exit(2);

	}

}



static void sigalrm(int sig)
@@ -1425,8 +1493,10 @@ int main(int argc, char **argv) 
	if (argc < 4)

		usage();



	if (signal(SIGALRM, sigalrm) == SIG_ERR)

		fprintf(stderr, "failed to arm SIGALRM"), exit(1);

	if (signal(SIGALRM, sigalrm) == SIG_ERR) {

		fprintf(stderr, "failed to arm SIGALRM");

		exit(1);

	}

	alarm(ALARM_INTERVAL_SECS);



	set_test_type(argv[1]);