label int64 0 1 | func1 stringlengths 23 97k | id int64 0 27.3k |
|---|---|---|
0 | static void virtio_net_tx_bh(void *opaque) { VirtIONetQueue *q = opaque; VirtIONet *n = q->n; VirtIODevice *vdev = VIRTIO_DEVICE(n); int32_t ret; assert(vdev->vm_running); q->tx_waiting = 0; /* Just in case the driver is not ready on more */ if (unlikely(!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK))) { return; } ret = v... | 5,572 |
0 | static int sclp_parse(const char *devname) { QemuOptsList *device = qemu_find_opts("device"); static int index = 0; char label[32]; QemuOpts *dev_opts; if (strcmp(devname, "none") == 0) { return 0; } if (index == MAX_SCLP_CONSOLES) { fprintf(stderr, "qemu: too many sclp consoles\n"); exit(1); } assert(arch_type == QEMU... | 5,574 |
0 | void arm_gen_test_cc(int cc, int label) { TCGv_i32 tmp; int inv; switch (cc) { case 0: /* eq: Z */ tcg_gen_brcondi_i32(TCG_COND_EQ, cpu_ZF, 0, label); break; case 1: /* ne: !Z */ tcg_gen_brcondi_i32(TCG_COND_NE, cpu_ZF, 0, label); break; case 2: /* cs: C */ tcg_gen_brcondi_i32(TCG_COND_NE, cpu_CF, 0, label); break; cas... | 5,575 |
0 | void ide_init_drive(IDEState *s, DriveInfo *dinfo, const char *version) { int cylinders, heads, secs; uint64_t nb_sectors; if (dinfo && dinfo->bdrv) { s->bs = dinfo->bdrv; bdrv_get_geometry(s->bs, &nb_sectors); bdrv_guess_geometry(s->bs, &cylinders, &heads, &secs); s->cylinders = cylinders; s->heads = heads; s->sectors... | 5,576 |
0 | static void ppc_heathrow_init(QEMUMachineInitArgs *args) { ram_addr_t ram_size = args->ram_size; const char *cpu_model = args->cpu_model; const char *kernel_filename = args->kernel_filename; const char *kernel_cmdline = args->kernel_cmdline; const char *initrd_filename = args->initrd_filename; const char *boot_device =... | 5,577 |
0 | static void synthfilt_build_sb_samples(QDM2Context *q, GetBitContext *gb, int length, int sb_min, int sb_max) { int sb, j, k, n, ch, run, channels; int joined_stereo, zero_encoding, chs; int type34_first; float type34_div = 0; float type34_predictor; float samples[10], sign_bits[16]; if (length == 0) { // If no data us... | 5,578 |
0 | void usb_desc_create_serial(USBDevice *dev) { DeviceState *hcd = dev->qdev.parent_bus->parent; const USBDesc *desc = usb_device_get_usb_desc(dev); int index = desc->id.iSerialNumber; char serial[64]; char *path; int dst; if (dev->serial) { /* 'serial' usb bus property has priority if present */ usb_desc_set_string(dev,... | 5,579 |
0 | static void xics_kvm_cpu_setup(XICSState *xics, PowerPCCPU *cpu) { CPUState *cs; ICPState *ss; KVMXICSState *xicskvm = XICS_SPAPR_KVM(xics); cs = CPU(cpu); ss = &xics->ss[cs->cpu_index]; assert(cs->cpu_index < xics->nr_servers); if (xicskvm->kernel_xics_fd == -1) { abort(); } /* * If we are reusing a parked vCPU fd cor... | 5,580 |
0 | static inline void tcg_out_ldst(TCGContext *s, int ret, int addr, int offset, int op) { if (check_fit_tl(offset, 13)) { tcg_out32(s, op | INSN_RD(ret) | INSN_RS1(addr) | INSN_IMM13(offset)); } else { tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_T1, offset); tcg_out_ldst_rr(s, ret, addr, TCG_REG_T1, op); } } | 5,583 |
0 | void smbios_entry_add(QemuOpts *opts) { Error *local_err = NULL; const char *val; assert(!smbios_immutable); val = qemu_opt_get(opts, "file"); if (val) { struct smbios_structure_header *header; struct smbios_table *table; int size; qemu_opts_validate(opts, qemu_smbios_file_opts, &local_err); if (local_err) { error_repo... | 5,584 |
0 | static void guest_fsfreeze_cleanup(void) { int64_t ret; Error *err = NULL; if (guest_fsfreeze_state.status == GUEST_FSFREEZE_STATUS_FROZEN) { ret = qmp_guest_fsfreeze_thaw(&err); if (ret < 0 || err) { slog("failed to clean up frozen filesystems"); } } } | 5,585 |
0 | static int qesd_init_in (HWVoiceIn *hw, audsettings_t *as) { ESDVoiceIn *esd = (ESDVoiceIn *) hw; audsettings_t obt_as = *as; int esdfmt = ESD_STREAM | ESD_RECORD; int err; sigset_t set, old_set; sigfillset (&set); esdfmt |= (as->nchannels == 2) ? ESD_STEREO : ESD_MONO; switch (as->fmt) { case AUD_FMT_S8: case AUD_FMT_... | 5,586 |
0 | static int latm_write_packet(AVFormatContext *s, AVPacket *pkt) { LATMContext *ctx = s->priv_data; AVIOContext *pb = s->pb; PutBitContext bs; int i, len; uint8_t loas_header[] = "\x56\xe0\x00"; if (s->streams[0]->codecpar->codec_id == AV_CODEC_ID_AAC_LATM) return ff_raw_write_packet(s, pkt); if (!s->streams[0]->codecpa... | 5,588 |
0 | static void end_ebml_master_crc32(AVIOContext *pb, AVIOContext **dyn_cp, MatroskaMuxContext *mkv, ebml_master master) { uint8_t *buf, crc[4]; int size; if (pb->seekable) { size = avio_close_dyn_buf(*dyn_cp, &buf); if (mkv->write_crc && mkv->mode != MODE_WEBM) { AV_WL32(crc, av_crc(av_crc_get_table(AV_CRC_32_IEEE_LE), U... | 5,589 |
0 | void ff_h264_direct_ref_list_init(const H264Context *const h, H264SliceContext *sl) { H264Ref *const ref1 = &sl->ref_list[1][0]; H264Picture *const cur = h->cur_pic_ptr; int list, j, field; int sidx = (h->picture_structure & 1) ^ 1; int ref1sidx = (ref1->reference & 1) ^ 1; for (list = 0; list < sl->list_count; list++)... | 5,590 |
0 | static av_cold int xvid_encode_init(AVCodecContext *avctx) { int xerr, i; int xvid_flags = avctx->flags; struct xvid_context *x = avctx->priv_data; uint16_t *intra, *inter; int fd; xvid_plugin_single_t single = { 0 }; struct xvid_ff_pass1 rc2pass1 = { 0 }; xvid_plugin_2pass2_t rc2pass2 = { 0 }; xvid_plugin_lumimasking_... | 5,591 |
0 | static inline void RENAME(yuv2packedX)(SwsContext *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t *dest, long dstW, long dstY) { #if COMPILE_TEMPLATE_MMX x86_reg dummy=0; x86_reg dstW_reg = dstW... | 5,592 |
1 | static inline int media_present(IDEState *s) { return (s->nb_sectors > 0); } | 5,593 |
1 | static void do_audio_out(AVFormatContext *s, AVOutputStream *ost, AVInputStream *ist, unsigned char *buf, int size) { uint8_t *buftmp; static uint8_t *audio_buf = NULL; static uint8_t *audio_out = NULL; const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE; int size_out, frame_bytes, ret; AVCodecContext *enc= ost->st->code... | 5,594 |
1 | int qemu_thread_is_self(QemuThread *thread) { QemuThread *this_thread = TlsGetValue(qemu_thread_tls_index); return this_thread->thread == thread->thread; } | 5,595 |
1 | static void tcx_realizefn(DeviceState *dev, Error **errp) { SysBusDevice *sbd = SYS_BUS_DEVICE(dev); TCXState *s = TCX(dev); ram_addr_t vram_offset = 0; int size, ret; uint8_t *vram_base; char *fcode_filename; memory_region_init_ram(&s->vram_mem, OBJECT(s), "tcx.vram", s->vram_size * (1 + 4 + 4), &error_abort); vmstate... | 5,597 |
1 | static int mace3_decode_frame(AVCodecContext *avctx, void *data, int *data_size, const uint8_t *buf, int buf_size) { int16_t *samples = data; MACEContext *ctx = avctx->priv_data; int i, j, k; for(i = 0; i < avctx->channels; i++) { int16_t *output = samples + i; for (j=0; j < buf_size / 2 / avctx->channels; j++) for (k=... | 5,598 |
1 | static void query_facilities(void) { struct sigaction sa_old, sa_new; register int r0 __asm__("0"); register void *r1 __asm__("1"); int fail; memset(&sa_new, 0, sizeof(sa_new)); sa_new.sa_handler = sigill_handler; sigaction(SIGILL, &sa_new, &sa_old); /* First, try STORE FACILITY LIST EXTENDED. If this is present, then ... | 5,599 |
1 | 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; /* main header */ pos=0; for(;;){ pos= find_startcode(bc, MAIN_STARTCODE, pos)+1; if (pos<0){ av_log(s, AV_LOG_ERROR, "no main startcode... | 5,600 |
0 | int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt) { int ret, flush = 0; ret = check_packet(s, pkt); if (ret < 0) goto fail; if (pkt) { AVStream *st = s->streams[pkt->stream_index]; //FIXME/XXX/HACK drop zero sized packets if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size == 0) { ret = 0; goto... | 5,602 |
0 | static av_noinline void FUNC(hl_decode_mb_444)(H264Context *h, H264SliceContext *sl) { const int mb_x = h->mb_x; const int mb_y = h->mb_y; const int mb_xy = h->mb_xy; const int mb_type = h->cur_pic.mb_type[mb_xy]; uint8_t *dest[3]; int linesize; int i, j, p; int *block_offset = &h->block_offset[0]; const int transform_... | 5,603 |
0 | static int synthfilt_build_sb_samples(QDM2Context *q, GetBitContext *gb, int length, int sb_min, int sb_max) { int sb, j, k, n, ch, run, channels; int joined_stereo, zero_encoding; int type34_first; float type34_div = 0; float type34_predictor; float samples[10]; int sign_bits[16]; if (length == 0) { // If no data use ... | 5,604 |
1 | static IsoBcSection *find_iso_bc_entry(void) { IsoBcEntry *e = (IsoBcEntry *)sec; uint32_t offset = find_iso_bc(); int i; if (!offset) { return NULL; } read_iso_sector(offset, sec, "Failed to read El Torito boot catalog"); if (!is_iso_bc_valid(e)) { /* The validation entry is mandatory */ virtio_panic("No valid boot ca... | 5,605 |
1 | static int ogg_new_stream(AVFormatContext *s, uint32_t serial, int new_avstream) { struct ogg *ogg = s->priv_data; int idx = ogg->nstreams++; AVStream *st; struct ogg_stream *os; ogg->streams = av_realloc (ogg->streams, ogg->nstreams * sizeof (*ogg->streams)); memset (ogg->streams + idx, 0, sizeof (*ogg->streams)); os ... | 5,606 |
1 | void gdb_exit(CPUArchState *env, int code) { GDBState *s; char buf[4]; s = gdbserver_state; if (!s) { return; } #ifdef CONFIG_USER_ONLY if (gdbserver_fd < 0 || s->fd < 0) { return; } #endif snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code); put_packet(s, buf); #ifndef CONFIG_USER_ONLY if (s->chr) { qemu_chr_delete(s->... | 5,608 |
1 | SCSIRequest *scsi_req_alloc(size_t size, SCSIDevice *d, uint32_t tag, uint32_t lun) { SCSIRequest *req; req = qemu_mallocz(size); /* Two references: one is passed back to the HBA, one is in d->requests. */ req->refcount = 2; req->bus = scsi_bus_from_device(d); req->dev = d; req->tag = tag; req->lun = lun; req->status =... | 5,609 |
1 | static void detach(sPAPRDRConnector *drc, DeviceState *d, spapr_drc_detach_cb *detach_cb, void *detach_cb_opaque, Error **errp) { DPRINTFN("drc: %x, detach", get_index(drc)); drc->detach_cb = detach_cb; drc->detach_cb_opaque = detach_cb_opaque; /* if we've signalled device presence to the guest, or if the guest * has g... | 5,610 |
1 | void xen_invalidate_map_cache_entry(uint8_t *buffer) { MapCacheEntry *entry = NULL, *pentry = NULL; MapCacheRev *reventry; target_phys_addr_t paddr_index; target_phys_addr_t size; int found = 0; if (mapcache->last_address_vaddr == buffer) { mapcache->last_address_index = -1; } QTAILQ_FOREACH(reventry, &mapcache->locked... | 5,612 |
1 | static void adx_decode_stereo(short *out,const unsigned char *in,PREV *prev) { short tmp[32*2]; int i; adx_decode(tmp ,in ,prev); adx_decode(tmp+32,in+18,prev+1); for(i=0;i<32;i++) { out[i*2] = tmp[i]; out[i*2+1] = tmp[i+32]; } } | 5,613 |
1 | void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque) { SaveStateEntry *se, *new_se; char id[256] = ""; if (dev && dev->parent_bus && dev->parent_bus->info->get_dev_path) { char *path = dev->parent_bus->info->get_dev_path(dev); if (path) { pstrcpy(id, sizeof(id), path); pstrcat(id, sizeof(id), "/");... | 5,614 |
1 | static void fsl_imx25_realize(DeviceState *dev, Error **errp) { FslIMX25State *s = FSL_IMX25(dev); uint8_t i; Error *err = NULL; object_property_set_bool(OBJECT(&s->cpu), true, "realized", &err); if (err) { error_propagate(errp, err); return; } object_property_set_bool(OBJECT(&s->avic), true, "realized", &err); if (err... | 5,615 |
1 | int add_av_stream(FFStream *feed, AVStream *st) { AVStream *fst; AVCodecContext *av, *av1; int i; av = &st->codec; for(i=0;i<feed->nb_streams;i++) { st = feed->streams[i]; av1 = &st->codec; if (av1->codec_id == av->codec_id && av1->codec_type == av->codec_type && av1->bit_rate == av->bit_rate) { switch(av->codec_type) ... | 5,616 |
0 | static void mov_text_new_line_cb(void *priv, int forced) { MovTextContext *s = priv; av_strlcpy(s->ptr, "\n", FFMIN(s->end - s->ptr, 2)); s->ptr++; } | 5,618 |
0 | static void pulse_get_output_timestamp(AVFormatContext *h, int stream, int64_t *dts, int64_t *wall) { PulseData *s = h->priv_data; pa_usec_t latency; int neg; pa_threaded_mainloop_lock(s->mainloop); pa_stream_get_latency(s->stream, &latency, &neg); pa_threaded_mainloop_unlock(s->mainloop); *wall = av_gettime(); *dts = ... | 5,619 |
0 | static int update_packetheader(NUTContext *nut, ByteIOContext *bc, int additional_size){ int64_t start= nut->packet_start; int64_t cur= url_ftell(bc); int size= cur - start + additional_size; if(size != nut->written_packet_size){ int i; assert( size <= nut->written_packet_size ); url_fseek(bc, nut->packet_size_pos, SEE... | 5,620 |
0 | static int build_huff(const uint8_t *src, VLC *vlc) { int i; HuffEntry he[256]; int last; uint32_t codes[256]; uint8_t bits[256]; uint8_t syms[256]; uint32_t code; for (i = 0; i < 256; i++) { he[i].sym = i; he[i].len = *src++; } qsort(he, 256, sizeof(*he), huff_cmp); if (!he[0].len || he[0].len > 32) return -1; last = ... | 5,622 |
1 | static void qemu_thread_set_name(QemuThread *thread, const char *name) { #ifdef CONFIG_PTHREAD_SETNAME_NP pthread_setname_np(thread->thread, name); #endif } | 5,623 |
1 | int ff_jpeg2000_init_component(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty, Jpeg2000QuantStyle *qntsty, int cbps, int dx, int dy, AVCodecContext *avctx) { uint8_t log2_band_prec_width, log2_band_prec_height; int reslevelno, bandno, gbandno = 0, ret, i, j; uint32_t csize = 1; if (!codsty->nreslevels2decode) { a... | 5,625 |
1 | static void icp_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); dc->vmsd = &vmstate_icp_server; dc->realize = icp_realize; } | 5,626 |
1 | static void balloon_stats_poll_cb(void *opaque) { VirtIOBalloon *s = opaque; VirtIODevice *vdev = VIRTIO_DEVICE(s); if (!balloon_stats_supported(s)) { /* re-schedule */ balloon_stats_change_timer(s, s->stats_poll_interval); return; } virtqueue_push(s->svq, s->stats_vq_elem, s->stats_vq_offset); virtio_notify(vdev, s->s... | 5,627 |
1 | void virtio_setup_block(struct subchannel_id schid) { struct vq_info_block info; struct vq_config_block config = {}; blk_cfg.blk_size = 0; /* mark "illegal" - setup started... */ guessed_disk_nature = false; virtio_reset(schid); /* * Skipping CCW_CMD_READ_FEAT. We're not doing anything fancy, and * we'll just stop dead... | 5,628 |
1 | static void test_tco1_control_bits(void) { TestData d; uint16_t val; d.args = NULL; d.noreboot = true; test_init(&d); val = TCO_LOCK; qpci_io_writew(d.dev, d.tco_io_base + TCO1_CNT, val); val &= ~TCO_LOCK; qpci_io_writew(d.dev, d.tco_io_base + TCO1_CNT, val); g_assert_cmpint(qpci_io_readw(d.dev, d.tco_io_base + TCO1_CN... | 5,629 |
1 | static void update_pam(PCII440FXState *d, uint32_t start, uint32_t end, int r, PAMMemoryRegion *mem) { if (mem->initialized) { memory_region_del_subregion(d->system_memory, &mem->mem); memory_region_destroy(&mem->mem); } // printf("ISA mapping %08x-0x%08x: %d\n", start, end, r); switch(r) { case 3: /* RAM */ memory_reg... | 5,631 |
0 | static int copy_cell(Indeo3DecodeContext *ctx, Plane *plane, Cell *cell) { int h, w, mv_x, mv_y, offset, offset_dst; uint8_t *src, *dst; /* setup output and reference pointers */ offset_dst = (cell->ypos << 2) * plane->pitch + (cell->xpos << 2); dst = plane->pixels[ctx->buf_sel] + offset_dst; mv_y = cell->mv_ptr[0]; mv... | 5,632 |
0 | int av_expr_parse(AVExpr **expr, const char *s, const char * const *const_names, const char * const *func1_names, double (* const *funcs1)(void *, double), const char * const *func2_names, double (* const *funcs2)(void *, double, double), int log_offset, void *log_ctx) { Parser p; AVExpr *e = NULL; char *w = av_malloc(... | 5,633 |
0 | static int disas_vfp_insn(DisasContext *s, uint32_t insn) { uint32_t rd, rn, rm, op, i, n, offset, delta_d, delta_m, bank_mask; int dp, veclen; TCGv_i32 addr; TCGv_i32 tmp; TCGv_i32 tmp2; if (!arm_dc_feature(s, ARM_FEATURE_VFP)) { return 1; } /* FIXME: this access check should not take precedence over UNDEF * for inval... | 5,635 |
0 | uint32_t cpu_mips_get_random (CPUMIPSState *env) { static uint32_t seed = 1; static uint32_t prev_idx = 0; uint32_t idx; /* Don't return same value twice, so get another value */ do { /* Use a simple algorithm of Linear Congruential Generator * from ISO/IEC 9899 standard. */ seed = 1103515245 * seed + 12345; idx = (see... | 5,636 |
0 | void ppc_hash64_store_hpte(PowerPCCPU *cpu, target_ulong pte_index, target_ulong pte0, target_ulong pte1) { CPUPPCState *env = &cpu->env; if (env->external_htab == MMU_HASH64_KVM_MANAGED_HPT) { kvmppc_hash64_write_pte(env, pte_index, pte0, pte1); return; } pte_index *= HASH_PTE_SIZE_64; if (env->external_htab) { stq_p(... | 5,637 |
0 | static uint64_t softusb_read(void *opaque, target_phys_addr_t addr, unsigned size) { MilkymistSoftUsbState *s = opaque; uint32_t r = 0; addr >>= 2; switch (addr) { case R_CTRL: r = s->regs[addr]; break; default: error_report("milkymist_softusb: read access to unknown register 0x" TARGET_FMT_plx, addr << 2); break; } tr... | 5,639 |
0 | GuestExec *qmp_guest_exec(const char *path, bool has_arg, strList *arg, bool has_env, strList *env, bool has_input_data, const char *input_data, bool has_capture_output, bool capture_output, Error **err) { GPid pid; GuestExec *ge = NULL; GuestExecInfo *gei; char **argv, **envp; strList arglist; gboolean ret; GError *ge... | 5,641 |
0 | static uint32_t cuda_readb(void *opaque, target_phys_addr_t addr) { CUDAState *s = opaque; uint32_t val; addr = (addr >> 9) & 0xf; switch(addr) { case 0: val = s->b; break; case 1: val = s->a; break; case 2: val = s->dirb; break; case 3: val = s->dira; break; case 4: val = get_counter(&s->timers[0]) & 0xff; s->ifr &= ~... | 5,642 |
0 | assigned_dev_msix_mmio_read(void *opaque, target_phys_addr_t addr, unsigned size) { AssignedDevice *adev = opaque; uint64_t val; memcpy(&val, (void *)((uint8_t *)adev->msix_table + addr), size); return val; } | 5,643 |
0 | void ff_jpegls_init_state(JLSState *state){ int i; state->twonear = state->near * 2 + 1; state->range = ((state->maxval + state->twonear - 1) / state->twonear) + 1; // QBPP = ceil(log2(RANGE)) for(state->qbpp = 0; (1 << state->qbpp) < state->range; state->qbpp++); if(state->bpp < 8) state->limit = 16 + 2 * state->bpp -... | 5,644 |
0 | static int rtl8139_can_receive(void *opaque) { RTL8139State *s = opaque; int avail; /* Receive (drop) packets if card is disabled. */ if (!s->clock_enabled) return 1; if (!rtl8139_receiver_enabled(s)) return 1; if (rtl8139_cp_receiver_enabled(s)) { /* ??? Flow control not implemented in c+ mode. This is a hack to work ... | 5,645 |
0 | TC6393xbState *tc6393xb_init(MemoryRegion *sysmem, uint32_t base, qemu_irq irq) { TC6393xbState *s; DriveInfo *nand; static const MemoryRegionOps tc6393xb_ops = { .read = tc6393xb_readb, .write = tc6393xb_writeb, .endianness = DEVICE_NATIVE_ENDIAN, .impl = { .min_access_size = 1, .max_access_size = 1, }, }; s = (TC6393... | 5,647 |
0 | int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs, int64_t sector_num, int nb_sectors, QEMUIOVector *qiov) { trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors); return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, BDRV_REQ_COPY_ON_READ); } | 5,649 |
0 | static void v9fs_lcreate(void *opaque) { int32_t dfid, flags, mode; gid_t gid; ssize_t err = 0; ssize_t offset = 7; V9fsString name; V9fsFidState *fidp; struct stat stbuf; V9fsQID qid; int32_t iounit; V9fsPDU *pdu = opaque; pdu_unmarshal(pdu, offset, "dsddd", &dfid, &name, &flags, &mode, &gid); trace_v9fs_lcreate(pdu->... | 5,650 |
0 | void s390_virtio_irq(S390CPU *cpu, int config_change, uint64_t token) { if (kvm_enabled()) { kvm_s390_virtio_irq(cpu, config_change, token); } else { cpu_inject_ext(cpu, EXT_VIRTIO, config_change, token); } } | 5,651 |
0 | static int aiocb_needs_copy(struct qemu_paiocb *aiocb) { if (aiocb->aio_flags & QEMU_AIO_SECTOR_ALIGNED) { int i; for (i = 0; i < aiocb->aio_niov; i++) if ((uintptr_t) aiocb->aio_iov[i].iov_base % 512) return 1; } return 0; } | 5,652 |
0 | static void virtio_net_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); PCIDeviceClass *k = PCI_DEVICE_CLASS(klass); k->init = virtio_net_init_pci; k->exit = virtio_net_exit_pci; k->romfile = "pxe-virtio.rom"; k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET; k->device_id = PCI_DEVICE_ID_... | 5,653 |
0 | static int jpg_decode_data(JPGContext *c, int width, int height, const uint8_t *src, int src_size, uint8_t *dst, int dst_stride, const uint8_t *mask, int mask_stride, int num_mbs, int swapuv) { GetBitContext gb; int mb_w, mb_h, mb_x, mb_y, i, j; int bx, by; int unesc_size; int ret; if ((ret = av_reallocp(&c->buf, src_s... | 5,654 |
0 | static inline void upmix_mono_to_stereo(AC3DecodeContext *ctx) { int i; float (*output)[256] = ctx->audio_block.block_output; for (i = 0; i < 256; i++) output[2][i] = output[1][i]; } | 5,655 |
0 | static void gen_flt3_arith (DisasContext *ctx, uint32_t opc, int fd, int fr, int fs, int ft) { const char *opn = "flt3_arith"; /* All of those work only on 64bit FPUs. */ gen_op_cp1_64bitmode(); switch (opc) { case OPC_ALNV_PS: GEN_LOAD_REG_TN(T0, fr); GEN_LOAD_FREG_FTN(DT0, fs); GEN_LOAD_FREG_FTN(DT1, ft); gen_op_floa... | 5,656 |
0 | static int v9fs_do_lstat(V9fsState *s, V9fsString *path, struct stat *stbuf) { return s->ops->lstat(&s->ctx, path->data, stbuf); } | 5,657 |
0 | static void test_source_timer_schedule(void) { TimerTestData data = { .n = 0, .ctx = ctx, .ns = SCALE_MS * 750LL, .max = 2, .clock_type = QEMU_CLOCK_VIRTUAL }; int pipefd[2]; int64_t expiry; /* aio_poll will not block to wait for timers to complete unless it has * an fd to wait on. Fixing this breaks other tests. So cr... | 5,658 |
0 | static void xenfv_machine_options(MachineClass *m) { pc_common_machine_options(m); m->desc = "Xen Fully-virtualized PC"; m->max_cpus = HVM_MAX_VCPUS; m->default_machine_opts = "accel=xen"; m->hot_add_cpu = pc_hot_add_cpu; } | 5,659 |
0 | static CharDriverState *qemu_chr_open_socket(QemuOpts *opts) { CharDriverState *chr = NULL; TCPCharDriver *s = NULL; int fd = -1; int is_listen; int is_waitconnect; int do_nodelay; int is_unix; int is_telnet; is_listen = qemu_opt_get_bool(opts, "server", 0); is_waitconnect = qemu_opt_get_bool(opts, "wait", 1); is_telne... | 5,661 |
0 | static void vfio_enable_intx_kvm(VFIODevice *vdev) { #ifdef CONFIG_KVM struct kvm_irqfd irqfd = { .fd = event_notifier_get_fd(&vdev->intx.interrupt), .gsi = vdev->intx.route.irq, .flags = KVM_IRQFD_FLAG_RESAMPLE, }; struct vfio_irq_set *irq_set; int ret, argsz; int32_t *pfd; if (!kvm_irqfds_enabled() || vdev->intx.rout... | 5,662 |
0 | static inline void tcg_out_rld(TCGContext *s, int op, TCGReg ra, TCGReg rs, int sh, int mb) { assert(TCG_TARGET_REG_BITS == 64); sh = SH(sh & 0x1f) | (((sh >> 5) & 1) << 1); mb = MB64((mb >> 5) | ((mb << 1) & 0x3f)); tcg_out32(s, op | RA(ra) | RS(rs) | sh | mb); } | 5,663 |
0 | static int opt_list(void *obj, void *av_log_obj, char *unit) { AVOption *opt=NULL; while((opt= av_next_option(obj, opt))){ if(!(opt->flags & (AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM))) continue; /* Don't print CONST's on level one. * Don't print anything but CONST's on level two. * Only print items from t... | 5,664 |
0 | static int set_dirty_tracking(void) { BlkMigDevState *bmds; int ret; QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) { bmds->dirty_bitmap = bdrv_create_dirty_bitmap(bmds->bs, BLOCK_SIZE, NULL); if (!bmds->dirty_bitmap) { ret = -errno; goto fail; } } return 0; fail: QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds... | 5,665 |
0 | static void cmd_prevent_allow_medium_removal(IDEState *s, uint8_t* buf) { s->tray_locked = buf[4] & 1; bdrv_lock_medium(s->bs, buf[4] & 1); ide_atapi_cmd_ok(s); } | 5,667 |
0 | void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size) { int l; while (size > 0) { l = IO_BUF_SIZE - f->buf_index; if (l > size) l = size; memcpy(f->buf + f->buf_index, buf, l); f->buf_index += l; buf += l; size -= l; if (f->buf_index >= IO_BUF_SIZE) qemu_fflush(f); } } | 5,668 |
0 | void cpu_exec_init_all(void) { #if !defined(CONFIG_USER_ONLY) qemu_mutex_init(&ram_list.mutex); memory_map_init(); io_mem_init(); #endif } | 5,669 |
0 | static void create_fw_cfg(const VirtBoardInfo *vbi, AddressSpace *as) { hwaddr base = vbi->memmap[VIRT_FW_CFG].base; hwaddr size = vbi->memmap[VIRT_FW_CFG].size; char *nodename; fw_cfg_init_mem_wide(base + 8, base, 8, base + 16, as); nodename = g_strdup_printf("/fw-cfg@%" PRIx64, base); qemu_fdt_add_subnode(vbi->fdt, n... | 5,671 |
0 | int av_file_map(const char *filename, uint8_t **bufptr, size_t *size, int log_offset, void *log_ctx) { FileLogContext file_log_ctx = { &file_log_ctx_class, log_offset, log_ctx }; int err, fd = open(filename, O_RDONLY); struct stat st; av_unused void *ptr; off_t off_size; char errbuf[128]; *bufptr = NULL; if (fd < 0) { ... | 5,675 |
0 | static void tcg_out_brcond_i32(TCGContext *s, TCGCond cond, TCGReg arg1, int32_t arg2, int const_arg2, int label) { tcg_out_cmp(s, arg1, arg2, const_arg2); tcg_out_bpcc(s, tcg_cond_to_bcond[cond], BPCC_ICC | BPCC_PT, label); tcg_out_nop(s); } | 5,677 |
0 | static void test_flush(void) { AHCIQState *ahci; ahci = ahci_boot_and_enable(); ahci_test_flush(ahci); ahci_shutdown(ahci); } | 5,678 |
0 | static void xtensa_lx200_init(MachineState *machine) { static const LxBoardDesc lx200_board = { .flash_base = 0xf8000000, .flash_size = 0x01000000, .flash_sector_size = 0x20000, .sram_size = 0x2000000, }; lx_init(&lx200_board, machine); } | 5,679 |
0 | static inline TCGv *compute_ldst_addr(DisasContext *dc, TCGv *t) { unsigned int extimm = dc->tb_flags & IMM_FLAG; /* Should be set to one if r1 is used by loadstores. */ int stackprot = 0; /* All load/stores use ra. */ if (dc->ra == 1) { stackprot = 1; } /* Treat the common cases first. */ if (!dc->type_b) { /* If any ... | 5,680 |
0 | static void decode_32Bit_opc(CPUTriCoreState *env, DisasContext *ctx) { int op1; int32_t r1, r2, r3; int32_t address, const16; int8_t b, const4; int32_t bpos; TCGv temp, temp2, temp3; op1 = MASK_OP_MAJOR(ctx->opcode); /* handle JNZ.T opcode only being 6 bit long */ if (unlikely((op1 & 0x3f) == OPCM_32_BRN_JTT)) { op1 =... | 5,681 |
0 | static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg1, intptr_t arg2) { uint8_t *old_code_ptr = s->code_ptr; if (type == TCG_TYPE_I32) { tcg_out_op_t(s, INDEX_op_ld_i32); tcg_out_r(s, ret); tcg_out_r(s, arg1); tcg_out32(s, arg2); } else { assert(type == TCG_TYPE_I64); #if TCG_TARGET_REG_BITS == 64... | 5,683 |
0 | static bool s390_cpu_has_work(CPUState *cs) { S390CPU *cpu = S390_CPU(cs); CPUS390XState *env = &cpu->env; return (cs->interrupt_request & CPU_INTERRUPT_HARD) && (env->psw.mask & PSW_MASK_EXT); } | 5,684 |
0 | static ssize_t qemu_enqueue_packet_iov(VLANClientState *sender, const struct iovec *iov, int iovcnt, NetPacketSent *sent_cb) { VLANPacket *packet; size_t max_len = 0; int i; max_len = calc_iov_length(iov, iovcnt); packet = qemu_malloc(sizeof(VLANPacket) + max_len); packet->sender = sender; packet->sent_cb = sent_cb; pa... | 5,685 |
0 | static void sm501_palette_write(void *opaque, target_phys_addr_t addr, uint32_t value) { SM501State * s = (SM501State *)opaque; SM501_DPRINTF("sm501 palette write addr=%x, val=%x\n", (int)addr, value); /* TODO : consider BYTE/WORD access */ /* TODO : consider endian */ assert(0 <= addr && addr < 0x400 * 3); *(uint32_t*... | 5,686 |
0 | static int qemu_gluster_open(BlockDriverState *bs, QDict *options, int bdrv_flags, Error **errp) { BDRVGlusterState *s = bs->opaque; int open_flags = O_BINARY; int ret = 0; GlusterConf *gconf = g_malloc0(sizeof(GlusterConf)); QemuOpts *opts; Error *local_err = NULL; const char *filename; opts = qemu_opts_create(&runtim... | 5,687 |
0 | static int draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir) { AVFilterContext *ctx = inlink->dst; TileContext *tile = ctx->priv; AVFilterLink *outlink = ctx->outputs[0]; unsigned x0, y0; get_current_tile_pos(ctx, &x0, &y0); ff_copy_rectangle2(&tile->draw, outlink->out_buf->data, outlink->out_buf->linesize,... | 5,688 |
0 | static int disas_vfp_insn(CPUState * env, DisasContext *s, uint32_t insn) { uint32_t rd, rn, rm, op, i, n, offset, delta_d, delta_m, bank_mask; int dp, veclen; TCGv addr; TCGv tmp; TCGv tmp2; if (!arm_feature(env, ARM_FEATURE_VFP)) return 1; if (!s->vfp_enabled) { /* VFP disabled. Only allow fmxr/fmrx to/from some cont... | 5,689 |
0 | void cpu_check_irqs(CPUState *env) { uint32_t pil = env->pil_in | (env->softint & ~SOFTINT_TIMER) | ((env->softint & SOFTINT_TIMER) << 14); if (pil && (env->interrupt_index == 0 || (env->interrupt_index & ~15) == TT_EXTINT)) { unsigned int i; for (i = 15; i > 0; i--) { if (pil & (1 << i)) { int old_interrupt = env->int... | 5,690 |
0 | static int default_fdset_dup_fd_find(int dup_fd) { return -1; } | 5,691 |
0 | static void t_gen_muls(TCGv d, TCGv d2, TCGv a, TCGv b) { TCGv t0, t1; t0 = tcg_temp_new(TCG_TYPE_I64); t1 = tcg_temp_new(TCG_TYPE_I64); tcg_gen_ext32s_i64(t0, a); tcg_gen_ext32s_i64(t1, b); tcg_gen_mul_i64(t0, t0, t1); tcg_gen_trunc_i64_i32(d, t0); tcg_gen_shri_i64(t0, t0, 32); tcg_gen_trunc_i64_i32(d2, t0); tcg_temp_... | 5,692 |
0 | static void vnc_client_write(void *opaque) { long ret; VncState *vs = opaque; #ifdef CONFIG_VNC_TLS if (vs->tls_session) { ret = gnutls_write(vs->tls_session, vs->output.buffer, vs->output.offset); if (ret < 0) { if (ret == GNUTLS_E_AGAIN) errno = EAGAIN; else errno = EIO; ret = -1; } } else #endif /* CONFIG_VNC_TLS */... | 5,693 |
0 | static void test_drive_del_device_del(void) { /* Start with a drive used by a device that unplugs instantaneously */ qtest_start("-drive if=none,id=drive0,file=null-co://,format=raw" " -device virtio-scsi-pci" " -device scsi-hd,drive=drive0,id=dev0"); /* * Delete the drive, and then the device * Doing it in this order ... | 5,695 |
0 | static void omap_uwire_write(void *opaque, target_phys_addr_t addr, uint64_t value, unsigned size) { struct omap_uwire_s *s = (struct omap_uwire_s *) opaque; int offset = addr & OMAP_MPUI_REG_MASK; if (size != 2) { return omap_badwidth_write16(opaque, addr, value); } switch (offset) { case 0x00: /* TDR */ s->txbuf = va... | 5,696 |
0 | static inline void _t_gen_mov_env_TN(int offset, TCGv tn) { if (offset > sizeof(CPUCRISState)) { fprintf(stderr, "wrong store to env at off=%d\n", offset); } tcg_gen_st_tl(tn, cpu_env, offset); } | 5,697 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.