1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2005-2009 Ariff Abdullah <ariff@FreeBSD.org>
5 * Copyright (c) 2001 Cameron Grant <cg@FreeBSD.org>
6 * Copyright (c) 2020 The FreeBSD Foundation
7 * All rights reserved.
8 *
9 * Portions of this software were developed by Ka Ho Ng
10 * under sponsorship from the FreeBSD Foundation.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34 #ifdef HAVE_KERNEL_OPTION_HEADERS
35 #include "opt_snd.h"
36 #endif
37
38 #include <sys/param.h>
39 #include <sys/lock.h>
40 #include <sys/malloc.h>
41 #include <sys/nv.h>
42 #include <sys/dnv.h>
43 #include <sys/sx.h>
44 #ifdef COMPAT_FREEBSD32
45 #include <sys/sysent.h>
46 #endif
47
48 #include <dev/sound/pcm/sound.h>
49 #include <dev/sound/pcm/pcm.h>
50 #include <dev/sound/version.h>
51
52
53 SND_DECLARE_FILE("$FreeBSD$");
54
55 #define SS_TYPE_MODULE 0
56 #define SS_TYPE_PCM 1
57 #define SS_TYPE_MIDI 2
58 #define SS_TYPE_SEQUENCER 3
59
60 static d_open_t sndstat_open;
61 static void sndstat_close(void *);
62 static d_read_t sndstat_read;
63 static d_write_t sndstat_write;
64 static d_ioctl_t sndstat_ioctl;
65
66 static struct cdevsw sndstat_cdevsw = {
67 .d_version = D_VERSION,
68 .d_open = sndstat_open,
69 .d_read = sndstat_read,
70 .d_write = sndstat_write,
71 .d_ioctl = sndstat_ioctl,
72 .d_name = "sndstat",
73 .d_flags = D_TRACKCLOSE,
74 };
75
76 struct sndstat_entry {
77 TAILQ_ENTRY(sndstat_entry) link;
78 device_t dev;
79 char *str;
80 sndstat_handler handler;
81 int type, unit;
82 };
83
84 struct sndstat_userdev {
85 TAILQ_ENTRY(sndstat_userdev) link;
86 char *provider;
87 char *nameunit;
88 char *devnode;
89 char *desc;
90 unsigned int pchan;
91 unsigned int rchan;
92 struct {
93 uint32_t min_rate;
94 uint32_t max_rate;
95 uint32_t formats;
96 uint32_t min_chn;
97 uint32_t max_chn;
98 } info_play, info_rec;
99 nvlist_t *provider_nvl;
100 };
101
102 struct sndstat_file {
103 TAILQ_ENTRY(sndstat_file) entry;
104 struct sbuf sbuf;
105 struct sx lock;
106 void *devs_nvlbuf; /* (l) */
107 size_t devs_nbytes; /* (l) */
108 TAILQ_HEAD(, sndstat_userdev) userdev_list; /* (l) */
109 int out_offset;
110 int in_offset;
111 int fflags;
112 };
113
114 static struct sx sndstat_lock;
115 static struct cdev *sndstat_dev;
116
117 #define SNDSTAT_LOCK() sx_xlock(&sndstat_lock)
118 #define SNDSTAT_UNLOCK() sx_xunlock(&sndstat_lock)
119
120 static TAILQ_HEAD(, sndstat_entry) sndstat_devlist = TAILQ_HEAD_INITIALIZER(sndstat_devlist);
121 static TAILQ_HEAD(, sndstat_file) sndstat_filelist = TAILQ_HEAD_INITIALIZER(sndstat_filelist);
122
123 int snd_verbose = 0;
124
125 static int sndstat_prepare(struct sndstat_file *);
126 static struct sndstat_userdev *
127 sndstat_line2userdev(struct sndstat_file *, const char *, int);
128
129 static int
130 sysctl_hw_sndverbose(SYSCTL_HANDLER_ARGS)
131 {
132 int error, verbose;
133
134 verbose = snd_verbose;
135 error = sysctl_handle_int(oidp, &verbose, 0, req);
136 if (error == 0 && req->newptr != NULL) {
137 if (verbose < 0 || verbose > 4)
138 error = EINVAL;
139 else
140 snd_verbose = verbose;
141 }
142 return (error);
143 }
144 SYSCTL_PROC(_hw_snd, OID_AUTO, verbose,
145 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, 0, sizeof(int),
146 sysctl_hw_sndverbose, "I",
147 "verbosity level");
148
149 static int
150 sndstat_open(struct cdev *i_dev, int flags, int mode, struct thread *td)
151 {
152 struct sndstat_file *pf;
153
154 pf = malloc(sizeof(*pf), M_DEVBUF, M_WAITOK | M_ZERO);
155
156 if (sbuf_new(&pf->sbuf, NULL, 4096, SBUF_AUTOEXTEND) == NULL) {
157 free(pf, M_DEVBUF);
158 return (ENOMEM);
159 }
160
161 pf->fflags = flags;
162 TAILQ_INIT(&pf->userdev_list);
163 sx_init(&pf->lock, "sndstat_file");
164
165 SNDSTAT_LOCK();
166 TAILQ_INSERT_TAIL(&sndstat_filelist, pf, entry);
167 SNDSTAT_UNLOCK();
168
169 devfs_set_cdevpriv(pf, &sndstat_close);
170
171 return (0);
172 }
173
174 /*
175 * Should only be called either when:
176 * * Closing
177 * * pf->lock held
178 */
179 static void
180 sndstat_remove_all_userdevs(struct sndstat_file *pf)
181 {
182 struct sndstat_userdev *ud;
183
184 KASSERT(
185 sx_xlocked(&pf->lock), ("%s: Called without pf->lock", __func__));
186 while ((ud = TAILQ_FIRST(&pf->userdev_list)) != NULL) {
187 TAILQ_REMOVE(&pf->userdev_list, ud, link);
188 free(ud->provider, M_DEVBUF);
189 free(ud->desc, M_DEVBUF);
190 free(ud->devnode, M_DEVBUF);
191 free(ud->nameunit, M_DEVBUF);
192 nvlist_destroy(ud->provider_nvl);
193 free(ud, M_DEVBUF);
194 }
195 }
196
197 static void
198 sndstat_close(void *sndstat_file)
199 {
200 struct sndstat_file *pf = (struct sndstat_file *)sndstat_file;
201
202 SNDSTAT_LOCK();
203 sbuf_delete(&pf->sbuf);
204 TAILQ_REMOVE(&sndstat_filelist, pf, entry);
205 SNDSTAT_UNLOCK();
206
207 free(pf->devs_nvlbuf, M_NVLIST);
208 sx_xlock(&pf->lock);
209 sndstat_remove_all_userdevs(pf);
210 sx_xunlock(&pf->lock);
211 sx_destroy(&pf->lock);
212
213 free(pf, M_DEVBUF);
214 }
215
216 static int
217 sndstat_read(struct cdev *i_dev, struct uio *buf, int flag)
218 {
219 struct sndstat_file *pf;
220 int err;
221 int len;
222
223 err = devfs_get_cdevpriv((void **)&pf);
224 if (err != 0)
225 return (err);
226
227 /* skip zero-length reads */
228 if (buf->uio_resid == 0)
229 return (0);
230
231 SNDSTAT_LOCK();
232 if (pf->out_offset != 0) {
233 /* don't allow both reading and writing */
234 err = EINVAL;
235 goto done;
236 } else if (pf->in_offset == 0) {
237 err = sndstat_prepare(pf);
238 if (err <= 0) {
239 err = ENOMEM;
240 goto done;
241 }
242 }
243 len = sbuf_len(&pf->sbuf) - pf->in_offset;
244 if (len > buf->uio_resid)
245 len = buf->uio_resid;
246 if (len > 0)
247 err = uiomove(sbuf_data(&pf->sbuf) + pf->in_offset, len, buf);
248 pf->in_offset += len;
249 done:
250 SNDSTAT_UNLOCK();
251 return (err);
252 }
253
254 static int
255 sndstat_write(struct cdev *i_dev, struct uio *buf, int flag)
256 {
257 struct sndstat_file *pf;
258 uint8_t temp[64];
259 int err;
260 int len;
261
262 err = devfs_get_cdevpriv((void **)&pf);
263 if (err != 0)
264 return (err);
265
266 /* skip zero-length writes */
267 if (buf->uio_resid == 0)
268 return (0);
269
270 /* don't allow writing more than 64Kbytes */
271 if (buf->uio_resid > 65536)
272 return (ENOMEM);
273
274 SNDSTAT_LOCK();
275 if (pf->in_offset != 0) {
276 /* don't allow both reading and writing */
277 err = EINVAL;
278 } else {
279 /* only remember the last write - allows for updates */
280 sx_xlock(&pf->lock);
281 sndstat_remove_all_userdevs(pf);
282 sx_xunlock(&pf->lock);
283
284 while (1) {
285 len = sizeof(temp);
286 if (len > buf->uio_resid)
287 len = buf->uio_resid;
288 if (len > 0) {
289 err = uiomove(temp, len, buf);
290 if (err)
291 break;
292 } else {
293 break;
294 }
295 if (sbuf_bcat(&pf->sbuf, temp, len) < 0) {
296 err = ENOMEM;
297 break;
298 }
299 }
300 sbuf_finish(&pf->sbuf);
301
302 if (err == 0) {
303 char *line, *str;
304
305 str = sbuf_data(&pf->sbuf);
306 while ((line = strsep(&str, "\n")) != NULL) {
307 struct sndstat_userdev *ud;
308
309 ud = sndstat_line2userdev(pf, line, strlen(line));
310 if (ud == NULL)
311 continue;
312
313 sx_xlock(&pf->lock);
314 TAILQ_INSERT_TAIL(&pf->userdev_list, ud, link);
315 sx_xunlock(&pf->lock);
316 }
317
318 pf->out_offset = sbuf_len(&pf->sbuf);
319 } else
320 pf->out_offset = 0;
321
322 sbuf_clear(&pf->sbuf);
323 }
324 SNDSTAT_UNLOCK();
325 return (err);
326 }
327
328 static void
329 sndstat_get_caps(struct snddev_info *d, bool play, uint32_t *min_rate,
330 uint32_t *max_rate, uint32_t *fmts, uint32_t *minchn, uint32_t *maxchn)
331 {
332 struct pcm_channel *c;
333 unsigned int encoding;
334 int dir;
335
336 dir = play ? PCMDIR_PLAY : PCMDIR_REC;
337
338 if (play && d->pvchancount > 0) {
339 *min_rate = *max_rate = d->pvchanrate;
340 *fmts = AFMT_ENCODING(d->pvchanformat);
341 *minchn = *maxchn = AFMT_CHANNEL(d->pvchanformat);
342 return;
343 } else if (!play && d->rvchancount > 0) {
344 *min_rate = *max_rate = d->rvchanrate;
345 *fmts = AFMT_ENCODING(d->rvchanformat);
346 *minchn = *maxchn = AFMT_CHANNEL(d->rvchanformat);
347 return;
348 }
349
350 *min_rate = UINT32_MAX;
351 *max_rate = 0;
352 *minchn = UINT32_MAX;
353 *maxchn = 0;
354 encoding = 0;
355 CHN_FOREACH(c, d, channels.pcm) {
356 struct pcmchan_caps *caps;
357 int i;
358
359 if (c->direction != dir || (c->flags & CHN_F_VIRTUAL) != 0)
360 continue;
361
362 CHN_LOCK(c);
363 caps = chn_getcaps(c);
364 *min_rate = min(caps->minspeed, *min_rate);
365 *max_rate = max(caps->maxspeed, *max_rate);
366 for (i = 0; caps->fmtlist[i]; i++) {
367 encoding |= AFMT_ENCODING(caps->fmtlist[i]);
368 *minchn = min(AFMT_CHANNEL(encoding), *minchn);
369 *maxchn = max(AFMT_CHANNEL(encoding), *maxchn);
370 }
371 CHN_UNLOCK(c);
372 }
373 if (*min_rate == UINT32_MAX)
374 *min_rate = 0;
375 if (*minchn == UINT32_MAX)
376 *minchn = 0;
377 }
378
379 static nvlist_t *
380 sndstat_create_diinfo_nv(uint32_t min_rate, uint32_t max_rate, uint32_t formats,
381 uint32_t min_chn, uint32_t max_chn)
382 {
383 nvlist_t *nv;
384
385 nv = nvlist_create(0);
386 if (nv == NULL)
387 return (NULL);
388 nvlist_add_number(nv, SNDST_DSPS_INFO_MIN_RATE, min_rate);
389 nvlist_add_number(nv, SNDST_DSPS_INFO_MAX_RATE, max_rate);
390 nvlist_add_number(nv, SNDST_DSPS_INFO_FORMATS, formats);
391 nvlist_add_number(nv, SNDST_DSPS_INFO_MIN_CHN, min_chn);
392 nvlist_add_number(nv, SNDST_DSPS_INFO_MAX_CHN, max_chn);
393 return (nv);
394 }
395
396 static int
397 sndstat_build_sound4_nvlist(struct snddev_info *d, nvlist_t **dip)
398 {
399 uint32_t maxrate, minrate, fmts, minchn, maxchn;
400 nvlist_t *di = NULL, *sound4di = NULL, *diinfo = NULL;
401 int err;
402
403 di = nvlist_create(0);
404 if (di == NULL) {
405 err = ENOMEM;
406 goto done;
407 }
408 sound4di = nvlist_create(0);
409 if (sound4di == NULL) {
410 err = ENOMEM;
411 goto done;
412 }
413
414 nvlist_add_bool(di, SNDST_DSPS_FROM_USER, false);
415 nvlist_add_stringf(di, SNDST_DSPS_NAMEUNIT, "%s",
416 device_get_nameunit(d->dev));
417 nvlist_add_stringf(di, SNDST_DSPS_DEVNODE, "dsp%d",
418 device_get_unit(d->dev));
419 nvlist_add_string(
420 di, SNDST_DSPS_DESC, device_get_desc(d->dev));
421
422 PCM_ACQUIRE_QUICK(d);
423 nvlist_add_number(di, SNDST_DSPS_PCHAN, d->playcount);
424 nvlist_add_number(di, SNDST_DSPS_RCHAN, d->reccount);
425 if (d->playcount > 0) {
426 sndstat_get_caps(d, true, &minrate, &maxrate, &fmts, &minchn,
427 &maxchn);
428 nvlist_add_number(di, "pminrate", minrate);
429 nvlist_add_number(di, "pmaxrate", maxrate);
430 nvlist_add_number(di, "pfmts", fmts);
431 diinfo = sndstat_create_diinfo_nv(minrate, maxrate, fmts,
432 minchn, maxchn);
433 if (diinfo == NULL)
434 nvlist_set_error(di, ENOMEM);
435 else
436 nvlist_move_nvlist(di, SNDST_DSPS_INFO_PLAY, diinfo);
437 }
438 if (d->reccount > 0) {
439 sndstat_get_caps(d, false, &minrate, &maxrate, &fmts, &minchn,
440 &maxchn);
441 nvlist_add_number(di, "rminrate", minrate);
442 nvlist_add_number(di, "rmaxrate", maxrate);
443 nvlist_add_number(di, "rfmts", fmts);
444 diinfo = sndstat_create_diinfo_nv(minrate, maxrate, fmts,
445 minchn, maxchn);
446 if (diinfo == NULL)
447 nvlist_set_error(di, ENOMEM);
448 else
449 nvlist_move_nvlist(di, SNDST_DSPS_INFO_REC, diinfo);
450 }
451
452 nvlist_add_number(sound4di, SNDST_DSPS_SOUND4_UNIT,
453 device_get_unit(d->dev)); // XXX: I want signed integer here
454 nvlist_add_bool(
455 sound4di, SNDST_DSPS_SOUND4_BITPERFECT, d->flags & SD_F_BITPERFECT);
456 nvlist_add_number(sound4di, SNDST_DSPS_SOUND4_PVCHAN, d->pvchancount);
457 nvlist_add_number(sound4di, SNDST_DSPS_SOUND4_RVCHAN, d->rvchancount);
458 nvlist_move_nvlist(di, SNDST_DSPS_PROVIDER_INFO, sound4di);
459 sound4di = NULL;
460 PCM_RELEASE_QUICK(d);
461 nvlist_add_string(di, SNDST_DSPS_PROVIDER, SNDST_DSPS_SOUND4_PROVIDER);
462
463 err = nvlist_error(di);
464 if (err)
465 goto done;
466
467 *dip = di;
468
469 done:
470 if (err) {
471 nvlist_destroy(sound4di);
472 nvlist_destroy(di);
473 }
474 return (err);
475 }
476
477 static int
478 sndstat_build_userland_nvlist(struct sndstat_userdev *ud, nvlist_t **dip)
479 {
480 nvlist_t *di, *diinfo;
481 int err;
482
483 di = nvlist_create(0);
484 if (di == NULL) {
485 err = ENOMEM;
486 goto done;
487 }
488
489 nvlist_add_bool(di, SNDST_DSPS_FROM_USER, true);
490 nvlist_add_number(di, SNDST_DSPS_PCHAN, ud->pchan);
491 nvlist_add_number(di, SNDST_DSPS_RCHAN, ud->rchan);
492 nvlist_add_string(di, SNDST_DSPS_NAMEUNIT, ud->nameunit);
493 nvlist_add_string(
494 di, SNDST_DSPS_DEVNODE, ud->devnode);
495 nvlist_add_string(di, SNDST_DSPS_DESC, ud->desc);
496 if (ud->pchan != 0) {
497 nvlist_add_number(di, "pminrate",
498 ud->info_play.min_rate);
499 nvlist_add_number(di, "pmaxrate",
500 ud->info_play.max_rate);
501 nvlist_add_number(di, "pfmts",
502 ud->info_play.formats);
503 diinfo = sndstat_create_diinfo_nv(ud->info_play.min_rate,
504 ud->info_play.max_rate, ud->info_play.formats,
505 ud->info_play.min_chn, ud->info_play.max_chn);
506 if (diinfo == NULL)
507 nvlist_set_error(di, ENOMEM);
508 else
509 nvlist_move_nvlist(di, SNDST_DSPS_INFO_PLAY, diinfo);
510 }
511 if (ud->rchan != 0) {
512 nvlist_add_number(di, "rminrate",
513 ud->info_rec.min_rate);
514 nvlist_add_number(di, "rmaxrate",
515 ud->info_rec.max_rate);
516 nvlist_add_number(di, "rfmts",
517 ud->info_rec.formats);
518 diinfo = sndstat_create_diinfo_nv(ud->info_rec.min_rate,
519 ud->info_rec.max_rate, ud->info_rec.formats,
520 ud->info_rec.min_chn, ud->info_rec.max_chn);
521 if (diinfo == NULL)
522 nvlist_set_error(di, ENOMEM);
523 else
524 nvlist_move_nvlist(di, SNDST_DSPS_INFO_REC, diinfo);
525 }
526 nvlist_add_string(di, SNDST_DSPS_PROVIDER,
527 (ud->provider != NULL) ? ud->provider : "");
528 if (ud->provider_nvl != NULL)
529 nvlist_add_nvlist(
530 di, SNDST_DSPS_PROVIDER_INFO, ud->provider_nvl);
531
532 err = nvlist_error(di);
533 if (err)
534 goto done;
535
536 *dip = di;
537
538 done:
539 if (err)
540 nvlist_destroy(di);
541 return (err);
542 }
543
544 /*
545 * Should only be called with the following locks held:
546 * * sndstat_lock
547 */
548 static int
549 sndstat_create_devs_nvlist(nvlist_t **nvlp)
550 {
551 int err;
552 nvlist_t *nvl;
553 struct sndstat_entry *ent;
554 struct sndstat_file *pf;
555
556 nvl = nvlist_create(0);
557 if (nvl == NULL)
558 return (ENOMEM);
559
560 TAILQ_FOREACH(ent, &sndstat_devlist, link) {
561 struct snddev_info *d;
562 nvlist_t *di;
563
564 if (ent->dev == NULL)
565 continue;
566 d = device_get_softc(ent->dev);
567 if (!PCM_REGISTERED(d))
568 continue;
569
570 err = sndstat_build_sound4_nvlist(d, &di);
571 if (err)
572 goto done;
573
574 nvlist_append_nvlist_array(nvl, SNDST_DSPS, di);
575 nvlist_destroy(di);
576 err = nvlist_error(nvl);
577 if (err)
578 goto done;
579 }
580
581 TAILQ_FOREACH(pf, &sndstat_filelist, entry) {
582 struct sndstat_userdev *ud;
583
584 sx_xlock(&pf->lock);
585
586 TAILQ_FOREACH(ud, &pf->userdev_list, link) {
587 nvlist_t *di;
588
589 err = sndstat_build_userland_nvlist(ud, &di);
590 if (err != 0) {
591 sx_xunlock(&pf->lock);
592 goto done;
593 }
594 nvlist_append_nvlist_array(nvl, SNDST_DSPS, di);
595 nvlist_destroy(di);
596
597 err = nvlist_error(nvl);
598 if (err != 0) {
599 sx_xunlock(&pf->lock);
600 goto done;
601 }
602 }
603
604 sx_xunlock(&pf->lock);
605 }
606
607 *nvlp = nvl;
608
609 done:
610 if (err != 0)
611 nvlist_destroy(nvl);
612 return (err);
613 }
614
615 static int
616 sndstat_refresh_devs(struct sndstat_file *pf)
617 {
618 sx_xlock(&pf->lock);
619 free(pf->devs_nvlbuf, M_NVLIST);
620 pf->devs_nvlbuf = NULL;
621 pf->devs_nbytes = 0;
622 sx_unlock(&pf->lock);
623
624 return (0);
625 }
626
627 static int
628 sndstat_get_devs(struct sndstat_file *pf, caddr_t data)
629 {
630 int err;
631 struct sndstioc_nv_arg *arg = (struct sndstioc_nv_arg *)data;
632
633 SNDSTAT_LOCK();
634 sx_xlock(&pf->lock);
635
636 if (pf->devs_nvlbuf == NULL) {
637 nvlist_t *nvl;
638 void *nvlbuf;
639 size_t nbytes;
640 int err;
641
642 sx_xunlock(&pf->lock);
643
644 err = sndstat_create_devs_nvlist(&nvl);
645 if (err) {
646 SNDSTAT_UNLOCK();
647 return (err);
648 }
649
650 sx_xlock(&pf->lock);
651
652 nvlbuf = nvlist_pack(nvl, &nbytes);
653 err = nvlist_error(nvl);
654 nvlist_destroy(nvl);
655 if (nvlbuf == NULL || err != 0) {
656 SNDSTAT_UNLOCK();
657 sx_xunlock(&pf->lock);
658 if (err == 0)
659 return (ENOMEM);
660 return (err);
661 }
662
663 free(pf->devs_nvlbuf, M_NVLIST);
664 pf->devs_nvlbuf = nvlbuf;
665 pf->devs_nbytes = nbytes;
666 }
667
668 SNDSTAT_UNLOCK();
669
670 if (!arg->nbytes) {
671 arg->nbytes = pf->devs_nbytes;
672 err = 0;
673 goto done;
674 }
675 if (arg->nbytes < pf->devs_nbytes) {
676 arg->nbytes = 0;
677 err = 0;
678 goto done;
679 }
680
681 err = copyout(pf->devs_nvlbuf, arg->buf, pf->devs_nbytes);
682 if (err)
683 goto done;
684
685 arg->nbytes = pf->devs_nbytes;
686
687 free(pf->devs_nvlbuf, M_NVLIST);
688 pf->devs_nvlbuf = NULL;
689 pf->devs_nbytes = 0;
690
691 done:
692 sx_unlock(&pf->lock);
693 return (err);
694 }
695
696 static int
697 sndstat_unpack_user_nvlbuf(const void *unvlbuf, size_t nbytes, nvlist_t **nvl)
698 {
699 void *nvlbuf;
700 int err;
701
702 nvlbuf = malloc(nbytes, M_DEVBUF, M_WAITOK);
703 err = copyin(unvlbuf, nvlbuf, nbytes);
704 if (err != 0) {
705 free(nvlbuf, M_DEVBUF);
706 return (err);
707 }
708 *nvl = nvlist_unpack(nvlbuf, nbytes, 0);
709 free(nvlbuf, M_DEVBUF);
710 if (nvl == NULL) {
711 return (EINVAL);
712 }
713
714 return (0);
715 }
716
717 static bool
718 sndstat_diinfo_is_sane(const nvlist_t *diinfo)
719 {
720 if (!(nvlist_exists_number(diinfo, SNDST_DSPS_INFO_MIN_RATE) &&
721 nvlist_exists_number(diinfo, SNDST_DSPS_INFO_MAX_RATE) &&
722 nvlist_exists_number(diinfo, SNDST_DSPS_INFO_FORMATS) &&
723 nvlist_exists_number(diinfo, SNDST_DSPS_INFO_MIN_CHN) &&
724 nvlist_exists_number(diinfo, SNDST_DSPS_INFO_MAX_CHN)))
725 return (false);
726 return (true);
727 }
728
729 static bool
730 sndstat_dsp_nvlist_is_sane(const nvlist_t *nvlist)
731 {
732 if (!(nvlist_exists_string(nvlist, SNDST_DSPS_DEVNODE) &&
733 nvlist_exists_string(nvlist, SNDST_DSPS_DESC) &&
734 nvlist_exists_number(nvlist, SNDST_DSPS_PCHAN) &&
735 nvlist_exists_number(nvlist, SNDST_DSPS_RCHAN)))
736 return (false);
737
738 if (nvlist_get_number(nvlist, SNDST_DSPS_PCHAN) > 0) {
739 if (nvlist_exists_nvlist(nvlist, SNDST_DSPS_INFO_PLAY)) {
740 if (!sndstat_diinfo_is_sane(nvlist_get_nvlist(nvlist,
741 SNDST_DSPS_INFO_PLAY)))
742 return (false);
743 } else if (!(nvlist_exists_number(nvlist, "pminrate") &&
744 nvlist_exists_number(nvlist, "pmaxrate") &&
745 nvlist_exists_number(nvlist, "pfmts")))
746 return (false);
747 }
748
749 if (nvlist_get_number(nvlist, SNDST_DSPS_RCHAN) > 0) {
750 if (nvlist_exists_nvlist(nvlist, SNDST_DSPS_INFO_REC)) {
751 if (!sndstat_diinfo_is_sane(nvlist_get_nvlist(nvlist,
752 SNDST_DSPS_INFO_REC)))
753 return (false);
754 } else if (!(nvlist_exists_number(nvlist, "rminrate") &&
755 nvlist_exists_number(nvlist, "rmaxrate") &&
756 nvlist_exists_number(nvlist, "rfmts")))
757 return (false);
758 }
759
760 return (true);
761
762 }
763
764 static void
765 sndstat_get_diinfo_nv(const nvlist_t *nv, uint32_t *min_rate,
766 uint32_t *max_rate, uint32_t *formats, uint32_t *min_chn,
767 uint32_t *max_chn)
768 {
769 *min_rate = nvlist_get_number(nv, SNDST_DSPS_INFO_MIN_RATE);
770 *max_rate = nvlist_get_number(nv, SNDST_DSPS_INFO_MAX_RATE);
771 *formats = nvlist_get_number(nv, SNDST_DSPS_INFO_FORMATS);
772 *min_chn = nvlist_get_number(nv, SNDST_DSPS_INFO_MIN_CHN);
773 *max_chn = nvlist_get_number(nv, SNDST_DSPS_INFO_MAX_CHN);
774 }
775
776 static int
777 sndstat_dsp_unpack_nvlist(const nvlist_t *nvlist, struct sndstat_userdev *ud)
778 {
779 const char *nameunit, *devnode, *desc;
780 unsigned int pchan, rchan;
781 uint32_t pminrate = 0, pmaxrate = 0;
782 uint32_t rminrate = 0, rmaxrate = 0;
783 uint32_t pfmts = 0, rfmts = 0;
784 uint32_t pminchn = 0, pmaxchn = 0;
785 uint32_t rminchn = 0, rmaxchn = 0;
786 nvlist_t *provider_nvl = NULL;
787 const nvlist_t *diinfo;
788 const char *provider;
789
790 devnode = nvlist_get_string(nvlist, SNDST_DSPS_DEVNODE);
791 if (nvlist_exists_string(nvlist, SNDST_DSPS_NAMEUNIT))
792 nameunit = nvlist_get_string(nvlist, SNDST_DSPS_NAMEUNIT);
793 else
794 nameunit = devnode;
795 desc = nvlist_get_string(nvlist, SNDST_DSPS_DESC);
796 pchan = nvlist_get_number(nvlist, SNDST_DSPS_PCHAN);
797 rchan = nvlist_get_number(nvlist, SNDST_DSPS_RCHAN);
798 if (pchan != 0) {
799 if (nvlist_exists_nvlist(nvlist, SNDST_DSPS_INFO_PLAY)) {
800 diinfo = nvlist_get_nvlist(nvlist,
801 SNDST_DSPS_INFO_PLAY);
802 sndstat_get_diinfo_nv(diinfo, &pminrate, &pmaxrate,
803 &pfmts, &pminchn, &pmaxchn);
804 } else {
805 pminrate = nvlist_get_number(nvlist, "pminrate");
806 pmaxrate = nvlist_get_number(nvlist, "pmaxrate");
807 pfmts = nvlist_get_number(nvlist, "pfmts");
808 }
809 }
810 if (rchan != 0) {
811 if (nvlist_exists_nvlist(nvlist, SNDST_DSPS_INFO_REC)) {
812 diinfo = nvlist_get_nvlist(nvlist,
813 SNDST_DSPS_INFO_REC);
814 sndstat_get_diinfo_nv(diinfo, &rminrate, &rmaxrate,
815 &rfmts, &rminchn, &rmaxchn);
816 } else {
817 rminrate = nvlist_get_number(nvlist, "rminrate");
818 rmaxrate = nvlist_get_number(nvlist, "rmaxrate");
819 rfmts = nvlist_get_number(nvlist, "rfmts");
820 }
821 }
822
823 provider = dnvlist_get_string(nvlist, SNDST_DSPS_PROVIDER, "");
824 if (provider[0] == '\0')
825 provider = NULL;
826
827 if (provider != NULL &&
828 nvlist_exists_nvlist(nvlist, SNDST_DSPS_PROVIDER_INFO)) {
829 provider_nvl = nvlist_clone(
830 nvlist_get_nvlist(nvlist, SNDST_DSPS_PROVIDER_INFO));
831 if (provider_nvl == NULL)
832 return (ENOMEM);
833 }
834
835 ud->provider = (provider != NULL) ? strdup(provider, M_DEVBUF) : NULL;
836 ud->devnode = strdup(devnode, M_DEVBUF);
837 ud->nameunit = strdup(nameunit, M_DEVBUF);
838 ud->desc = strdup(desc, M_DEVBUF);
839 ud->pchan = pchan;
840 ud->rchan = rchan;
841 ud->info_play.min_rate = pminrate;
842 ud->info_play.max_rate = pmaxrate;
843 ud->info_play.formats = pfmts;
844 ud->info_play.min_chn = pminchn;
845 ud->info_play.max_chn = pmaxchn;
846 ud->info_rec.min_rate = rminrate;
847 ud->info_rec.max_rate = rmaxrate;
848 ud->info_rec.formats = rfmts;
849 ud->info_rec.min_chn = rminchn;
850 ud->info_rec.max_chn = rmaxchn;
851 ud->provider_nvl = provider_nvl;
852 return (0);
853 }
854
855 static int
856 sndstat_add_user_devs(struct sndstat_file *pf, caddr_t data)
857 {
858 int err;
859 nvlist_t *nvl = NULL;
860 const nvlist_t * const *dsps;
861 size_t i, ndsps;
862 struct sndstioc_nv_arg *arg = (struct sndstioc_nv_arg *)data;
863
864 if ((pf->fflags & FWRITE) == 0) {
865 err = EPERM;
866 goto done;
867 }
868
869 err = sndstat_unpack_user_nvlbuf(arg->buf, arg->nbytes, &nvl);
870 if (err != 0)
871 goto done;
872
873 if (!nvlist_exists_nvlist_array(nvl, SNDST_DSPS)) {
874 err = EINVAL;
875 goto done;
876 }
877 dsps = nvlist_get_nvlist_array(nvl, SNDST_DSPS, &ndsps);
878 for (i = 0; i < ndsps; i++) {
879 if (!sndstat_dsp_nvlist_is_sane(dsps[i])) {
880 err = EINVAL;
881 goto done;
882 }
883 }
884 sx_xlock(&pf->lock);
885 for (i = 0; i < ndsps; i++) {
886 struct sndstat_userdev *ud =
887 malloc(sizeof(*ud), M_DEVBUF, M_WAITOK);
888 err = sndstat_dsp_unpack_nvlist(dsps[i], ud);
889 if (err) {
890 sx_unlock(&pf->lock);
891 goto done;
892 }
893 TAILQ_INSERT_TAIL(&pf->userdev_list, ud, link);
894 }
895 sx_unlock(&pf->lock);
896
897 done:
898 nvlist_destroy(nvl);
899 return (err);
900 }
901
902 static int
903 sndstat_flush_user_devs(struct sndstat_file *pf)
904 {
905 if ((pf->fflags & FWRITE) == 0)
906 return (EPERM);
907
908 sx_xlock(&pf->lock);
909 sndstat_remove_all_userdevs(pf);
910 sx_xunlock(&pf->lock);
911
912 return (0);
913 }
914
915 #ifdef COMPAT_FREEBSD32
916 static int
917 compat_sndstat_get_devs32(struct sndstat_file *pf, caddr_t data)
918 {
919 struct sndstioc_nv_arg32 *arg32 = (struct sndstioc_nv_arg32 *)data;
920 struct sndstioc_nv_arg arg;
921 int err;
922
923 arg.buf = (void *)(uintptr_t)arg32->buf;
924 arg.nbytes = arg32->nbytes;
925
926 err = sndstat_get_devs(pf, (caddr_t)&arg);
927 if (err == 0) {
928 arg32->buf = (uint32_t)(uintptr_t)arg.buf;
929 arg32->nbytes = arg.nbytes;
930 }
931
932 return (err);
933 }
934
935 static int
936 compat_sndstat_add_user_devs32(struct sndstat_file *pf, caddr_t data)
937 {
938 struct sndstioc_nv_arg32 *arg32 = (struct sndstioc_nv_arg32 *)data;
939 struct sndstioc_nv_arg arg;
940 int err;
941
942 arg.buf = (void *)(uintptr_t)arg32->buf;
943 arg.nbytes = arg32->nbytes;
944
945 err = sndstat_add_user_devs(pf, (caddr_t)&arg);
946 if (err == 0) {
947 arg32->buf = (uint32_t)(uintptr_t)arg.buf;
948 arg32->nbytes = arg.nbytes;
949 }
950
951 return (err);
952 }
953 #endif
954
955 static int
956 sndstat_ioctl(
957 struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
958 {
959 int err;
960 struct sndstat_file *pf;
961
962 err = devfs_get_cdevpriv((void **)&pf);
963 if (err != 0)
964 return (err);
965
966 switch (cmd) {
967 case SNDSTIOC_GET_DEVS:
968 err = sndstat_get_devs(pf, data);
969 break;
970 #ifdef COMPAT_FREEBSD32
971 case SNDSTIOC_GET_DEVS32:
972 if (!SV_CURPROC_FLAG(SV_ILP32)) {
973 err = ENODEV;
974 break;
975 }
976 err = compat_sndstat_get_devs32(pf, data);
977 break;
978 #endif
979 case SNDSTIOC_ADD_USER_DEVS:
980 err = sndstat_add_user_devs(pf, data);
981 break;
982 #ifdef COMPAT_FREEBSD32
983 case SNDSTIOC_ADD_USER_DEVS32:
984 if (!SV_CURPROC_FLAG(SV_ILP32)) {
985 err = ENODEV;
986 break;
987 }
988 err = compat_sndstat_add_user_devs32(pf, data);
989 break;
990 #endif
991 case SNDSTIOC_REFRESH_DEVS:
992 err = sndstat_refresh_devs(pf);
993 break;
994 case SNDSTIOC_FLUSH_USER_DEVS:
995 err = sndstat_flush_user_devs(pf);
996 break;
997 default:
998 err = ENODEV;
999 }
1000
1001 return (err);
1002 }
1003
1004 static struct sndstat_userdev *
1005 sndstat_line2userdev(struct sndstat_file *pf, const char *line, int n)
1006 {
1007 struct sndstat_userdev *ud;
1008 const char *e, *m;
1009
1010 ud = malloc(sizeof(*ud), M_DEVBUF, M_WAITOK|M_ZERO);
1011
1012 ud->provider = NULL;
1013 ud->provider_nvl = NULL;
1014 e = strchr(line, ':');
1015 if (e == NULL)
1016 goto fail;
1017 ud->nameunit = strndup(line, e - line, M_DEVBUF);
1018 ud->devnode = (char *)malloc(e - line + 1, M_DEVBUF, M_WAITOK | M_ZERO);
1019 strlcat(ud->devnode, ud->nameunit, e - line + 1);
1020 line = e + 1;
1021
1022 e = strchr(line, '<');
1023 if (e == NULL)
1024 goto fail;
1025 line = e + 1;
1026 e = strrchr(line, '>');
1027 if (e == NULL)
1028 goto fail;
1029 ud->desc = strndup(line, e - line, M_DEVBUF);
1030 line = e + 1;
1031
1032 e = strchr(line, '(');
1033 if (e == NULL)
1034 goto fail;
1035 line = e + 1;
1036 e = strrchr(line, ')');
1037 if (e == NULL)
1038 goto fail;
1039 m = strstr(line, "play");
1040 if (m != NULL && m < e)
1041 ud->pchan = 1;
1042 m = strstr(line, "rec");
1043 if (m != NULL && m < e)
1044 ud->rchan = 1;
1045
1046 return (ud);
1047
1048 fail:
1049 free(ud->nameunit, M_DEVBUF);
1050 free(ud->devnode, M_DEVBUF);
1051 free(ud->desc, M_DEVBUF);
1052 free(ud, M_DEVBUF);
1053 return (NULL);
1054 }
1055
1056 /************************************************************************/
1057
1058 int
1059 sndstat_register(device_t dev, char *str, sndstat_handler handler)
1060 {
1061 struct sndstat_entry *ent;
1062 struct sndstat_entry *pre;
1063 const char *devtype;
1064 int type, unit;
1065
1066 if (dev) {
1067 unit = device_get_unit(dev);
1068 devtype = device_get_name(dev);
1069 if (!strcmp(devtype, "pcm"))
1070 type = SS_TYPE_PCM;
1071 else if (!strcmp(devtype, "midi"))
1072 type = SS_TYPE_MIDI;
1073 else if (!strcmp(devtype, "sequencer"))
1074 type = SS_TYPE_SEQUENCER;
1075 else
1076 return (EINVAL);
1077 } else {
1078 type = SS_TYPE_MODULE;
1079 unit = -1;
1080 }
1081
1082 ent = malloc(sizeof *ent, M_DEVBUF, M_WAITOK | M_ZERO);
1083 ent->dev = dev;
1084 ent->str = str;
1085 ent->type = type;
1086 ent->unit = unit;
1087 ent->handler = handler;
1088
1089 SNDSTAT_LOCK();
1090 /* sorted list insertion */
1091 TAILQ_FOREACH(pre, &sndstat_devlist, link) {
1092 if (pre->unit > unit)
1093 break;
1094 else if (pre->unit < unit)
1095 continue;
1096 if (pre->type > type)
1097 break;
1098 else if (pre->type < unit)
1099 continue;
1100 }
1101 if (pre == NULL) {
1102 TAILQ_INSERT_TAIL(&sndstat_devlist, ent, link);
1103 } else {
1104 TAILQ_INSERT_BEFORE(pre, ent, link);
1105 }
1106 SNDSTAT_UNLOCK();
1107
1108 return (0);
1109 }
1110
1111 int
1112 sndstat_registerfile(char *str)
1113 {
1114 return (sndstat_register(NULL, str, NULL));
1115 }
1116
1117 int
1118 sndstat_unregister(device_t dev)
1119 {
1120 struct sndstat_entry *ent;
1121 int error = ENXIO;
1122
1123 SNDSTAT_LOCK();
1124 TAILQ_FOREACH(ent, &sndstat_devlist, link) {
1125 if (ent->dev == dev) {
1126 TAILQ_REMOVE(&sndstat_devlist, ent, link);
1127 free(ent, M_DEVBUF);
1128 error = 0;
1129 break;
1130 }
1131 }
1132 SNDSTAT_UNLOCK();
1133
1134 return (error);
1135 }
1136
1137 int
1138 sndstat_unregisterfile(char *str)
1139 {
1140 struct sndstat_entry *ent;
1141 int error = ENXIO;
1142
1143 SNDSTAT_LOCK();
1144 TAILQ_FOREACH(ent, &sndstat_devlist, link) {
1145 if (ent->dev == NULL && ent->str == str) {
1146 TAILQ_REMOVE(&sndstat_devlist, ent, link);
1147 free(ent, M_DEVBUF);
1148 error = 0;
1149 break;
1150 }
1151 }
1152 SNDSTAT_UNLOCK();
1153
1154 return (error);
1155 }
1156
1157 /************************************************************************/
1158
1159 static int
1160 sndstat_prepare(struct sndstat_file *pf_self)
1161 {
1162 struct sbuf *s = &pf_self->sbuf;
1163 struct sndstat_entry *ent;
1164 struct snddev_info *d;
1165 struct sndstat_file *pf;
1166 int k;
1167
1168 /* make sure buffer is reset */
1169 sbuf_clear(s);
1170
1171 if (snd_verbose > 0) {
1172 sbuf_printf(s, "FreeBSD Audio Driver (%ubit %d/%s)\n",
1173 (u_int)sizeof(intpcm32_t) << 3, SND_DRV_VERSION,
1174 MACHINE_ARCH);
1175 }
1176
1177 /* generate list of installed devices */
1178 k = 0;
1179 TAILQ_FOREACH(ent, &sndstat_devlist, link) {
1180 if (ent->dev == NULL)
1181 continue;
1182 d = device_get_softc(ent->dev);
1183 if (!PCM_REGISTERED(d))
1184 continue;
1185 if (!k++)
1186 sbuf_printf(s, "Installed devices:\n");
1187 sbuf_printf(s, "%s:", device_get_nameunit(ent->dev));
1188 sbuf_printf(s, " <%s>", device_get_desc(ent->dev));
1189 if (snd_verbose > 0)
1190 sbuf_printf(s, " %s", ent->str);
1191 if (ent->handler) {
1192 /* XXX Need Giant magic entry ??? */
1193 PCM_ACQUIRE_QUICK(d);
1194 ent->handler(s, ent->dev, snd_verbose);
1195 PCM_RELEASE_QUICK(d);
1196 }
1197 sbuf_printf(s, "\n");
1198 }
1199 if (k == 0)
1200 sbuf_printf(s, "No devices installed.\n");
1201
1202 /* append any input from userspace */
1203 k = 0;
1204 TAILQ_FOREACH(pf, &sndstat_filelist, entry) {
1205 struct sndstat_userdev *ud;
1206
1207 if (pf == pf_self)
1208 continue;
1209 sx_xlock(&pf->lock);
1210 if (TAILQ_EMPTY(&pf->userdev_list)) {
1211 sx_unlock(&pf->lock);
1212 continue;
1213 }
1214 if (!k++)
1215 sbuf_printf(s, "Installed devices from userspace:\n");
1216 TAILQ_FOREACH(ud, &pf->userdev_list, link) {
1217 const char *caps = (ud->pchan && ud->rchan) ?
1218 "play/rec" :
1219 (ud->pchan ? "play" : (ud->rchan ? "rec" : ""));
1220 sbuf_printf(s, "%s: <%s>", ud->nameunit, ud->desc);
1221 sbuf_printf(s, " (%s)", caps);
1222 sbuf_printf(s, "\n");
1223 }
1224 sx_unlock(&pf->lock);
1225 }
1226 if (k == 0)
1227 sbuf_printf(s, "No devices installed from userspace.\n");
1228
1229 /* append any file versions */
1230 if (snd_verbose >= 3) {
1231 k = 0;
1232 TAILQ_FOREACH(ent, &sndstat_devlist, link) {
1233 if (ent->dev == NULL && ent->str != NULL) {
1234 if (!k++)
1235 sbuf_printf(s, "\nFile Versions:\n");
1236 sbuf_printf(s, "%s\n", ent->str);
1237 }
1238 }
1239 if (k == 0)
1240 sbuf_printf(s, "\nNo file versions.\n");
1241 }
1242 sbuf_finish(s);
1243 return (sbuf_len(s));
1244 }
1245
1246 static void
1247 sndstat_sysinit(void *p)
1248 {
1249 sx_init(&sndstat_lock, "sndstat lock");
1250 sndstat_dev = make_dev(&sndstat_cdevsw, SND_DEV_STATUS,
1251 UID_ROOT, GID_WHEEL, 0644, "sndstat");
1252 }
1253 SYSINIT(sndstat_sysinit, SI_SUB_DRIVERS, SI_ORDER_FIRST, sndstat_sysinit, NULL);
1254
1255 static void
1256 sndstat_sysuninit(void *p)
1257 {
1258 if (sndstat_dev != NULL) {
1259 /* destroy_dev() will wait for all references to go away */
1260 destroy_dev(sndstat_dev);
1261 }
1262 sx_destroy(&sndstat_lock);
1263 }
1264 SYSUNINIT(sndstat_sysuninit, SI_SUB_DRIVERS, SI_ORDER_FIRST, sndstat_sysuninit, NULL);
Cache object: ac9ea4c51ef5478ade31b416b6d78d79
|