cachepc-qemu

Fork of AMDESE/qemu with changes for cachepc side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-qemu
Log | Files | Refs | Submodules | LICENSE | sfeed.txt

audio_legacy.c (16183B)

      1/*
      2 * QEMU Audio subsystem: legacy configuration handling
      3 *
      4 * Copyright (c) 2015-2019 Zoltán Kővágó <DirtY.iCE.hu@gmail.com>
      5 *
      6 * Permission is hereby granted, free of charge, to any person obtaining a copy
      7 * of this software and associated documentation files (the "Software"), to deal
      8 * in the Software without restriction, including without limitation the rights
      9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
     10 * copies of the Software, and to permit persons to whom the Software is
     11 * furnished to do so, subject to the following conditions:
     12 *
     13 * The above copyright notice and this permission notice shall be included in
     14 * all copies or substantial portions of the Software.
     15 *
     16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
     19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
     22 * THE SOFTWARE.
     23 */
     24#include "qemu/osdep.h"
     25#include "audio.h"
     26#include "audio_int.h"
     27#include "qemu/cutils.h"
     28#include "qemu/timer.h"
     29#include "qapi/error.h"
     30#include "qapi/qapi-visit-audio.h"
     31#include "qapi/visitor-impl.h"
     32
     33#define AUDIO_CAP "audio-legacy"
     34#include "audio_int.h"
     35
     36static uint32_t toui32(const char *str)
     37{
     38    unsigned long long ret;
     39    if (parse_uint_full(str, &ret, 10) || ret > UINT32_MAX) {
     40        dolog("Invalid integer value `%s'\n", str);
     41        exit(1);
     42    }
     43    return ret;
     44}
     45
     46/* helper functions to convert env variables */
     47static void get_bool(const char *env, bool *dst, bool *has_dst)
     48{
     49    const char *val = getenv(env);
     50    if (val) {
     51        *dst = toui32(val) != 0;
     52        *has_dst = true;
     53    }
     54}
     55
     56static void get_int(const char *env, uint32_t *dst, bool *has_dst)
     57{
     58    const char *val = getenv(env);
     59    if (val) {
     60        *dst = toui32(val);
     61        *has_dst = true;
     62    }
     63}
     64
     65static void get_str(const char *env, char **dst, bool *has_dst)
     66{
     67    const char *val = getenv(env);
     68    if (val) {
     69        if (*has_dst) {
     70            g_free(*dst);
     71        }
     72        *dst = g_strdup(val);
     73        *has_dst = true;
     74    }
     75}
     76
     77static void get_fmt(const char *env, AudioFormat *dst, bool *has_dst)
     78{
     79    const char *val = getenv(env);
     80    if (val) {
     81        size_t i;
     82        for (i = 0; AudioFormat_lookup.size; ++i) {
     83            if (strcasecmp(val, AudioFormat_lookup.array[i]) == 0) {
     84                *dst = i;
     85                *has_dst = true;
     86                return;
     87            }
     88        }
     89
     90        dolog("Invalid audio format `%s'\n", val);
     91        exit(1);
     92    }
     93}
     94
     95
     96static void get_millis_to_usecs(const char *env, uint32_t *dst, bool *has_dst)
     97{
     98    const char *val = getenv(env);
     99    if (val) {
    100        *dst = toui32(val) * 1000;
    101        *has_dst = true;
    102    }
    103}
    104
    105static uint32_t frames_to_usecs(uint32_t frames,
    106                                AudiodevPerDirectionOptions *pdo)
    107{
    108    uint32_t freq = pdo->has_frequency ? pdo->frequency : 44100;
    109    return (frames * 1000000 + freq / 2) / freq;
    110}
    111
    112
    113static void get_frames_to_usecs(const char *env, uint32_t *dst, bool *has_dst,
    114                                AudiodevPerDirectionOptions *pdo)
    115{
    116    const char *val = getenv(env);
    117    if (val) {
    118        *dst = frames_to_usecs(toui32(val), pdo);
    119        *has_dst = true;
    120    }
    121}
    122
    123static uint32_t samples_to_usecs(uint32_t samples,
    124                                 AudiodevPerDirectionOptions *pdo)
    125{
    126    uint32_t channels = pdo->has_channels ? pdo->channels : 2;
    127    return frames_to_usecs(samples / channels, pdo);
    128}
    129
    130static void get_samples_to_usecs(const char *env, uint32_t *dst, bool *has_dst,
    131                                 AudiodevPerDirectionOptions *pdo)
    132{
    133    const char *val = getenv(env);
    134    if (val) {
    135        *dst = samples_to_usecs(toui32(val), pdo);
    136        *has_dst = true;
    137    }
    138}
    139
    140static uint32_t bytes_to_usecs(uint32_t bytes, AudiodevPerDirectionOptions *pdo)
    141{
    142    AudioFormat fmt = pdo->has_format ? pdo->format : AUDIO_FORMAT_S16;
    143    uint32_t bytes_per_sample = audioformat_bytes_per_sample(fmt);
    144    return samples_to_usecs(bytes / bytes_per_sample, pdo);
    145}
    146
    147static void get_bytes_to_usecs(const char *env, uint32_t *dst, bool *has_dst,
    148                               AudiodevPerDirectionOptions *pdo)
    149{
    150    const char *val = getenv(env);
    151    if (val) {
    152        *dst = bytes_to_usecs(toui32(val), pdo);
    153        *has_dst = true;
    154    }
    155}
    156
    157/* backend specific functions */
    158/* ALSA */
    159static void handle_alsa_per_direction(
    160    AudiodevAlsaPerDirectionOptions *apdo, const char *prefix)
    161{
    162    char buf[64];
    163    size_t len = strlen(prefix);
    164    bool size_in_usecs = false;
    165    bool dummy;
    166
    167    memcpy(buf, prefix, len);
    168    strcpy(buf + len, "TRY_POLL");
    169    get_bool(buf, &apdo->try_poll, &apdo->has_try_poll);
    170
    171    strcpy(buf + len, "DEV");
    172    get_str(buf, &apdo->dev, &apdo->has_dev);
    173
    174    strcpy(buf + len, "SIZE_IN_USEC");
    175    get_bool(buf, &size_in_usecs, &dummy);
    176
    177    strcpy(buf + len, "PERIOD_SIZE");
    178    get_int(buf, &apdo->period_length, &apdo->has_period_length);
    179    if (apdo->has_period_length && !size_in_usecs) {
    180        apdo->period_length = frames_to_usecs(
    181            apdo->period_length,
    182            qapi_AudiodevAlsaPerDirectionOptions_base(apdo));
    183    }
    184
    185    strcpy(buf + len, "BUFFER_SIZE");
    186    get_int(buf, &apdo->buffer_length, &apdo->has_buffer_length);
    187    if (apdo->has_buffer_length && !size_in_usecs) {
    188        apdo->buffer_length = frames_to_usecs(
    189            apdo->buffer_length,
    190            qapi_AudiodevAlsaPerDirectionOptions_base(apdo));
    191    }
    192}
    193
    194static void handle_alsa(Audiodev *dev)
    195{
    196    AudiodevAlsaOptions *aopt = &dev->u.alsa;
    197    handle_alsa_per_direction(aopt->in, "QEMU_ALSA_ADC_");
    198    handle_alsa_per_direction(aopt->out, "QEMU_ALSA_DAC_");
    199
    200    get_millis_to_usecs("QEMU_ALSA_THRESHOLD",
    201                        &aopt->threshold, &aopt->has_threshold);
    202}
    203
    204/* coreaudio */
    205static void handle_coreaudio(Audiodev *dev)
    206{
    207    get_frames_to_usecs(
    208        "QEMU_COREAUDIO_BUFFER_SIZE",
    209        &dev->u.coreaudio.out->buffer_length,
    210        &dev->u.coreaudio.out->has_buffer_length,
    211        qapi_AudiodevCoreaudioPerDirectionOptions_base(dev->u.coreaudio.out));
    212    get_int("QEMU_COREAUDIO_BUFFER_COUNT",
    213            &dev->u.coreaudio.out->buffer_count,
    214            &dev->u.coreaudio.out->has_buffer_count);
    215}
    216
    217/* dsound */
    218static void handle_dsound(Audiodev *dev)
    219{
    220    get_millis_to_usecs("QEMU_DSOUND_LATENCY_MILLIS",
    221                        &dev->u.dsound.latency, &dev->u.dsound.has_latency);
    222    get_bytes_to_usecs("QEMU_DSOUND_BUFSIZE_OUT",
    223                       &dev->u.dsound.out->buffer_length,
    224                       &dev->u.dsound.out->has_buffer_length,
    225                       dev->u.dsound.out);
    226    get_bytes_to_usecs("QEMU_DSOUND_BUFSIZE_IN",
    227                       &dev->u.dsound.in->buffer_length,
    228                       &dev->u.dsound.in->has_buffer_length,
    229                       dev->u.dsound.in);
    230}
    231
    232/* OSS */
    233static void handle_oss_per_direction(
    234    AudiodevOssPerDirectionOptions *opdo, const char *try_poll_env,
    235    const char *dev_env)
    236{
    237    get_bool(try_poll_env, &opdo->try_poll, &opdo->has_try_poll);
    238    get_str(dev_env, &opdo->dev, &opdo->has_dev);
    239
    240    get_bytes_to_usecs("QEMU_OSS_FRAGSIZE",
    241                       &opdo->buffer_length, &opdo->has_buffer_length,
    242                       qapi_AudiodevOssPerDirectionOptions_base(opdo));
    243    get_int("QEMU_OSS_NFRAGS", &opdo->buffer_count,
    244            &opdo->has_buffer_count);
    245}
    246
    247static void handle_oss(Audiodev *dev)
    248{
    249    AudiodevOssOptions *oopt = &dev->u.oss;
    250    handle_oss_per_direction(oopt->in, "QEMU_AUDIO_ADC_TRY_POLL",
    251                             "QEMU_OSS_ADC_DEV");
    252    handle_oss_per_direction(oopt->out, "QEMU_AUDIO_DAC_TRY_POLL",
    253                             "QEMU_OSS_DAC_DEV");
    254
    255    get_bool("QEMU_OSS_MMAP", &oopt->try_mmap, &oopt->has_try_mmap);
    256    get_bool("QEMU_OSS_EXCLUSIVE", &oopt->exclusive, &oopt->has_exclusive);
    257    get_int("QEMU_OSS_POLICY", &oopt->dsp_policy, &oopt->has_dsp_policy);
    258}
    259
    260/* pulseaudio */
    261static void handle_pa_per_direction(
    262    AudiodevPaPerDirectionOptions *ppdo, const char *env)
    263{
    264    get_str(env, &ppdo->name, &ppdo->has_name);
    265}
    266
    267static void handle_pa(Audiodev *dev)
    268{
    269    handle_pa_per_direction(dev->u.pa.in, "QEMU_PA_SOURCE");
    270    handle_pa_per_direction(dev->u.pa.out, "QEMU_PA_SINK");
    271
    272    get_samples_to_usecs(
    273        "QEMU_PA_SAMPLES", &dev->u.pa.in->buffer_length,
    274        &dev->u.pa.in->has_buffer_length,
    275        qapi_AudiodevPaPerDirectionOptions_base(dev->u.pa.in));
    276    get_samples_to_usecs(
    277        "QEMU_PA_SAMPLES", &dev->u.pa.out->buffer_length,
    278        &dev->u.pa.out->has_buffer_length,
    279        qapi_AudiodevPaPerDirectionOptions_base(dev->u.pa.out));
    280
    281    get_str("QEMU_PA_SERVER", &dev->u.pa.server, &dev->u.pa.has_server);
    282}
    283
    284/* SDL */
    285static void handle_sdl(Audiodev *dev)
    286{
    287    /* SDL is output only */
    288    get_samples_to_usecs("QEMU_SDL_SAMPLES", &dev->u.sdl.out->buffer_length,
    289        &dev->u.sdl.out->has_buffer_length,
    290        qapi_AudiodevSdlPerDirectionOptions_base(dev->u.sdl.out));
    291}
    292
    293/* wav */
    294static void handle_wav(Audiodev *dev)
    295{
    296    get_int("QEMU_WAV_FREQUENCY",
    297            &dev->u.wav.out->frequency, &dev->u.wav.out->has_frequency);
    298    get_fmt("QEMU_WAV_FORMAT", &dev->u.wav.out->format,
    299            &dev->u.wav.out->has_format);
    300    get_int("QEMU_WAV_DAC_FIXED_CHANNELS",
    301            &dev->u.wav.out->channels, &dev->u.wav.out->has_channels);
    302    get_str("QEMU_WAV_PATH", &dev->u.wav.path, &dev->u.wav.has_path);
    303}
    304
    305/* general */
    306static void handle_per_direction(
    307    AudiodevPerDirectionOptions *pdo, const char *prefix)
    308{
    309    char buf[64];
    310    size_t len = strlen(prefix);
    311
    312    memcpy(buf, prefix, len);
    313    strcpy(buf + len, "FIXED_SETTINGS");
    314    get_bool(buf, &pdo->fixed_settings, &pdo->has_fixed_settings);
    315
    316    strcpy(buf + len, "FIXED_FREQ");
    317    get_int(buf, &pdo->frequency, &pdo->has_frequency);
    318
    319    strcpy(buf + len, "FIXED_FMT");
    320    get_fmt(buf, &pdo->format, &pdo->has_format);
    321
    322    strcpy(buf + len, "FIXED_CHANNELS");
    323    get_int(buf, &pdo->channels, &pdo->has_channels);
    324
    325    strcpy(buf + len, "VOICES");
    326    get_int(buf, &pdo->voices, &pdo->has_voices);
    327}
    328
    329static AudiodevListEntry *legacy_opt(const char *drvname)
    330{
    331    AudiodevListEntry *e = g_malloc0(sizeof(AudiodevListEntry));
    332    e->dev = g_malloc0(sizeof(Audiodev));
    333    e->dev->id = g_strdup(drvname);
    334    e->dev->driver = qapi_enum_parse(
    335        &AudiodevDriver_lookup, drvname, -1, &error_abort);
    336
    337    audio_create_pdos(e->dev);
    338
    339    handle_per_direction(audio_get_pdo_in(e->dev), "QEMU_AUDIO_ADC_");
    340    handle_per_direction(audio_get_pdo_out(e->dev), "QEMU_AUDIO_DAC_");
    341
    342    /* Original description: Timer period in HZ (0 - use lowest possible) */
    343    get_int("QEMU_AUDIO_TIMER_PERIOD",
    344            &e->dev->timer_period, &e->dev->has_timer_period);
    345    if (e->dev->has_timer_period && e->dev->timer_period) {
    346        e->dev->timer_period = NANOSECONDS_PER_SECOND / 1000 /
    347                               e->dev->timer_period;
    348    }
    349
    350    switch (e->dev->driver) {
    351    case AUDIODEV_DRIVER_ALSA:
    352        handle_alsa(e->dev);
    353        break;
    354
    355    case AUDIODEV_DRIVER_COREAUDIO:
    356        handle_coreaudio(e->dev);
    357        break;
    358
    359    case AUDIODEV_DRIVER_DSOUND:
    360        handle_dsound(e->dev);
    361        break;
    362
    363    case AUDIODEV_DRIVER_OSS:
    364        handle_oss(e->dev);
    365        break;
    366
    367    case AUDIODEV_DRIVER_PA:
    368        handle_pa(e->dev);
    369        break;
    370
    371    case AUDIODEV_DRIVER_SDL:
    372        handle_sdl(e->dev);
    373        break;
    374
    375    case AUDIODEV_DRIVER_WAV:
    376        handle_wav(e->dev);
    377        break;
    378
    379    default:
    380        break;
    381    }
    382
    383    return e;
    384}
    385
    386AudiodevListHead audio_handle_legacy_opts(void)
    387{
    388    const char *drvname = getenv("QEMU_AUDIO_DRV");
    389    AudiodevListHead head = QSIMPLEQ_HEAD_INITIALIZER(head);
    390
    391    if (drvname) {
    392        AudiodevListEntry *e;
    393        audio_driver *driver = audio_driver_lookup(drvname);
    394        if (!driver) {
    395            dolog("Unknown audio driver `%s'\n", drvname);
    396            exit(1);
    397        }
    398        e = legacy_opt(drvname);
    399        QSIMPLEQ_INSERT_TAIL(&head, e, next);
    400    } else {
    401        for (int i = 0; audio_prio_list[i]; i++) {
    402            audio_driver *driver = audio_driver_lookup(audio_prio_list[i]);
    403            if (driver && driver->can_be_default) {
    404                AudiodevListEntry *e = legacy_opt(driver->name);
    405                QSIMPLEQ_INSERT_TAIL(&head, e, next);
    406            }
    407        }
    408        if (QSIMPLEQ_EMPTY(&head)) {
    409            dolog("Internal error: no default audio driver available\n");
    410            exit(1);
    411        }
    412    }
    413
    414    return head;
    415}
    416
    417/* visitor to print -audiodev option */
    418typedef struct {
    419    Visitor visitor;
    420
    421    bool comma;
    422    GList *path;
    423} LegacyPrintVisitor;
    424
    425static bool lv_start_struct(Visitor *v, const char *name, void **obj,
    426                            size_t size, Error **errp)
    427{
    428    LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;
    429    lv->path = g_list_append(lv->path, g_strdup(name));
    430    return true;
    431}
    432
    433static void lv_end_struct(Visitor *v, void **obj)
    434{
    435    LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;
    436    lv->path = g_list_delete_link(lv->path, g_list_last(lv->path));
    437}
    438
    439static void lv_print_key(Visitor *v, const char *name)
    440{
    441    GList *e;
    442    LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;
    443    if (lv->comma) {
    444        putchar(',');
    445    } else {
    446        lv->comma = true;
    447    }
    448
    449    for (e = lv->path; e; e = e->next) {
    450        if (e->data) {
    451            printf("%s.", (const char *) e->data);
    452        }
    453    }
    454
    455    printf("%s=", name);
    456}
    457
    458static bool lv_type_int64(Visitor *v, const char *name, int64_t *obj,
    459                          Error **errp)
    460{
    461    lv_print_key(v, name);
    462    printf("%" PRIi64, *obj);
    463    return true;
    464}
    465
    466static bool lv_type_uint64(Visitor *v, const char *name, uint64_t *obj,
    467                           Error **errp)
    468{
    469    lv_print_key(v, name);
    470    printf("%" PRIu64, *obj);
    471    return true;
    472}
    473
    474static bool lv_type_bool(Visitor *v, const char *name, bool *obj, Error **errp)
    475{
    476    lv_print_key(v, name);
    477    printf("%s", *obj ? "on" : "off");
    478    return true;
    479}
    480
    481static bool lv_type_str(Visitor *v, const char *name, char **obj, Error **errp)
    482{
    483    const char *str = *obj;
    484    lv_print_key(v, name);
    485
    486    while (*str) {
    487        if (*str == ',') {
    488            putchar(',');
    489        }
    490        putchar(*str++);
    491    }
    492    return true;
    493}
    494
    495static void lv_complete(Visitor *v, void *opaque)
    496{
    497    LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;
    498    assert(lv->path == NULL);
    499}
    500
    501static void lv_free(Visitor *v)
    502{
    503    LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;
    504
    505    g_list_free_full(lv->path, g_free);
    506    g_free(lv);
    507}
    508
    509static Visitor *legacy_visitor_new(void)
    510{
    511    LegacyPrintVisitor *lv = g_malloc0(sizeof(LegacyPrintVisitor));
    512
    513    lv->visitor.start_struct = lv_start_struct;
    514    lv->visitor.end_struct = lv_end_struct;
    515    /* lists not supported */
    516    lv->visitor.type_int64 = lv_type_int64;
    517    lv->visitor.type_uint64 = lv_type_uint64;
    518    lv->visitor.type_bool = lv_type_bool;
    519    lv->visitor.type_str = lv_type_str;
    520
    521    lv->visitor.type = VISITOR_OUTPUT;
    522    lv->visitor.complete = lv_complete;
    523    lv->visitor.free = lv_free;
    524
    525    return &lv->visitor;
    526}
    527
    528void audio_legacy_help(void)
    529{
    530    AudiodevListHead head;
    531    AudiodevListEntry *e;
    532
    533    printf("Environment variable based configuration deprecated.\n");
    534    printf("Please use the new -audiodev option.\n");
    535
    536    head = audio_handle_legacy_opts();
    537    printf("\nEquivalent -audiodev to your current environment variables:\n");
    538    if (!getenv("QEMU_AUDIO_DRV")) {
    539        printf("(Since you didn't specify QEMU_AUDIO_DRV, I'll list all "
    540               "possibilities)\n");
    541    }
    542
    543    QSIMPLEQ_FOREACH(e, &head, next) {
    544        Visitor *v;
    545        Audiodev *dev = e->dev;
    546        printf("-audiodev ");
    547
    548        v = legacy_visitor_new();
    549        visit_type_Audiodev(v, NULL, &dev, &error_abort);
    550        visit_free(v);
    551
    552        printf("\n");
    553    }
    554    audio_free_audiodev_list(&head);
    555}