ok  	github.com/google/syzkaller/dashboard/app	(cached)
?   	github.com/google/syzkaller/dashboard/dashapi	[no test files]
?   	github.com/google/syzkaller/executor	[no test files]
ok  	github.com/google/syzkaller/pkg/ast	(cached)
?   	github.com/google/syzkaller/pkg/bisect	[no test files]
ok  	github.com/google/syzkaller/pkg/build	1.209s
ok  	github.com/google/syzkaller/pkg/compiler	(cached)
ok  	github.com/google/syzkaller/pkg/config	(cached)
?   	github.com/google/syzkaller/pkg/cover	[no test files]
--- FAIL: TestGenerate (4.55s)
    --- FAIL: TestGenerate/netbsd/amd64 (0.08s)
    	csource_test.go:72: seed=1566412099864264936
        --- FAIL: TestGenerate/netbsd/amd64/18 (0.18s)
        	csource_test.go:110: opts: {Threaded:true Collide:false Repeat:true RepeatTimes:0 Procs:0 Sandbox:none Fault:false FaultCall:0 FaultNth:0 Leak:false EnableTun:true EnableNetDev:false EnableNetReset:false EnableCgroups:false EnableBinfmtMisc:false EnableCloseFds:false UseTmpDir:true HandleSegv:false Repro:false Trace:false}
        		program:
        		preadv(0xffffffffffffffff, &(0x7f00000013c0)=[{&(0x7f0000000000)=""/102, 0x66}, {&(0x7f0000000080)=""/211, 0xd3}, {&(0x7f0000000180)=""/189, 0xbd}, {&(0x7f0000000240)=""/4096, 0x1000}, {&(0x7f0000001240)=""/27, 0x1b}, {&(0x7f0000001280)=""/128, 0x80}, {&(0x7f0000001300)=""/190, 0xbe}], 0x7, 0x0)
        		setsockopt$sock_int(0xffffffffffffffff, 0xffff, 0x1000, &(0x7f0000001440)=0x8, 0x4)
        		mincore(&(0x7f0000ffd000/0x3000)=nil, 0x3000, &(0x7f0000001480)=""/166)
        		r0 = socket$inet6(0x18, 0x10000000, 0x547)
        		connect$unix(0xffffffffffffffff, &(0x7f0000001540)=@abs={0x0, 0x0, 0x1}, 0x8)
        		madvise(&(0x7f0000ffe000/0x2000)=nil, 0x2000, 0x4)
        		r1 = dup2(r0, r0)
        		ftruncate(r0, 0x100)
        		getdents(r1, &(0x7f0000001580)=""/209, 0xd1)
        		getpeername$inet(r1, &(0x7f0000001680), &(0x7f00000016c0)=0xc)
        		syz_emit_ethernet(0x75, &(0x7f0000000000)="3fdb258ea0dc974313d892e0997f18f6d63f519505ca290361840a7bf02c1c925541d5606487fa7cde2520404b6a14d88d3f7501661ed05802844b805785d08959a80de737a550bb5bec7ef6fcc05b949faea6bcfe5c5e63e56880566452e0f4967a47ae37e8702f79bd2056dd0678ff7ace70a46a")
        		syz_execute_func(&(0x7f0000000080)="c4816a5f05b90000000f57bcd6090000003e6445d7f2f365470f1a2036660ff8f4c4226d07d40f94c4c4e3517f1a69f2400f1ad58fc960960a")
        		syz_extract_tcp_res(&(0x7f00000000c0), 0x5, 0xffffffffffff7fff)
        		
        	csource_test.go:111: failed to build program:
        		// autogenerated by syzkaller (https://github.com/google/syzkaller)
        		
        		#define _GNU_SOURCE 
        		
        		#include <dirent.h>
        		#include <endian.h>
        		#include <errno.h>
        		#include <fcntl.h>
        		#include <net/ethertypes.h>
        		#include <net/if.h>
        		#include <net/if_arp.h>
        		#include <net/if_tun.h>
        		#include <netinet/in.h>
        		#include <netinet/ip.h>
        		#include <netinet/ip6.h>
        		#include <netinet/tcp.h>
        		#include <pthread.h>
        		#include <pwd.h>
        		#include <signal.h>
        		#include <stdarg.h>
        		#include <stdbool.h>
        		#include <stdint.h>
        		#include <stdio.h>
        		#include <stdlib.h>
        		#include <string.h>
        		#include <sys/resource.h>
        		#include <sys/stat.h>
        		#include <sys/syscall.h>
        		#include <sys/types.h>
        		#include <sys/uio.h>
        		#include <sys/wait.h>
        		#include <time.h>
        		#include <unistd.h>
        		
        		#include <netinet/if_ether.h>
        		
        		static void kill_and_wait(int pid, int* status)
        		{
        			kill(pid, SIGKILL);
        			while (waitpid(-1, status, 0) != pid) {
        			}
        		}
        		
        		static void sleep_ms(uint64_t ms)
        		{
        			usleep(ms * 1000);
        		}
        		
        		static uint64_t current_time_ms(void)
        		{
        			struct timespec ts;
        			if (clock_gettime(CLOCK_MONOTONIC, &ts))
        			exit(1);
        			return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
        		}
        		
        		static void use_temporary_dir(void)
        		{
        			char tmpdir_template[] = "./syzkaller.XXXXXX";
        			char* tmpdir = mkdtemp(tmpdir_template);
        			if (!tmpdir)
        			exit(1);
        			if (chmod(tmpdir, 0777))
        			exit(1);
        			if (chdir(tmpdir))
        			exit(1);
        		}
        		
        		static void remove_dir(const char* dir)
        		{
        			DIR* dp;
        			struct dirent* ep;
        			dp = opendir(dir);
        			if (dp == NULL)
        			exit(1);
        			while ((ep = readdir(dp))) {
        				if (strcmp(ep->d_name, ".") == 0 || strcmp(ep->d_name, "..") == 0)
        					continue;
        				char filename[FILENAME_MAX];
        				snprintf(filename, sizeof(filename), "%s/%s", dir, ep->d_name);
        				struct stat st;
        				if (lstat(filename, &st))
        			exit(1);
        				if (S_ISDIR(st.st_mode)) {
        					remove_dir(filename);
        					continue;
        				}
        				if (unlink(filename))
        			exit(1);
        			}
        			closedir(dp);
        			if (rmdir(dir))
        			exit(1);
        		}
        		
        		static void thread_start(void* (*fn)(void*), void* arg)
        		{
        			pthread_t th;
        			pthread_attr_t attr;
        			pthread_attr_init(&attr);
        			pthread_attr_setstacksize(&attr, 128 << 10);
        			int i;
        			for (i = 0; i < 100; i++) {
        				if (pthread_create(&th, &attr, fn, arg) == 0) {
        					pthread_attr_destroy(&attr);
        					return;
        				}
        				if (errno == EAGAIN) {
        					usleep(50);
        					continue;
        				}
        				break;
        			}
        			exit(1);
        		}
        		
        		typedef struct {
        			pthread_mutex_t mu;
        			pthread_cond_t cv;
        			int state;
        		} event_t;
        		
        		static void event_init(event_t* ev)
        		{
        			if (pthread_mutex_init(&ev->mu, 0))
        			exit(1);
        			if (pthread_cond_init(&ev->cv, 0))
        			exit(1);
        			ev->state = 0;
        		}
        		
        		static void event_reset(event_t* ev)
        		{
        			ev->state = 0;
        		}
        		
        		static void event_set(event_t* ev)
        		{
        			pthread_mutex_lock(&ev->mu);
        			if (ev->state)
        			exit(1);
        			ev->state = 1;
        			pthread_mutex_unlock(&ev->mu);
        			pthread_cond_broadcast(&ev->cv);
        		}
        		
        		static void event_wait(event_t* ev)
        		{
        			pthread_mutex_lock(&ev->mu);
        			while (!ev->state)
        				pthread_cond_wait(&ev->cv, &ev->mu);
        			pthread_mutex_unlock(&ev->mu);
        		}
        		
        		static int event_isset(event_t* ev)
        		{
        			pthread_mutex_lock(&ev->mu);
        			int res = ev->state;
        			pthread_mutex_unlock(&ev->mu);
        			return res;
        		}
        		
        		static int event_timedwait(event_t* ev, uint64_t timeout)
        		{
        			uint64_t start = current_time_ms();
        			uint64_t now = start;
        			pthread_mutex_lock(&ev->mu);
        			for (;;) {
        				if (ev->state)
        					break;
        				uint64_t remain = timeout - (now - start);
        				struct timespec ts;
        				ts.tv_sec = remain / 1000;
        				ts.tv_nsec = (remain % 1000) * 1000 * 1000;
        				pthread_cond_timedwait(&ev->cv, &ev->mu, &ts);
        				now = current_time_ms();
        				if (now - start > timeout)
        					break;
        			}
        			int res = ev->state;
        			pthread_mutex_unlock(&ev->mu);
        			return res;
        		}
        		
        		static int tunfd = -1;
        		#define SYZ_TUN_MAX_PACKET_SIZE 1000
        		
        		#define MAX_TUN 64
        		
        		#define TUN_IFACE "tap%d"
        		#define TUN_DEVICE "/dev/tap%d"
        		
        		#define LOCAL_MAC "aa:aa:aa:aa:aa:aa"
        		#define REMOTE_MAC "aa:aa:aa:aa:aa:bb"
        		#define LOCAL_IPV4 "172.20.%d.170"
        		#define REMOTE_IPV4 "172.20.%d.187"
        		#define LOCAL_IPV6 "fe80::%02hxaa"
        		#define REMOTE_IPV6 "fe80::%02hxbb"
        		
        		static void vsnprintf_check(char* str, size_t size, const char* format, va_list args)
        		{
        			int rv;
        			rv = vsnprintf(str, size, format, args);
        			if (rv < 0)
        			exit(1);
        			if ((size_t)rv >= size)
        			exit(1);
        		}
        		
        		static void snprintf_check(char* str, size_t size, const char* format, ...)
        		{
        			va_list args;
        			va_start(args, format);
        			vsnprintf_check(str, size, format, args);
        			va_end(args);
        		}
        		
        		#define COMMAND_MAX_LEN 128
        		#define PATH_PREFIX "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin "
        		#define PATH_PREFIX_LEN (sizeof(PATH_PREFIX) - 1)
        		
        		static void execute_command(bool panic, const char* format, ...)
        		{
        			va_list args;
        			char command[PATH_PREFIX_LEN + COMMAND_MAX_LEN];
        			int rv;
        			va_start(args, format);
        			memcpy(command, PATH_PREFIX, PATH_PREFIX_LEN);
        			vsnprintf_check(command + PATH_PREFIX_LEN, COMMAND_MAX_LEN, format, args);
        			va_end(args);
        			rv = system(command);
        			if (rv) {
        				if (panic)
        			exit(1);
        			}
        		}
        		
        		static void initialize_tun(int tun_id)
        		{
        			if (tun_id < 0 || tun_id >= MAX_TUN) {
        			exit(1);
        			}
        			char tun_device[sizeof(TUN_DEVICE)];
        			snprintf_check(tun_device, sizeof(tun_device), TUN_DEVICE, tun_id);
        			char tun_iface[sizeof(TUN_IFACE)];
        			snprintf_check(tun_iface, sizeof(tun_iface), TUN_IFACE, tun_id);
        			execute_command(0, "ifconfig %s destroy", tun_iface);
        			execute_command(0, "ifconfig %s create", tun_iface);
        			tunfd = open(tun_device, O_RDWR | O_NONBLOCK);
        			if (tunfd == -1) {
        				printf("tun: can't open %s: errno=%d\n", tun_device, errno);
        				return;
        			}
        			const int kTunFd = 240;
        			if (dup2(tunfd, kTunFd) < 0)
        			exit(1);
        			close(tunfd);
        			tunfd = kTunFd;
        			char local_mac[sizeof(LOCAL_MAC)];
        			snprintf_check(local_mac, sizeof(local_mac), LOCAL_MAC);
        			execute_command(1, "ifconfig %s link %s", tun_iface, local_mac);
        			char local_ipv4[sizeof(LOCAL_IPV4)];
        			snprintf_check(local_ipv4, sizeof(local_ipv4), LOCAL_IPV4, tun_id);
        			execute_command(1, "ifconfig %s inet %s netmask 255.255.255.0", tun_iface, local_ipv4);
        			char remote_mac[sizeof(REMOTE_MAC)];
        			char remote_ipv4[sizeof(REMOTE_IPV4)];
        			snprintf_check(remote_mac, sizeof(remote_mac), REMOTE_MAC);
        			snprintf_check(remote_ipv4, sizeof(remote_ipv4), REMOTE_IPV4, tun_id);
        			execute_command(0, "arp -s %s %s", remote_ipv4, remote_mac);
        			char local_ipv6[sizeof(LOCAL_IPV6)];
        			snprintf_check(local_ipv6, sizeof(local_ipv6), LOCAL_IPV6, tun_id);
        			execute_command(1, "ifconfig %s inet6 %s", tun_iface, local_ipv6);
        			char remote_ipv6[sizeof(REMOTE_IPV6)];
        			snprintf_check(remote_ipv6, sizeof(remote_ipv6), REMOTE_IPV6, tun_id);
        			execute_command(0, "ndp -s %s%%%s %s", remote_ipv6, tun_iface, remote_mac);
        		}
        		
        		static long syz_emit_ethernet(volatile long a0, volatile long a1)
        		{
        			if (tunfd < 0)
        				return (uintptr_t)-1;
        			size_t length = a0;
        			const char* data = (char*)a1;
        			return write(tunfd, data, length);
        		}
        		
        		static int read_tun(char* data, int size)
        		{
        			if (tunfd < 0)
        				return -1;
        			int rv = read(tunfd, data, size);
        			if (rv < 0) {
        				if (errno == EAGAIN)
        					return -1;
        			exit(1);
        			}
        			return rv;
        		}
        		
        		struct tcp_resources {
        			uint32_t seq;
        			uint32_t ack;
        		};
        		
        		static long syz_extract_tcp_res(volatile long a0, volatile long a1, volatile long a2)
        		{
        			if (tunfd < 0)
        				return (uintptr_t)-1;
        			char data[SYZ_TUN_MAX_PACKET_SIZE];
        			int rv = read_tun(&data[0], sizeof(data));
        			if (rv == -1)
        				return (uintptr_t)-1;
        			size_t length = rv;
        			struct tcphdr* tcphdr;
        			if (length < sizeof(struct ether_header))
        				return (uintptr_t)-1;
        			struct ether_header* ethhdr = (struct ether_header*)&data[0];
        			if (ethhdr->ether_type == htons(ETHERTYPE_IP)) {
        				if (length < sizeof(struct ether_header) + sizeof(struct ip))
        					return (uintptr_t)-1;
        				struct ip* iphdr = (struct ip*)&data[sizeof(struct ether_header)];
        				if (iphdr->ip_p != IPPROTO_TCP)
        					return (uintptr_t)-1;
        				if (length < sizeof(struct ether_header) + iphdr->ip_hl * 4 + sizeof(struct tcphdr))
        					return (uintptr_t)-1;
        				tcphdr = (struct tcphdr*)&data[sizeof(struct ether_header) + iphdr->ip_hl * 4];
        			} else {
        				if (length < sizeof(struct ether_header) + sizeof(struct ip6_hdr))
        					return (uintptr_t)-1;
        				struct ip6_hdr* ipv6hdr = (struct ip6_hdr*)&data[sizeof(struct ether_header)];
        				if (ipv6hdr->ip6_nxt != IPPROTO_TCP)
        					return (uintptr_t)-1;
        				if (length < sizeof(struct ether_header) + sizeof(struct ip6_hdr) + sizeof(struct tcphdr))
        					return (uintptr_t)-1;
        				tcphdr = (struct tcphdr*)&data[sizeof(struct ether_header) + sizeof(struct ip6_hdr)];
        			}
        			struct tcp_resources* res = (struct tcp_resources*)a0;
        		res->seq = htonl((ntohl(tcphdr->th_seq) + (uint32_t)a1));
        		res->ack = htonl((ntohl(tcphdr->th_ack) + (uint32_t)a2));
        			return 0;
        		}
        		
        		static void sandbox_common()
        		{
        			if (setsid() == -1)
        			exit(1);
        			struct rlimit rlim;
        			rlim.rlim_cur = rlim.rlim_max = 8 << 20;
        			setrlimit(RLIMIT_MEMLOCK, &rlim);
        			rlim.rlim_cur = rlim.rlim_max = 1 << 20;
        			setrlimit(RLIMIT_FSIZE, &rlim);
        			rlim.rlim_cur = rlim.rlim_max = 1 << 20;
        			setrlimit(RLIMIT_STACK, &rlim);
        			rlim.rlim_cur = rlim.rlim_max = 0;
        			setrlimit(RLIMIT_CORE, &rlim);
        			rlim.rlim_cur = rlim.rlim_max = 256;
        			setrlimit(RLIMIT_NOFILE, &rlim);
        		}
        		
        		static void loop();
        		
        		static int do_sandbox_none(void)
        		{
        			sandbox_common();
        			initialize_tun(procid);
        			loop();
        			return 0;
        		}
        		
        		static long syz_execute_func(volatile long text)
        		{
        			volatile long p[8] = {0};
        			(void)p;
        			asm volatile("" ::"r"(0l), "r"(1l), "r"(2l), "r"(3l), "r"(4l), "r"(5l), "r"(6l),
        				     "r"(7l), "r"(8l), "r"(9l), "r"(10l), "r"(11l), "r"(12l), "r"(13l));
        		((void (*)(void))(text))();
        			return 0;
        		}
        		
        		struct thread_t {
        			int created, call;
        			event_t ready, done;
        		};
        		
        		static struct thread_t threads[16];
        		static void execute_call(int call);
        		static int running;
        		
        		static void* thr(void* arg)
        		{
        			struct thread_t* th = (struct thread_t*)arg;
        			for (;;) {
        				event_wait(&th->ready);
        				event_reset(&th->ready);
        				execute_call(th->call);
        				__atomic_fetch_sub(&running, 1, __ATOMIC_RELAXED);
        				event_set(&th->done);
        			}
        			return 0;
        		}
        		
        		static void execute_one(void)
        		{
        			int i, call, thread;
        			for (call = 0; call < 13; call++) {
        				for (thread = 0; thread < (int)(sizeof(threads) / sizeof(threads[0])); thread++) {
        					struct thread_t* th = &threads[thread];
        					if (!th->created) {
        						th->created = 1;
        						event_init(&th->ready);
        						event_init(&th->done);
        						event_set(&th->done);
        						thread_start(thr, th);
        					}
        					if (!event_isset(&th->done))
        						continue;
        					event_reset(&th->done);
        					th->call = call;
        					__atomic_fetch_add(&running, 1, __ATOMIC_RELAXED);
        					event_set(&th->ready);
        					event_timedwait(&th->done, 45);
        					break;
        				}
        			}
        			for (i = 0; i < 100 && __atomic_load_n(&running, __ATOMIC_RELAXED); i++)
        				sleep_ms(1);
        		}
        		
        		static void execute_one(void);
        		
        		#define WAIT_FLAGS 0
        		
        		static void loop(void)
        		{
        			int iter;
        			for (iter = 0;; iter++) {
        				char cwdbuf[32];
        				sprintf(cwdbuf, "./%d", iter);
        				if (mkdir(cwdbuf, 0777))
        			exit(1);
        				int pid = fork();
        				if (pid < 0)
        			exit(1);
        				if (pid == 0) {
        					if (chdir(cwdbuf))
        			exit(1);
        					execute_one();
        					exit(0);
        				}
        				int status = 0;
        				uint64_t start = current_time_ms();
        				for (;;) {
        					if (waitpid(-1, &status, WNOHANG | WAIT_FLAGS) == pid)
        						break;
        					sleep_ms(1);
        					if (current_time_ms() - start < 5 * 1000)
        						continue;
        					kill_and_wait(pid, &status);
        					break;
        				}
        				remove_dir(cwdbuf);
        			}
        		}
        		
        		#ifndef SYS_connect
        		#define SYS_connect 98
        		#endif
        		#ifndef SYS_dup2
        		#define SYS_dup2 90
        		#endif
        		#ifndef SYS_ftruncate
        		#define SYS_ftruncate 201
        		#endif
        		#ifndef SYS_getdents
        		#define SYS_getdents 390
        		#endif
        		#ifndef SYS_getpeername
        		#define SYS_getpeername 31
        		#endif
        		#ifndef SYS_madvise
        		#define SYS_madvise 75
        		#endif
        		#ifndef SYS_mincore
        		#define SYS_mincore 78
        		#endif
        		#ifndef SYS_mmap
        		#define SYS_mmap 197
        		#endif
        		#ifndef SYS_preadv
        		#define SYS_preadv 289
        		#endif
        		#ifndef SYS_setsockopt
        		#define SYS_setsockopt 105
        		#endif
        		#ifndef SYS_socket
        		#define SYS_socket 394
        		#endif
        		
        		uint64_t r[2] = {0xffffffffffffffff, 0xffffffffffffffff};
        		
        		void execute_call(int call)
        		{
        				intptr_t res;	switch (call) {
        			case 0:
        		*(uint64_t*)0x200013c0 = 0x20000000;
        		*(uint64_t*)0x200013c8 = 0x66;
        		*(uint64_t*)0x200013d0 = 0x20000080;
        		*(uint64_t*)0x200013d8 = 0xd3;
        		*(uint64_t*)0x200013e0 = 0x20000180;
        		*(uint64_t*)0x200013e8 = 0xbd;
        		*(uint64_t*)0x200013f0 = 0x20000240;
        		*(uint64_t*)0x200013f8 = 0x1000;
        		*(uint64_t*)0x20001400 = 0x20001240;
        		*(uint64_t*)0x20001408 = 0x1b;
        		*(uint64_t*)0x20001410 = 0x20001280;
        		*(uint64_t*)0x20001418 = 0x80;
        		*(uint64_t*)0x20001420 = 0x20001300;
        		*(uint64_t*)0x20001428 = 0xbe;
        				syscall(SYS_preadv, -1, 0x200013c0, 7, 0);
        				break;
        			case 1:
        		*(uint32_t*)0x20001440 = 8;
        				syscall(SYS_setsockopt, -1, 0xffff, 0x1000, 0x20001440, 4);
        				break;
        			case 2:
        				syscall(SYS_mincore, 0x20ffd000, 0x3000, 0x20001480);
        				break;
        			case 3:
        				res = syscall(SYS_socket, 0x18, 0x10000000, 0x47);
        				if (res != -1)
        						r[0] = res;
        				break;
        			case 4:
        		*(uint16_t*)0x20001540 = 0;
        		*(uint8_t*)0x20001542 = 0;
        		*(uint32_t*)0x20001544 = 0x4e21;
        				syscall(SYS_connect, -1, 0x20001540, 8);
        				break;
        			case 5:
        				syscall(SYS_madvise, 0x20ffe000, 0x2000, 4);
        				break;
        			case 6:
        				res = syscall(SYS_dup2, r[0], r[0]);
        				if (res != -1)
        						r[1] = res;
        				break;
        			case 7:
        				syscall(SYS_ftruncate, r[0], 0x100);
        				break;
        			case 8:
        				syscall(SYS_getdents, r[1], 0x20001580, 0xd1);
        				break;
        			case 9:
        		*(uint32_t*)0x200016c0 = 0xc;
        				syscall(SYS_getpeername, r[1], 0x20001680, 0x200016c0);
        				break;
        			case 10:
        		memcpy((void*)0x20000000, "\x3f\xdb\x25\x8e\xa0\xdc\x97\x43\x13\xd8\x92\xe0\x99\x7f\x18\xf6\xd6\x3f\x51\x95\x05\xca\x29\x03\x61\x84\x0a\x7b\xf0\x2c\x1c\x92\x55\x41\xd5\x60\x64\x87\xfa\x7c\xde\x25\x20\x40\x4b\x6a\x14\xd8\x8d\x3f\x75\x01\x66\x1e\xd0\x58\x02\x84\x4b\x80\x57\x85\xd0\x89\x59\xa8\x0d\xe7\x37\xa5\x50\xbb\x5b\xec\x7e\xf6\xfc\xc0\x5b\x94\x9f\xae\xa6\xbc\xfe\x5c\x5e\x63\xe5\x68\x80\x56\x64\x52\xe0\xf4\x96\x7a\x47\xae\x37\xe8\x70\x2f\x79\xbd\x20\x56\xdd\x06\x78\xff\x7a\xce\x70\xa4\x6a", 117);
        				syz_emit_ethernet(0x75, 0x20000000);
        				break;
        			case 11:
        		memcpy((void*)0x20000080, "\xc4\x81\x6a\x5f\x05\xb9\x00\x00\x00\x0f\x57\xbc\xd6\x09\x00\x00\x00\x3e\x64\x45\xd7\xf2\xf3\x65\x47\x0f\x1a\x20\x36\x66\x0f\xf8\xf4\xc4\x22\x6d\x07\xd4\x0f\x94\xc4\xc4\xe3\x51\x7f\x1a\x69\xf2\x40\x0f\x1a\xd5\x8f\xc9\x60\x96\x0a", 57);
        				syz_execute_func(0x20000080);
        				break;
        			case 12:
        				syz_extract_tcp_res(0x200000c0, 5, 0xffff7fff);
        				break;
        			}
        		
        		}
        		int main(void)
        		{
        				syscall(SYS_mmap, 0x20000000, 0x1000000, 3, 0x1012, -1, 0, 0);
        					use_temporary_dir();
        					do_sandbox_none();
        			return 0;
        		}
        		
        		<stdin>: In function 'do_sandbox_none':
        		<stdin>:365:17: error: 'procid' undeclared (first use in this function); did you mean 'profil'?
        		<stdin>:365:17: note: each undeclared identifier is reported only once for each function it appears in
        		
        		compiler invocation: /syzkaller/netbsd/src/../tools/bin/x86_64--netbsd-g++ [-o /tmp/syz-executor864963751 -DGOOS_netbsd=1 -DGOARCH_amd64=1 -DHOSTGOOS_linux=1 -x c - -O2 -pthread -Wall -Werror -Wparentheses -Wframe-larger-than=8192 -m64 --sysroot /syzkaller/netbsd/src/../dest/]
FAIL
FAIL	github.com/google/syzkaller/pkg/csource	12.190s
ok  	github.com/google/syzkaller/pkg/db	(cached)
ok  	github.com/google/syzkaller/pkg/email	(cached)
?   	github.com/google/syzkaller/pkg/gce	[no test files]
?   	github.com/google/syzkaller/pkg/gcs	[no test files]
?   	github.com/google/syzkaller/pkg/hash	[no test files]
ok  	github.com/google/syzkaller/pkg/host	(cached)
?   	github.com/google/syzkaller/pkg/html	[no test files]
ok  	github.com/google/syzkaller/pkg/ifuzz	(cached)
?   	github.com/google/syzkaller/pkg/ifuzz/gen	[no test files]
?   	github.com/google/syzkaller/pkg/ifuzz/generated	[no test files]
ok  	github.com/google/syzkaller/pkg/instance	0.970s
ok  	github.com/google/syzkaller/pkg/ipc	6.628s
?   	github.com/google/syzkaller/pkg/ipc/ipcconfig	[no test files]
ok  	github.com/google/syzkaller/pkg/kd	(cached)
ok  	github.com/google/syzkaller/pkg/log	(cached)
ok  	github.com/google/syzkaller/pkg/mgrconfig	(cached)
ok  	github.com/google/syzkaller/pkg/osutil	(cached)
ok  	github.com/google/syzkaller/pkg/report	3.527s
ok  	github.com/google/syzkaller/pkg/repro	1.436s
?   	github.com/google/syzkaller/pkg/rpctype	[no test files]
ok  	github.com/google/syzkaller/pkg/runtest	18.122s
ok  	github.com/google/syzkaller/pkg/serializer	(cached)
?   	github.com/google/syzkaller/pkg/signal	[no test files]
ok  	github.com/google/syzkaller/pkg/symbolizer	0.149s
ok  	github.com/google/syzkaller/pkg/vcs	1.867s
ok  	github.com/google/syzkaller/prog	(cached)
ok  	github.com/google/syzkaller/prog/test	(cached)
?   	github.com/google/syzkaller/sys	[no test files]
?   	github.com/google/syzkaller/sys/akaros	[no test files]
?   	github.com/google/syzkaller/sys/akaros/gen	[no test files]
?   	github.com/google/syzkaller/sys/freebsd	[no test files]
?   	github.com/google/syzkaller/sys/freebsd/gen	[no test files]
?   	github.com/google/syzkaller/sys/fuchsia	[no test files]
?   	github.com/google/syzkaller/sys/fuchsia/fidlgen	[no test files]
?   	github.com/google/syzkaller/sys/fuchsia/gen	[no test files]
?   	github.com/google/syzkaller/sys/fuchsia/layout	[no test files]
ok  	github.com/google/syzkaller/sys/linux	(cached)
?   	github.com/google/syzkaller/sys/linux/gen	[no test files]
?   	github.com/google/syzkaller/sys/netbsd	[no test files]
?   	github.com/google/syzkaller/sys/netbsd/gen	[no test files]
ok  	github.com/google/syzkaller/sys/openbsd	(cached)
?   	github.com/google/syzkaller/sys/openbsd/gen	[no test files]
?   	github.com/google/syzkaller/sys/syz-extract	[no test files]
?   	github.com/google/syzkaller/sys/syz-sysgen	[no test files]
?   	github.com/google/syzkaller/sys/targets	[no test files]
?   	github.com/google/syzkaller/sys/test	[no test files]
?   	github.com/google/syzkaller/sys/test/gen	[no test files]
?   	github.com/google/syzkaller/sys/trusty	[no test files]
?   	github.com/google/syzkaller/sys/trusty/gen	[no test files]
?   	github.com/google/syzkaller/sys/windows	[no test files]
?   	github.com/google/syzkaller/sys/windows/gen	[no test files]
ok  	github.com/google/syzkaller/syz-ci	1.687s
?   	github.com/google/syzkaller/syz-fuzzer	[no test files]
ok  	github.com/google/syzkaller/syz-hub	(cached)
ok  	github.com/google/syzkaller/syz-hub/state	(cached)
?   	github.com/google/syzkaller/syz-manager	[no test files]
?   	github.com/google/syzkaller/tools/syz-benchcmp	[no test files]
?   	github.com/google/syzkaller/tools/syz-bisect	[no test files]
?   	github.com/google/syzkaller/tools/syz-cover	[no test files]
?   	github.com/google/syzkaller/tools/syz-crush	[no test files]
?   	github.com/google/syzkaller/tools/syz-db	[no test files]
?   	github.com/google/syzkaller/tools/syz-env	[no test files]
?   	github.com/google/syzkaller/tools/syz-execprog	[no test files]
?   	github.com/google/syzkaller/tools/syz-fmt	[no test files]
?   	github.com/google/syzkaller/tools/syz-imagegen	[no test files]
?   	github.com/google/syzkaller/tools/syz-mutate	[no test files]
?   	github.com/google/syzkaller/tools/syz-prog2c	[no test files]
?   	github.com/google/syzkaller/tools/syz-repro	[no test files]
?   	github.com/google/syzkaller/tools/syz-runtest	[no test files]
?   	github.com/google/syzkaller/tools/syz-stress	[no test files]
?   	github.com/google/syzkaller/tools/syz-symbolize	[no test files]
?   	github.com/google/syzkaller/tools/syz-testbuild	[no test files]
?   	github.com/google/syzkaller/tools/syz-trace2syz	[no test files]
ok  	github.com/google/syzkaller/tools/syz-trace2syz/parser	(cached)
ok  	github.com/google/syzkaller/tools/syz-trace2syz/proggen	(cached)
?   	github.com/google/syzkaller/tools/syz-tty	[no test files]
?   	github.com/google/syzkaller/tools/syz-upgrade	[no test files]
?   	github.com/google/syzkaller/tools/syz-usbgen	[no test files]
ok  	github.com/google/syzkaller/vm	9.847s
?   	github.com/google/syzkaller/vm/adb	[no test files]
?   	github.com/google/syzkaller/vm/bhyve	[no test files]
?   	github.com/google/syzkaller/vm/gce	[no test files]
?   	github.com/google/syzkaller/vm/gvisor	[no test files]
?   	github.com/google/syzkaller/vm/isolated	[no test files]
?   	github.com/google/syzkaller/vm/kvm	[no test files]
?   	github.com/google/syzkaller/vm/odroid	[no test files]
?   	github.com/google/syzkaller/vm/qemu	[no test files]
ok  	github.com/google/syzkaller/vm/vmimpl	(cached)
?   	github.com/google/syzkaller/vm/vmm	[no test files]