Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
qemu | include/qapi/visitor-impl.h | void visit_type_uint64(Visitor *v, uint64_t *obj, const char *name,
Error **errp)
{
int64_t value;
if (v->type_uint64) {
v->type_uint64(v, obj, name, errp);
} else {
value = *obj;
v->type_int64(v, &value, name, errp);
*obj = value;
}
} | [
0,
0
] |
qemu | hw/tpm/tpm_int.h | static int tpm_passthrough_unix_tx_bufs(TPMPassthruState *tpm_pt,
const uint8_t *in, uint32_t in_len,
uint8_t *out, uint32_t out_len)
{
int ret;
tpm_pt->tpm_op_canceled = false;
tpm_pt->tpm_executing = true;
ret = tpm_passthr... | [
1,
0
] |
qemu | monitor.c | static int get_str(char *buf, int buf_size, const char **pp)
{
const char *p;
char *q;
int c;
q = buf;
p = *pp;
while (qemu_isspace(*p))
p++;
if (*p == '\0') {
fail:
*q = '\0';
*pp = p;
return -1;
}
if (*p == '\"') {
p++;
while (*p != '\0' && *p != '\"') {
... | [
1,
0
] |
qemu | hw/hpet.c | static void hpet_reset(void *opaque) {
HPETState *s = opaque;
int i;
static int count = 0;
for (i = 0; i < HPET_NUM_TIMERS; i++) {
HPETTimer *timer = &s->timer[i];
hpet_del_timer(timer);
timer->tn = i;
timer->cmp = ~0ULL;
timer->config = HPET_TN_PERIODIC_CAP | HPET_TN_SIZE_CAP;
... | [
1,
0
] |
FFmpeg | libavcodec/mpeg12enc.c | static inline void encode_dc(MpegEncContext *s, int diff, int component)
{
if (((unsigned)(diff + 255)) >= 511) {
int index;
if (diff < 0) {
index = av_log2_16bit(-2 * diff);
diff--;
} else {
index = av_log2_16bit(2 * diff);
}
if (component == 0)
put_bits(&s->pb,
... | [
1,
0
] |
qemu | qga/channel-posix.c | static void qmp_command_info(QmpCommand *cmd, void *opaque)
{
GuestAgentInfo *info = opaque;
GuestAgentCommandInfo *cmd_info;
GuestAgentCommandInfoList *cmd_info_list;
cmd_info = g_malloc0(sizeof(GuestAgentCommandInfo));
cmd_info->name = g_strdup(qmp_command_name(cmd));
cmd_info->enabled = qmp_comman... | [
1,
0
] |
FFmpeg | libavcodec/adx.c | static void adx_decode(short *out, const unsigned char *in, PREV *prev)
{
int scale = ((in[0] << 8) | (in[1]));
int i;
int s0, s1, s2, d;
// printf("%x ",scale);
in += 2;
s1 = prev->s1;
s2 = prev->s2;
for (i = 0; i < 16; i++) {
d = in[i];
// d>>=4; if (d&8) d-=16;
d = ((signed ch... | [
1,
0
] |
qemu | linux-user/main.c | static void gen_tlbie(DisasContext *ctx)
{
#if defined(CONFIG_USER_ONLY)
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
#else
if (unlikely(ctx->pr || !ctx->hv)) {
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
return;
}
if (NARROW_MODE(ctx)) {
TCGv t0 = tcg_temp_new();
tcg_gen_ext3... | [
1,
0
] |
qemu | tcg/tcg.c | int dyngen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf,
const uint8_t *searched_pc)
{
return tcg_gen_code_common(s, gen_code_buf, 1, searched_pc);
} | [
1,
0
] |
FFmpeg | libavcodec/diracdec.c | static void decode_subband(DiracContext *s, GetBitContext *gb, int quant,
int slice_x, int slice_y, int bits_end,
SubBand *b1, SubBand *b2)
{
int left = b1->width * slice_x / s->num_x;
int right = b1->width * (slice_x + 1) / s->num_x;
int top = b1->heigh... | [
1,
0
] |
qemu | hw/acpi/piix4.c | static void spapr_vio_bridge_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
k->init = spapr_vio_bridge_init;
dc->no_user = 1;
} | [
1,
0
] |
qemu | ui/vnc-auth-sasl.c | void vnc_sasl_client_cleanup(VncState *vs)
{
if (vs->sasl.conn) {
vs->sasl.runSSF = vs->sasl.waitWriteSSF = vs->sasl.wantSSF = 0;
vs->sasl.encodedLength = vs->sasl.encodedOffset = 0;
vs->sasl.encoded = NULL;
g_free(vs->sasl.username);
free(vs->sasl.mechlist);
vs->sasl.username = vs->sa... | [
1,
0
] |
FFmpeg | libavformat/matroskadec.c | static int webm_dash_manifest_read_header(AVFormatContext *s)
{
char *buf;
int ret = matroska_read_header(s);
MatroskaTrack *tracks;
MatroskaDemuxContext *matroska = s->priv_data;
if (ret) {
av_log(s, AV_LOG_ERROR, "Failed to read file headers\n");
return -1;
if (!matroska->is_live) {
... | [
1,
0
] |
FFmpeg | libavformat/mp3enc.c | static int mp3_write_audio_packet(AVFormatContext *s, AVPacket *pkt)
{
MP3Context *mp3 = s->priv_data;
if (pkt->data && pkt->size >= 4) {
MPADecodeHeader c;
int av_unused base;
avpriv_mpegaudio_decode_header(&c, AV_RB32(pkt->data));
if (!mp3->initial_bitrate)
mp3->initial_bitrate = c.b... | [
1,
0
] |
qemu | target-s390x/kvm.c | static int handle_instruction(CPUState *env, struct kvm_run *run)
{
unsigned int ipa0 = (run->s390_sieic.ipa & 0xff00);
uint8_t ipa1 = run->s390_sieic.ipa & 0x00ff;
int ipb_code = (run->s390_sieic.ipb & 0x0fff0000) >> 16;
int r = -1;
dprintf("handle_instruction 0x%x 0x%x\n", run->s390_sieic.ipa,
... | [
1,
0
] |
qemu | configure | ssize_t vnc_client_read_buf(VncState *vs, uint8_t *data, size_t datalen)
{
ssize_t ret;
#ifdef CONFIG_VNC_TLS
if (vs->tls.session) {
ret = vnc_client_read_tls(&vs->tls.session, data, datalen);
} else {
#endif /* CONFIG_VNC_TLS */
ret = qemu_recv(vs->csock, data, datalen, 0);
#ifdef CONFIG_VNC_TLS... | [
1,
0
] |
qemu | hw/lance.c | void lance_init(NICInfo *nd, int irq, uint32_t leaddr, uint32_t ledaddr)
{
LANCEState *s;
int lance_io_memory, ledma_io_memory;
s = qemu_mallocz(sizeof(LANCEState));
if (!s)
return;
s->irq = irq;
lance_io_memory =
cpu_register_io_memory(0, lance_mem_read, lance_mem_write, s);
cpu_regist... | [
1,
0
] |
FFmpeg | libavcodec/aacdec.c | static int decode_pulses(Pulse *pulse, GetBitContext *gb,
const uint16_t *swb_offset, int num_swb)
{
int i, pulse_swb;
pulse->num_pulse = get_bits(gb, 2) + 1;
pulse_swb = get_bits(gb, 6);
if (pulse_swb >= num_swb)
return -1;
pulse->pos[0] = swb_offset[pulse_swb];
pulse-... | [
0,
0
] |
FFmpeg | libavformat/utils.c | void avformat_close_input(AVFormatContext **ps)
{
AVFormatContext *s = *ps;
AVIOContext *pb =
(s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO)
?
NULL
: s->pb;
flush_packet_queue(s);
if (s->iformat->read_close)
s->iformat->read_close(s);
av... | [
1,
0
] |
qemu | monitor.c | static void do_change_block(const char *device, const char *filename)
{
BlockDriverState *bs;
bs = bdrv_find(device);
if (!bs) {
term_printf("device not found\n");
return;
}
if (eject_device(bs, 0) < 0)
return;
bdrv_open(bs, filename, 0);
qemu_key_check(bs, filename);
} | [
1,
0
] |
FFmpeg | libavresample/audio_mix.c | int avresample_set_matrix(AVAudioResampleContext *avr, const double *matrix,
int stride)
{
int in_channels, out_channels, i, o;
in_channels = av_get_channel_layout_nb_channels(avr->in_channel_layout);
out_channels = av_get_channel_layout_nb_channels(avr->out_channel_layout);
if (... | [
1,
1
] |
qemu | docs/qapi-code-gen.txt | void visit_start_implicit_struct(Visitor *v, void **obj, size_t size,
Error **errp)
{
if (!error_is_set(errp) && v->start_implicit_struct) {
v->start_implicit_struct(v, obj, size, errp);
}
} | [
1,
0
] |
FFmpeg | libavcodec/dsputil.c | static int pix_norm1_c(uint8_t *pix, int line_size)
{
int s, i, j;
uint32_t *sq = ff_squareTbl + 256;
s = 0;
for (i = 0; i < 16; i++) {
for (j = 0; j < 16; j += 8) {
#if 0
s += sq[pix[0]];
s += sq[pix[1]];
s += sq[pix[2]];
s += sq[pix[3]];
... | [
0,
0
] |
qemu | hw/file-op-9p.h | static int local_mknod(FsContext *fs_ctx, const char *path, FsCred *credp)
{
int err = -1;
int serrno = 0;
/* Determine the security model */
if (fs_ctx->fs_sm == SM_MAPPED) {
err = mknod(rpath(fs_ctx, path), SM_LOCAL_MODE_BITS | S_IFREG, 0);
if (err == -1) {
return err;
}
local_s... | [
1,
0
] |
qemu | target-arm/cpu.h | static void pmsav5_data_ap_write(CPUARMState *env, const ARMCPRegInfo *ri,
uint64_t value)
{
env->cp15.c5_data = extended_mpu_ap_bits(value);
} | [
1,
0
] |
qemu | hw/ssi/xilinx_spips.c | static void xilinx_spips_realize(DeviceState *dev, Error **errp)
{
XilinxSPIPS *s = XILINX_SPIPS(dev);
SysBusDevice *sbd = SYS_BUS_DEVICE(dev);
XilinxSPIPSClass *xsc = XILINX_SPIPS_GET_CLASS(s);
int i;
DB_PRINT_L(0, "realized spips\n");
s->spi = g_new(SSIBus *, s->num_busses);
for (i = 0; i < s->n... | [
1,
0
] |
qemu | hw/ppc/spapr.c | static void spapr_machine_device_unplug(HotplugHandler *hotplug_dev,
DeviceState *dev, Error **errp)
{
sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine());
if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) {
error_setg(errp, "Memory hot unplug not ... | [
1,
0
] |
qemu | target-arm/translate.c | static void gen_exception(int excp)
{
TCGv tmp = new_tmp();
tcg_gen_movi_i32(tmp, excp);
gen_helper_exception(tmp);
dead_tmp(tmp);
} | [
1,
0
] |
qemu | hw/arm/allwinner-a10.c | static void mb_cpu_class_init(ObjectClass *oc, void *data) {
DeviceClass *dc = DEVICE_CLASS(oc);
CPUClass *cc = CPU_CLASS(oc);
MicroBlazeCPUClass *mcc = MICROBLAZE_CPU_CLASS(oc);
mcc->parent_realize = dc->realize;
dc->realize = mb_cpu_realizefn;
mcc->parent_reset = cc->reset;
cc->reset = mb_cpu_reset;
c... | [
1,
0
] |
FFmpeg | libavformat/aviobuf.c | static void fill_buffer(AVIOContext *s)
{
int max_buffer_size = s->max_packet_size ?
s->max_packet_size
: IO_BUFFER_SIZE;
uint8_t *dst = s->buf_end - s->buffer + max_buffer_size < s->buffer_size
?
... | [
1,
0
] |
FFmpeg | libavutil/opt.c | static int get_number(void *obj, const char *name, const AVOption **o_out,
double *num, int *den, int64_t *intnum)
{
const AVOption *o = av_opt_find(obj, name, NULL, 0, 0);
void *dst;
if (!o || o->offset <= 0)
goto error;
dst = ((uint8_t *)obj) + o->offset;
if (o_out)
*o_o... | [
1,
0
] |
qemu | qapi/qmp-input-visitor.c | bool qdict_get_try_bool(const QDict *qdict, const char *key, bool def_value)
{
QObject *obj;
obj = qdict_get(qdict, key);
if (!obj || qobject_type(obj) != QTYPE_QBOOL)
return def_value;
return qbool_get_bool(qobject_to_qbool(obj));
} | [
1,
0
] |
qemu | hw/display/vmware_vga.c | static void vmsvga_init(struct vmsvga_state_s *s,
MemoryRegion *address_space, MemoryRegion *io)
{
DisplaySurface *surface;
s->scratch_size = SVGA_SCRATCH_SIZE;
s->scratch = g_malloc(s->scratch_size * 4);
s->vga.con = graphic_console_init(vmsvga_update_display,
... | [
1,
0
] |
qemu | hw/file-op-9p.h | static ssize_t local_readlink(FsContext *fs_ctx, const char *path,
char *buf, size_t bufsz)
{
ssize_t tsize = -1;
if (fs_ctx->fs_sm == SM_MAPPED) {
int fd;
fd = open(rpath(fs_ctx, path), O_RDONLY);
if (fd == -1) {
return -1;
}
do {
tsize = read... | [
1,
0
] |
qemu | dump.c | static int dump_cleanup(DumpState *s)
{
int ret = 0;
guest_phys_blocks_free(&s->guest_phys_blocks);
memory_mapping_list_free(&s->list);
if (s->fd != -1) {
close(s->fd);
}
if (s->resume) {
vm_start();
}
return ret;
} | [
1,
0
] |
FFmpeg | libavformat/mxfenc.c | static void mxf_write_preface(AVFormatContext *s)
{
MXFContext *mxf = s->priv_data;
AVIOContext *pb = s->pb;
mxf_write_metadata_key(pb, 0x012f00);
PRINT_KEY(s, "preface key", pb->buf_ptr - 16);
klv_encode_ber_length(pb, 130 + 16 * mxf->essence_container_count);
// write preface set uid
mxf_write_l... | [
1,
0
] |
FFmpeg | libavcodec/adx.c | static int adx_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
const uint8_t *buf0, int buf_size)
{
ADXContext *c = avctx->priv_data;
short *samples = data;
const uint8_t *buf = buf0;
int rest = buf_size;
if (!c->header_parsed) {
... | [
1,
0
] |
qemu | hw/net/vmware_utils.h | static void vmxnet3_process_tx_queue(VMXNET3State *s, int qidx)
{
struct Vmxnet3_TxDesc txd;
uint32_t txd_idx;
uint32_t data_len;
hwaddr data_pa;
for (;;) {
if (!vmxnet3_pop_next_tx_descr(s, qidx, &txd, &txd_idx)) {
break;
}
vmxnet3_dump_tx_descr(&txd);
if (!s->skip_current_tx_... | [
1,
0
] |
FFmpeg | libavcodec/avcodec.h | static int ljpeg_encode_yuv(AVCodecContext *avctx, PutBitContext *pb,
const AVFrame *frame)
{
const int predictor = avctx->prediction_method + 1;
LJpegEncContext *s = avctx->priv_data;
const int mb_width = (avctx->width + s->hsample[0] - 1) / s->hsample[0];
const int mb_height ... | [
1,
0
] |
qemu | block/vvfat.c | static void checkpoint(void) {
assert(((mapping_t *)array_get(&(vvv->mapping), 0))->end == 2);
check1(vvv);
check2(vvv);
assert(!vvv->current_mapping || vvv->current_fd ||
(vvv->current_mapping->mode & MODE_DIRECTORY));
#if 0
if (((direntry_t*)vvv->directory.pointer)[1].attributes != 0xf)
f... | [
1,
0
] |
FFmpeg | libavformat/rtpenc_h264.c | static const uint8_t *avc_mp4_find_startcode(const uint8_t *start,
const uint8_t *end,
int nal_length_size)
{
int res = 0;
if (end - start < nal_length_size)
return NULL;
while (nal_length_size--)
res = (res <<... | [
1,
0
] |
qemu | hw/s390x/virtio-ccw.c | static void virtio_ccw_notify(DeviceState *d, uint16_t vector)
{
VirtioCcwDevice *dev = to_virtio_ccw_dev_fast(d);
SubchDev *sch = dev->sch;
uint64_t indicators;
if (vector >= 128) {
return;
}
if (vector < VIRTIO_CCW_QUEUE_MAX) {
if (!dev->indicators) {
return;
}
if (sch->thi... | [
1,
0
] |
qemu | hw/pci/pci.c | static int pci_unregister_device(DeviceState *dev)
{
PCIDevice *pci_dev = PCI_DEVICE(dev);
PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(pci_dev);
pci_unregister_io_regions(pci_dev);
pci_del_option_rom(pci_dev);
if (pc->exit) {
pc->exit(pci_dev);
}
do_pci_unregister_device(pci_dev);
return 0;
} | [
1,
0
] |
FFmpeg | libavresample/utils.c | static inline int available_samples(AVFrame *out)
{
int bytes_per_sample = av_get_bytes_per_sample(out->format);
int samples = out->linesize[0] / bytes_per_sample;
if (av_sample_fmt_is_planar(out->format)) {
return samples;
} else {
int channels = av_get_channel_layout_nb_channels(out->channel_la... | [
1,
0
] |
qemu | hw/ppc/spapr_rtas.c | static void rtas_start_cpu(PowerPCCPU *cpu_, sPAPRMachineState *spapr,
uint32_t token, uint32_t nargs, target_ulong args,
uint32_t nret, target_ulong rets) {
target_ulong id, start, r3;
PowerPCCPU *cpu;
if (nargs != 3 || nret != 1) {
rtas_st(rets, 0, RTAS_... | [
1,
0
] |
qemu | hw/usb/hcd-uhci.c | static void uhci_async_cancel_all(UHCIState *s)
{
UHCIQueue *queue, *nq;
QTAILQ_FOREACH_SAFE(queue, &s->queues, next, nq) { uhci_queue_free(queue); }
} | [
1,
0
] |
qemu | arch_init.c | static int save_xbzrle_page(QEMUFile *f, uint8_t *current_data,
ram_addr_t current_addr, RAMBlock *block,
ram_addr_t offset, int cont, bool last_stage)
{
int encoded_len = 0, bytes_sent = -1;
uint8_t *prev_cached_page;
if (!cache_is_cached(XBZRLE.cache... | [
1,
0
] |
qemu | linux-user/main.c | static void gen_mtmsr(DisasContext *ctx)
{
#if defined(CONFIG_USER_ONLY)
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
#else
if (unlikely(ctx->pr)) {
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
return;
}
if (ctx->opcode & 0x00010000) {
/* Special form that does not need any synchron... | [
1,
1
] |
FFmpeg | libavcodec/opt.c | static const AVOption *av_set_number(void *obj, const char *name, double num,
int den, int64_t intnum) {
const AVOption *o = av_find_opt(obj, name, NULL, 0, 0);
void *dst;
if (!o || o->offset <= 0)
return NULL;
if (o->max * den < num * intnum || o->min * den > num *... | [
1,
0
] |
qemu | hw/ide/core.c | void ide_flush_cache(IDEState *s)
{
if (s->bs == NULL) {
ide_flush_cb(s, 0);
return;
}
bdrv_acct_start(s->bs, &s->acct, 0, BDRV_ACCT_FLUSH);
bdrv_aio_flush(s->bs, ide_flush_cb, s);
} | [
1,
0
] |
qemu | Makefile.objs | static void blk_mig_read_cb(void *opaque, int ret)
{
BlkMigBlock *blk = opaque;
blk_mig_lock();
blk->ret = ret;
QSIMPLEQ_INSERT_TAIL(&block_mig_state.blk_list, blk, entry);
bmds_set_aio_inflight(blk->bmds, blk->sector, blk->nr_sectors, 0);
block_mig_state.submitted--;
block_mig_state.read_done++;
... | [
1,
0
] |
FFmpeg | libavcodec/magicyuv.c | static int huff_build10(VLC *vlc, uint8_t *len)
{
HuffEntry he[1024];
uint32_t codes[1024];
uint8_t bits[1024];
uint16_t syms[1024];
uint32_t code;
int i;
for (i = 0; i < 1024; i++) {
he[i].sym = 1023 - i;
he[i].len = len[i];
}
AV_QSORT(he, 1024, HuffEntry, huff_cmp_len10);
code ... | [
1,
0
] |
qemu | cpu-exec.c | static void tcg_handle_interrupt(CPUArchState *env, int mask)
{
CPUState *cpu = ENV_GET_CPU(env);
int old_mask;
old_mask = env->interrupt_request;
env->interrupt_request |= mask;
/*
* If called from iothread context, wake the target cpu in
* case its halted.
*/
if (!qemu_cpu_is_self(cpu))... | [
1,
0
] |
FFmpeg | libavcodec/mmvideo.c | static int mm_decode_inter(MmContext *s, int half_horiz, int half_vert)
{
int data_off = bytestream2_get_le16(&s->gb), y;
GetByteContext data_ptr;
if (bytestream2_get_bytes_left(&s->gb) < data_off)
return AVERROR_INVALIDDATA;
bytestream2_init(&data_ptr, s->gb.buffer + data_off,
byte... | [
1,
0
] |
qemu | block/curl.c | int parse_host_src_port(struct sockaddr_in *haddr,
struct sockaddr_in *saddr,
const char *input_str)
{
char *str = strdup(input_str);
char *host_str = str;
char *src_str;
const char *src_str2;
char *ptr;
/*
* Chop off any extra arguments at the en... | [
1,
0
] |
qemu | block.c | int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
{
if (bs->drv->bdrv_check == NULL) {
return -ENOTSUP;
memset(res, 0, sizeof(*res));
return bs->drv->bdrv_check(bs, res, fix); | [
1,
0
] |
qemu | target-s390x/op_helper.c | void HELPER(cksm)(uint32_t r1, uint32_t r2)
{
uint64_t src = get_address_31fix(r2);
uint64_t src_len = env->regs[(r2 + 1) & 15];
uint64_t cksm = 0;
while (src_len >= 4) {
cksm += ldl(src);
cksm = cksm_overflow(cksm);
/* move to next word */
src_len -= 4;
src += 4;
}
switch (sr... | [
1,
1
] |
FFmpeg | libavcodec/mpegvideo.c | int ff_mpv_lowest_referenced_row(MpegEncContext *s, int dir)
{
int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
int my, off, i, mvs;
if (s->picture_structure != PICT_FRAME || s->mcsel)
goto unhandled;
switch (s->mv_type) {
case MV_TYPE_16X16:
mvs = 1;
break;
cas... | [
1,
0
] |
qemu | hw/acpi/piix4.c | static void grackle_pci_class_init(ObjectClass *klass, void *data)
{
PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
DeviceClass *dc = DEVICE_CLASS(klass);
k->init = grackle_pci_host_init;
k->vendor_id = PCI_VENDOR_ID_MOTOROLA;
k->device_id = PCI_DEVICE_ID_MOTOROLA_MPC106;
k->revision = 0x00;
k->clas... | [
1,
0
] |
qemu | hw/block/dataplane/virtio-blk.c | void virtio_irq(VirtQueue *vq)
{
trace_virtio_irq(vq);
virtio_set_isr(vq->vdev, 0x1);
virtio_notify_vector(vq->vdev, vq->vector);
} | [
1,
0
] |
qemu | kvm-all.c | static KVMSlot *kvm_lookup_slot(KVMState *s, target_phys_addr_t start_addr)
{
int i;
for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
KVMSlot *mem = &s->slots[i];
if (start_addr >= mem->start_addr &&
start_addr < (mem->start_addr + mem->memory_size))
return mem;
}
return NULL;
} | [
1,
0
] |
qemu | tests/e1000e-test.c | void qpci_io_writew(QPCIDevice *dev, void *data, uint16_t value)
{
uintptr_t addr = (uintptr_t)data;
if (addr < QPCI_PIO_LIMIT) {
dev->bus->pio_writew(dev->bus, addr, value);
} else {
value = cpu_to_le16(value);
dev->bus->memwrite(dev->bus, addr, &value, sizeof(value));
}
} | [
1,
0
] |
qemu | hw/input/Makefile.objs | static void adb_kbd_class_init(ObjectClass *oc, void *data)
{
DeviceClass *dc = DEVICE_CLASS(oc);
ADBDeviceClass *adc = ADB_DEVICE_CLASS(oc);
ADBKeyboardClass *akc = ADB_KEYBOARD_CLASS(oc);
akc->parent_realize = dc->realize;
dc->realize = adb_kbd_realizefn;
set_bit(DEVICE_CATEGORY_INPUT, dc->categori... | [
1,
0
] |
qemu | hw/usb/hcd-ohci.c | static int ohci_eof_timer_pre_load(void *opaque)
{
OHCIState *ohci = opaque;
ohci_bus_start(ohci);
return 0;
} | [
1,
0
] |
qemu | Makefile.objs | static void put_unused_buffer(QEMUFile *f, void *pv, size_t size)
{
static const uint8_t buf[1024];
int block_len;
while (size > 0) {
block_len = MIN(sizeof(buf), size);
size -= block_len;
qemu_put_buffer(f, buf, block_len);
}
} | [
1,
0
] |
FFmpeg | libavcodec/eamad.c | static void decode_mb(MadContext *t, int inter)
{
MpegEncContext *s = &t->s;
int mv_map = 0;
int mv_x, mv_y;
int j;
if (inter) {
int v = decode210(&s->gb);
if (v < 2) {
mv_map = v ? get_bits(&s->gb, 6) : 63;
mv_x = decode_motion(&s->gb);
mv_y = decode_motion(&s->gb);
... | [
1,
0
] |
qemu | hw/misc/arm_sysctl.c | static bool vexpress_cfgctrl_read(arm_sysctl_state *s, unsigned int dcc,
unsigned int function, unsigned int site,
unsigned int position, unsigned int device,
uint32_t *val)
{
/* We don't support anything other ... | [
1,
0
] |
FFmpeg | libavformat/aviobuf.c | static int nut_read_header(AVFormatContext *s, AVFormatParameters *ap)
{
NUTContext *nut = s->priv_data;
ByteIOContext *bc = &s->pb;
int64_t pos;
int inited_stream_count;
nut->avf = s;
av_set_pts_info(s, 60, 1, AV_TIME_BASE);
/* main header */
pos = 0;
for (;;) {
if (find_startcode(bc, ... | [
0,
1
] |
qemu | hw/arm/allwinner-a10.c | static void xlnx_zynqmp_class_init(ObjectClass *oc, void *data) {
DeviceClass *dc = DEVICE_CLASS(oc);
dc->props = xlnx_zynqmp_props;
dc->realize = xlnx_zynqmp_realize;
} | [
1,
0
] |
FFmpeg | libavcodec/g2meet.c | static uint32_t epic_decode_pixel_pred(ePICContext *dc, int x, int y,
const uint32_t *curr_row,
const uint32_t *above_row) {
uint32_t N, W, NW, pred;
unsigned delta;
int GN, GW, GNW, R, G, B;
if (x && y) {
W = curr_row[x - 1];
... | [
1,
0
] |
qemu | hw/input/Makefile.objs | static int adb_kbd_request(ADBDevice *d, uint8_t *obuf,
const uint8_t *buf, int len)
{
KBDState *s = ADB_KEYBOARD(d);
int cmd, reg, olen;
if ((buf[0] & 0x0f) == ADB_FLUSH) {
/* flush keyboard fifo */
s->wptr = s->rptr = s->count = 0;
return 0;
}
cmd = buf[0] & 0... | [
1,
1
] |
qemu | hw/9pfs/cofs.c | static ssize_t mp_pacl_getxattr(FsContext *ctx, const char *path,
const char *name, void *value, size_t size)
{
char buffer[PATH_MAX];
return lgetxattr(rpath(ctx, path, buffer), MAP_ACL_ACCESS, value, size);
} | [
0,
0
] |
qemu | qga/commands-posix.c | void ga_command_state_init(GAState *s, GACommandState *cs)
{
if (vss_init(true)) {
ga_command_state_add(cs, NULL, guest_fsfreeze_cleanup);
}
} | [
0,
0
] |
FFmpeg | libavcodec/vaapi.c | int ff_vaapi_commit_slices(FFVAContext *vactx)
{
VABufferID *slice_buf_ids;
VABufferID slice_param_buf_id, slice_data_buf_id;
if (vactx->slice_count == 0)
return 0;
slice_buf_ids =
av_fast_realloc(vactx->slice_buf_ids,
&vactx->slice_buf_ids_alloc,
(... | [
1,
0
] |
qemu | target-lm32/translate.c | static void dec_scall(DisasContext *dc)
{
TCGv t0;
int l1;
if (dc->imm5 == 7) {
LOG_DIS("scall\n");
} else if (dc->imm5 == 2) {
LOG_DIS("break\n");
} else {
cpu_abort(dc->env, "invalid opcode\n");
}
t0 = tcg_temp_new();
l1 = gen_new_label();
if (dc->imm5 == 7) {
tcg_gen_mo... | [
0,
0
] |
qemu | kvm-all.c | static KVMMSIRoute *kvm_lookup_msi_route(KVMState *s, MSIMessage msg)
{
unsigned int hash = kvm_hash_msi(msg.data);
KVMMSIRoute *route;
QTAILQ_FOREACH(route, &s->msi_hashtab[hash], entry) {
if (route->kroute.u.msi.address_lo == (uint32_t)msg.address &&
route->kroute.u.msi.address_hi == (msg.addr... | [
1,
0
] |
qemu | ui/vnc-auth-sasl.c | static int protocol_client_vencrypt_auth(VncState *vs, uint8_t *data,
size_t len)
{
int auth = read_u32(data, 0);
if (auth != vs->vd->subauth) {
VNC_DEBUG("Rejecting auth %d\n", auth);
vnc_write_u8(vs, 0); /* Reject auth */
vnc_flush(vs);
vnc_client_er... | [
1,
0
] |
qemu | hw/arm/musicpal.c | static int pci_std_vga_initfn(PCIDevice *dev)
{
PCIVGAState *d = DO_UPCAST(PCIVGAState, dev, dev);
VGACommonState *s = &d->vga;
/* vga + console init */
vga_common_init(s);
vga_init(s, pci_address_space(dev), pci_address_space_io(dev), true);
s->con = graphic_console_init(s->update, s->invalidate,
... | [
0,
1
] |
qemu | hw/arm/nseries.c | static int tosa_dac_recv(I2CSlave *s)
{
printf("%s: recv not supported!!!\n", __FUNCTION__);
return -1;
} | [
0,
0
] |
qemu | block/raw.c | static BlockDriverAIOCB *
raw_aio_readv(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque)
{
return bdrv_aio_readv(bs->file, sector_num, qiov, nb_sectors, cb, opaque);
} | [
0,
0
] |
qemu | fpu/softfloat-specialize.h | float64 float64_sqrt(float64 a STATUS_PARAM)
{
flag aSign;
int16 aExp, zExp;
bits64 aSig, zSig, doubleZSig;
bits64 rem0, rem1, term0, term1;
aSig = extractFloat64Frac(a);
aExp = extractFloat64Exp(a);
aSign = extractFloat64Sign(a);
if (aExp == 0x7FF) {
if (aSig)
return propagateFloat6... | [
1,
0
] |
qemu | configure | static int dynticks_start_timer(struct qemu_alarm_timer *t)
{
struct sigevent ev;
timer_t host_timer;
struct sigaction act;
sigfillset(&act.sa_mask);
act.sa_flags = 0;
act.sa_handler = host_alarm_handler;
sigaction(SIGALRM, &act, NULL);
/*
* Initialize ev struct to 0 to avoid valgrind compl... | [
1,
0
] |
qemu | qemu-timer.c | int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
{
if (!timer_head)
return 0;
return (timer_head->expire_time <= current_time);
} | [
0,
0
] |
qemu | blockdev.c | void qmp_block_job_resume(const char *device, Error **errp)
{
BlockJob *job = find_block_job(device);
if (!job) {
error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);
return;
}
trace_qmp_block_job_resume(job);
block_job_resume(job);
} | [
0,
0
] |
qemu | target-lm32/translate.c | static void dec_user(DisasContext *dc)
{
LOG_DIS("user");
cpu_abort(dc->env, "user insn undefined\n");
} | [
1,
0
] |
qemu | configure | void qemu_main_loop_start(void)
{} | [
1,
0
] |
qemu | target/i386/cpu.c | static void max_x86_cpu_initfn(Object *obj)
{
X86CPU *cpu = X86_CPU(obj);
CPUX86State *env = &cpu->env;
KVMState *s = kvm_state;
/* We can't fill the features array here because we don't know yet if
* "migratable" is true or false.
*/
cpu->max_features = true;
if (kvm_enabled()) {
X86CPU... | [
1,
0
] |
FFmpeg | libavformat/mpeg.c | static int mpeg_mux_write_packet(AVFormatContext *ctx, int stream_index,
const uint8_t *buf, int size, int64_t pts)
{
MpegMuxContext *s = ctx->priv_data;
AVStream *st = ctx->streams[stream_index];
StreamInfo *stream = st->priv_data;
int64_t dts;
int len;
/* XXX: syst... | [
1,
1
] |
qemu | blockdev.c | int qemu_opts_set(QemuOptsList *list, const char *id,
const char *name, const char *value)
{
QemuOpts *opts;
opts = qemu_opts_create(list, id, 1);
if (opts == NULL) {
return -1;
}
return qemu_opt_set(opts, name, value);
} | [
1,
0
] |
FFmpeg | libavcodec/h264.c | static av_cold void decode_init_vlc(void) {
static int done = 0;
if (!done) {
int i;
done = 1;
init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4 * 5,
&chroma_dc_coeff_token_len[0], 1, 1,
&chroma_dc_coeff_token_bits[0], 1, 1, 1);
for (i = 0; i < ... | [
1,
0
] |
qemu | hw/usb/bus.c | static USBDevice *usb_serial_init(USBBus *bus, const char *filename)
{
USBDevice *dev;
CharDriverState *cdrv;
uint32_t vendorid = 0, productid = 0;
char label[32];
static int index;
while (*filename && *filename != ':') {
const char *p;
char *e;
if (strstart(filename, "vendorid=", &p))... | [
1,
0
] |
qemu | bsd-user/main.c | static void cpu_devinit(const char *cpu_model, unsigned int id,
uint64_t prom_addr, qemu_irq **cpu_irqs)
{
CPUState *cs;
SPARCCPU *cpu;
CPUSPARCState *env;
cpu = SPARC_CPU(cpu_generic_init(TYPE_SPARC_CPU, cpu_model));
if (cpu == NULL) {
fprintf(stderr, "qemu: Unable to find... | [
1,
0
] |
qemu | hw/virtio-net.c | static int32_t virtio_net_flush_tx(VirtIONet *n, VirtQueue *vq)
{
VirtQueueElement elem;
int32_t num_packets = 0;
if (!(n->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK)) {
return num_packets;
}
if (n->async_tx.elem.out_num) {
virtio_queue_set_notification(n->tx_vq, 0);
return num_packets;
}
... | [
1,
0
] |
qemu | block/vmdk.c | static int vmdk_read(BlockDriverState *bs, int64_t sector_num,
uint8_t *buf, int nb_sectors)
{
BDRVVmdkState *s = bs->opaque;
int ret;
uint64_t n, index_in_cluster;
VmdkExtent *extent = NULL;
uint64_t cluster_offset;
while (nb_sectors > 0) {
extent = find_extent(s, sector_n... | [
1,
0
] |
qemu | Makefile.objs | void fd_start_incoming_migration(const char *infd, Error **errp)
{
int fd;
QEMUFile *f;
DPRINTF("Attempting to start an incoming migration via fd\n");
fd = strtol(infd, NULL, 0);
f = qemu_fdopen(fd, "rb");
if (f == NULL) {
error_setg_errno(errp, errno, "failed to open the source descriptor");
... | [
1,
0
] |
qemu | target-s390x/helper.c | hwaddr s390_cpu_get_phys_page_debug(CPUState *cs, vaddr vaddr)
{
S390CPU *cpu = S390_CPU(cs);
CPUS390XState *env = &cpu->env;
target_ulong raddr;
int prot;
uint64_t asc = env->psw.mask & PSW_MASK_ASC;
/* 31-Bit mode */
if (!(env->psw.mask & PSW_MASK_64)) {
vaddr &= 0x7fffffff;
}
mmu_tran... | [
1,
0
] |
FFmpeg | cmdutils.c | av_cold void avcodec_register(AVCodec *codec)
{
AVCodec **p;
avcodec_init();
p = &first_avcodec;
while (*p != NULL)
p = &(*p)->next;
*p = codec;
codec->next = NULL;
if (codec->init_static_data)
codec->init_static_data(codec);
} | [
0,
0
] |
qemu | target/openrisc/cpu.h | static void gen_add(DisasContext *dc, TCGv dest, TCGv srca, TCGv srcb)
{
TCGv t0 = tcg_const_tl(0);
TCGv res = tcg_temp_new();
TCGv sr_cy = tcg_temp_new();
TCGv sr_ov = tcg_temp_new();
tcg_gen_add2_tl(res, sr_cy, srca, t0, srcb, t0);
tcg_gen_xor_tl(sr_ov, srca, srcb);
tcg_gen_xor_tl(t0, res, srcb)... | [
1,
0
] |
qemu | block/qcow2-cluster.c | static int coroutine_fn copy_sectors(BlockDriverState *bs,
uint64_t start_sect,
uint64_t cluster_offset,
int n_start, int n_end)
{
BDRVQcowState *s = bs->opaque;
QEMUIOVector qiov;
struct iovec io... | [
1,
0
] |
qemu | hw/ide/ahci.c | static uint32_t ahci_port_read(AHCIState *s, int port, int offset)
{
uint32_t val;
AHCIPortRegs *pr;
pr = &s->dev[port].port_regs;
switch (offset) {
case PORT_LST_ADDR:
val = pr->lst_addr;
break;
case PORT_LST_ADDR_HI:
val = pr->lst_addr_hi;
break;
case PORT_FIS_ADDR:
val ... | [
1,
0
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.