START	lib/libc/sys	2023-12-25T06:32:41Z

==== run-t_access ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_access.c
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/atf-c.c
cc   -o t_access t_access.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_access -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_access NUMBERS="$tnumbers" regress
1..6
==== run-t_access-1 ====
1 Test access(2) for EACCES
su build -c exec ./t_access -r 1

==== cleanup-t_access-1 ====
./t_access -c 1

==== run-t_access-2 ====
2 Test access(2) for EFAULT
./t_access -r 2

==== cleanup-t_access-2 ====
./t_access -c 2

==== run-t_access-3 ====
3 Test access(2) for EINVAL
./t_access -r 3

==== cleanup-t_access-3 ====
./t_access -c 3

==== run-t_access-4 ====
4 Test access(2) for ENOTDIR
./t_access -r 4

==== cleanup-t_access-4 ====
./t_access -c 4

==== run-t_access-5 ====
5 Test access(2) for ENOENT
./t_access -r 5

==== cleanup-t_access-5 ====
./t_access -c 5

==== run-t_access-6 ====
6 Test access(2) for ENAMETOOLONG
./t_access -r 6

==== cleanup-t_access-6 ====
./t_access -c 6


==== run-t_bind ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_bind.c
cc   -o t_bind t_bind.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_bind -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_bind NUMBERS="$tnumbers" regress
1..1
==== run-t_bind-1 ====
1 Checks that binding a socket with a different address family fails
./t_bind -r 1

==== cleanup-t_bind-1 ====
./t_bind -c 1


==== run-t_chroot ====
rm -rf dir
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_chroot.c
cc   -o t_chroot t_chroot.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_chroot -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_chroot NUMBERS="$tnumbers" regress
1..3
==== run-t_chroot-1 ====
1 A basic test of chroot(2)
./t_chroot -r 1

==== cleanup-t_chroot-1 ====
./t_chroot -c 1

==== run-t_chroot-2 ====
2 Test error conditions of chroot(2)
./t_chroot -r 2

==== cleanup-t_chroot-2 ====
./t_chroot -c 2

==== run-t_chroot-3 ====
3 Test permissions with chroot(2)
su build -c exec ./t_chroot -r 3

==== cleanup-t_chroot-3 ====
./t_chroot -c 3


==== run-t_clock_gettime ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_clock_gettime.c
cc   -o t_clock_gettime t_clock_gettime.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_clock_gettime -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_clock_gettime NUMBERS="$tnumbers" regress
1..1
==== run-t_clock_gettime-1 ====
1 Checks the monotonicity of the CLOCK_REALTIME implementation
./t_clock_gettime -r 1
kern.timecounter.hardware = AMD8111
kern.timecounter.choice = i8254(0) AMD8111(2000) acpitimer0(1000)

==== cleanup-t_clock_gettime-1 ====
./t_clock_gettime -c 1


==== run-t_connect ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_connect.c
cc   -o t_connect t_connect.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_connect -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_connect NUMBERS="$tnumbers" regress
1..2
==== run-t_connect-1 ====
1 Checks that low-port allocation works
./t_connect -r 1

==== cleanup-t_connect-1 ====
./t_connect -c 1

==== run-t_connect-2 ====
2 Checks that connecting a socket with a different address family fails
./t_connect -r 2

==== cleanup-t_connect-2 ====
./t_connect -c 2


==== run-t_dup ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_dup.c
cc   -o t_dup t_dup.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_dup -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_dup NUMBERS="$tnumbers" regress
1..10
==== run-t_dup-1 ====
1 A basic test of dup2(2)
./t_dup -r 1

==== cleanup-t_dup-1 ====
./t_dup -c 1

==== run-t_dup-2 ====
2 Test error conditions of dup2(2)
./t_dup -r 2

==== cleanup-t_dup-2 ====
./t_dup -c 2

==== run-t_dup-3 ====
3 Test dup2(2) against limits
./t_dup -r 3

==== cleanup-t_dup-3 ====
./t_dup -c 3

==== run-t_dup-4 ====
4 A basic test of dup2(2)
./t_dup -r 4

==== cleanup-t_dup-4 ====
./t_dup -c 4

==== run-t_dup-5 ====
5 Test error conditions of dup3(2) (PR lib/45148)
./t_dup -r 5

==== cleanup-t_dup-5 ====
./t_dup -c 5

==== run-t_dup-6 ====
6 Test dup3(2) against limits
./t_dup -r 6

==== cleanup-t_dup-6 ====
./t_dup -c 6

==== run-t_dup-7 ====
7 A basic test of dup3(2)
./t_dup -r 7

==== cleanup-t_dup-7 ====
./t_dup -c 7

==== run-t_dup-8 ====
8 Test error conditions of dup(2)
./t_dup -r 8

==== cleanup-t_dup-8 ====
./t_dup -c 8

==== run-t_dup-9 ====
9 Test dup(2) against limits
./t_dup -r 9

==== cleanup-t_dup-9 ====
./t_dup -c 9

==== run-t_dup-10 ====
10 A basic test of dup(2)
./t_dup -r 10

==== cleanup-t_dup-10 ====
./t_dup -c 10


==== run-t_fork ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_fork.c
cc   -o t_fork t_fork.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_fork -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_fork NUMBERS="$tnumbers" regress
1..10
==== run-t_fork-1 ====
1 raise SIGKILL in a child
./t_fork -r 1

==== cleanup-t_fork-1 ====
./t_fork -c 1

==== run-t_fork-2 ====
2 raise SIGSTOP in a child
./t_fork -r 2

==== cleanup-t_fork-2 ====
./t_fork -c 2

==== run-t_fork-3 ====
# Only works with a controlling tty
DISABLED

==== cleanup-t_fork-3 ====
./t_fork -c 3

==== run-t_fork-4 ====
# Only works with a controlling tty
DISABLED

==== cleanup-t_fork-4 ====
./t_fork -c 4

==== run-t_fork-5 ====
# Only works with a controlling tty
DISABLED

==== cleanup-t_fork-5 ====
./t_fork -c 5

==== run-t_fork-6 ====
6 raise SIGABRT in a child
./t_fork -r 6

==== cleanup-t_fork-6 ====
./t_fork -c 6

==== run-t_fork-7 ====
7 raise SIGHUP in a child
./t_fork -r 7

==== cleanup-t_fork-7 ====
./t_fork -c 7

==== run-t_fork-8 ====
8 raise SIGCONT in a child
./t_fork -r 8

==== cleanup-t_fork-8 ====
./t_fork -c 8

==== run-t_fork-9 ====
9 Test nested fork in a child
./t_fork -r 9

==== cleanup-t_fork-9 ====
./t_fork -c 9

==== run-t_fork-10 ====
10 Test nested vfork in a child
./t_fork -r 10

==== cleanup-t_fork-10 ====
./t_fork -c 10


==== run-t_fsync ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_fsync.c
cc   -o t_fsync t_fsync.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_fsync -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_fsync NUMBERS="$tnumbers" regress
1..2
==== run-t_fsync-1 ====
1 Test error conditions of fsync(2) (PR kern/30)
./t_fsync -r 1

==== cleanup-t_fsync-1 ====
./t_fsync -c 1

==== run-t_fsync-2 ====
2 A basic test of fsync(2)
./t_fsync -r 2

==== cleanup-t_fsync-2 ====
./t_fsync -c 2


==== run-t_getgroups ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_getgroups.c
cc   -o t_getgroups t_getgroups.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_getgroups -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_getgroups NUMBERS="$tnumbers" regress
1..4
==== run-t_getgroups-1 ====
1 Test errors in getgroups(2)
./t_getgroups -r 1

==== cleanup-t_getgroups-1 ====
./t_getgroups -c 1

==== run-t_getgroups-2 ====
2 Test getgid(2) from getgroups(2)
./t_getgroups -r 2

==== cleanup-t_getgroups-2 ====
./t_getgroups -c 2

==== run-t_getgroups-3 ====
3 Test setgid(2) from getgroups(2)
./t_getgroups -r 3

==== cleanup-t_getgroups-3 ====
./t_getgroups -c 3

==== run-t_getgroups-4 ====
4 Test getgroups(2) with zero param
./t_getgroups -r 4

==== cleanup-t_getgroups-4 ====
./t_getgroups -c 4


==== run-t_getitimer ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_getitimer.c
cc   -o t_getitimer t_getitimer.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_getitimer -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_getitimer NUMBERS="$tnumbers" regress
1..5
==== run-t_getitimer-1 ====
1 getitimer(2) before setitimer(2)
./t_getitimer -r 1

==== cleanup-t_getitimer-1 ====
./t_getitimer -c 1

==== run-t_getitimer-2 ====
2 Test errors from getitimer(2)
./t_getitimer -r 2

==== cleanup-t_getitimer-2 ====
./t_getitimer -c 2

==== run-t_getitimer-3 ====
3 A basic test of setitimer(2)
./t_getitimer -r 3

==== cleanup-t_getitimer-3 ====
./t_getitimer -c 3

==== run-t_getitimer-4 ====
4 Test errors from setitimer(2) (PR standards/44927)
./t_getitimer -r 4

==== cleanup-t_getitimer-4 ====
./t_getitimer -c 4

==== run-t_getitimer-5 ====
5 Test old values from setitimer(2)
./t_getitimer -r 5

==== cleanup-t_getitimer-5 ====
./t_getitimer -c 5


==== run-t_getlogin ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_getlogin.c
cc   -o t_getlogin t_getlogin.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_getlogin -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_getlogin NUMBERS="$tnumbers" regress
1..5
==== run-t_getlogin-1 ====
1 Test errors from getlogin_r(2)
./t_getlogin -r 1

==== cleanup-t_getlogin-1 ====
./t_getlogin -c 1

==== run-t_getlogin-2 ====
2 getlogin(2) vs. getlogin_r(2)
./t_getlogin -r 2

==== cleanup-t_getlogin-2 ====
./t_getlogin -c 2

==== run-t_getlogin-3 ====
3 Test that setlogin(2) works
./t_getlogin -r 3

==== cleanup-t_getlogin-3 ====
./t_getlogin -c 3

==== run-t_getlogin-4 ====
4 Test errors from setlogin(2)
./t_getlogin -r 4

==== cleanup-t_getlogin-4 ====
./t_getlogin -c 4

==== run-t_getlogin-5 ====
5 Test setlogin(2) as normal user
su build -c exec ./t_getlogin -r 5

==== cleanup-t_getlogin-5 ====
./t_getlogin -c 5


==== run-t_getpid ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_getpid.c
cc   -o t_getpid t_getpid.o atf-c.o -lpthread
ulimit -c unlimited &&  ntests="`./t_getpid -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_getpid NUMBERS="$tnumbers" regress
1..2
==== run-t_getpid-1 ====
1 Test getpid(2) with processes
./t_getpid -r 1

==== cleanup-t_getpid-1 ====
./t_getpid -c 1

==== run-t_getpid-2 ====
2 Test getpid(2) with threads
./t_getpid -r 2

==== cleanup-t_getpid-2 ====
./t_getpid -c 2


==== run-t_getrusage ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_getrusage.c
cc   -o t_getrusage t_getrusage.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_getrusage -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_getrusage NUMBERS="$tnumbers" regress
1..6
==== run-t_getrusage-1 ====
1 Test error conditions
./t_getrusage -r 1

==== cleanup-t_getrusage-1 ====
./t_getrusage -c 1

==== run-t_getrusage-2 ====
2 Test signal count with getrusage(2)
./t_getrusage -r 2

==== cleanup-t_getrusage-2 ====
./t_getrusage -c 2

==== run-t_getrusage-3 ====
3 Test maxrss growing with getrusage(2)
./t_getrusage -r 3

==== cleanup-t_getrusage-3 ====
./t_getrusage -c 3

==== run-t_getrusage-4 ====
4 Test send growing with getrusage(2)
./t_getrusage -r 4

==== cleanup-t_getrusage-4 ====
./t_getrusage -c 4

==== run-t_getrusage-5 ====
5 Test bogus values from getrusage(2)
./t_getrusage -r 5

==== cleanup-t_getrusage-5 ====
./t_getrusage -c 5

==== run-t_getrusage-6 ====
6 Test zero utime from getrusage(2)
./t_getrusage -r 6

==== cleanup-t_getrusage-6 ====
./t_getrusage -c 6


==== run-t_getsid ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_getsid.c
cc   -o t_getsid t_getsid.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_getsid -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_getsid NUMBERS="$tnumbers" regress
1..3
==== run-t_getsid-1 ====
1 Test getsid(0)
./t_getsid -r 1

==== cleanup-t_getsid-1 ====
./t_getsid -c 1

==== run-t_getsid-2 ====
2 Test error conditions in getsid(2)
./t_getsid -r 2

==== cleanup-t_getsid-2 ====
./t_getsid -c 2

==== run-t_getsid-3 ====
3 Test getsid(2) with processes
./t_getsid -r 3

==== cleanup-t_getsid-3 ====
./t_getsid -c 3


==== run-t_getsockname ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_getsockname.c
cc   -o t_getsockname t_getsockname.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_getsockname -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_getsockname NUMBERS="$tnumbers" regress
1..1
==== run-t_getsockname-1 ====
1 Checks getsockname with UNIX domain
./t_getsockname -r 1

==== cleanup-t_getsockname-1 ====
./t_getsockname -c 1


==== run-t_gettimeofday ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_gettimeofday.c
cc   -o t_gettimeofday t_gettimeofday.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_gettimeofday -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_gettimeofday NUMBERS="$tnumbers" regress
1..2
==== run-t_gettimeofday-1 ====
1 Test errors from gettimeofday(2)
./t_gettimeofday -r 1

==== cleanup-t_gettimeofday-1 ====
./t_gettimeofday -c 1

==== run-t_gettimeofday-2 ====
2 Test monotonicity of gettimeofday(2)
./t_gettimeofday -r 2

==== cleanup-t_gettimeofday-2 ====
./t_gettimeofday -c 2


==== run-t_kevent ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_kevent.c
cc   -o t_kevent t_kevent.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_kevent -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_kevent NUMBERS="$tnumbers" regress
1..2
==== run-t_kevent-1 ====
1 Checks that kevent with a 0 timer does not crash the system (PR lib/45618)
./t_kevent -r 1

==== cleanup-t_kevent-1 ====
./t_kevent -c 1

==== run-t_kevent-2 ====
2 Checks that passing a kqueue to another process does not crash the kernel (PR 46463)
./t_kevent -r 2
parent (pid 6912): sending kq fd 3

==== cleanup-t_kevent-2 ====
./t_kevent -c 2


==== run-t_kill ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_kill.c
cc   -o t_kill t_kill.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_kill -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_kill NUMBERS="$tnumbers" regress
1..5
==== run-t_kill-1 ====
1 Test that kill(2) works
./t_kill -r 1

==== cleanup-t_kill-1 ====
./t_kill -c 1

==== run-t_kill-2 ====
2 Test error conditions of kill(2)
./t_kill -r 2

==== cleanup-t_kill-2 ====
./t_kill -c 2

==== run-t_kill-3 ====
3 Test kill(2) permissions
./t_kill -r 3

==== cleanup-t_kill-3 ====
./t_kill -c 3

==== run-t_kill-4 ====
4 Test kill(2) with process group, #2
./t_kill -r 4

==== cleanup-t_kill-4 ====
./t_kill -c 4

==== run-t_kill-5 ====
5 Test kill(2) with process group, #1
./t_kill -r 5

==== cleanup-t_kill-5 ====
./t_kill -c 5


==== run-t_link ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_link.c
cc   -o t_link t_link.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_link -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_link NUMBERS="$tnumbers" regress
1..4
==== run-t_link-1 ====
1 link(2) counts are incremented?
./t_link -r 1

==== cleanup-t_link-1 ====
./t_link -c 1

==== run-t_link-2 ====
2 Test error conditions of link(2)
./t_link -r 2

==== cleanup-t_link-2 ====
./t_link -c 2

==== run-t_link-3 ====
3 Test permissions with link(2)
su build -c exec ./t_link -r 3

==== cleanup-t_link-3 ====
./t_link -c 3

==== run-t_link-4 ====
4 Check stat(2) of a linked file
./t_link -r 4

==== cleanup-t_link-4 ====
./t_link -c 4


==== run-t_listen ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_listen.c
cc   -o t_listen t_listen.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_listen -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_listen NUMBERS="$tnumbers" regress
1..2
==== run-t_listen-1 ====
1 Checks errors from listen(2) (PR standards/46150)
./t_listen -r 1

==== cleanup-t_listen-1 ====
./t_listen -c 1

==== run-t_listen-2 ====
2 Does low-port allocation work?
./t_listen -r 2

==== cleanup-t_listen-2 ====
./t_listen -c 2


==== run-t_minherit ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_minherit.c
cc   -o t_minherit t_minherit.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_minherit -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_minherit NUMBERS="$tnumbers" regress
1..5
==== run-t_minherit-1 ====
1 Test for MAP_INHERIT_COPY from minherit(2)
./t_minherit -r 1

==== cleanup-t_minherit-1 ====
./t_minherit -c 1

==== run-t_minherit-2 ====
2 Test for MAP_INHERIT_SHARE from minherit(2)
./t_minherit -r 2

==== cleanup-t_minherit-2 ====
./t_minherit -c 2

==== run-t_minherit-3 ====
3 Test for MAP_INHERIT_NONE from minherit(2)
./t_minherit -r 3

==== cleanup-t_minherit-3 ====
./t_minherit -c 3

==== run-t_minherit-4 ====
4 Test for MAP_INHERIT_ZERO from minherit(2)
./t_minherit -r 4

==== cleanup-t_minherit-4 ====
./t_minherit -c 4

==== run-t_minherit-5 ====
5 Test for bad minherit(2)
./t_minherit -r 5

==== cleanup-t_minherit-5 ====
./t_minherit -c 5


==== run-t_mkdir ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_mkdir.c
cc   -o t_mkdir t_mkdir.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_mkdir -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_mkdir NUMBERS="$tnumbers" regress
1..4
==== run-t_mkdir-1 ====
1 Checks errors from mkdir(2)
./t_mkdir -r 1

==== cleanup-t_mkdir-1 ====
./t_mkdir -c 1

==== run-t_mkdir-2 ====
2 Checks permissions with mkdir(2)
su build -c exec ./t_mkdir -r 2

==== cleanup-t_mkdir-2 ====
./t_mkdir -c 2

==== run-t_mkdir-3 ====
3 Test that UIDs and GIDs are right for a directory created with mkdir(2)
./t_mkdir -r 3

==== cleanup-t_mkdir-3 ====
./t_mkdir -c 3

==== run-t_mkdir-4 ====
4 Checks mkdir(2) for trailing slashes
./t_mkdir -r 4
Checking "dir1/"
Checking "dir2//"

==== cleanup-t_mkdir-4 ====
./t_mkdir -c 4


==== run-t_mkfifo ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_mkfifo.c
cc   -o t_mkfifo t_mkfifo.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_mkfifo -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_mkfifo NUMBERS="$tnumbers" regress
1..6
==== run-t_mkfifo-1 ====
1 Test that FIFOs block
./t_mkfifo -r 1

==== cleanup-t_mkfifo-1 ====
./t_mkfifo -c 1

==== run-t_mkfifo-2 ====
2 Test erros from mkfifo(2)
./t_mkfifo -r 2

==== cleanup-t_mkfifo-2 ====
./t_mkfifo -c 2

==== run-t_mkfifo-3 ====
3 Test O_NONBLOCK with FIFOs
./t_mkfifo -r 3

==== cleanup-t_mkfifo-3 ====
./t_mkfifo -c 3

==== run-t_mkfifo-4 ====
4 Test permissions with mkfifo(2)
su build -c exec ./t_mkfifo -r 4

==== cleanup-t_mkfifo-4 ====
./t_mkfifo -c 4

==== run-t_mkfifo-5 ====
5 Test mkfifo(2) with stat
./t_mkfifo -r 5

==== cleanup-t_mkfifo-5 ====
./t_mkfifo -c 5

==== run-t_mkfifo-6 ====
6 Test mknod(2) with S_IFIFO
./t_mkfifo -r 6

==== cleanup-t_mkfifo-6 ====
./t_mkfifo -c 6


==== run-t_mknod ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_mknod.c
cc   -o t_mknod t_mknod.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_mknod -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_mknod NUMBERS="$tnumbers" regress
1..4
==== run-t_mknod-1 ====
1 Test error conditions of mknod(2) (PR kern/45111)
./t_mknod -r 1

==== cleanup-t_mknod-1 ====
./t_mknod -c 1

==== run-t_mknod-2 ====
2 Test EEXIST from mknod(2)
./t_mknod -r 2

==== cleanup-t_mknod-2 ====
./t_mknod -c 2

==== run-t_mknod-3 ====
3 Test permissions of mknod(2)
su build -c exec ./t_mknod -r 3

==== cleanup-t_mknod-3 ====
./t_mknod -c 3

==== run-t_mknod-4 ====
4 A basic test of mknod(2)
./t_mknod -r 4

==== cleanup-t_mknod-4 ====
./t_mknod -c 4


==== run-t_mlock ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_mlock.c
cc   -o t_mlock t_mlock.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_mlock -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_mlock NUMBERS="$tnumbers" regress
1..5
==== run-t_mlock-1 ====
1 Test with mlock(2) that UVM only clips if the clip address is within the entry (PR kern/44788)
./t_mlock -r 1
mlock_clip: buf = 0x399b90c3000 (page=4096)

==== cleanup-t_mlock-1 ====
./t_mlock -c 1

==== run-t_mlock-2 ====
2 Test error conditions in mlock(2) and munlock(2)
./t_mlock -r 2
mlock_err: buf = 0xafd8979a000 (page=4096)
testing with (hopefully) invalid pointer 0xafab008a000

==== cleanup-t_mlock-2 ====
./t_mlock -c 2

==== run-t_mlock-3 ====
3 Test system limits with mlock(2)
./t_mlock -r 3
mlock_limits: buf = 0x903692dd000 (page=4096)
trying to lock 4096 bytes with 4095 byte limit
trying to lock 3996 bytes with 3995 byte limit
trying to lock 3896 bytes with 3895 byte limit
trying to lock 3796 bytes with 3795 byte limit
trying to lock 3696 bytes with 3695 byte limit
trying to lock 3596 bytes with 3595 byte limit
trying to lock 3496 bytes with 3495 byte limit
trying to lock 3396 bytes with 3395 byte limit
trying to lock 3296 bytes with 3295 byte limit
trying to lock 3196 bytes with 3195 byte limit
trying to lock 3096 bytes with 3095 byte limit
trying to lock 2996 bytes with 2995 byte limit
trying to lock 2896 bytes with 2895 byte limit
trying to lock 2796 bytes with 2795 byte limit
trying to lock 2696 bytes with 2695 byte limit
trying to lock 2596 bytes with 2595 byte limit
trying to lock 2496 bytes with 2495 byte limit
trying to lock 2396 bytes with 2395 byte limit
trying to lock 2296 bytes with 2295 byte limit
trying to lock 2196 bytes with 2195 byte limit
trying to lock 2096 bytes with 2095 byte limit
trying to lock 1996 bytes with 1995 byte limit
trying to lock 1896 bytes with 1895 byte limit
trying to lock 1796 bytes with 1795 byte limit
trying to lock 1696 bytes with 1695 byte limit
trying to lock 1596 bytes with 1595 byte limit
trying to lock 1496 bytes with 1495 byte limit
trying to lock 1396 bytes with 1395 byte limit
trying to lock 1296 bytes with 1295 byte limit
trying to lock 1196 bytes with 1195 byte limit
trying to lock 1096 bytes with 1095 byte limit
trying to lock 996 bytes with 995 byte limit
trying to lock 896 bytes with 895 byte limit
trying to lock 796 bytes with 795 byte limit
trying to lock 696 bytes with 695 byte limit
trying to lock 596 bytes with 595 byte limit
trying to lock 496 bytes with 495 byte limit
trying to lock 396 bytes with 395 byte limit
trying to lock 296 bytes with 295 byte limit
trying to lock 196 bytes with 195 byte limit
trying to lock 96 bytes with 95 byte limit

==== cleanup-t_mlock-3 ====
./t_mlock -c 3

==== run-t_mlock-4 ====
4 Test mlock(2)-mmap(2) interaction
./t_mlock -r 4
mlock_mmap: buf=0x9e85e8e7000, page=4096
mlock_mmap: first test succeeded

/usr/src/regress/lib/libc/sys/t_mlock.c:276: 'mlock(buf, page) != 0' evaluated to false
*** Error 1 in . (Makefile:140 'run-t_mlock-4')
EXPECTED_FAIL

==== cleanup-t_mlock-4 ====
./t_mlock -c 4

==== run-t_mlock-5 ====
5 Test that consecutive mlock(2) calls succeed
./t_mlock -r 5
mlock_nested: buf = 0xe6f6e5f1000 (page=4096)

==== cleanup-t_mlock-5 ====
./t_mlock -c 5


==== run-t_mmap ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_mmap.c
cc   -o t_mmap t_mmap.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_mmap -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_mmap NUMBERS="$tnumbers" regress
1..8
==== run-t_mmap-1 ====
1 Test mmap(2) with a block device
./t_mmap -r 1
trying: /dev/cd0c
/dev/cd0c: No medium found
trying: /dev/sd0c
using /dev/sd0c
first byte ffffffea
first byte ffffffea

==== cleanup-t_mmap-1 ====
./t_mmap -c 1

==== run-t_mmap-2 ====
2 Test error conditions of mmap(2)
./t_mmap -r 2

==== cleanup-t_mmap-2 ====
./t_mmap -c 2

==== run-t_mmap-3 ====
3 Test uvm page loanout with mmap(2)
./t_mmap -r 3

==== cleanup-t_mmap-3 ====
./t_mmap -c 3

==== run-t_mmap-4 ====
4 Test mmap(2) protections, #1
./t_mmap -r 4

==== cleanup-t_mmap-4 ====
./t_mmap -c 4

==== run-t_mmap-5 ====
5 Test mmap(2) protections, #2
./t_mmap -r 5

==== cleanup-t_mmap-5 ====
./t_mmap -c 5

==== run-t_mmap-6 ====
6 Test mmap(2) protections, #3
./t_mmap -r 6

==== cleanup-t_mmap-6 ====
./t_mmap -c 6

==== run-t_mmap-7 ====
7 Test mmap(2) and ftruncate(2)
./t_mmap -r 7

==== cleanup-t_mmap-7 ====
./t_mmap -c 7

==== run-t_mmap-8 ====
8 Test mmap(2) ftruncate(2) causing signal
./t_mmap -r 8

==== cleanup-t_mmap-8 ====
./t_mmap -c 8


==== run-t_msgctl ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_msgctl.c
cc   -o t_msgctl t_msgctl.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_msgctl -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_msgctl NUMBERS="$tnumbers" regress
1..5
==== run-t_msgctl-1 ====
1 Test errors from msgctl(2)
./t_msgctl -r 1

==== cleanup-t_msgctl-1 ====
./t_msgctl -c 1

==== run-t_msgctl-2 ====
2 Test permissions with msgctl(2)
./t_msgctl -r 2

==== cleanup-t_msgctl-2 ====
./t_msgctl -c 2

==== run-t_msgctl-3 ====
3 Test that PIDs are updated
./t_msgctl -r 3

==== cleanup-t_msgctl-3 ====
./t_msgctl -c 3

==== run-t_msgctl-4 ====
4 Test msgctl(2) with IPC_SET
./t_msgctl -r 4

==== cleanup-t_msgctl-4 ====
./t_msgctl -c 4

==== run-t_msgctl-5 ====
5 Test that access times are updated
./t_msgctl -r 5

==== cleanup-t_msgctl-5 ====
./t_msgctl -c 5


==== run-t_msgget ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_msgget.c
cc   -o t_msgget t_msgget.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_msgget -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_msgget NUMBERS="$tnumbers" regress
1..4
==== run-t_msgget-1 ====
1 Test msgget(2) with IPC_EXCL
./t_msgget -r 1

==== cleanup-t_msgget-1 ====
./t_msgget -c 1

==== run-t_msgget-2 ====
2 Test that XSI message queues are not removed when the process exits
./t_msgget -r 2

==== cleanup-t_msgget-2 ====
./t_msgget -c 2

==== run-t_msgget-3 ====
3 Test that msgget(2) initializes data structures properly
./t_msgget -r 3

==== cleanup-t_msgget-3 ====
./t_msgget -c 3

==== run-t_msgget-4 ====
4 Test different modes with msgget(2)
./t_msgget -r 4
testing mode 448
testing mode 256
testing mode 128
testing mode 64
testing mode 56
testing mode 32
testing mode 16
testing mode 8
testing mode 7
testing mode 4
testing mode 2
testing mode 1

==== cleanup-t_msgget-4 ====
./t_msgget -c 4


==== run-t_msgrcv ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_msgrcv.c
cc   -o t_msgrcv t_msgrcv.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_msgrcv -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_msgrcv NUMBERS="$tnumbers" regress
1..6
==== run-t_msgrcv-1 ====
1 A basic test of msgrcv(2)
./t_msgrcv -r 1

==== cleanup-t_msgrcv-1 ====
./t_msgrcv -c 1

==== run-t_msgrcv-2 ====
2 Test that msgrcv(2) blocks
./t_msgrcv -r 2

==== cleanup-t_msgrcv-2 ====
./t_msgrcv -c 2

==== run-t_msgrcv-3 ====
3 Test errors from msgrcv(2)
./t_msgrcv -r 3

/usr/src/regress/lib/libc/sys/t_msgrcv.c:192: 'msgrcv(id, &r, 3 - 1, 0x41, 004000) == -1' evaluated to false
*** Error 1 in . (Makefile:140 'run-t_msgrcv-3')
EXPECTED_FAIL

==== cleanup-t_msgrcv-3 ====
./t_msgrcv -c 3

==== run-t_msgrcv-4 ====
4 Test message types with msgrcv(2)
./t_msgrcv -r 4

==== cleanup-t_msgrcv-4 ====
./t_msgrcv -c 4

==== run-t_msgrcv-5 ====
5 Test msgrcv(2) with IPC_NOWAIT
./t_msgrcv -r 5

==== cleanup-t_msgrcv-5 ====
./t_msgrcv -c 5

==== run-t_msgrcv-6 ====
6 Test msgrcv(2) with MSG_NOERROR
./t_msgrcv -r 6

==== cleanup-t_msgrcv-6 ====
./t_msgrcv -c 6


==== run-t_msgsnd ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_msgsnd.c
cc   -o t_msgsnd t_msgsnd.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_msgsnd -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_msgsnd NUMBERS="$tnumbers" regress
1..5
==== run-t_msgsnd-1 ====
1 Test that msgsnd(2) blocks
./t_msgsnd -r 1

==== cleanup-t_msgsnd-1 ====
./t_msgsnd -c 1

==== run-t_msgsnd-2 ====
2 Test that msgsnd(2) increments the amount of message in the queue, as given by msgctl(2)
./t_msgsnd -r 2

==== cleanup-t_msgsnd-2 ====
./t_msgsnd -c 2

==== run-t_msgsnd-3 ====
3 Test errors from msgsnd(2)
./t_msgsnd -r 3

==== cleanup-t_msgsnd-3 ====
./t_msgsnd -c 3

==== run-t_msgsnd-4 ====
4 Test msgsnd(2) with IPC_NOWAIT
./t_msgsnd -r 4

==== cleanup-t_msgsnd-4 ====
./t_msgsnd -c 4

==== run-t_msgsnd-5 ====
5 Test permissions with msgsnd(2)
./t_msgsnd -r 5

==== cleanup-t_msgsnd-5 ====
./t_msgsnd -c 5


==== run-t_msync ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_msync.c
cc   -o t_msync t_msync.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_msync -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_msync NUMBERS="$tnumbers" regress
1..4
==== run-t_msync-1 ====
1 Test of msync(2), MS_ASYNC
./t_msync -r 1

==== cleanup-t_msync-1 ====
./t_msync -c 1

==== run-t_msync-2 ====
2 Test error conditions in msync(2)
./t_msync -r 2

==== cleanup-t_msync-2 ====
./t_msync -c 2

==== run-t_msync-3 ====
3 Test of msync(2), MS_INVALIDATE
./t_msync -r 3

==== cleanup-t_msync-3 ====
./t_msync -c 3

==== run-t_msync-4 ====
4 Test of msync(2), MS_SYNC
./t_msync -r 4

==== cleanup-t_msync-4 ====
./t_msync -c 4


==== run-t_pipe ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_pipe.c
cc   -o t_pipe t_pipe.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_pipe -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_pipe NUMBERS="$tnumbers" regress
1..1
==== run-t_pipe-1 ====
1 Checks that writing to pipe works correctly after being interrupted and restarted (PR kern/14087)
./t_pipe -r 1
Read:     0x200000
Expected: 0x200000

==== cleanup-t_pipe-1 ====
./t_pipe -c 1


==== run-t_pipe2 ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_pipe2.c
cc   -o t_pipe2 t_pipe2.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_pipe2 -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_pipe2 NUMBERS="$tnumbers" regress
1..5
==== run-t_pipe2-1 ====
1 A basic test of pipe2(2)
./t_pipe2 -r 1

==== cleanup-t_pipe2-1 ====
./t_pipe2 -c 1

==== run-t_pipe2-2 ====
2 Test that consuming file descriptors with pipe2(2) does not crash the system (PR kern/46457)
./t_pipe2 -r 2

==== cleanup-t_pipe2-2 ====
./t_pipe2 -c 2

==== run-t_pipe2-3 ====
3 A non-blocking test of pipe2(2)
./t_pipe2 -r 3

==== cleanup-t_pipe2-3 ====
./t_pipe2 -c 3

==== run-t_pipe2-4 ====
4 A close-on-exec test of pipe2(2)
./t_pipe2 -r 4

==== cleanup-t_pipe2-4 ====
./t_pipe2 -c 4

==== run-t_pipe2-5 ====
5 A error check of pipe2(2)
./t_pipe2 -r 5

==== cleanup-t_pipe2-5 ====
./t_pipe2 -c 5


==== run-t_poll ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_poll.c
cc   -o t_poll t_poll.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_poll -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_poll NUMBERS="$tnumbers" regress
1..3
==== run-t_poll-1 ====
1 Check for 3-way collision for descriptor. First child comes and polls on descriptor, second child comes and polls, first child times out and exits, third child comes and polls. When the wakeup event happens, the two remaining children should both be awaken. (kern/17517)
./t_poll -r 1
parent write
parent terminated

==== cleanup-t_poll-1 ====
./t_poll -c 1

==== run-t_poll-2 ====
2 Basis functionality test for poll(2)
./t_poll -r 2

==== cleanup-t_poll-2 ====
./t_poll -c 2

==== run-t_poll-3 ====
3 Check errors from poll(2)
./t_poll -r 3

==== cleanup-t_poll-3 ====
./t_poll -c 3


==== run-t_ppoll ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_ppoll.c
In file included from /usr/src/regress/lib/libc/sys/t_ppoll.c:34:
/usr/src/regress/lib/libc/sys/t_pollts.c:82:25: warning: unsequenced modification and access to 'ret' [-Wunsequenced]
        ATF_REQUIRE_EQ_MSG(ret = POLLTS(&pfds[0], 1, &timeout, NULL), 0,
                               ^
/usr/src/regress/lib/libc/sys/atf-c.h:90:11: note: expanded from macro 'ATF_REQUIRE_EQ_MSG'
        atf_req((a) == (b), -1, fmt, ##__VA_ARGS__)
                 ^                     ~~~~~~~~~~~
/usr/src/regress/lib/libc/sys/atf-c.h:84:14: note: expanded from macro 'atf_req'
        atf_require(exp, err, #exp, __FILE__, __LINE__, msg, ##__VA_ARGS__)
                    ^                                          ~~~~~~~~~~~
In file included from /usr/src/regress/lib/libc/sys/t_ppoll.c:34:
/usr/src/regress/lib/libc/sys/t_pollts.c:90:25: warning: unsequenced modification and access to 'ret' [-Wunsequenced]
        ATF_REQUIRE_EQ_MSG(ret = POLLTS(&pfds[1], 1, &timeout, NULL), 1,
                               ^
/usr/src/regress/lib/libc/sys/atf-c.h:90:11: note: expanded from macro 'ATF_REQUIRE_EQ_MSG'
        atf_req((a) == (b), -1, fmt, ##__VA_ARGS__)
                 ^                     ~~~~~~~~~~~
/usr/src/regress/lib/libc/sys/atf-c.h:84:14: note: expanded from macro 'atf_req'
        atf_require(exp, err, #exp, __FILE__, __LINE__, msg, ##__VA_ARGS__)
                    ^                                          ~~~~~~~~~~~
In file included from /usr/src/regress/lib/libc/sys/t_ppoll.c:34:
/usr/src/regress/lib/libc/sys/t_pollts.c:99:25: warning: unsequenced modification and access to 'ret' [-Wunsequenced]
        ATF_REQUIRE_EQ_MSG(ret = POLLTS(pfds, 2, &timeout, NULL), 1,
                               ^
/usr/src/regress/lib/libc/sys/atf-c.h:90:11: note: expanded from macro 'ATF_REQUIRE_EQ_MSG'
        atf_req((a) == (b), -1, fmt, ##__VA_ARGS__)
                 ^                     ~~~~~~~~~~~
/usr/src/regress/lib/libc/sys/atf-c.h:84:14: note: expanded from macro 'atf_req'
        atf_require(exp, err, #exp, __FILE__, __LINE__, msg, ##__VA_ARGS__)
                    ^                                          ~~~~~~~~~~~
In file included from /usr/src/regress/lib/libc/sys/t_ppoll.c:34:
/usr/src/regress/lib/libc/sys/t_pollts.c:111:25: warning: unsequenced modification and access to 'ret' [-Wunsequenced]
        ATF_REQUIRE_EQ_MSG(ret = POLLTS(pfds, 2, &timeout, NULL), 2,
                               ^
/usr/src/regress/lib/libc/sys/atf-c.h:90:11: note: expanded from macro 'ATF_REQUIRE_EQ_MSG'
        atf_req((a) == (b), -1, fmt, ##__VA_ARGS__)
                 ^                     ~~~~~~~~~~~
/usr/src/regress/lib/libc/sys/atf-c.h:84:14: note: expanded from macro 'atf_req'
        atf_require(exp, err, #exp, __FILE__, __LINE__, msg, ##__VA_ARGS__)
                    ^                                          ~~~~~~~~~~~
In file included from /usr/src/regress/lib/libc/sys/t_ppoll.c:34:
/usr/src/regress/lib/libc/sys/t_pollts.c:184:25: warning: unsequenced modification and access to 'ret' [-Wunsequenced]
        ATF_REQUIRE_EQ_MSG(ret = POLLTS(&pfd, 1, &timeout, &mask), 1,
                               ^
/usr/src/regress/lib/libc/sys/atf-c.h:90:11: note: expanded from macro 'ATF_REQUIRE_EQ_MSG'
        atf_req((a) == (b), -1, fmt, ##__VA_ARGS__)
                 ^                     ~~~~~~~~~~~
/usr/src/regress/lib/libc/sys/atf-c.h:84:14: note: expanded from macro 'atf_req'
        atf_require(exp, err, #exp, __FILE__, __LINE__, msg, ##__VA_ARGS__)
                    ^                                          ~~~~~~~~~~~
5 warnings generated.
cc   -o t_ppoll t_ppoll.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_ppoll -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_ppoll NUMBERS="$tnumbers" regress
1..3
==== run-t_ppoll-1 ====
1 Basis functionality test for ppoll(2)/pollts(2)
./t_ppoll -r 1

==== cleanup-t_ppoll-1 ====
./t_ppoll -c 1

==== run-t_ppoll-2 ====
2 Check errors from ppoll(2)/pollts(2)
./t_ppoll -r 2

==== cleanup-t_ppoll-2 ====
./t_ppoll -c 2

==== run-t_ppoll-3 ====
3 Check that ppoll(2)/pollts(2) restores the signal mask (PR kern/44986)
./t_ppoll -r 3

==== cleanup-t_ppoll-3 ====
./t_ppoll -c 3


==== run-t_ptrace ====
rm -rf dir
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_ptrace.c
cc   -o t_ptrace t_ptrace.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_ptrace -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_ptrace NUMBERS="$tnumbers" regress
1..6
==== run-t_ptrace-1 ====
1 Assert that a debugger cannot attach to PID 0
./t_ptrace -r 1

==== cleanup-t_ptrace-1 ====
./t_ptrace -c 1

==== run-t_ptrace-2 ====
2 Assert that a debugger cannot attach to PID 1 (as non-root)
su build -c exec ./t_ptrace -r 2

==== cleanup-t_ptrace-2 ====
./t_ptrace -c 2

==== run-t_ptrace-3 ====
3 Assert that a debugger cannot attach to PID 1 with securelevel >= 0 (as root)
./t_ptrace -r 3

==== cleanup-t_ptrace-3 ====
./t_ptrace -c 3

==== run-t_ptrace-4 ====
4 Assert that a debugger cannot attach to self (as it's nonsense)
./t_ptrace -r 4

==== cleanup-t_ptrace-4 ====
./t_ptrace -c 4

==== run-t_ptrace-5 ====
5 Assert that a debugger cannot trace another process unless the process's root directory is at or below the tracing process's root
./t_ptrace -r 5
Waiting for chrooting of the child PID 75310
Child is ready, it will try to PT_ATTACH to parent
fds_fromparent is no longer needed - close it
fds_toparent is no longer needed - close it

==== cleanup-t_ptrace-5 ====
./t_ptrace -c 5

==== run-t_ptrace-6 ====
6 Assert that a process cannot mark its parent a debugger twice
./t_ptrace -r 6
Mark the parent process (PID 68540) a debugger of PID 35317
Mark the parent process (PID 68540) a debugger of PID 35317 again

==== cleanup-t_ptrace-6 ====
./t_ptrace -c 6


==== run-t_recvmmsg ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_recvmmsg.c
cc   -o t_recvmmsg t_recvmmsg.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_recvmmsg -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_recvmmsg NUMBERS="$tnumbers" regress
1..1
==== run-t_recvmmsg-1 ====
1 A basic test of recvmmsg(2)
./t_recvmmsg -r 1

==== cleanup-t_recvmmsg-1 ====
./t_recvmmsg -c 1


==== run-t_revoke ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_revoke.c
cc   -o t_revoke t_revoke.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_revoke -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_revoke NUMBERS="$tnumbers" regress
1..1
==== run-t_revoke-1 ====
1 Test errors from revoke(2)
su build -c exec ./t_revoke -r 1

==== cleanup-t_revoke-1 ====
./t_revoke -c 1


==== run-t_select ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_select.c
cc   -o t_select t_select.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_select -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_select NUMBERS="$tnumbers" regress
1..2
==== run-t_select-1 ====
1 Checks pselect's temporary mask setting when a signal is received (PR lib/43625)
./t_select -r 1

==== cleanup-t_select-1 ====
./t_select -c 1

==== run-t_select-2 ====
2 Checks pselect's temporary mask setting when a timeout occurs
./t_select -r 2

==== cleanup-t_select-2 ====
./t_select -c 2


==== run-t_sendmmsg ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_sendmmsg.c
cc   -o t_sendmmsg t_sendmmsg.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_sendmmsg -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_sendmmsg NUMBERS="$tnumbers" regress
1..1
==== run-t_sendmmsg-1 ====
1 A basic test of sendmmsg(2)
./t_sendmmsg -r 1

==== cleanup-t_sendmmsg-1 ====
./t_sendmmsg -c 1


==== run-t_sendrecv ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_sendrecv.c
cc   -o t_sendrecv t_sendrecv.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_sendrecv -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_sendrecv NUMBERS="$tnumbers" regress
1..2
==== run-t_sendrecv-1 ====
1 A basic test of send/recv(2)
./t_sendrecv -r 1

==== cleanup-t_sendrecv-1 ====
./t_sendrecv -c 1

==== run-t_sendrecv-2 ====
2 Test send/recv(2) with receiver error
./t_sendrecv -r 2

==== cleanup-t_sendrecv-2 ====
./t_sendrecv -c 2


==== run-t_setrlimit ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_setrlimit.c
cc   -o t_setrlimit t_setrlimit.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_setrlimit -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_setrlimit NUMBERS="$tnumbers" regress
1..10
==== run-t_setrlimit-1 ====
1 A basic soft limit test
./t_setrlimit -r 1

==== cleanup-t_setrlimit-1 ====
./t_setrlimit -c 1

==== run-t_setrlimit-2 ====
2 setrlimit(3) with current limits
./t_setrlimit -r 2

==== cleanup-t_setrlimit-2 ====
./t_setrlimit -c 2

==== run-t_setrlimit-3 ====
3 Test error conditions
./t_setrlimit -r 3

==== cleanup-t_setrlimit-3 ====
./t_setrlimit -c 3

==== run-t_setrlimit-4 ====
4 Test setrlimit(2), RLIMIT_FSIZE
./t_setrlimit -r 4

==== cleanup-t_setrlimit-4 ====
./t_setrlimit -c 4

==== run-t_setrlimit-5 ====
5 Test setrlimit(2), RLIMIT_MEMLOCK
./t_setrlimit -r 5

==== cleanup-t_setrlimit-5 ====
./t_setrlimit -c 5

==== run-t_setrlimit-6 ====
6 Test setrlimit(2), RLIMIT_NOFILE, #1
./t_setrlimit -r 6

==== cleanup-t_setrlimit-6 ====
./t_setrlimit -c 6

==== run-t_setrlimit-7 ====
7 Test setrlimit(2), RLIMIT_NOFILE, #2
./t_setrlimit -r 7

==== cleanup-t_setrlimit-7 ====
./t_setrlimit -c 7

==== run-t_setrlimit-8 ====
8 Test setrlimit(2), RLIMIT_NPROC
su build -c exec ./t_setrlimit -r 8

==== cleanup-t_setrlimit-8 ====
./t_setrlimit -c 8

==== run-t_setrlimit-9 ====
9 Test setrlimit(2) for EPERM
su build -c exec ./t_setrlimit -r 9

==== cleanup-t_setrlimit-9 ====
./t_setrlimit -c 9

==== run-t_setrlimit-10 ====
10 Test setrlimit(2), RLIMIT_STACK
su build -c exec ./t_setrlimit -r 10

==== cleanup-t_setrlimit-10 ====
./t_setrlimit -c 10


==== run-t_setuid ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_setuid.c
cc   -o t_setuid t_setuid.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_setuid -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_setuid NUMBERS="$tnumbers" regress
1..3
==== run-t_setuid-1 ====
1 Test setuid(0) as normal user
su build -c exec ./t_setuid -r 1

==== cleanup-t_setuid-1 ====
./t_setuid -c 1

==== run-t_setuid-2 ====
2 Test setuid(2) with real UID
./t_setuid -r 2

==== cleanup-t_setuid-2 ====
./t_setuid -c 2

==== run-t_setuid-3 ====
3 A basic test of setuid(2)
./t_setuid -r 3

==== cleanup-t_setuid-3 ====
./t_setuid -c 3


==== run-t_sigaction ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_sigaction.c
cc   -o t_sigaction t_sigaction.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_sigaction -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_sigaction NUMBERS="$tnumbers" regress
1..3
==== run-t_sigaction-1 ====
1 Checks for correct I&D cachesynchronization after copying out the trampoline code.
./t_sigaction -r 1

==== cleanup-t_sigaction-1 ====
./t_sigaction -c 1

==== run-t_sigaction-2 ====
2 Checks programming a signal with sigaction(2) but without any flags
./t_sigaction -r 2

==== cleanup-t_sigaction-2 ====
./t_sigaction -c 2

==== run-t_sigaction-3 ====
3 Checks that SA_RESETHAND works
./t_sigaction -r 3

==== cleanup-t_sigaction-3 ====
./t_sigaction -c 3


==== run-t_sigaltstack ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_sigaltstack.c
cc   -o t_sigaltstack t_sigaltstack.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_sigaltstack -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_sigaltstack NUMBERS="$tnumbers" regress
1..1
==== run-t_sigaltstack-1 ====
1 Checks for using signal stack with SA_ONSTACK
./t_sigaltstack -r 1

==== cleanup-t_sigaltstack-1 ====
./t_sigaltstack -c 1


==== run-t_socketpair ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_socketpair.c
cc   -o t_socketpair t_socketpair.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_socketpair -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_socketpair NUMBERS="$tnumbers" regress
1..3
==== run-t_socketpair-1 ====
1 A basic test of socketpair(2)
./t_socketpair -r 1

==== cleanup-t_socketpair-1 ====
./t_socketpair -c 1

==== run-t_socketpair-2 ====
2 A non-blocking test of socketpair(2)
./t_socketpair -r 2

==== cleanup-t_socketpair-2 ====
./t_socketpair -c 2

==== run-t_socketpair-3 ====
3 A close-on-exec of socketpair(2)
./t_socketpair -r 3

==== cleanup-t_socketpair-3 ====
./t_socketpair -c 3


==== run-t_stat ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_stat.c
cc   -o t_stat t_stat.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_stat -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_stat NUMBERS="$tnumbers" regress
1..8
==== run-t_stat-1 ====
1 Test chflags(2) with stat(2)
./t_stat -r 1

==== cleanup-t_stat-1 ====
./t_stat -c 1

==== run-t_stat-2 ====
2 Test stat(2) with directories
./t_stat -r 2

==== cleanup-t_stat-2 ====
./t_stat -c 2

==== run-t_stat-3 ====
3 Test errors from the stat(2) family
./t_stat -r 3

==== cleanup-t_stat-3 ====
./t_stat -c 3

==== run-t_stat-4 ====
4 Test modification times with stat(2)
./t_stat -r 4

==== cleanup-t_stat-4 ====
./t_stat -c 4

==== run-t_stat-5 ====
5 Test permissions with stat(2)
./t_stat -r 5

==== cleanup-t_stat-5 ====
./t_stat -c 5

==== run-t_stat-6 ====
6 Test file sizes with stat(2)
./t_stat -r 6

==== cleanup-t_stat-6 ====
./t_stat -c 6

==== run-t_stat-7 ====
7 Test fstat(2) with a socket (PR kern/46077)
./t_stat -r 7

==== cleanup-t_stat-7 ====
./t_stat -c 7

==== run-t_stat-8 ====
8 Test symbolic links with stat(2)
./t_stat -r 8

==== cleanup-t_stat-8 ====
./t_stat -c 8


==== run-t_truncate ====
touch truncate_test.root_owned
chown root:wheel truncate_test.root_owned
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_truncate.c
cc   -o t_truncate t_truncate.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_truncate -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_truncate NUMBERS="$tnumbers" regress
1..4
==== run-t_truncate-1 ====
1 A basic test of ftruncate(2)
./t_truncate -r 1
truncating to 8 bytes
truncating to 16 bytes
truncating to 512 bytes
truncating to 1024 bytes
truncating to 2048 bytes
truncating to 4094 bytes
truncating to 3000 bytes
truncating to 30 bytes

==== cleanup-t_truncate-1 ====
./t_truncate -c 1

==== run-t_truncate-2 ====
2 Test errors from ftruncate(2)
su build -c exec ./t_truncate -r 2

==== cleanup-t_truncate-2 ====
./t_truncate -c 2

==== run-t_truncate-3 ====
3 A basic test of truncate(2)
./t_truncate -r 3
truncating to 8 bytes
truncating to 16 bytes
truncating to 512 bytes
truncating to 1024 bytes
truncating to 2048 bytes
truncating to 4094 bytes
truncating to 3000 bytes
truncating to 30 bytes

==== cleanup-t_truncate-3 ====
./t_truncate -c 3

==== run-t_truncate-4 ====
4 Test errors from truncate(2)
su build -c exec ./t_truncate -r 4

==== cleanup-t_truncate-4 ====
./t_truncate -c 4


==== run-t_umask ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_umask.c
cc   -o t_umask t_umask.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_umask -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_umask NUMBERS="$tnumbers" regress
1..3
==== run-t_umask-1 ====
1 Check that umask(2) is inherited
./t_umask -r 1

==== cleanup-t_umask-1 ====
./t_umask -c 1

==== run-t_umask-2 ====
2 A basic test of open(2) and umask(2)
./t_umask -r 2

==== cleanup-t_umask-2 ====
./t_umask -c 2

==== run-t_umask-3 ====
3 Test the return value from umask(2)
./t_umask -r 3

==== cleanup-t_umask-3 ====
./t_umask -c 3


==== run-t_unlink ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_unlink.c
cc   -o t_unlink t_unlink.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_unlink -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_unlink NUMBERS="$tnumbers" regress
1..4
==== run-t_unlink-1 ====
1 A basic test of unlink(2)
./t_unlink -r 1

==== cleanup-t_unlink-1 ====
./t_unlink -c 1

==== run-t_unlink-2 ====
2 Test error conditions of unlink(2)
./t_unlink -r 2

==== cleanup-t_unlink-2 ====
./t_unlink -c 2

==== run-t_unlink-3 ====
3 Test unlink(2) for a FIFO
./t_unlink -r 3

==== cleanup-t_unlink-3 ====
./t_unlink -c 3

==== run-t_unlink-4 ====
4 Test permissions with unlink(2)
su build -c exec ./t_unlink -r 4

==== cleanup-t_unlink-4 ====
./t_unlink -c 4


==== run-t_vfork ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_vfork.c
cc   -o t_vfork t_vfork.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_vfork -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_vfork NUMBERS="$tnumbers" regress
1..10
==== run-t_vfork-1 ====
1 raise SIGKILL in a child
./t_vfork -r 1

==== cleanup-t_vfork-1 ====
./t_vfork -c 1

==== run-t_vfork-2 ====
# SIGSTOP with vfork is masked before exec(3)/exit(3)
# see NetBSD: kern_sig.c,v 1.345
DISABLED

==== cleanup-t_vfork-2 ====
./t_vfork -c 2

==== run-t_vfork-3 ====
3 raise SIGTSTP in a child
./t_vfork -r 3

==== cleanup-t_vfork-3 ====
./t_vfork -c 3

==== run-t_vfork-4 ====
4 raise SIGTTIN in a child
./t_vfork -r 4

==== cleanup-t_vfork-4 ====
./t_vfork -c 4

==== run-t_vfork-5 ====
5 raise SIGTTOU in a child
./t_vfork -r 5

==== cleanup-t_vfork-5 ====
./t_vfork -c 5

==== run-t_vfork-6 ====
6 raise SIGABRT in a child
./t_vfork -r 6

==== cleanup-t_vfork-6 ====
./t_vfork -c 6

==== run-t_vfork-7 ====
7 raise SIGHUP in a child
./t_vfork -r 7

==== cleanup-t_vfork-7 ====
./t_vfork -c 7

==== run-t_vfork-8 ====
8 raise SIGCONT in a child
./t_vfork -r 8

==== cleanup-t_vfork-8 ====
./t_vfork -c 8

==== run-t_vfork-9 ====
9 Test nested fork in a child
./t_vfork -r 9

==== cleanup-t_vfork-9 ====
./t_vfork -c 9

==== run-t_vfork-10 ====
10 Test nested vfork in a child
./t_vfork -r 10

==== cleanup-t_vfork-10 ====
./t_vfork -c 10


==== run-t_waitid ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_waitid.c
cc   -o t_waitid t_waitid.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_waitid -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_waitid NUMBERS="$tnumbers" regress
1..6
==== run-t_waitid-1 ====
1 Test that waitid(2) returns EINVAL with 0 options
./t_waitid -r 1

==== cleanup-t_waitid-1 ====
./t_waitid -c 1

==== run-t_waitid-2 ====
2 Test that waitid(2) handled exiting process and code
./t_waitid -r 2
user: 0 system: 0

==== cleanup-t_waitid-2 ====
./t_waitid -c 2

==== run-t_waitid-3 ====
3 Test that waitid(2) handled terminated process and code
./t_waitid -r 3
user: 0 system: 0

==== cleanup-t_waitid-3 ====
./t_waitid -c 3

==== run-t_waitid-4 ====
4 Test that waitid(2) handled coredumped process and code
./t_waitid -r 4
user: 0 system: 0

==== cleanup-t_waitid-4 ====
./t_waitid -c 4

==== run-t_waitid-5 ====
5 Test that waitid(2) handled stopped/continued process and code
./t_waitid -r 5
user: 0 system: 0
user: 0 system: 0
user: 0 system: 0

==== cleanup-t_waitid-5 ====
./t_waitid -c 5

==== run-t_waitid-6 ====
6 Test that waitid(2) handled stopped/continued process loop
./t_waitid -r 6
Before loop of SIGSTOP/SIGCONT sequence 100 times
user: 0 system: 0

==== cleanup-t_waitid-6 ====
./t_waitid -c 6


==== run-t_wait_noproc ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_wait_noproc.c
cc   -o t_wait_noproc t_wait_noproc.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_wait_noproc -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_wait_noproc NUMBERS="$tnumbers" regress
1..9
==== run-t_wait_noproc-1 ====
1 Test that wait(2) returns ECHILD for no child
./t_wait_noproc -r 1

==== cleanup-t_wait_noproc-1 ====
./t_wait_noproc -c 1

==== run-t_wait_noproc-2 ====
2 Test that waitpid(2) returns ECHILD for WAIT_ANY and option TWAIT_OPTION
./t_wait_noproc -r 2

==== cleanup-t_wait_noproc-2 ====
./t_wait_noproc -c 2

==== run-t_wait_noproc-3 ====
3 Test that waitid(2) returns ECHILD for P_ALL and option TWAIT_OPTION
./t_wait_noproc -r 3

==== cleanup-t_wait_noproc-3 ====
./t_wait_noproc -c 3

==== run-t_wait_noproc-4 ====
4 Test that wait3(2) returns ECHILD for no child
./t_wait_noproc -r 4

==== cleanup-t_wait_noproc-4 ====
./t_wait_noproc -c 4

==== run-t_wait_noproc-5 ====
5 Test that wait4(2) returns ECHILD for WAIT_ANY and option TWAIT_OPTION
./t_wait_noproc -r 5

==== cleanup-t_wait_noproc-5 ====
./t_wait_noproc -c 5

==== run-t_wait_noproc-6 ====
6 Test that waitpid(2) returns ECHILD for WAIT_ANY and valid combination of options without WNOHANG
./t_wait_noproc -r 6
Testing waitpid(2) with options 0
Testing waitpid(2) with options 2

==== cleanup-t_wait_noproc-6 ====
./t_wait_noproc -c 6

==== run-t_wait_noproc-7 ====
7 Test that waitid(2) returns ECHILD for P_ALL and valid combination of options without WNOHANG
./t_wait_noproc -r 7
Testing waitid(2) with options 4
Testing waitid(2) with options 14
Testing waitid(2) with options 2
Testing waitid(2) with options 12
Testing waitid(2) with options 6
Testing waitid(2) with options 16
Testing waitid(2) with options 20
Testing waitid(2) with options 30
Testing waitid(2) with options 24
Testing waitid(2) with options 34
Testing waitid(2) with options 22
Testing waitid(2) with options 32
Testing waitid(2) with options 26
Testing waitid(2) with options 36
Testing waitid(2) with options 8
Testing waitid(2) with options 18
Testing waitid(2) with options c
Testing waitid(2) with options 1c
Testing waitid(2) with options a
Testing waitid(2) with options 1a
Testing waitid(2) with options e
Testing waitid(2) with options 1e
Testing waitid(2) with options 28
Testing waitid(2) with options 38
Testing waitid(2) with options 2c
Testing waitid(2) with options 3c
Testing waitid(2) with options 2a
Testing waitid(2) with options 3a
Testing waitid(2) with options 2e
Testing waitid(2) with options 3e

==== cleanup-t_wait_noproc-7 ====
./t_wait_noproc -c 7

==== run-t_wait_noproc-8 ====
8 Test that wait3(2) returns ECHILD for no child
./t_wait_noproc -r 8
Testing wait3(2) with options 0
Testing wait3(2) with options 2

==== cleanup-t_wait_noproc-8 ====
./t_wait_noproc -c 8

==== run-t_wait_noproc-9 ====
9 Test that wait4(2) returns ECHILD for WAIT_ANY and option TWAIT_OPTION
./t_wait_noproc -r 9
Testing wait4(2) with options 0
Testing wait4(2) with options 2

==== cleanup-t_wait_noproc-9 ====
./t_wait_noproc -c 9


==== run-t_wait_noproc_wnohang ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_wait_noproc_wnohang.c
cc   -o t_wait_noproc_wnohang t_wait_noproc_wnohang.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_wait_noproc_wnohang -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_wait_noproc_wnohang NUMBERS="$tnumbers" regress
1..8
==== run-t_wait_noproc_wnohang-1 ====
1 Test that waitpid(2) returns ECHILD for WAIT_ANY and option TWAIT_OPTION
./t_wait_noproc_wnohang -r 1

==== cleanup-t_wait_noproc_wnohang-1 ====
./t_wait_noproc_wnohang -c 1

==== run-t_wait_noproc_wnohang-2 ====
2 Test that waitid(2) returns ECHILD for P_ALL and option TWAIT_OPTION
./t_wait_noproc_wnohang -r 2

==== cleanup-t_wait_noproc_wnohang-2 ====
./t_wait_noproc_wnohang -c 2

==== run-t_wait_noproc_wnohang-3 ====
3 Test that wait3(2) returns ECHILD for no child
./t_wait_noproc_wnohang -r 3

==== cleanup-t_wait_noproc_wnohang-3 ====
./t_wait_noproc_wnohang -c 3

==== run-t_wait_noproc_wnohang-4 ====
4 Test that wait4(2) returns ECHILD for WAIT_ANY and option TWAIT_OPTION
./t_wait_noproc_wnohang -r 4

==== cleanup-t_wait_noproc_wnohang-4 ====
./t_wait_noproc_wnohang -c 4

==== run-t_wait_noproc_wnohang-5 ====
5 Test that waitpid(2) returns ECHILD for WAIT_ANY and valid combination of options with WNOHANG
./t_wait_noproc_wnohang -r 5
Testing waitpid(2) with options 0
Testing waitpid(2) with options 2

==== cleanup-t_wait_noproc_wnohang-5 ====
./t_wait_noproc_wnohang -c 5

==== run-t_wait_noproc_wnohang-6 ====
6 Test that waitid(2) returns ECHILD for P_ALL and valid combination of options with WNOHANG
./t_wait_noproc_wnohang -r 6
Testing waitid(2) with options 4
Testing waitid(2) with options 14
Testing waitid(2) with options 2
Testing waitid(2) with options 12
Testing waitid(2) with options 6
Testing waitid(2) with options 16
Testing waitid(2) with options 20
Testing waitid(2) with options 30
Testing waitid(2) with options 24
Testing waitid(2) with options 34
Testing waitid(2) with options 22
Testing waitid(2) with options 32
Testing waitid(2) with options 26
Testing waitid(2) with options 36
Testing waitid(2) with options 8
Testing waitid(2) with options 18
Testing waitid(2) with options c
Testing waitid(2) with options 1c
Testing waitid(2) with options a
Testing waitid(2) with options 1a
Testing waitid(2) with options e
Testing waitid(2) with options 1e
Testing waitid(2) with options 28
Testing waitid(2) with options 38
Testing waitid(2) with options 2c
Testing waitid(2) with options 3c
Testing waitid(2) with options 2a
Testing waitid(2) with options 3a
Testing waitid(2) with options 2e
Testing waitid(2) with options 3e

==== cleanup-t_wait_noproc_wnohang-6 ====
./t_wait_noproc_wnohang -c 6

==== run-t_wait_noproc_wnohang-7 ====
7 Test that wait3(2) returns ECHILD for no child
./t_wait_noproc_wnohang -r 7
Testing wait3(2) with options 0
Testing wait3(2) with options 2

==== cleanup-t_wait_noproc_wnohang-7 ====
./t_wait_noproc_wnohang -c 7

==== run-t_wait_noproc_wnohang-8 ====
8 Test that wait4(2) returns ECHILD for WAIT_ANY and option TWAIT_OPTION
./t_wait_noproc_wnohang -r 8
Testing wait4(2) with options 0
Testing wait4(2) with options 2

==== cleanup-t_wait_noproc_wnohang-8 ====
./t_wait_noproc_wnohang -c 8


==== run-t_write ====
cc -O2 -pipe  -std=gnu99  -MD -MP  -c /usr/src/regress/lib/libc/sys/t_write.c
cc   -o t_write t_write.o atf-c.o 
ulimit -c unlimited &&  ntests="`./t_write -n`" &&  echo "1..$ntests" &&  tnumbers="`jot -ns' ' - 1 $ntests`" &&  make -C /usr/src/regress/lib/libc/sys PROG=t_write NUMBERS="$tnumbers" regress
1..7
==== run-t_write-1 ====
1 Checks errors from write(2)
./t_write -r 1

==== cleanup-t_write-1 ====
./t_write -c 1

==== run-t_write-2 ====
2 Checks for EPIPE from write(2)
./t_write -r 2

==== cleanup-t_write-2 ====
./t_write -c 2

==== run-t_write-3 ====
3 Checks that write(2) updates the file position
./t_write -r 3

==== cleanup-t_write-3 ====
./t_write -c 3

==== run-t_write-4 ====
4 Checks return values from write(2)
./t_write -r 4

==== cleanup-t_write-4 ====
./t_write -c 4

==== run-t_write-5 ====
5 Checks that file descriptor is properly FILE_UNUSE()d when iovcnt is greater than IOV_MAX
./t_write -r 5
Calling writev(2, NULL, IOV_MAX + 1)...

==== cleanup-t_write-5 ====
./t_write -c 5

==== run-t_write-6 ====
6 Check that writing to non-permitted space returns EFAULT
./t_write -r 6

==== cleanup-t_write-6 ====
./t_write -c 6

==== run-t_write-7 ====
7 Check that reading from non-permitted space returns EFAULT
./t_write -r 7

==== cleanup-t_write-7 ====
./t_write -c 7


XFAIL	lib/libc/sys	*** Error 1 in . (Makefile:140 'run-t_mlock-4'), *** Error 1 in . (Makefile:140 'run-t_msgrcv-3')