label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
1 | RockerSwitch *qmp_query_rocker(const char *name, Error **errp){ RockerSwitch *rocker = g_malloc0(sizeof(*rocker)); Rocker *r; r = rocker_find(name); if (!r) { error_set(errp, ERROR_CLASS_GENERIC_ERROR, "rocker %s not found", name); return NULL; } rocker->name = g_strdup(r->name); rocker->id = r->switch_id; rocker->port... |
0 | static int init_dimensions(H264Context *h){ int width = h->width - (h->sps.crop_right + h->sps.crop_left); int height = h->height - (h->sps.crop_top + h->sps.crop_bottom); /* handle container cropping */ if (FFALIGN(h->avctx->width, 16) == FFALIGN(width, 16) && FFALIGN(h->avctx->height, 16) == FFALIGN(height, 16)) { wi... |
1 | static inline CopyRet copy_frame(AVCodecContext *avctx, BC_DTS_PROC_OUT *output, void *data, int *data_size, uint8_t second_field){ BC_STATUS ret; BC_DTS_STATUS decoder_status; uint8_t is_paff; uint8_t next_frame_same; uint8_t interlaced; CHDContext *priv = avctx->priv_data; int64_t pkt_pts = AV_NOPTS_VALUE; uint8_t pi... |
0 | static int x11grab_read_packet(AVFormatContext *s1, AVPacket *pkt){ X11GrabContext *s = s1->priv_data; Display *dpy = s->dpy; XImage *image = s->image; int x_off = s->x_off; int y_off = s->y_off; int follow_mouse = s->follow_mouse; int screen; Window root; int64_t curtime, delay; struct timespec ts; /* Calculate the ti... |
1 | void usb_ep_combine_input_packets(USBEndpoint *ep){ USBPacket *p, *u, *next, *prev = NULL, *first = NULL; USBPort *port = ep->dev->port; int ret; assert(ep->pipeline); assert(ep->pid == USB_TOKEN_IN); QTAILQ_FOREACH_SAFE(p, &ep->queue, queue, next) { /* Empty the queue on a halt */ if (ep->halted) { p->result = USB_RET... |
1 | static MemoryRegionSection *address_space_lookup_region(AddressSpaceDispatch *d, hwaddr addr, bool resolve_subpage){ MemoryRegionSection *section = atomic_read(&d->mru_section); subpage_t *subpage; bool update; if (section && section != &d->map.sections[PHYS_SECTION_UNASSIGNED] && section_covers_addr(section, addr)) { ... |
1 | static int asf_read_generic_value(AVFormatContext *s, uint8_t *name, uint16_t name_len, int type, AVDictionary **met){ AVIOContext *pb = s->pb; uint64_t value; char buf[32]; switch (type) { case ASF_BOOL: value = avio_rl32(pb); break; case ASF_DWORD: value = avio_rl32(pb); break; case ASF_QWORD: value = avio_rl64(pb); ... |
1 | int do_netdev_add(Monitor *mon, const QDict *qdict, QObject **ret_data){ QemuOpts *opts; int res; opts = qemu_opts_from_qdict(&qemu_netdev_opts, qdict); if (!opts) { return -1; res = net_client_init(mon, opts, 1); return res; |
1 | static int save_zero_page(RAMState *rs, RAMBlock *block, ram_addr_t offset, uint8_t *p){ int pages = -1; if (is_zero_range(p, TARGET_PAGE_SIZE)) { rs->zero_pages++; rs->bytes_transferred += save_page_header(rs, block, offset | RAM_SAVE_FLAG_COMPRESS); qemu_put_byte(rs->f, 0); rs->bytes_transferred += 1; pages = 1; } re... |
0 | static int movie_push_frame(AVFilterContext *ctx, unsigned out_id){ MovieContext *movie = ctx->priv; AVPacket *pkt = &movie->pkt; enum AVMediaType frame_type; MovieStream *st; int ret, got_frame = 0, pkt_out_id; AVFilterLink *outlink; AVFrame *frame; if (!pkt->size) { if (movie->eof) { if (movie->st[out_id].done) { if ... |
1 | static inline void RENAME(rgb24to15)(const uint8_t *src, uint8_t *dst, int src_size){ const uint8_t *s = src; const uint8_t *end; const uint8_t *mm_end; uint16_t *d = (uint16_t *)dst; end = s + src_size; __asm__ volatile(PREFETCH" %0"::"m"(*src):"memory"); __asm__ volatile( "movq %0, %%mm7 \n\t" "movq %1, %%mm6 \n\t" :... |
0 | static int decode_picture_timing(H264Context *h){ if (h->sps.nal_hrd_parameters_present_flag || h->sps.vcl_hrd_parameters_present_flag) { h->sei_cpb_removal_delay = get_bits(&h->gb, h->sps.cpb_removal_delay_length); h->sei_dpb_output_delay = get_bits(&h->gb, h->sps.dpb_output_delay_length); } if (h->sps.pic_struct_pres... |
0 | static int ftp_close(URLContext *h){ FTPContext *s = h->priv_data; av_dlog(h, "ftp protocol close\n"); ftp_close_both_connections(s); av_freep(&s->user); av_freep(&s->password); av_freep(&s->hostname); av_freep(&s->path); av_freep(&s->features); return 0;} |
0 | int av_open_input_file(AVFormatContext **ic_ptr, const char *filename, AVInputFormat *fmt, int buf_size, AVFormatParameters *ap){ AVFormatContext *ic = NULL; int err; char buf[PROBE_BUF_SIZE]; AVProbeData probe_data, *pd = &probe_data; ic = av_mallocz(sizeof(AVFormatContext)); if (!ic) { err = AVERROR_NOMEM; goto fail;... |
0 | static int dec_21154_pci_host_init(PCIDevice *d){ /* PCI2PCI bridge same values as PearPC - check this */ pci_config_set_vendor_id(d->config, PCI_VENDOR_ID_DEC); pci_config_set_device_id(d->config, PCI_DEVICE_ID_DEC_21154); pci_set_byte(d->config + PCI_REVISION_ID, 0x02); pci_config_set_class(d->config, PCI_CLASS_BRIDG... |
0 | static void guess_mv(MpegEncContext *s){ uint8_t *fixed = av_malloc(s->mb_stride * s->mb_height);#define MV_FROZEN 3#define MV_CHANGED 2#define MV_UNCHANGED 1 const int mb_stride = s->mb_stride; const int mb_width = s->mb_width; const int mb_height = s->mb_height; int i, depth, num_avail; int mb_x, mb_y, mot_step, mot_... |
0 | static void audio_reset_timer (AudioState *s){ if (audio_is_timer_needed ()) { timer_mod (s->ts, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + conf.period.ticks); } else { timer_del (s->ts); }} |
0 | int bdrv_get_translation_hint(BlockDriverState *bs){ return bs->translation;} |
0 | static int omap_validate_emifs_addr(struct omap_mpu_state_s *s, target_phys_addr_t addr){ return range_covers_byte(OMAP_EMIFS_BASE, OMAP_EMIFF_BASE - OMAP_EMIFS_BASE, addr);} |
0 | StringOutputVisitor *string_output_visitor_new(bool human){ StringOutputVisitor *v; v = g_malloc0(sizeof(*v)); v->string = g_string_new(NULL); v->human = human; v->visitor.type = VISITOR_OUTPUT; v->visitor.type_int64 = print_type_int64; v->visitor.type_uint64 = print_type_uint64; v->visitor.type_size = print_type_size;... |
0 | int qemu_input_key_value_to_number(const KeyValue *value){ if (value->kind == KEY_VALUE_KIND_QCODE) { return qcode_to_number[value->qcode]; } else { assert(value->kind == KEY_VALUE_KIND_NUMBER); return value->number; }} |
0 | uint64_t HELPER(paired_cmpxchg64_be)(CPUARMState *env, uint64_t addr, uint64_t new_lo, uint64_t new_hi){ uintptr_t ra = GETPC(); Int128 oldv, cmpv, newv; bool success; cmpv = int128_make128(env->exclusive_val, env->exclusive_high); newv = int128_make128(new_lo, new_hi); if (parallel_cpus) {#ifndef CONFIG_ATOMIC128 cpu_... |
0 | void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload){ /* * Artificially limit timeout rate to something * achievable under QEMU. Otherwise, QEMU spends all * its time generating timer interrupts, and there * is no forward progress. * About ten microseconds is the fastest that really works * on the current... |
0 | static inline void conv_to_int32(int32_t *loc, float *samples, int num, float norm){ int i; for (i = 0; i < num; i++) loc[i] = ceilf((samples[i]/norm)*INT32_MAX);} |
0 | static inline void RENAME(hcscale_fast)(SwsContext *c, int16_t *dst, long dstWidth, const uint8_t *src1, const uint8_t *src2, int srcW, int xInc){#if ARCH_X86#if COMPILE_TEMPLATE_MMX2 int32_t *filterPos = c->hChrFilterPos; int16_t *filter = c->hChrFilter; int canMMX2BeUsed = c->canMMX2BeUsed; void *mmx2FilterCode= c->c... |
0 | static void ga_channel_listen_close(GAChannel *c){ g_assert(c->method == GA_CHANNEL_UNIX_LISTEN); g_assert(c->listen_channel); g_io_channel_shutdown(c->listen_channel, true, NULL); g_io_channel_unref(c->listen_channel); c->listen_channel = NULL;} |
0 | static int v9fs_do_setuid(V9fsState *s, uid_t uid){ return s->ops->setuid(&s->ctx, uid);} |
0 | static void vgafb_update_display(void *opaque){ MilkymistVgafbState *s = opaque; SysBusDevice *sbd; DisplaySurface *surface = qemu_console_surface(s->con); int first = 0; int last = 0; drawfn fn; if (!vgafb_enabled(s)) { return; } sbd = SYS_BUS_DEVICE(s); int dest_width = s->regs[R_HRES]; switch (surface_bits_per_pixel... |
0 | static void mainstone_common_init(int ram_size, int vga_ram_size, DisplayState *ds, const char *kernel_filename, const char *kernel_cmdline, const char *initrd_filename, const char *cpu_model, enum mainstone_model_e model, int arm_id){ uint32_t mainstone_ram = 0x04000000; uint32_t mainstone_rom = 0x00800000; struct pxa... |
0 | uint32_t HELPER(xc)(CPUS390XState *env, uint32_t l, uint64_t dest, uint64_t src){ int i; unsigned char x; uint32_t cc = 0; HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "\n", __func__, l, dest, src);#ifndef CONFIG_USER_ONLY /* xor with itself is the same as memset(0) */ if ((l > 32) && (src == dest) && (src & TARG... |
0 | static int xen_pt_pci_config_access_check(PCIDevice *d, uint32_t addr, int len){ /* check offset range */ if (addr >= 0xFF) { XEN_PT_ERR(d, "Failed to access register with offset exceeding 0xFF. " "(addr: 0x%02x, len: %d)\n", addr, len); return -1; } /* check read size */ if ((len != 1) && (len != 2) && (len != 4)) { X... |
0 | static inline int dmg_read_chunk(BlockDriverState *bs, int sector_num){ BDRVDMGState *s = bs->opaque; if(!is_sector_in_chunk(s,s->current_chunk,sector_num)) {int ret;uint32_t chunk = search_chunk(s,sector_num);if(chunk>=s->n_chunks) return -1;s->current_chunk = s->n_chunks;switch(s->types[chunk]) {case 0x80000005: { /*... |
0 | void object_property_add_child(Object *obj, const char *name, Object *child, Error **errp){ Error *local_err = NULL; gchar *type; type = g_strdup_printf("child<%s>", object_get_typename(OBJECT(child))); object_property_add(obj, name, type, object_get_child_property, NULL, object_finalize_child_property, child, &local_e... |
1 | void tlb_fill(CPUState *cs, target_ulong addr, MMUAccessType access_type, int mmu_idx, uintptr_t retaddr){ bool ret; uint32_t fsr = 0; ARMMMUFaultInfo fi = {}; ret = arm_tlb_fill(cs, addr, access_type, mmu_idx, &fsr, &fi); if (unlikely(ret)) { ARMCPU *cpu = ARM_CPU(cs); CPUARMState *env = &cpu->env; uint32_t syn, exc; ... |
1 | static inline FFAMediaCodec *codec_create(int method, const char *arg){ int ret = -1; JNIEnv *env = NULL; FFAMediaCodec *codec = NULL; jstring jarg = NULL; jobject object = NULL; jmethodID create_id = NULL; codec = av_mallocz(sizeof(FFAMediaCodec)); if (!codec) { return NULL; codec->class = &amediacodec_class; env = ff... |
1 | static int parse_header(OutputStream *os, const uint8_t *buf, int buf_size){ if (buf_size < 13) return AVERROR_INVALIDDATA; if (memcmp(buf, "FLV", 3)) return AVERROR_INVALIDDATA; buf += 13; buf_size -= 13; while (buf_size >= 11 + 4) { int type = buf[0]; int size = AV_RB24(&buf[1]) + 11 + 4; if (size > buf_size) return ... |
1 | static void omap_i2c_send(I2CAdapter *i2c, uint8_t addr, const uint8_t *buf, uint16_t len){ OMAPI2C *s = (OMAPI2C *)i2c; uint16_t data; omap_i2c_set_slave_addr(s, addr); data = len; memwrite(s->addr + OMAP_I2C_CNT, &data, 2); data = OMAP_I2C_CON_I2C_EN | OMAP_I2C_CON_TRX | OMAP_I2C_CON_MST | OMAP_I2C_CON_STT | OMAP_I2C... |
1 | static void mps2_common_init(MachineState *machine){ MPS2MachineState *mms = MPS2_MACHINE(machine); MPS2MachineClass *mmc = MPS2_MACHINE_GET_CLASS(machine); MemoryRegion *system_memory = get_system_memory(); DeviceState *armv7m, *sccdev; if (!machine->cpu_model) { machine->cpu_model = mmc->cpu_model; } if (strcmp(machi... |
1 | static int xbm_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt){ AVFrame *p = data; const uint8_t *end, *ptr = avpkt->data; uint8_t *dst; int ret, linesize, i, j; end = avpkt->data + avpkt->size; while (!avctx->width || !avctx->height) { char name[256]; int number, len; ptr += strcspn(pt... |
1 | int mips_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n){ MIPSCPU *cpu = MIPS_CPU(cs); CPUMIPSState *env = &cpu->env; target_ulong tmp; tmp = ldtul_p(mem_buf); if (n < 32) { env->active_tc.gpr[n] = tmp; return sizeof(target_ulong); } if (env->CP0_Config1 & (1 << CP0C1_FP) && n >= 38 && n < 73) { if (n < 7... |
1 | static int yuv4_read_packet(AVFormatContext *s, AVPacket *pkt){ int i; char header[MAX_FRAME_HEADER+1]; int ret; int64_t off = avio_tell(s->pb); for (i = 0; i < MAX_FRAME_HEADER; i++) { header[i] = avio_r8(s->pb); if (header[i] == '\n') { header[i + 1] = 0; break; } } if (s->pb->error) return s->pb->error; else if (s->... |
1 | uint64_t HELPER(neon_add_saturate_u64)(uint64_t src1, uint64_t src2){ uint64_t res; res = src1 + src2; if (res < src1) { env->QF = 1; res = ~(uint64_t)0; } return res;} |
1 | static void load_linux(PCMachineState *pcms, FWCfgState *fw_cfg){ uint16_t protocol; int setup_size, kernel_size, initrd_size = 0, cmdline_size; uint32_t initrd_max; uint8_t header[8192], *setup, *kernel, *initrd_data; hwaddr real_addr, prot_addr, cmdline_addr, initrd_addr = 0; FILE *f; char *vmode; MachineState *machi... |
1 | void ga_command_state_add(GACommandState *cs, void (*init)(void), void (*cleanup)(void)){ GACommandGroup *cg = g_malloc0(sizeof(GACommandGroup)); cg->init = init; cg->cleanup = cleanup; cs->groups = g_slist_append(cs->groups, cg);} |
1 | static void new_pes_packet(PESContext *pes, AVPacket *pkt){ av_init_packet(pkt); pkt->destruct = av_destruct_packet; pkt->data = pes->buffer; pkt->size = pes->data_index; memset(pkt->data+pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE); // Separate out the AC3 substream from an HDMV combined TrueHD/AC3 PID if (pes->sub_st ... |
1 | static int seqvideo_decode(SeqVideoContext *seq, const unsigned char *data, int data_size){ const unsigned char *data_end = data + data_size; GetBitContext gb; int flags, i, j, x, y, op; unsigned char c[3]; unsigned char *dst; uint32_t *palette; flags = *data++; if (flags & 1) { palette = (uint32_t *)seq->frame.data[1]... |
1 | QTestState *qtest_init_without_qmp_handshake(const char *extra_args){ QTestState *s; int sock, qmpsock, i; gchar *socket_path; gchar *qmp_socket_path; gchar *command; const char *qemu_binary; qemu_binary = getenv("QTEST_QEMU_BINARY"); g_assert(qemu_binary != NULL); s = g_malloc(sizeof(*s)); socket_path = g_strdup_print... |
1 | static inline void RENAME(yuv2packed2)(SwsContext *c, uint16_t *buf0, uint16_t *buf1, uint16_t *uvbuf0, uint16_t *uvbuf1, uint8_t *dest, int dstW, int yalpha, int uvalpha, int y){int yalpha1=yalpha^4095;int uvalpha1=uvalpha^4095;int i;#if 0 //isn't usedif(flags&SWS_FULL_CHR_H_INT){switch(dstFormat){#ifdef HAVE_MMXcase ... |
0 | static int http_parse_request(HTTPContext *c){ const char *p; char *p1; enum RedirType redir_type; char cmd[32]; char info[1024], filename[1024]; char url[1024], *q; char protocol[32]; char msg[1024]; const char *mime_type; FFServerStream *stream; int i; char ratebuf[32]; const char *useragent = 0; p = c->buffer; get_w... |
1 | static int get_bitmap(QEMUFile *f, void *pv, size_t size){ unsigned long *bmp = pv; int i, idx = 0; for (i = 0; i < BITS_TO_U64S(size); i++) { uint64_t w = qemu_get_be64(f); bmp[idx++] = w; if (sizeof(unsigned long) == 4 && idx < BITS_TO_LONGS(size)) { bmp[idx++] = w >> 32; } } return 0;} |
1 | long do_sigreturn(CPUM68KState *env){ struct target_sigframe *frame; abi_ulong frame_addr = env->aregs[7] - 4; target_sigset_t target_set; sigset_t set; int d0, i; if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) goto badframe; /* set blocked signals */ if (__get_user(target_set.sig[0], &frame->sc.sc_mask)) go... |
1 | static int vscsi_send_adapter_info(VSCSIState *s, vscsi_req *req){ struct viosrp_adapter_info *sinfo; struct mad_adapter_info_data info; int rc; sinfo = &req->iu.mad.adapter_info;#if 0 /* What for ? */ rc = spapr_tce_dma_read(&s->vdev, be64_to_cpu(sinfo->buffer), &info, be16_to_cpu(sinfo->common.length)); if (rc) { fpr... |
1 | static void qmp_input_type_null(Visitor *v, const char *name, Error **errp){ QmpInputVisitor *qiv = to_qiv(v); QObject *qobj = qmp_input_get_object(qiv, name, true); if (qobject_type(qobj) != QTYPE_QNULL) { error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null", "null"); |
1 | static void gen_spr_970_lpar(CPUPPCState *env){ /* Logical partitionning */ /* PPC970: HID4 is effectively the LPCR */ spr_register(env, SPR_970_HID4, "HID4", SPR_NOACCESS, SPR_NOACCESS, &spr_read_generic, &spr_write_generic, 0x00000000);} |
1 | static inline void *alloc_code_gen_buffer(void){ void *buf = static_code_gen_buffer;#ifdef __mips__ if (cross_256mb(buf, tcg_ctx.code_gen_buffer_size)) { buf = split_cross_256mb(buf, tcg_ctx.code_gen_buffer_size); }#endif map_exec(buf, tcg_ctx.code_gen_buffer_size); return buf;} |
1 | static void intel_hda_update_int_sts(IntelHDAState *d){ uint32_t sts = 0; uint32_t i; /* update controller status */ if (d->rirb_sts & ICH6_RBSTS_IRQ) { sts |= (1 << 30); } if (d->rirb_sts & ICH6_RBSTS_OVERRUN) { sts |= (1 << 30); } if (d->state_sts & d->wake_en) { sts |= (1 << 30); } /* update stream status */ for (i ... |
1 | static void do_loadvm(Monitor *mon, const QDict *qdict){ int saved_vm_running = vm_running; const char *name = qdict_get_str(qdict, "name"); vm_stop(0); if (load_vmstate(name) >= 0 && saved_vm_running) vm_start();} |
1 | static av_always_inline void mc_chroma_scaled(VP9Context *s, vp9_scaled_mc_func smc, vp9_mc_func (*mc)[2], uint8_t *dst_u, uint8_t *dst_v, ptrdiff_t dst_stride, const uint8_t *ref_u, ptrdiff_t src_stride_u, const uint8_t *ref_v, ptrdiff_t src_stride_v, ThreadFrame *ref_frame, ptrdiff_t y, ptrdiff_t x, const VP56mv *in_... |
1 | static void gen_add_carry(TCGv dest, TCGv t0, TCGv t1){ TCGv tmp; tcg_gen_add_i32(dest, t0, t1); tmp = load_cpu_field(CF); tcg_gen_add_i32(dest, dest, tmp); dead_tmp(tmp);} |
1 | static int compat_decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt){ AVCodecInternal *avci = avctx->internal; int ret; av_assert0(avci->compat_decode_consumed == 0); *got_frame = 0; avci->compat_decode = 1; if (avci->compat_decode_partial_size > 0 && avci->compat_decode_partial_size != pkt->s... |
1 | static void gen_wsr_debugcause(DisasContext *dc, uint32_t sr, TCGv_i32 v){} |
1 | static int jp2_find_codestream(Jpeg2000DecoderContext *s){ uint32_t atom_size, atom, atom_end; int search_range = 10; while (search_range && bytestream2_get_bytes_left(&s->g) >= 8) { atom_size = bytestream2_get_be32u(&s->g); atom = bytestream2_get_be32u(&s->g); atom_end = bytestream2_tell(&s->g) + atom_size - 8; if (at... |
0 | static void i440fx_realize(PCIDevice *dev, Error **errp){ dev->config[I440FX_SMRAM] = 0x02; if (object_property_get_bool(qdev_get_machine(), "iommu", NULL)) { error_report("warning: i440fx doesn't support emulated iommu"); }} |
0 | static inline unsigned char gif_clut_index(uint8_t r, uint8_t g, uint8_t b){ return ((((r)/47)%6)*6*6+(((g)/47)%6)*6+(((b)/47)%6));} |
0 | static void coroutine_fn bdrv_co_do_rw(void *opaque){ BlockAIOCBCoroutine *acb = opaque; BlockDriverState *bs = acb->common.bs; if (!acb->is_write) { acb->req.error = bdrv_co_do_readv(bs, acb->req.sector, acb->req.nb_sectors, acb->req.qiov, acb->req.flags); } else { acb->req.error = bdrv_co_do_writev(bs, acb->req.secto... |
0 | static int xen_add_to_physmap(XenIOState *state, hwaddr start_addr, ram_addr_t size, MemoryRegion *mr, hwaddr offset_within_region){ unsigned long i = 0; int rc = 0; XenPhysmap *physmap = NULL; hwaddr pfn, start_gpfn; hwaddr phys_offset = memory_region_get_ram_addr(mr); char path[80], value[17]; const char *mr_name; if... |
0 | static int fmod_init_in (HWVoiceIn *hw, audsettings_t *as){ int bits16, mode; FMODVoiceIn *fmd = (FMODVoiceIn *) hw; audsettings_t obt_as = *as; if (conf.broken_adc) { return -1; } mode = aud_to_fmodfmt (as->fmt, as->nchannels == 2 ? 1 : 0); fmd->fmod_sample = FSOUND_Sample_Alloc ( FSOUND_FREE, /* index */ conf.nb_samp... |
0 | static void monitor_control_event(void *opaque, int event){ if (event == CHR_EVENT_OPENED) { QObject *data; Monitor *mon = opaque; json_message_parser_init(&mon->mc->parser, handle_qmp_command); data = qobject_from_jsonf("{ 'QMP': { 'capabilities': [] } }"); assert(data != NULL); monitor_json_emitter(mon, data); qobjec... |
0 | static void pmac_ide_transfer_cb(void *opaque, int ret){ DBDMA_io *io = opaque; MACIOIDEState *m = io->opaque; IDEState *s = idebus_active_if(&m->bus); int n = 0; int64_t sector_num; int unaligned; if (ret < 0) { MACIO_DPRINTF("DMA error\n"); m->aiocb = NULL; qemu_sglist_destroy(&s->sg); ide_dma_error(s); io->remainder... |
0 | static uint64_t bmdma_read(void *opaque, target_phys_addr_t addr, unsigned size){ BMDMAState *bm = opaque; PCIIDEState *pci_dev = bm->pci_dev; uint32_t val; if (size != 1) { return ((uint64_t)1 << (size * 8)) - 1; } switch(addr & 3) { case 0: val = bm->cmd; break; case 1: val = pci_dev->dev.config[MRDMODE]; break; case... |
0 | static void hash32_bat_size(CPUPPCState *env, target_ulong *blp, int *validp, target_ulong batu, target_ulong batl){ target_ulong bl; int valid; bl = (batu & BATU32_BL) << 15; valid = 0; if (((msr_pr == 0) && (batu & BATU32_VS)) || ((msr_pr != 0) && (batu & BATU32_VP))) { valid = 1; } *blp = bl; *validp = valid;} |
0 | static int do_fork(CPUArchState *env, unsigned int flags, abi_ulong newsp, abi_ulong parent_tidptr, target_ulong newtls, abi_ulong child_tidptr){ CPUState *cpu = ENV_GET_CPU(env); int ret; TaskState *ts; CPUState *new_cpu; CPUArchState *new_env; unsigned int nptl_flags; sigset_t sigmask; /* Emulate vfork() with fork() ... |
0 | static void test_hash_digest(void){ size_t i; g_assert(qcrypto_init(NULL) == 0); for (i = 0; i < G_N_ELEMENTS(expected_outputs) ; i++) { int ret; char *digest; size_t digestsize; digestsize = qcrypto_hash_digest_len(i); g_assert_cmpint(digestsize * 2, ==, strlen(expected_outputs[i])); ret = qcrypto_hash_digest(i, INPUT... |
0 | static uint32_t pci_apb_ioreadw (void *opaque, target_phys_addr_t addr){ uint32_t val; val = bswap16(cpu_inw(addr & IOPORTS_MASK)); return val;} |
0 | static void destroy_l2_mapping(PhysPageEntry *lp, unsigned level){ unsigned i; PhysPageEntry *p = lp->u.node; if (!p) { return; } for (i = 0; i < L2_SIZE; ++i) { if (level > 0) { destroy_l2_mapping(&p[i], level - 1); } else { destroy_page_desc(p[i].u.leaf); } } g_free(p); lp->u.node = NULL;} |
0 | static void prstat_to_stat(struct stat *stbuf, ProxyStat *prstat){ memset(stbuf, 0, sizeof(*stbuf)); stbuf->st_dev = prstat->st_dev; stbuf->st_ino = prstat->st_ino; stbuf->st_nlink = prstat->st_nlink; stbuf->st_mode = prstat->st_mode; stbuf->st_uid = prstat->st_uid; stbuf->st_gid = prstat->st_gid; stbuf->st_rdev = prst... |
0 | S390CPU *cpu_s390x_init(const char *cpu_model){ S390CPU *cpu; cpu = S390_CPU(object_new(TYPE_S390_CPU)); object_property_set_bool(OBJECT(cpu), true, "realized", NULL); return cpu;} |
0 | void pci_unregister_vga(PCIDevice *pci_dev){ if (!pci_dev->has_vga) { return; } memory_region_del_subregion(pci_dev->bus->address_space_mem, pci_dev->vga_regions[QEMU_PCI_VGA_MEM]); memory_region_del_subregion(pci_dev->bus->address_space_io, pci_dev->vga_regions[QEMU_PCI_VGA_IO_LO]); memory_region_del_subregion(pci_dev... |
0 | static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; C93DecoderContext * const c93 = avctx->priv_data; AVFrame * const newpic = &c93->pictures[c93->currentpic]; AVFrame * const oldpic = &c93->pictures[c93->currentpic^1... |
0 | VncInfo2List *qmp_query_vnc_servers(Error **errp){ VncInfo2List *item, *prev = NULL; VncInfo2 *info; VncDisplay *vd; DeviceState *dev; QTAILQ_FOREACH(vd, &vnc_displays, next) { info = g_new0(VncInfo2, 1); info->id = g_strdup(vd->id); info->clients = qmp_query_client_list(vd); qmp_query_auth(vd, info); if (vd->dcl.con) ... |
0 | pic_read(void *opaque, target_phys_addr_t addr, unsigned int size){ struct etrax_pic *fs = opaque; uint32_t rval; rval = fs->regs[addr >> 2]; D(printf("%s %x=%x\n", __func__, addr, rval)); return rval;} |
0 | static int coroutine_fn nfs_co_writev(BlockDriverState *bs, int64_t sector_num, int nb_sectors, QEMUIOVector *iov){ NFSClient *client = bs->opaque; NFSRPC task; char *buf = NULL; nfs_co_init_task(client, &task); buf = g_try_malloc(nb_sectors * BDRV_SECTOR_SIZE); if (nb_sectors && buf == NULL) { return -ENOMEM; } qemu_i... |
0 | static gboolean cadence_uart_xmit(GIOChannel *chan, GIOCondition cond, void *opaque){ CadenceUARTState *s = opaque; int ret; /* instant drain the fifo when there's no back-end */ if (!s->chr) { s->tx_count = 0; return FALSE; } if (!s->tx_count) { return FALSE; } ret = qemu_chr_fe_write(s->chr, s->tx_fifo, s->tx_count);... |
0 | void error_set_field(Error *err, const char *field, const char *value){ QDict *dict = qdict_get_qdict(err->obj, "data"); return qdict_put(dict, field, qstring_from_str(value));} |
0 | static void replay_add_event(ReplayAsyncEventKind event_kind, void *opaque, void *opaque2, uint64_t id){ assert(event_kind < REPLAY_ASYNC_COUNT); if (!replay_file || replay_mode == REPLAY_MODE_NONE || !events_enabled) { Event e; e.event_kind = event_kind; e.opaque = opaque; e.opaque2 = opaque2; e.id = id; replay_run_ev... |
0 | static void unsafe_flush_warning(BDRVSSHState *s, const char *what){ if (!s->unsafe_flush_warning) { error_report("warning: ssh server %s does not support fsync", s->inet->host); if (what) { error_report("to support fsync, you need %s", what); } s->unsafe_flush_warning = true; }} |
0 | static int hls_slice_header(HEVCContext *s){ GetBitContext *gb = &s->HEVClc->gb; SliceHeader *sh = &s->sh; int i, j, ret; // Coded parameters sh->first_slice_in_pic_flag = get_bits1(gb); if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) { s->seq_decode = (s->seq_decode + 1) & 0xff; s->max_ra = INT_MAX; if (I... |
0 | static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ int x, y, fr, f; sx = av_clip(sx, 0, w - 1); sy = av_clip(sy, 0, h - 1); ex = av_clip(ex, 0, w - 1); ey = av_clip(ey, 0, h - 1); buf[sy * stride + sx] += color; if (FFABS(ex - sx) > FFABS(ey - sy)) { if (sx > ex) {... |
0 | static int bdrv_prwv_co(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov, bool is_write, BdrvRequestFlags flags){ Coroutine *co; RwCo rwco = { .bs = bs, .offset = offset, .qiov = qiov, .is_write = is_write, .ret = NOT_DONE, .flags = flags, }; /** * In sync call context, when the vcpu is blocked, this throttling... |
0 | static uint64_t omap_mcbsp_read(void *opaque, hwaddr addr, unsigned size){ struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque; int offset = addr & OMAP_MPUI_REG_MASK; uint16_t ret; if (size != 2) { return omap_badwidth_read16(opaque, addr); } switch (offset) { case 0x00:/* DRR2 */ if (((s->rcr[0] >> 5) & 7) < 3)/*... |
0 | static void check_suspend_mode(GuestSuspendMode mode, Error **errp){ SYSTEM_POWER_CAPABILITIES sys_pwr_caps; Error *local_err = NULL; ZeroMemory(&sys_pwr_caps, sizeof(sys_pwr_caps)); if (!GetPwrCapabilities(&sys_pwr_caps)) { error_setg(&local_err, QERR_QGA_COMMAND_FAILED, "failed to determine guest suspend capabilities... |
0 | av_cold static int lavfi_read_header(AVFormatContext *avctx){ LavfiContext *lavfi = avctx->priv_data; AVFilterInOut *input_links = NULL, *output_links = NULL, *inout; AVFilter *buffersink, *abuffersink; int *pix_fmts = create_all_formats(AV_PIX_FMT_NB); enum AVMediaType type; int ret = 0, i, n;#define FAIL(ERR) { ret =... |
0 | int do_balloon(Monitor *mon, const QDict *params, MonitorCompletion cb, void *opaque){ int ret; if (kvm_enabled() && !kvm_has_sync_mmu()) { qerror_report(QERR_KVM_MISSING_CAP, "synchronous MMU", "balloon"); return -1; } ret = qemu_balloon(qdict_get_int(params, "value")); if (ret == 0) { qerror_report(QERR_DEVICE_NOT_AC... |
0 | static av_cold int movie_init(AVFilterContext *ctx, const char *args){ MovieContext *movie = ctx->priv; AVInputFormat *iformat = NULL; int64_t timestamp; int nb_streams, ret, i; char default_streams[16], *stream_specs, *spec, *cursor; char name[16]; AVStream *st; movie->class = &movie_class; av_opt_set_defaults(movie);... |
0 | void cpu_outl(pio_addr_t addr, uint32_t val){ LOG_IOPORT("outl: %04"FMT_pioaddr" %08"PRIx32"\n", addr, val); trace_cpu_out(addr, val); ioport_write(2, addr, val);} |
0 | static void do_loadvm(int argc, const char **argv){ if (argc != 2) { help_cmd(argv[0]); return; } if (qemu_loadvm(argv[1]) < 0) term_printf("I/O error when loading VM from '%s'\n", argv[1]);} |
0 | static void vmdk_refresh_limits(BlockDriverState *bs, Error **errp){ BDRVVmdkState *s = bs->opaque; int i; for (i = 0; i < s->num_extents; i++) { if (!s->extents[i].flat) { bs->bl.write_zeroes_alignment = MAX(bs->bl.write_zeroes_alignment, s->extents[i].cluster_sectors); } }} |
0 | static int handle_cmd(AHCIState *s, int port, int slot){ IDEState *ide_state; uint32_t opts; uint64_t tbl_addr; AHCICmdHdr *cmd; uint8_t *cmd_fis; dma_addr_t cmd_len; if (s->dev[port].port.ifs[0].status & (BUSY_STAT|DRQ_STAT)) { /* Engine currently busy, try again later */ DPRINTF(port, "engine busy\n"); return -1; } c... |
0 | static void virtio_rng_process(VirtIORNG *vrng){ size_t size; if (!is_guest_ready(vrng)) { return; } size = get_request_size(vrng->vq); size = MIN(vrng->quota_remaining, size); if (size) { rng_backend_request_entropy(vrng->rng, size, chr_read, vrng); }} |
0 | static int vhost_verify_ring_part_mapping(void *part, uint64_t part_addr, uint64_t part_size, uint64_t start_addr, uint64_t size){ hwaddr l; void *p; int r = 0; if (!ranges_overlap(start_addr, size, part_addr, part_size)) { return 0; } l = part_size; p = cpu_physical_memory_map(part_addr, &l, 1); if (!p || l != part_si... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.