 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_kcov.c,v 1.5 2019/03/10 17:51:00 kamil Exp $	*/
+/*	$NetBSD: subr_kcov.c,v 1.6 2019/03/10 22:34:14 kamil Exp $	*/
 /*
  * Copyright (c) 2019 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Siddharth Muralee.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -407,27 +407,27 @@ trace_cmp(uint64_t type, uint64_t arg1,
 	kd = lwp_getspecific(kcov_lwp_key);
 	if (__predict_true(kd == NULL)) {
 		/* Not traced. */
 		return;
+	}
 	if (!kd->enabled) {
 		/* Tracing not enabled */
 		return;
+	}
 	if (kd->mode != KCOV_MODE_TRACE_CMP) {
-		/* PC tracing mode not enabled */
+		/* CMP tracing mode not enabled */
 		return;
+	}
 	idx = KCOV_LOAD(kd->buf[0]);
 	if ((idx * 4 + 4) <= kd->bufnent) {
 		KCOV_STORE(kd->buf[idx * 4 + 1], type);
 		KCOV_STORE(kd->buf[idx * 4 + 2], arg1);
 		KCOV_STORE(kd->buf[idx * 4 + 3], arg2);
 		KCOV_STORE(kd->buf[idx * 4 + 4], pc);
 		KCOV_STORE(kd->buf[0], idx + 1);
+	}
+}

 @@ -47,26 +47,54 @@
 static int
 open_kcov(void)
+{
 	int fd;
 	fd = open("/dev/kcov", O_RDWR);
 	if (fd == -1)
 		atf_tc_skip("Failed to open /dev/kcov");
 	return fd;
+}
 static int
 pick_unassigned_fd(int greater_than_fd)
+{
 	int fd2;
 	fd2 = greater_than_fd;
 	do {
 		++fd2;
 	} while (fcntl(fd2, F_GETFL) != -1 || errno != EBADF);
 	return fd2;
+}
 ATF_TC_WITHOUT_HEAD(kcov_dup2);
 ATF_TC_BODY(kcov_dup2, tc)
+{
 	int fd1, fd2;
 	fd1 = open_kcov();
 	fd2 = pick_unassigned_fd(fd1);
 	/* Test the dup2(2) trick used by syzkaller */
 	ATF_REQUIRE_EQ(dup2(fd1, fd2), fd2);
 	close(fd1);
 	close(fd2);
+}
 ATF_TC_WITHOUT_HEAD(kcov_multiopen);
 ATF_TC_BODY(kcov_multiopen, tc)
+{
 	int fd1, fd2;
 	fd1 = open_kcov();
 	fd2 = open("/dev/kcov", O_RDWR);
 	ATF_REQUIRE(fd2 != -1);
 	close(fd1);
 	close(fd2);
+}
 @@ -206,31 +234,27 @@ ATF_TC_BODY(kcov_enable, tc)
 	ATF_REQUIRE(ioctl(fd, KCOV_IOC_SETBUFSIZE, &size) ==0);
 	/* We need to enable before disable */
 	ATF_CHECK(ioctl(fd, KCOV_IOC_DISABLE) == -1);
 	/* Check enabling works only with a valid trace method */
 	ATF_CHECK(ioctl(fd, KCOV_IOC_ENABLE, &mode) == 0);
 	ATF_CHECK(ioctl(fd, KCOV_IOC_ENABLE, &mode) == -1);
 	/* Disable should only be called once */
 	ATF_CHECK(ioctl(fd, KCOV_IOC_DISABLE) == 0);
 	ATF_CHECK(ioctl(fd, KCOV_IOC_DISABLE) == -1);
-	/* Re-enabling should also work */
+	/* Re-enabling and changing mode should also work */
 	ATF_CHECK(ioctl(fd, KCOV_IOC_ENABLE, &mode) == 0);
 	ATF_CHECK(ioctl(fd, KCOV_IOC_DISABLE) == 0);
 	/* Re-enablibling and changing mode should also work */
 	mode = KCOV_MODE_NONE;
 	ATF_CHECK(ioctl(fd, KCOV_IOC_ENABLE, &mode) == 0);
 	ATF_CHECK(ioctl(fd, KCOV_IOC_DISABLE) == 0);
 	mode = KCOV_MODE_TRACE_PC;
 	ATF_CHECK(ioctl(fd, KCOV_IOC_ENABLE, &mode) == 0);
 	ATF_CHECK(ioctl(fd, KCOV_IOC_DISABLE) == 0);
 	mode = KCOV_MODE_TRACE_CMP;
 	ATF_CHECK(ioctl(fd, KCOV_IOC_ENABLE, &mode) == 0);
 	ATF_CHECK(ioctl(fd, KCOV_IOC_DISABLE) == 0);
 	close(fd);
+}
 @@ -252,89 +276,120 @@ ATF_TC_WITHOUT_HEAD(kcov_enable_no_disab
 ATF_TC_BODY(kcov_enable_no_disable_no_close, tc)
+{
 	int fd;
 	uint64_t size = PAGE_SIZE / KCOV_ENTRY_SIZE;
 	int mode;
 	fd = open_kcov();
 	ATF_REQUIRE(ioctl(fd, KCOV_IOC_SETBUFSIZE, &size) ==0);
 	mode = KCOV_MODE_NONE;
 	ATF_CHECK(ioctl(fd, KCOV_IOC_ENABLE, &mode) == 0);
+}
 static void *
-common_head(int *fdp)
+common_head_raw(bool fd_dup, int *fdp)
+{
 	void *data;
-	int fd;
+	int fd, fd2;
 	uint64_t size = PAGE_SIZE / KCOV_ENTRY_SIZE;
 	fd = open_kcov();
 	/* Test the dup2(2) trick used by syzkaller */
 	if (fd_dup) {
 		fd2 = pick_unassigned_fd(fd);
 		ATF_REQUIRE_EQ(dup2(fd, fd2), fd2);
 		close(fd);
 		fd = fd2;
+	}
 	ATF_REQUIRE_MSG(ioctl(fd, KCOV_IOC_SETBUFSIZE, &size) == 0,
 	    "Unable to set the kcov buffer size");
 	data = mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 	ATF_REQUIRE_MSG(data != MAP_FAILED, "Unable to mmap the kcov buffer");
 	*fdp = fd;
 	return data;
+}
 static void *
 common_head(int *fdp)
+{
 	return common_head_raw(false, fdp);
+}
 static void
 common_tail(int fd, kcov_int_t *data)
+{
 	ATF_REQUIRE_MSG(munmap(__UNVOLATILE(data), PAGE_SIZE) == 0,
 	    "Unable to unmap the kcov buffer");
 	close(fd);
+}
 static void
-kcov_basic(int mode)
+kcov_basic(bool fd_dup, int mode)
+{
 	kcov_int_t *buf;
 	int fd;
-	buf = common_head(&fd);
+	buf = common_head_raw(fd_dup, &fd);
 	ATF_REQUIRE_MSG(ioctl(fd, KCOV_IOC_ENABLE, &mode) == 0,
 	    "Unable to enable kcov ");
 	KCOV_STORE(buf[0], 0);
 	sleep(0); /* XXX: Is it enough for all trace types? */
 	ATF_REQUIRE_MSG(KCOV_LOAD(buf[0]) != 0, "No records found");
 	ATF_REQUIRE_MSG(ioctl(fd, KCOV_IOC_DISABLE) == 0,
 	    "Unable to disable kcov");
 	common_tail(fd, buf);
+}
 ATF_TC_WITHOUT_HEAD(kcov_basic_pc);
 ATF_TC_BODY(kcov_basic_pc, tc)
+{
-	kcov_basic(KCOV_MODE_TRACE_PC);
+	kcov_basic(false, KCOV_MODE_TRACE_PC);
+}
 ATF_TC_WITHOUT_HEAD(kcov_basic_cmp);
 ATF_TC_BODY(kcov_basic_cmp, tc)
+{
 	atf_tc_skip("XXX: GCC8 needed");
-	kcov_basic(KCOV_MODE_TRACE_CMP);
+	kcov_basic(false, KCOV_MODE_TRACE_CMP);
+}
 ATF_TC_WITHOUT_HEAD(kcov_basic_dup2_pc);
 ATF_TC_BODY(kcov_basic_dup2_pc, tc)
+{
 	kcov_basic(true, KCOV_MODE_TRACE_PC);
+}
 ATF_TC_WITHOUT_HEAD(kcov_basic_dup2_cmp);
 ATF_TC_BODY(kcov_basic_dup2_cmp, tc)
+{
 	atf_tc_skip("XXX: GCC8 needed");
 	kcov_basic(true, KCOV_MODE_TRACE_CMP);
+}
 ATF_TC_WITHOUT_HEAD(kcov_multienable_on_the_same_thread);
 ATF_TC_BODY(kcov_multienable_on_the_same_thread, tc)
+{
 	kcov_int_t *buf1, *buf2;
 	int fd1, fd2;
 	int mode;
 	buf1 = common_head(&fd1);
 	buf2 = common_head(&fd2);
 	mode = KCOV_MODE_NONE;
 	ATF_REQUIRE_MSG(ioctl(fd1, KCOV_IOC_ENABLE, &mode) == 0,
 @@ -476,35 +531,38 @@ ATF_TC_BODY(kcov_multiple_threads##n, tc
+						\
 	kcov_multiple_threads(n);		\
+}
 KCOV_MULTIPLE_THREADS(2)
 KCOV_MULTIPLE_THREADS(4)
 KCOV_MULTIPLE_THREADS(8)
 KCOV_MULTIPLE_THREADS(16)
 KCOV_MULTIPLE_THREADS(32)
 ATF_TP_ADD_TCS(tp)
+{
 	ATF_TP_ADD_TC(tp, kcov_dup2);
 	ATF_TP_ADD_TC(tp, kcov_multiopen);
 	ATF_TP_ADD_TC(tp, kcov_open_close_open);
 	ATF_TP_ADD_TC(tp, kcov_bufsize);
 	ATF_TP_ADD_TC(tp, kcov_mmap);
 	ATF_TP_ADD_TC(tp, kcov_mmap_no_munmap);
 	ATF_TP_ADD_TC(tp, kcov_mmap_no_munmap_no_close);
 	ATF_TP_ADD_TC(tp, kcov_enable);
 	ATF_TP_ADD_TC(tp, kcov_enable_no_disable);
 	ATF_TP_ADD_TC(tp, kcov_enable_no_disable_no_close);
 	ATF_TP_ADD_TC(tp, kcov_mmap_enable_thread_close);
 	ATF_TP_ADD_TC(tp, kcov_basic_pc);
 	ATF_TP_ADD_TC(tp, kcov_basic_cmp);
 	ATF_TP_ADD_TC(tp, kcov_basic_dup2_pc);
 	ATF_TP_ADD_TC(tp, kcov_basic_dup2_cmp);
 	ATF_TP_ADD_TC(tp, kcov_multienable_on_the_same_thread);
 	ATF_TP_ADD_TC(tp, kcov_buffer_access_from_custom_thread);
 	ATF_TP_ADD_TC(tp, kcov_thread);
 	ATF_TP_ADD_TC(tp, kcov_multiple_threads2);
 	ATF_TP_ADD_TC(tp, kcov_multiple_threads4);
 	ATF_TP_ADD_TC(tp, kcov_multiple_threads8);
 	ATF_TP_ADD_TC(tp, kcov_multiple_threads16);
 	ATF_TP_ADD_TC(tp, kcov_multiple_threads32);
 	return atf_no_error();
+}