START	lib/libc/sys	2023-12-15T19:34:22Z

==== 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 = CP0
kern.timecounter.choice = CP0(1000) ioclock(0)

==== 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 62769): 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 = 0xdd827c000 (page=16384)

==== 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 = 0x3567094000 (page=16384)
testing with (hopefully) invalid pointer 0x30fff6c000

==== 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 = 0x296efc8000 (page=16384)
trying to lock 16384 bytes with 16383 byte limit
trying to lock 16284 bytes with 16283 byte limit
trying to lock 16184 bytes with 16183 byte limit
trying to lock 16084 bytes with 16083 byte limit
trying to lock 15984 bytes with 15983 byte limit
trying to lock 15884 bytes with 15883 byte limit
trying to lock 15784 bytes with 15783 byte limit
trying to lock 15684 bytes with 15683 byte limit
trying to lock 15584 bytes with 15583 byte limit
trying to lock 15484 bytes with 15483 byte limit
trying to lock 15384 bytes with 15383 byte limit
trying to lock 15284 bytes with 15283 byte limit
trying to lock 15184 bytes with 15183 byte limit
trying to lock 15084 bytes with 15083 byte limit
trying to lock 14984 bytes with 14983 byte limit
trying to lock 14884 bytes with 14883 byte limit
trying to lock 14784 bytes with 14783 byte limit
trying to lock 14684 bytes with 14683 byte limit
trying to lock 14584 bytes with 14583 byte limit
trying to lock 14484 bytes with 14483 byte limit
trying to lock 14384 bytes with 14383 byte limit
trying to lock 14284 bytes with 14283 byte limit
trying to lock 14184 bytes with 14183 byte limit
trying to lock 14084 bytes with 14083 byte limit
trying to lock 13984 bytes with 13983 byte limit
trying to lock 13884 bytes with 13883 byte limit
trying to lock 13784 bytes with 13783 byte limit
trying to lock 13684 bytes with 13683 byte limit
trying to lock 13584 bytes with 13583 byte limit
trying to lock 13484 bytes with 13483 byte limit
trying to lock 13384 bytes with 13383 byte limit
trying to lock 13284 bytes with 13283 byte limit
trying to lock 13184 bytes with 13183 byte limit
trying to lock 13084 bytes with 13083 byte limit
trying to lock 12984 bytes with 12983 byte limit
trying to lock 12884 bytes with 12883 byte limit
trying to lock 12784 bytes with 12783 byte limit
trying to lock 12684 bytes with 12683 byte limit
trying to lock 12584 bytes with 12583 byte limit
trying to lock 12484 bytes with 12483 byte limit
trying to lock 12384 bytes with 12383 byte limit
trying to lock 12284 bytes with 12283 byte limit
trying to lock 12184 bytes with 12183 byte limit
trying to lock 12084 bytes with 12083 byte limit
trying to lock 11984 bytes with 11983 byte limit
trying to lock 11884 bytes with 11883 byte limit
trying to lock 11784 bytes with 11783 byte limit
trying to lock 11684 bytes with 11683 byte limit
trying to lock 11584 bytes with 11583 byte limit
trying to lock 11484 bytes with 11483 byte limit
trying to lock 11384 bytes with 11383 byte limit
trying to lock 11284 bytes with 11283 byte limit
trying to lock 11184 bytes with 11183 byte limit
trying to lock 11084 bytes with 11083 byte limit
trying to lock 10984 bytes with 10983 byte limit
trying to lock 10884 bytes with 10883 byte limit
trying to lock 10784 bytes with 10783 byte limit
trying to lock 10684 bytes with 10683 byte limit
trying to lock 10584 bytes with 10583 byte limit
trying to lock 10484 bytes with 10483 byte limit
trying to lock 10384 bytes with 10383 byte limit
trying to lock 10284 bytes with 10283 byte limit
trying to lock 10184 bytes with 10183 byte limit
trying to lock 10084 bytes with 10083 byte limit
trying to lock 9984 bytes with 9983 byte limit
trying to lock 9884 bytes with 9883 byte limit
trying to lock 9784 bytes with 9783 byte limit
trying to lock 9684 bytes with 9683 byte limit
trying to lock 9584 bytes with 9583 byte limit
trying to lock 9484 bytes with 9483 byte limit
trying to lock 9384 bytes with 9383 byte limit
trying to lock 9284 bytes with 9283 byte limit
trying to lock 9184 bytes with 9183 byte limit
trying to lock 9084 bytes with 9083 byte limit
trying to lock 8984 bytes with 8983 byte limit
trying to lock 8884 bytes with 8883 byte limit
trying to lock 8784 bytes with 8783 byte limit
trying to lock 8684 bytes with 8683 byte limit
trying to lock 8584 bytes with 8583 byte limit
trying to lock 8484 bytes with 8483 byte limit
trying to lock 8384 bytes with 8383 byte limit
trying to lock 8284 bytes with 8283 byte limit
trying to lock 8184 bytes with 8183 byte limit
trying to lock 8084 bytes with 8083 byte limit
trying to lock 7984 bytes with 7983 byte limit
trying to lock 7884 bytes with 7883 byte limit
trying to lock 7784 bytes with 7783 byte limit
trying to lock 7684 bytes with 7683 byte limit
trying to lock 7584 bytes with 7583 byte limit
trying to lock 7484 bytes with 7483 byte limit
trying to lock 7384 bytes with 7383 byte limit
trying to lock 7284 bytes with 7283 byte limit
trying to lock 7184 bytes with 7183 byte limit
trying to lock 7084 bytes with 7083 byte limit
trying to lock 6984 bytes with 6983 byte limit
trying to lock 6884 bytes with 6883 byte limit
trying to lock 6784 bytes with 6783 byte limit
trying to lock 6684 bytes with 6683 byte limit
trying to lock 6584 bytes with 6583 byte limit
trying to lock 6484 bytes with 6483 byte limit
trying to lock 6384 bytes with 6383 byte limit
trying to lock 6284 bytes with 6283 byte limit
trying to lock 6184 bytes with 6183 byte limit
trying to lock 6084 bytes with 6083 byte limit
trying to lock 5984 bytes with 5983 byte limit
trying to lock 5884 bytes with 5883 byte limit
trying to lock 5784 bytes with 5783 byte limit
trying to lock 5684 bytes with 5683 byte limit
trying to lock 5584 bytes with 5583 byte limit
trying to lock 5484 bytes with 5483 byte limit
trying to lock 5384 bytes with 5383 byte limit
trying to lock 5284 bytes with 5283 byte limit
trying to lock 5184 bytes with 5183 byte limit
trying to lock 5084 bytes with 5083 byte limit
trying to lock 4984 bytes with 4983 byte limit
trying to lock 4884 bytes with 4883 byte limit
trying to lock 4784 bytes with 4783 byte limit
trying to lock 4684 bytes with 4683 byte limit
trying to lock 4584 bytes with 4583 byte limit
trying to lock 4484 bytes with 4483 byte limit
trying to lock 4384 bytes with 4383 byte limit
trying to lock 4284 bytes with 4283 byte limit
trying to lock 4184 bytes with 4183 byte limit
trying to lock 4084 bytes with 4083 byte limit
trying to lock 3984 bytes with 3983 byte limit
trying to lock 3884 bytes with 3883 byte limit
trying to lock 3784 bytes with 3783 byte limit
trying to lock 3684 bytes with 3683 byte limit
trying to lock 3584 bytes with 3583 byte limit
trying to lock 3484 bytes with 3483 byte limit
trying to lock 3384 bytes with 3383 byte limit
trying to lock 3284 bytes with 3283 byte limit
trying to lock 3184 bytes with 3183 byte limit
trying to lock 3084 bytes with 3083 byte limit
trying to lock 2984 bytes with 2983 byte limit
trying to lock 2884 bytes with 2883 byte limit
trying to lock 2784 bytes with 2783 byte limit
trying to lock 2684 bytes with 2683 byte limit
trying to lock 2584 bytes with 2583 byte limit
trying to lock 2484 bytes with 2483 byte limit
trying to lock 2384 bytes with 2383 byte limit
trying to lock 2284 bytes with 2283 byte limit
trying to lock 2184 bytes with 2183 byte limit
trying to lock 2084 bytes with 2083 byte limit
trying to lock 1984 bytes with 1983 byte limit
trying to lock 1884 bytes with 1883 byte limit
trying to lock 1784 bytes with 1783 byte limit
trying to lock 1684 bytes with 1683 byte limit
trying to lock 1584 bytes with 1583 byte limit
trying to lock 1484 bytes with 1483 byte limit
trying to lock 1384 bytes with 1383 byte limit
trying to lock 1284 bytes with 1283 byte limit
trying to lock 1184 bytes with 1183 byte limit
trying to lock 1084 bytes with 1083 byte limit
trying to lock 984 bytes with 983 byte limit
trying to lock 884 bytes with 883 byte limit
trying to lock 784 bytes with 783 byte limit
trying to lock 684 bytes with 683 byte limit
trying to lock 584 bytes with 583 byte limit
trying to lock 484 bytes with 483 byte limit
trying to lock 384 bytes with 383 byte limit
trying to lock 284 bytes with 283 byte limit
trying to lock 184 bytes with 183 byte limit
trying to lock 84 bytes with 83 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=0x2fe5f74000, page=16384
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 = 0x2f93900000 (page=16384)

==== 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/sd0c
using /dev/sd0c
first byte 0
first byte 0

==== 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 9653
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 54802) a debugger of PID 50996
Mark the parent process (PID 54802) a debugger of PID 50996 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')