label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | static void ide_atapi_cmd_read_dma(IDEState *s, int lba, int nb_sectors, int sector_size){ s->lba = lba; s->packet_transfer_size = nb_sectors * sector_size; s->io_buffer_index = 0; s->io_buffer_size = 0; s->cd_sector_size = sector_size; block_acct_start(bdrv_get_stats(s->bs), &s->acct, s->packet_transfer_size, BLOCK_AC... |
0 | void qed_acquire(BDRVQEDState *s){ aio_context_acquire(bdrv_get_aio_context(s->bs));} |
0 | static int qemu_rdma_post_send_control(RDMAContext *rdma, uint8_t *buf, RDMAControlHeader *head){ int ret = 0; RDMAWorkRequestData *wr = &rdma->wr_data[RDMA_WRID_CONTROL]; struct ibv_send_wr *bad_wr; struct ibv_sge sge = { .addr = (uint64_t)(wr->control), .length = head->len + sizeof(RDMAControlHeader), .lkey = wr->con... |
0 | static int hdev_open(BlockDriverState *bs, QDict *options, int flags, Error **errp){ BDRVRawState *s = bs->opaque; Error *local_err = NULL; int ret;#if defined(__APPLE__) && defined(__MACH__) const char *filename = qdict_get_str(options, "filename"); if (strstart(filename, "/dev/cdrom", NULL)) { kern_return_t kernResul... |
0 | static void pc_init1(MachineState *machine, int pci_enabled, int kvmclock_enabled){ PCMachineState *pc_machine = PC_MACHINE(machine); MemoryRegion *system_memory = get_system_memory(); MemoryRegion *system_io = get_system_io(); int i; ram_addr_t below_4g_mem_size, above_4g_mem_size; PCIBus *pci_bus; ISABus *isa_bus; PC... |
0 | static void qpci_spapr_io_writel(QPCIBus *bus, void *addr, uint32_t value){ QPCIBusSPAPR *s = container_of(bus, QPCIBusSPAPR, bus); uint64_t port = (uintptr_t)addr; value = bswap32(value); if (port < s->pio.size) { writel(s->pio_cpu_base + port, value); } else { writel(s->mmio_cpu_base + port, value); }} |
0 | static int get_char(GDBState *s){ uint8_t ch; int ret; for(;;) { ret = qemu_recv(s->fd, &ch, 1, 0); if (ret < 0) { if (errno == ECONNRESET) s->fd = -1; if (errno != EINTR && errno != EAGAIN) return -1; } else if (ret == 0) { close(s->fd); s->fd = -1; return -1; } else { break; } } return ch;} |
0 | static void gen_ldda_asi(DisasContext *dc, TCGv hi, TCGv addr, int insn, int rd){ TCGv_i32 r_asi, r_rd; r_asi = gen_get_asi(dc, insn); r_rd = tcg_const_i32(rd); gen_helper_ldda_asi(cpu_env, addr, r_asi, r_rd); tcg_temp_free_i32(r_rd); tcg_temp_free_i32(r_asi);} |
0 | static int kvm_sclp_service_call(CPUS390XState *env, struct kvm_run *run, uint16_t ipbh0){ uint32_t sccb; uint64_t code; int r = 0; cpu_synchronize_state(env); sccb = env->regs[ipbh0 & 0xf]; code = env->regs[(ipbh0 & 0xf0) >> 4]; r = sclp_service_call(env, sccb, code); if (r) { setcc(env, 3); } return 0;} |
0 | void av_log_format_line(void *ptr, int level, const char *fmt, va_list vl, char *line, int line_size, int *print_prefix){ AVBPrint part[4]; format_line(ptr, level, fmt, vl, part, print_prefix, NULL); snprintf(line, line_size, "%s%s%s%s", part[0].str, part[1].str, part[2].str, part[3].str); av_bprint_finalize(part+3, NU... |
0 | void do_raise_exception_err (uint32_t exception, int error_code){#if 0 printf("Raise exception %3x code : %d\n", exception, error_code);#endif switch (exception) { case EXCP_PROGRAM: if (error_code == EXCP_FP && msr_fe0 == 0 && msr_fe1 == 0) return; break; default: break; } env->exception_index = exception; env->error_... |
0 | static AddressSpace *virtio_pci_get_dma_as(DeviceState *d){ VirtIOPCIProxy *proxy = VIRTIO_PCI(d); PCIDevice *dev = &proxy->pci_dev; return pci_get_address_space(dev);} |
0 | static int pte32_check (mmu_ctx_t *ctx, target_ulong pte0, target_ulong pte1, int h, int rw){ return _pte_check(ctx, 0, pte0, pte1, h, rw);} |
0 | static void x86_cpu_class_check_missing_features(X86CPUClass *xcc, strList **missing_feats){ X86CPU *xc; FeatureWord w; Error *err = NULL; strList **next = missing_feats; if (xcc->kvm_required && !kvm_enabled()) { strList *new = g_new0(strList, 1); new->value = g_strdup("kvm");; *missing_feats = new; return; } xc = X86... |
0 | int bdrv_flush(BlockDriverState *bs){ Coroutine *co; RwCo rwco = { .bs = bs, .ret = NOT_DONE, }; if (qemu_in_coroutine()) { /* Fast-path if already in coroutine context */ bdrv_flush_co_entry(&rwco); } else { AioContext *aio_context = bdrv_get_aio_context(bs); co = qemu_coroutine_create(bdrv_flush_co_entry); qemu_corou... |
0 | void qmp_nbd_server_start(SocketAddressLegacy *addr, bool has_tls_creds, const char *tls_creds, Error **errp){ if (nbd_server) { error_setg(errp, "NBD server already running"); return; } nbd_server = g_new0(NBDServerData, 1); nbd_server->watch = -1; nbd_server->listen_ioc = qio_channel_socket_new(); qio_channel_set_nam... |
0 | vubr_backend_recv_cb(int sock, void *ctx){ VubrDev *vubr = (VubrDev *) ctx; VuDev *dev = &vubr->vudev; VuVirtq *vq = vu_get_queue(dev, 0); VuVirtqElement *elem = NULL; struct iovec mhdr_sg[VIRTQUEUE_MAX_SIZE]; struct virtio_net_hdr_mrg_rxbuf mhdr; unsigned mhdr_cnt = 0; int hdrlen = vubr->hdrlen; int i = 0; struct virt... |
0 | int ff_j2k_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, csize = 1; if (ret=ff_jpeg2000_dwt_init(&comp->dwt, comp->coo... |
0 | static av_always_inline void blend_image_packed_rgb(AVFilterContext *ctx, AVFrame *dst, const AVFrame *src, int main_has_alpha, int x, int y, int is_straight){ OverlayContext *s = ctx->priv; int i, imax, j, jmax; const int src_w = src->width; const int src_h = src->height; const int dst_w = dst->width; const int dst_h ... |
1 | static int qemu_rdma_exchange_send(RDMAContext *rdma, RDMAControlHeader *head, uint8_t *data, RDMAControlHeader *resp, int *resp_idx, int (*callback)(RDMAContext *rdma)){ int ret = 0; /* * Wait until the dest is ready before attempting to deliver the message * by waiting for a READY message. */ if (rdma->control_ready_... |
1 | static int configure_accelerator(void){ const char *p = NULL; char buf[10]; int i, ret; bool accel_initialised = false; bool init_failed = false; QemuOptsList *list = qemu_find_opts("machine"); if (!QTAILQ_EMPTY(&list->head)) { p = qemu_opt_get(QTAILQ_FIRST(&list->head), "accel"); } if (p == NULL) { /* Use the default ... |
1 | void qemu_chr_add_handlers(CharDriverState *s, IOCanReadHandler *fd_can_read, IOReadHandler *fd_read, IOEventHandler *fd_event, void *opaque){ if (!opaque) { /* chr driver being released. */ s->assigned = 0; } s->chr_can_read = fd_can_read; s->chr_read = fd_read; s->chr_event = fd_event; s->handler_opaque = opaque; if ... |
1 | static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block, uint8_t *last_nnz, int ac_index, int16_t *quant_matrix, int ss, int se, int Al, int *EOBRUN){ int code, i = ss, j, sign, val, run; int last = FFMIN(se, *last_nnz); OPEN_READER(re, &s->gb); if (*EOBRUN) { (*EOBRUN)--; } else { for (; ; i++) { UPDA... |
1 | int ff_mov_lang_to_iso639(int code, char *to){ int i; /* is it the mangled iso code? */ /* see http://www.geocities.com/xhelmboyx/quicktime/formats/mp4-layout.txt */ if (code > 138) { for (i = 2; i >= 0; i--) { to[i] = 0x60 + (code & 0x1f); code >>= 5; } return 1; } /* old fashion apple lang code */ if (code >= FF_ARRA... |
1 | static void ohci_sysbus_class_init(ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS(klass); dc->realize = ohci_realize_pxa; set_bit(DEVICE_CATEGORY_USB, dc->categories); dc->desc = "OHCI USB Controller"; dc->props = ohci_sysbus_properties; dc->reset = usb_ohci_reset_sysbus;} |
0 | av_cold void ff_vp3dsp_init_x86(VP3DSPContext *c, int flags){#if HAVE_YASM int cpuflags = av_get_cpu_flags();#if ARCH_X86_32 if (HAVE_MMX && cpuflags & AV_CPU_FLAG_MMX) { c->idct_put = ff_vp3_idct_put_mmx; c->idct_add = ff_vp3_idct_add_mmx; c->idct_perm = FF_PARTTRANS_IDCT_PERM; }#endif if (HAVE_MMXEXT && cpuflags & AV... |
0 | void memory_region_init(MemoryRegion *mr, const char *name, uint64_t size){ mr->ops = NULL; mr->parent = NULL; mr->size = int128_make64(size); if (size == UINT64_MAX) { mr->size = int128_2_64(); } mr->addr = 0; mr->subpage = false; mr->enabled = true; mr->terminates = false; mr->ram = false; mr->romd_mode = true; mr->r... |
0 | float64 helper_sub_cmpf64(CPUM68KState *env, float64 src0, float64 src1){ /* ??? This may incorrectly raise exceptions. */ /* ??? Should flush denormals to zero. */ float64 res; res = float64_sub(src0, src1, &env->fp_status); if (float64_is_nan(res)) { /* +/-inf compares equal against itself, but sub returns nan. */ if... |
0 | bool write_list_to_kvmstate(ARMCPU *cpu){ CPUState *cs = CPU(cpu); int i; bool ok = true; for (i = 0; i < cpu->cpreg_array_len; i++) { struct kvm_one_reg r; uint64_t regidx = cpu->cpreg_indexes[i]; uint32_t v32; int ret; r.id = regidx; switch (regidx & KVM_REG_SIZE_MASK) { case KVM_REG_SIZE_U32: v32 = cpu->cpreg_values... |
0 | static void do_mchk_interrupt(CPUS390XState *env){ S390CPU *cpu = s390_env_get_cpu(env); uint64_t mask, addr; LowCore *lowcore; MchkQueue *q; int i; if (!(env->psw.mask & PSW_MASK_MCHECK)) { cpu_abort(CPU(cpu), "Machine check w/o mchk mask\n"); } if (env->mchk_index < 0 || env->mchk_index >= MAX_MCHK_QUEUE) { cpu_abort... |
0 | static void bochs_bios_init(void){ void *fw_cfg; uint8_t *smbios_table; size_t smbios_len; uint64_t *numa_fw_cfg; int i, j; register_ioport_write(0x400, 1, 2, bochs_bios_write, NULL); register_ioport_write(0x401, 1, 2, bochs_bios_write, NULL); register_ioport_write(0x402, 1, 1, bochs_bios_write, NULL); register_ioport_... |
0 | check_host_key_hash(BDRVSSHState *s, const char *hash, int hash_type, size_t fingerprint_len){ const char *fingerprint; fingerprint = libssh2_hostkey_hash(s->session, hash_type); if (!fingerprint) { session_error_report(s, "failed to read remote host key"); return -EINVAL; } if(compare_fingerprint((unsigned char *) fin... |
0 | static uint64_t get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate, int compressed_size, int n_start, int n_end){ BDRVQcowState *s = bs->opaque; int min_index, i, j, l1_index, l2_index; uint64_t l2_offset, *l2_table, cluster_offset, tmp; uint32_t min_count; int new_l2_table; l1_index = offset >> (s-... |
0 | static int decode_hrd(VC9Context *v, GetBitContext *gb){ int i, num; num = get_bits(gb, 5); if (v->hrd_rate || num != v->hrd_num_leaky_buckets) { av_freep(&v->hrd_rate); } if (!v->hrd_rate) v->hrd_rate = av_malloc(num); if (!v->hrd_rate) return -1; if (v->hrd_buffer || num != v->hrd_num_leaky_buckets) { av_freep(&v->hr... |
0 | static int handle_utimensat(FsContext *ctx, V9fsPath *fs_path, const struct timespec *buf){ int fd, ret; struct handle_data *data = (struct handle_data *)ctx->private; fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK); if (fd < 0) { return fd; } ret = futimens(fd, buf); close(fd); return ret;} |
0 | int kqemu_cpu_exec(CPUState *env){ struct kqemu_cpu_state kcpu_state, *kenv = &kcpu_state; int ret, cpl, i;#ifdef CONFIG_PROFILER int64_t ti;#endif#ifdef _WIN32 DWORD temp;#endif#ifdef CONFIG_PROFILER ti = profile_getclock();#endif LOG_INT("kqemu: cpu_exec: enter\n"); LOG_INT_STATE(env); for(i = 0; i < CPU_NB_REGS; i++... |
0 | static void cpu_handle_ioreq(void *opaque){ XenIOState *state = opaque; ioreq_t *req = cpu_get_ioreq(state); handle_buffered_iopage(state); if (req) { handle_ioreq(state, req); if (req->state != STATE_IOREQ_INPROCESS) { fprintf(stderr, "Badness in I/O request ... not in service?!: " "%x, ptr: %x, port: %"PRIx64", " "da... |
0 | int float64_is_nan( float64 a1 ){ float64u u; uint64_t a; u.f = a1; a = u.i; return ( LIT64( 0xFFF0000000000000 ) < (bits64) ( a<<1 ) );} |
0 | uint32_t helper_efdctsf (uint64_t val){ CPU_DoubleU u; float64 tmp; u.ll = val; /* NaN are not treated the same way IEEE 754 does */ if (unlikely(float64_is_nan(u.d))) return 0; tmp = uint64_to_float64(1ULL << 32, &env->vec_status); u.d = float64_mul(u.d, tmp, &env->vec_status); return float64_to_int32(u.d, &env->vec_s... |
0 | static void char_socket_class_init(ObjectClass *oc, void *data){ ChardevClass *cc = CHARDEV_CLASS(oc); cc->parse = qemu_chr_parse_socket; cc->open = qmp_chardev_open_socket; cc->chr_wait_connected = tcp_chr_wait_connected; cc->chr_write = tcp_chr_write; cc->chr_sync_read = tcp_chr_sync_read; cc->chr_disconnect = tcp_ch... |
0 | static void hb_regs_write(void *opaque, hwaddr offset, uint64_t value, unsigned size){ uint32_t *regs = opaque; if (offset == 0xf00) { if (value == 1 || value == 2) { qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET); } else if (value == 3) { qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN); } } regs[off... |
0 | static bool fw_cfg_ctl_mem_valid(void *opaque, target_phys_addr_t addr, unsigned size, bool is_write){ return is_write && size == 2;} |
0 | static ssize_t net_socket_receive(NetClientState *nc, const uint8_t *buf, size_t size){ NetSocketState *s = DO_UPCAST(NetSocketState, nc, nc); uint32_t len; len = htonl(size); send_all(s->fd, (const uint8_t *)&len, sizeof(len)); return send_all(s->fd, buf, size);} |
0 | static SocketAddress *nbd_config(BDRVNBDState *s, QDict *options, Error **errp){ SocketAddress *saddr = NULL; QDict *addr = NULL; QObject *crumpled_addr = NULL; Visitor *iv = NULL; Error *local_err = NULL; qdict_extract_subqdict(options, &addr, "server."); if (!qdict_size(addr)) { error_setg(errp, "NBD server address m... |
0 | static int local_mkdir(FsContext *ctx, const char *path, mode_t mode){ return mkdir(rpath(ctx, path), mode);} |
0 | static int vnc_client_io_error(VncState *vs, int ret, int last_errno){ if (ret == 0 || ret == -1) { if (ret == -1) { switch (last_errno) { case EINTR: case EAGAIN:#ifdef _WIN32 case WSAEWOULDBLOCK:#endif return 0; default: break; } }VNC_DEBUG("Closing down client sock %d %d\n", ret, ret < 0 ? last_errno : 0);qemu_set_f... |
0 | static void qemu_event_increment(void){ /* Write 8 bytes to be compatible with eventfd. */ static const uint64_t val = 1; ssize_t ret; if (io_thread_fd == -1) return; do { ret = write(io_thread_fd, &val, sizeof(val)); } while (ret < 0 && errno == EINTR); /* EAGAIN is fine, a read must be pending. */ if (ret < 0 && errn... |
0 | static uint64_t mv88w8618_wlan_read(void *opaque, target_phys_addr_t offset, unsigned size){ switch (offset) { /* Workaround to allow loading the binary-only wlandrv.ko crap * from the original Freecom firmware. */ case MP_WLAN_MAGIC1: return ~3; case MP_WLAN_MAGIC2: return -1; default: return 0; }} |
0 | static av_cold int oggvorbis_encode_close(AVCodecContext *avccontext){ OggVorbisContext *context = avccontext->priv_data;/* ogg_packet op ; */ vorbis_analysis_wrote(&context->vd, 0); /* notify vorbisenc this is EOF */ vorbis_block_clear(&context->vb); vorbis_dsp_clear(&context->vd); vorbis_info_clear(&context->vi); av_... |
0 | static int dxtory_decode_v2_565(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size, int is_565){ GetByteContext gb; GetBitContext gb2; int nslices, slice, slice_height; uint32_t off, slice_size; uint8_t *dst; int ret; bytestream2_init(&gb, src, src_size); nslices = bytestream2_get_le16(&gb); off = FF... |
1 | static void gen_icread(DisasContext *ctx){#if defined(CONFIG_USER_ONLY) gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);#else if (unlikely(ctx->pr)) { gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC); return; } /* interpreted as no-op */#endif} |
1 | static inline void RENAME(rgb32to16)(const uint8_t *src, uint8_t *dst, long src_size){const uint8_t *s = src;const uint8_t *end;#ifdef HAVE_MMXconst uint8_t *mm_end;#endifuint16_t *d = (uint16_t *)dst;end = s + src_size;#ifdef HAVE_MMXmm_end = end - 15;#if 1 //is faster only if multiplies are reasonable fast (FIXME fig... |
1 | static void print_formats(AVFilterContext *filter_ctx){ int i, j;#define PRINT_FMTS(inout, outin, INOUT) \ for (i = 0; i < filter_ctx->nb_##inout##puts; i++) { \ if (filter_ctx->inout##puts[i]->type == AVMEDIA_TYPE_VIDEO) { \ AVFilterFormats *fmts = \ filter_ctx->inout##puts[i]->outin##_formats; \ for (j = 0; j < fmts-... |
1 | static void imx6_defer_clear_reset_bit(int cpuid, IMX6SRCState *s, unsigned long reset_shift){ struct SRCSCRResetInfo *ri; ri = g_malloc(sizeof(struct SRCSCRResetInfo)); ri->s = s; ri->reset_bit = reset_shift; async_run_on_cpu(arm_get_cpu_by_id(cpuid), imx6_clear_reset_bit, RUN_ON_CPU_HOST_PTR(ri));} |
1 | static void fsl_imx6_realize(DeviceState *dev, Error **errp){ FslIMX6State *s = FSL_IMX6(dev); uint16_t i; Error *err = NULL; for (i = 0; i < smp_cpus; i++) { /* On uniprocessor, the CBAR is set to 0 */ if (smp_cpus > 1) { object_property_set_int(OBJECT(&s->cpu[i]), FSL_IMX6_A9MPCORE_ADDR, "reset-cbar", &error_abort); ... |
1 | static int hls_slice_data_wpp(HEVCContext *s, const uint8_t *nal, int length){ HEVCLocalContext *lc = s->HEVClc; int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int)); int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int)); int offset; int startheader, cmpt = 0; int i, j, res = ... |
1 | ssize_t v9fs_iov_vunmarshal(struct iovec *out_sg, int out_num, size_t offset, int bswap, const char *fmt, va_list ap){ int i; ssize_t copied = 0; size_t old_offset = offset; for (i = 0; fmt[i]; i++) { switch (fmt[i]) { case 'b': { uint8_t *valp = va_arg(ap, uint8_t *); copied = v9fs_unpack(valp, out_sg, out_num, offset... |
0 | static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride){ const int index = size2index[log2h][log2w]; const int h = 1 << log2h; int code = get_vlc2(&f->gb, block_type_vlc[1 - (f->version > 1)][index].table, BLOCK_TYPE_VLC_BITS, 1); uint16_t *start = (uint16_t *)f->last... |
0 | static void generate_coupling_coordinates(AC3DecodeContext * ctx){ ac3_audio_block *ab = &ctx->audio_block; uint8_t exp, mstrcplco; int16_t mant; uint32_t cplbndstrc = (1 << ab->ncplsubnd) >> 1; int ch, bnd, sbnd; float cplco; if (ab->cplcoe) for (ch = 0; ch < ctx->bsi.nfchans; ch++) if (ab->cplcoe & (1 << ch)) { mstrc... |
0 | static void usb_serial_event(void *opaque, int event){ USBSerialState *s = opaque; switch (event) { case CHR_EVENT_BREAK: s->event_trigger |= FTDI_BI; break; case CHR_EVENT_FOCUS: break; case CHR_EVENT_OPENED: usb_serial_reset(s); /* TODO: Reset USB port */ break; }} |
0 | static void gen_exception(DisasContext *s, int trapno, target_ulong cur_eip){ gen_update_cc_op(s); gen_jmp_im(cur_eip); gen_helper_raise_exception(cpu_env, tcg_const_i32(trapno)); s->is_jmp = DISAS_TB_JUMP;} |
0 | uint32_t helper_efdctsiz (uint64_t val){ CPU_DoubleU u; u.ll = val; /* NaN are not treated the same way IEEE 754 does */ if (unlikely(float64_is_nan(u.d))) return 0; return float64_to_int32_round_to_zero(u.d, &env->vec_status);} |
0 | static inline uint32_t reloc_pc16_val(tcg_insn_unit *pc, tcg_insn_unit *target){ /* Let the compiler perform the right-shift as part of the arithmetic. */ ptrdiff_t disp = target - (pc + 1); assert(disp == (int16_t)disp); return disp & 0xffff;} |
0 | static int update_streams_from_subdemuxer(AVFormatContext *s, struct playlist *pls){ while (pls->n_main_streams < pls->ctx->nb_streams) { int ist_idx = pls->n_main_streams; AVStream *st = avformat_new_stream(s, NULL); AVStream *ist = pls->ctx->streams[ist_idx]; if (!st) return AVERROR(ENOMEM); st->id = pls->index; set_... |
0 | static uint16_t pxb_bus_numa_node(PCIBus *bus){ PXBDev *pxb = PXB_DEV(bus->parent_dev); return pxb->numa_node;} |
0 | void ptimer_run(ptimer_state *s, int oneshot){ bool was_disabled = !s->enabled; if (was_disabled && s->period == 0) { fprintf(stderr, "Timer with period zero, disabling\n"); return; } s->enabled = oneshot ? 2 : 1; if (was_disabled) { s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL); ptimer_reload(s); }} |
0 | static uint16_t reloc_pc14_val(tcg_insn_unit *pc, tcg_insn_unit *target){ ptrdiff_t disp = tcg_ptr_byte_diff(target, pc); assert(disp == (int16_t) disp); return disp & 0xfffc;} |
0 | static void qemu_sgl_init_external(VirtIOSCSIReq *req, struct iovec *sg, hwaddr *addr, int num){ QEMUSGList *qsgl = &req->qsgl; qemu_sglist_init(qsgl, DEVICE(req->dev), num, &address_space_memory); while (num--) { qemu_sglist_add(qsgl, *(addr++), (sg++)->iov_len); }} |
0 | bool vring_setup(Vring *vring, VirtIODevice *vdev, int n){ hwaddr vring_addr = virtio_queue_get_ring_addr(vdev, n); hwaddr vring_size = virtio_queue_get_ring_size(vdev, n); void *vring_ptr; vring->broken = false; hostmem_init(&vring->hostmem); vring_ptr = hostmem_lookup(&vring->hostmem, vring_addr, vring_size, true); i... |
0 | static uint32_t drc_set_usable(sPAPRDRConnector *drc){ /* if there's no resource/device associated with the DRC, there's * no way for us to put it in an allocation state consistent with * being 'USABLE'. PAPR 2.7, 13.5.3.4 documents that this should * result in an RTAS return code of -3 / "no such indicator" */ if (!dr... |
0 | static uint32_t gt64120_readl (void *opaque, target_phys_addr_t addr){ GT64120State *s = opaque; uint32_t val; uint32_t saddr; val = 0; saddr = (addr & 0xfff) >> 2; switch (saddr) { /* CPU Configuration */ case GT_MULTI: /* Only one GT64xxx is present on the CPU bus, return the initial value */ val = s->regs[saddr]; br... |
0 | static void x86_cpu_expand_features(X86CPU *cpu, Error **errp){ CPUX86State *env = &cpu->env; FeatureWord w; GList *l; Error *local_err = NULL; /*TODO: cpu->max_features incorrectly overwrites features * set using "feat=on|off". Once we fix this, we can convert * plus_features & minus_features to global properties * in... |
0 | static BusState *qbus_find_bus(DeviceState *dev, char *elem){ BusState *child; LIST_FOREACH(child, &dev->child_bus, sibling) { if (strcmp(child->name, elem) == 0) { return child; } } return NULL;} |
0 | static inline void h264_loop_filter_luma_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta, int8_t *tc0){ int i, d; for( i = 0; i < 4; i++ ) { if( tc0[i] < 0 ) { pix += 4*ystride; continue; } for( d = 0; d < 4; d++ ) { const int p0 = pix[-1*xstride]; const int p1 = pix[-2*xstride]; const int p2 = pix[-3*xst... |
0 | static int open_f(BlockBackend *blk, int argc, char **argv){ int flags = BDRV_O_UNMAP; int readonly = 0; bool writethrough = true; int c; QemuOpts *qopts; QDict *opts; bool force_share = false; while ((c = getopt(argc, argv, "snro:kt:d:U")) != -1) { switch (c) { case 's': flags |= BDRV_O_SNAPSHOT; break; case 'n': flag... |
0 | static bool iscsi_allocationmap_is_allocated(IscsiLun *iscsilun, int64_t sector_num, int nb_sectors){ unsigned long size; if (iscsilun->allocationmap == NULL) { return true; } size = DIV_ROUND_UP(sector_num + nb_sectors, iscsilun->cluster_sectors); return !(find_next_bit(iscsilun->allocationmap, size, sector_num / iscs... |
0 | static void disas_ldst_pair(DisasContext *s, uint32_t insn){ int rt = extract32(insn, 0, 5); int rn = extract32(insn, 5, 5); int rt2 = extract32(insn, 10, 5); int64_t offset = sextract32(insn, 15, 7); int index = extract32(insn, 23, 2); bool is_vector = extract32(insn, 26, 1); bool is_load = extract32(insn, 22, 1); int... |
0 | static struct omap_rtc_s *omap_rtc_init(target_phys_addr_t base, qemu_irq *irq, omap_clk clk){ int iomemtype; struct omap_rtc_s *s = (struct omap_rtc_s *) qemu_mallocz(sizeof(struct omap_rtc_s)); s->irq = irq[0]; s->alarm = irq[1]; s->clk = qemu_new_timer(rt_clock, omap_rtc_tick, s); omap_rtc_reset(s); iomemtype = cpu_... |
0 | static int mov_write_udta_tag(ByteIOContext *pb, MOVContext* mov, AVFormatContext *s){ offset_t pos = url_ftell(pb); int i; put_be32(pb, 0); /* size */ put_tag(pb, "udta"); /* iTunes meta data */ mov_write_meta_tag(pb, mov, s); if(mov->mode == MODE_MOV){ // the title field breaks gtkpod with mp4 and my suspicion is tha... |
0 | static void selfTest(uint8_t *ref[4], int refStride[4], int w, int h){ const int flags[] = { SWS_FAST_BILINEAR, SWS_BILINEAR, SWS_BICUBIC, SWS_X , SWS_POINT , SWS_AREA, 0 }; const int srcW = w; const int srcH = h; const int dstW[] = { srcW - srcW/3, srcW, srcW + srcW/3, 0 }; const int dstH[] = { srcH - srcH/3, srcH, sr... |
0 | static void avc_biwgt_4width_msa(uint8_t *src, int32_t src_stride, uint8_t *dst, int32_t dst_stride, int32_t height, int32_t log2_denom, int32_t src_weight, int32_t dst_weight, int32_t offset_in){ if (2 == height) { avc_biwgt_4x2_msa(src, src_stride, dst, dst_stride, log2_denom, src_weight, dst_weight, offset_in); } el... |
0 | static inline int decode_vui_parameters(GetBitContext *gb, AVCodecContext *avctx, SPS *sps){ int aspect_ratio_info_present_flag; unsigned int aspect_ratio_idc; aspect_ratio_info_present_flag = get_bits1(gb); if (aspect_ratio_info_present_flag) { aspect_ratio_idc = get_bits(gb, 8); if (aspect_ratio_idc == EXTENDED_SAR) ... |
0 | static int buffer_needs_copy(PadContext *s, AVFrame *frame, AVBufferRef *buf){ int planes[4] = { -1, -1, -1, -1}, *p = planes; int i, j; /* get all planes in this buffer */ for (i = 0; i < FF_ARRAY_ELEMS(planes) && frame->data[i]; i++) { if (av_frame_get_plane_buffer(frame, i) == buf) *p++ = i; } /* for each plane in t... |
1 | static uint64_t bonito_ldma_readl(void *opaque, hwaddr addr, unsigned size){ uint32_t val; PCIBonitoState *s = opaque; val = ((uint32_t *)(&s->bonldma))[addr/sizeof(uint32_t)]; return val; |
1 | static void integratorcp_init(ram_addr_t ram_size, const char *boot_device, const char *kernel_filename, const char *kernel_cmdline, const char *initrd_filename, const char *cpu_model){ CPUState *env; ram_addr_t ram_offset; qemu_irq pic[32]; qemu_irq *cpu_pic; DeviceState *dev; int i; if (!cpu_model) cpu_model = "arm92... |
1 | static void ich9_apm_ctrl_changed(uint32_t val, void *arg){ ICH9LPCState *lpc = arg; /* ACPI specs 3.0, 4.7.2.5 */ acpi_pm1_cnt_update(&lpc->pm.acpi_regs, val == ICH9_APM_ACPI_ENABLE, val == ICH9_APM_ACPI_DISABLE); if (val == ICH9_APM_ACPI_ENABLE || val == ICH9_APM_ACPI_DISABLE) { return; } /* SMI_EN = PMBASE + 30. SMI... |
1 | static uint32_t get_cluster_count_for_direntry(BDRVVVFATState* s,direntry_t* direntry, const char* path){ /* * This is a little bit tricky: * IF the guest OS just inserts a cluster into the file chain, * and leaves the rest alone, (i.e. the original file had clusters * 15 -> 16, but now has 15 -> 32 -> 16), then the fo... |
1 | void visit_type_str(Visitor *v, const char *name, char **obj, Error **errp){ v->type_str(v, name, obj, errp);} |
1 | static void decode_pitch_lag_high(int *lag_int, int *lag_frac, int pitch_index, uint8_t *base_lag_int, int subframe){ if (subframe == 0 || subframe == 2) { if (pitch_index < 376) { *lag_int = (pitch_index + 137) >> 2; *lag_frac = pitch_index - (*lag_int << 2) + 136; } else if (pitch_index < 440) { *lag_int = (pitch_ind... |
1 | static bool invalid_qmp_mode(const Monitor *mon, const char *cmd, Error **errp){ bool is_cap = g_str_equal(cmd, "qmp_capabilities"); if (is_cap && mon->qmp.in_command_mode) { error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND, "Capabilities negotiation is already complete, command " "'%s' ignored", cmd); return true; } if (... |
1 | static void migration_completion(MigrationState *s, int current_active_state, bool *old_vm_running, int64_t *start_time){ int ret; if (s->state == MIGRATION_STATUS_ACTIVE) { qemu_mutex_lock_iothread(); *start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER); *old_vm_ru... |
1 | static int transcode(AVFormatContext **output_files, int nb_output_files, InputFile *input_files, int nb_input_files, StreamMap *stream_maps, int nb_stream_maps){ int ret = 0, i, j, k, n, nb_ostreams = 0, step; AVFormatContext *is, *os; AVCodecContext *codec, *icodec; OutputStream *ost, **ost_table = NULL; InputStream ... |
1 | static int qemu_event_init(void){ int err; int fds[2]; err = pipe(fds); if (err == -1) return -errno; err = fcntl_setfl(fds[0], O_NONBLOCK); if (err < 0) goto fail; err = fcntl_setfl(fds[1], O_NONBLOCK); if (err < 0) goto fail; qemu_set_fd_handler2(fds[0], NULL, qemu_event_read, NULL, (void *)(unsigned long)fds[0]); io... |
1 | static int amv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic_arg, int *got_packet){ MpegEncContext *s = avctx->priv_data; AVFrame *pic; int i, ret; int chroma_h_shift, chroma_v_shift; av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift); //CODEC_FLAG_EMU_EDGE have... |
0 | static void gen_casx_asi(DisasContext *dc, TCGv addr, TCGv val2, int insn, int rd){ TCGv val1 = gen_load_gpr(dc, rd); TCGv dst = gen_dest_gpr(dc, rd); TCGv_i32 r_asi = gen_get_asi(dc, insn); gen_helper_casx_asi(dst, cpu_env, addr, val1, val2, r_asi); tcg_temp_free_i32(r_asi); gen_store_gpr(dc, rd, dst);} |
0 | static void bt_vhci_add(int vlan_id){ struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id); if (!vlan->slave) fprintf(stderr, "qemu: warning: adding a VHCI to " "an empty scatternet %i\n", vlan_id); bt_vhci_init(bt_new_hci(vlan));} |
0 | e1000_autoneg_timer(void *opaque){ E1000State *s = opaque; if (!qemu_get_queue(s->nic)->link_down) { e1000_link_up(s); } s->phy_reg[PHY_STATUS] |= MII_SR_AUTONEG_COMPLETE; DBGOUT(PHY, "Auto negotiation is completed\n");} |
0 | static inline void halfpel_motion_search4(MpegEncContext * s, int *mx_ptr, int *my_ptr, int dmin, int xmin, int ymin, int xmax, int ymax, int pred_x, int pred_y, int block_x, int block_y, uint8_t *ref_picture){ UINT16 *mv_penalty= s->mv_penalty[s->f_code] + MAX_MV; // f_code of the prev frame const int quant= s->qscale... |
0 | void cpu_loop(CPUCRISState *env){ CPUState *cs = CPU(cris_env_get_cpu(env)); int trapnr, ret; target_siginfo_t info; while (1) { cpu_exec_start(cs); trapnr = cpu_cris_exec(cs); cpu_exec_end(cs); switch (trapnr) { case 0xaa: { info.si_signo = TARGET_SIGSEGV; info.si_errno = 0; /* XXX: check env->error_code */ info.si_co... |
0 | static void tlb_info_32(Monitor *mon, CPUState *env){ int l1, l2; uint32_t pgd, pde, pte; pgd = env->cr[3] & ~0xfff; for(l1 = 0; l1 < 1024; l1++) { cpu_physical_memory_read(pgd + l1 * 4, &pde, 4); pde = le32_to_cpu(pde); if (pde & PG_PRESENT_MASK) { if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) { /* 4M pages ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.