 @@ -1,14 +1,14 @@
-/*	$NetBSD: audio.c,v 1.55 2020/02/23 04:24:56 isaki Exp $	*/
+/*	$NetBSD: audio.c,v 1.56 2020/02/23 07:17:01 isaki Exp $	*/
 /*-
  * Copyright (c) 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * 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.
 @@ -132,27 +132,27 @@
  *   these may be also called after attach, the thread lock is required.
+ *
  * In addition, there is an additional lock.
+ *
  * - track->lock.  This is an atomic variable and is similar to the
  *   "interrupt lock".  This is one for each track.  If any thread context
  *   (and software interrupt context) and hardware interrupt context who
  *   want to access some variables on this track, they must acquire this
  *   lock before.  It protects track's consistency between hardware
  *   interrupt context and others.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: audio.c,v 1.55 2020/02/23 04:24:56 isaki Exp $");
+__KERNEL_RCSID(0, "$NetBSD: audio.c,v 1.56 2020/02/23 07:17:01 isaki Exp $");
 #ifdef _KERNEL_OPT
 #include "audio.h"
 #include "midi.h"
 #endif
 #if NAUDIO > 0
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/atomic.h>
 #include <sys/audioio.h>
 #include <sys/conf.h>
 @@ -489,58 +489,60 @@ static bool audio_suspend(device_t dv, c
 static bool audio_resume(device_t dv, const pmf_qual_t *);
 static void audio_volume_down(device_t);
 static void audio_volume_up(device_t);
 static void audio_volume_toggle(device_t);
 static void audio_mixer_capture(struct audio_softc *);
 static void audio_mixer_restore(struct audio_softc *);
 static void audio_softintr_rd(void *);
 static void audio_softintr_wr(void *);
 static int  audio_enter_exclusive(struct audio_softc *);
 static void audio_exit_exclusive(struct audio_softc *);
 static struct audio_softc *audio_file_enter(audio_file_t *, struct psref *);
 static void audio_file_exit(struct audio_softc *, struct psref *);
 static int audio_track_waitio(struct audio_softc *, audio_track_t *);
 static int audioclose(struct file *);
 static int audioread(struct file *, off_t *, struct uio *, kauth_cred_t, int);
 static int audiowrite(struct file *, off_t *, struct uio *, kauth_cred_t, int);
 static int audioioctl(struct file *, u_long, void *);
 static int audiopoll(struct file *, int);
 static int audiokqfilter(struct file *, struct knote *);
 static int audiommap(struct file *, off_t *, size_t, int, int *, int *,
 	struct uvm_object **, int *);
 static int audiostat(struct file *, struct stat *);
 static void filt_audiowrite_detach(struct knote *);
 static int  filt_audiowrite_event(struct knote *, long);
 static void filt_audioread_detach(struct knote *);
 static int  filt_audioread_event(struct knote *, long);
 static int audio_open(dev_t, struct audio_softc *, int, int, struct lwp *,
 	audio_file_t **);
 static int audio_close(struct audio_softc *, audio_file_t *);
 static int audio_unlink(struct audio_softc *, audio_file_t *);
 static int audio_read(struct audio_softc *, struct uio *, int, audio_file_t *);
 static int audio_write(struct audio_softc *, struct uio *, int, audio_file_t *);
 static void audio_file_clear(struct audio_softc *, audio_file_t *);
 static int audio_ioctl(dev_t, struct audio_softc *, u_long, void *, int,
 	struct lwp *, audio_file_t *);
 static int audio_poll(struct audio_softc *, int, struct lwp *, audio_file_t *);
 static int audio_kqfilter(struct audio_softc *, audio_file_t *, struct knote *);
 static int audio_mmap(struct audio_softc *, off_t *, size_t, int, int *, int *,
 	struct uvm_object **, int *, audio_file_t *);
 static int audioctl_open(dev_t, struct audio_softc *, int, int, struct lwp *);
 static int audioctl_close(struct audio_softc *, audio_file_t *);
 static void audio_pintr(void *);
 static void audio_rintr(void *);
 static int audio_query_devinfo(struct audio_softc *, mixer_devinfo_t *);
 static __inline int audio_track_readablebytes(const audio_track_t *);
 static int audio_file_setinfo(struct audio_softc *, audio_file_t *,
 	const struct audio_info *);
 static int audio_track_setinfo_check(audio_format2_t *,
 	const struct audio_prinfo *, const audio_format2_t *);
 static void audio_track_setinfo_water(audio_track_t *,
 	const struct audio_info *);
 @@ -800,26 +802,28 @@ static const audio_encoding_t audio_enco
 static const struct portname itable[] = {
 	{ AudioNmicrophone,	AUDIO_MICROPHONE },
 	{ AudioNline,		AUDIO_LINE_IN },
 	{ AudioNcd,		AUDIO_CD },
 	{ 0, 0 }
 };
 static const struct portname otable[] = {
 	{ AudioNspeaker,	AUDIO_SPEAKER },
 	{ AudioNheadphone,	AUDIO_HEADPHONE },
 	{ AudioNline,		AUDIO_LINE_OUT },
 	{ 0, 0 }
 };
 static struct psref_class *audio_psref_class __read_mostly;
 CFATTACH_DECL3_NEW(audio, sizeof(struct audio_softc),
     audiomatch, audioattach, audiodetach, audioactivate, audiorescan,
     audiochilddet, DVF_DETACH_SHUTDOWN);
 static int
 audiomatch(device_t parent, cfdata_t match, void *aux)
+{
 	struct audio_attach_args *sa;
 	sa = aux;
 	DPRINTF(1, "%s: type=%d sa=%p hw=%p\n",
 	     __func__, sa->type, sa, sa->hwif);
 	return (sa->type == AUDIODEV_TYPE_AUDIO) ? 1 : 0;
 @@ -988,26 +992,29 @@ audioattach(device_t parent, device_t se
 	/*
 	 * Init track mixers.  If at least one direction is available on
 	 * attach time, we assume a success.
 	 */
 	error = audio_mixers_init(sc, mode, &phwfmt, &rhwfmt, &pfil, &rfil);
 	mutex_exit(sc->sc_lock);
 	if (sc->sc_pmixer == NULL && sc->sc_rmixer == NULL) {
 		aprint_error_dev(self, "audio_mixers_init failed, "
 		    "error = %d\n", error);
 		goto bad;
+	}
 	sc->sc_psz = pserialize_create();
 	psref_target_init(&sc->sc_psref, audio_psref_class);
 	selinit(&sc->sc_wsel);
 	selinit(&sc->sc_rsel);
 	/* Initial parameter of /dev/sound */
 	sc->sc_sound_pparams = params_to_format2(&audio_default);
 	sc->sc_sound_rparams = params_to_format2(&audio_default);
 	sc->sc_sound_ppause = false;
 	sc->sc_sound_rpause = false;
 	/* XXX TODO: consider about sc_ai */
 	mixer_init(sc);
 	TRACE(2, "inputs ports=0x%x, input master=%d, "
 @@ -1245,65 +1252,81 @@ audioactivate(device_t self, enum devact
 		sc->sc_dying = true;
 		cv_broadcast(&sc->sc_exlockcv);
 		mutex_exit(sc->sc_lock);
 		return 0;
 	default:
 		return EOPNOTSUPP;
+	}
+}
 static int
 audiodetach(device_t self, int flags)
+{
 	struct audio_softc *sc;
-	int maj, mn;
+	struct audio_file *file;
 	int error;
 	sc = device_private(self);
 	TRACE(2, "flags=%d", flags);
 	/* device is not initialized */
 	if (sc->hw_if == NULL)
 		return 0;
 	/* Start draining existing accessors of the device. */
 	error = config_detach_children(self, flags);
 	if (error)
 		return error;
 	/* delete sysctl nodes */
 	sysctl_teardown(&sc->sc_log);
 	mutex_enter(sc->sc_lock);
 	sc->sc_dying = true;
 	cv_broadcast(&sc->sc_exlockcv);
 	if (sc->sc_pmixer)
 		cv_broadcast(&sc->sc_pmixer->outcv);
 	if (sc->sc_rmixer)
 		cv_broadcast(&sc->sc_rmixer->outcv);
 	mutex_exit(sc->sc_lock);
-	/* delete sysctl nodes */
+	/* Prevent new users */
-	sysctl_teardown(&sc->sc_log);
+	SLIST_FOREACH(file, &sc->sc_files, entry) {
 		atomic_store_relaxed(&file->dying, true);
+	}
 	/*
 	 * Wait for existing users to drain.
 	 * - pserialize_perform waits for all pserialize_read sections on
 	 *   all CPUs; after this, no more new psref_acquire can happen.
 	 * - psref_target_destroy waits for all extant acquired psrefs to
 	 *   be psref_released.
 	 */
 	pserialize_perform(sc->sc_psz);
 	mutex_exit(sc->sc_lock);
 	psref_target_destroy(&sc->sc_psref, audio_psref_class);
-	/* locate the major number */
+	/*
-	maj = cdevsw_lookup_major(&audio_cdevsw);
+	 * We are now guaranteed that there are no calls to audio fileops
 	 * that hold sc, and any new calls with files that were for sc will
 	 * fail.  Thus, we now have exclusive access to the softc.
 	 */
 	/*
-	 * Nuke the vnodes for any open instances (calls close).
+	 * Nuke all open instances.
-	 * Will wait until any activity on the device nodes has ceased.
+	 * Here, we no longer need any locks to traverse sc_files.
 	 */
-	mn = device_unit(self);
+	while ((file = SLIST_FIRST(&sc->sc_files)) != NULL) {
-	vdevgone(maj, mn | SOUND_DEVICE,    mn | SOUND_DEVICE, VCHR);
+		audio_unlink(sc, file);
 	vdevgone(maj, mn | AUDIO_DEVICE,    mn | AUDIO_DEVICE, VCHR);
 	vdevgone(maj, mn | AUDIOCTL_DEVICE, mn | AUDIOCTL_DEVICE, VCHR);
 	vdevgone(maj, mn | MIXER_DEVICE,    mn | MIXER_DEVICE, VCHR);
 	pmf_event_deregister(self, PMFE_AUDIO_VOLUME_DOWN,
 	    audio_volume_down, true);
 	pmf_event_deregister(self, PMFE_AUDIO_VOLUME_UP,
 	    audio_volume_up, true);
 	pmf_event_deregister(self, PMFE_AUDIO_VOLUME_TOGGLE,
 	    audio_volume_toggle, true);
 #ifdef AUDIO_PM_IDLE
 	callout_halt(&sc->sc_idle_counter, sc->sc_lock);
 	device_active_deregister(self, audio_activity);
 #endif
 @@ -1430,26 +1453,68 @@ static void
 audio_exit_exclusive(struct audio_softc *sc)
+{
 	KASSERT(mutex_owned(sc->sc_lock));
 	KASSERT(sc->sc_exlock);
 	/* Leave critical section */
 	sc->sc_exlock = 0;
 	cv_broadcast(&sc->sc_exlockcv);
 	mutex_exit(sc->sc_lock);
+}
 /*
  * Acquire sc from file, and increment the psref count.
  * If successful, returns sc.  Otherwise returns NULL.
  */
 struct audio_softc *
 audio_file_enter(audio_file_t *file, struct psref *refp)
+{
 	int s;
 	bool dying;
 	/* psref(9) forbids to migrate CPUs */
 	curlwp_bind();
 	/* Block audiodetach while we acquire a reference */
 	s = pserialize_read_enter();
 	/* If close or audiodetach already ran, tough -- no more audio */
 	dying = atomic_load_relaxed(&file->dying);
 	if (dying) {
 		pserialize_read_exit(s);
 		return NULL;
+	}
 	/* Acquire a reference */
 	psref_acquire(refp, &file->sc->sc_psref, audio_psref_class);
 	/* Now sc won't go away until we drop the reference count */
 	pserialize_read_exit(s);
 	return file->sc;
+}
 /*
  * Decrement the psref count.
  */
 void
 audio_file_exit(struct audio_softc *sc, struct psref *refp)
+{
 	psref_release(refp, &sc->sc_psref, audio_psref_class);
+}
 /*
  * Wait for I/O to complete, releasing sc_lock.
  * Must be called with sc_lock held.
  */
 static int
 audio_track_waitio(struct audio_softc *sc, audio_track_t *track)
+{
 	int error;
 	KASSERT(track);
 	KASSERT(mutex_owned(sc->sc_lock));
 	/* Wait for pending I/O to complete. */
 	error = cv_timedwait_sig(&track->mixer->outcv, sc->sc_lock,
 @@ -1530,274 +1595,329 @@ audioopen(dev_t dev, int flags, int ifmt
 	default:
 		error = ENXIO;
 		break;
+	}
 	audio_exit_exclusive(sc);
 	return error;
+}
 static int
 audioclose(struct file *fp)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	audio_file_t *file;
 	int error;
 	dev_t dev;
 	KASSERT(fp->f_audioctx);
 	file = fp->f_audioctx;
 	sc = file->sc;
 	dev = file->dev;
 	error = 0;
-	/* audio_{enter,exit}_exclusive() is called by lower audio_close() */
+	/*
 	 * audioclose() must
 	 * - unplug track from the trackmixer (and unplug anything from softc),
 	 *   if sc exists.
 	 * - free all memory objects, regardless of sc.
 	 */
-	device_active(sc->sc_dev, DVA_SYSTEM);
+	sc = audio_file_enter(file, &sc_ref);
-	switch (AUDIODEV(dev)) {
+	if (sc) {
-	case SOUND_DEVICE:
+		switch (AUDIODEV(dev)) {
-	case AUDIO_DEVICE:
+		case SOUND_DEVICE:
-		error = audio_close(sc, file);
+		case AUDIO_DEVICE:
-		break;
+			error = audio_close(sc, file);
-	case AUDIOCTL_DEVICE:
+			break;
-		error = audioctl_close(sc, file);
+		case AUDIOCTL_DEVICE:
-		break;
+			error = 0;
-	case MIXER_DEVICE:
+			break;
-		error = mixer_close(sc, file);
+		case MIXER_DEVICE:
-		break;
+			error = mixer_close(sc, file);
-	default:
+			break;
-		error = ENXIO;
+		default:
-		break;
+			error = ENXIO;
 			break;
+		}
 		audio_file_exit(sc, &sc_ref);
+	}
 	/* f_audioctx has already been freed in lower *_close() */
 	/* Free memory objects anyway */
 	TRACEF(2, file, "free memory");
 	if (file->ptrack)
 		audio_track_destroy(file->ptrack);
 	if (file->rtrack)
 		audio_track_destroy(file->rtrack);
 	kmem_free(file, sizeof(*file));
 	fp->f_audioctx = NULL;
 	return error;
+}
 static int
 audioread(struct file *fp, off_t *offp, struct uio *uio, kauth_cred_t cred,
 	int ioflag)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	audio_file_t *file;
 	int error;
 	dev_t dev;
 	KASSERT(fp->f_audioctx);
 	file = fp->f_audioctx;
 	sc = file->sc;
 	dev = file->dev;
 	sc = audio_file_enter(file, &sc_ref);
 	if (sc == NULL)
 		return EIO;
 	if (fp->f_flag & O_NONBLOCK)
 		ioflag |= IO_NDELAY;
 	switch (AUDIODEV(dev)) {
 	case SOUND_DEVICE:
 	case AUDIO_DEVICE:
 		error = audio_read(sc, uio, ioflag, file);
 		break;
 	case AUDIOCTL_DEVICE:
 	case MIXER_DEVICE:
 		error = ENODEV;
 		break;
 	default:
 		error = ENXIO;
 		break;
+	}
 	audio_file_exit(sc, &sc_ref);
 	return error;
+}
 static int
 audiowrite(struct file *fp, off_t *offp, struct uio *uio, kauth_cred_t cred,
 	int ioflag)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	audio_file_t *file;
 	int error;
 	dev_t dev;
 	KASSERT(fp->f_audioctx);
 	file = fp->f_audioctx;
 	sc = file->sc;
 	dev = file->dev;
 	sc = audio_file_enter(file, &sc_ref);
 	if (sc == NULL)
 		return EIO;
 	if (fp->f_flag & O_NONBLOCK)
 		ioflag |= IO_NDELAY;
 	switch (AUDIODEV(dev)) {
 	case SOUND_DEVICE:
 	case AUDIO_DEVICE:
 		error = audio_write(sc, uio, ioflag, file);
 		break;
 	case AUDIOCTL_DEVICE:
 	case MIXER_DEVICE:
 		error = ENODEV;
 		break;
 	default:
 		error = ENXIO;
 		break;
+	}
 	audio_file_exit(sc, &sc_ref);
 	return error;
+}
 static int
 audioioctl(struct file *fp, u_long cmd, void *addr)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	audio_file_t *file;
 	struct lwp *l = curlwp;
 	int error;
 	dev_t dev;
 	KASSERT(fp->f_audioctx);
 	file = fp->f_audioctx;
 	sc = file->sc;
 	dev = file->dev;
 	sc = audio_file_enter(file, &sc_ref);
 	if (sc == NULL)
 		return EIO;
 	switch (AUDIODEV(dev)) {
 	case SOUND_DEVICE:
 	case AUDIO_DEVICE:
 	case AUDIOCTL_DEVICE:
 		mutex_enter(sc->sc_lock);
 		device_active(sc->sc_dev, DVA_SYSTEM);
 		mutex_exit(sc->sc_lock);
 		if (IOCGROUP(cmd) == IOCGROUP(AUDIO_MIXER_READ))
 			error = mixer_ioctl(sc, cmd, addr, fp->f_flag, l);
 		else
 			error = audio_ioctl(dev, sc, cmd, addr, fp->f_flag, l,
 			    file);
 		break;
 	case MIXER_DEVICE:
 		error = mixer_ioctl(sc, cmd, addr, fp->f_flag, l);
 		break;
 	default:
 		error = ENXIO;
 		break;
+	}
 	audio_file_exit(sc, &sc_ref);
 	return error;
+}
 static int
 audiostat(struct file *fp, struct stat *st)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	audio_file_t *file;
 	KASSERT(fp->f_audioctx);
 	file = fp->f_audioctx;
 	sc = audio_file_enter(file, &sc_ref);
 	if (sc == NULL)
 		return EIO;
 	memset(st, 0, sizeof(*st));
 	st->st_dev = file->dev;
 	st->st_uid = kauth_cred_geteuid(fp->f_cred);
 	st->st_gid = kauth_cred_getegid(fp->f_cred);
 	st->st_mode = S_IFCHR;
 	audio_file_exit(sc, &sc_ref);
 	return 0;
+}
 static int
 audiopoll(struct file *fp, int events)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	audio_file_t *file;
 	struct lwp *l = curlwp;
 	int revents;
 	dev_t dev;
 	KASSERT(fp->f_audioctx);
 	file = fp->f_audioctx;
 	sc = file->sc;
 	dev = file->dev;
 	sc = audio_file_enter(file, &sc_ref);
 	if (sc == NULL)
 		return EIO;
 	switch (AUDIODEV(dev)) {
 	case SOUND_DEVICE:
 	case AUDIO_DEVICE:
 		revents = audio_poll(sc, events, l, file);
 		break;
 	case AUDIOCTL_DEVICE:
 	case MIXER_DEVICE:
 		revents = 0;
 		break;
 	default:
 		revents = POLLERR;
 		break;
+	}
 	audio_file_exit(sc, &sc_ref);
 	return revents;
+}
 static int
 audiokqfilter(struct file *fp, struct knote *kn)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	audio_file_t *file;
 	dev_t dev;
 	int error;
 	KASSERT(fp->f_audioctx);
 	file = fp->f_audioctx;
 	sc = file->sc;
 	dev = file->dev;
 	sc = audio_file_enter(file, &sc_ref);
 	if (sc == NULL)
 		return EIO;
 	switch (AUDIODEV(dev)) {
 	case SOUND_DEVICE:
 	case AUDIO_DEVICE:
 		error = audio_kqfilter(sc, file, kn);
 		break;
 	case AUDIOCTL_DEVICE:
 	case MIXER_DEVICE:
 		error = ENODEV;
 		break;
 	default:
 		error = ENXIO;
 		break;
+	}
 	audio_file_exit(sc, &sc_ref);
 	return error;
+}
 static int
 audiommap(struct file *fp, off_t *offp, size_t len, int prot, int *flagsp,
 	int *advicep, struct uvm_object **uobjp, int *maxprotp)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	audio_file_t *file;
 	dev_t dev;
 	int error;
 	KASSERT(fp->f_audioctx);
 	file = fp->f_audioctx;
 	sc = file->sc;
 	dev = file->dev;
 	sc = audio_file_enter(file, &sc_ref);
 	if (sc == NULL)
 		return EIO;
 	mutex_enter(sc->sc_lock);
 	device_active(sc->sc_dev, DVA_SYSTEM); /* XXXJDM */
 	mutex_exit(sc->sc_lock);
 	switch (AUDIODEV(dev)) {
 	case SOUND_DEVICE:
 	case AUDIO_DEVICE:
 		error = audio_mmap(sc, offp, len, prot, flagsp, advicep,
 		    uobjp, maxprotp, file);
 		break;
 	case AUDIOCTL_DEVICE:
 	case MIXER_DEVICE:
 	default:
 		error = ENOTSUP;
 		break;
+	}
 	audio_file_exit(sc, &sc_ref);
 	return error;
+}
 /* Exported interfaces for audiobell. */
 /*
  * Open for audiobell.
  * It stores allocated file to *filep.
  * If successful returns 0, otherwise errno.
  */
 int
 audiobellopen(dev_t dev, audio_file_t **filep)
 @@ -1816,67 +1936,81 @@ audiobellopen(dev_t dev, audio_file_t **
 	device_active(sc->sc_dev, DVA_SYSTEM);
 	error = audio_open(dev, sc, FWRITE, 0, curlwp, filep);
 	audio_exit_exclusive(sc);
 	return error;
+}
 /* Close for audiobell */
 int
 audiobellclose(audio_file_t *file)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	int error;
-	sc = file->sc;
+	sc = audio_file_enter(file, &sc_ref);
 	if (sc == NULL)
 		return EIO;
 	device_active(sc->sc_dev, DVA_SYSTEM);
 	error = audio_close(sc, file);
 	audio_file_exit(sc, &sc_ref);
 	return error;
+}
 /* Set sample rate for audiobell */
 int
 audiobellsetrate(audio_file_t *file, u_int sample_rate)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	struct audio_info ai;
 	int error;
-	sc = file->sc;
+	sc = audio_file_enter(file, &sc_ref);
 	if (sc == NULL)
 		return EIO;
 	AUDIO_INITINFO(&ai);
 	ai.play.sample_rate = sample_rate;
 	error = audio_enter_exclusive(sc);
 	if (error)
-		return error;
+		goto done;
 	error = audio_file_setinfo(sc, file, &ai);
 	audio_exit_exclusive(sc);
 done:
 	audio_file_exit(sc, &sc_ref);
 	return error;
+}
 /* Playback for audiobell */
 int
 audiobellwrite(audio_file_t *file, struct uio *uio)
+{
 	struct audio_softc *sc;
 	struct psref sc_ref;
 	int error;
-	sc = file->sc;
+	sc = audio_file_enter(file, &sc_ref);
 	if (sc == NULL)
 		return EIO;
 	error = audio_write(sc, uio, 0, file);
 	audio_file_exit(sc, &sc_ref);
 	return error;
+}
 /*
  * Audio driver
  */
 int
 audio_open(dev_t dev, struct audio_softc *sc, int flags, int ifmt,
 	struct lwp *l, audio_file_t **bellfile)
+{
 	struct audio_info ai;
 	struct file *fp;
 @@ -2121,126 +2255,144 @@ bad2:
 		af->ptrack = NULL;
+	}
 bad1:
 	kmem_free(af, sizeof(*af));
 	return error;
+}
 /*
  * Must be called without sc_lock nor sc_exlock held.
  */
 int
 audio_close(struct audio_softc *sc, audio_file_t *file)
+{
 	audio_track_t *oldtrack;
 	/* Protect entering new fileops to this file */
 	atomic_store_relaxed(&file->dying, true);
 	/*
 	 * Drain first.
 	 * It must be done before unlinking(acquiring exclusive lock).
 	 */
 	if (file->ptrack) {
 		mutex_enter(sc->sc_lock);
 		audio_track_drain(sc, file->ptrack);
 		mutex_exit(sc->sc_lock);
+	}
 	return audio_unlink(sc, file);
+}
 /*
  * Unlink this file, but not freeing memory here.
  * Must be called without sc_lock nor sc_exlock held.
  */
 int
 audio_unlink(struct audio_softc *sc, audio_file_t *file)
+{
 	int error;
 	TRACEF(1, file, "%spid=%d.%d po=%d ro=%d",
 	    (audiodebug >= 3) ? "start " : "",
 	    (int)curproc->p_pid, (int)curlwp->l_lid,
 	    sc->sc_popens, sc->sc_ropens);
 	KASSERTMSG(sc->sc_popens + sc->sc_ropens > 0,
 	    "sc->sc_popens=%d, sc->sc_ropens=%d",
 	    sc->sc_popens, sc->sc_ropens);
 	mutex_enter(sc->sc_lock);
 	/*
-	 * Drain first.
+	 * Acquire exclusive lock to protect counters.
-	 * It must be done before acquiring exclusive lock.
+	 * Does not use audio_enter_exclusive() due to sc_dying.
 	 */
-	if (file->ptrack) {
+	while (__predict_false(sc->sc_exlock != 0)) {
-		mutex_enter(sc->sc_lock);
+		error = cv_timedwait_sig(&sc->sc_exlockcv, sc->sc_lock,
-		audio_track_drain(sc, file->ptrack);
+		    mstohz(AUDIO_TIMEOUT));
-		mutex_exit(sc->sc_lock);
+		/* XXX what should I do on error? */
 		if (error == EWOULDBLOCK) {
 			mutex_exit(sc->sc_lock);
 			device_printf(sc->sc_dev,
 			    "%s: cv_timedwait_sig failed %d", __func__, error);
 			return error;
+		}
+	}
 	sc->sc_exlock = 1;
-	/* Then, acquire exclusive lock to protect counters. */
+	device_active(sc->sc_dev, DVA_SYSTEM);
 	/* XXX what should I do when an error occurs? */
-	error = audio_enter_exclusive(sc);
+	mutex_enter(sc->sc_intr_lock);
-	if (error)
+	SLIST_REMOVE(&sc->sc_files, file, audio_file, entry);
-		return error;
+	mutex_exit(sc->sc_intr_lock);
 	if (file->ptrack) {
 		TRACET(3, file->ptrack, "dropframes=%" PRIu64,
 		    file->ptrack->dropframes);
 		KASSERT(sc->sc_popens > 0);
 		sc->sc_popens--;
 		/* Call hw halt_output if this is the last playback track. */
-		if (sc->sc_popens == 1 && sc->sc_pbusy) {
+		if (sc->sc_popens == 0 && sc->sc_pbusy) {
 			error = audio_pmixer_halt(sc);
 			if (error) {
 				device_printf(sc->sc_dev,
-				    "halt_output failed with %d\n", error);
+				    "halt_output failed with %d (ignored)\n",
 				    error);
+			}
+		}
 		/* Destroy the track. */
 		oldtrack = file->ptrack;
 		mutex_enter(sc->sc_intr_lock);
 		file->ptrack = NULL;
 		mutex_exit(sc->sc_intr_lock);
 		TRACET(3, oldtrack, "dropframes=%" PRIu64,
 		    oldtrack->dropframes);
 		audio_track_destroy(oldtrack);
 		KASSERT(sc->sc_popens > 0);
 		sc->sc_popens--;
 		/* Restore mixing volume if all tracks are gone. */
 		if (sc->sc_popens == 0) {
 			/* intr_lock is not necessary, but just manners. */
 			mutex_enter(sc->sc_intr_lock);
 			sc->sc_pmixer->volume = 256;
 			sc->sc_pmixer->voltimer = 0;
 			mutex_exit(sc->sc_intr_lock);
+		}
+	}
 	if (file->rtrack) {
 		TRACET(3, file->rtrack, "dropframes=%" PRIu64,
 		    file->rtrack->dropframes);
 		KASSERT(sc->sc_ropens > 0);
 		sc->sc_ropens--;
 		/* Call hw halt_input if this is the last recording track. */
-		if (sc->sc_ropens == 1 && sc->sc_rbusy) {
+		if (sc->sc_ropens == 0 && sc->sc_rbusy) {
 			error = audio_rmixer_halt(sc);
 			if (error) {
 				device_printf(sc->sc_dev,
-				    "halt_input failed with %d\n", error);
+				    "halt_input failed with %d (ignored)\n",
 				    error);
+			}
+		}
 		/* Destroy the track. */
 		oldtrack = file->rtrack;
 		mutex_enter(sc->sc_intr_lock);
 		file->rtrack = NULL;
 		mutex_exit(sc->sc_intr_lock);
 		TRACET(3, oldtrack, "dropframes=%" PRIu64,
 		    oldtrack->dropframes);
 		audio_track_destroy(oldtrack);
 		KASSERT(sc->sc_ropens > 0);
 		sc->sc_ropens--;
+	}
 	/* Call hw close if this is the last track. */
 	if (sc->sc_popens + sc->sc_ropens == 0) {
 		if (sc->hw_if->close) {
 			TRACE(2, "hw_if close");
 			mutex_enter(sc->sc_intr_lock);
 			sc->hw_if->close(sc->hw_hdl);
 			mutex_exit(sc->sc_intr_lock);
+		}
 		kauth_cred_free(sc->sc_cred);
+	}
 	mutex_enter(sc->sc_intr_lock);
 	SLIST_REMOVE(&sc->sc_files, file, audio_file, entry);
 	mutex_exit(sc->sc_intr_lock);
 	TRACE(3, "done");
 	audio_exit_exclusive(sc);
 	kmem_free(file, sizeof(*file));
 	return 0;
+}
 /*
  * Must be called without sc_lock nor sc_exlock held.
  */
 int
 audio_read(struct audio_softc *sc, struct uio *uio, int ioflag,
 	audio_file_t *file)
+{
 	audio_track_t *track;
 	audio_ring_t *usrbuf;
 	audio_ring_t *input;
 @@ -3082,34 +3234,26 @@ audioctl_open(dev_t dev, struct audio_so
 	af = kmem_zalloc(sizeof(audio_file_t), KM_SLEEP);
 	af->sc = sc;
 	af->dev = dev;
 	/* Not necessary to insert sc_files. */
 	error = fd_clone(fp, fd, flags, &audio_fileops, af);
 	KASSERTMSG(error == EMOVEFD, "error=%d", error);
 	return error;
+}
 static int
 audioctl_close(struct audio_softc *sc, audio_file_t *file)
 	kmem_free(file, sizeof(*file));
 	return 0;
 /*
  * Free 'mem' if available, and initialize the pointer.
  * For this reason, this is implemented as macro.
  */
 #define audio_free(mem)	do {	\
 	if (mem != NULL) {	\
 		kern_free(mem);	\
 		mem = NULL;	\
 	}	\
 } while (0)
 /*
  * (Re)allocate 'memblock' with specified 'bytes'.
 @@ -7683,27 +7827,26 @@ mixer_signal(struct audio_softc *sc)
 /*
  * Close a mixer device
  */
 int
 mixer_close(struct audio_softc *sc, audio_file_t *file)
+{
 	mutex_enter(sc->sc_lock);
 	TRACE(1, "");
 	mixer_async_remove(sc, curproc->p_pid);
 	mutex_exit(sc->sc_lock);
 	kmem_free(file, sizeof(*file));
 	return 0;
+}
 /*
  * Must be called without sc_lock nor sc_exlock held.
  */
 int
 mixer_ioctl(struct audio_softc *sc, u_long cmd, void *addr, int flag,
 	struct lwp *l)
+{
 	mixer_devinfo_t *mi;
 	mixer_ctrl_t *mc;
 	int error;
 @@ -8435,43 +8578,48 @@ audioprint(void *aux, const char *pnp)
 devmajor_t audio_bmajor = -1, audio_cmajor = -1;
 #include "ioconf.c"
 #endif
 MODULE(MODULE_CLASS_DRIVER, audio, NULL);
 static int
 audio_modcmd(modcmd_t cmd, void *arg)
+{
 	int error = 0;
 #ifdef _MODULE
 	switch (cmd) {
 	case MODULE_CMD_INIT:
 		/* XXX interrupt level? */
 		audio_psref_class = psref_class_create("audio", IPL_SOFTSERIAL);
 #ifdef _MODULE
 		error = devsw_attach(audio_cd.cd_name, NULL, &audio_bmajor,
 		    &audio_cdevsw, &audio_cmajor);
 		if (error)
 			break;
 		error = config_init_component(cfdriver_ioconf_audio,
 		    cfattach_ioconf_audio, cfdata_ioconf_audio);
 		if (error) {
 			devsw_detach(NULL, &audio_cdevsw);
+		}
 #endif
 		break;
 	case MODULE_CMD_FINI:
 #ifdef _MODULE
 		devsw_detach(NULL, &audio_cdevsw);
 		error = config_fini_component(cfdriver_ioconf_audio,
 		   cfattach_ioconf_audio, cfdata_ioconf_audio);
 		if (error)
 			devsw_attach(audio_cd.cd_name, NULL, &audio_bmajor,
 			    &audio_cdevsw, &audio_cmajor);
 #endif
 		psref_class_destroy(audio_psref_class);
 		break;
 	default:
 		error = ENOTTY;
 		break;
+	}
 #endif
 	return error;
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: audiodef.h,v 1.9 2020/02/22 06:58:39 isaki Exp $	*/
+/*	$NetBSD: audiodef.h,v 1.10 2020/02/23 07:17:01 isaki Exp $	*/
 /*
  * Copyright (C) 2017 Tetsuya Isaki. All rights reserved.
  * Copyright (C) 2017 Y.Sugahara (moveccr). 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.
 @@ -192,26 +192,29 @@ struct audio_file {
 	/*
 	 * Indicates the operation mode of this file.
 	 * AUMODE_PLAY means playback is requested.
 	 * AUMODE_RECORD means recording is requested.
 	 * AUMODE_PLAY_ALL affects nothing but can be get/set for backward
 	 * compatibility.
 	 */
 	int		mode;
 	/* process who wants audio SIGIO. */
 	pid_t		async_audio;
 	/* true when closing */
 	bool		dying;
 	SLIST_ENTRY(audio_file) entry;
 };
 struct audio_trackmixer {
 	struct audio_softc *sc;
 	int		mode;		/* AUMODE_PLAY or AUMODE_RECORD */
 	audio_format2_t	track_fmt;	/* track <-> trackmixer format */
 	int		frames_per_block; /* number of frames in a block */
 	/*
 	 * software master volume (0..256)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: audiovar.h,v 1.7 2020/01/11 04:53:10 isaki Exp $	*/
+/*	$NetBSD: audiovar.h,v 1.8 2020/02/23 07:17:01 isaki Exp $	*/
 /*-
  * Copyright (c) 2002 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by TAMURA Kent
+ *
  * 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.
 @@ -59,26 +59,28 @@
  * 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.
+ *
  *	From: Header: audiovar.h,v 1.3 93/07/18 14:07:25 mccanne Exp  (LBL)
  */
 #ifndef _SYS_DEV_AUDIO_AUDIOVAR_H_
 #define _SYS_DEV_AUDIO_AUDIOVAR_H_
 #include <sys/condvar.h>
 #include <sys/proc.h>
 #include <sys/pserialize.h>
 #include <sys/psref.h>
 #include <sys/queue.h>
 #include <dev/audio/audio_if.h>
 #include <dev/audio/audiofil.h>
 /*
  * Whether supports [US]LINEAR24/24 as userland format.
  */
 /* #define AUDIO_SUPPORT_LINEAR24 */
 /*
  * Frequency range.
  * For lower limit, there are some antique machines who supports under
 @@ -208,26 +210,33 @@ struct audio_softc {
 	 * Thread lock and interrupt lock obtained by get_locks().
 	 */
 	kmutex_t *sc_lock;
 	kmutex_t *sc_intr_lock;
 	/*
 	 * Critical section.
 	 * Must be protected by sc_lock.
 	 */
 	int sc_exlock;
 	kcondvar_t sc_exlockcv;
 	/*
 	 * Passive reference to prevent a race between detach and fileops.
 	 * pserialize_perform(sc_psz) must be protected by sc_lock.
 	 */
 	pserialize_t sc_psz;
 	struct psref_target sc_psref;
 	/*
 	 * Must be protected by sc_lock (?)
 	 */
 	bool		sc_dying;
 	/*
 	 * If multiuser is false, other users who have different euid
 	 * than the first user cannot open this device.
 	 * Must be protected by sc_lock.
 	 */
 	bool sc_multiuser;
 	kauth_cred_t sc_cred;
 	struct sysctllog *sc_log;