git: c0d8f5862997 - main - Revert "sound: Get rid of snd_clone and use DEVFS_CDEVPRIV(9)"
- Go to: [ bottom of page ] [ top of archives ] [ this month ]
Date: Fri, 05 Apr 2024 10:38:26 UTC
The branch main has been updated by christos:
URL: https://cgit.FreeBSD.org/src/commit/?id=c0d8f586299713f999b3b4757617a805774b03fa
commit c0d8f586299713f999b3b4757617a805774b03fa
Author: Christos Margiolis <christos@FreeBSD.org>
AuthorDate: 2024-04-05 10:32:32 +0000
Commit: Christos Margiolis <christos@FreeBSD.org>
CommitDate: 2024-04-05 10:33:41 +0000
Revert "sound: Get rid of snd_clone and use DEVFS_CDEVPRIV(9)"
This reverts commit dc831e93bad63f9faea09f1806a7733a40bff316.
After several reports in the mailing lists, this commit breaks
pulseaudio. Revert until the issue is resolved.
---
share/man/man4/pcm.4 | 53 +-
sys/conf/files | 1 +
sys/dev/sound/clone.c | 705 ++++++++++++++++++++++++++
sys/dev/sound/clone.h | 127 +++++
sys/dev/sound/pcm/dsp.c | 1027 ++++++++++++++++++++++++++------------
sys/dev/sound/pcm/dsp.h | 7 +-
sys/dev/sound/pcm/sound.c | 194 ++++++-
sys/dev/sound/pcm/sound.h | 6 +-
sys/modules/sound/sound/Makefile | 2 +-
9 files changed, 1793 insertions(+), 329 deletions(-)
diff --git a/share/man/man4/pcm.4 b/share/man/man4/pcm.4
index e406bd2c8343..17ac499e6bb3 100644
--- a/share/man/man4/pcm.4
+++ b/share/man/man4/pcm.4
@@ -23,7 +23,7 @@
.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
.\" SUCH DAMAGE.
.\"
-.Dd March 24, 2024
+.Dd January 10, 2024
.Dt SOUND 4
.Os
.Sh NAME
@@ -513,6 +513,14 @@ device state on each tick using a
mechanism.
Disabled by default and currently only available for a few device drivers.
.El
+.Ss Recording Channels
+On devices that have more than one recording source (ie: mic and line),
+there is a corresponding
+.Pa /dev/dsp%d.r%d
+device.
+The
+.Xr mixer 8
+utility can be used to start and stop recording from an specific device.
.Ss Statistics
Channel statistics are only kept while the device is open.
So with situations involving overruns and underruns, consider the output
@@ -534,24 +542,36 @@ functions.
.Sh FILES
The
.Nm
-drivers may create the following device nodes:
+drivers may create the following
+device nodes:
.Pp
-.Bl -tag -width ".Pa /dev/sndstat" -compact
-.It Pa /dev/dsp%d
-Audio device.
-The number represents the unit number of the device.
-.It Pa /dev/dsp
-Alias of
-.Pa /dev/dsp${hw.snd.default_unit} .
-Available only if
-.Pa hw.snd.basename_clone
-is set.
+.Bl -tag -width ".Pa /dev/audio%d.%d" -compact
+.It Pa /dev/audio%d.%d
+Sparc-compatible audio device.
+.It Pa /dev/dsp%d.%d
+Digitized voice device.
+.It Pa /dev/dspW%d.%d
+Like
+.Pa /dev/dsp ,
+but 16 bits per sample.
+.It Pa /dev/dsp%d.p%d
+Playback channel.
+.It Pa /dev/dsp%d.r%d
+Record channel.
+.It Pa /dev/dsp%d.vp%d
+Virtual playback channel.
+.It Pa /dev/dsp%d.vr%d
+Virtual recording channel.
.It Pa /dev/sndstat
Current
.Nm
status, including all channels and drivers.
.El
.Pp
+The first number in the device node
+represents the unit number of the
+.Nm
+device.
All
.Nm
devices are listed
@@ -561,6 +581,15 @@ Additional messages are sometimes recorded when the
device is probed and attached, these messages can be viewed with the
.Xr dmesg 8
utility.
+.Pp
+The above device nodes are only created on demand through the dynamic
+.Xr devfs 5
+clone handler.
+Users are strongly discouraged to access them directly.
+For specific sound card access, please instead use
+.Pa /dev/dsp
+or
+.Pa /dev/dsp%d .
.Sh EXAMPLES
Use the sound metadriver to load all
.Nm
diff --git a/sys/conf/files b/sys/conf/files
index 0fbb7fea70c9..549a3590f76b 100644
--- a/sys/conf/files
+++ b/sys/conf/files
@@ -3064,6 +3064,7 @@ dev/smc/if_smc.c optional smc
dev/smc/if_smc_acpi.c optional smc acpi
dev/smc/if_smc_fdt.c optional smc fdt
dev/snp/snp.c optional snp
+dev/sound/clone.c optional sound
dev/sound/unit.c optional sound
dev/sound/pci/als4000.c optional snd_als4000 pci
dev/sound/pci/atiixp.c optional snd_atiixp pci
diff --git a/sys/dev/sound/clone.c b/sys/dev/sound/clone.c
new file mode 100644
index 000000000000..4cac5f050ee2
--- /dev/null
+++ b/sys/dev/sound/clone.c
@@ -0,0 +1,705 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause
+ *
+ * Copyright (c) 2007 Ariff Abdullah <ariff@FreeBSD.org>
+ * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/proc.h>
+
+#ifdef HAVE_KERNEL_OPTION_HEADERS
+#include "opt_snd.h"
+#endif
+
+#if defined(SND_DIAGNOSTIC) || defined(SND_DEBUG)
+#include <dev/sound/pcm/sound.h>
+#endif
+
+#include <dev/sound/clone.h>
+
+/*
+ * So here we go again, another clonedevs manager. Unlike default clonedevs,
+ * this clone manager is designed to withstand various abusive behavior
+ * (such as 'while : ; do ls /dev/whatever ; done', etc.), reusable object
+ * after reaching certain expiration threshold, aggressive garbage collector,
+ * transparent device allocator and concurrency handling across multiple
+ * thread/proc. Due to limited information given by dev_clone EVENTHANDLER,
+ * we don't have much clues whether the caller wants a real open() or simply
+ * making fun of us with things like stat(), mtime() etc. Assuming that:
+ * 1) Time window between dev_clone EH <-> real open() should be small
+ * enough and 2) mtime()/stat() etc. always looks like a half way / stalled
+ * operation, we can decide whether a new cdev must be created, old
+ * (expired) cdev can be reused or an existing cdev can be shared.
+ *
+ * Most of the operations and logics are generic enough and can be applied
+ * on other places (such as if_tap, snp, etc). Perhaps this can be
+ * rearranged to complement clone_*(). However, due to this still being
+ * specific to the sound driver (and as a proof of concept on how it can be
+ * done), si_drv2 is used to keep the pointer of the clone list entry to
+ * avoid expensive lookup.
+ */
+
+/* clone entry */
+struct snd_clone_entry {
+ TAILQ_ENTRY(snd_clone_entry) link;
+ struct snd_clone *parent;
+ struct cdev *devt;
+ struct timespec tsp;
+ uint32_t flags;
+ pid_t pid;
+ int unit;
+};
+
+/* clone manager */
+struct snd_clone {
+ TAILQ_HEAD(link_head, snd_clone_entry) head;
+ struct timespec tsp;
+ int refcount;
+ int size;
+ int typemask;
+ int maxunit;
+ int deadline;
+ uint32_t flags;
+};
+
+#ifdef SND_DIAGNOSTIC
+#define SND_CLONE_ASSERT(x, y) do { \
+ if (!(x)) \
+ panic y; \
+} while (0)
+#else
+#define SND_CLONE_ASSERT(...) KASSERT(__VA_ARGS__)
+#endif
+
+/*
+ * snd_clone_create() : Return opaque allocated clone manager.
+ */
+struct snd_clone *
+snd_clone_create(int typemask, int maxunit, int deadline, uint32_t flags)
+{
+ struct snd_clone *c;
+
+ SND_CLONE_ASSERT(!(typemask & ~SND_CLONE_MAXUNIT),
+ ("invalid typemask: 0x%08x", typemask));
+ SND_CLONE_ASSERT(maxunit == -1 ||
+ !(maxunit & ~(~typemask & SND_CLONE_MAXUNIT)),
+ ("maxunit overflow: typemask=0x%08x maxunit=%d",
+ typemask, maxunit));
+ SND_CLONE_ASSERT(!(flags & ~SND_CLONE_MASK),
+ ("invalid clone flags=0x%08x", flags));
+
+ c = malloc(sizeof(*c), M_DEVBUF, M_WAITOK | M_ZERO);
+ c->refcount = 0;
+ c->size = 0;
+ c->typemask = typemask;
+ c->maxunit = (maxunit == -1) ? (~typemask & SND_CLONE_MAXUNIT) :
+ maxunit;
+ c->deadline = deadline;
+ c->flags = flags;
+ getnanouptime(&c->tsp);
+ TAILQ_INIT(&c->head);
+
+ return (c);
+}
+
+int
+snd_clone_busy(struct snd_clone *c)
+{
+ struct snd_clone_entry *ce;
+
+ SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
+
+ if (c->size == 0)
+ return (0);
+
+ TAILQ_FOREACH(ce, &c->head, link) {
+ if ((ce->flags & SND_CLONE_BUSY) ||
+ (ce->devt != NULL && ce->devt->si_threadcount != 0))
+ return (EBUSY);
+ }
+
+ return (0);
+}
+
+/*
+ * snd_clone_enable()/disable() : Suspend/resume clone allocation through
+ * snd_clone_alloc(). Everything else will not be affected by this.
+ */
+int
+snd_clone_enable(struct snd_clone *c)
+{
+ SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
+
+ if (c->flags & SND_CLONE_ENABLE)
+ return (EINVAL);
+
+ c->flags |= SND_CLONE_ENABLE;
+
+ return (0);
+}
+
+int
+snd_clone_disable(struct snd_clone *c)
+{
+ SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
+
+ if (!(c->flags & SND_CLONE_ENABLE))
+ return (EINVAL);
+
+ c->flags &= ~SND_CLONE_ENABLE;
+
+ return (0);
+}
+
+/*
+ * Getters / Setters. Not worth explaining :)
+ */
+int
+snd_clone_getsize(struct snd_clone *c)
+{
+ SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
+
+ return (c->size);
+}
+
+int
+snd_clone_getmaxunit(struct snd_clone *c)
+{
+ SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
+
+ return (c->maxunit);
+}
+
+int
+snd_clone_setmaxunit(struct snd_clone *c, int maxunit)
+{
+ SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
+ SND_CLONE_ASSERT(maxunit == -1 ||
+ !(maxunit & ~(~c->typemask & SND_CLONE_MAXUNIT)),
+ ("maxunit overflow: typemask=0x%08x maxunit=%d",
+ c->typemask, maxunit));
+
+ c->maxunit = (maxunit == -1) ? (~c->typemask & SND_CLONE_MAXUNIT) :
+ maxunit;
+
+ return (c->maxunit);
+}
+
+int
+snd_clone_getdeadline(struct snd_clone *c)
+{
+ SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
+
+ return (c->deadline);
+}
+
+int
+snd_clone_setdeadline(struct snd_clone *c, int deadline)
+{
+ SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
+
+ c->deadline = deadline;
+
+ return (c->deadline);
+}
+
+uint32_t
+snd_clone_getflags(struct snd_clone *c)
+{
+ SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
+
+ return (c->flags);
+}
+
+uint32_t
+snd_clone_setflags(struct snd_clone *c, uint32_t flags)
+{
+ SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
+ SND_CLONE_ASSERT(!(flags & ~SND_CLONE_MASK),
+ ("invalid clone flags=0x%08x", flags));
+
+ c->flags = flags;
+
+ return (c->flags);
+}
+
+uint32_t
+snd_clone_getdevflags(struct cdev *dev)
+{
+ struct snd_clone_entry *ce;
+
+ SND_CLONE_ASSERT(dev != NULL, ("NULL dev"));
+
+ ce = dev->si_drv2;
+ if (ce == NULL)
+ return (0xffffffff);
+
+ SND_CLONE_ASSERT(ce->parent != NULL, ("NULL parent"));
+
+ return (ce->flags);
+}
+
+uint32_t
+snd_clone_setdevflags(struct cdev *dev, uint32_t flags)
+{
+ struct snd_clone_entry *ce;
+
+ SND_CLONE_ASSERT(dev != NULL, ("NULL dev"));
+ SND_CLONE_ASSERT(!(flags & ~SND_CLONE_DEVMASK),
+ ("invalid clone dev flags=0x%08x", flags));
+
+ ce = dev->si_drv2;
+ if (ce == NULL)
+ return (0xffffffff);
+
+ SND_CLONE_ASSERT(ce->parent != NULL, ("NULL parent"));
+
+ ce->flags = flags;
+
+ return (ce->flags);
+}
+
+/* Elapsed time conversion to ms */
+#define SND_CLONE_ELAPSED(x, y) \
+ ((((x)->tv_sec - (y)->tv_sec) * 1000) + \
+ (((y)->tv_nsec > (x)->tv_nsec) ? \
+ (((1000000000L + (x)->tv_nsec - \
+ (y)->tv_nsec) / 1000000) - 1000) : \
+ (((x)->tv_nsec - (y)->tv_nsec) / 1000000)))
+
+#define SND_CLONE_EXPIRED(x, y, z) \
+ ((x)->deadline < 1 || \
+ ((y)->tv_sec - (z)->tv_sec) > ((x)->deadline / 1000) || \
+ SND_CLONE_ELAPSED(y, z) > (x)->deadline)
+
+/*
+ * snd_clone_gc() : Garbage collector for stalled, expired objects. Refer to
+ * clone.h for explanations on GC settings.
+ */
+int
+snd_clone_gc(struct snd_clone *c)
+{
+ struct snd_clone_entry *ce, *tce;
+ struct timespec now;
+ int pruned;
+
+ SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
+
+ if (!(c->flags & SND_CLONE_GC_ENABLE) || c->size == 0)
+ return (0);
+
+ getnanouptime(&now);
+
+ /*
+ * Bail out if the last clone handler was invoked below the deadline
+ * threshold.
+ */
+ if ((c->flags & SND_CLONE_GC_EXPIRED) &&
+ !SND_CLONE_EXPIRED(c, &now, &c->tsp))
+ return (0);
+
+ pruned = 0;
+
+ /*
+ * Visit each object in reverse order. If the object is still being
+ * referenced by a valid open(), skip it. Look for expired objects
+ * and either revoke its clone invocation status or mercilessly
+ * throw it away.
+ */
+ TAILQ_FOREACH_REVERSE_SAFE(ce, &c->head, link_head, link, tce) {
+ if (!(ce->flags & SND_CLONE_BUSY) &&
+ (!(ce->flags & SND_CLONE_INVOKE) ||
+ SND_CLONE_EXPIRED(c, &now, &ce->tsp))) {
+ if ((c->flags & SND_CLONE_GC_REVOKE) ||
+ ce->devt->si_threadcount != 0) {
+ ce->flags &= ~SND_CLONE_INVOKE;
+ ce->pid = -1;
+ } else {
+ TAILQ_REMOVE(&c->head, ce, link);
+ destroy_dev(ce->devt);
+ free(ce, M_DEVBUF);
+ c->size--;
+ }
+ pruned++;
+ }
+ }
+
+ /* return total pruned objects */
+ return (pruned);
+}
+
+void
+snd_clone_destroy(struct snd_clone *c)
+{
+ struct snd_clone_entry *ce, *tmp;
+
+ SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
+
+ ce = TAILQ_FIRST(&c->head);
+ while (ce != NULL) {
+ tmp = TAILQ_NEXT(ce, link);
+ if (ce->devt != NULL)
+ destroy_dev(ce->devt);
+ free(ce, M_DEVBUF);
+ ce = tmp;
+ }
+
+ free(c, M_DEVBUF);
+}
+
+/*
+ * snd_clone_acquire() : The vital part of concurrency management. Must be
+ * called somewhere at the beginning of open() handler. ENODEV is not really
+ * fatal since it just tell the caller that this is not cloned stuff.
+ * EBUSY is *real*, don't forget that!
+ */
+int
+snd_clone_acquire(struct cdev *dev)
+{
+ struct snd_clone_entry *ce;
+
+ SND_CLONE_ASSERT(dev != NULL, ("NULL dev"));
+
+ ce = dev->si_drv2;
+ if (ce == NULL)
+ return (ENODEV);
+
+ SND_CLONE_ASSERT(ce->parent != NULL, ("NULL parent"));
+
+ ce->flags &= ~SND_CLONE_INVOKE;
+
+ if (ce->flags & SND_CLONE_BUSY)
+ return (EBUSY);
+
+ ce->flags |= SND_CLONE_BUSY;
+
+ return (0);
+}
+
+/*
+ * snd_clone_release() : Release busy status. Must be called somewhere at
+ * the end of close() handler, or somewhere after fail open().
+ */
+int
+snd_clone_release(struct cdev *dev)
+{
+ struct snd_clone_entry *ce;
+
+ SND_CLONE_ASSERT(dev != NULL, ("NULL dev"));
+
+ ce = dev->si_drv2;
+ if (ce == NULL)
+ return (ENODEV);
+
+ SND_CLONE_ASSERT(ce->parent != NULL, ("NULL parent"));
+
+ ce->flags &= ~SND_CLONE_INVOKE;
+
+ if (!(ce->flags & SND_CLONE_BUSY))
+ return (EBADF);
+
+ ce->flags &= ~SND_CLONE_BUSY;
+ ce->pid = -1;
+
+ return (0);
+}
+
+/*
+ * snd_clone_ref/unref() : Garbage collector reference counter. To make
+ * garbage collector run automatically, the sequence must be something like
+ * this (both in open() and close() handlers):
+ *
+ * open() - 1) snd_clone_acquire()
+ * 2) .... check check ... if failed, snd_clone_release()
+ * 3) Success. Call snd_clone_ref()
+ *
+ * close() - 1) .... check check check ....
+ * 2) Success. snd_clone_release()
+ * 3) snd_clone_unref() . Garbage collector will run at this point
+ * if this is the last referenced object.
+ */
+int
+snd_clone_ref(struct cdev *dev)
+{
+ struct snd_clone_entry *ce;
+ struct snd_clone *c;
+
+ SND_CLONE_ASSERT(dev != NULL, ("NULL dev"));
+
+ ce = dev->si_drv2;
+ if (ce == NULL)
+ return (0);
+
+ c = ce->parent;
+ SND_CLONE_ASSERT(c != NULL, ("NULL parent"));
+ SND_CLONE_ASSERT(c->refcount >= 0, ("refcount < 0"));
+
+ return (++c->refcount);
+}
+
+int
+snd_clone_unref(struct cdev *dev)
+{
+ struct snd_clone_entry *ce;
+ struct snd_clone *c;
+
+ SND_CLONE_ASSERT(dev != NULL, ("NULL dev"));
+
+ ce = dev->si_drv2;
+ if (ce == NULL)
+ return (0);
+
+ c = ce->parent;
+ SND_CLONE_ASSERT(c != NULL, ("NULL parent"));
+ SND_CLONE_ASSERT(c->refcount > 0, ("refcount <= 0"));
+
+ c->refcount--;
+
+ /*
+ * Run automatic garbage collector, if needed.
+ */
+ if ((c->flags & SND_CLONE_GC_UNREF) &&
+ (!(c->flags & SND_CLONE_GC_LASTREF) ||
+ (c->refcount == 0 && (c->flags & SND_CLONE_GC_LASTREF))))
+ (void)snd_clone_gc(c);
+
+ return (c->refcount);
+}
+
+void
+snd_clone_register(struct snd_clone_entry *ce, struct cdev *dev)
+{
+ SND_CLONE_ASSERT(ce != NULL, ("NULL snd_clone_entry"));
+ SND_CLONE_ASSERT(dev != NULL, ("NULL dev"));
+ SND_CLONE_ASSERT(dev->si_drv2 == NULL, ("dev->si_drv2 not NULL"));
+ SND_CLONE_ASSERT((ce->flags & SND_CLONE_ALLOC) == SND_CLONE_ALLOC,
+ ("invalid clone alloc flags=0x%08x", ce->flags));
+ SND_CLONE_ASSERT(ce->devt == NULL, ("ce->devt not NULL"));
+ SND_CLONE_ASSERT(ce->unit == dev2unit(dev),
+ ("invalid unit ce->unit=0x%08x dev2unit=0x%08x",
+ ce->unit, dev2unit(dev)));
+
+ SND_CLONE_ASSERT(ce->parent != NULL, ("NULL parent"));
+
+ dev->si_drv2 = ce;
+ ce->devt = dev;
+ ce->flags &= ~SND_CLONE_ALLOC;
+ ce->flags |= SND_CLONE_INVOKE;
+}
+
+struct snd_clone_entry *
+snd_clone_alloc(struct snd_clone *c, struct cdev **dev, int *unit, int tmask)
+{
+ struct snd_clone_entry *ce, *after, *bce, *cce, *nce, *tce;
+ struct timespec now;
+ int cunit, allocunit;
+ pid_t curpid;
+
+ SND_CLONE_ASSERT(c != NULL, ("NULL snd_clone"));
+ SND_CLONE_ASSERT(dev != NULL, ("NULL dev pointer"));
+ SND_CLONE_ASSERT((c->typemask & tmask) == tmask,
+ ("invalid tmask: typemask=0x%08x tmask=0x%08x",
+ c->typemask, tmask));
+ SND_CLONE_ASSERT(unit != NULL, ("NULL unit pointer"));
+ SND_CLONE_ASSERT(*unit == -1 || !(*unit & (c->typemask | tmask)),
+ ("typemask collision: typemask=0x%08x tmask=0x%08x *unit=%d",
+ c->typemask, tmask, *unit));
+
+ if (!(c->flags & SND_CLONE_ENABLE) ||
+ (*unit != -1 && *unit > c->maxunit))
+ return (NULL);
+
+ ce = NULL;
+ after = NULL;
+ bce = NULL; /* "b"usy candidate */
+ cce = NULL; /* "c"urthread/proc candidate */
+ nce = NULL; /* "n"ull, totally unbusy candidate */
+ tce = NULL; /* Last "t"ry candidate */
+ cunit = 0;
+ allocunit = (*unit == -1) ? 0 : *unit;
+ curpid = curthread->td_proc->p_pid;
+
+ getnanouptime(&now);
+
+ TAILQ_FOREACH(ce, &c->head, link) {
+ /*
+ * Sort incrementally according to device type.
+ */
+ if (tmask > (ce->unit & c->typemask)) {
+ if (cunit == 0)
+ after = ce;
+ continue;
+ } else if (tmask < (ce->unit & c->typemask))
+ break;
+
+ /*
+ * Shoot.. this is where the grumpiness begin. Just
+ * return immediately.
+ */
+ if (*unit != -1 && *unit == (ce->unit & ~tmask))
+ goto snd_clone_alloc_out;
+
+ cunit++;
+ /*
+ * Simmilar device type. Sort incrementally according
+ * to allocation unit. While here, look for free slot
+ * and possible collision for new / future allocation.
+ */
+ if (*unit == -1 && (ce->unit & ~tmask) == allocunit)
+ allocunit++;
+ if ((ce->unit & ~tmask) < allocunit)
+ after = ce;
+ /*
+ * Clone logic:
+ * 1. Look for non busy, but keep track of the best
+ * possible busy cdev.
+ * 2. Look for the best (oldest referenced) entry that is
+ * in a same process / thread.
+ * 3. Look for the best (oldest referenced), absolute free
+ * entry.
+ * 4. Lastly, look for the best (oldest referenced)
+ * any entries that doesn't fit with anything above.
+ */
+ if (ce->flags & SND_CLONE_BUSY) {
+ if (ce->devt != NULL && (bce == NULL ||
+ timespeccmp(&ce->tsp, &bce->tsp, <)))
+ bce = ce;
+ continue;
+ }
+ if (ce->pid == curpid &&
+ (cce == NULL || timespeccmp(&ce->tsp, &cce->tsp, <)))
+ cce = ce;
+ else if (!(ce->flags & SND_CLONE_INVOKE) &&
+ (nce == NULL || timespeccmp(&ce->tsp, &nce->tsp, <)))
+ nce = ce;
+ else if (tce == NULL || timespeccmp(&ce->tsp, &tce->tsp, <))
+ tce = ce;
+ }
+ if (*unit != -1)
+ goto snd_clone_alloc_new;
+ else if (cce != NULL) {
+ /* Same proc entry found, go for it */
+ ce = cce;
+ goto snd_clone_alloc_out;
+ } else if (nce != NULL) {
+ /*
+ * Next, try absolute free entry. If the calculated
+ * allocunit is smaller, create new entry instead.
+ */
+ if (allocunit < (nce->unit & ~tmask))
+ goto snd_clone_alloc_new;
+ ce = nce;
+ goto snd_clone_alloc_out;
+ } else if (allocunit > c->maxunit) {
+ /*
+ * Maximum allowable unit reached. Try returning any
+ * available cdev and hope for the best. If the lookup is
+ * done for things like stat(), mtime() etc. , things should
+ * be ok. Otherwise, open() handler should do further checks
+ * and decide whether to return correct error code or not.
+ */
+ if (tce != NULL) {
+ ce = tce;
+ goto snd_clone_alloc_out;
+ } else if (bce != NULL) {
+ ce = bce;
+ goto snd_clone_alloc_out;
+ }
+ return (NULL);
+ }
+
+snd_clone_alloc_new:
+ /*
+ * No free entries found, and we still haven't reached maximum
+ * allowable units. Allocate, setup a minimal unique entry with busy
+ * status so nobody will monkey on this new entry. Unit magic is set
+ * right here to avoid collision with other contesting handler.
+ * The caller must be carefull here to maintain its own
+ * synchronization, as long as it will not conflict with malloc(9)
+ * operations.
+ *
+ * That said, go figure.
+ */
+ ce = malloc(sizeof(*ce), M_DEVBUF,
+ ((c->flags & SND_CLONE_WAITOK) ? M_WAITOK : M_NOWAIT) | M_ZERO);
+ if (ce == NULL) {
+ if (*unit != -1)
+ return (NULL);
+ /*
+ * We're being dense, ignorance is bliss,
+ * Super Regulatory Measure (TM).. TRY AGAIN!
+ */
+ if (nce != NULL) {
+ ce = nce;
+ goto snd_clone_alloc_out;
+ } else if (tce != NULL) {
+ ce = tce;
+ goto snd_clone_alloc_out;
+ } else if (bce != NULL) {
+ ce = bce;
+ goto snd_clone_alloc_out;
+ }
+ return (NULL);
+ }
+ /* Setup new entry */
+ ce->parent = c;
+ ce->unit = tmask | allocunit;
+ ce->pid = curpid;
+ ce->tsp = now;
+ ce->flags |= SND_CLONE_ALLOC;
+ if (after != NULL) {
+ TAILQ_INSERT_AFTER(&c->head, after, ce, link);
+ } else {
+ TAILQ_INSERT_HEAD(&c->head, ce, link);
+ }
+ c->size++;
+ c->tsp = now;
+ /*
+ * Save new allocation unit for caller which will be used
+ * by make_dev().
+ */
+ *unit = allocunit;
+
+ return (ce);
+
+snd_clone_alloc_out:
+ /*
+ * Set, mark, timestamp the entry if this is a truly free entry.
+ * Leave busy entry alone.
+ */
+ if (!(ce->flags & SND_CLONE_BUSY)) {
+ ce->pid = curpid;
+ ce->tsp = now;
+ ce->flags |= SND_CLONE_INVOKE;
+ }
+ c->tsp = now;
+ *dev = ce->devt;
+
+ return (NULL);
+}
diff --git a/sys/dev/sound/clone.h b/sys/dev/sound/clone.h
new file mode 100644
index 000000000000..38b57b85b3e4
--- /dev/null
+++ b/sys/dev/sound/clone.h
@@ -0,0 +1,127 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause
+ *
+ * Copyright (c) 2007 Ariff Abdullah <ariff@FreeBSD.org>
+ * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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.
+ */
+
+#ifndef _SND_CLONE_H_
+#define _SND_CLONE_H_
+
+struct snd_clone_entry;
+struct snd_clone;
+
+/*
+ * 750 milisecond default deadline. Short enough to not cause excessive
+ * garbage collection, long enough to indicate stalled VFS.
+ */
+#define SND_CLONE_DEADLINE_DEFAULT 750
+
+/*
+ * Fit within 24bit MAXMINOR.
+ */
+#define SND_CLONE_MAXUNIT 0xffffff
+
+/*
+ * Creation flags, mostly related to the behaviour of garbage collector.
+ *
+ * SND_CLONE_ENABLE - Enable clone allocation.
+ * SND_CLONE_GC_ENABLE - Enable garbage collector operation, automatically
+ * or if explicitly called upon.
+ * SND_CLONE_GC_UNREF - Garbage collect during unref operation.
+ * SND_CLONE_GC_LASTREF - Garbage collect during last reference
+ * (refcount = 0)
+ * SND_CLONE_GC_EXPIRED - Don't garbage collect unless the global clone
+ * handler has been expired.
+ * SND_CLONE_GC_REVOKE - Revoke clone invocation status which has been
+ * expired instead of removing and freeing it.
+ * SND_CLONE_WAITOK - malloc() is allowed to sleep while allocating
+ * clone entry.
+ */
+#define SND_CLONE_ENABLE 0x00000001
+#define SND_CLONE_GC_ENABLE 0x00000002
+#define SND_CLONE_GC_UNREF 0x00000004
+#define SND_CLONE_GC_LASTREF 0x00000008
+#define SND_CLONE_GC_EXPIRED 0x00000010
+#define SND_CLONE_GC_REVOKE 0x00000020
+#define SND_CLONE_WAITOK 0x80000000
+
+#define SND_CLONE_GC_MASK (SND_CLONE_GC_ENABLE | \
+ SND_CLONE_GC_UNREF | \
+ SND_CLONE_GC_LASTREF | \
+ SND_CLONE_GC_EXPIRED | \
+ SND_CLONE_GC_REVOKE)
+
+#define SND_CLONE_MASK (SND_CLONE_ENABLE | SND_CLONE_GC_MASK | \
+ SND_CLONE_WAITOK)
+
+/*
+ * Runtime clone device flags
+ *
+ * These are mostly private to the clone manager operation:
+ *
+ * SND_CLONE_NEW - New clone allocation in progress.
+ * SND_CLONE_INVOKE - Cloning being invoked, waiting for next VFS operation.
+ * SND_CLONE_BUSY - In progress, being referenced by living thread/proc.
+ */
+#define SND_CLONE_NEW 0x00000001
+#define SND_CLONE_INVOKE 0x00000002
+#define SND_CLONE_BUSY 0x00000004
+
+/*
+ * Nothing important, just for convenience.
+ */
+#define SND_CLONE_ALLOC (SND_CLONE_NEW | SND_CLONE_INVOKE | \
+ SND_CLONE_BUSY)
+
+#define SND_CLONE_DEVMASK SND_CLONE_ALLOC
+
+struct snd_clone *snd_clone_create(int, int, int, uint32_t);
+int snd_clone_busy(struct snd_clone *);
+int snd_clone_enable(struct snd_clone *);
+int snd_clone_disable(struct snd_clone *);
+int snd_clone_getsize(struct snd_clone *);
+int snd_clone_getmaxunit(struct snd_clone *);
+int snd_clone_setmaxunit(struct snd_clone *, int);
+int snd_clone_getdeadline(struct snd_clone *);
+int snd_clone_setdeadline(struct snd_clone *, int);
+uint32_t snd_clone_getflags(struct snd_clone *);
+uint32_t snd_clone_setflags(struct snd_clone *, uint32_t);
+uint32_t snd_clone_getdevflags(struct cdev *);
+uint32_t snd_clone_setdevflags(struct cdev *, uint32_t);
+int snd_clone_gc(struct snd_clone *);
+void snd_clone_destroy(struct snd_clone *);
+int snd_clone_acquire(struct cdev *);
+int snd_clone_release(struct cdev *);
+int snd_clone_ref(struct cdev *);
+int snd_clone_unref(struct cdev *);
+void snd_clone_register(struct snd_clone_entry *, struct cdev *);
+struct snd_clone_entry *snd_clone_alloc(struct snd_clone *, struct cdev **,
+ int *, int);
+
+#define snd_clone_enabled(x) ((x) != NULL && \
+ (snd_clone_getflags(x) & SND_CLONE_ENABLE))
+#define snd_clone_disabled(x) (!snd_clone_enabled(x))
+
+#endif /* !_SND_CLONE_H */
diff --git a/sys/dev/sound/pcm/dsp.c b/sys/dev/sound/pcm/dsp.c
index b9693908da43..9040c77893d4 100644
--- a/sys/dev/sound/pcm/dsp.c
+++ b/sys/dev/sound/pcm/dsp.c
@@ -43,14 +43,6 @@
#include <vm/vm_page.h>
#include <vm/vm_pager.h>
-struct dsp_cdevpriv {
- struct snddev_info *sc;
*** 1855 LINES SKIPPED ***