/* $NetBSD: audiotest.c,v 1.33 2025/06/27 19:52:03 andvar Exp $ */

/* $NetBSD: audiotest.c,v 1.33 2025/06/27 19:52:03 andvar Exp $ */

/*
* Copyright (C) 2019 Tetsuya Isaki. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

#include <sys/cdefs.h>
__RCSID("$NetBSD: audiotest.c,v 1.33 2025/06/27 19:52:03 andvar Exp $");

#include <errno.h>
#include <fcntl.h>
#define __STDC_FORMAT_MACROS /* for PRIx64 */
#include <inttypes.h>
#include <pthread.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <util.h>
#include <sys/audioio.h>
#include <sys/event.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/poll.h>
#include <sys/sysctl.h>
#include <sys/time.h>
#include <sys/wait.h>
#if !defined(NO_RUMP)
#include <rump/rump.h>
#include <rump/rump_syscalls.h>
#endif

/* this internal driver option is not exported to userland */
#define AUDIO_SUPPORT_LINEAR24

#if !defined(AUDIO_ENCODING_SLINEAR_NE)
#if BYTE_ORDER == LITTLE_ENDIAN
#define AUDIO_ENCODING_SLINEAR_NE AUDIO_ENCODING_SLINEAR_LE
#define AUDIO_ENCODING_ULINEAR_NE AUDIO_ENCODING_ULINEAR_LE
#define AUDIO_ENCODING_SLINEAR_OE AUDIO_ENCODING_SLINEAR_BE
#define AUDIO_ENCODING_ULINEAR_OE AUDIO_ENCODING_ULINEAR_BE
#else
#define AUDIO_ENCODING_SLINEAR_NE AUDIO_ENCODING_SLINEAR_BE
#define AUDIO_ENCODING_ULINEAR_NE AUDIO_ENCODING_ULINEAR_BE
#define AUDIO_ENCODING_SLINEAR_OE AUDIO_ENCODING_SLINEAR_LE
#define AUDIO_ENCODING_ULINEAR_OE AUDIO_ENCODING_ULINEAR_LE
#endif
#endif

struct testentry {
const char *name;
void (*func)(void);
};

void usage(void) __dead;
void xp_err(int, int, const char *, ...) __printflike(3, 4) __dead;
void xp_errx(int, int, const char *, ...) __printflike(3, 4) __dead;
bool match(const char *, const char *);
void xxx_close_wait(void);
int mixer_get_outputs_master(int);
void do_test(int);
int rump_or_open(const char *, int);
int rump_or_write(int, const void *, size_t);
int rump_or_read(int, void *, size_t);
int rump_or_ioctl(int, u_long, void *);
int rump_or_close(int);
int rump_or_fcntl(int, int, ...);
int rump_or_poll(struct pollfd *, nfds_t, int);
int rump_or_kqueue(void);
int rump_or_kevent(int, const struct kevent *, size_t,
struct kevent *, size_t, const struct timespec *);
int hw_canplay(void);
int hw_canrec(void);
int hw_bidir(void);
int hw_fulldup(void);
void init(int);
void *consumer_thread(void *);
void cleanup_audiofd(void);
void TEST(const char *, ...) __printflike(1, 2);
bool xp_fail(int, const char *, ...) __printflike(2, 3);
void xp_skip(int, const char *, ...) __printflike(2, 3);
bool xp_eq(int, int, int, const char *);
bool xp_eq_str(int, const char *, const char *, const char *);
bool xp_ne(int, int, int, const char *);
bool xp_if(int, bool, const char *);
bool xp_sys_eq(int, int, int, const char *);
bool xp_sys_ok(int, int, const char *);
bool xp_sys_ng(int, int, int, const char *);
bool xp_sys_ptr(int, int, void *, const char *);
int debug_open(int, const char *, int);
int debug_write(int, int, const void *, size_t);
int debug_read(int, int, void *, size_t);
int debug_ioctl(int, int, u_long, const char *, void *, const char *, ...)
__printflike(6, 7);
int debug_fcntl(int, int, int, const char *, ...) __printflike(4, 5);
int debug_close(int, int);
void *debug_mmap(int, void *, size_t, int, int, int, off_t);
int debug_munmap(int, void *, int);
const char *event_tostr(int);
int debug_poll(int, struct pollfd *, int, int);
int debug_kqueue(int);
int debug_kevent_set(int, int, const struct kevent *, size_t);
int debug_kevent_poll(int, int, struct kevent *, size_t,
const struct timespec *);
void debug_kev(int, const char *, const struct kevent *);
uid_t debug_getuid(int);
int debug_seteuid(int, uid_t);
int debug_sysctlbyname(int, const char *, void *, size_t *, const void *,
size_t);

int openable_mode(void);
int mode2aumode(int);
int mode2play(int);
int mode2rec(int);
void reset_after_mmap(void);

/* from audio.c */
static const char *encoding_names[] __unused = {
"none",
AudioEmulaw,
AudioEalaw,
"pcm16",
"pcm8",
AudioEadpcm,
AudioEslinear_le,
AudioEslinear_be,
AudioEulinear_le,
AudioEulinear_be,
AudioEslinear,
AudioEulinear,
AudioEmpeg_l1_stream,
AudioEmpeg_l1_packets,
AudioEmpeg_l1_system,
AudioEmpeg_l2_stream,
AudioEmpeg_l2_packets,
AudioEmpeg_l2_system,
AudioEac3,
};

int debug;
int props;
int hwfull;
int netbsd;
bool opt_atf;
char testname[64];
int testcount;
int failcount;
int skipcount;
int unit;
bool use_rump;
bool use_pad;
bool exact_match;
int padfd;
int maxfd;
pthread_t th;
char devicename[16]; /* "audioN" */
char devaudio[16]; /* "/dev/audioN" */
char devsound[16]; /* "/dev/soundN" */
char devaudioctl[16]; /* "/dev/audioctlN" */
char devmixer[16]; /* "/dev/mixerN" */
extern struct testentry testtable[];

void
usage(void)
{
fprintf(stderr, "usage:\t%s [<options>] [<testname>...]\n",
getprogname());
fprintf(stderr, "\t-A : make output suitable for ATF\n");
fprintf(stderr, "\t-a : Test all\n");
fprintf(stderr, "\t-d : Increase debug level\n");
fprintf(stderr, "\t-e : Use exact match for testnames "
"(default is forward match)\n");
fprintf(stderr, "\t-l : List all tests\n");
fprintf(stderr, "\t-p : Open pad\n");
#if !defined(NO_RUMP)
fprintf(stderr, "\t-R : Use rump (implies -p)\n");
#endif
fprintf(stderr, "\t-u <unit> : Use audio<unit> (default:0)\n");
exit(1);
}

/* Customized err(3) */
void
xp_err(int code, int line, const char *fmt, ...)
{
va_list ap;
int backup_errno;

backup_errno = errno;
printf("%s %d: ", (opt_atf ? "Line" : " ERROR:"), line);
va_start(ap, fmt);
vprintf(fmt, ap);
va_end(ap);
printf(": %s\n", strerror(backup_errno));

exit(code);
}

/* Customized errx(3) */
void
xp_errx(int code, int line, const char *fmt, ...)
{
va_list ap;

printf("%s %d: ", (opt_atf ? "Line" : " ERROR:"), line);
va_start(ap, fmt);
vprintf(fmt, ap);
va_end(ap);
printf("\n");

exit(code);
}

int
main(int argc, char *argv[])
{
int i;
int j;
int c;
enum {
CMD_TEST,
CMD_ALL,
CMD_LIST,
} cmd;
bool found;

props = -1;
hwfull = 0;
unit = 0;
cmd = CMD_TEST;
use_pad = false;
padfd = -1;
exact_match = false;

while ((c = getopt(argc, argv, "AadelpRu:")) != -1) {
switch (c) {
case 'A':
opt_atf = true;
break;
case 'a':
cmd = CMD_ALL;
break;
case 'd':
debug++;
break;
case 'e':
exact_match = true;
break;
case 'l':
cmd = CMD_LIST;
break;
case 'p':
use_pad = true;
break;
case 'R':
#if !defined(NO_RUMP)
use_rump = true;
use_pad = true;
#else
usage();
#endif
break;
case 'u':
unit = atoi(optarg);
break;
default:
usage();
}
}
argc -= optind;
argv += optind;

if (cmd == CMD_LIST) {
/* List all */
for (i = 0; testtable[i].name != NULL; i++)
printf("%s\n", testtable[i].name);
return 0;
}

init(unit);

if (cmd == CMD_ALL) {
/* Test all */
if (argc > 0)
usage();
for (i = 0; testtable[i].name != NULL; i++)
do_test(i);
} else {
/* Test only matched */
if (argc == 0)
usage();

found = false;
for (j = 0; j < argc; j++) {
for (i = 0; testtable[i].name != NULL; i++) {
if (match(argv[j], testtable[i].name)) {
do_test(i);
found = true;
}
}
}
if (!found) {
printf("test not found\n");
exit(1);
}
}

if (opt_atf == false) {
printf("Result: %d tests, %d success",
testcount,
testcount - failcount - skipcount);
if (failcount > 0)
printf(", %d failed", failcount);
if (skipcount > 0)
printf(", %d skipped", skipcount);
printf("\n");
}

if (skipcount > 0)
return 2;
if (failcount > 0)
return 1;

return 0;
}

bool
match(const char *arg, const char *name)
{
if (exact_match) {
/* Exact match */
if (strcmp(arg, name) == 0)
return true;
} else {
/* Forward match */
if (strncmp(arg, name, strlen(arg)) == 0)
return true;
}
return false;
}

/*
* XXX
* Some hardware drivers (e.g. hdafg(4)) require a little "rest" between
* close(2) and re-open(2).
* audio(4) uses hw_if->close() to tell the hardware to close. However,
* there is no agreement to wait for completion between MI and MD layer.
* audio(4) immediately shifts the "closed" state, and that is, the next
* open() will be acceptable immediately in audio layer. But the real
* hardware may not have been closed actually at that point.
* It's troublesome issue but should be fixed...
*
* However, the most frequently used pad(4) (for ATF tests) doesn't have
* such problem, so avoids it to reduce time.
*/
void
xxx_close_wait(void)
{

if (!use_pad)
usleep(500 * 1000);
}

void
do_test(int testnumber)
{
/* Sentinel */
strlcpy(testname, "<NoName>", sizeof(testname));
/* Do test */
testtable[testnumber].func();

cleanup_audiofd();
xxx_close_wait();
}

/*
* system call wrappers for rump.
*/

/* open(2) or rump_sys_open(3) */
int
rump_or_open(const char *filename, int flag)
{
int r;

#if !defined(NO_RUMP)
if (use_rump)
r = rump_sys_open(filename, flag);
else
#endif
r = open(filename, flag);

if (r > maxfd)
maxfd = r;
return r;
}

/* write(2) or rump_sys_write(3) */
int
rump_or_write(int fd, const void *buf, size_t len)
{
int r;

#if !defined(NO_RUMP)
if (use_rump)
r = rump_sys_write(fd, buf, len);
else
#endif
r = write(fd, buf, len);
return r;
}

/* read(2) or rump_sys_read(3) */
int
rump_or_read(int fd, void *buf, size_t len)
{
int r;

#if !defined(NO_RUMP)
if (use_rump)
r = rump_sys_read(fd, buf, len);
else
#endif
r = read(fd, buf, len);
return r;
}

/* ioctl(2) or rump_sys_ioctl(3) */
int
rump_or_ioctl(int fd, u_long cmd, void *arg)
{
int r;

#if !defined(NO_RUMP)
if (use_rump)
r = rump_sys_ioctl(fd, cmd, arg);
else
#endif
r = ioctl(fd, cmd, arg);
return r;
}

/* close(2) or rump_sys_close(3) */
int
rump_or_close(int fd)
{
int r;

#if !defined(NO_RUMP)
if (use_rump)
r = rump_sys_close(fd);
else
#endif
r = close(fd);

/* maxfd-1 may not valid fd but no matter */
if (fd == maxfd)
maxfd--;
return r;
}

/* fcntl(2) or rump_sys_fcntl(3) */
/* XXX Supported only with no arguments for now */
int
rump_or_fcntl(int fd, int cmd, ...)
{
int r;

#if !defined(NO_RUMP)
if (use_rump)
r = rump_sys_fcntl(fd, cmd);
else
#endif
r = fcntl(fd, cmd);
return r;
}

/* poll(2) or rump_sys_poll(3) */
int
rump_or_poll(struct pollfd *fds, nfds_t nfds, int timeout)
{
int r;

#if !defined(NO_RUMP)
if (use_rump)
r = rump_sys_poll(fds, nfds, timeout);
else
#endif
r = poll(fds, nfds, timeout);
return r;
}

/* kqueue(2) or rump_sys_kqueue(3) */
int
rump_or_kqueue(void)
{
int r;

#if !defined(NO_RUMP)
if (use_rump)
r = rump_sys_kqueue();
else
#endif
r = kqueue();
return r;
}

/* kevent(2) or rump_sys_kevent(3) */
int
rump_or_kevent(int kq, const struct kevent *chlist, size_t nch,
struct kevent *evlist, size_t nev,
const struct timespec *timeout)
{
int r;

#if !defined(NO_RUMP)
if (use_rump)
r = rump_sys_kevent(kq, chlist, nch, evlist, nev, timeout);
else
#endif
r = kevent(kq, chlist, nch, evlist, nev, timeout);
return r;
}

int
hw_canplay(void)
{
return (props & AUDIO_PROP_PLAYBACK) ? 1 : 0;
}

int
hw_canrec(void)
{
return (props & AUDIO_PROP_CAPTURE) ? 1 : 0;
}

int
hw_bidir(void)
{
return hw_canplay() & hw_canrec();
}

int
hw_fulldup(void)
{
return (props & AUDIO_PROP_FULLDUPLEX) ? 1 : 0;
}

#define DPRINTF(fmt...) do { \
if (debug) \
printf(fmt); \
} while (0)

#define DPRINTFF(line, fmt...) do { \
if (debug) { \
printf(" > %d: ", line); \
DPRINTF(fmt); \
fflush(stdout); \
} \
} while (0)

#define DRESULT(r) do { \
int backup_errno = errno; \
if (r == -1) { \
DPRINTF(" = %d, err#%d %s\n", \
r, backup_errno, \
strerror(backup_errno)); \
} else { \
DPRINTF(" = %d\n", r); \
} \
errno = backup_errno; \
return r; \
} while (0)

/* pointer variants for mmap */
#define DRESULT_PTR(r) do { \
int backup_errno = errno; \
if (r == (void *)-1) { \
DPRINTF(" = -1, err#%d %s\n", \
backup_errno, \
strerror(backup_errno)); \
} else { \
DPRINTF(" = %p\n", r); \
} \
errno = backup_errno; \
return r; \
} while (0)

/*
* requnit < 0: Use auto by pad (not implemented).
* requnit >= 0: Use audio<requnit>.
*/
void
init(int requnit)
{
struct audio_device devinfo;
size_t len;
int rel;
int fd;
int r;

/* XXX */
atexit(cleanup_audiofd);

if (requnit < 0) {
xp_errx(1, __LINE__, "requnit < 0 not implemented.");
} else {
unit = requnit;
}

/* Set device name */
snprintf(devicename, sizeof(devicename), "audio%d", unit);
snprintf(devaudio, sizeof(devaudio), "/dev/audio%d", unit);
snprintf(devsound, sizeof(devsound), "/dev/sound%d", unit);
snprintf(devaudioctl, sizeof(devaudioctl), "/dev/audioctl%d", unit);
snprintf(devmixer, sizeof(devmixer), "/dev/mixer%d", unit);

/*
* version
* audio2 is merged in 8.99.39.
*/
len = sizeof(rel);
r = sysctlbyname("kern.osrevision", &rel, &len, NULL, 0);
if (r == -1)
xp_err(1, __LINE__, "sysctl kern.osrevision");
netbsd = rel / 100000000;
if (rel >= 899003900)
netbsd = 9;

#if !defined(NO_RUMP)
if (use_rump) {
DPRINTF(" use rump\n");
rump_init();
}
#endif

/*
* Open pad device before all accesses (including /dev/audioctl).
*/
if (use_pad) {
padfd = rump_or_open("/dev/pad0", O_RDONLY);
if (padfd == -1)
xp_err(1, __LINE__, "rump_or_open");

/* Create consumer thread */
pthread_create(&th, NULL, consumer_thread, NULL);
/* Set this thread's name */
pthread_setname_np(pthread_self(), "main", NULL);
}

/*
* Get device properties, etc.
*/
fd = rump_or_open(devaudioctl, O_RDONLY);
if (fd == -1)
xp_err(1, __LINE__, "open %s", devaudioctl);
r = rump_or_ioctl(fd, AUDIO_GETPROPS, &props);
if (r == -1)
xp_err(1, __LINE__, "AUDIO_GETPROPS");
r = rump_or_ioctl(fd, AUDIO_GETDEV, &devinfo);
if (r == -1)
xp_err(1, __LINE__, "AUDIO_GETDEV");
rump_or_close(fd);

if (debug) {
printf(" device = %s, %s, %s\n",
devinfo.name, devinfo.version, devinfo.config);
printf(" hw props =");
if (hw_canplay())
printf(" playback");
if (hw_canrec())
printf(" capture");
if (hw_fulldup())
printf(" fullduplex");
printf("\n");
}

}

/* Consumer thread used by pad */
void *
consumer_thread(void *arg)
{
char buf[1024];
int r;

pthread_setname_np(pthread_self(), "consumer", NULL);
pthread_detach(pthread_self());

/* throw away data anyway */
for (;;) {
r = read(padfd, buf, sizeof(buf));
if (r < 1)
break;
}

pthread_exit(NULL);
}

/*
* XXX
* Closing pad descriptor before audio descriptor causes panic (PR kern/54427).
* To avoid this, close non-pad descriptor first using atexit(3) for now.
* This is just a workaround and this function should be removed.
*/
void cleanup_audiofd()
{
int fd;

for (fd = 3; fd <= maxfd; fd++) {
if (fd != padfd)
close(fd);
}
maxfd = 3;
}

/*
* Support functions
*/

/* Set testname */
void
TEST(const char *name, ...)
{
va_list ap;

va_start(ap, name);
vsnprintf(testname, sizeof(testname), name, ap);
va_end(ap);
if (opt_atf == false) {
printf("%s\n", testname);
fflush(stdout);
}
}

/*
* XP_FAIL() should be called when this test fails.
* If caller already count up testcount, call xp_fail() instead.
*/
#define XP_FAIL(fmt...) do { \
testcount++; \
xp_fail(__LINE__, fmt); \
} while (0)
bool xp_fail(int line, const char *fmt, ...)
{
va_list ap;

printf("%s %d: ", (opt_atf ? "Line" : " FAIL:"), line);
va_start(ap, fmt);
vprintf(fmt, ap);
va_end(ap);
printf("\n");
fflush(stdout);
failcount++;

return false;
}

/*
* XP_SKIP() should be called when you want to skip this test.
* If caller already count up testcount, call xp_skip() instead.
*/
#define XP_SKIP(fmt...) do { \
testcount++; \
xp_skip(__LINE__, fmt); \
} while (0)
void xp_skip(int line, const char *fmt, ...)
{
va_list ap;

printf("%s %d: ", (opt_atf ? "Line" : " SKIP:"), line);
va_start(ap, fmt);
vprintf(fmt, ap);
va_end(ap);
printf("\n");
fflush(stdout);
skipcount++;
}

#define XP_EQ(exp, act) xp_eq(__LINE__, exp, act, #act)
bool xp_eq(int line, int exp, int act, const char *varname)
{
bool r = true;

testcount++;
if (exp != act) {
r = xp_fail(line, "%s expects %d but %d", varname, exp, act);
}
return r;
}
#define XP_EQ_STR(exp, act) xp_eq_str(__LINE__, exp, act, #act)
bool xp_eq_str(int line, const char *exp, const char *act, const char *varname)
{
bool r = true;

testcount++;
if (strcmp(exp, act) != 0) {
r = xp_fail(line, "%s expects \"%s\" but \"%s\"",
varname, exp, act);
}
return r;
}

#define XP_NE(exp, act) xp_ne(__LINE__, exp, act, #act)
bool xp_ne(int line, int exp, int act, const char *varname)
{
bool r = true;

testcount++;
if (exp == act) {
r = xp_fail(line, "%s expects != %d but %d", varname, exp, act);
}
return r;
}

/* This expects that result is expressed in expr. */
/* GCC extension */
#define XP_IF(expr) xp_if(__LINE__, (expr), #expr)
bool xp_if(int line, bool expr, const char *exprname)
{
bool r = true;
testcount++;
if (!expr) {
r = xp_fail(__LINE__, "(%s) is expected but not met", exprname);
}
return r;
}

/* This expects that the system call returns 'exp'. */
#define XP_SYS_EQ(exp, act) xp_sys_eq(__LINE__, exp, act, #act)
bool xp_sys_eq(int line, int exp, int act, const char *varname)
{
bool r = true;

testcount++;
if (act == -1) {
r = xp_fail(line, "%s expects %d but -1,err#%d(%s)",
varname, exp, errno, strerror(errno));
} else {
r = xp_eq(line, exp, act, varname);
}
return r;
}

/*
* This expects that system call succeeds.
* This is useful when you expect the system call succeeds but don't know
* the expected return value, such as open(2).
*/
#define XP_SYS_OK(act) xp_sys_ok(__LINE__, act, #act)
bool xp_sys_ok(int line, int act, const char *varname)
{
bool r = true;

testcount++;
if (act == -1) {
r = xp_fail(line, "%s expects success but -1,err#%d(%s)",
varname, errno, strerror(errno));
}
return r;
}

/* This expects that the system call fails with 'experrno'. */
#define XP_SYS_NG(experrno, act) xp_sys_ng(__LINE__, experrno, act, #act)
bool xp_sys_ng(int line, int experrno, int act, const char *varname)
{
bool r = true;

testcount++;
if (act != -1) {
r = xp_fail(line, "%s expects -1,err#%d but %d",
varname, experrno, act);
} else if (experrno != errno) {
char acterrbuf[100];
int acterrno = errno;
strlcpy(acterrbuf, strerror(acterrno), sizeof(acterrbuf));
r = xp_fail(line, "%s expects -1,err#%d(%s) but -1,err#%d(%s)",
varname, experrno, strerror(experrno),
acterrno, acterrbuf);
}
return r;
}

/*
* When exp == 0, this expects that the system call succeeds with returned
* pointer is not -1.
* When exp != 0, this expects that the system call fails with returned
* pointer is -1 and its errno is exp.
* It's only for mmap().
*/
#define XP_SYS_PTR(exp, act) xp_sys_ptr(__LINE__, exp, act, #act)
bool xp_sys_ptr(int line, int exp, void *act, const char *varname)
{
char errbuf[256];
int actual_errno;
bool r = true;

testcount++;
if (exp == 0) {
/* expects to succeed */
if (act == (void *)-1) {
r = xp_fail(line,
"%s expects success but -1,err#%d(%s)",
varname, errno, strerror(errno));
}
} else {
/* expects to fail */
if (act != (void *)-1) {
r = xp_fail(line,
"%s expects -1,err#%d(%s) but success",
varname, exp, strerror(exp));
} else if (exp != errno) {
actual_errno = errno;
strerror_r(actual_errno, errbuf, sizeof(errbuf));
r = xp_fail(line,
"%s expects -1,err#%d(%s) but -1,err#%d(%s)",
varname, exp, strerror(exp), actual_errno, errbuf);
}
}
return r;
}

/*
* REQUIRED_* return immediately if condition does not meet.
*/
#define REQUIRED_EQ(e, a) do { if (!XP_EQ(e, a)) return; } while (0)
#define REQUIRED_NE(e, a) do { if (!XP_NE(e, a)) return; } while (0)
#define REQUIRED_IF(expr) do { if (!XP_IF(expr)) return; } while (0)
#define REQUIRED_SYS_EQ(e, a) do { if (!XP_SYS_EQ(e, a)) return; } while (0)
#define REQUIRED_SYS_OK(a) do { if (!XP_SYS_OK(a)) return; } while (0)

static const char *openmode_str[] = {
"O_RDONLY",
"O_WRONLY",
"O_RDWR",
};

/*
* All system calls in following tests should be called with these macros.
*/

#define OPEN(name, mode) \
debug_open(__LINE__, name, mode)
int debug_open(int line, const char *name, int mode)
{
char modestr[32];
int n;

if ((mode & 3) != 3) {
n = snprintf(modestr, sizeof(modestr), "%s",
openmode_str[mode & 3]);
} else {
n = snprintf(modestr, sizeof(modestr), "%d", mode & 3);
}
if ((mode & O_NONBLOCK))
n += snprintf(modestr + n, sizeof(modestr) - n, "|O_NONBLOCK");

DPRINTFF(line, "open(\"%s\", %s)", name, modestr);
int r = rump_or_open(name, mode);
DRESULT(r);
}

#define WRITE(fd, addr, len) \
debug_write(__LINE__, fd, addr, len)
int debug_write(int line, int fd, const void *addr, size_t len)
{
DPRINTFF(line, "write(%d, %p, %zd)", fd, addr, len);
int r = rump_or_write(fd, addr, len);
DRESULT(r);
}

#define READ(fd, addr, len) \
debug_read(__LINE__, fd, addr, len)
int debug_read(int line, int fd, void *addr, size_t len)
{
DPRINTFF(line, "read(%d, %p, %zd)", fd, addr, len);
int r = rump_or_read(fd, addr, len);
DRESULT(r);
}

/*
* addrstr is the comment for debug message.
* int onoff = 0;
* ioctl(fd, SWITCH, onoff); -> IOCTL(fd, SWITCH, onoff, "off");
*/
#define IOCTL(fd, name, addr, addrfmt...) \
debug_ioctl(__LINE__, fd, name, #name, addr, addrfmt)
int debug_ioctl(int line, int fd, u_long name, const char *namestr,
void *addr, const char *addrfmt, ...)
{
char addrbuf[100];
va_list ap;

va_start(ap, addrfmt);
vsnprintf(addrbuf, sizeof(addrbuf), addrfmt, ap);
va_end(ap);
DPRINTFF(line, "ioctl(%d, %s, %s)", fd, namestr, addrbuf);
int r = rump_or_ioctl(fd, name, addr);
DRESULT(r);
}

#define FCNTL(fd, name...) \
debug_fcntl(__LINE__, fd, name, #name)
int debug_fcntl(int line, int fd, int name, const char *namestr, ...)
{
int r;

switch (name) {
case F_GETFL: /* no arguments */
DPRINTFF(line, "fcntl(%d, %s)", fd, namestr);
r = rump_or_fcntl(fd, name);
break;
default:
__unreachable();
}
DRESULT(r);
return r;
}

#define CLOSE(fd) \
debug_close(__LINE__, fd)
int debug_close(int line, int fd)
{
DPRINTFF(line, "close(%d)", fd);
int r = rump_or_close(fd);
DRESULT(r);
}

#define MMAP(ptr, len, prot, flags, fd, offset) \
debug_mmap(__LINE__, ptr, len, prot, flags, fd, offset)
void *debug_mmap(int line, void *ptr, size_t len, int prot, int flags, int fd,
off_t offset)
{
char protbuf[256];
char flagbuf[256];
int n;

#define ADDFLAG(buf, var, name) do { \
if (((var) & (name))) \
n = strlcat(buf, "|" #name, sizeof(buf)); \
(var) &= ~(name); \
} while (0)

n = 0;
protbuf[n] = '\0';
if (prot == 0) {
strlcpy(protbuf, "|PROT_NONE", sizeof(protbuf));
} else {
ADDFLAG(protbuf, prot, PROT_EXEC);
ADDFLAG(protbuf, prot, PROT_WRITE);
ADDFLAG(protbuf, prot, PROT_READ);
if (prot != 0) {
snprintf(protbuf + n, sizeof(protbuf) - n,
"|prot=0x%x", prot);
}
}

n = 0;
flagbuf[n] = '\0';
if (flags == 0) {
strlcpy(flagbuf, "|MAP_FILE", sizeof(flagbuf));
} else {
ADDFLAG(flagbuf, flags, MAP_SHARED);
ADDFLAG(flagbuf, flags, MAP_PRIVATE);
ADDFLAG(flagbuf, flags, MAP_FIXED);
ADDFLAG(flagbuf, flags, MAP_INHERIT);
ADDFLAG(flagbuf, flags, MAP_HASSEMAPHORE);
ADDFLAG(flagbuf, flags, MAP_TRYFIXED);
ADDFLAG(flagbuf, flags, MAP_WIRED);
ADDFLAG(flagbuf, flags, MAP_ANON);
if (flags != 0) {
n += snprintf(flagbuf + n, sizeof(flagbuf) - n,
"|flag=0x%x", flags);
}
}

DPRINTFF(line, "mmap(%p, %zd, %s, %s, %d, %jd)",
ptr, len, protbuf + 1, flagbuf + 1, fd, offset);
void *r = mmap(ptr, len, prot, flags, fd, offset);
DRESULT_PTR(r);
}

#define MUNMAP(ptr, len) \
debug_munmap(__LINE__, ptr, len)
int debug_munmap(int line, void *ptr, int len)
{
#if !defined(NO_RUMP)
if (use_rump)
xp_errx(1, __LINE__, "rump doesn't support munmap");
#endif
DPRINTFF(line, "munmap(%p, %d)", ptr, len);
int r = munmap(ptr, len);
DRESULT(r);
}

const char *
event_tostr(int events)
{
static char buf[64];

snprintb(buf, sizeof(buf),
"\177\020" \
"b\10WRBAND\0" \
"b\7RDBAND\0" "b\6RDNORM\0" "b\5NVAL\0" "b\4HUP\0" \
"b\3ERR\0" "b\2OUT\0" "b\1PRI\0" "b\0IN\0",
events);
return buf;
}

#define POLL(pfd, nfd, timeout) \
debug_poll(__LINE__, pfd, nfd, timeout)
int debug_poll(int line, struct pollfd *pfd, int nfd, int timeout)
{
char buf[256];
int n = 0;
buf[n] = '\0';
for (int i = 0; i < nfd; i++) {
n += snprintf(buf + n, sizeof(buf) - n, "{fd=%d,events=%s}",
pfd[i].fd, event_tostr(pfd[i].events));
}
DPRINTFF(line, "poll(%s, %d, %d)", buf, nfd, timeout);
int r = rump_or_poll(pfd, nfd, timeout);
DRESULT(r);
}

#define KQUEUE() \
debug_kqueue(__LINE__)
int debug_kqueue(int line)
{
DPRINTFF(line, "kqueue()");
int r = rump_or_kqueue();
DRESULT(r);
}

#define KEVENT_SET(kq, kev, nev) \
debug_kevent_set(__LINE__, kq, kev, nev)
int debug_kevent_set(int line, int kq, const struct kevent *kev, size_t nev)
{
DPRINTFF(line, "kevent_set(%d, %p, %zd)", kq, kev, nev);
int r = rump_or_kevent(kq, kev, nev, NULL, 0, NULL);
DRESULT(r);
}

#define KEVENT_POLL(kq, kev, nev, ts) \
debug_kevent_poll(__LINE__, kq, kev, nev, ts)
int debug_kevent_poll(int line, int kq, struct kevent *kev, size_t nev,
const struct timespec *ts)
{
char tsbuf[32];

if (ts == NULL) {
snprintf(tsbuf, sizeof(tsbuf), "NULL");
} else if (ts->tv_sec == 0 && ts->tv_nsec == 0) {
snprintf(tsbuf, sizeof(tsbuf), "0.0");
} else {
snprintf(tsbuf, sizeof(tsbuf), "%d.%09ld",
(int)ts->tv_sec, ts->tv_nsec);
}
DPRINTFF(line, "kevent_poll(%d, %p, %zd, %s)", kq, kev, nev, tsbuf);
int r = rump_or_kevent(kq, NULL, 0, kev, nev, ts);
DRESULT(r);
}

#define DEBUG_KEV(name, kev) \
debug_kev(__LINE__, name, kev)
void debug_kev(int line, const char *name, const struct kevent *kev)
{
char flagbuf[256];
const char *filterbuf;
uint32_t v;
int n;

n = 0;
flagbuf[n] = '\0';
if (kev->flags == 0) {
strcpy(flagbuf, "|0?");
} else {
v = kev->flags;
ADDFLAG(flagbuf, v, EV_ADD);
if (v != 0)
snprintf(flagbuf + n, sizeof(flagbuf)-n, "|0x%x", v);
}

switch (kev->filter) {
case EVFILT_READ: filterbuf = "EVFILT_READ"; break;
case EVFILT_WRITE: filterbuf = "EVFILT_WRITE"; break;
default: filterbuf = "EVFILT_?"; break;
}

DPRINTFF(line,
"%s={id:%d,%s,%s,fflags:0x%x,data:0x%" PRIx64 ",udata:0x%x}\n",
name,
(int)kev->ident,
flagbuf + 1,
filterbuf,
kev->fflags,
kev->data,
(int)(intptr_t)kev->udata);
}

/* XXX rump? */
#define GETUID() \
debug_getuid(__LINE__)
uid_t debug_getuid(int line)
{
DPRINTFF(line, "getuid");
uid_t r = getuid();
/* getuid() never fails */
DPRINTF(" = %u\n", r);
return r;
}

/* XXX rump? */
#define SETEUID(id) \
debug_seteuid(__LINE__, id)
int debug_seteuid(int line, uid_t id)
{
DPRINTFF(line, "seteuid(%d)", (int)id);
int r = seteuid(id);
DRESULT(r);
}

#define SYSCTLBYNAME(name, oldp, oldlenp, newp, newlen) \
debug_sysctlbyname(__LINE__, name, oldp, oldlenp, newp, newlen)
int debug_sysctlbyname(int line, const char *name, void *oldp, size_t *oldlenp,
const void *newp, size_t newlen)
{
DPRINTFF(line, "sysctlbyname(\"%s\")", name);
int r = sysctlbyname(name, oldp, oldlenp, newp, newlen);
DRESULT(r);
}

/* Return openable mode on this hardware property */
int
openable_mode(void)
{
if (hw_bidir())
return O_RDWR;
if (hw_canplay())
return O_WRONLY;
else
return O_RDONLY;
}

int mode2aumode_full[] = {
AUMODE_RECORD, /* O_RDONLY */
AUMODE_PLAY | AUMODE_PLAY_ALL, /* O_WRONLY */
AUMODE_PLAY | AUMODE_PLAY_ALL | AUMODE_RECORD, /* O_RDWR */
};

/* Convert openmode(O_*) to AUMODE_*, with hardware property */
int
mode2aumode(int mode)
{
int aumode;

aumode = mode2aumode_full[mode];
if (hw_canplay() == 0)
aumode &= ~(AUMODE_PLAY | AUMODE_PLAY_ALL);
if (hw_canrec() == 0)
aumode &= ~AUMODE_RECORD;

if (netbsd >= 9) {
/* half-duplex treats O_RDWR as O_WRONLY */
if (mode == O_RDWR && hw_bidir() && hw_fulldup() == 0)
aumode &= ~AUMODE_RECORD;
}

return aumode;
}

/* Is this mode + hardware playable? */
int
mode2play(int mode)
{
int aumode;

aumode = mode2aumode(mode);
return ((aumode & AUMODE_PLAY)) ? 1 : 0;
}

/* Is this mode + hardware recordable? */
int
mode2rec(int mode)
{
int aumode;

aumode = mode2aumode(mode);
return ((aumode & AUMODE_RECORD)) ? 1 : 0;
}

/*
* On NetBSD7, open() after-closing-mmap fails due to a bug.
* It happens once every two times like flip-flop, so the workaround is
* to open it again.
*/
void
reset_after_mmap(void)
{
int fd;

if (netbsd < 8) {
fd = OPEN(devaudio, O_WRONLY);
if (fd != -1)
CLOSE(fd);
}
}

/*
* Lookup "outputs.master" and return its mixer device index.
* It may not be strict but I'm not sure.
*/
int
mixer_get_outputs_master(int mixerfd)
{
const char * const typename[] = { "CLASS", "ENUM", "SET", "VALUE" };
mixer_devinfo_t di;
int class_outputs;
int i;
int r;

class_outputs = -1;
for (i = 0; ; i++) {
memset(&di, 0, sizeof(di));
di.index = i;
r = IOCTL(mixerfd, AUDIO_MIXER_DEVINFO, &di, "index=%d", i);
if (r < 0)
break;
DPRINTF(" > type=%s(%d) mixer_class=%d name=%s\n",
(0 <= di.type && di.type <= 3) ? typename[di.type] : "",
di.type, di.mixer_class, di.label.name);
if (di.type == AUDIO_MIXER_CLASS &&
strcmp(di.label.name, "outputs") == 0) {
class_outputs = di.mixer_class;
DPRINTF(" > class_output=%d\n", class_outputs);
continue;
}
if (di.type == AUDIO_MIXER_VALUE &&
di.mixer_class == class_outputs &&
strcmp(di.label.name, "master") == 0) {
return i;
}
}
/* Not found */
return -1;
}

/*
* Tests
*/

void test_open_mode(int);
void test_open(const char *, int);
void test_open_simul(int, int);
void try_open_multiuser(bool);
void test_open_multiuser(bool);
void test_rdwr_fallback(int, bool, bool);
void test_rdwr_two(int, int);
void test_mmap_mode(int, int);
void test_mmap_len(size_t, off_t, int);
void test_poll_mode(int, int, int);
void test_poll_in_open(const char *);
void test_kqueue_mode(int, int, int);
volatile int sigio_caught;
void signal_FIOASYNC(int);
void test_AUDIO_SETFD_xxONLY(int);
void test_AUDIO_SETINFO_mode(int, int, int, int);
void test_AUDIO_SETINFO_params_set(int, int, int);
void test_AUDIO_SETINFO_pause(int, int, int);
int getenc_make_table(int, int[][5]);
void xp_getenc(int[][5], int, int, int, struct audio_prinfo *);
void getenc_check_encodings(int, int[][5]);
void test_AUDIO_ERROR(int);
void test_AUDIO_GETIOFFS_one(int);
void test_AUDIO_GETOOFFS_one(int);
void test_AUDIO_GETOOFFS_wrap(int);
void test_AUDIO_GETOOFFS_flush(int);
void test_AUDIO_GETOOFFS_set(int);
void test_audioctl_open_1(int, int);
void test_audioctl_open_2(int, int);
void try_audioctl_open_multiuser(const char *, const char *);
void test_audioctl_open_multiuser(bool, const char *, const char *);
void test_audioctl_rw(int);

#define DEF(name) \
void test__ ## name (void); \
void test__ ## name (void)

/*
* Whether it can be open()ed with specified mode.
*/
void
test_open_mode(int mode)
{
int fd;
int r;

TEST("open_mode_%s", openmode_str[mode] + 2);

fd = OPEN(devaudio, mode);
if (mode2aumode(mode) != 0) {
XP_SYS_OK(fd);
} else {
XP_SYS_NG(ENXIO, fd);
}

if (fd >= 0) {
r = CLOSE(fd);
XP_SYS_EQ(0, r);
}
}
DEF(open_mode_RDONLY) { test_open_mode(O_RDONLY); }
DEF(open_mode_WRONLY) { test_open_mode(O_WRONLY); }
DEF(open_mode_RDWR) { test_open_mode(O_RDWR); }

/*
* Check the initial parameters and stickiness.
* /dev/audio
* The initial parameters are always the same whenever you open.
* /dev/sound and /dev/audioctl
* The initial parameters are inherited from the last /dev/sound or
* /dev/audio.
*/
void
test_open(const char *devname, int mode)
{
struct audio_info ai;
struct audio_info ai0;
char devfile[16];
int fd;
int r;
int can_play;
int can_rec;
int exp_mode;
int exp_encoding;
int exp_precision;
int exp_channels;
int exp_sample_rate;
int exp_pause;
int exp_popen;
int exp_ropen;

TEST("open_%s_%s", devname, openmode_str[mode] + 2);

snprintf(devfile, sizeof(devfile), "/dev/%s%d", devname, unit);
can_play = mode2play(mode);
can_rec = mode2rec(mode);
if (strcmp(devname, "audioctl") != 0) {
if (can_play + can_rec == 0) {
/* Check whether it cannot be opened */
fd = OPEN(devaudio, mode);
XP_SYS_NG(ENXIO, fd);
return;
}
}

/* /dev/audio is always initialized */
if (strcmp(devname, "audio") == 0) {
exp_encoding = AUDIO_ENCODING_ULAW;
exp_precision = 8;
exp_channels = 1;
exp_sample_rate = 8000;
exp_pause = 0;
} else {
exp_encoding = AUDIO_ENCODING_SLINEAR_LE;
exp_precision = 16;
exp_channels = 2;
exp_sample_rate = 11025;
exp_pause = 1;
}

/* /dev/audioctl is always "not opened" */
if (strcmp(devname, "audioctl") == 0) {
exp_mode = 0;
exp_popen = 0;
exp_ropen = 0;
} else {
exp_mode = mode2aumode(mode);
exp_popen = can_play;
exp_ropen = can_rec;
}

/*
* At first, initialize the sticky parameters both of play and rec.
* This uses /dev/audio to verify /dev/audio. It's not good way but
* I don't have better one...
*/
fd = OPEN(devaudio, openable_mode());
REQUIRED_SYS_OK(fd);
r = CLOSE(fd);
REQUIRED_SYS_EQ(0, r);

/*
* Open target device and check the initial parameters
* At this moment, all devices are initialized by default.
*/
fd = OPEN(devfile, mode);
REQUIRED_SYS_OK(fd);
memset(&ai, 0, sizeof(ai));
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);

XP_NE(0, ai.blocksize);
/* hiwat/lowat */
XP_EQ(exp_mode, ai.mode);
/* ai.play */
XP_EQ(8000, ai.play.sample_rate);
XP_EQ(1, ai.play.channels);
XP_EQ(8, ai.play.precision);
XP_EQ(AUDIO_ENCODING_ULAW, ai.play.encoding);
/* gain */
/* port */
XP_EQ(0, ai.play.seek);
/* avail_ports */
XP_NE(0, ai.play.buffer_size);
XP_EQ(0, ai.play.samples);
XP_EQ(0, ai.play.eof);
XP_EQ(0, ai.play.pause);
XP_EQ(0, ai.play.error);
XP_EQ(0, ai.play.waiting);
/* balance */
XP_EQ(exp_popen, ai.play.open);
XP_EQ(0, ai.play.active);
/* ai.record */
XP_EQ(8000, ai.record.sample_rate);
XP_EQ(1, ai.record.channels);
XP_EQ(8, ai.record.precision);
XP_EQ(AUDIO_ENCODING_ULAW, ai.record.encoding);
/* gain */
/* port */
XP_EQ(0, ai.record.seek);
/* avail_ports */
XP_NE(0, ai.record.buffer_size);
XP_EQ(0, ai.record.samples);
XP_EQ(0, ai.record.eof);
XP_EQ(0, ai.record.pause);
XP_EQ(0, ai.record.error);
XP_EQ(0, ai.record.waiting);
/* balance */
XP_EQ(exp_ropen, ai.record.open);
if (netbsd < 9 && strcmp(devname, "sound") == 0) {
/*
* On NetBSD7/8, it doesn't seem to start recording on open
* for /dev/sound. It should be a bug.
*/
XP_EQ(0, ai.record.active);
} else {
XP_EQ(exp_ropen, ai.record.active);
}
/* Save it */
ai0 = ai;

/*
* Change much as possible
*/
AUDIO_INITINFO(&ai);
ai.mode = ai0.mode ^ AUMODE_PLAY_ALL;
ai.play.sample_rate = 11025;
ai.play.channels = 2;
ai.play.precision = 16;
ai.play.encoding = AUDIO_ENCODING_SLINEAR_LE;
ai.play.pause = 1;
ai.record.sample_rate = 11025;
ai.record.channels = 2;
ai.record.precision = 16;
ai.record.encoding = AUDIO_ENCODING_SLINEAR_LE;
ai.record.pause = 1;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "ai");
REQUIRED_SYS_EQ(0, r);
r = CLOSE(fd);
REQUIRED_SYS_EQ(0, r);

/*
* Open the same target device again and check
*/
fd = OPEN(devfile, mode);
REQUIRED_SYS_OK(fd);
memset(&ai, 0, sizeof(ai));
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);

XP_NE(0, ai.blocksize);
/* hiwat/lowat */
if (netbsd < 8) {
/*
* On NetBSD7, the behavior when changing ai.mode on
* /dev/audioctl can not be explained yet but I won't
* verify it more over.
*/
} else {
/* On NetBSD9, changing mode never affects other fds */
XP_EQ(exp_mode, ai.mode);
}
/* ai.play */
XP_EQ(exp_sample_rate, ai.play.sample_rate);
XP_EQ(exp_channels, ai.play.channels);
XP_EQ(exp_precision, ai.play.precision);
XP_EQ(exp_encoding, ai.play.encoding);
/* gain */
/* port */
XP_EQ(0, ai.play.seek);
/* avail_ports */
XP_NE(0, ai.play.buffer_size);
XP_EQ(0, ai.play.samples);
XP_EQ(0, ai.play.eof);
XP_EQ(exp_pause, ai.play.pause);
XP_EQ(0, ai.play.error);
XP_EQ(0, ai.play.waiting);
/* balance */
XP_EQ(exp_popen, ai.play.open);
XP_EQ(0, ai.play.active);
/* ai.record */
XP_EQ(exp_sample_rate, ai.record.sample_rate);
XP_EQ(exp_channels, ai.record.channels);
XP_EQ(exp_precision, ai.record.precision);
XP_EQ(exp_encoding, ai.record.encoding);
/* gain */
/* port */
XP_EQ(0, ai.record.seek);
/* avail_ports */
XP_NE(0, ai.record.buffer_size);
XP_EQ(0, ai.record.samples);
XP_EQ(0, ai.record.eof);
XP_EQ(exp_pause, ai.record.pause);
XP_EQ(0, ai.record.error);
XP_EQ(0, ai.record.waiting);
/* balance */
XP_EQ(exp_ropen, ai.record.open);
if (netbsd < 9 && strcmp(devname, "sound") == 0) {
/*
* On NetBSD7/8, it doesn't seem to start recording on open
* for /dev/sound. It should be a bug.
*/
XP_EQ(0, ai.record.active);
} else {
XP_EQ(exp_ropen, ai.record.active);
}

r = CLOSE(fd);
REQUIRED_SYS_EQ(0, r);
}
DEF(open_audio_RDONLY) { test_open("audio", O_RDONLY); }
DEF(open_audio_WRONLY) { test_open("audio", O_WRONLY); }
DEF(open_audio_RDWR) { test_open("audio", O_RDWR); }
DEF(open_sound_RDONLY) { test_open("sound", O_RDONLY); }
DEF(open_sound_WRONLY) { test_open("sound", O_WRONLY); }
DEF(open_sound_RDWR) { test_open("sound", O_RDWR); }
DEF(open_audioctl_RDONLY) { test_open("audioctl", O_RDONLY); }
DEF(open_audioctl_WRONLY) { test_open("audioctl", O_WRONLY); }
DEF(open_audioctl_RDWR) { test_open("audioctl", O_RDWR); }

/*
* Open (1) /dev/sound -> (2) /dev/audio -> (3) /dev/sound,
* Both of /dev/audio and /dev/sound share the sticky parameters,
* /dev/sound inherits and use it but /dev/audio initialize and use it.
* So 2nd audio descriptor affects 3rd sound descriptor.
*/
DEF(open_sound_sticky)
{
struct audio_info ai;
int fd;
int r;
int openmode;

TEST("open_sound_sticky");

openmode = openable_mode();

/* First, open /dev/sound and change encoding as a delegate */
fd = OPEN(devsound, openmode);
REQUIRED_SYS_OK(fd);
AUDIO_INITINFO(&ai);
ai.play.encoding = AUDIO_ENCODING_SLINEAR_LE;
ai.record.encoding = AUDIO_ENCODING_SLINEAR_LE;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);
r = CLOSE(fd);
REQUIRED_SYS_EQ(0, r);

/* Next, open /dev/audio. It makes the encoding mulaw */
fd = OPEN(devaudio, openmode);
REQUIRED_SYS_OK(fd);
r = CLOSE(fd);
REQUIRED_SYS_EQ(0, r);

/* And then, open /dev/sound again */
fd = OPEN(devsound, openmode);
REQUIRED_SYS_OK(fd);
memset(&ai, 0, sizeof(ai));
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);
XP_EQ(AUDIO_ENCODING_ULAW, ai.play.encoding);
XP_EQ(AUDIO_ENCODING_ULAW, ai.record.encoding);
r = CLOSE(fd);
REQUIRED_SYS_EQ(0, r);
}

/*
* /dev/audioctl has stickiness like /dev/sound.
*/
DEF(open_audioctl_sticky)
{
struct audio_info ai;
int fd;
int r;
int openmode;

TEST("open_audioctl_sticky");

openmode = openable_mode();

/* First, open /dev/audio and change encoding */
fd = OPEN(devaudio, openmode);
REQUIRED_SYS_OK(fd);
AUDIO_INITINFO(&ai);
ai.play.encoding = AUDIO_ENCODING_SLINEAR_LE;
ai.play.precision = 16;
ai.record.encoding = AUDIO_ENCODING_SLINEAR_LE;
ai.record.precision = 16;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "SLINEAR_LE");
REQUIRED_SYS_EQ(0, r);
r = CLOSE(fd);
REQUIRED_SYS_EQ(0, r);

/* Next, open /dev/audioctl. It should be affected */
fd = OPEN(devaudioctl, openmode);
REQUIRED_SYS_OK(fd);
memset(&ai, 0, sizeof(ai));
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);
XP_EQ(AUDIO_ENCODING_SLINEAR_LE, ai.play.encoding);
XP_EQ(16, ai.play.precision);
XP_EQ(AUDIO_ENCODING_SLINEAR_LE, ai.record.encoding);
XP_EQ(16, ai.record.precision);

/* Then, change /dev/audioctl */
AUDIO_INITINFO(&ai);
ai.play.encoding = AUDIO_ENCODING_ULAW;
ai.play.precision = 8;
ai.record.encoding = AUDIO_ENCODING_ULAW;
ai.record.precision = 8;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "ULAW");
REQUIRED_SYS_EQ(0, r);
r = CLOSE(fd);
REQUIRED_SYS_EQ(0, r);

/* Finally, open /dev/sound. It also should be affected */
fd = OPEN(devsound, openmode);
REQUIRED_SYS_OK(fd);
memset(&ai, 0, sizeof(ai));
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);
XP_EQ(AUDIO_ENCODING_ULAW, ai.play.encoding);
XP_EQ(8, ai.play.precision);
XP_EQ(AUDIO_ENCODING_ULAW, ai.record.encoding);
XP_EQ(8, ai.record.precision);
r = CLOSE(fd);
REQUIRED_SYS_EQ(0, r);
}

/*
* Open two descriptors simultaneously.
*/
void
test_open_simul(int mode0, int mode1)
{
struct audio_info ai;
int fd0, fd1;
int i;
int r;
int actmode;
#define AUMODE_BOTH (AUMODE_PLAY | AUMODE_RECORD)
struct {
int mode0;
int mode1;
} expfulltable[] = {
/* expected fd0 expected fd1 (-errno expects error) */
{ AUMODE_RECORD, AUMODE_RECORD }, // REC, REC
{ AUMODE_RECORD, AUMODE_PLAY }, // REC, PLAY
{ AUMODE_RECORD, AUMODE_BOTH }, // REC, BOTH
{ AUMODE_PLAY, AUMODE_RECORD }, // PLAY, REC
{ AUMODE_PLAY, AUMODE_PLAY }, // PLAY, PLAY
{ AUMODE_PLAY, AUMODE_BOTH }, // PLAY, BOTH
{ AUMODE_BOTH, AUMODE_RECORD }, // BOTH, REC
{ AUMODE_BOTH, AUMODE_PLAY }, // BOTH, PLAY
{ AUMODE_BOTH, AUMODE_BOTH }, // BOTH, BOTH
},
exphalftable[] = {
/* expected fd0 expected fd1 (-errno expects error) */
{ AUMODE_RECORD, AUMODE_RECORD }, // REC, REC
{ AUMODE_RECORD, -ENODEV }, // REC, PLAY
{ AUMODE_RECORD, -ENODEV }, // REC, BOTH
{ AUMODE_PLAY, -ENODEV }, // PLAY, REC
{ AUMODE_PLAY, AUMODE_PLAY }, // PLAY, PLAY
{ AUMODE_PLAY, AUMODE_PLAY }, // PLAY, BOTH
{ AUMODE_PLAY, -ENODEV }, // BOTH, REC
{ AUMODE_PLAY, AUMODE_PLAY }, // BOTH, PLAY
{ AUMODE_PLAY, AUMODE_PLAY }, // BOTH, BOTH
}, *exptable;

/* The expected values are different in half-duplex or full-duplex */
if (hw_fulldup()) {
exptable = expfulltable;
} else {
exptable = exphalftable;
}

TEST("open_simul_%s_%s",
openmode_str[mode0] + 2,
openmode_str[mode1] + 2);

if (netbsd < 8) {
XP_SKIP("Multiple open is not supported");
return;
}

if (mode2aumode(mode0) == 0 || mode2aumode(mode1) == 0) {
XP_SKIP("Operation not allowed on this hardware property");
return;
}

i = mode0 * 3 + mode1;

/* Open first one */
fd0 = OPEN(devaudio, mode0);
REQUIRED_SYS_OK(fd0);
r = IOCTL(fd0, AUDIO_GETBUFINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);
actmode = ai.mode & AUMODE_BOTH;
XP_EQ(exptable[i].mode0, actmode);

/* Open second one */
fd1 = OPEN(devaudio, mode1);
if (exptable[i].mode1 >= 0) {
/* Case to expect to be able to open */
REQUIRED_SYS_OK(fd1);
r = IOCTL(fd1, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
if (r == 0) {
actmode = ai.mode & AUMODE_BOTH;
XP_EQ(exptable[i].mode1, actmode);
}
} else {
/* Case to expect not to be able to open */
XP_SYS_NG(ENODEV, fd1);
if (fd1 == -1) {
XP_EQ(-exptable[i].mode1, errno);
} else {
r = IOCTL(fd1, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
if (r == 0) {
actmode = ai.mode & AUMODE_BOTH;
XP_FAIL("expects error but %d", actmode);
}
}
}

if (fd1 >= 0) {
r = CLOSE(fd1);
XP_SYS_EQ(0, r);
}

r = CLOSE(fd0);
XP_SYS_EQ(0, r);
}
DEF(open_simul_RDONLY_RDONLY) { test_open_simul(O_RDONLY, O_RDONLY); }
DEF(open_simul_RDONLY_WRONLY) { test_open_simul(O_RDONLY, O_WRONLY); }
DEF(open_simul_RDONLY_RDWR) { test_open_simul(O_RDONLY, O_RDWR); }
DEF(open_simul_WRONLY_RDONLY) { test_open_simul(O_WRONLY, O_RDONLY); }
DEF(open_simul_WRONLY_WRONLY) { test_open_simul(O_WRONLY, O_WRONLY); }
DEF(open_simul_WRONLY_RDWR) { test_open_simul(O_WRONLY, O_RDWR); }
DEF(open_simul_RDWR_RDONLY) { test_open_simul(O_RDWR, O_RDONLY); }
DEF(open_simul_RDWR_WRONLY) { test_open_simul(O_RDWR, O_WRONLY); }
DEF(open_simul_RDWR_RDWR) { test_open_simul(O_RDWR, O_RDWR); }

/*
* /dev/audio can be opened by other user who opens /dev/audio.
*/
void
try_open_multiuser(bool multiuser)
{
int fd0;
int fd1;
int r;
uid_t ouid;

/*
* Test1: Open as root first and then unprivileged user.
*/

/* At first, open as root */
fd0 = OPEN(devaudio, openable_mode());
REQUIRED_SYS_OK(fd0);

ouid = GETUID();
r = SETEUID(1);
REQUIRED_SYS_EQ(0, r);

/* Then, open as unprivileged user */
fd1 = OPEN(devaudio, openable_mode());
if (multiuser) {
/* If multiuser, another user also can open */
XP_SYS_OK(fd1);
} else {
/* If not multiuser, another user cannot open */
XP_SYS_NG(EPERM, fd1);
}
if (fd1 != -1) {
r = CLOSE(fd1);
XP_SYS_EQ(0, r);
}

r = SETEUID(ouid);
REQUIRED_SYS_EQ(0, r);

r = CLOSE(fd0);
XP_SYS_EQ(0, r);

/*
* Test2: Open as unprivileged user first and then root.
*/

/* At first, open as unprivileged user */
ouid = GETUID();
r = SETEUID(1);
REQUIRED_SYS_EQ(0, r);

fd0 = OPEN(devaudio, openable_mode());
REQUIRED_SYS_OK(fd0);

/* Then open as root */
r = SETEUID(ouid);
REQUIRED_SYS_EQ(0, r);

/* root always can open */
fd1 = OPEN(devaudio, openable_mode());
XP_SYS_OK(fd1);
if (fd1 != -1) {
r = CLOSE(fd1);
XP_SYS_EQ(0, r);
}

/* Close first one as unprivileged user */
r = SETEUID(1);
REQUIRED_SYS_EQ(0, r);
r = CLOSE(fd0);
XP_SYS_EQ(0, r);
r = SETEUID(ouid);
REQUIRED_SYS_EQ(0, r);
}
/*
* This is a wrapper for open_multiuser.
* XXX XP_* macros are not compatible with on-error-goto, we need try-catch...
*/
void
test_open_multiuser(bool multiuser)
{
char mibname[32];
bool oldval;
size_t oldlen;
int r;

TEST("open_multiuser_%d", multiuser);
if (netbsd < 8) {
XP_SKIP("Multiple open is not supported");
return;
}
if (netbsd < 9) {
/* NetBSD8 has no way (difficult) to determine device name */
XP_SKIP("NetBSD8 cannot determine device name");
return;
}
if (geteuid() != 0) {
XP_SKIP("Must be run as a privileged user");
return;
}

/* Get current multiuser mode (and save it) */
snprintf(mibname, sizeof(mibname), "hw.%s.multiuser", devicename);
oldlen = sizeof(oldval);
r = SYSCTLBYNAME(mibname, &oldval, &oldlen, NULL, 0);
REQUIRED_SYS_EQ(0, r);
DPRINTF(" > multiuser=%d\n", oldval);

/* Change if necessary */
if (oldval != multiuser) {
r = SYSCTLBYNAME(mibname, NULL, NULL, &multiuser,
sizeof(multiuser));
REQUIRED_SYS_EQ(0, r);
DPRINTF(" > new multiuser=%d\n", multiuser);
}

/* Do test */
try_open_multiuser(multiuser);

/* Restore multiuser mode */
if (oldval != multiuser) {
DPRINTF(" > restore multiuser to %d\n", oldval);
r = SYSCTLBYNAME(mibname, NULL, NULL, &oldval, sizeof(oldval));
REQUIRED_SYS_EQ(0, r);
}
}
DEF(open_multiuser_0) { test_open_multiuser(false); }
DEF(open_multiuser_1) { test_open_multiuser(true); }

/*
* Normal playback (with PLAY_ALL).
* It does not verify real playback data.
*/
DEF(write_PLAY_ALL)
{
char buf[8000];
int fd;
int r;

TEST("write_PLAY_ALL");

fd = OPEN(devaudio, O_WRONLY);
if (hw_canplay()) {
REQUIRED_SYS_OK(fd);
} else {
XP_SYS_NG(ENXIO, fd);
return;
}

/* mulaw 1sec silence */
memset(buf, 0xff, sizeof(buf));
r = WRITE(fd, buf, sizeof(buf));
XP_SYS_EQ(sizeof(buf), r);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}

/*
* Normal playback (without PLAY_ALL).
* It does not verify real playback data.
*/
DEF(write_PLAY)
{
struct audio_info ai;
char *wav;
int wavsize;
int totalsize;
int fd;
int r;

TEST("write_PLAY");

fd = OPEN(devaudio, O_WRONLY);
if (hw_canplay()) {
REQUIRED_SYS_OK(fd);
} else {
XP_SYS_NG(ENXIO, fd);
return;
}

/* Drop PLAY_ALL */
AUDIO_INITINFO(&ai);
ai.mode = AUMODE_PLAY;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "mode");
REQUIRED_SYS_EQ(0, r);

/* Check mode and get blocksize */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);
XP_EQ(AUMODE_PLAY, ai.mode);

wavsize = ai.blocksize;
wav = (char *)malloc(wavsize);
REQUIRED_IF(wav != NULL);
memset(wav, 0xff, wavsize);

/* Write blocks until 1sec */
for (totalsize = 0; totalsize < 8000; ) {
r = WRITE(fd, wav, wavsize);
XP_SYS_EQ(wavsize, r);
if (r == -1)
break; /* XXX */
totalsize += r;
}

/* XXX What should I test it? */
/* Check ai.play.error */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);
XP_EQ(0, ai.play.error);

/* Playback data is no longer necessary */
r = IOCTL(fd, AUDIO_FLUSH, NULL, "");
REQUIRED_SYS_EQ(0, r);

r = CLOSE(fd);
REQUIRED_SYS_EQ(0, r);

free(wav);
}

/*
* Normal recording.
* It does not verify real recorded data.
*/
DEF(read)
{
char buf[8000];
int fd;
int r;

TEST("read");

fd = OPEN(devaudio, O_RDONLY);
if (hw_canrec()) {
REQUIRED_SYS_OK(fd);
} else {
XP_SYS_NG(ENXIO, fd);
return;
}

/* mulaw 1sec */
r = READ(fd, buf, sizeof(buf));
XP_SYS_EQ(sizeof(buf), r);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}

/*
* Repeat open-write-close cycle.
*/
DEF(rept_write)
{
struct timeval start, end, result;
double res;
char buf[8000]; /* 1sec in 8bit-mulaw,1ch,8000Hz */
int fd;
int r;
int n;

TEST("rept_write");

if (hw_canplay() == 0) {
XP_SKIP("This test is only for playable device");
return;
}

/* XXX It may timeout on some hardware driver. */
XP_SKIP("not yet");
return;

memset(buf, 0xff, sizeof(buf));
n = 3;
gettimeofday(&start, NULL);
for (int i = 0; i < n; i++) {
fd = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(fd);

r = WRITE(fd, buf, sizeof(buf));
XP_SYS_EQ(sizeof(buf), r);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}
gettimeofday(&end, NULL);
timersub(&end, &start, &result);
res = (double)result.tv_sec + (double)result.tv_usec / 1000000;
/* Make judgement but not too strict */
if (res >= n * 1.5) {
XP_FAIL("expects %d sec but %4.1f sec", n, res);
return;
}
}

/*
* Repeat open-read-close cycle.
*/
DEF(rept_read)
{
struct timeval start, end, result;
double res;
char buf[8000]; /* 1sec in 8bit-mulaw,1ch,8000Hz */
int fd;
int r;
int n;

TEST("rept_read");

if (hw_canrec() == 0) {
XP_SKIP("This test is only for recordable device");
return;
}

/* XXX It may timeout on some hardware driver. */
XP_SKIP("not yet");
return;

n = 3;
gettimeofday(&start, NULL);
for (int i = 0; i < n; i++) {
fd = OPEN(devaudio, O_RDONLY);
REQUIRED_SYS_OK(fd);

r = READ(fd, buf, sizeof(buf));
XP_SYS_EQ(sizeof(buf), r);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}
gettimeofday(&end, NULL);
timersub(&end, &start, &result);
res = (double)result.tv_sec + (double)result.tv_usec / 1000000;
/* Make judgement but not too strict */
if (res >= n * 1.5) {
XP_FAIL("expects %d sec but %4.1f sec", n, res);
return;
}
}

/*
* Opening with O_RDWR on half-duplex hardware falls back to O_WRONLY.
* expwrite: expected to be able to play.
* expread : expected to be able to record.
*/
void
test_rdwr_fallback(int openmode, bool expwrite, bool expread)
{
struct audio_info ai;
char buf[10];
int fd;
int r;

TEST("rdwr_fallback_%s", openmode_str[openmode] + 2);

if (hw_bidir() == 0) {
XP_SKIP("This test is only for bi-directional device");
return;
}

AUDIO_INITINFO(&ai);
ai.play.pause = 1;
ai.record.pause = 1;

fd = OPEN(devaudio, openmode);
REQUIRED_SYS_OK(fd);

/* Set pause not to play noise */
r = IOCTL(fd, AUDIO_SETINFO, &ai, "pause");
REQUIRED_SYS_EQ(0, r);

memset(buf, 0xff, sizeof(buf));
r = WRITE(fd, buf, sizeof(buf));
if (expwrite) {
XP_SYS_EQ(sizeof(buf), r);
} else {
XP_SYS_NG(EBADF, r);
}

r = READ(fd, buf, 0);
if (expread) {
XP_SYS_EQ(0, r);
} else {
XP_SYS_NG(EBADF, r);
}

r = CLOSE(fd);
REQUIRED_SYS_EQ(0, r);
}
DEF(rdwr_fallback_RDONLY) { test_rdwr_fallback(O_RDONLY, false, true); }
DEF(rdwr_fallback_WRONLY) { test_rdwr_fallback(O_WRONLY, true, false); }
DEF(rdwr_fallback_RDWR) {
bool expread;
/*
* On NetBSD7, O_RDWR on half-duplex is accepted. It's possible to
* read and write if they don't occur at the same time.
* On NetBSD9, O_RDWR on half-duplex falls back O_WRONLY.
*/
if (netbsd < 8) {
expread = true;
} else {
expread = hw_fulldup() ? true : false;
}
test_rdwr_fallback(O_RDWR, true, expread);
}

/*
* On full-duplex hardware, the second descriptor's readability/writability
* does not depend on the first descriptor's open mode.
* On half-duplex hardware, it depends on the first descriptor's open mode.
*/
void
test_rdwr_two(int mode0, int mode1)
{
struct audio_info ai;
char wbuf[100]; /* 1/80sec in 8bit-mulaw,1ch,8000Hz */
char rbuf[100]; /* 1/80sec in 8bit-mulaw,1ch,8000Hz */
bool canopen;
bool canwrite;
bool canread;
int fd0;
int fd1;
int r;
struct {
bool canopen;
bool canwrite;
bool canread;
} exptable_full[] = {
/* open write read 1st, 2nd mode */
{ 1, 0, 1 }, /* REC, REC */
{ 1, 1, 0 }, /* REC, PLAY */
{ 1, 1, 1 }, /* REC, BOTH */
{ 1, 0, 1 }, /* PLAY, REC */
{ 1, 1, 0 }, /* PLAY, PLAY */
{ 1, 1, 1 }, /* PLAY, BOTH */
{ 1, 0, 1 }, /* BOTH, REC */
{ 1, 1, 0 }, /* BOTH, PLAY */
{ 1, 1, 1 }, /* BOTH, BOTH */
},
exptable_half[] = {
{ 1, 0, 1 }, /* REC, REC */
{ 0, 0, 0 }, /* REC, PLAY */
{ 0, 0, 0 }, /* REC, BOTH */
{ 0, 0, 0 }, /* PLAY, REC */
{ 1, 1, 0 }, /* PLAY, PLAY */
{ 1, 1, 0 }, /* PLAY, BOTH */
{ 0, 0, 0 }, /* BOTH, REC */
{ 1, 1, 0 }, /* BOTH, PLAY */
{ 0, 0, 0 }, /* BOTH, BOTH */
}, *exptable;

TEST("rdwr_two_%s_%s",
openmode_str[mode0] + 2,
openmode_str[mode1] + 2);

if (netbsd < 8) {
XP_SKIP("Multiple open is not supported");
return;
}
if (hw_bidir() == 0) {
XP_SKIP("This test is only for bi-directional device");
return;
}

exptable = hw_fulldup() ? exptable_full : exptable_half;

canopen = exptable[mode0 * 3 + mode1].canopen;
canwrite = exptable[mode0 * 3 + mode1].canwrite;
canread = exptable[mode0 * 3 + mode1].canread;

if (!canopen) {
XP_SKIP("This combination is not openable on half-duplex");
return;
}

fd0 = OPEN(devaudio, mode0);
REQUIRED_SYS_OK(fd0);

fd1 = OPEN(devaudio, mode1);
REQUIRED_SYS_OK(fd1);

/* Silent data to make no sound */
memset(&wbuf, 0xff, sizeof(wbuf));
/* Pause to make no sound */
AUDIO_INITINFO(&ai);
ai.play.pause = 1;
r = IOCTL(fd0, AUDIO_SETINFO, &ai, "pause");
XP_SYS_EQ(0, r);

/* write(fd1) */
r = WRITE(fd1, wbuf, sizeof(wbuf));
if (canwrite) {
XP_SYS_EQ(100, r);
} else {
XP_SYS_NG(EBADF, r);
}

/* read(fd1) */
r = READ(fd1, rbuf, sizeof(rbuf));
if (canread) {
XP_SYS_EQ(100, r);
} else {
XP_SYS_NG(EBADF, r);
}

r = CLOSE(fd0);
XP_SYS_EQ(0, r);
r = CLOSE(fd1);
XP_SYS_EQ(0, r);
}
DEF(rdwr_two_RDONLY_RDONLY) { test_rdwr_two(O_RDONLY, O_RDONLY); }
DEF(rdwr_two_RDONLY_WRONLY) { test_rdwr_two(O_RDONLY, O_WRONLY); }
DEF(rdwr_two_RDONLY_RDWR) { test_rdwr_two(O_RDONLY, O_RDWR); }
DEF(rdwr_two_WRONLY_RDONLY) { test_rdwr_two(O_WRONLY, O_RDONLY); }
DEF(rdwr_two_WRONLY_WRONLY) { test_rdwr_two(O_WRONLY, O_WRONLY); }
DEF(rdwr_two_WRONLY_RDWR) { test_rdwr_two(O_WRONLY, O_RDWR); }
DEF(rdwr_two_RDWR_RDONLY) { test_rdwr_two(O_RDWR, O_RDONLY); }
DEF(rdwr_two_RDWR_WRONLY) { test_rdwr_two(O_RDWR, O_WRONLY); }
DEF(rdwr_two_RDWR_RDWR) { test_rdwr_two(O_RDWR, O_RDWR); }

/*
* Read and write different descriptors simultaneously.
* Only on full-duplex.
*/
DEF(rdwr_simul)
{
char wbuf[1000]; /* 1/8sec in mulaw,1ch,8kHz */
char rbuf[1000];
int fd0;
int fd1;
int r;
int status;
pid_t pid;

TEST("rdwr_simul");
if (netbsd < 8) {
XP_SKIP("Multiple open is not supported");
return;
}
if (!hw_fulldup()) {
XP_SKIP("This test is only for full-duplex device");
return;
}

/* Silence data to make no sound */
memset(wbuf, 0xff, sizeof(wbuf));

fd0 = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(fd0);
fd1 = OPEN(devaudio, O_RDONLY);
REQUIRED_SYS_OK(fd1);

fflush(stdout);
fflush(stderr);
pid = fork();
if (pid == -1)
xp_err(1, __LINE__, "fork");

if (pid == 0) {
/* child (read) */
for (int i = 0; i < 10; i++) {
r = READ(fd1, rbuf, sizeof(rbuf));
if (r == -1)
xp_err(1, __LINE__, "read(i=%d)", i);
}
exit(0);
} else {
/* parent (write) */
for (int i = 0; i < 10; i++) {
r = WRITE(fd0, wbuf, sizeof(wbuf));
if (r == -1)
xp_err(1, __LINE__, "write(i=%d)", i);
}
waitpid(pid, &status, 0);
}

CLOSE(fd0);
CLOSE(fd1);
/* If you reach here, consider as success */
XP_EQ(0, 0);
}

/*
* DRAIN should work even on incomplete data left.
*/
DEF(drain_incomplete)
{
struct audio_info ai;
int r;
int fd;

TEST("drain_incomplete");

if (hw_canplay() == 0) {
XP_SKIP("This test is only for playable device");
return;
}

fd = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(fd);

AUDIO_INITINFO(&ai);
/* let precision > 8 */
ai.play.encoding = AUDIO_ENCODING_SLINEAR_LE;
ai.play.precision = 16;
ai.mode = AUMODE_PLAY;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);
/* Write one byte and then close */
r = WRITE(fd, &r, 1);
XP_SYS_EQ(1, r);
r = CLOSE(fd);
XP_SYS_EQ(0, r);
}

/*
* DRAIN should work even in pause.
*/
DEF(drain_pause)
{
struct audio_info ai;
int r;
int fd;

TEST("drain_pause");

if (hw_canplay() == 0) {
XP_SKIP("This test is only for playable device");
return;
}

fd = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(fd);

/* Set pause */
AUDIO_INITINFO(&ai);
ai.play.pause = 1;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "");
XP_SYS_EQ(0, r);
/* Write some data and then close */
r = WRITE(fd, &r, 4);
XP_SYS_EQ(4, r);
r = CLOSE(fd);
XP_SYS_EQ(0, r);
}

/*
* DRAIN does not affect for record-only descriptor.
*/
DEF(drain_onrec)
{
int fd;
int r;

TEST("drain_onrec");

if (hw_canrec() == 0) {
XP_SKIP("This test is only for recordable device");
return;
}

fd = OPEN(devaudio, O_RDONLY);
REQUIRED_SYS_OK(fd);

r = IOCTL(fd, AUDIO_DRAIN, NULL, "");
XP_SYS_EQ(0, r);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}

/*
* Whether mmap() succeeds with specified parameter.
*/
void
test_mmap_mode(int mode, int prot)
{
char buf[10];
struct audio_info ai;
const char *protstr;
int expected;
int fd;
int r;
int len;
void *ptr;

if (prot == PROT_NONE) {
protstr = "NONE";
} else if (prot == PROT_READ) {
protstr = "READ";
} else if (prot == PROT_WRITE) {
protstr = "WRITE";
} else if (prot == (PROT_READ | PROT_WRITE)) {
protstr = "READWRITE";
} else {
xp_errx(1, __LINE__, "unknown prot %x\n", prot);
}
TEST("mmap_%s_%s", openmode_str[mode] + 2, protstr);
if ((props & AUDIO_PROP_MMAP) == 0) {
XP_SKIP("This test is only for mmap-able device");
return;
}
if (mode2aumode(mode) == 0) {
XP_SKIP("Operation not allowed on this hardware property");
return;
}
#if !defined(NO_RUMP)
if (use_rump) {
XP_SKIP("rump doesn't support mmap");
return;
}
#endif

/*
* On NetBSD7 and 8, mmap() always succeeds regardless of open mode.
* On NetBSD9, mmap() succeeds only for writable descriptor.
*/
expected = mode2play(mode);
if (netbsd < 9) {
expected = true;
}

fd = OPEN(devaudio, mode);
REQUIRED_SYS_OK(fd);

r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "get");
REQUIRED_SYS_EQ(0, r);

len = ai.play.buffer_size;

/* Make it pause */
AUDIO_INITINFO(&ai);
ai.play.pause = 1;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "pause");
REQUIRED_SYS_EQ(0, r);

ptr = MMAP(NULL, len, prot, MAP_FILE, fd, 0);
XP_SYS_PTR(expected ? 0 : EACCES, ptr);
if (expected) {
/* XXX Doing mmap(2) doesn't inhibit read(2) */
if (mode2rec(mode)) {
r = READ(fd, buf, 0);
XP_SYS_EQ(0, r);
}
/* Doing mmap(2) inhibits write(2) */
if (mode2play(mode)) {
/* NetBSD9 changes errno */
r = WRITE(fd, buf, 0);
if (netbsd < 9) {
XP_SYS_NG(EINVAL, r);
} else {
XP_SYS_NG(EPERM, r);
}
}
}
if (ptr != MAP_FAILED) {
r = MUNMAP(ptr, len);
XP_SYS_EQ(0, r);
}

/* Whether the pause is still valid */
if (mode2play(mode)) {
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
XP_EQ(1, ai.play.pause);
}

r = CLOSE(fd);
XP_SYS_EQ(0, r);

reset_after_mmap();
}
#define PROT_READWRITE (PROT_READ | PROT_WRITE)
DEF(mmap_mode_RDONLY_NONE) { test_mmap_mode(O_RDONLY, PROT_NONE); }
DEF(mmap_mode_RDONLY_READ) { test_mmap_mode(O_RDONLY, PROT_READ); }
DEF(mmap_mode_RDONLY_WRITE) { test_mmap_mode(O_RDONLY, PROT_WRITE); }
DEF(mmap_mode_RDONLY_READWRITE) { test_mmap_mode(O_RDONLY, PROT_READWRITE); }
DEF(mmap_mode_WRONLY_NONE) { test_mmap_mode(O_WRONLY, PROT_NONE); }
DEF(mmap_mode_WRONLY_READ) { test_mmap_mode(O_WRONLY, PROT_READ); }
DEF(mmap_mode_WRONLY_WRITE) { test_mmap_mode(O_WRONLY, PROT_WRITE); }
DEF(mmap_mode_WRONLY_READWRITE) { test_mmap_mode(O_WRONLY, PROT_READWRITE); }
DEF(mmap_mode_RDWR_NONE) { test_mmap_mode(O_RDWR, PROT_NONE); }
DEF(mmap_mode_RDWR_READ) { test_mmap_mode(O_RDWR, PROT_READ); }
DEF(mmap_mode_RDWR_WRITE) { test_mmap_mode(O_RDWR, PROT_WRITE); }
DEF(mmap_mode_RDWR_READWRITE) { test_mmap_mode(O_RDWR, PROT_READWRITE); }

/*
* Check mmap()'s length and offset.
*
* Actual len and offset cannot be determined before open. So that,
* pass pre-defined constant as argument, and convert it after open.
*/
#define LS (100) /* lsize */
#define LS1 (101) /* lsize + 1 */
void
test_mmap_len(size_t len, off_t offset, int exp)
{
struct audio_info ai;
int fd;
int r;
size_t plen;
void *ptr;
int bufsize;
int pagesize;
int lsize;

TEST("mmap_len(%zd, %jd, %d)", len, offset, exp);
if ((props & AUDIO_PROP_MMAP) == 0) {
XP_SKIP("This test is only for mmap-able device");
return;
}
#if !defined(NO_RUMP)
if (use_rump) {
XP_SKIP("rump doesn't support mmap");
return;
}
#endif

plen = sizeof(pagesize);
r = SYSCTLBYNAME("hw.pagesize", &pagesize, &plen, NULL, 0);
REQUIRED_SYS_EQ(0, r);

fd = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(r);

/* Get buffer_size */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);
bufsize = ai.play.buffer_size;

/*
* XXX someone refers bufsize and another one does pagesize.
* I'm not sure.
*/
lsize = roundup2(bufsize, pagesize);

/* Here, lsize can be assigned */
if (len == LS) {
len = lsize;
} else if (len == LS1) {
len = lsize + 1;
}
if (offset == LS) {
offset = lsize;
} else if (offset == LS1) {
offset = lsize + 1;
}

ptr = MMAP(NULL, len, PROT_WRITE, MAP_FILE, fd, offset);
if (exp == 0) {
XP_SYS_PTR(0, ptr);
} else {
/* NetBSD8 introduces EOVERFLOW */
if (netbsd < 8 && exp == EOVERFLOW)
exp = EINVAL;
XP_SYS_PTR(exp, ptr);
}

if (ptr != MAP_FAILED) {
r = MUNMAP(ptr, len);
XP_SYS_EQ(0, r);
}

r = CLOSE(fd);
XP_SYS_EQ(0, r);

reset_after_mmap();
}
#define f(l, o, e) test_mmap_len(l, o, e)
DEF(mmap_len_0) { f(0, 0, EINVAL); } /* len is 0 */
DEF(mmap_len_1) { f(1, 0, 0); } /* len is smaller than lsize */
DEF(mmap_len_2) { f(LS, 0, 0); } /* len is the same as lsize */
DEF(mmap_len_3) { f(LS1, 0, EOVERFLOW); } /* len is larger */
DEF(mmap_len_4) { f(0, -1, EINVAL); } /* offset is negative */
DEF(mmap_len_5) { f(0, LS, EINVAL); } /* len is 0 */
DEF(mmap_len_6) { f(0, LS1, EINVAL); } /* len is 0 */
DEF(mmap_len_7) { f(1, LS, EOVERFLOW); } /* exceed */
/*
* When you treat the offset as 32bit, offset will be 0 and thus it
* incorrectly succeeds.
*/
DEF(mmap_len_8) { f(LS, 1ULL << 32, EOVERFLOW); }
#undef f

/*
* mmap() the same descriptor twice.
*/
DEF(mmap_twice)
{
struct audio_info ai;
int fd;
int r;
int len;
void *ptr1;
void *ptr2;

TEST("mmap_twice");
if ((props & AUDIO_PROP_MMAP) == 0) {
XP_SKIP("This test is only for mmap-able device");
return;
}
#if !defined(NO_RUMP)
if (use_rump) {
XP_SKIP("rump doesn't support mmap");
return;
}
#endif

fd = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(fd);

r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "get");
REQUIRED_SYS_EQ(0, r);
len = ai.play.buffer_size;

ptr1 = MMAP(NULL, len, PROT_WRITE, MAP_FILE, fd, 0);
XP_SYS_PTR(0, ptr1);

/* XXX I'm not sure this sucess is intended. Anyway I follow it */
ptr2 = MMAP(NULL, len, PROT_WRITE, MAP_FILE, fd, 0);
XP_SYS_PTR(0, ptr2);

if (ptr2 != MAP_FAILED) {
r = MUNMAP(ptr2, len);
XP_SYS_EQ(0, r);
}
if (ptr1 != MAP_FAILED) {
r = MUNMAP(ptr1, len);
XP_SYS_EQ(0, r);
}

r = CLOSE(fd);
XP_SYS_EQ(0, r);

reset_after_mmap();
}

/*
* mmap() different descriptors.
*/
DEF(mmap_multi)
{
struct audio_info ai;
int fd0;
int fd1;
int r;
int len;
void *ptr0;
void *ptr1;

TEST("mmap_multi");
if (netbsd < 8) {
XP_SKIP("Multiple open is not supported");
return;
}
if ((props & AUDIO_PROP_MMAP) == 0) {
XP_SKIP("This test is only for mmap-able device");
return;
}
#if !defined(NO_RUMP)
if (use_rump) {
XP_SKIP("rump doesn't support mmap");
return;
}
#endif

fd0 = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(fd0);

r = IOCTL(fd0, AUDIO_GETBUFINFO, &ai, "get");
REQUIRED_SYS_EQ(0, r);
len = ai.play.buffer_size;

fd1 = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(fd1);

ptr0 = MMAP(NULL, len, PROT_WRITE, MAP_FILE, fd0, 0);
XP_SYS_PTR(0, ptr0);

ptr1 = MMAP(NULL, len, PROT_WRITE, MAP_FILE, fd1, 0);
XP_SYS_PTR(0, ptr1);

if (ptr0 != MAP_FAILED) {
r = MUNMAP(ptr1, len);
XP_SYS_EQ(0, r);
}

r = CLOSE(fd1);
XP_SYS_EQ(0, r);

if (ptr1 != MAP_FAILED) {
r = MUNMAP(ptr0, len);
XP_SYS_EQ(0, r);
}

r = CLOSE(fd0);
XP_SYS_EQ(0, r);

reset_after_mmap();
}

#define IN POLLIN
#define OUT POLLOUT
/*
* Whether poll() succeeds with specified mode.
*/
void
test_poll_mode(int mode, int events, int expected_revents)
{
struct pollfd pfd;
const char *events_str;
int fd;
int r;
int expected_r;

if (events == IN) {
events_str = "IN";
} else if (events == OUT) {
events_str = "OUT";
} else if (events == (IN | OUT)) {
events_str = "INOUT";
} else {
events_str = "?";
}
TEST("poll_mode_%s_%s", openmode_str[mode] + 2, events_str);
if (mode2aumode(mode) == 0) {
XP_SKIP("Operation not allowed on this hardware property");
return;
}

expected_r = (expected_revents != 0) ? 1 : 0;

fd = OPEN(devaudio, mode);
REQUIRED_SYS_OK(fd);

/* Wait a bit to be recorded. */
usleep(100 * 1000);

memset(&pfd, 0, sizeof(pfd));
pfd.fd = fd;
pfd.events = events;

r = POLL(&pfd, 1, 100);
/* It's a bit complicated.. */
if (r < 0 || r > 1) {
/*
* Check these two cases first:
* - system call fails.
* - poll() with one nfds returns >1. It's strange.
*/
XP_SYS_EQ(expected_r, r);
} else {
/*
* Otherwise, poll() returned 0 or 1.
*/
DPRINTF(" > pfd.revents=%s\n", event_tostr(pfd.revents));

/* NetBSD7,8 have several strange behavior. It must be bug. */

XP_SYS_EQ(expected_r, r);
XP_EQ(expected_revents, pfd.revents);
}
r = CLOSE(fd);
XP_SYS_EQ(0, r);
}
DEF(poll_mode_RDONLY_IN) { test_poll_mode(O_RDONLY, IN, IN); }
DEF(poll_mode_RDONLY_OUT) { test_poll_mode(O_RDONLY, OUT, 0); }
DEF(poll_mode_RDONLY_INOUT) { test_poll_mode(O_RDONLY, IN|OUT, IN); }
DEF(poll_mode_WRONLY_IN) { test_poll_mode(O_WRONLY, IN, 0); }
DEF(poll_mode_WRONLY_OUT) { test_poll_mode(O_WRONLY, OUT, OUT); }
DEF(poll_mode_WRONLY_INOUT) { test_poll_mode(O_WRONLY, IN|OUT, OUT); }
DEF(poll_mode_RDWR_IN) {
/* On half-duplex, O_RDWR is the same as O_WRONLY. */
if (hw_fulldup()) test_poll_mode(O_RDWR, IN, IN);
else test_poll_mode(O_RDWR, IN, 0);
}
DEF(poll_mode_RDWR_OUT) { test_poll_mode(O_RDWR, OUT, OUT); }
DEF(poll_mode_RDWR_INOUT) {
/* On half-duplex, O_RDWR is the same as O_WRONLY. */
if (hw_fulldup()) test_poll_mode(O_RDWR, IN|OUT, IN|OUT);
else test_poll_mode(O_RDWR, IN|OUT, OUT);
}

/*
* Poll(OUT) when buffer is empty.
*/
DEF(poll_out_empty)
{
struct pollfd pfd;
int fd;
int r;

TEST("poll_out_empty");

fd = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(fd);

memset(&pfd, 0, sizeof(pfd));
pfd.fd = fd;
pfd.events = POLLOUT;

/* Check when empty. It should succeed even if timeout == 0 */
r = POLL(&pfd, 1, 0);
XP_SYS_EQ(1, r);
XP_EQ(POLLOUT, pfd.revents);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}

/*
* Poll(OUT) when buffer is full.
*/
DEF(poll_out_full)
{
struct audio_info ai;
struct pollfd pfd;
int fd;
int r;
char *buf;
int buflen;

TEST("poll_out_full");

fd = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
REQUIRED_SYS_OK(fd);

/* Pause */
AUDIO_INITINFO(&ai);
ai.play.pause = 1;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "");
XP_SYS_EQ(0, r);

/* Get buffer size */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);

/* Write until full */
buflen = ai.play.buffer_size;
buf = (char *)malloc(buflen);
REQUIRED_IF(buf != NULL);
memset(buf, 0xff, buflen);
do {
r = WRITE(fd, buf, buflen);
} while (r == buflen);
if (r == -1) {
XP_SYS_NG(EAGAIN, r);
}

/* Do poll */
memset(&pfd, 0, sizeof(pfd));
pfd.fd = fd;
pfd.events = POLLOUT;
r = POLL(&pfd, 1, 0);
XP_SYS_EQ(0, r);
XP_EQ(0, pfd.revents);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
free(buf);
}

/*
* Poll(OUT) when buffer is full but hiwat sets lower than full.
*/
DEF(poll_out_hiwat)
{
struct audio_info ai;
struct pollfd pfd;
int fd;
int r;
char *buf;
int buflen;
int newhiwat;

TEST("poll_out_hiwat");

fd = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
REQUIRED_SYS_OK(fd);

/* Get buffer size and hiwat */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
/* Change hiwat some different value */
newhiwat = ai.lowat;

/* Set pause and hiwat */
AUDIO_INITINFO(&ai);
ai.play.pause = 1;
ai.hiwat = newhiwat;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "pause=1;hiwat");
XP_SYS_EQ(0, r);

/* Get the set hiwat again */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);

/* Write until full */
buflen = ai.blocksize * ai.hiwat;
buf = (char *)malloc(buflen);
REQUIRED_IF(buf != NULL);
memset(buf, 0xff, buflen);
do {
r = WRITE(fd, buf, buflen);
} while (r == buflen);
if (r == -1) {
XP_SYS_NG(EAGAIN, r);
}

/* Do poll */
memset(&pfd, 0, sizeof(pfd));
pfd.fd = fd;
pfd.events = POLLOUT;
r = POLL(&pfd, 1, 0);
XP_SYS_EQ(0, r);
XP_EQ(0, pfd.revents);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
free(buf);
}

/*
* Unpause from buffer full, POLLOUT should raise.
* XXX poll(2) on NetBSD7 is really incomplete and weird. I don't test it.
*/
DEF(poll_out_unpause)
{
struct audio_info ai;
struct pollfd pfd;
int fd;
int r;
char *buf;
int buflen;
u_int blocksize;
int hiwat;
int lowat;

TEST("poll_out_unpause");
if (netbsd < 8) {
XP_SKIP("NetBSD7's poll() is too incomplete to test.");
return;
}

/* Non-blocking open */
fd = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
REQUIRED_SYS_OK(fd);

/* Adjust block size and hiwat/lowat to make the test time 1sec */
blocksize = 1000; /* 1/8 sec in mulaw,1ch,8000Hz */
hiwat = 12; /* 1.5sec */
lowat = 4; /* 0.5sec */
AUDIO_INITINFO(&ai);
ai.blocksize = blocksize;
ai.hiwat = hiwat;
ai.lowat = lowat;
/* and also set encoding */
/*
* XXX NetBSD7 has different results depending on whether the input
* encoding is emulated (AUDIO_ENCODINGFLAG_EMULATED) or not. It's
* not easy to ensure this situation on all hardware environment.
* On NetBSD9, the result is the same regardless of input encoding.
*/
r = IOCTL(fd, AUDIO_SETINFO, &ai, "blocksize=%d", blocksize);
XP_SYS_EQ(0, r);
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
if (ai.blocksize != blocksize) {
/*
* NetBSD9 can not change the blocksize. Then,
* adjust using hiwat/lowat.
*/
blocksize = ai.blocksize;
hiwat = howmany(8000 * 1.5, blocksize);
lowat = howmany(8000 * 0.5, blocksize);
}
/* Anyway, set the parameters */
AUDIO_INITINFO(&ai);
ai.blocksize = blocksize;
ai.hiwat = hiwat;
ai.lowat = lowat;
ai.play.pause = 1;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "pause=1");
XP_SYS_EQ(0, r);

/* Get the set parameters again */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);

/* Write until full */
buflen = ai.blocksize * ai.hiwat;
buf = (char *)malloc(buflen);
REQUIRED_IF(buf != NULL);
memset(buf, 0xff, buflen);
do {
r = WRITE(fd, buf, buflen);
} while (r == buflen);
if (r == -1) {
XP_SYS_NG(EAGAIN, r);
}

/* At this time, POLLOUT should not be set because buffer is full */
memset(&pfd, 0, sizeof(pfd));
pfd.fd = fd;
pfd.events = POLLOUT;
r = POLL(&pfd, 1, 0);
XP_SYS_EQ(0, r);
XP_EQ(0, pfd.revents);

/* Unpause */
AUDIO_INITINFO(&ai);
ai.play.pause = 0;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "pause=0");
XP_SYS_EQ(0, r);

/*
* When unpause occurs:
* - NetBSD7 (emul=0) -> the buffer remains.
* - NetBSD7 (emul=1) -> the buffer is cleared.
* - NetBSD8 -> the buffer remains.
* - NetBSD9 -> the buffer remains.
*/

/* Check poll() up to 2sec */
pfd.revents = 0;
r = POLL(&pfd, 1, 2000);
XP_SYS_EQ(1, r);
XP_EQ(POLLOUT, pfd.revents);

/*
* Since POLLOUT is set, it should be writable.
* But at this time, no all buffer may be writable.
*/
r = WRITE(fd, buf, buflen);
XP_SYS_OK(r);

/* Flush it because there is no need to play it */
r = IOCTL(fd, AUDIO_FLUSH, NULL, "");
XP_SYS_EQ(0, r);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
free(buf);
}

/*
* poll(2) must not be affected by playback of other descriptors.
*/
DEF(poll_out_simul)
{
struct audio_info ai;
struct pollfd pfd[2];
int fd[2];
int r;
char *buf;
u_int blocksize;
int hiwat;
int lowat;
int buflen;
int time;

TEST("poll_out_simul");
if (netbsd < 8) {
XP_SKIP("Multiple open is not supported");
return;
}

/* Make sure that it's not affected by descriptor order */
for (int i = 0; i < 2; i++) {
int a = i;
int b = 1 - i;

fd[0] = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
REQUIRED_SYS_OK(fd[0]);
fd[1] = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
REQUIRED_SYS_OK(fd[1]);

/*
* Adjust block size and hiwat/lowat.
* I want to choice suitable blocksize (if possible).
*/
blocksize = 1000; /* 1/8 sec in mulaw,1ch,8000Hz */
hiwat = 12; /* 1.5sec */
lowat = 4; /* 0.5sec */
AUDIO_INITINFO(&ai);
ai.blocksize = blocksize;
ai.hiwat = hiwat;
ai.lowat = lowat;
r = IOCTL(fd[0], AUDIO_SETINFO, &ai, "blocksize=1000");
XP_SYS_EQ(0, r);
r = IOCTL(fd[0], AUDIO_GETBUFINFO, &ai, "read back blocksize");
if (ai.blocksize != blocksize) {
/*
* NetBSD9 can not change the blocksize. Then,
* adjust using hiwat/lowat.
*/
blocksize = ai.blocksize;
hiwat = howmany(8000 * 1.5, blocksize);
lowat = howmany(8000 * 0.5, blocksize);
}
/* Anyway, set the parameters */
AUDIO_INITINFO(&ai);
ai.blocksize = blocksize;
ai.hiwat = hiwat;
ai.lowat = lowat;
/* Pause fdA */
ai.play.pause = 1;
r = IOCTL(fd[a], AUDIO_SETINFO, &ai, "pause=1");
XP_SYS_EQ(0, r);
/* Unpause fdB */
ai.play.pause = 0;
r = IOCTL(fd[b], AUDIO_SETINFO, &ai, "pause=0");
XP_SYS_EQ(0, r);

/* Get again. XXX two individual ioctls are correct */
r = IOCTL(fd[0], AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
DPRINTF(" > blocksize=%d lowat=%d hiwat=%d\n",
ai.blocksize, ai.lowat, ai.hiwat);

/* Enough long time than the playback time */
time = (ai.hiwat - ai.lowat) * blocksize / 8; /*[msec]*/
time *= 2;

/* Write fdA full */
buflen = blocksize * ai.lowat;
buf = (char *)malloc(buflen);
REQUIRED_IF(buf != NULL);
memset(buf, 0xff, buflen);
do {
r = WRITE(fd[a], buf, buflen);
} while (r == buflen);
if (r == -1) {
XP_SYS_NG(EAGAIN, r);
}

/* POLLOUT should not be set, because fdA is buffer full */
memset(pfd, 0, sizeof(pfd));
pfd[0].fd = fd[a];
pfd[0].events = POLLOUT;
r = POLL(pfd, 1, 0);
XP_SYS_EQ(0, r);
XP_EQ(0, pfd[0].revents);

/* Write fdB at least lowat */
r = WRITE(fd[b], buf, buflen);
XP_SYS_EQ(buflen, r);
r = WRITE(fd[b], buf, buflen);
if (r == -1) {
XP_SYS_NG(EAGAIN, r);
}

/* Only fdB should become POLLOUT */
memset(pfd, 0, sizeof(pfd));
pfd[0].fd = fd[0];
pfd[0].events = POLLOUT;
pfd[1].fd = fd[1];
pfd[1].events = POLLOUT;
r = POLL(pfd, 2, time);
XP_SYS_EQ(1, r);
if (r != -1) {
XP_EQ(0, pfd[a].revents);
XP_EQ(POLLOUT, pfd[b].revents);
}

/* Drop the rest */
r = IOCTL(fd[0], AUDIO_FLUSH, NULL, "");
XP_SYS_EQ(0, r);
r = IOCTL(fd[1], AUDIO_FLUSH, NULL, "");
XP_SYS_EQ(0, r);

r = CLOSE(fd[0]);
XP_SYS_EQ(0, r);
r = CLOSE(fd[1]);
XP_SYS_EQ(0, r);
free(buf);

xxx_close_wait();
}
}

/*
* Open with READ mode starts recording immediately.
* Of course, audioctl doesn't start.
*/
void
test_poll_in_open(const char *devname)
{
struct audio_info ai;
struct pollfd pfd;
char buf[4096];
char devfile[16];
int fd;
int r;
bool is_audioctl;

TEST("poll_in_open_%s", devname);
if (hw_canrec() == 0) {
XP_SKIP("This test is only for recordable device");
return;
}

snprintf(devfile, sizeof(devfile), "/dev/%s%d", devname, unit);
is_audioctl = (strcmp(devname, "audioctl") == 0);

fd = OPEN(devfile, O_RDONLY);
REQUIRED_SYS_OK(fd);

r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);
if (is_audioctl) {
/* opening /dev/audioctl doesn't start recording. */
XP_EQ(0, ai.record.active);
} else {
/* opening /dev/{audio,sound} starts recording. */
/*
* On NetBSD7/8, opening /dev/sound doesn't start recording.
* It must be a bug.
*/
XP_EQ(1, ai.record.active);
}

memset(&pfd, 0, sizeof(pfd));
pfd.fd = fd;
pfd.events = POLLIN;
r = POLL(&pfd, 1, 1000);
if (is_audioctl) {
/*
* poll-ing /dev/audioctl always fails.
* XXX Returning error instead of timeout should be better(?).
*/
REQUIRED_SYS_EQ(0, r);
} else {
/*
* poll-ing /dev/{audio,sound} will succeed when recorded
* data is arrived.
*/
/*
* On NetBSD7/8, opening /dev/sound doesn't start recording.
* It must be a bug.
*/
REQUIRED_SYS_EQ(1, r);

/* In this case, read() should succeed. */
r = READ(fd, buf, sizeof(buf));
XP_SYS_OK(r);
XP_NE(0, r);
}

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}
DEF(poll_in_open_audio) { test_poll_in_open("audio"); }
DEF(poll_in_open_sound) { test_poll_in_open("sound"); }
DEF(poll_in_open_audioctl) { test_poll_in_open("audioctl"); }

/*
* poll(2) must not be affected by other recording descriptors even if
* playback descriptor waits with POLLIN (though it's not normal usage).
* In other words, two POLLIN must not interfere.
*/
DEF(poll_in_simul)
{
struct audio_info ai;
struct pollfd pfd;
int fd[2];
int r;
char *buf;
int blocksize;

TEST("poll_in_simul");
if (netbsd < 8) {
XP_SKIP("Multiple open is not supported");
return;
}
if (hw_fulldup() == 0) {
XP_SKIP("This test is only for full-duplex device");
return;
}

int play = 0;
int rec = 1;

fd[play] = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
REQUIRED_SYS_OK(fd[play]);
fd[rec] = OPEN(devaudio, O_RDONLY);
REQUIRED_SYS_OK(fd[rec]);

/* Get block size */
r = IOCTL(fd[rec], AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
blocksize = ai.blocksize;

buf = (char *)malloc(blocksize);
REQUIRED_IF(buf != NULL);

/*
* At first, make sure the playback one doesn't return POLLIN.
*/
memset(&pfd, 0, sizeof(pfd));
pfd.fd = fd[play];
pfd.events = POLLIN;
r = POLL(&pfd, 1, 0);
if (r == 0 && pfd.revents == 0) {
XP_SYS_EQ(0, r);
XP_EQ(0, pfd.revents);
} else {
XP_FAIL("play fd returns POLLIN");
goto abort;
}

/* Start recording */
r = READ(fd[rec], buf, blocksize);
XP_SYS_EQ(blocksize, r);

/* Poll()ing playback descriptor with POLLIN should not raise */
r = POLL(&pfd, 1, 1000);
XP_SYS_EQ(0, r);
XP_EQ(0, pfd.revents);

/* Poll()ing recording descriptor with POLLIN should raise */
pfd.fd = fd[rec];
r = POLL(&pfd, 1, 0);
XP_SYS_EQ(1, r);
XP_EQ(POLLIN, pfd.revents);

abort:
r = CLOSE(fd[play]);
XP_SYS_EQ(0, r);
r = CLOSE(fd[rec]);
XP_SYS_EQ(0, r);
free(buf);
}

/*
* Whether kqueue() succeeds with specified mode.
*/
void
test_kqueue_mode(int openmode, int filt, int expected)
{
struct kevent kev;
struct timespec ts;
int fd;
int kq;
int r;

TEST("kqueue_mode_%s_%s",
openmode_str[openmode] + 2,
(filt == EVFILT_READ) ? "READ" : "WRITE");
if (mode2aumode(openmode) == 0) {
XP_SKIP("Operation not allowed on this hardware property");
return;
}

ts.tv_sec = 0;
ts.tv_nsec = 100 * 1000 * 1000; // 100msec

kq = KQUEUE();
XP_SYS_OK(kq);

fd = OPEN(devaudio, openmode);
REQUIRED_SYS_OK(fd);

/*
* Check whether the specified filter can be set.
* Any filters can always be set, even if pointless combination.
* For example, EVFILT_READ can be set on O_WRONLY descriptor
* though it will never raise.
* I will not mention about good or bad of this behavior here.
*/
EV_SET(&kev, fd, filt, EV_ADD, 0, 0, 0);
r = KEVENT_SET(kq, &kev, 1);
XP_SYS_EQ(0, r);

if (r == 0) {
/* If the filter can be set, try kevent(poll) */
r = KEVENT_POLL(kq, &kev, 1, &ts);
XP_SYS_EQ(expected, r);

/* Delete it */
EV_SET(&kev, fd, filt, EV_DELETE, 0, 0, 0);
r = KEVENT_SET(kq, &kev, 1);
XP_SYS_EQ(0, r);
}

r = CLOSE(fd);
XP_SYS_EQ(0, r);
r = CLOSE(kq);
XP_SYS_EQ(0, r);
}
DEF(kqueue_mode_RDONLY_READ) {
/* Should raise */
test_kqueue_mode(O_RDONLY, EVFILT_READ, 1);
}
DEF(kqueue_mode_RDONLY_WRITE) {
/* Should never raise (NetBSD7 has bugs) */
int expected = (netbsd < 8) ? 1 : 0;
test_kqueue_mode(O_RDONLY, EVFILT_WRITE, expected);
}
DEF(kqueue_mode_WRONLY_READ) {
/* Should never raise */
test_kqueue_mode(O_WRONLY, EVFILT_READ, 0);
}
DEF(kqueue_mode_WRONLY_WRITE) {
/* Should raise */
test_kqueue_mode(O_WRONLY, EVFILT_WRITE, 1);
}
DEF(kqueue_mode_RDWR_READ) {
/* Should raise on fulldup but not on halfdup, on NetBSD9 */
int expected = hw_fulldup() ? 1 : 0;
test_kqueue_mode(O_RDWR, EVFILT_READ, expected);
}
DEF(kqueue_mode_RDWR_WRITE) {
/* Should raise */
test_kqueue_mode(O_RDWR, EVFILT_WRITE, 1);
}

/*
* kqueue(2) when buffer is empty.
*/
DEF(kqueue_empty)
{
struct audio_info ai;
struct kevent kev;
struct timespec ts;
int kq;
int fd;
int r;

TEST("kqueue_empty");

fd = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(fd);

r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);

kq = KQUEUE();
XP_SYS_OK(kq);

EV_SET(&kev, fd, EV_ADD, EVFILT_WRITE, 0, 0, 0);
r = KEVENT_SET(kq, &kev, 1);
XP_SYS_EQ(0, r);

/* When the buffer is empty, it should succeed even if timeout == 0 */
memset(&ts, 0, sizeof(ts));
r = KEVENT_POLL(kq, &kev, 1, &ts);
XP_SYS_EQ(1, r);
XP_EQ(fd, kev.ident);
/*
* XXX According to kqueue(2) manpage, returned kev.data contains
* "the amount of space remaining in the write buffer".
* NetBSD7 returns buffer_size. Shouldn't it be blocksize * hiwat?
*/
/* XP_EQ(ai.blocksize * ai.hiwat, kev.data); */
XP_EQ(ai.play.buffer_size, kev.data);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
r = CLOSE(kq);
XP_SYS_EQ(0, r);
}

/*
* kqueue(2) when buffer is full.
*/
DEF(kqueue_full)
{
struct audio_info ai;
struct kevent kev;
struct timespec ts;
int kq;
int fd;
int r;
char *buf;
int buflen;

TEST("kqueue_full");

fd = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
REQUIRED_SYS_OK(fd);

/* Pause */
AUDIO_INITINFO(&ai);
ai.play.pause = 1;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "");
XP_SYS_EQ(0, r);

/* Get buffer size */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);

/* Write until full */
buflen = ai.play.buffer_size;
buf = (char *)malloc(buflen);
REQUIRED_IF(buf != NULL);
memset(buf, 0xff, buflen);
do {
r = WRITE(fd, buf, buflen);
} while (r == buflen);
if (r == -1) {
XP_SYS_NG(EAGAIN, r);
}

kq = KQUEUE();
XP_SYS_OK(kq);

EV_SET(&kev, fd, EV_ADD, EVFILT_WRITE, 0, 0, 0);
r = KEVENT_SET(kq, &kev, 1);
XP_SYS_EQ(0, r);

/* kevent() should not raise */
ts.tv_sec = 0;
ts.tv_nsec = 100L * 1000 * 1000; /* 100msec */
r = KEVENT_POLL(kq, &kev, 1, &ts);
XP_SYS_EQ(0, r);
if (r > 0) {
XP_EQ(fd, kev.ident);
XP_EQ(0, kev.data);
}

r = CLOSE(fd);
XP_SYS_EQ(0, r);
r = CLOSE(kq);
XP_SYS_EQ(0, r);
free(buf);
}

/*
* kqueue(2) when buffer is full but hiwat sets lower than full.
*/
DEF(kqueue_hiwat)
{
struct audio_info ai;
struct kevent kev;
struct timespec ts;
int kq;
int fd;
int r;
char *buf;
int buflen;
int newhiwat;

TEST("kqueue_hiwat");

fd = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
REQUIRED_SYS_OK(fd);

/* Get buffer size and hiwat */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "hiwat");
XP_SYS_EQ(0, r);
/* Change hiwat some different value */
newhiwat = ai.hiwat - 1;

/* Set pause and hiwat */
AUDIO_INITINFO(&ai);
ai.play.pause = 1;
ai.hiwat = newhiwat;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "pause=1;hiwat");
XP_SYS_EQ(0, r);

/* Get the set parameters again */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
XP_EQ(1, ai.play.pause);
XP_EQ(newhiwat, ai.hiwat);

/* Write until full */
buflen = ai.blocksize * ai.hiwat;
buf = (char *)malloc(buflen);
REQUIRED_IF(buf != NULL);
memset(buf, 0xff, buflen);
do {
r = WRITE(fd, buf, buflen);
} while (r == buflen);
if (r == -1) {
XP_SYS_NG(EAGAIN, r);
}

kq = KQUEUE();
XP_SYS_OK(kq);

EV_SET(&kev, fd, EV_ADD, EVFILT_WRITE, 0, 0, 0);
r = KEVENT_SET(kq, &kev, 1);
XP_SYS_EQ(0, r);

/* Should not raise because it's not possible to write */
ts.tv_sec = 0;
ts.tv_nsec = 100L * 1000 * 1000; /* 100msec */
r = KEVENT_POLL(kq, &kev, 1, &ts);
if (r > 0)
DEBUG_KEV("kev", &kev);
XP_SYS_EQ(0, r);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
r = CLOSE(kq);
XP_SYS_EQ(0, r);
free(buf);
}

/*
* Unpause from buffer full, kevent() should raise.
*/
DEF(kqueue_unpause)
{
struct audio_info ai;
struct kevent kev;
struct timespec ts;
int fd;
int r;
int kq;
char *buf;
int buflen;
u_int blocksize;
int hiwat;
int lowat;

TEST("kqueue_unpause");

/* Non-blocking open */
fd = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
REQUIRED_SYS_OK(fd);

/* Adjust block size and hiwat/lowat to make the test time 1sec */
blocksize = 1000; /* 1/8 sec in mulaw,1ch,8000Hz */
hiwat = 12; /* 1.5sec */
lowat = 4; /* 0.5sec */
AUDIO_INITINFO(&ai);
ai.blocksize = blocksize;
ai.hiwat = hiwat;
ai.lowat = lowat;
/* and also set encoding */
/*
* XXX NetBSD7 has different results depending on whether the input
* encoding is emulated (AUDIO_ENCODINGFLAG_EMULATED) or not. It's
* not easy to ensure this situation on all hardware environment.
* On NetBSD9, the result is the same regardless of input encoding.
*/
r = IOCTL(fd, AUDIO_SETINFO, &ai, "blocksize=%d", blocksize);
XP_SYS_EQ(0, r);
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
if (ai.blocksize != blocksize) {
/*
* NetBSD9 can not change the blocksize. Then,
* adjust using hiwat/lowat.
*/
blocksize = ai.blocksize;
hiwat = howmany(8000 * 1.5, blocksize);
lowat = howmany(8000 * 0.5, blocksize);
}
/* Anyway, set the parameters */
AUDIO_INITINFO(&ai);
ai.blocksize = blocksize;
ai.hiwat = hiwat;
ai.lowat = lowat;
ai.play.pause = 1;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "pause=1");
XP_SYS_EQ(0, r);

/* Get the set parameters again */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
DPRINTF(" > blocksize=%d hiwat=%d lowat=%d buffer_size=%d\n",
ai.blocksize, ai.hiwat, ai.lowat, ai.play.buffer_size);

/* Write until full */
buflen = ai.blocksize * ai.hiwat;
buf = (char *)malloc(buflen);
REQUIRED_IF(buf != NULL);
memset(buf, 0xff, buflen);
do {
r = WRITE(fd, buf, buflen);
} while (r == buflen);
if (r == -1) {
XP_SYS_NG(EAGAIN, r);
}

kq = KQUEUE();
XP_SYS_OK(kq);

EV_SET(&kev, fd, EV_ADD, EVFILT_WRITE, 0, 0, 0);
r = KEVENT_SET(kq, &kev, 1);
XP_SYS_EQ(0, r);

/* Unpause */
AUDIO_INITINFO(&ai);
ai.play.pause = 0;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "pause=0");
XP_SYS_EQ(0, r);

/* Check kevent() up to 2sec */
ts.tv_sec = 2;
ts.tv_nsec = 0;
r = KEVENT_POLL(kq, &kev, 1, &ts);
if (r >= 1)
DEBUG_KEV("kev", &kev);
if (netbsd < 8) {
/*
* NetBSD7 with EMULATED_FLAG unset has bugs. Unpausing
* unintentionally clears buffer (and therefore it becomes
* writable) but it doesn't raise EVFILT_WRITE.
*/
} else {
XP_SYS_EQ(1, r);
}

/* Flush it because there is no need to play it */
r = IOCTL(fd, AUDIO_FLUSH, NULL, "");
XP_SYS_EQ(0, r);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
r = CLOSE(kq);
XP_SYS_EQ(0, r);
free(buf);
}

/*
* kevent(2) must not be affected by other audio descriptors.
*/
DEF(kqueue_simul)
{
struct audio_info ai;
struct audio_info ai2;
struct kevent kev[2];
struct timespec ts;
int fd[2];
int r;
int kq;
u_int blocksize;
int hiwat;
int lowat;
char *buf;
int buflen;

TEST("kqueue_simul");
if (netbsd < 8) {
XP_SKIP("Multiple open is not supported");
return;
}

memset(&ts, 0, sizeof(ts));

/* Make sure that it's not affected by descriptor order */
for (int i = 0; i < 2; i++) {
int a = i;
int b = 1 - i;

fd[0] = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
REQUIRED_SYS_OK(fd[0]);
fd[1] = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
REQUIRED_SYS_OK(fd[1]);

/*
* Adjust block size and hiwat/lowat.
* I want to choice suitable blocksize (if possible).
*/
blocksize = 1000; /* 1/8 sec in mulaw,1ch,8000Hz */
hiwat = 12; /* 1.5sec */
lowat = 4; /* 0.5sec */
AUDIO_INITINFO(&ai);
ai.blocksize = blocksize;
ai.hiwat = hiwat;
ai.lowat = lowat;
r = IOCTL(fd[0], AUDIO_SETINFO, &ai, "blocksize=1000");
XP_SYS_EQ(0, r);
r = IOCTL(fd[0], AUDIO_GETBUFINFO, &ai, "read back blocksize");
if (ai.blocksize != blocksize) {
/*
* NetBSD9 can not change the blocksize. Then,
* adjust using hiwat/lowat.
*/
blocksize = ai.blocksize;
hiwat = howmany(8000 * 1.5, blocksize);
lowat = howmany(8000 * 0.5, blocksize);
}
/* Anyway, set the parameters to both */
AUDIO_INITINFO(&ai);
ai.blocksize = blocksize;
ai.hiwat = hiwat;
ai.lowat = lowat;
ai.play.pause = 1;
r = IOCTL(fd[a], AUDIO_SETINFO, &ai, "pause=1");
XP_SYS_EQ(0, r);
r = IOCTL(fd[b], AUDIO_SETINFO, &ai, "pause=1");
XP_SYS_EQ(0, r);

/* Write both until full */
buflen = ai.blocksize * ai.hiwat;
buf = (char *)malloc(buflen);
REQUIRED_IF(buf != NULL);
memset(buf, 0xff, buflen);
/* Write fdA */
do {
r = WRITE(fd[a], buf, buflen);
} while (r == buflen);
if (r == -1) {
XP_SYS_NG(EAGAIN, r);
}
/* Write fdB */
do {
r = WRITE(fd[b], buf, buflen);
} while (r == buflen);
if (r == -1) {
XP_SYS_NG(EAGAIN, r);
}

/* Get fdB's initial seek for later */
r = IOCTL(fd[b], AUDIO_GETBUFINFO, &ai2, "");
XP_SYS_EQ(0, r);

kq = KQUEUE();
XP_SYS_OK(kq);

/* Both aren't raised at this point */
EV_SET(&kev[0], fd[a], EV_ADD, EVFILT_WRITE, 0, 0, 0);
EV_SET(&kev[1], fd[b], EV_ADD, EVFILT_WRITE, 0, 0, 0);
r = KEVENT_SET(kq, kev, 2);
XP_SYS_EQ(0, r);

/* Unpause only fdA */
AUDIO_INITINFO(&ai);
ai.play.pause = 0;
r = IOCTL(fd[a], AUDIO_SETINFO, &ai, "pause=0");
XP_SYS_EQ(0, r);

/* kevent() up to 2sec */
ts.tv_sec = 2;
ts.tv_nsec = 0;
r = KEVENT_POLL(kq, &kev[0], 1, &ts);
if (r >= 1)
DEBUG_KEV("kev", &kev[0]);
/* fdA should raise */
XP_SYS_EQ(1, r);
XP_EQ(fd[a], kev[0].ident);

/* Make sure that fdB keeps whole data */
r = IOCTL(fd[b], AUDIO_GETBUFINFO, &ai, "");
XP_EQ(ai2.play.seek, ai.play.seek);

/* Flush it because there is no need to play it */
r = IOCTL(fd[0], AUDIO_FLUSH, NULL, "");
XP_SYS_EQ(0, r);
r = IOCTL(fd[1], AUDIO_FLUSH, NULL, "");
XP_SYS_EQ(0, r);

r = CLOSE(fd[0]);
XP_SYS_EQ(0, r);
r = CLOSE(fd[1]);
XP_SYS_EQ(0, r);
r = CLOSE(kq);
XP_SYS_EQ(0, r);
free(buf);

xxx_close_wait();
}
}

/* Shared data between threads for ioctl_while_write */
struct ioctl_while_write_data {
int fd;
struct timeval start;
int terminated;
};

/* Test thread for ioctl_while_write */
void *thread_ioctl_while_write(void *);
void *
thread_ioctl_while_write(void *arg)
{
struct ioctl_while_write_data *data = arg;
struct timeval now, res;
struct audio_info ai;
int r;

/* If 0.5 seconds have elapsed since writing, assume it's blocked */
do {
usleep(100);
gettimeofday(&now, NULL);
timersub(&now, &data->start, &res);
} while (res.tv_usec < 500000);

/* Then, do ioctl() */
r = IOCTL(data->fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);

/* Terminate */
data->terminated = 1;

/* Resume write() by unpause */
AUDIO_INITINFO(&ai);
if (netbsd < 8) {
/*
* XXX NetBSD7 has bugs and it cannot be unpaused.
* However, it also has another bug and it clears buffer
* when encoding is changed. I use it. :-P
*/
ai.play.encoding = AUDIO_ENCODING_SLINEAR_LE;
}
ai.play.pause = 0;
r = IOCTL(data->fd, AUDIO_SETINFO, &ai, "pause=0");
XP_SYS_EQ(0, r);

return NULL;
}

/*
* ioctl(2) can be issued while write(2)-ing.
*/
DEF(ioctl_while_write)
{
struct audio_info ai;
struct ioctl_while_write_data data0, *data;
char buf[8000]; /* 1sec in mulaw,1ch,8000Hz */
pthread_t tid;
int r;

TEST("ioctl_while_write");

data = &data0;
memset(data, 0, sizeof(*data));
memset(buf, 0xff, sizeof(buf));

data->fd = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(data->fd);

/* Pause to block write(2)ing */
AUDIO_INITINFO(&ai);
ai.play.pause = 1;
r = IOCTL(data->fd, AUDIO_SETINFO, &ai, "pause=1");
XP_SYS_EQ(0, r);

gettimeofday(&data->start, NULL);

pthread_create(&tid, NULL, thread_ioctl_while_write, data);

/* Write until blocking */
for (;;) {
r = WRITE(data->fd, buf, sizeof(buf));
if (data->terminated)
break;
XP_SYS_EQ(sizeof(buf), r);

/* Update written time */
gettimeofday(&data->start, NULL);
}

pthread_join(tid, NULL);

/* Flush */
r = IOCTL(data->fd, AUDIO_FLUSH, NULL, "");
XP_SYS_EQ(0, r);
r = CLOSE(data->fd);
XP_SYS_EQ(0, r);
}

volatile int sigio_caught;
void
signal_FIOASYNC(int signo)
{
if (signo == SIGIO) {
sigio_caught = 1;
DPRINTF(" > %d: pid %d got SIGIO\n", __LINE__, (int)getpid());
}
}

/*
* FIOASYNC between two descriptors should be split.
*/
DEF(FIOASYNC_reset)
{
int fd0, fd1;
int r;
int val;

TEST("FIOASYNC_reset");
if (netbsd < 8) {
XP_SKIP("Multiple open is not supported");
return;
}

/* The first one opens */
fd0 = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(fd0);

/* The second one opens, enables ASYNC, and closes */
fd1 = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(fd1);
val = 1;
r = IOCTL(fd1, FIOASYNC, &val, "on");
XP_SYS_EQ(0, r);
r = CLOSE(fd1);
XP_SYS_EQ(0, r);

/* Again, the second one opens and enables ASYNC */
fd1 = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(fd1);
val = 1;
r = IOCTL(fd1, FIOASYNC, &val, "on");
XP_SYS_EQ(0, r); /* NetBSD8 fails */
r = CLOSE(fd1);
XP_SYS_EQ(0, r);
r = CLOSE(fd0);
XP_SYS_EQ(0, r);
}

/*
* Whether SIGIO is emitted on playback.
* XXX I don't understand conditions that NetBSD7 emits signal.
*/
DEF(FIOASYNC_play_signal)
{
struct audio_info ai;
int r;
int fd;
int val;
char *data;
int i;

TEST("FIOASYNC_play_signal");
if (hw_canplay() == 0) {
XP_SKIP("This test is only for playable device");
return;
}

signal(SIGIO, signal_FIOASYNC);
sigio_caught = 0;

fd = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(fd);

r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);
REQUIRED_IF(ai.blocksize != 0);
data = (char *)malloc(ai.blocksize);
REQUIRED_IF(data != NULL);
memset(data, 0xff, ai.blocksize);

val = 1;
r = IOCTL(fd, FIOASYNC, &val, "on");
XP_SYS_EQ(0, r);

r = WRITE(fd, data, ai.blocksize);
XP_SYS_EQ(ai.blocksize, r);

/* Waits signal until 1sec */
for (i = 0; i < 100 && sigio_caught == 0; i++) {
usleep(10000);
}
signal(SIGIO, SIG_IGN);
XP_EQ(1, sigio_caught);

r = CLOSE(fd);
XP_SYS_EQ(0, r);

free(data);
signal(SIGIO, SIG_IGN);
sigio_caught = 0;
}

/*
* Whether SIGIO is emitted on recording.
*/
DEF(FIOASYNC_rec_signal)
{
char buf[10];
int r;
int fd;
int val;
int i;

TEST("FIOASYNC_rec_signal");
if (hw_canrec() == 0) {
XP_SKIP("This test is only for recordable device");
return;
}

signal(SIGIO, signal_FIOASYNC);
sigio_caught = 0;

fd = OPEN(devaudio, O_RDONLY);
REQUIRED_SYS_OK(fd);

val = 1;
r = IOCTL(fd, FIOASYNC, &val, "on");
XP_SYS_EQ(0, r);

r = READ(fd, buf, sizeof(buf));
XP_SYS_EQ(sizeof(buf), r);

/* Wait signal until 1sec */
for (i = 0; i < 100 && sigio_caught == 0; i++) {
usleep(10000);
}
signal(SIGIO, SIG_IGN);
XP_EQ(1, sigio_caught);

r = CLOSE(fd);
XP_SYS_EQ(0, r);

signal(SIGIO, SIG_IGN);
sigio_caught = 0;
}

/*
* FIOASYNC doesn't affect other descriptor.
* For simplify, test only for playback...
*/
DEF(FIOASYNC_multi)
{
struct audio_info ai;
char *buf;
char pipebuf[1];
int r;
int i;
int fd1;
int fd2;
int pd[2];
int val;
pid_t pid;
int status;

TEST("FIOASYNC_multi");
if (netbsd < 8) {
XP_SKIP("Multiple open is not supported");
return;
}
if (hw_canplay() == 0) {
XP_SKIP("This test is only for playable device");
return;
}

/* Pipe used between parent and child */
r = pipe(pd);
REQUIRED_SYS_EQ(0, r);

fd1 = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(fd1);
fd2 = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(fd2);

/* Pause fd2 */
AUDIO_INITINFO(&ai);
ai.play.pause = 1;
r = IOCTL(fd2, AUDIO_SETINFO, &ai, "pause");
REQUIRED_SYS_EQ(0, r);

/* Fill both */
r = IOCTL(fd1, AUDIO_GETBUFINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);
REQUIRED_IF(ai.blocksize != 0);
buf = (char *)malloc(ai.blocksize);
REQUIRED_IF(buf != NULL);
memset(buf, 0xff, ai.blocksize);
r = WRITE(fd1, buf, ai.blocksize);
XP_SYS_EQ(ai.blocksize, r);

sigio_caught = 0;
val = 1;

fflush(stdout);
fflush(stderr);
pid = fork();
if (pid == -1) {
REQUIRED_SYS_OK(pid);
}
if (pid == 0) {
/* Child */
close(fd1);

/* Child enables ASYNC on fd2 */
signal(SIGIO, signal_FIOASYNC);
r = IOCTL(fd2, FIOASYNC, &val, "on");
/* It cannot count errors because here is a child process */
/* XP_SYS_EQ(0, r); */

/*
* Waits signal until 1sec.
* But fd2 is paused so it should never raise.
*/
for (i = 0; i < 100 && sigio_caught == 0; i++) {
usleep(10000);
}
signal(SIGIO, SIG_IGN);
pipebuf[0] = sigio_caught;
/* This is not WRITE() macro here */
write(pd[1], pipebuf, sizeof(pipebuf));

/* XXX? */
close(fd2);
sleep(1);
exit(0);
} else {
/* Parent */
DPRINTF(" > fork() = %d\n", (int)pid);

/* Parent enables ASYNC on fd1 */
signal(SIGIO, signal_FIOASYNC);
r = IOCTL(fd1, FIOASYNC, &val, "on");
XP_SYS_EQ(0, r);

/* Waits signal until 1sec */
for (i = 0; i < 100 && sigio_caught == 0; i++) {
usleep(10000);
}
signal(SIGIO, SIG_IGN);
XP_EQ(1, sigio_caught);

/* Then read child's result from pipe */
r = read(pd[0], pipebuf, sizeof(pipebuf));
if (r != 1) {
XP_FAIL("reading from child failed");
}
DPRINTF(" > child's sigio_cauht = %d\n", pipebuf[0]);
XP_EQ(0, pipebuf[0]);

waitpid(pid, &status, 0);
}

r = CLOSE(fd1);
XP_SYS_EQ(0, r);
r = CLOSE(fd2);
XP_SYS_EQ(0, r);

signal(SIGIO, SIG_IGN);
sigio_caught = 0;
free(buf);
}

/*
* Check AUDIO_WSEEK behavior.
*/
DEF(AUDIO_WSEEK)
{
char buf[4];
struct audio_info ai;
int r;
int fd;
u_long n;

TEST("AUDIO_WSEEK");

fd = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(fd);

/* Pause to count sample data */
AUDIO_INITINFO(&ai);
ai.play.pause = 1;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "pause=1");
REQUIRED_SYS_EQ(0, r);

/* On the initial state, it should be 0 bytes */
n = 0;
r = IOCTL(fd, AUDIO_WSEEK, &n, "");
XP_SYS_EQ(0, r);
XP_EQ(0, n);

/* When writing 4 bytes, it should be 4 bytes */
memset(buf, 0xff, sizeof(buf));
r = WRITE(fd, buf, sizeof(buf));
REQUIRED_EQ(sizeof(buf), r);
r = IOCTL(fd, AUDIO_WSEEK, &n, "");
XP_SYS_EQ(0, r);
if (netbsd < 9) {
/*
* On NetBSD7, it will return 0.
* Perhaps, WSEEK returns the number of pustream bytes but
* data has already advanced...
*/
XP_EQ(0, n);
} else {
/* Data less than one block remains here */
XP_EQ(4, n);
}

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}

/*
* Check AUDIO_SETFD behavior for O_*ONLY descriptor.
* On NetBSD7, SETFD modify audio layer's state (and MD driver's state)
* regardless of open mode. GETFD obtains audio layer's duplex.
* On NetBSD9, SETFD is obsoleted. GETFD obtains hardware's duplex.
*/
void
test_AUDIO_SETFD_xxONLY(int openmode)
{
struct audio_info ai;
int r;
int fd;
int n;

TEST("AUDIO_SETFD_%s", openmode_str[openmode] + 2);
if (openmode == O_RDONLY && hw_canrec() == 0) {
XP_SKIP("This test is for recordable device");
return;
}
if (openmode == O_WRONLY && hw_canplay() == 0) {
XP_SKIP("This test is for playable device");
return;
}

fd = OPEN(devaudio, openmode);
REQUIRED_SYS_OK(fd);

/*
* Just after open(2),
* - On NetBSD7, it's always half-duplex.
* - On NetBSD9, it's the same as hardware one regardless of openmode.
*/
n = 0;
r = IOCTL(fd, AUDIO_GETFD, &n, "");
XP_SYS_EQ(0, r);
if (netbsd < 9) {
XP_EQ(0, n);
} else {
XP_EQ(hw_fulldup(), n);
}

/*
* When trying to set to full-duplex,
* - On NetBSD7, it will succeed if the hardware is full-duplex, or
* will fail if the hardware is half-duplex.
* - On NetBSD9, it will always succeed but will not be modified.
*/
n = 1;
r = IOCTL(fd, AUDIO_SETFD, &n, "on");
if (netbsd < 8) {
if (hw_fulldup()) {
XP_SYS_EQ(0, r);
} else {
XP_SYS_NG(ENOTTY, r);
}
} else if (netbsd == 8) {
XP_FAIL("expected result is unknown");
} else {
XP_SYS_EQ(0, r);
}

/*
* When obtain it,
* - On NetBSD7, it will be 1 if the hardware is full-duplex or
* 0 if half-duplex.
* - On NetBSD9, it will never be changed because it's the hardware
* property.
*/
n = 0;
r = IOCTL(fd, AUDIO_GETFD, &n, "");
XP_SYS_EQ(0, r);
if (netbsd < 8) {
XP_EQ(hw_fulldup(), n);
} else if (netbsd == 8) {
XP_FAIL("expected result is unknown");
} else {
XP_EQ(hw_fulldup(), n);
}

/* Some track parameters like ai.*.open should not change */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
XP_EQ(mode2play(openmode), ai.play.open);
XP_EQ(mode2rec(openmode), ai.record.open);

/*
* When trying to set to half-duplex,
* - On NetBSD7, it will succeed if the hardware is full-duplex, or
* it will succeed with nothing happens.
* - On NetBSD9, it will always succeed but nothing happens.
*/
n = 0;
r = IOCTL(fd, AUDIO_SETFD, &n, "off");
XP_SYS_EQ(0, r);

/*
* When obtain it again,
* - On NetBSD7, it will be 0 if the hardware is full-duplex, or
* still 0 if half-duplex.
* - On NetBSD9, it should not change.
*/
n = 0;
r = IOCTL(fd, AUDIO_GETFD, &n, "");
XP_SYS_EQ(0, r);
if (netbsd < 9) {
XP_EQ(0, n);
} else {
XP_EQ(hw_fulldup(), n);
}

/* Some track parameters like ai.*.open should not change */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
XP_EQ(mode2play(openmode), ai.play.open);
XP_EQ(mode2rec(openmode), ai.record.open);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}
DEF(AUDIO_SETFD_RDONLY) { test_AUDIO_SETFD_xxONLY(O_RDONLY); }
DEF(AUDIO_SETFD_WRONLY) { test_AUDIO_SETFD_xxONLY(O_WRONLY); }

/*
* Check AUDIO_SETFD behavior for O_RDWR descriptor.
*/
DEF(AUDIO_SETFD_RDWR)
{
struct audio_info ai;
int r;
int fd;
int n;

TEST("AUDIO_SETFD_RDWR");
if (!hw_fulldup()) {
XP_SKIP("This test is only for full-duplex device");
return;
}

fd = OPEN(devaudio, O_RDWR);
REQUIRED_SYS_OK(fd);

/*
* - audio(4) manpage until NetBSD7 said "If a full-duplex capable
* audio device is opened for both reading and writing it will
* start in half-duplex play mode", but implementation doesn't
* seem to follow it. It returns full-duplex.
* - On NetBSD9, it should return full-duplex on full-duplex, or
* half-duplex on half-duplex.
*/
n = 0;
r = IOCTL(fd, AUDIO_GETFD, &n, "");
XP_SYS_EQ(0, r);
XP_EQ(hw_fulldup(), n);

/*
* When trying to set to full-duplex,
* - On NetBSD7, it will succeed with nothing happens if full-duplex,
* or will fail if half-duplex.
* - On NetBSD9, it will always succeed with nothing happens.
*/
n = 1;
r = IOCTL(fd, AUDIO_SETFD, &n, "on");
if (netbsd < 9) {
if (hw_fulldup()) {
XP_SYS_EQ(0, r);
} else {
XP_SYS_NG(ENOTTY, r);
}
} else {
XP_SYS_EQ(0, r);
}

/* When obtains it, it returns half/full-duplex as is */
n = 0;
r = IOCTL(fd, AUDIO_GETFD, &n, "");
XP_SYS_EQ(0, r);
XP_EQ(hw_fulldup(), n);

/* Some track parameters like ai.*.open should not change */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
XP_EQ(1, ai.play.open);
XP_EQ(mode2rec(O_RDWR), ai.record.open);

/*
* When trying to set to half-duplex,
* - On NetBSD7, it will succeed if the hardware is full-duplex, or
* it will succeed with nothing happens.
* - On NetBSD9, it will always succeed but nothing happens.
*/
n = 0;
r = IOCTL(fd, AUDIO_SETFD, &n, "off");
if (netbsd < 8) {
XP_SYS_EQ(0, r);
} else if (netbsd == 8) {
XP_FAIL("expected result is unknown");
} else {
XP_SYS_EQ(0, r);
}

/*
* When obtain it again,
* - On NetBSD7, it will be 0 if the hardware is full-duplex, or
* still 0 if half-duplex.
* - On NetBSD9, it should be 1 if the hardware is full-duplex, or
* 0 if half-duplex.
*/
n = 0;
r = IOCTL(fd, AUDIO_GETFD, &n, "");
XP_SYS_EQ(0, r);
if (netbsd < 8) {
XP_EQ(0, n);
} else if (netbsd == 8) {
XP_FAIL("expected result is unknown");
} else {
XP_EQ(hw_fulldup(), n);
}

/* Some track parameters like ai.*.open should not change */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
XP_EQ(1, ai.play.open);
XP_EQ(mode2rec(O_RDWR), ai.record.open);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}

/*
* Check AUDIO_GETINFO.eof behavior.
*/
DEF(AUDIO_GETINFO_eof)
{
struct audio_info ai;
char buf[4];
int r;
int fd, fd1;

TEST("AUDIO_GETINFO_eof");
if (hw_canplay() == 0) {
XP_SKIP("This test is for playable device");
return;
}

fd = OPEN(devaudio, O_RDWR);
REQUIRED_SYS_OK(fd);

/* Pause to make no sound */
AUDIO_INITINFO(&ai);
ai.play.pause = 1;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "pause");
REQUIRED_SYS_EQ(0, r);

/* It should be 0 initially */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
XP_EQ(0, ai.play.eof);
XP_EQ(0, ai.record.eof);

/* Writing zero bytes should increment it */
r = WRITE(fd, &r, 0);
REQUIRED_SYS_OK(r);
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
XP_EQ(1, ai.play.eof);
XP_EQ(0, ai.record.eof);

/* Writing one ore more bytes should noto increment it */
memset(buf, 0xff, sizeof(buf));
r = WRITE(fd, buf, sizeof(buf));
REQUIRED_SYS_OK(r);
memset(&ai, 0, sizeof(ai));
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
XP_EQ(1, ai.play.eof);
XP_EQ(0, ai.record.eof);

/* Writing zero bytes again should increment it */
r = WRITE(fd, buf, 0);
REQUIRED_SYS_OK(r);
memset(&ai, 0, sizeof(ai));
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
XP_EQ(2, ai.play.eof);
XP_EQ(0, ai.record.eof);

/* Reading zero bytes should not increment it */
if (hw_fulldup()) {
r = READ(fd, buf, 0);
REQUIRED_SYS_OK(r);
memset(&ai, 0, sizeof(ai));
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
XP_EQ(2, ai.play.eof);
XP_EQ(0, ai.record.eof);
}

/* should not interfere with other descriptor */
if (netbsd >= 8) {
fd1 = OPEN(devaudio, O_RDWR);
REQUIRED_SYS_OK(fd1);
memset(&ai, 0, sizeof(ai));
r = IOCTL(fd1, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
XP_EQ(0, ai.play.eof);
XP_EQ(0, ai.record.eof);
r = CLOSE(fd1);
XP_SYS_EQ(0, r);
}

r = CLOSE(fd);
XP_SYS_EQ(0, r);

xxx_close_wait();

/* When reopen, it should reset the counter */
fd = OPEN(devaudio, O_RDWR);
REQUIRED_SYS_OK(fd);

r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
XP_EQ(0, ai.play.eof);
XP_EQ(0, ai.record.eof);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}

/*
* Check relationship between openmode and mode set by AUDIO_SETINFO.
*/
void
test_AUDIO_SETINFO_mode(int openmode, int index, int setmode, int expected)
{
struct audio_info ai;
char buf[10];
int inimode;
int r;
int fd;
bool canwrite;
bool canread;

/* index was passed only for displaying here */
TEST("AUDIO_SETINFO_mode_%s_%d", openmode_str[openmode] + 2, index);
if (mode2aumode(openmode) == 0) {
XP_SKIP("Operation not allowed on this hardware property");
return;
}

inimode = mode2aumode(openmode);

fd = OPEN(devaudio, openmode);
REQUIRED_SYS_OK(fd);

/* When just after opening */
memset(&ai, 0, sizeof(ai));
r = IOCTL(fd, AUDIO_GETINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);
XP_EQ(inimode, ai.mode);
XP_EQ(mode2play(openmode), ai.play.open);
XP_EQ(mode2rec(openmode), ai.record.open);
XP_NE(0, ai.play.buffer_size);
XP_NE(0, ai.record.buffer_size);

/* Change mode (and pause here) */
ai.mode = setmode;
ai.play.pause = 1;
ai.record.pause = 1;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "mode");
XP_SYS_EQ(0, r);
if (r == 0) {
r = IOCTL(fd, AUDIO_GETINFO, &ai, "");
XP_SYS_EQ(0, r);
XP_EQ(expected, ai.mode);

/* It seems to keep the initial openmode regardless of mode */
XP_EQ(mode2play(openmode), ai.play.open);
XP_EQ(mode2rec(openmode), ai.record.open);
XP_NE(0, ai.play.buffer_size);
XP_NE(0, ai.record.buffer_size);
}

/*
* On NetBSD7, whether writable depends openmode when open.
* On NetBSD9, whether writable should depend inimode when open.
* Modifying after open should not affect this mode.
*/
if (netbsd < 9) {
canwrite = (openmode != O_RDONLY);
} else {
canwrite = ((inimode & AUMODE_PLAY) != 0);
}
r = WRITE(fd, buf, 0);
if (canwrite) {
XP_SYS_EQ(0, r);
} else {
XP_SYS_NG(EBADF, r);
}

/*
* On NetBSD7, whether readable depends openmode when open.
* On NetBSD9, whether readable should depend inimode when open.
* Modifying after open should not affect this mode.
*/
if (netbsd < 9) {
canread = (openmode != O_WRONLY);
} else {
canread = ((inimode & AUMODE_RECORD) != 0);
}
r = READ(fd, buf, 0);
if (canread) {
XP_SYS_EQ(0, r);
} else {
XP_SYS_NG(EBADF, r);
}

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}
/*
* XXX hmm... it's too complex
*/
/* shortcut for table form */
#define P AUMODE_PLAY
#define A AUMODE_PLAY_ALL
#define R AUMODE_RECORD
struct setinfo_mode_t {
int setmode; /* mode used in SETINFO */
int expmode7; /* expected mode on NetBSD7 */
int expmode9; /* expected mode on NetBSD9 */
};
/*
* The following tables show this operation on NetBSD7 is almost 'undefined'.
* In contrast, NetBSD9 never changes mode by AUDIO_SETINFO except
* AUMODE_PLAY_ALL.
*
* setmode == 0 and 8 are out of range and invalid input samples.
* But NetBSD7 seems to accept it as is.
*/
struct setinfo_mode_t table_SETINFO_mode_O_RDONLY[] = {
/* setmode expmode7 expmode9 */
{ 0, 0, R },
{ P, P, R },
{ A , A|P, R },
{ A|P, A|P, R },
{ R , R , R },
{ R| P, P, R },
{ R|A , A|P, R },
{ R|A|P, A|P, R },
{ 8, 8, R },
};
struct setinfo_mode_t table_SETINFO_mode_O_WRONLY[] = {
/* setmode expmode7 expmode9 */
{ 0, 0, P },
{ P, P, P },
{ A , A|P, A|P },
{ A|P, A|P, A|P },
{ R , R , P },
{ R| P, P, P },
{ R|A , A|P, A|P },
{ R|A|P, A|P, A|P },
{ 8, 8, P },
};
#define f(openmode, index) do { \
struct setinfo_mode_t *table = table_SETINFO_mode_##openmode; \
int setmode = table[index].setmode; \
int expected = (netbsd < 9) \
? table[index].expmode7 \
: table[index].expmode9; \
test_AUDIO_SETINFO_mode(openmode, index, setmode, expected); \
} while (0)
DEF(AUDIO_SETINFO_mode_RDONLY_0) { f(O_RDONLY, 0); }
DEF(AUDIO_SETINFO_mode_RDONLY_1) { f(O_RDONLY, 1); }
DEF(AUDIO_SETINFO_mode_RDONLY_2) { f(O_RDONLY, 2); }
DEF(AUDIO_SETINFO_mode_RDONLY_3) { f(O_RDONLY, 3); }
DEF(AUDIO_SETINFO_mode_RDONLY_4) { f(O_RDONLY, 4); }
DEF(AUDIO_SETINFO_mode_RDONLY_5) { f(O_RDONLY, 5); }
DEF(AUDIO_SETINFO_mode_RDONLY_6) { f(O_RDONLY, 6); }
DEF(AUDIO_SETINFO_mode_RDONLY_7) { f(O_RDONLY, 7); }
DEF(AUDIO_SETINFO_mode_RDONLY_8) { f(O_RDONLY, 8); }
DEF(AUDIO_SETINFO_mode_WRONLY_0) { f(O_WRONLY, 0); }
DEF(AUDIO_SETINFO_mode_WRONLY_1) { f(O_WRONLY, 1); }
DEF(AUDIO_SETINFO_mode_WRONLY_2) { f(O_WRONLY, 2); }
DEF(AUDIO_SETINFO_mode_WRONLY_3) { f(O_WRONLY, 3); }
DEF(AUDIO_SETINFO_mode_WRONLY_4) { f(O_WRONLY, 4); }
DEF(AUDIO_SETINFO_mode_WRONLY_5) { f(O_WRONLY, 5); }
DEF(AUDIO_SETINFO_mode_WRONLY_6) { f(O_WRONLY, 6); }
DEF(AUDIO_SETINFO_mode_WRONLY_7) { f(O_WRONLY, 7); }
DEF(AUDIO_SETINFO_mode_WRONLY_8) { f(O_WRONLY, 8); }
#undef f
/*
* The following tables also show that NetBSD7's behavior is almost
* 'undefined'.
*/
struct setinfo_mode_t table_SETINFO_mode_O_RDWR_full[] = {
/* setmode expmode7 expmode9 */
{ 0, 0, R| P },
{ P, P, R| P },
{ A , A|P, R|A|P },
{ A|P, A|P, R|A|P },
{ R , R , R| P },
{ R| P, R| P, R| P },
{ R|A , R|A|P, R|A|P },
{ R|A|P, R|A|P, R|A|P },
{ 8, 8, R| P },
};
struct setinfo_mode_t table_SETINFO_mode_O_RDWR_half[] = {
/* setmode expmode7 expmode9 */
{ 0, 0, P },
{ P, P, P },
{ A , A|P, A|P },
{ A|P, A|P, A|P },
{ R , R , P },
{ R| P, P, P },
{ R|A , A|P, A|P },
{ R|A|P, A|P, A|P },
{ 8, 8, P },
};
#define f(index) do { \
struct setinfo_mode_t *table = (hw_fulldup()) \
? table_SETINFO_mode_O_RDWR_full \
: table_SETINFO_mode_O_RDWR_half; \
int setmode = table[index].setmode; \
int expected = (netbsd < 9) \
? table[index].expmode7 \
: table[index].expmode9; \
test_AUDIO_SETINFO_mode(O_RDWR, index, setmode, expected); \
} while (0)
DEF(AUDIO_SETINFO_mode_RDWR_0) { f(0); }
DEF(AUDIO_SETINFO_mode_RDWR_1) { f(1); }
DEF(AUDIO_SETINFO_mode_RDWR_2) { f(2); }
DEF(AUDIO_SETINFO_mode_RDWR_3) { f(3); }
DEF(AUDIO_SETINFO_mode_RDWR_4) { f(4); }
DEF(AUDIO_SETINFO_mode_RDWR_5) { f(5); }
DEF(AUDIO_SETINFO_mode_RDWR_6) { f(6); }
DEF(AUDIO_SETINFO_mode_RDWR_7) { f(7); }
DEF(AUDIO_SETINFO_mode_RDWR_8) { f(8); }
#undef f
#undef P
#undef A
#undef R

/*
* Check whether encoding params can be set.
*/
void
test_AUDIO_SETINFO_params_set(int openmode, int aimode, int pause)
{
struct audio_info ai;
int r;
int fd;

/*
* aimode is bool value that indicates whether to change ai.mode.
* pause is bool value that indicates whether to change ai.*.pause.
*/

TEST("AUDIO_SETINFO_params_%s_%d_%d",
openmode_str[openmode] + 2, aimode, pause);
if (mode2aumode(openmode) == 0) {
XP_SKIP("Operation not allowed on this hardware property");
return;
}

/* On half-duplex, O_RDWR is the same as O_WRONLY, so skip it */
if (!hw_fulldup() && openmode == O_RDWR) {
XP_SKIP("This is the same with O_WRONLY on half-duplex");
return;
}

fd = OPEN(devaudio, openmode);
REQUIRED_SYS_OK(fd);

AUDIO_INITINFO(&ai);
/*
* It takes time and effort to check all parameters independently,
* so that use sample_rate as a representative.
*/
ai.play.sample_rate = 11025;
ai.record.sample_rate = 11025;
if (aimode)
ai.mode = mode2aumode(openmode) & ~AUMODE_PLAY_ALL;
if (pause) {
ai.play.pause = 1;
ai.record.pause = 1;
}

r = IOCTL(fd, AUDIO_SETINFO, &ai, "");
XP_SYS_EQ(0, r);

r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
int expmode = (aimode)
? (mode2aumode(openmode) & ~AUMODE_PLAY_ALL)
: mode2aumode(openmode);
XP_EQ(expmode, ai.mode);
XP_EQ(11025, ai.play.sample_rate);
XP_EQ(pause, ai.play.pause);
XP_EQ(11025, ai.record.sample_rate);
XP_EQ(pause, ai.record.pause);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}
#define f(a,b,c) test_AUDIO_SETINFO_params_set(a, b, c)
DEF(AUDIO_SETINFO_params_set_RDONLY_0) { f(O_RDONLY, 0, 0); }
DEF(AUDIO_SETINFO_params_set_RDONLY_1) { f(O_RDONLY, 0, 1); }
/* On RDONLY, ai.mode is not changeable
* AUDIO_SETINFO_params_set_RDONLY_2) { f(O_RDONLY, 1, 0); }
* AUDIO_SETINFO_params_set_RDONLY_3) { f(O_RDONLY, 1, 1); }
*/
DEF(AUDIO_SETINFO_params_set_WRONLY_0) { f(O_WRONLY, 0, 0); }
DEF(AUDIO_SETINFO_params_set_WRONLY_1) { f(O_WRONLY, 0, 1); }
DEF(AUDIO_SETINFO_params_set_WRONLY_2) { f(O_WRONLY, 1, 0); }
DEF(AUDIO_SETINFO_params_set_WRONLY_3) { f(O_WRONLY, 1, 1); }
DEF(AUDIO_SETINFO_params_set_RDWR_0) { f(O_RDWR, 0, 0); }
DEF(AUDIO_SETINFO_params_set_RDWR_1) { f(O_RDWR, 0, 1); }
DEF(AUDIO_SETINFO_params_set_RDWR_2) { f(O_RDWR, 1, 0); }
DEF(AUDIO_SETINFO_params_set_RDWR_3) { f(O_RDWR, 1, 1); }
#undef f

/*
* AUDIO_SETINFO for existing track should not be interfered by other
* descriptor.
* AUDIO_SETINFO for non-existing track affects/is affected sticky parameters
* for backward compatibility.
*/
DEF(AUDIO_SETINFO_params_simul)
{
struct audio_info ai;
int fd0;
int fd1;
int r;

TEST("AUDIO_SETINFO_params_simul");
if (netbsd < 8) {
XP_SKIP("Multiple open is not supported");
return;
}
if (hw_canplay() == 0) {
XP_SKIP("This test is for playable device");
return;
}

/* Open the 1st one as playback only */
fd0 = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(fd0);

/* Open the 2nd one as both of playback and recording */
fd1 = OPEN(devaudio, O_RDWR);
REQUIRED_SYS_OK(fd1);

/* Change some parameters of both track on the 2nd one */
AUDIO_INITINFO(&ai);
ai.play.sample_rate = 11025;
ai.record.sample_rate = 11025;
r = IOCTL(fd1, AUDIO_SETINFO, &ai, "");
XP_SYS_EQ(0, r);

/*
* The 1st one doesn't have recording track so that only recording
* parameter is affected by sticky parameter.
*/
memset(&ai, 0, sizeof(ai));
r = IOCTL(fd0, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
XP_EQ(8000, ai.play.sample_rate);
XP_EQ(11025, ai.record.sample_rate);

/* Next, change some parameters of both track on the 1st one */
AUDIO_INITINFO(&ai);
ai.play.sample_rate = 16000;
ai.record.sample_rate = 16000;
r = IOCTL(fd0, AUDIO_SETINFO, &ai, "");
XP_SYS_EQ(0, r);

/*
* On full-duplex device, the 2nd one has both track so that
* both track are not affected by sticky parameter.
* Otherwise, the 2nd one has only playback track so that
* playback track is not affected by sticky parameter.
*/
memset(&ai, 0, sizeof(ai));
r = IOCTL(fd1, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
XP_EQ(11025, ai.play.sample_rate);
if (hw_fulldup()) {
XP_EQ(11025, ai.record.sample_rate);
} else {
XP_EQ(16000, ai.record.sample_rate);
}

r = CLOSE(fd0);
XP_SYS_EQ(0, r);
r = CLOSE(fd1);
XP_SYS_EQ(0, r);
}

/*
* AUDIO_SETINFO(encoding/precision) is tested in AUDIO_GETENC_range below.
*/

/*
* Check whether the number of channels can be set.
*/
DEF(AUDIO_SETINFO_channels)
{
struct audio_info hwinfo;
struct audio_info ai;
int mode;
int r;
int fd;
int i;
unsigned int ch;
struct {
int ch;
bool expected;
} table[] = {
{ 0, false },
{ 1, true }, /* monaural */
{ 2, true }, /* stereo */
};

TEST("AUDIO_SETINFO_channels");
if (netbsd < 8) {
/*
* On NetBSD7, the result depends the hardware and there is
* no way to know it.
*/
XP_SKIP("The test doesn't make sense on NetBSD7");
return;
}

mode = openable_mode();
fd = OPEN(devaudio, mode);
REQUIRED_SYS_OK(fd);

/*
* The audio layer always supports monaural and stereo regardless of
* the hardware capability.
*/
for (i = 0; i < (int)__arraycount(table); i++) {
ch = table[i].ch;
bool expected = table[i].expected;

AUDIO_INITINFO(&ai);
if (mode != O_RDONLY)
ai.play.channels = ch;
if (mode != O_WRONLY)
ai.record.channels = ch;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "channels=%d", ch);
if (expected) {
/* Expects to succeed */
XP_SYS_EQ(0, r);

r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
if (mode != O_RDONLY)
XP_EQ(ch, ai.play.channels);
if (mode != O_WRONLY)
XP_EQ(ch, ai.record.channels);
} else {
/* Expects to fail */
XP_SYS_NG(EINVAL, r);
}
}

/*
* The maximum number of supported channels depends the hardware.
*/
/* Get the number of channels that the hardware supports */
r = IOCTL(fd, AUDIO_GETFORMAT, &hwinfo, "");
REQUIRED_SYS_EQ(0, r);

if ((hwinfo.mode & AUMODE_PLAY)) {
DPRINTF(" > hwinfo.play.channels = %d\n",
hwinfo.play.channels);
for (ch = 3; ch <= hwinfo.play.channels; ch++) {
AUDIO_INITINFO(&ai);
ai.play.channels = ch;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "channels=%d", ch);
XP_SYS_EQ(0, r);

r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
XP_EQ(ch, ai.play.channels);
}

AUDIO_INITINFO(&ai);
ai.play.channels = ch;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "channels=%d", ch);
XP_SYS_NG(EINVAL, r);
}
if ((hwinfo.mode & AUMODE_RECORD)) {
DPRINTF(" > hwinfo.record.channels = %d\n",
hwinfo.record.channels);
for (ch = 3; ch <= hwinfo.record.channels; ch++) {
AUDIO_INITINFO(&ai);
ai.record.channels = ch;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "channels=%d", ch);
XP_SYS_EQ(0, r);

r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
XP_EQ(ch, ai.record.channels);
}

AUDIO_INITINFO(&ai);
ai.record.channels = ch;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "channels=%d", ch);
XP_SYS_NG(EINVAL, r);
}

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}

/*
* Check whether the sample rate can be set.
*/
DEF(AUDIO_SETINFO_sample_rate)
{
struct audio_info ai;
int mode;
int r;
int fd;
int i;
struct {
int freq;
bool expected;
} table[] = {
{ 999, false },
{ 1000, true }, /* lower limit */
{ 48000, true },
{ 192000, true }, /* upper limit */
{ 192001, false },
};

TEST("AUDIO_SETINFO_sample_rate");
if (netbsd < 8) {
/*
* On NetBSD7, the result depends the hardware and there is
* no way to know it.
*/
XP_SKIP("The test doesn't make sense on NetBSD7");
return;
}

mode = openable_mode();
fd = OPEN(devaudio, mode);
REQUIRED_SYS_OK(fd);

for (i = 0; i < (int)__arraycount(table); i++) {
int freq = table[i].freq;
bool expected = table[i].expected;

AUDIO_INITINFO(&ai);
if (mode != O_RDONLY)
ai.play.sample_rate = freq;
if (mode != O_WRONLY)
ai.record.sample_rate = freq;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "sample_rate=%d", freq);
if (expected) {
/* Expects to succeed */
XP_SYS_EQ(0, r);

r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
if (mode != O_RDONLY)
XP_EQ(freq, ai.play.sample_rate);
if (mode != O_WRONLY)
XP_EQ(freq, ai.record.sample_rate);
} else {
/* Expects to fail */
XP_SYS_NG(EINVAL, r);
}
}

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}

/*
* SETINFO(sample_rate = 0) should fail correctly.
*/
DEF(AUDIO_SETINFO_sample_rate_0)
{
struct audio_info ai;
int mode;
int r;
int fd;

TEST("AUDIO_SETINFO_sample_rate_0");
if (netbsd < 9) {
/*
* On NetBSD7,8 this will block system call and you will not
* even be able to shutdown...
*/
XP_SKIP("This will cause an infinite loop in the kernel");
return;
}

mode = openable_mode();
fd = OPEN(devaudio, mode);
REQUIRED_SYS_OK(fd);

AUDIO_INITINFO(&ai);
ai.play.sample_rate = 0;
ai.record.sample_rate = 0;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "sample_rate=0");
/* Expects to fail */
XP_SYS_NG(EINVAL, r);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}

/*
* Check whether the pause/unpause works.
*/
void
test_AUDIO_SETINFO_pause(int openmode, int aimode, int param)
{
struct audio_info ai;
int r;
int fd;

/*
* aimode is bool value that indicates whether to change ai.mode.
* param is bool value that indicates whether to change encoding
* parameters of ai.{play,record}.*.
*/

TEST("AUDIO_SETINFO_pause_%s_%d_%d",
openmode_str[openmode] + 2, aimode, param);
if (mode2aumode(openmode) == 0) {
XP_SKIP("Operation not allowed on this hardware property");
return;
}

/* On half-duplex, O_RDWR is the same as O_WRONLY, so skip it */
if (!hw_fulldup() && openmode == O_RDWR) {
XP_SKIP("This is the same with O_WRONLY on half-duplex");
return;
}

fd = OPEN(devaudio, openmode);
REQUIRED_SYS_OK(fd);

/* Set pause */
AUDIO_INITINFO(&ai);
ai.play.pause = 1;
ai.record.pause = 1;
if (aimode)
ai.mode = mode2aumode(openmode) & ~AUMODE_PLAY_ALL;
if (param) {
ai.play.sample_rate = 11025;
ai.record.sample_rate = 11025;
}

r = IOCTL(fd, AUDIO_SETINFO, &ai, "");
XP_SYS_EQ(0, r);

r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
int expmode = (aimode)
? (mode2aumode(openmode) & ~AUMODE_PLAY_ALL)
: mode2aumode(openmode);
XP_EQ(expmode, ai.mode);
XP_EQ(1, ai.play.pause);
XP_EQ(param ? 11025 : 8000, ai.play.sample_rate);
XP_EQ(1, ai.record.pause);
XP_EQ(param ? 11025 : 8000, ai.record.sample_rate);

/* Set unpause (?) */
AUDIO_INITINFO(&ai);
ai.play.pause = 0;
ai.record.pause = 0;
if (aimode)
ai.mode = mode2aumode(openmode);
if (param) {
ai.play.sample_rate = 16000;
ai.record.sample_rate = 16000;
}

r = IOCTL(fd, AUDIO_SETINFO, &ai, "");
XP_SYS_EQ(0, r);

r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);
XP_EQ(mode2aumode(openmode), ai.mode);
XP_EQ(0, ai.play.pause);
XP_EQ(0, ai.record.pause);
if (openmode != O_RDONLY)
XP_EQ(param ? 16000 : 8000, ai.play.sample_rate);
if (openmode != O_WRONLY)
XP_EQ(param ? 16000 : 8000, ai.record.sample_rate);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}
DEF(AUDIO_SETINFO_pause_RDONLY_0) { test_AUDIO_SETINFO_pause(O_RDONLY, 0, 0); }
DEF(AUDIO_SETINFO_pause_RDONLY_1) { test_AUDIO_SETINFO_pause(O_RDONLY, 0, 1); }
/* On RDONLY, ai.mode is not changeable
* AUDIO_SETINFO_pause_RDONLY_2) { test_AUDIO_SETINFO_pause(O_RDONLY, 1, 0); }
* AUDIO_SETINFO_pause_RDONLY_3) { test_AUDIO_SETINFO_pause(O_RDONLY, 1, 1); }
*/
DEF(AUDIO_SETINFO_pause_WRONLY_0) { test_AUDIO_SETINFO_pause(O_WRONLY, 0, 0); }
DEF(AUDIO_SETINFO_pause_WRONLY_1) { test_AUDIO_SETINFO_pause(O_WRONLY, 0, 1); }
DEF(AUDIO_SETINFO_pause_WRONLY_2) { test_AUDIO_SETINFO_pause(O_WRONLY, 1, 0); }
DEF(AUDIO_SETINFO_pause_WRONLY_3) { test_AUDIO_SETINFO_pause(O_WRONLY, 1, 1); }
DEF(AUDIO_SETINFO_pause_RDWR_0) { test_AUDIO_SETINFO_pause(O_RDWR, 0, 0); }
DEF(AUDIO_SETINFO_pause_RDWR_1) { test_AUDIO_SETINFO_pause(O_RDWR, 0, 1); }
DEF(AUDIO_SETINFO_pause_RDWR_2) { test_AUDIO_SETINFO_pause(O_RDWR, 1, 0); }
DEF(AUDIO_SETINFO_pause_RDWR_3) { test_AUDIO_SETINFO_pause(O_RDWR, 1, 1); }

/*
* Check whether gain can be obtained/set.
* And the gain should work with rich mixer.
* PR kern/52781
*/
DEF(AUDIO_SETINFO_gain)
{
struct audio_info ai;
mixer_ctrl_t m;
int index;
int master;
int master_backup;
int gain;
int fd;
int mixerfd;
int r;

TEST("AUDIO_SETINFO_gain");

/* Open /dev/mixer */
mixerfd = OPEN(devmixer, O_RDWR);
REQUIRED_SYS_OK(mixerfd);
index = mixer_get_outputs_master(mixerfd);
if (index == -1) {
XP_SKIP("Hardware has no outputs.master");
CLOSE(mixerfd);
return;
}

/*
* Get current outputs.master.
* auich(4) requires class type (m.type) and number of channels
* (un.value.num_channels) in addition to the index (m.dev)...
* What is the index...?
*/
memset(&m, 0, sizeof(m));
m.dev = index;
m.type = AUDIO_MIXER_VALUE;
m.un.value.num_channels = 1; /* dummy */
r = IOCTL(mixerfd, AUDIO_MIXER_READ, &m, "m.dev=%d", m.dev);
REQUIRED_SYS_EQ(0, r);
master = m.un.value.level[0];
DPRINTF(" > outputs.master = %d\n", master);
master_backup = master;

/* Open /dev/audio */
fd = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(fd);

/* Check ai.play.gain */
r = IOCTL(fd, AUDIO_GETINFO, &ai, "");
XP_SYS_EQ(0, r);
XP_EQ(master, ai.play.gain);

/* Change it some different value */
AUDIO_INITINFO(&ai);
if (master == 0)
gain = 255;
else
gain = 0;
ai.play.gain = gain;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "play.gain=%d", ai.play.gain);
XP_SYS_EQ(0, r);

/* Check gain has changed */
r = IOCTL(fd, AUDIO_GETINFO, &ai, "play.gain");
XP_SYS_EQ(0, r);
XP_NE(master, ai.play.gain);

/* Check whether outputs.master work with gain */
r = IOCTL(mixerfd, AUDIO_MIXER_READ, &m, "");
XP_SYS_EQ(0, r);
XP_EQ(ai.play.gain, m.un.value.level[0]);

/* Restore outputs.master */
AUDIO_INITINFO(&ai);
ai.play.gain = master_backup;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "play.gain=%d", ai.play.gain);
XP_SYS_EQ(0, r);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
r = CLOSE(mixerfd);
XP_SYS_EQ(0, r);
}

/*
* Look if there are any (non-zero) gain values that can be changed.
* If any gain can be set, it is set to gain[0].
* If another gain can be set, it is set to gain[1], otherwise gain[1] = -1.
* This is for AUDIO_SETINFO_gain_balance.
*/
static void
get_changeable_gain(int fd, int *gain, const char *dir, int offset)
{
struct audio_info ai;
int *ai_gain;
int hi;
int lo;
int r;

/* A hack to handle ai.{play,record}.gain in the same code.. */
ai_gain = (int *)(((char *)&ai) + offset);

/* Try to set the maximum gain */
AUDIO_INITINFO(&ai);
*ai_gain = AUDIO_MAX_GAIN;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "%s.gain=%d", dir, *ai_gain);
XP_SYS_EQ(0, r);
/* Get again. The value you set is not always used as is. */
AUDIO_INITINFO(&ai);
r = IOCTL(fd, AUDIO_GETINFO, &ai, "&ai");
XP_SYS_EQ(0, r);
hi = *ai_gain;

/* Look for next configurable value. */
for (lo = hi - 1; lo >= 0; lo--) {
AUDIO_INITINFO(&ai);
*ai_gain = lo;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "%s.gain=%d", dir, *ai_gain);
XP_SYS_EQ(0, r);
/* Get again */
r = IOCTL(fd, AUDIO_GETINFO, &ai, "&ai");
XP_SYS_EQ(0, r);
if (*ai_gain != hi) {
lo = *ai_gain;
break;
}
}

/* Now gain is lo(=gain[0]). */

/*
* hi lo
* --- ---
* <0 <0 : not available.
* >=0 <0 : available but not changeable.
* >=0 >=0 (hi!=lo) : available and changeable.
*/
if (hi < 0) {
gain[0] = -1;
gain[1] = -1;
DPRINTF(" > %s.gain cannot be set\n", dir);
} else if (lo < 0) {
gain[0] = hi;
gain[1] = -1;
DPRINTF(" > %s.gain can only be set %d\n", dir, gain[0]);
} else {
gain[0] = lo;
gain[1] = hi;
DPRINTF(" > %s.gain can be set %d, %d\n",
dir, gain[0], gain[1]);
}
}

/*
* Look if there are any balance values that can be changed.
* If any balance value can be set, it is set to balance[0].
* If another balance value can be set, it is set to balance[1],
* otherwise balance[1] = -1.
* This is for AUDIO_SETINFO_gain_balance.
*/
static void
get_changeable_balance(int fd, int *balance, const char *dir, int offset)
{
struct audio_info ai;
u_char *ai_balance;
u_char left;
u_char right;
int r;

/* A hack to handle ai.{play,record}.balance in the same code.. */
ai_balance = ((u_char *)&ai) + offset;

/* Look for the right side configurable value. */
AUDIO_INITINFO(&ai);
*ai_balance = AUDIO_RIGHT_BALANCE;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "%s.balance=%d", dir, *ai_balance);
XP_SYS_EQ(0, r);
/* Get again. The value you set is not always used as is. */
r = IOCTL(fd, AUDIO_GETINFO, &ai, "&ai");
XP_SYS_EQ(0, r);
right = *ai_balance;

/* Look for the left side configurable value. */
AUDIO_INITINFO(&ai);
*ai_balance = AUDIO_LEFT_BALANCE;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "%s.balance=%d", dir, *ai_balance);
XP_SYS_EQ(0, r);
/* Get again */
r = IOCTL(fd, AUDIO_GETINFO, &ai, "&ai");
XP_SYS_EQ(0, r);
left = *ai_balance;

/* Now balance is the left(=balance[0]). */

if (left == right) {
/* The driver has no balance feature. */
balance[0] = left;
balance[1] = -1;
DPRINTF(" > %s.balance can only be set %d\n",
dir, balance[0]);
} else {
balance[0] = left;
balance[1] = right;
DPRINTF(" > %s.balance can be set %d, %d\n",
dir, balance[0], balance[1]);
}
}

/*
* Check whether gain and balance can be set at the same time.
* PR kern/56308
*/
DEF(AUDIO_SETINFO_gain_balance)
{
struct audio_info oai;
struct audio_info ai;
int i;
int mode;
int fd;
int r;
int pgain[2];
int pbalance[2];
int rgain[2];
int rbalance[2];
bool ptest;
bool rtest;

TEST("AUDIO_SETINFO_gain_balance");

mode = openable_mode();
fd = OPEN(devaudio, mode);
REQUIRED_SYS_OK(fd);

/* Backup current gain and balance */
r = IOCTL(fd, AUDIO_GETINFO, &oai, "&oai");
XP_SYS_EQ(0, r);

if (debug) {
printf(" > old play.gain = %d\n", oai.play.gain);
printf(" > old play.balance = %d\n", oai.play.balance);
printf(" > old record.gain = %d\n", oai.record.gain);
printf(" > old record.balance = %d\n", oai.record.balance);
}

for (i = 0; i < 2; i++) {
pgain[i] = -1;
pbalance[i] = -1;
rgain[i] = -1;
rbalance[i] = -1;
}

/*
* First, check each one separately can be changed.
*
* The simplest two different gain values are zero and non-zero.
* But some device drivers seem to process balance differently
* when the gain is high enough and when the gain is zero or near.
* So I needed to select two different "non-zero (and high if
* possible)" gains.
*/
if (hw_canplay()) {
get_changeable_gain(fd, pgain, "play",
offsetof(struct audio_info, play.gain));
get_changeable_balance(fd, pbalance, "play",
offsetof(struct audio_info, play.balance));
}
if (hw_canrec()) {
get_changeable_gain(fd, rgain, "record",
offsetof(struct audio_info, record.gain));
get_changeable_balance(fd, rbalance, "record",
offsetof(struct audio_info, record.balance));
}

/*
* [0] [1]
* --- ---
* -1 * : not available.
* >=0 -1 : available but not changeable.
* >=0 >=0 : available and changeable. It can be tested.
*/
ptest = (pgain[0] >= 0 && pgain[1] >= 0 &&
pbalance[0] >= 0 && pbalance[1] >= 0);
rtest = (rgain[0] >= 0 && rgain[1] >= 0 &&
rbalance[0] >= 0 && rbalance[1] >= 0);

if (ptest == false && rtest == false) {
XP_SKIP(
"The test requires changeable gain and changeable balance");

/* Restore as possible */
AUDIO_INITINFO(&ai);
ai.play.gain = oai.play.gain;
ai.play.balance = oai.play.balance;
ai.record.gain = oai.record.gain;
ai.record.balance = oai.record.balance;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "restore all");
XP_SYS_EQ(0, r);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
return;
}

/*
* If both play.gain and play.balance are changeable,
* it should be able to set both at the same time.
*/
if (ptest) {
AUDIO_INITINFO(&ai);
ai.play.gain = pgain[1];
ai.play.balance = pbalance[1];
r = IOCTL(fd, AUDIO_SETINFO, &ai, "play.gain=%d/balance=%d",
ai.play.gain, ai.play.balance);
XP_SYS_EQ(0, r);

AUDIO_INITINFO(&ai);
r = IOCTL(fd, AUDIO_GETINFO, &ai, "&ai");
XP_SYS_EQ(0, r);

DPRINTF(" > setting play.gain=%d/balance=%d: "
"result gain=%d/balance=%d\n",
pgain[1], pbalance[1], ai.play.gain, ai.play.balance);
XP_EQ(ai.play.gain, pgain[1]);
XP_EQ(ai.play.balance, pbalance[1]);
}
/*
* If both record.gain and record.balance are changeable,
* it should be able to set both at the same time.
*/
if (rtest) {
AUDIO_INITINFO(&ai);
ai.record.gain = rgain[1];
ai.record.balance = rbalance[1];
r = IOCTL(fd, AUDIO_SETINFO, &ai, "record.gain=%d/balance=%d",
ai.record.gain, ai.record.balance);
XP_SYS_EQ(0, r);

AUDIO_INITINFO(&ai);
r = IOCTL(fd, AUDIO_GETINFO, &ai, "&ai");
XP_SYS_EQ(0, r);

DPRINTF(" > setting record.gain=%d/balance=%d: "
"result gain=%d/balance=%d\n",
rgain[1], rbalance[1], ai.record.gain, ai.record.balance);
XP_EQ(ai.record.gain, rgain[1]);
XP_EQ(ai.record.balance, rbalance[1]);
}

/*
* Restore all values as possible at the same time.
* This restore is also a test.
*/
AUDIO_INITINFO(&ai);
ai.play.gain = oai.play.gain;
ai.play.balance = oai.play.balance;
ai.record.gain = oai.record.gain;
ai.record.balance = oai.record.balance;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "restore all");
XP_SYS_EQ(0, r);

AUDIO_INITINFO(&ai);
r = IOCTL(fd, AUDIO_GETINFO, &ai, "&ai");
XP_SYS_EQ(0, r);
XP_EQ(oai.play.gain, ai.play.gain);
XP_EQ(oai.play.balance, ai.play.balance);
XP_EQ(oai.record.gain, ai.record.gain);
XP_EQ(oai.record.balance, ai.record.balance);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}

/*
* Changing track formats after mmap should fail.
*/
DEF(AUDIO_SETINFO_mmap_enc)
{
struct audio_info ai;
void *ptr;
int fd;
int r;

TEST("AUDIO_SETINFO_mmap");

#if !defined(NO_RUMP)
if (use_rump) {
XP_SKIP("rump doesn't support mmap");
return;
}
#endif

fd = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(fd);

ptr = MMAP(NULL, 1, PROT_WRITE, MAP_FILE, fd, 0);
XP_SYS_PTR(0, ptr);

/*
* SETINFO after mmap should fail.
* NetBSD9 changes errno.
*/
AUDIO_INITINFO(&ai);
ai.play.channels = 2;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "channels=2");
if (netbsd < 9) {
XP_SYS_NG(EINVAL, r);
} else {
XP_SYS_NG(EIO, r);
}

r = CLOSE(fd);
XP_SYS_EQ(0, r);

reset_after_mmap();
}

/*
* Even after mmap, changing pause should succeed.
*/
DEF(AUDIO_SETINFO_mmap_pause)
{
struct audio_info ai;
void *ptr;
int fd;
int r;

TEST("AUDIO_SETINFO_mmap");

#if !defined(NO_RUMP)
if (use_rump) {
XP_SKIP("rump doesn't support mmap");
return;
}
#endif

fd = OPEN(devaudio, O_WRONLY);
REQUIRED_SYS_OK(fd);

ptr = MMAP(NULL, 1, PROT_WRITE, MAP_FILE, fd, 0);
XP_SYS_PTR(0, ptr);

/* SETINFO after mmap should fail */
AUDIO_INITINFO(&ai);
ai.play.pause = 1;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "set pause");
XP_SYS_EQ(0, r);

AUDIO_INITINFO(&ai);
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "get pause");
XP_SYS_EQ(0, r);

XP_EQ(1, ai.play.pause);

/*
* Unpause before close. Unless, subsequent audioplay(1) which use
* /dev/sound by default will pause...
*/
AUDIO_INITINFO(&ai);
ai.play.pause = 0;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "reset pause");
XP_SYS_EQ(0, r);

r = CLOSE(fd);
XP_SYS_EQ(0, r);

reset_after_mmap();
}

#define NENC (AUDIO_ENCODING_AC3 + 1)
#define NPREC (5)
/*
* Make table of encoding+precision supported by this device.
* Return last used index .
* This function is called from test_AUDIO_GETENC_*()
*/
int
getenc_make_table(int fd, int expected[][5])
{
audio_encoding_t ae;
int idx;
int p;
int r;

/*
* expected[][] is two dimensional table.
* encoding \ precision| 4 8 16 24 32
* --------------------+-----------------
* AUDIO_ENCODING_NONE |
* AUDIO_ENCODING_ULAW |
* :
*
* Each cell has expected behavior.
* 0: the hardware doesn't support this encoding/precision.
* 1: the hardware supports this encoding/precision.
* 2: the hardware doesn't support this encoding/precision but
* audio layer will respond as supported for compatibility.
*/
for (idx = 0; ; idx++) {
memset(&ae, 0, sizeof(ae));
ae.index = idx;
r = IOCTL(fd, AUDIO_GETENC, &ae, "index=%d", idx);
if (r != 0) {
XP_SYS_NG(EINVAL, r);
break;
}

XP_EQ(idx, ae.index);
if (0 <= ae.encoding && ae.encoding <= AUDIO_ENCODING_AC3) {
XP_EQ_STR(encoding_names[ae.encoding], ae.name);
} else {
XP_FAIL("ae.encoding %d", ae.encoding);
}

if (ae.precision != 4 &&
ae.precision != 8 &&
ae.precision != 16 &&
ae.precision != 24 &&
ae.precision != 32)
{
XP_FAIL("ae.precision %d", ae.precision);
}
/* Other bits should not be set */
XP_EQ(0, (ae.flags & ~AUDIO_ENCODINGFLAG_EMULATED));

expected[ae.encoding][ae.precision / 8] = 1;
DPRINTF(" > encoding=%s precision=%d\n",
encoding_names[ae.encoding], ae.precision);
}

/*
* Backward compatibility bandaid.
*
* - Some encoding/precision pairs are obviously inconsistent
* (e.g., encoding=AUDIO_ENCODING_PCM8, precision=16) but
* it's due to historical reasons.
* - It's incomplete for NetBSD7 and NetBSD8. I don't really
* understand their rule... This is just memo, not specification.
*/
#define SET(x) do { \
if ((x) == 0) \
x = 2; \
} while (0)
#define p4 (0)
#define p8 (1)
#define p16 (2)
#define p24 (3)
#define p32 (4)

if (expected[AUDIO_ENCODING_SLINEAR][p8]) {
SET(expected[AUDIO_ENCODING_SLINEAR_LE][p8]);
SET(expected[AUDIO_ENCODING_SLINEAR_BE][p8]);
}
if (expected[AUDIO_ENCODING_ULINEAR][p8]) {
SET(expected[AUDIO_ENCODING_ULINEAR_LE][p8]);
SET(expected[AUDIO_ENCODING_ULINEAR_BE][p8]);
SET(expected[AUDIO_ENCODING_PCM8][p8]);
SET(expected[AUDIO_ENCODING_PCM16][p8]);
}
for (p = p16; p <= p32; p++) {
#if !defined(AUDIO_SUPPORT_LINEAR24)
if (p == p24)
continue;
#endif
if (expected[AUDIO_ENCODING_SLINEAR_NE][p]) {
SET(expected[AUDIO_ENCODING_SLINEAR][p]);
SET(expected[AUDIO_ENCODING_PCM16][p]);
}
if (expected[AUDIO_ENCODING_ULINEAR_NE][p]) {
SET(expected[AUDIO_ENCODING_ULINEAR][p]);
}
}

if (netbsd < 9) {
if (expected[AUDIO_ENCODING_SLINEAR_LE][p16] ||
expected[AUDIO_ENCODING_SLINEAR_BE][p16] ||
expected[AUDIO_ENCODING_ULINEAR_LE][p16] ||
expected[AUDIO_ENCODING_ULINEAR_BE][p16])
{
SET(expected[AUDIO_ENCODING_PCM8][p8]);
SET(expected[AUDIO_ENCODING_PCM16][p8]);
SET(expected[AUDIO_ENCODING_SLINEAR_LE][p8]);
SET(expected[AUDIO_ENCODING_SLINEAR_BE][p8]);
SET(expected[AUDIO_ENCODING_ULINEAR_LE][p8]);
SET(expected[AUDIO_ENCODING_ULINEAR_BE][p8]);
SET(expected[AUDIO_ENCODING_SLINEAR][p8]);
SET(expected[AUDIO_ENCODING_ULINEAR][p8]);
}
}

/* Return last used index */
return idx;
#undef SET
#undef p4
#undef p8
#undef p16
#undef p24
#undef p32
}

/*
* This function is called from test_AUDIO_GETENC below.
*/
void
xp_getenc(int expected[][5], int enc, int j, int r, struct audio_prinfo *pr)
{
int prec = (j == 0) ? 4 : j * 8;

if (expected[enc][j]) {
/* expect to succeed */
XP_SYS_EQ(0, r);

XP_EQ(enc, pr->encoding);
XP_EQ(prec, pr->precision);
} else {
/* expect to fail */
XP_SYS_NG(EINVAL, r);
}
}

/*
* This function is called from test_AUDIO_GETENC below.
*/
void
getenc_check_encodings(int openmode, int expected[][5])
{
struct audio_info ai;
int fd;
int i, j;
int r;

fd = OPEN(devaudio, openmode);
REQUIRED_SYS_OK(fd);

for (i = 0; i < NENC; i++) {
for (j = 0; j < NPREC; j++) {
/* precisions are 4 and 8, 16, 24, 32 */
int prec = (j == 0) ? 4 : j * 8;

/*
* AUDIO_GETENC has no way to know range of
* supported channels and sample_rate.
*/
AUDIO_INITINFO(&ai);
ai.play.encoding = i;
ai.play.precision = prec;
ai.record.encoding = i;
ai.record.precision = prec;

r = IOCTL(fd, AUDIO_SETINFO, &ai, "%s:%d",
encoding_names[i], prec);
if (mode2play(openmode))
xp_getenc(expected, i, j, r, &ai.play);
if (mode2rec(openmode))
xp_getenc(expected, i, j, r, &ai.record);
}
}
r = CLOSE(fd);
XP_SYS_EQ(0, r);
}

/*
* Check whether encoding+precision obtained by AUDIO_GETENC can be set.
*/
DEF(AUDIO_GETENC_range)
{
audio_encoding_t ae;
int fd;
int r;
int expected[NENC][NPREC];
int i, j;

TEST("AUDIO_GETENC_range");

fd = OPEN(devaudio, openable_mode());
REQUIRED_SYS_OK(fd);

memset(&expected, 0, sizeof(expected));
i = getenc_make_table(fd, expected);

/* When error has occurred, the next index should also occur error */
ae.index = i + 1;
r = IOCTL(fd, AUDIO_GETENC, &ae, "index=%d", ae.index);
XP_SYS_NG(EINVAL, r);

r = CLOSE(fd);
XP_SYS_EQ(0, r);

/* For debug */
if (debug) {
for (i = 0; i < NENC; i++) {
printf("expected[%2d] %15s", i, encoding_names[i]);
for (j = 0; j < NPREC; j++) {
printf(" %d", expected[i][j]);
}
printf("\n");
}
}

/* Whether obtained encodings can be actually set */
if (hw_fulldup()) {
/* Test both R/W at once using single descriptor */
getenc_check_encodings(O_RDWR, expected);
} else {
/* Test playback and recording if available */
if (hw_canplay()) {
getenc_check_encodings(O_WRONLY, expected);
}
if (hw_canplay() && hw_canrec()) {
xxx_close_wait();
}
if (hw_canrec()) {
getenc_check_encodings(O_RDONLY, expected);
}
}
}
#undef NENC
#undef NPREC

/*
* Check AUDIO_GETENC out of range.
*/
DEF(AUDIO_GETENC_error)
{
audio_encoding_t e;
int fd;
int r;

TEST("AUDIO_GETENC_error");

fd = OPEN(devaudio, openable_mode());
REQUIRED_SYS_OK(fd);

memset(&e, 0, sizeof(e));
e.index = -1;
r = IOCTL(fd, AUDIO_GETENC, &e, "index=-1");
/* NetBSD7 may not fail depending on hardware driver */
XP_SYS_NG(EINVAL, r);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}

/*
* AUDIO_[PR]ERROR should be zero on the initial state even on non-existent
* track.
*/
void
test_AUDIO_ERROR(int openmode)
{
int fd;
int r;
int errors;

TEST("AUDIO_ERROR_%s", openmode_str[openmode] + 2);
if (mode2aumode(openmode) == 0) {
XP_SKIP("Operation not allowed on this hardware property");
return;
}

fd = OPEN(devaudio, openmode);
REQUIRED_SYS_OK(fd);

/* Check PERROR */
errors = 0xdeadbeef;
r = IOCTL(fd, AUDIO_PERROR, &errors, "");
XP_SYS_EQ(0, r);
XP_EQ(0, errors);

/* Check RERROR */
errors = 0xdeadbeef;
r = IOCTL(fd, AUDIO_RERROR, &errors, "");
XP_SYS_EQ(0, r);
XP_EQ(0, errors);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}
DEF(AUDIO_ERROR_RDONLY) { test_AUDIO_ERROR(O_RDONLY); }
DEF(AUDIO_ERROR_WRONLY) { test_AUDIO_ERROR(O_WRONLY); }
DEF(AUDIO_ERROR_RDWR) { test_AUDIO_ERROR(O_RDWR); }

/*
* AUDIO_GETIOFFS at least one block.
*/
void
test_AUDIO_GETIOFFS_one(int openmode)
{
struct audio_info ai;
audio_offset_t o;
int fd;
int r;
u_int blocksize;
u_int blk_ms;

TEST("AUDIO_GETIOFFS_one_%s", openmode_str[openmode] + 2);
if (mode2aumode(openmode) == 0) {
XP_SKIP("Operation not allowed on this hardware property");
return;
}

fd = OPEN(devaudio, openmode);
REQUIRED_SYS_OK(fd);

#if 0
/*
* On NetBSD7/8, native encodings and emulated encodings behave
* differently. But it's hard to identify which encoding is native.
* If you try other encodings, edit these parameters manually.
*/
AUDIO_INITINFO(&ai);
ai.record.encoding = AUDIO_ENCODING_SLINEAR_NE;
ai.record.precision = 16;
ai.record.channels = 2;
ai.record.sample_rate = 48000;
/* ai.blocksize is shared by play and record, so set both the same. */
*ai.play = *ai.record;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);
#endif

/* Get blocksize to calc blk_ms. */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);
blocksize = ai.blocksize;
if (netbsd < 9) {
blk_ms = 0;
} else {
/* On NetBSD9, blocktime can always be calculated. */
blk_ms = blocksize * 1000 /
(ai.play.precision / 8 * ai.play.channels *
ai.play.sample_rate);
}
if (blk_ms == 0)
blk_ms = 50;
DPRINTF(" > blocksize=%u, estimated blk_ms=%u\n", blocksize, blk_ms);

/*
* Even when just opened, recording counters will start.
* Wait a moment, about one block time.
*/
usleep(blk_ms * 1000);

r = IOCTL(fd, AUDIO_GETIOFFS, &o, "");
XP_SYS_EQ(0, r);
if (mode2rec(openmode)) {
/*
* It's difficult to know exact values.
* But at least these should not be zero.
*/
DPRINTF(" > %d: samples=%u deltablks=%u offset=%u\n",
__LINE__, o.samples, o.deltablks, o.offset);
XP_NE(0, o.samples);
XP_NE(0, o.deltablks);
XP_NE(0, o.offset);
} else {
/* All are zero on playback track. */
XP_EQ(0, o.samples);
XP_EQ(0, o.deltablks);
XP_EQ(0, o.offset);
}

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}
DEF(AUDIO_GETIOFFS_one_RDONLY) { test_AUDIO_GETIOFFS_one(O_RDONLY); }
DEF(AUDIO_GETIOFFS_one_WRONLY) { test_AUDIO_GETIOFFS_one(O_WRONLY); }
DEF(AUDIO_GETIOFFS_one_RDWR) { test_AUDIO_GETIOFFS_one(O_RDWR); }

/*
* AUDIO_GETOOFFS for one block.
*/
void
test_AUDIO_GETOOFFS_one(int openmode)
{
struct audio_info ai;
audio_offset_t o;
char *buf;
int fd;
int r;
u_int blocksize;
u_int initial_offset;
u_int blk_ms;

TEST("AUDIO_GETOOFFS_one_%s", openmode_str[openmode] + 2);
if (mode2aumode(openmode) == 0) {
XP_SKIP("Operation not allowed on this hardware property");
return;
}

fd = OPEN(devaudio, openmode);
REQUIRED_SYS_OK(fd);

#if 0
/*
* On NetBSD7/8, native encodings and emulated encodings behave
* differently. But it's hard to identify which encoding is native.
* If you try other encodings, edit these parameters manually.
*/
AUDIO_INITINFO(&ai);
ai.play.encoding = AUDIO_ENCODING_SLINEAR_NE;
ai.play.precision = 16;
ai.play.channels = 2;
ai.play.sample_rate = 48000;
/* ai.blocksize is shared by play and record, so set both the same. */
*ai.record = *ai.play;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "slinear16/2ch/48000");
REQUIRED_SYS_EQ(0, r);
#endif

/* Get blocksize to calc blk_ms. */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);
blocksize = ai.blocksize;
if (netbsd < 9) {
blk_ms = 0;
} else {
/* On NetBSD9, blocktime can always be calculated. */
blk_ms = blocksize * 1000 /
(ai.play.precision / 8 * ai.play.channels *
ai.play.sample_rate);
}
if (blk_ms == 0)
blk_ms = 50;
DPRINTF(" > blocksize=%u, estimated blk_ms=%u\n", blocksize, blk_ms);

buf = (char *)malloc(blocksize);
REQUIRED_IF(buf != NULL);
memset(buf, 0xff, blocksize);

/*
* On NetBSD7, .offset starts from one block. What is the block??
* On NetBSD9, .offset starts from zero.
*/
if (netbsd < 9) {
initial_offset = blocksize;
} else {
initial_offset = 0;
}

/* When just opened, all are zero. */
r = IOCTL(fd, AUDIO_GETOOFFS, &o, "");
XP_SYS_EQ(0, r);
XP_EQ(0, o.samples);
XP_EQ(0, o.deltablks);
XP_EQ(initial_offset, o.offset);

/* Even if wait (at least) one block, these remain unchanged. */
usleep(blk_ms * 1000);
r = IOCTL(fd, AUDIO_GETOOFFS, &o, "");
XP_SYS_EQ(0, r);
XP_EQ(0, o.samples);
XP_EQ(0, o.deltablks);
XP_EQ(initial_offset, o.offset);

/* Write one block. */
r = WRITE(fd, buf, blocksize);
if (mode2play(openmode)) {
XP_SYS_EQ(blocksize, r);
} else {
XP_SYS_NG(EBADF, r);
}
r = IOCTL(fd, AUDIO_DRAIN, NULL, "");
REQUIRED_SYS_EQ(0, r);

r = IOCTL(fd, AUDIO_GETOOFFS, &o, "");
XP_SYS_EQ(0, r);
if (mode2play(openmode)) {
/* All advance one block. */
XP_EQ(blocksize, o.samples);
XP_EQ(1, o.deltablks);
XP_EQ(initial_offset + blocksize, o.offset);
} else {
/*
* All are zero on non-play track.
* On NetBSD7, the rec track has play buffer, too.
*/
XP_EQ(0, o.samples);
XP_EQ(0, o.deltablks);
XP_EQ(initial_offset, o.offset);
}

r = CLOSE(fd);
XP_SYS_EQ(0, r);

free(buf);
}
DEF(AUDIO_GETOOFFS_one_RDONLY) { test_AUDIO_GETOOFFS_one(O_RDONLY); }
DEF(AUDIO_GETOOFFS_one_WRONLY) { test_AUDIO_GETOOFFS_one(O_WRONLY); }
DEF(AUDIO_GETOOFFS_one_RDWR) { test_AUDIO_GETOOFFS_one(O_RDWR); }

/*
* AUDIO_GETOOFFS when wrap around buffer.
*/
void
test_AUDIO_GETOOFFS_wrap(int openmode)
{
struct audio_info ai;
audio_offset_t o;
char *buf;
int fd;
int r;
u_int blocksize;
u_int buffer_size;
u_int initial_offset;
u_int nblks;

TEST("AUDIO_GETOOFFS_wrap_%s", openmode_str[openmode] + 2);
if (mode2aumode(openmode) == 0) {
XP_SKIP("Operation not allowed on this hardware property");
return;
}

fd = OPEN(devaudio, openmode);
REQUIRED_SYS_OK(fd);

#if 1
/* To save test time, use larger format if possible. */
AUDIO_INITINFO(&ai);
ai.play.encoding = AUDIO_ENCODING_SLINEAR_NE;
ai.play.precision = 16;
ai.play.channels = 2;
ai.play.sample_rate = 48000;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "slinear16/2/48000");
if (r != 0)
#endif
{
/*
* If it cannot be set, use common format instead.
* May be happened on NetBSD7/8.
*/
AUDIO_INITINFO(&ai);
ai.play.encoding = AUDIO_ENCODING_ULAW;
ai.play.precision = 8;
ai.play.channels = 1;
ai.play.sample_rate = 8000;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "ulaw/1/8000");
}
REQUIRED_SYS_EQ(0, r);

/* Get buffer_size and blocksize. */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);
buffer_size = ai.play.buffer_size;
blocksize = ai.blocksize;
nblks = buffer_size / blocksize;
DPRINTF(" > buffer_size=%u blocksize=%u nblks=%u\n",
buffer_size, blocksize, nblks);

buf = (char *)malloc(buffer_size);
REQUIRED_IF(buf != NULL);
memset(buf, 0xff, buffer_size);

/*
* On NetBSD7, .offset starts from one block. What is the block??
* On NetBSD9, .offset starts from zero.
*/
if (netbsd < 9) {
initial_offset = blocksize;
} else {
initial_offset = 0;
}

/* Write full buffer. */
r = WRITE(fd, buf, buffer_size);
if (mode2play(openmode)) {
XP_SYS_EQ(buffer_size, r);

/* Then, wait. */
r = IOCTL(fd, AUDIO_DRAIN, NULL, "");
REQUIRED_SYS_EQ(0, r);
} else {
XP_SYS_NG(EBADF, r);
}

/*
* .deltablks is number of blocks since last checked.
* .offset is wrapped around to zero.
*/
r = IOCTL(fd, AUDIO_GETOOFFS, &o, "");
XP_SYS_EQ(0, r);
if (mode2play(openmode)) {
/*
* On NetBSD7, samples may be blocksize * nblks or buffer_size
* depending on native/emulated encoding.
* On NetBSD9, samples is always equal to buffer_size.
*/
if (buffer_size != blocksize * nblks &&
o.samples == blocksize * nblks) {
DPRINTF(" > %d: samples(%u) == blocksize * nblks\n",
__LINE__, o.samples);
} else {
XP_EQ(buffer_size, o.samples);
}
XP_EQ(nblks, o.deltablks);
XP_EQ(initial_offset, o.offset);
} else {
/*
* On non-play track, it silently succeeds with zero.
* But on NetBSD7, RDONLY descriptor also has play buffer.
*/
XP_EQ(0, o.samples);
XP_EQ(0, o.deltablks);
XP_EQ(initial_offset, o.offset);
}

r = CLOSE(fd);
XP_SYS_EQ(0, r);

free(buf);
}
DEF(AUDIO_GETOOFFS_wrap_RDONLY) { test_AUDIO_GETOOFFS_wrap(O_RDONLY); }
DEF(AUDIO_GETOOFFS_wrap_WRONLY) { test_AUDIO_GETOOFFS_wrap(O_WRONLY); }
DEF(AUDIO_GETOOFFS_wrap_RDWR) { test_AUDIO_GETOOFFS_wrap(O_RDWR); }

/*
* Check whether AUDIO_FLUSH clears AUDIO_GETOOFFS.
*/
void
test_AUDIO_GETOOFFS_flush(int openmode)
{
struct audio_info ai;
audio_offset_t o;
char *buf;
int fd;
int r;
u_int initial_offset;
u_int last_offset;

TEST("AUDIO_GETOOFFS_flush_%s", openmode_str[openmode] + 2);
if (mode2aumode(openmode) == 0) {
XP_SKIP("Operation not allowed on this hardware property");
return;
}

fd = OPEN(devaudio, openmode);
REQUIRED_SYS_OK(fd);

#if 0
/* On NetBSD7/8, native encoding changes buffer behavior. */
AUDIO_INITINFO(&ai);
ai.play.encoding = AUDIO_ENCODING_SLINEAR_NE;
ai.play.precision = 16;
ai.play.channels = 2;
ai.play.sample_rate = 48000;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);
#endif

/* Get blocksize. */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);

buf = (char *)malloc(ai.blocksize);
REQUIRED_IF(buf != NULL);
memset(buf, 0xff, ai.blocksize);

/*
* On NetBSD7, .offset starts from one block. What is the block??
* On NetBSD9, .offset starts from zero.
*/
if (netbsd < 9) {
initial_offset = ai.blocksize;
} else {
initial_offset = 0;
}

/* Write one block. */
r = WRITE(fd, buf, ai.blocksize);
if (mode2play(openmode)) {
XP_SYS_EQ(ai.blocksize, r);
} else {
XP_SYS_NG(EBADF, r);
}
r = IOCTL(fd, AUDIO_DRAIN, NULL, "");
XP_SYS_EQ(0, r);

/* Obtain once. */
r = IOCTL(fd, AUDIO_GETOOFFS, &o, "");
XP_SYS_EQ(0, r);
if (mode2play(openmode)) {
XP_EQ(ai.blocksize, o.samples);
XP_EQ(1, o.deltablks);
XP_EQ(initial_offset + ai.blocksize, o.offset);
} else {
/*
* On non-play track, it silently succeeds with zero.
* But on NetBSD7, RDONLY descriptor also has play buffer.
*/
XP_EQ(0, o.samples);
XP_EQ(0, o.deltablks);
XP_EQ(initial_offset, o.offset);
}

/* Write one more block to advance .offset. */
r = WRITE(fd, buf, ai.blocksize);
if (mode2play(openmode)) {
XP_SYS_EQ(ai.blocksize, r);
} else {
XP_SYS_NG(EBADF, r);
}
r = IOCTL(fd, AUDIO_DRAIN, NULL, "");
XP_SYS_EQ(0, r);

/* If offset remains unchanged, this is expected offset. */
last_offset = initial_offset + ai.blocksize * 2;

/* Then, flush. */
r = IOCTL(fd, AUDIO_FLUSH, NULL, "");
REQUIRED_SYS_EQ(0, r);

/* All should be cleared. */
r = IOCTL(fd, AUDIO_GETOOFFS, &o, "");
XP_SYS_EQ(0, r);
XP_EQ(0, o.samples);
XP_EQ(0, o.deltablks);
if (mode2play(openmode)) {
/*
* On NetBSD7,
* offset is cleared if native encodings(?), but remains
* unchanged if emulated encodings(?). Looks a bug.
* On NetBSD9, it should always be cleared.
*/
if (netbsd < 9 && o.offset == last_offset) {
DPRINTF(" > %d: offset(%u) == last_offset\n",
__LINE__, o.offset);
} else {
XP_EQ(initial_offset, o.offset);
}
} else {
XP_EQ(initial_offset, o.offset);
}

r = CLOSE(fd);
XP_SYS_EQ(0, r);

free(buf);
}
DEF(AUDIO_GETOOFFS_flush_RDONLY) { test_AUDIO_GETOOFFS_flush(O_RDONLY); }
DEF(AUDIO_GETOOFFS_flush_WRONLY) { test_AUDIO_GETOOFFS_flush(O_WRONLY); }
DEF(AUDIO_GETOOFFS_flush_RDWR) { test_AUDIO_GETOOFFS_flush(O_RDWR); }

/*
* Check whether AUDIO_SETINFO(encoding) clears AUDIO_GETOOFFS.
*/
void
test_AUDIO_GETOOFFS_set(int openmode)
{
struct audio_info ai;
audio_offset_t o;
char *buf;
int fd;
int r;
u_int initial_offset;

TEST("AUDIO_GETOOFFS_set_%s", openmode_str[openmode] + 2);
if (mode2aumode(openmode) == 0) {
XP_SKIP("Operation not allowed on this hardware property");
return;
}

fd = OPEN(devaudio, openmode);
REQUIRED_SYS_OK(fd);

/* Get blocksize. */
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
XP_SYS_EQ(0, r);

buf = (char *)malloc(ai.blocksize);
REQUIRED_IF(buf != NULL);
memset(buf, 0xff, ai.blocksize);

/*
* On NetBSD7, .offset starts from one block. What is the block??
* On NetBSD9, .offset starts from zero.
*/
if (netbsd < 9) {
initial_offset = ai.blocksize;
} else {
initial_offset = 0;
}

/* Write one block. */
r = WRITE(fd, buf, ai.blocksize);
if (mode2play(openmode)) {
XP_SYS_EQ(ai.blocksize, r);
} else {
XP_SYS_NG(EBADF, r);
}
r = IOCTL(fd, AUDIO_DRAIN, NULL, "");
XP_SYS_EQ(0, r);

/*
* Then, change encoding.
* If we fail to change it, we cannot continue. This may happen
* on NetBSD7/8.
*/
AUDIO_INITINFO(&ai);
ai.play.encoding = AUDIO_ENCODING_SLINEAR_NE;
ai.play.precision = 16;
ai.play.channels = 2;
ai.play.sample_rate = 48000;
r = IOCTL(fd, AUDIO_SETINFO, &ai, "slinear16/2ch/48000");
REQUIRED_SYS_EQ(0, r);

r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
REQUIRED_SYS_EQ(0, r);
if (netbsd < 9) {
initial_offset = ai.blocksize;
} else {
initial_offset = 0;
}

/* Clear counters? */
r = IOCTL(fd, AUDIO_GETOOFFS, &o, "");
XP_SYS_EQ(0, r);
XP_EQ(0, o.samples);
XP_EQ(0, o.deltablks);
XP_EQ(initial_offset, o.offset);

r = CLOSE(fd);
XP_SYS_EQ(0, r);

free(buf);
}
DEF(AUDIO_GETOOFFS_set_RDONLY) { test_AUDIO_GETOOFFS_set(O_RDONLY); }
DEF(AUDIO_GETOOFFS_set_WRONLY) { test_AUDIO_GETOOFFS_set(O_WRONLY); }
DEF(AUDIO_GETOOFFS_set_RDWR) { test_AUDIO_GETOOFFS_set(O_RDWR); }

/*
* /dev/audioctl can always be opened while /dev/audio is open.
*/
void
test_audioctl_open_1(int fmode, int cmode)
{
int fd;
int ctl;
int r;

TEST("audioctl_open_1_%s_%s",
openmode_str[fmode] + 2, openmode_str[cmode] + 2);
if (hw_canplay() == 0 && fmode == O_WRONLY) {
XP_SKIP("This test is for playable device");
return;
}
if (hw_canrec() == 0 && fmode == O_RDONLY) {
XP_SKIP("This test is for recordable device");
return;
}

fd = OPEN(devaudio, fmode);
REQUIRED_SYS_OK(fd);

ctl = OPEN(devaudioctl, cmode);
XP_SYS_OK(ctl);

r = CLOSE(ctl);
XP_SYS_EQ(0, r);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}
DEF(audioctl_open_1_RDONLY_RDONLY) { test_audioctl_open_1(O_RDONLY, O_RDONLY); }
DEF(audioctl_open_1_RDONLY_RWONLY) { test_audioctl_open_1(O_RDONLY, O_WRONLY); }
DEF(audioctl_open_1_RDONLY_RDWR) { test_audioctl_open_1(O_RDONLY, O_RDWR); }
DEF(audioctl_open_1_WRONLY_RDONLY) { test_audioctl_open_1(O_WRONLY, O_RDONLY); }
DEF(audioctl_open_1_WRONLY_RWONLY) { test_audioctl_open_1(O_WRONLY, O_WRONLY); }
DEF(audioctl_open_1_WRONLY_RDWR) { test_audioctl_open_1(O_WRONLY, O_RDWR); }
DEF(audioctl_open_1_RDWR_RDONLY) { test_audioctl_open_1(O_RDWR, O_RDONLY); }
DEF(audioctl_open_1_RDWR_RWONLY) { test_audioctl_open_1(O_RDWR, O_WRONLY); }
DEF(audioctl_open_1_RDWR_RDWR) { test_audioctl_open_1(O_RDWR, O_RDWR); }

/*
* /dev/audio can always be opened while /dev/audioctl is open.
*/
void
test_audioctl_open_2(int fmode, int cmode)
{
int fd;
int ctl;
int r;

TEST("audioctl_open_2_%s_%s",
openmode_str[fmode] + 2, openmode_str[cmode] + 2);
if (hw_canplay() == 0 && fmode == O_WRONLY) {
XP_SKIP("This test is for playable device");
return;
}
if (hw_canrec() == 0 && fmode == O_RDONLY) {
XP_SKIP("This test is for recordable device");
return;
}

ctl = OPEN(devaudioctl, cmode);
REQUIRED_SYS_OK(ctl);

fd = OPEN(devaudio, fmode);
XP_SYS_OK(fd);

r = CLOSE(fd);
XP_SYS_EQ(0, r);

r = CLOSE(ctl);
XP_SYS_EQ(0, r);
}
DEF(audioctl_open_2_RDONLY_RDONLY) { test_audioctl_open_2(O_RDONLY, O_RDONLY); }
DEF(audioctl_open_2_RDONLY_RWONLY) { test_audioctl_open_2(O_RDONLY, O_WRONLY); }
DEF(audioctl_open_2_RDONLY_RDWR) { test_audioctl_open_2(O_RDONLY, O_RDWR); }
DEF(audioctl_open_2_WRONLY_RDONLY) { test_audioctl_open_2(O_WRONLY, O_RDONLY); }
DEF(audioctl_open_2_WRONLY_RWONLY) { test_audioctl_open_2(O_WRONLY, O_WRONLY); }
DEF(audioctl_open_2_WRONLY_RDWR) { test_audioctl_open_2(O_WRONLY, O_RDWR); }
DEF(audioctl_open_2_RDWR_RDONLY) { test_audioctl_open_2(O_RDWR, O_RDONLY); }
DEF(audioctl_open_2_RDWR_RWONLY) { test_audioctl_open_2(O_RDWR, O_WRONLY); }
DEF(audioctl_open_2_RDWR_RDWR) { test_audioctl_open_2(O_RDWR, O_RDWR); }

/*
* Open multiple /dev/audioctl.
*/
DEF(audioctl_open_simul)
{
int ctl0;
int ctl1;
int r;

TEST("audioctl_open_simul");

ctl0 = OPEN(devaudioctl, O_RDWR);
REQUIRED_SYS_OK(ctl0);

ctl1 = OPEN(devaudioctl, O_RDWR);
XP_SYS_OK(ctl1);

r = CLOSE(ctl0);
XP_SYS_EQ(0, r);

r = CLOSE(ctl1);
XP_SYS_EQ(0, r);
}

/*
* /dev/audioctl can be opened by other user who opens /dev/audioctl,
* /dev/audioctl can be opened by other user who opens /dev/audio,
* /dev/audio can be opened by other user who opens /dev/audioctl,
* regardless of multiuser mode.
*/
void
try_audioctl_open_multiuser(const char *dev1, const char *dev2)
{
int fd1;
int fd2;
int r;
uid_t ouid;

/*
* At first, open dev1 as root.
* And then open dev2 as unprivileged user.
*/

fd1 = OPEN(dev1, O_RDWR);
REQUIRED_SYS_OK(fd1);

ouid = GETUID();
r = SETEUID(1);
REQUIRED_SYS_EQ(0, r);

fd2 = OPEN(dev2, O_RDWR);
XP_SYS_OK(fd2);

/* Close */
r = CLOSE(fd2);
XP_SYS_EQ(0, r);

r = SETEUID(ouid);
REQUIRED_SYS_EQ(0, r);

r = CLOSE(fd1);
XP_SYS_EQ(0, r);
}
/*
* This is a wrapper for audioctl_open_multiuser.
* XXX XP_* macros are not compatible with on-error-goto, we need try-catch...
*/
void
test_audioctl_open_multiuser(bool multiuser,
const char *dev1, const char *dev2)
{
char mibname[32];
bool oldval;
size_t oldlen;
int r;

if (netbsd < 8 && multiuser == 1) {
XP_SKIP("multiuser is not supported");
return;
}
if (netbsd < 9) {
/* NetBSD8 has no way (difficult) to determine device name */
XP_SKIP("NetBSD8 cannot determine device name");
return;
}
if (geteuid() != 0) {
XP_SKIP("This test must be privileged user");
return;
}

/* Get current multiuser mode (and save it) */
snprintf(mibname, sizeof(mibname), "hw.%s.multiuser", devicename);
oldlen = sizeof(oldval);
r = SYSCTLBYNAME(mibname, &oldval, &oldlen, NULL, 0);
REQUIRED_SYS_EQ(0, r);
DPRINTF(" > multiuser=%d\n", oldval);

/* Change if necessary */
if (oldval != multiuser) {
r = SYSCTLBYNAME(mibname, NULL, NULL, &multiuser,
sizeof(multiuser));
REQUIRED_SYS_EQ(0, r);
DPRINTF(" > new multiuser=%d\n", multiuser);
}

/* Do test */
try_audioctl_open_multiuser(dev1, dev2);

/* Restore multiuser mode */
if (oldval != multiuser) {
DPRINTF(" > restore multiuser to %d\n", oldval);
r = SYSCTLBYNAME(mibname, NULL, NULL, &oldval, sizeof(oldval));
XP_SYS_EQ(0, r);
}
}
DEF(audioctl_open_multiuser0_audio1) {
TEST("audioctl_open_multiuser0_audio1");
test_audioctl_open_multiuser(false, devaudio, devaudioctl);
}
DEF(audioctl_open_multiuser1_audio1) {
TEST("audioctl_open_multiuser1_audio1");
test_audioctl_open_multiuser(true, devaudio, devaudioctl);
}
DEF(audioctl_open_multiuser0_audio2) {
TEST("audioctl_open_multiuser0_audio2");
test_audioctl_open_multiuser(false, devaudioctl, devaudio);
}
DEF(audioctl_open_multiuser1_audio2) {
TEST("audioctl_open_multiuser1_audio2");
test_audioctl_open_multiuser(true, devaudioctl, devaudio);
}
DEF(audioctl_open_multiuser0_audioctl) {
TEST("audioctl_open_multiuser0_audioctl");
test_audioctl_open_multiuser(false, devaudioctl, devaudioctl);
}
DEF(audioctl_open_multiuser1_audioctl) {
TEST("audioctl_open_multiuser1_audioctl");
test_audioctl_open_multiuser(true, devaudioctl, devaudioctl);
}

/*
* /dev/audioctl cannot be read/written regardless of its open mode.
*/
void
test_audioctl_rw(int openmode)
{
char buf[1];
int fd;
int r;

TEST("audioctl_rw_%s", openmode_str[openmode] + 2);

fd = OPEN(devaudioctl, openmode);
REQUIRED_SYS_OK(fd);

if (mode2play(openmode)) {
r = WRITE(fd, buf, sizeof(buf));
XP_SYS_NG(ENODEV, r);
}

if (mode2rec(openmode)) {
r = READ(fd, buf, sizeof(buf));
XP_SYS_NG(ENODEV, r);
}

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}
DEF(audioctl_rw_RDONLY) { test_audioctl_rw(O_RDONLY); }
DEF(audioctl_rw_WRONLY) { test_audioctl_rw(O_WRONLY); }
DEF(audioctl_rw_RDWR) { test_audioctl_rw(O_RDWR); }

/*
* poll(2) for /dev/audioctl should never raise.
* I'm not sure about consistency between poll(2) and kqueue(2) but
* anyway I follow it.
* XXX Omit checking each openmode
*/
DEF(audioctl_poll)
{
struct pollfd pfd;
int fd;
int r;

TEST("audioctl_poll");

fd = OPEN(devaudioctl, O_WRONLY);
REQUIRED_SYS_OK(fd);

pfd.fd = fd;
pfd.events = POLLOUT;
r = POLL(&pfd, 1, 100);
XP_SYS_EQ(0, r);
XP_EQ(0, pfd.revents);

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}

/*
* kqueue(2) for /dev/audioctl fails.
* I'm not sure about consistency between poll(2) and kqueue(2) but
* anyway I follow it.
* XXX Omit checking each openmode
*/
DEF(audioctl_kqueue)
{
struct kevent kev;
int fd;
int kq;
int r;

TEST("audioctl_kqueue");

fd = OPEN(devaudioctl, O_WRONLY);
REQUIRED_SYS_OK(fd);

kq = KQUEUE();
XP_SYS_OK(kq);

EV_SET(&kev, fd, EVFILT_WRITE, EV_ADD, 0, 0, 0);
r = KEVENT_SET(kq, &kev, 1);
/*
* NetBSD7 has a bug. It looks to wanted to treat it as successful
* but returned 1(== EPERM).
* On NetBSD9, I decided to return ENODEV.
*/
if (netbsd < 8) {
XP_SYS_NG(1/*EPERM*/, r);
} else {
XP_SYS_NG(ENODEV, r);
}

r = CLOSE(fd);
XP_SYS_EQ(0, r);
}

/*
* This table is processed by t_audio.awk!
* Keep /^\tENT(testname),/ format in order to add to atf.
*/
#define ENT(x) { #x, test__ ## x }
struct testentry testtable[] = {
ENT(open_mode_RDONLY),
ENT(open_mode_WRONLY),
ENT(open_mode_RDWR),
ENT(open_audio_RDONLY),
ENT(open_audio_WRONLY),
ENT(open_audio_RDWR),
ENT(open_sound_RDONLY),
ENT(open_sound_WRONLY),
ENT(open_sound_RDWR),
ENT(open_audioctl_RDONLY),
ENT(open_audioctl_WRONLY),
ENT(open_audioctl_RDWR),
ENT(open_sound_sticky),
ENT(open_audioctl_sticky),
ENT(open_simul_RDONLY_RDONLY),
ENT(open_simul_RDONLY_WRONLY),
ENT(open_simul_RDONLY_RDWR),
ENT(open_simul_WRONLY_RDONLY),
ENT(open_simul_WRONLY_WRONLY),
ENT(open_simul_WRONLY_RDWR),
ENT(open_simul_RDWR_RDONLY),
ENT(open_simul_RDWR_WRONLY),
ENT(open_simul_RDWR_RDWR),
/**/ ENT(open_multiuser_0), // XXX TODO sysctl
/**/ ENT(open_multiuser_1), // XXX TODO sysctl
ENT(write_PLAY_ALL),
ENT(write_PLAY),
ENT(read),
ENT(rept_write),
ENT(rept_read),
ENT(rdwr_fallback_RDONLY),
ENT(rdwr_fallback_WRONLY),
ENT(rdwr_fallback_RDWR),
ENT(rdwr_two_RDONLY_RDONLY),
ENT(rdwr_two_RDONLY_WRONLY),
ENT(rdwr_two_RDONLY_RDWR),
ENT(rdwr_two_WRONLY_RDONLY),
ENT(rdwr_two_WRONLY_WRONLY),
ENT(rdwr_two_WRONLY_RDWR),
ENT(rdwr_two_RDWR_RDONLY),
ENT(rdwr_two_RDWR_WRONLY),
ENT(rdwr_two_RDWR_RDWR),
ENT(rdwr_simul),
ENT(drain_incomplete),
ENT(drain_pause),
ENT(drain_onrec),
/**/ ENT(mmap_mode_RDONLY_NONE), // XXX rump doesn't support mmap
/**/ ENT(mmap_mode_RDONLY_READ), // XXX rump doesn't support mmap
/**/ ENT(mmap_mode_RDONLY_WRITE), // XXX rump doesn't support mmap
/**/ ENT(mmap_mode_RDONLY_READWRITE),// XXX rump doesn't support mmap
/**/ ENT(mmap_mode_WRONLY_NONE), // XXX rump doesn't support mmap
/**/ ENT(mmap_mode_WRONLY_READ), // XXX rump doesn't support mmap
/**/ ENT(mmap_mode_WRONLY_WRITE), // XXX rump doesn't support mmap
/**/ ENT(mmap_mode_WRONLY_READWRITE),// XXX rump doesn't support mmap
/**/ ENT(mmap_mode_RDWR_NONE), // XXX rump doesn't support mmap
/**/ ENT(mmap_mode_RDWR_READ), // XXX rump doesn't support mmap
/**/ ENT(mmap_mode_RDWR_WRITE), // XXX rump doesn't support mmap
/**/ ENT(mmap_mode_RDWR_READWRITE), // XXX rump doesn't support mmap
/**/ ENT(mmap_len_0), // XXX rump doesn't support mmap
/**/ ENT(mmap_len_1), // XXX rump doesn't support mmap
/**/ ENT(mmap_len_2), // XXX rump doesn't support mmap
/**/ ENT(mmap_len_3), // XXX rump doesn't support mmap
/**/ ENT(mmap_len_4), // XXX rump doesn't support mmap
/**/ ENT(mmap_len_5), // XXX rump doesn't support mmap
/**/ ENT(mmap_len_6), // XXX rump doesn't support mmap
/**/ ENT(mmap_len_7), // XXX rump doesn't support mmap
/**/ ENT(mmap_len_8), // XXX rump doesn't support mmap
/**/ ENT(mmap_twice), // XXX rump doesn't support mmap
/**/ ENT(mmap_multi), // XXX rump doesn't support mmap
ENT(poll_mode_RDONLY_IN),
ENT(poll_mode_RDONLY_OUT),
ENT(poll_mode_RDONLY_INOUT),
ENT(poll_mode_WRONLY_IN),
ENT(poll_mode_WRONLY_OUT),
ENT(poll_mode_WRONLY_INOUT),
ENT(poll_mode_RDWR_IN),
ENT(poll_mode_RDWR_OUT),
ENT(poll_mode_RDWR_INOUT),
ENT(poll_out_empty),
ENT(poll_out_full),
ENT(poll_out_hiwat),
/**/ ENT(poll_out_unpause), // XXX does not seem to work on rump
/**/ ENT(poll_out_simul), // XXX does not seem to work on rump
ENT(poll_in_open_audio),
ENT(poll_in_open_sound),
ENT(poll_in_open_audioctl),
ENT(poll_in_simul),
ENT(kqueue_mode_RDONLY_READ),
ENT(kqueue_mode_RDONLY_WRITE),
ENT(kqueue_mode_WRONLY_READ),
ENT(kqueue_mode_WRONLY_WRITE),
ENT(kqueue_mode_RDWR_READ),
ENT(kqueue_mode_RDWR_WRITE),
ENT(kqueue_empty),
ENT(kqueue_full),
ENT(kqueue_hiwat),
/**/ ENT(kqueue_unpause), // XXX does not seem to work on rump
/**/ ENT(kqueue_simul), // XXX does not seem to work on rump
ENT(ioctl_while_write),
ENT(FIOASYNC_reset),
ENT(FIOASYNC_play_signal),
ENT(FIOASYNC_rec_signal),
/**/ ENT(FIOASYNC_multi), // XXX does not seem to work on rump
ENT(AUDIO_WSEEK),
ENT(AUDIO_SETFD_RDONLY),
ENT(AUDIO_SETFD_WRONLY),
ENT(AUDIO_SETFD_RDWR),
ENT(AUDIO_GETINFO_eof),
ENT(AUDIO_SETINFO_mode_RDONLY_0),
ENT(AUDIO_SETINFO_mode_RDONLY_1),
ENT(AUDIO_SETINFO_mode_RDONLY_2),
ENT(AUDIO_SETINFO_mode_RDONLY_3),
ENT(AUDIO_SETINFO_mode_RDONLY_4),
ENT(AUDIO_SETINFO_mode_RDONLY_5),
ENT(AUDIO_SETINFO_mode_RDONLY_6),
ENT(AUDIO_SETINFO_mode_RDONLY_7),
ENT(AUDIO_SETINFO_mode_RDONLY_8),
ENT(AUDIO_SETINFO_mode_WRONLY_0),
ENT(AUDIO_SETINFO_mode_WRONLY_1),
ENT(AUDIO_SETINFO_mode_WRONLY_2),
ENT(AUDIO_SETINFO_mode_WRONLY_3),
ENT(AUDIO_SETINFO_mode_WRONLY_4),
ENT(AUDIO_SETINFO_mode_WRONLY_5),
ENT(AUDIO_SETINFO_mode_WRONLY_6),
ENT(AUDIO_SETINFO_mode_WRONLY_7),
ENT(AUDIO_SETINFO_mode_WRONLY_8),
ENT(AUDIO_SETINFO_mode_RDWR_0),
ENT(AUDIO_SETINFO_mode_RDWR_1),
ENT(AUDIO_SETINFO_mode_RDWR_2),
ENT(AUDIO_SETINFO_mode_RDWR_3),
ENT(AUDIO_SETINFO_mode_RDWR_4),
ENT(AUDIO_SETINFO_mode_RDWR_5),
ENT(AUDIO_SETINFO_mode_RDWR_6),
ENT(AUDIO_SETINFO_mode_RDWR_7),
ENT(AUDIO_SETINFO_mode_RDWR_8),
ENT(AUDIO_SETINFO_params_set_RDONLY_0),
ENT(AUDIO_SETINFO_params_set_RDONLY_1),
ENT(AUDIO_SETINFO_params_set_WRONLY_0),
ENT(AUDIO_SETINFO_params_set_WRONLY_1),
ENT(AUDIO_SETINFO_params_set_WRONLY_2),
ENT(AUDIO_SETINFO_params_set_WRONLY_3),
ENT(AUDIO_SETINFO_params_set_RDWR_0),
ENT(AUDIO_SETINFO_params_set_RDWR_1),
ENT(AUDIO_SETINFO_params_set_RDWR_2),
ENT(AUDIO_SETINFO_params_set_RDWR_3),
ENT(AUDIO_SETINFO_params_simul),
ENT(AUDIO_SETINFO_channels),
ENT(AUDIO_SETINFO_sample_rate),
ENT(AUDIO_SETINFO_sample_rate_0),
ENT(AUDIO_SETINFO_pause_RDONLY_0),
ENT(AUDIO_SETINFO_pause_RDONLY_1),
ENT(AUDIO_SETINFO_pause_WRONLY_0),
ENT(AUDIO_SETINFO_pause_WRONLY_1),
ENT(AUDIO_SETINFO_pause_WRONLY_2),
ENT(AUDIO_SETINFO_pause_WRONLY_3),
ENT(AUDIO_SETINFO_pause_RDWR_0),
ENT(AUDIO_SETINFO_pause_RDWR_1),
ENT(AUDIO_SETINFO_pause_RDWR_2),
ENT(AUDIO_SETINFO_pause_RDWR_3),
ENT(AUDIO_SETINFO_gain),
ENT(AUDIO_SETINFO_gain_balance),
/**/ ENT(AUDIO_SETINFO_mmap_enc), // XXX rump doesn't support mmap
/**/ ENT(AUDIO_SETINFO_mmap_pause), // XXX rump doesn't support mmap
ENT(AUDIO_GETENC_range),
ENT(AUDIO_GETENC_error),
ENT(AUDIO_ERROR_RDONLY),
ENT(AUDIO_ERROR_WRONLY),
ENT(AUDIO_ERROR_RDWR),
ENT(AUDIO_GETIOFFS_one_RDONLY),
ENT(AUDIO_GETIOFFS_one_WRONLY),
ENT(AUDIO_GETIOFFS_one_RDWR),
ENT(AUDIO_GETOOFFS_one_RDONLY),
ENT(AUDIO_GETOOFFS_one_WRONLY),
ENT(AUDIO_GETOOFFS_one_RDWR),
ENT(AUDIO_GETOOFFS_wrap_RDONLY),
ENT(AUDIO_GETOOFFS_wrap_WRONLY),
ENT(AUDIO_GETOOFFS_wrap_RDWR),
ENT(AUDIO_GETOOFFS_flush_RDONLY),
ENT(AUDIO_GETOOFFS_flush_WRONLY),
ENT(AUDIO_GETOOFFS_flush_RDWR),
ENT(AUDIO_GETOOFFS_set_RDONLY),
ENT(AUDIO_GETOOFFS_set_WRONLY),
ENT(AUDIO_GETOOFFS_set_RDWR),
ENT(audioctl_open_1_RDONLY_RDONLY),
ENT(audioctl_open_1_RDONLY_RWONLY),
ENT(audioctl_open_1_RDONLY_RDWR),
ENT(audioctl_open_1_WRONLY_RDONLY),
ENT(audioctl_open_1_WRONLY_RWONLY),
ENT(audioctl_open_1_WRONLY_RDWR),
ENT(audioctl_open_1_RDWR_RDONLY),
ENT(audioctl_open_1_RDWR_RWONLY),
ENT(audioctl_open_1_RDWR_RDWR),
ENT(audioctl_open_2_RDONLY_RDONLY),
ENT(audioctl_open_2_RDONLY_RWONLY),
ENT(audioctl_open_2_RDONLY_RDWR),
ENT(audioctl_open_2_WRONLY_RDONLY),
ENT(audioctl_open_2_WRONLY_RWONLY),
ENT(audioctl_open_2_WRONLY_RDWR),
ENT(audioctl_open_2_RDWR_RDONLY),
ENT(audioctl_open_2_RDWR_RWONLY),
ENT(audioctl_open_2_RDWR_RDWR),
ENT(audioctl_open_simul),
/**/ ENT(audioctl_open_multiuser0_audio1), // XXX TODO sysctl
/**/ ENT(audioctl_open_multiuser1_audio1), // XXX TODO sysctl
/**/ ENT(audioctl_open_multiuser0_audio2), // XXX TODO sysctl
/**/ ENT(audioctl_open_multiuser1_audio2), // XXX TODO sysctl
/**/ ENT(audioctl_open_multiuser0_audioctl), // XXX TODO sysctl
/**/ ENT(audioctl_open_multiuser1_audioctl), // XXX TODO sysctl
ENT(audioctl_rw_RDONLY),
ENT(audioctl_rw_WRONLY),
ENT(audioctl_rw_RDWR),
ENT(audioctl_poll),
ENT(audioctl_kqueue),
{.name = NULL},
};