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_NEEDGIANT, 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); 1265