Archipelago » qemu

    if (acl)

        return acl;

    /* Deny by default, so there is no window of "open

     * access" between QEMU starting, and the user setting

     * up ACLs in the monitor */

    acl->nentries = 0;

    QTAILQ_INIT(&acl->entries);

    acls[nacls] = acl;

    nacls++;

{

    qemu_acl_entry *entry;

    entry->deny = deny;

    QTAILQ_INSERT_TAIL(&acl->entries, entry, next);

        return qemu_acl_append(acl, deny, match);

    entry->deny = deny;

    QTAILQ_FOREACH(tmp, &acl->entries, next) {

                 * releasing the walking_handlers lock.

                 */

                QLIST_REMOVE(node, node);

            }

        }

    } else {

        if (node == NULL) {

            /* Alloc and insert if it's not already there */

            node->fd = fd;

            QLIST_INSERT_HEAD(&aio_handlers, node, node);

        }

                if (tmp->deleted) {

                    QLIST_REMOVE(tmp, node);

                }

            }

    QLIST_FOREACH(block, &ram_list.blocks, next) {

        ++n;

    }

    n = 0;

    QLIST_FOREACH_SAFE(block, &ram_list.blocks, next, nblock) {

        blocks[n++] = block;

    while (--n >= 0) {

        QLIST_INSERT_HEAD(&ram_list.blocks, blocks[n], next);

    }

}

int ram_save_live(Monitor *mon, QEMUFile *f, int stage, void *opaque)

QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)

{

    QEMUBH *bh;

    bh->cb = cb;

    bh->opaque = opaque;

    bh->next = first_bh;

        bh = *bhp;

        if (bh->deleted) {

            *bhp = bh->next;

        } else

            bhp = &bh->next;

    }

        for (i = 0; i < hlp->count; ++i) {

            qemu_set_fd_handler (pfds[i].fd, NULL, NULL, NULL);

        }

    }

    hlp->pfds = NULL;

    hlp->count = 0;

    if (err < 0) {

        alsa_logerr (err, "Could not initialize poll mode\n"

                     "Could not obtain poll descriptors\n");

        return -1;

    }

            while (i--) {

                qemu_set_fd_handler (pfds[i].fd, NULL, NULL, NULL);

            }

            return -1;

        }

    }

    alsa_anal_close (&alsa->handle, &alsa->pollhlp);

    if (alsa->pcm_buf) {

        alsa->pcm_buf = NULL;

    }

}

    alsa_anal_close (&alsa->handle, &alsa->pollhlp);

    if (alsa->pcm_buf) {

        alsa->pcm_buf = NULL;

    }

}

        return NULL;

    }

}

static char *audio_alloc_prefix (const char *s)

    }

    len = strlen (s);

    u = r + sizeof (qemu_prefix) - 1;

        printf ("    %s\n", opt->descr);

    }

}

static void audio_process_options (const char *prefix,

         * (includes trailing zero) + zero + underscore (on behalf of

         * sizeof) */

        optlen = len + preflen + sizeof (qemu_prefix) + 1;

        pstrcpy (optname, optlen, qemu_prefix);

            opt->overriddenp = &opt->overridden;

        }

        *opt->overriddenp = !def;

    }

}

        QLIST_REMOVE (sw, entries);

        QLIST_REMOVE (sc, entries);

        if (was_active) {

            /* We have removed soft voice from the capture:

               this might have changed the overall status of the capture

        sw->rate = st_rate_start (sw->info.freq, hw_cap->info.freq);

        if (!sw->rate) {

            dolog ("Could not start rate conversion for `%s'\n", SW_NAME (sw));

            return -1;

        }

        QLIST_INSERT_HEAD (&hw_cap->sw_head, sw, entries);

void AUD_register_card (const char *name, QEMUSoundCard *card)

{

    audio_init ();

    memset (&card->entries, 0, sizeof (card->entries));

    QLIST_INSERT_HEAD (&glob_audio_state.card_head, card, entries);

}

void AUD_remove_card (QEMUSoundCard *card)

{

    QLIST_REMOVE (card, entries);

}

        return cap;

    err3:

    err2:

    err1:

    err0:

        return NULL;

    }

        if (cb->opaque == cb_opaque) {

            cb->ops.destroy (cb_opaque);

            QLIST_REMOVE (cb, entries);

            if (!cap->cb_head.lh_first) {

                SWVoiceOut *sw = cap->hw.sw_head.lh_first, *sw1;

                    }

                    QLIST_REMOVE (sw, entries);

                    QLIST_REMOVE (sc, entries);

                    sw = sw1;

                }

                QLIST_REMOVE (cap, entries);

            }

            return;

        }

static void glue (audio_pcm_hw_free_resources_, TYPE) (HW *hw)

{

    if (HWBUF) {

    }

    HWBUF = NULL;

static void glue (audio_pcm_sw_free_resources_, TYPE) (SW *sw)

{

    if (sw->buf) {

    }

    if (sw->rate) {

    sw->rate = st_rate_start (sw->hw->info.freq, sw->info.freq);

#endif

    if (!sw->rate) {

        sw->buf = NULL;

        return -1;

    }

        [sw->info.swap_endianness]

        [audio_bits_to_index (sw->info.bits)];

    err = glue (audio_pcm_sw_alloc_resources_, TYPE) (sw);

    if (err) {

        sw->name = NULL;

    }

    return err;

{

    glue (audio_pcm_sw_free_resources_, TYPE) (sw);

    if (sw->name) {

        sw->name = NULL;

    }

}

        glue (s->nb_hw_voices_, TYPE) += 1;

        glue (audio_pcm_hw_free_resources_ ,TYPE) (hw);

        glue (hw->pcm_ops->fini_, TYPE) (hw);

        *hwp = NULL;

    }

}

 err1:

    glue (hw->pcm_ops->fini_, TYPE) (hw);

 err0:

    return NULL;

}

    glue (audio_pcm_hw_del_sw_, TYPE) (sw);

    glue (audio_pcm_hw_gc_, TYPE) (&hw);

err2:

err1:

    return NULL;

}

    glue (audio_pcm_sw_fini_, TYPE) (sw);

    glue (audio_pcm_hw_del_sw_, TYPE) (sw);

    glue (audio_pcm_hw_gc_, TYPE) (&sw->hw);

}

void glue (AUD_close_, TYPE) (QEMUSoundCard *card, SW *sw)

    esd->fd = -1;

 fail1:

    esd->pcm_buf = NULL;

    return -1;

}

    audio_pt_fini (&esd->pt, AUDIO_FUNC);

    esd->pcm_buf = NULL;

}

    esd->fd = -1;

 fail1:

    esd->pcm_buf = NULL;

    return -1;

}

    audio_pt_fini (&esd->pt, AUDIO_FUNC);

    esd->pcm_buf = NULL;

}

void st_rate_stop (void *opaque)

{

}

void mixeng_clear (struct st_sample *buf, int len)

            }

        }

        else {

        }

        oss->pcm_buf = NULL;

    }

    oss_anal_close (&oss->fd);

    if (oss->pcm_buf) {

        oss->pcm_buf = NULL;

    }

}

    return 0;

 fail3:

    pa->pcm_buf = NULL;

 fail2:

    pa_simple_free (pa->s);

    return 0;

 fail3:

    pa->pcm_buf = NULL;

 fail2:

    pa_simple_free (pa->s);

    }

    audio_pt_fini (&pa->pt, AUDIO_FUNC);

    pa->pcm_buf = NULL;

}

    }

    audio_pt_fini (&pa->pt, AUDIO_FUNC);

    pa->pcm_buf = NULL;

}

    if (!wav->f) {

        dolog ("Failed to open wave file `%s'\nReason: %s\n",

               conf.wav_path, strerror (errno));

        wav->pcm_buf = NULL;

        return -1;

    }

    qemu_fclose (wav->f);

    wav->f = NULL;

    wav->pcm_buf = NULL;

}

        qemu_fclose (wav->f);

    }

}

static void wav_capture (void *opaque, void *buf, int size)

    ops.capture = wav_capture;

    ops.destroy = wav_destroy;

    shift = bits16 + stereo;

    hdr[34] = bits16 ? 0x10 : 0x08;

    if (!wav->f) {

        monitor_printf(mon, "Failed to open wave file `%s'\nReason: %s\n",

                       path, strerror (errno));

        return -1;

    }

    wav->bits = bits;

    wav->nchannels = nchannels;

    wav->freq = freq;

    cap = AUD_add_capture (&as, &ops, wav);

    if (!cap) {

        monitor_printf(mon, "Failed to add audio capture\n");

        qemu_fclose (wav->f);

        return -1;

    }

    return 0;

 err4:

 err3:

 err2:

    winwave_anal_close_out (wave);

 err1:

        wave->event = NULL;

    }

    wave->pcm_buf = NULL;

    wave->hdrs = NULL;

}

    return 0;

 err4:

 err3:

 err2:

    winwave_anal_close_in (wave);

 err1:

        wave->event = NULL;

    }

    wave->pcm_buf = NULL;

    wave->hdrs = NULL;

}

static inline unsigned long *bitmap_new(int nbits)

{

    int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);

}

static inline void bitmap_zero(unsigned long *dst, int nbits)

            BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1;

    bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8;

}

static void blk_mig_read_cb(void *opaque, int ret)

        nr_sectors = total_sectors - cur_sector;

    }

    blk->bmds = bmds;

    blk->sector = cur_sector;

    blk->nr_sectors = nr_sectors;

error:

    monitor_printf(mon, "Error reading sector %" PRId64 "\n", cur_sector);

    qemu_file_set_error(f);

    return 0;

}

            return;

        }

        bmds->bs = bs;

        bmds->bulk_completed = 0;

        bmds->total_sectors = sectors;

            } else {

                nr_sectors = BDRV_SECTORS_PER_DIRTY_CHUNK;

            }

            blk->bmds = bmds;

            blk->sector = sector;

            blk->nr_sectors = nr_sectors;

                }

                blk_send(f, blk);

            }

            bdrv_reset_dirty(bmds->bs, sector, nr_sectors);

error:

    monitor_printf(mon, "Error reading sector %" PRId64 "\n", sector);

    qemu_file_set_error(f);

    return 0;

}

        blk_send(f, blk);

        QSIMPLEQ_REMOVE_HEAD(&block_mig_state.blk_list, entry);

        block_mig_state.read_done--;

        block_mig_state.transferred++;

        QSIMPLEQ_REMOVE_HEAD(&block_mig_state.bmds_list, entry);

        bdrv_set_in_use(bmds->bs, 0);

        drive_put_ref(drive_get_by_blockdev(bmds->bs));

    }

    while ((blk = QSIMPLEQ_FIRST(&block_mig_state.blk_list)) != NULL) {

        QSIMPLEQ_REMOVE_HEAD(&block_mig_state.blk_list, entry);

    }

    monitor_printf(mon, "\n");

                nr_sectors = BDRV_SECTORS_PER_DIRTY_CHUNK;

            }

            qemu_get_buffer(f, buf, BLOCK_SIZE);

            ret = bdrv_write(bs, addr, buf, nr_sectors);

            if (ret < 0) {

                return ret;

            }

{

    BlockDriverState *bs;

    pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);

    if (device_name[0] != '\0') {

        QTAILQ_INSERT_TAIL(&bdrv_states, bs, list);

    }

    bs->drv = drv;

    if (flags & BDRV_O_CACHE_WB)

        bs->enable_write_cache = 1;

        bdrv_delete(bs->file);

        bs->file = NULL;

    }

    bs->opaque = NULL;

    bs->drv = NULL;

    return ret;

            bs->backing_hd = NULL;

        }

        bs->drv->bdrv_close(bs);

#ifdef _WIN32

        if (bs->is_temporary) {

            unlink(bs->filename);

    }

    assert(bs != bs_snapshots);

}

int bdrv_attach(BlockDriverState *bs, DeviceState *qdev)

    }

    total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;

    for (sector = 0; sector < total_sectors; sector += n) {

        if (drv->bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n)) {

        bdrv_flush(bs->backing_hd);

ro_cleanup:

    if (ro) {

        /* re-open as RO */

        set_dirty_bitmap(b->bs, b->sector_num, b->nb_sectors, 1);

    }

    b->cb(b->opaque, ret);

}

static BlockCompleteData *blk_dirty_cb_alloc(BlockDriverState *bs,

                                             BlockDriverCompletionFunc *cb,

                                             void *opaque)

{

    blkdata->bs = bs;

    blkdata->cb = cb;

        if (mcb->callbacks[i].free_qiov) {

            qemu_iovec_destroy(mcb->callbacks[i].free_qiov);

        }

        qemu_vfree(mcb->callbacks[i].free_buf);

    }

}

    mcb->num_requests--;

    if (mcb->num_requests == 0) {

        multiwrite_user_cb(mcb);

    }

}

        if (merge) {

            size_t size;

            qemu_iovec_init(qiov,

                reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);

    }

    // Create MultiwriteCB structure

    mcb->num_requests = 0;

    mcb->num_callbacks = num_reqs;

    for (i = 0; i < mcb->num_callbacks; i++) {

        reqs[i].error = -EIO;

    }

    return -1;

}

        acb = pool->free_aiocb;

        pool->free_aiocb = acb->next;

    } else {

        acb->pool = pool;

    }

    acb->bs = bs;

                    BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1;

            bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8;

        }

    } else {

        if (bs->dirty_bitmap) {

            bs->dirty_bitmap = NULL;

        }

    }

    }

    /* Set attributes common for all actions */

    *rule = (struct BlkdebugRule) {

        .event  = event,

        .action = d->action,

    for (i = 0; i < BLKDBG_EVENT_MAX; i++) {

        QLIST_FOREACH_SAFE(rule, &s->rules[i], next, next) {

            QLIST_REMOVE(rule, next);

        }

    }

}

    }

    s->catalog_size = le32_to_cpu(bochs.extra.redolog.catalog);

    if (bdrv_pread(bs->file, le32_to_cpu(bochs.header), s->catalog_bitmap,

                   s->catalog_size * 4) != s->catalog_size * 4)

	goto fail;

static void bochs_close(BlockDriverState *bs)

{

    BDRVBochsState *s = bs->opaque;

}

static BlockDriver bdrv_bochs = {

    /* read offsets */

    offsets_size = s->n_blocks * sizeof(uint64_t);

    if (bdrv_pread(bs->file, 128 + 4 + 4, s->offsets, offsets_size) <

            offsets_size) {

	goto cloop_close;

    }

    /* initialize zlib engine */

    if(inflateInit(&s->zstream) != Z_OK)

	goto cloop_close;

    s->current_block=s->n_blocks;

    static int inited = 0;

    s->readahead_size = READ_AHEAD_SIZE;

    /* Parse a trailing ":readahead=#:" param, if present. */

    curl_easy_cleanup(state->curl);

    state->curl = NULL;

out_noclean:

    return -EINVAL;

}

    state->buf_off = 0;

    if (state->orig_buf)

    state->buf_start = start;

    state->buf_len = acb->end + s->readahead_size;

    end = MIN(start + state->buf_len, s->len) - 1;

    state->acb[0] = acb;

    snprintf(state->range, 127, "%zd-%zd", start, end);

            s->states[i].curl = NULL;

        }

        if (s->states[i].orig_buf) {

            s->states[i].orig_buf = NULL;

        }

    }

	    chunk_count = (count-204)/40;

	    new_size = sizeof(uint64_t) * (s->n_chunks + chunk_count);

	    for(i=s->n_chunks;i<s->n_chunks+chunk_count;i++) {

		s->types[i] = read_uint32(bs, offset);

    }

    /* initialize zlib engine */

    if(inflateInit(&s->zstream) != Z_OK)

	goto fail;

    const char *unixpath;

    int err = -EINVAL;

    export_name = strstr(file, EN_OPTSTR);

    if (export_name) {

        }

        export_name[0] = 0; /* truncate 'file' */

        export_name += strlen(EN_OPTSTR);

    }

    /* extract the host_spec - fail if it's not nbd:... */

        if (unixpath[0] != '/') { /* We demand  an absolute path*/

            goto out;

        }

    } else {

    }

    err = 0;

out:

    if (err != 0) {

    }

    return err;

}

static void nbd_close(BlockDriverState *bs)

{

    BDRVNBDState *s = bs->opaque;

    nbd_teardown_connection(bs);

}

    s->tracks = le32_to_cpu(ph.tracks);

    s->catalog_size = le32_to_cpu(ph.catalog_entries);

    if (bdrv_pread(bs->file, 64, s->catalog_bitmap, s->catalog_size * 4) !=

	s->catalog_size * 4)

	goto fail;

    return 0;

fail:

    if (s->catalog_bitmap)

    return -1;

}

static void parallels_close(BlockDriverState *bs)

{

    BDRVParallelsState *s = bs->opaque;

}

static BlockDriver bdrv_parallels = {

    s->l1_size = (header.size + (1LL << shift) - 1) >> shift;

    s->l1_table_offset = header.l1_table_offset;

    if (!s->l1_table)

        goto fail;

    if (bdrv_pread(bs->file, s->l1_table_offset, s->l1_table, s->l1_size * sizeof(uint64_t)) !=

        be64_to_cpus(&s->l1_table[i]);

    }

    /* alloc L2 cache */

    if (!s->l2_cache)

        goto fail;

    if (!s->cluster_cache)

        goto fail;

    if (!s->cluster_data)

        goto fail;

    s->cluster_cache_offset = -1;

    return 0;

 fail:

    return -1;

}

    }

    if (s->crypt_method) {

        if (!acb->cluster_data) {

        }

        encrypt_sectors(s, acb->sector_num, acb->cluster_data, acb->buf,

                        acb->n, 1, &s->aes_encrypt_key);

static void qcow_close(BlockDriverState *bs)

{

    BDRVQcowState *s = bs->opaque;

}

static int qcow_create(const char *filename, QEMUOptionParameter *options)

    if (nb_sectors != s->cluster_sectors)

        return -EINVAL;

    if (!out_buf)

        return -1;

                       Z_DEFLATED, -12,

                       9, Z_DEFAULT_STRATEGY);

    if (ret != 0) {

        return -1;

    }

    ret = deflate(&strm, Z_FINISH);

    if (ret != Z_STREAM_END && ret != Z_OK) {

        deflateEnd(&strm);

        return -1;

    }

                                            out_len, 0, 0);

        cluster_offset &= s->cluster_offset_mask;

        if (bdrv_pwrite(bs->file, cluster_offset, out_buf, out_len) != out_len) {

            return -1;

        }

    }

    return 0;

}

    Qcow2Cache *c;

    int i;

    c->size = num_tables;

    c->writethrough = writethrough;

    for (i = 0; i < c->size; i++) {

        qemu_vfree(c->entries[i].table);

    }

    return 0;

}

#endif

    new_l1_size2 = sizeof(uint64_t) * new_l1_size;

    memcpy(new_l1_table, s->l1_table, s->l1_size * sizeof(uint64_t));

    /* write new table (align to cluster) */

    BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_ALLOC_TABLE);

    new_l1_table_offset = qcow2_alloc_clusters(bs, new_l1_size2);

    if (new_l1_table_offset < 0) {

        return new_l1_table_offset;

    }

    if (ret < 0) {

        goto fail;

    }

    qcow2_free_clusters(bs, s->l1_table_offset, s->l1_size * sizeof(uint64_t));

    s->l1_table_offset = new_l1_table_offset;

    s->l1_table = new_l1_table;

    s->l1_size = new_l1_size;

    return 0;

 fail:

    qcow2_free_clusters(bs, new_l1_table_offset, new_l1_size2);

    return ret;

}

    if (m->nb_clusters == 0)

        return 0;

    /* copy content of unmodified sectors */

    start_sect = (m->offset & ~(s->cluster_size - 1)) >> 9;

    ret = 0;

err:

    return ret;

 }

    int ret, refcount_table_size2, i;

    refcount_table_size2 = s->refcount_table_size * sizeof(uint64_t);

    if (s->refcount_table_size > 0) {

        BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_LOAD);

        ret = bdrv_pread(bs->file, s->refcount_table_offset,

void qcow2_refcount_close(BlockDriverState *bs)

{

    BDRVQcowState *s = bs->opaque;

}

    uint64_t meta_offset = (blocks_used * refcount_block_clusters) *

        s->cluster_size;

    uint64_t table_offset = meta_offset + blocks_clusters * s->cluster_size;

    assert(meta_offset >= (s->free_cluster_index * s->cluster_size));

    BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS);

    ret = bdrv_pwrite_sync(bs->file, meta_offset, new_blocks,

        blocks_clusters * s->cluster_size);

    if (ret < 0) {

        goto fail_table;

    }

    uint64_t old_table_offset = s->refcount_table_offset;

    uint64_t old_table_size = s->refcount_table_size;

    s->refcount_table = new_table;

    s->refcount_table_size = table_size;

    s->refcount_table_offset = table_offset;

    return new_block;

fail_table:

fail_block:

    if (*refcount_block != NULL) {

        qcow2_cache_put(bs, s->refcount_block_cache, (void**) refcount_block);

    l1_size2 = l1_size * sizeof(uint64_t);

    if (l1_table_offset != s->l1_table_offset) {

        if (l1_size2 != 0) {

        } else {

            l1_table = NULL;

        }

            be64_to_cpus(&l1_table[i]);

    }

    if (l1_allocated)

    return ret;

}

    /* Read L2 table from disk */

    l2_size = s->l2_size * sizeof(uint64_t);

    if (bdrv_pread(bs->file, l2_offset, l2_table, l2_size) != l2_size)

        goto fail;

        }

    }

    return 0;

fail:

    fprintf(stderr, "ERROR: I/O error in check_refcounts_l2\n");

    return -EIO;

}

    if (l1_size2 == 0) {

        l1_table = NULL;

    } else {

        if (bdrv_pread(bs->file, l1_table_offset,

                       l1_table, l1_size2) != l1_size2)

            goto fail;

            }

        }

    }

    return 0;

fail:

    fprintf(stderr, "ERROR: I/O error in check_refcounts_l1\n");

    res->check_errors++;

    return -EIO;

}

    size = bdrv_getlength(bs->file);

    nb_clusters = size_to_clusters(s, size);

    /* header */

    inc_refcounts(bs, res, refcount_table, nb_clusters,

    ret = 0;

fail:

    return ret;

}

    int i;

    for(i = 0; i < s->nb_snapshots; i++) {