label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | static void reanalyze(MpegTSContext *ts) { AVIOContext *pb = ts->stream->pb; int64_t pos = avio_tell(pb); if(pos < 0) return; pos += ts->raw_packet_size - ts->pos47_full; if (pos == TS_PACKET_SIZE) { ts->size_stat[0] ++; } else if (pos == TS_DVHS_PACKET_SIZE) { ts->size_stat[1] ++; } else if (pos == TS_FEC_PACKET_SIZE)... |
0 | static void spapr_create_nvram(sPAPREnvironment *spapr){ DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram"); DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0); if (dinfo) { qdev_prop_set_drive_nofail(dev, "drive", blk_bs(blk_by_legacy_dinfo(dinfo))); } qdev_init_nofail(dev); spapr->nvram = (struct sPAPRNVR... |
0 | void qmp_block_dirty_bitmap_remove(const char *node, const char *name, Error **errp){ AioContext *aio_context; BlockDriverState *bs; BdrvDirtyBitmap *bitmap; bitmap = block_dirty_bitmap_lookup(node, name, &bs, &aio_context, errp); if (!bitmap || !bs) { return; } if (bdrv_dirty_bitmap_frozen(bitmap)) { error_setg(errp, ... |
0 | int tcg_gen_code(TCGContext *s, TranslationBlock *tb){ int i, oi, oi_next, num_insns;#ifdef CONFIG_PROFILER { int n; n = s->gen_last_op_idx + 1; s->op_count += n; if (n > s->op_count_max) { s->op_count_max = n; } n = s->nb_temps; s->temp_count += n; if (n > s->temp_count_max) { s->temp_count_max = n; } }#endif#ifdef DE... |
0 | static void curl_multi_read(void *arg){ CURLState *s = (CURLState *)arg; aio_context_acquire(s->s->aio_context); curl_multi_do_locked(s); curl_multi_check_completion(s->s); aio_context_release(s->s->aio_context);} |
0 | static int sh_pci_host_init(PCIDevice *d){ pci_config_set_vendor_id(d->config, PCI_VENDOR_ID_HITACHI); pci_config_set_device_id(d->config, PCI_DEVICE_ID_HITACHI_SH7751R); pci_set_word(d->config + PCI_COMMAND, PCI_COMMAND_WAIT); pci_set_word(d->config + PCI_STATUS, PCI_STATUS_CAP_LIST | PCI_STATUS_FAST_BACK | PCI_STATUS... |
0 | static int do_sigframe_return_v2(CPUARMState *env, target_ulong frame_addr, struct target_ucontext_v2 *uc){ sigset_t host_set; abi_ulong *regspace; target_to_host_sigset(&host_set, &uc->tuc_sigmask); sigprocmask(SIG_SETMASK, &host_set, NULL); if (restore_sigcontext(env, &uc->tuc_mcontext)) return 1; /* Restore coproces... |
0 | static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num, int nb_sectors){ if (nb_sectors < 0 || nb_sectors > BDRV_REQUEST_MAX_SECTORS) { return -EIO; } return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE, nb_sectors * BDRV_SECTOR_SIZE);} |
0 | static int kvm_arch_sync_sregs(CPUState *cenv){ struct kvm_sregs sregs; int ret; if (cenv->excp_model == POWERPC_EXCP_BOOKE) { return 0; } else { if (!cap_segstate) { return 0; } } ret = kvm_vcpu_ioctl(cenv, KVM_GET_SREGS, &sregs); if (ret) { return ret; } sregs.pvr = cenv->spr[SPR_PVR]; return kvm_vcpu_ioctl(cenv, KVM... |
0 | static int net_client_init1(const void *object, int is_netdev, Error **errp){ union { const Netdev *netdev; const NetLegacy *net; } u; const NetClientOptions *opts; const char *name; if (is_netdev) { u.netdev = object; opts = u.netdev->opts; name = u.netdev->id; if (opts->kind == NET_CLIENT_OPTIONS_KIND_DUMP || opts->k... |
0 | static inline void gen_evsel (DisasContext *ctx){ if (unlikely(!ctx->spe_enabled)) { RET_EXCP(ctx, EXCP_NO_SPE, 0); return; } gen_op_load_crf_T0(ctx->opcode & 0x7); gen_op_load_gpr64_T0(rA(ctx->opcode)); gen_op_load_gpr64_T1(rB(ctx->opcode)); gen_op_evsel(); gen_op_store_T0_gpr64(rD(ctx->opcode));} |
1 | int pci_device_load(PCIDevice *s, QEMUFile *f){ uint32_t version_id; int i; version_id = qemu_get_be32(f); if (version_id > 2) return -EINVAL; qemu_get_buffer(f, s->config, 256); pci_update_mappings(s); if (version_id >= 2) for (i = 0; i < 4; i ++) s->irq_state[i] = qemu_get_be32(f); return 0;} |
0 | int ff_hevc_decode_nal_vps(HEVCContext *s){ int i,j; GetBitContext *gb = &s->HEVClc.gb; int vps_id = 0; HEVCVPS *vps; AVBufferRef *vps_buf = av_buffer_allocz(sizeof(*vps)); if (!vps_buf) return AVERROR(ENOMEM); vps = (HEVCVPS*)vps_buf->data; av_log(s->avctx, AV_LOG_DEBUG, "Decoding VPS\n"); vps_id = get_bits(gb, 4); if... |
1 | static int decode_frame(AVCodecContext * avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; KmvcContext *const ctx = avctx->priv_data; uint8_t *out, *src; int i; int header; int blocksize; const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PAL... |
1 | static int read_header(FFV1Context *f){ uint8_t state[CONTEXT_SIZE]; int i, j, context_count = -1; //-1 to avoid warning RangeCoder *const c = &f->slice_context[0]->c; memset(state, 128, sizeof(state)); if (f->version < 2) { int chroma_planes, chroma_h_shift, chroma_v_shift, transparency, colorspace, bits_per_raw_sampl... |
1 | static int config_props(AVFilterLink *outlink){ AVFilterContext *ctx = outlink->src; AVFilterLink *inlink = outlink->src->inputs[0]; ScaleContext *scale = ctx->priv; int64_t w, h; double var_values[VARS_NB], res; char *expr; int ret; var_values[VAR_PI] = M_PI; var_values[VAR_PHI] = M_PHI; var_values[VAR_E] = M_E; var_v... |
1 | static int set_sps(HEVCContext *s, const HEVCSPS *sps){ #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + CONFIG_HEVC_D3D11VA_HWACCEL) enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts; int ret; export_stream_params(s->avctx, &s->ps, sps); pic_arrays_free(s); ret = pic_arrays_init(s, sps); if (ret < 0) goto ... |
1 | static int svq1_encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){ SVQ1Context * const s = avctx->priv_data; AVFrame *pict = data; AVFrame * const p= (AVFrame*)&s->picture; AVFrame temp; int i; if(avctx->pix_fmt != PIX_FMT_YUV410P){ av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n... |
1 | static void scsi_dma_restart_bh(void *opaque){ SCSIDiskState *s = opaque; SCSIRequest *req; SCSIDiskReq *r; qemu_bh_delete(s->bh); s->bh = NULL; QTAILQ_FOREACH(req, &s->qdev.requests, next) { r = DO_UPCAST(SCSIDiskReq, req, req); if (r->status & SCSI_REQ_STATUS_RETRY) { int status = r->status; int ret; r->status &= ~(S... |
1 | static bool is_sector_request_lun_aligned(int64_t sector_num, int nb_sectors, IscsiLun *iscsilun){ assert(nb_sectors < BDRV_REQUEST_MAX_SECTORS); return is_byte_request_lun_aligned(sector_num << BDRV_SECTOR_BITS, nb_sectors << BDRV_SECTOR_BITS, iscsilun);} |
0 | void ff_put_h264_qpel16_mc11_msa(uint8_t *dst, const uint8_t *src, ptrdiff_t stride){ avc_luma_hv_qrt_16w_msa(src - 2, src - (stride * 2), stride, dst, stride, 16);} |
0 | static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len){ MpegTSContext *ts = filter->u.section_filter.opaque; MpegTSSectionFilter *tssf = &filter->u.section_filter; SectionHeader h1, *h = &h1; PESContext *pes; AVStream *st; const uint8_t *p, *p_end, *desc_list_end; int program_info_length, pcr... |
0 | static int rm_read_packet(AVFormatContext *s, AVPacket *pkt){ RMDemuxContext *rm = s->priv_data; AVStream *st; int i, len, res, seq = 1; int64_t timestamp, pos; int flags; for (;;) { if (rm->audio_pkt_cnt) { // If there are queued audio packet return them first st = s->streams[rm->audio_stream_num]; ff_rm_retrieve_cach... |
0 | static int decode_group3_2d_line(AVCodecContext *avctx, GetBitContext *gb, int width, int *runs, const int *runend, const int *ref){ int mode = 0, offs = 0, run = 0, saved_run = 0, t; int run_off = *ref++; int *run_start = runs; runend--; // for the last written 0 while(offs < width){ int cmode = get_vlc2(gb, ccitt_gro... |
0 | static int analyze(const uint8_t *buf, int size, int packet_size, int *index, int probe){ int stat[TS_MAX_PACKET_SIZE]; int stat_all = 0; int i; int best_score = 0; memset(stat, 0, packet_size * sizeof(*stat)); for (i = 0; i < size - 3; i++) { if (buf[i] == 0x47 && (!probe || (!(buf[i + 1] & 0x80) && buf[i + 3] != 0x47... |
0 | static void ff_h264_idct_dc_add8_mmx2(uint8_t *dst, int16_t *block, int stride){ __asm__ volatile( "movd %0, %%mm0 \n\t" // 0 0 X D "punpcklwd %1, %%mm0 \n\t" // x X d D "paddsw %2, %%mm0 \n\t" "psraw $6, %%mm0 \n\t" "punpcklwd %%mm0, %%mm0 \n\t" // d d D D "pxor %%mm1, %%mm1 \n\t" // 0 0 0 0 "psubw %%mm0, %%mm1 \n\t" ... |
0 | void uninit_opts(void){ int i; for (i = 0; i < AVMEDIA_TYPE_NB; i++) av_freep(&avcodec_opts[i]); av_freep(&avformat_opts->key); av_freep(&avformat_opts);#if CONFIG_SWSCALE av_freep(&sws_opts);#endif for (i = 0; i < opt_name_count; i++) { //opt_values are only stored for codec-specific options in which case //both the n... |
0 | static int ftp_send_command(FTPContext *s, const char *command, const int response_codes[], char **response){ int err; /* Flush control connection input to get rid of non relevant responses if any */ if ((err = ftp_flush_control_input(s)) < 0) return err; /* send command in blocking mode */ s->conn_control_block_flag =... |
0 | static int libvorbis_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr){ LibvorbisContext *s = avctx->priv_data; ogg_packet op; int ret, duration; /* send samples to libvorbis */ if (frame) { const int samples = frame->nb_samples; float **buffer; int c, channels = s->vi.chan... |
0 | int bdrv_set_key(BlockDriverState *bs, const char *key){ int ret; if (bs->backing_hd && bs->backing_hd->encrypted) { ret = bdrv_set_key(bs->backing_hd, key); if (ret < 0) return ret; if (!bs->encrypted) return 0; } if (!bs->encrypted) { return -EINVAL; } else if (!bs->drv || !bs->drv->bdrv_set_key) { return -ENOMEDIUM;... |
0 | int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id){ BlockDriver *drv = bs->drv; if (!drv) return -ENOMEDIUM; if (drv->bdrv_snapshot_delete) return drv->bdrv_snapshot_delete(bs, snapshot_id); if (bs->file) return bdrv_snapshot_delete(bs->file, snapshot_id); return -ENOTSUP;} |
0 | static char *idebus_get_fw_dev_path(DeviceState *dev){ char path[30]; snprintf(path, sizeof(path), "%s@%d", qdev_fw_name(dev), ((IDEBus*)dev->parent_bus)->bus_id); return strdup(path);} |
0 | int bdrv_key_required(BlockDriverState *bs){ BlockDriverState *backing_hd = bs->backing_hd; if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key) return 1; return (bs->encrypted && !bs->valid_key);} |
0 | static void init_proc_970 (CPUPPCState *env){ gen_spr_ne_601(env); gen_spr_7xx(env); /* Time base */ gen_tbl(env); /* Hardware implementation registers */ /* XXX : not implemented */ spr_register(env, SPR_HID0, "HID0", SPR_NOACCESS, SPR_NOACCESS, &spr_read_generic, &spr_write_clear, 0x60000000); /* XXX : not implemente... |
0 | void qmp_drive_mirror(DriveMirror *arg, Error **errp){ BlockDriverState *bs; BlockBackend *blk; BlockDriverState *source, *target_bs; AioContext *aio_context; BlockMirrorBackingMode backing_mode; Error *local_err = NULL; QDict *options = NULL; int flags; int64_t size; const char *format = arg->format; blk = blk_by_name... |
0 | static int get_aac_sample_rates(AVFormatContext *s, AVCodecParameters *par, int *sample_rate, int *output_sample_rate){ MPEG4AudioConfig mp4ac; if (avpriv_mpeg4audio_get_config(&mp4ac, par->extradata, par->extradata_size * 8, 1) < 0) { av_log(s, AV_LOG_ERROR, "Error parsing AAC extradata, unable to determine samplerate... |
0 | static void pxa2xx_lcdc_dma0_redraw_rot270(PXA2xxLCDState *s, hwaddr addr, int *miny, int *maxy){ DisplaySurface *surface = qemu_console_surface(s->con); int src_width, dest_width; drawfn fn = NULL; if (s->dest_width) { fn = s->line_fn[s->transp][s->bpp]; } if (!fn) { return; } src_width = (s->xres + 3) & ~3; /* Pad to... |
0 | static void tci_out_label(TCGContext *s, TCGLabel *label){ if (label->has_value) { tcg_out_i(s, label->u.value); assert(label->u.value); } else { tcg_out_reloc(s, s->code_ptr, sizeof(tcg_target_ulong), label, 0); s->code_ptr += sizeof(tcg_target_ulong); }} |
0 | void tlb_flush(CPUState *env, int flush_global){ int i;#if defined(DEBUG_TLB) printf("tlb_flush:\n");#endif /* must reset current TB so that interrupts cannot modify the links while we are modifying them */ env->current_tb = NULL; for(i = 0; i < CPU_TLB_SIZE; i++) { env->tlb_table[0][i].addr_read = -1; env->tlb_table[0... |
0 | static int write_elf64_load(DumpState *s, MemoryMapping *memory_mapping, int phdr_index, hwaddr offset){ Elf64_Phdr phdr; int ret; int endian = s->dump_info.d_endian; memset(&phdr, 0, sizeof(Elf64_Phdr)); phdr.p_type = cpu_convert_to_target32(PT_LOAD, endian); phdr.p_offset = cpu_convert_to_target64(offset, endian); ph... |
0 | static int patch_hypercalls(VAPICROMState *s){ hwaddr rom_paddr = s->rom_state_paddr & ROM_BLOCK_MASK; static const uint8_t vmcall_pattern[] = { /* vmcall */ 0xb8, 0x1, 0, 0, 0, 0xf, 0x1, 0xc1 }; static const uint8_t outl_pattern[] = { /* nop; outl %eax,0x7e */ 0xb8, 0x1, 0, 0, 0, 0x90, 0xe7, 0x7e }; uint8_t alternates... |
0 | static void vnc_zlib_start(VncState *vs){ buffer_reset(&vs->zlib); // make the output buffer be the zlib buffer, so we can compress it later vs->zlib_tmp = vs->output; vs->output = vs->zlib;} |
0 | target_ulong helper_rdhwr_cpunum(CPUMIPSState *env){ if ((env->hflags & MIPS_HFLAG_CP0) || (env->CP0_HWREna & (1 << 0))) return env->CP0_EBase & 0x3ff; else do_raise_exception(env, EXCP_RI, GETPC()); return 0;} |
0 | static int write_l1_entry(BlockDriverState *bs, int l1_index){ BDRVQcowState *s = bs->opaque; uint64_t buf[L1_ENTRIES_PER_SECTOR]; int l1_start_index; int i, ret; l1_start_index = l1_index & ~(L1_ENTRIES_PER_SECTOR - 1); for (i = 0; i < L1_ENTRIES_PER_SECTOR; i++) { buf[i] = cpu_to_be64(s->l1_table[l1_start_index + i])... |
0 | static int amr_wb_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; AMRWBContext *s = avctx->priv_data; int mode; int packet_size; static const uint8_t block_size[16] = {18, 24, 33, 37, 41, 47, 51, 59, 61, 6, 6, 0, 0, 0, 1, 1}... |
0 | static void gui_update(void *opaque){ uint64_t interval = GUI_REFRESH_INTERVAL; DisplayState *ds = opaque; DisplayChangeListener *dcl = ds->listeners; qemu_flush_coalesced_mmio_buffer(); dpy_refresh(ds); while (dcl != NULL) { if (dcl->gui_timer_interval && dcl->gui_timer_interval < interval) interval = dcl->gui_timer_i... |
0 | static void spapr_phb_vfio_instance_init(Object *obj){ error_report("spapr-pci-vfio-host-bridge is deprecated");} |
0 | static void connex_init(ram_addr_t ram_size, int vga_ram_size, const char *boot_device, const char *kernel_filename, const char *kernel_cmdline, const char *initrd_filename, const char *cpu_model){ struct pxa2xx_state_s *cpu; int index; uint32_t connex_rom = 0x01000000; uint32_t connex_ram = 0x04000000; if (ram_size < ... |
0 | static void handle_notify(EventNotifier *e){ VirtIOBlockDataPlane *s = container_of(e, VirtIOBlockDataPlane, host_notifier); VirtIOBlock *vblk = VIRTIO_BLK(s->vdev); event_notifier_test_and_clear(&s->host_notifier); blk_io_plug(s->conf->conf.blk); for (;;) { MultiReqBuffer mrb = {}; int ret; /* Disable guest->host noti... |
0 | static void mcf5208evb_init(ram_addr_t ram_size, int vga_ram_size, const char *boot_device, DisplayState *ds, const char *kernel_filename, const char *kernel_cmdline, const char *initrd_filename, const char *cpu_model){ CPUState *env; int kernel_size; uint64_t elf_entry; target_ulong entry; qemu_irq *pic; if (!cpu_mode... |
0 | static int qcow_read_extensions(BlockDriverState *bs, uint64_t start_offset, uint64_t end_offset){ BDRVQcowState *s = bs->opaque; QCowExtension ext; uint64_t offset;#ifdef DEBUG_EXT printf("qcow_read_extensions: start=%ld end=%ld\n", start_offset, end_offset);#endif offset = start_offset; while (offset < end_offset) {#... |
0 | int armv7m_nvic_acknowledge_irq(void *opaque){ nvic_state *s = (nvic_state *)opaque; uint32_t irq; irq = gic_acknowledge_irq(&s->gic, 0); if (irq == 1023) hw_error("Interrupt but no vector\n"); if (irq >= 32) irq -= 16; return irq;} |
0 | static FlatView *address_space_get_flatview(AddressSpace *as){ FlatView *view; qemu_mutex_lock(&flat_view_mutex); view = as->current_map; flatview_ref(view); qemu_mutex_unlock(&flat_view_mutex); return view;} |
0 | static int kvm_put_vcpu_events(X86CPU *cpu, int level){ CPUX86State *env = &cpu->env; struct kvm_vcpu_events events; if (!kvm_has_vcpu_events()) { return 0; } events.exception.injected = (env->exception_injected >= 0); events.exception.nr = env->exception_injected; events.exception.has_error_code = env->has_error_code;... |
0 | static int qdm2_decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){ QDM2Context *s = avctx->priv_data; if((buf == NULL) || (buf_size < s->checksum_size)) return 0; *data_size = s->channels * s->frame_size * sizeof(int16_t); av_log(avctx, AV_LOG_DEBUG, "decode(%d): %p[%d] -> %p[%... |
0 | static void bdrv_sync_complete(void *opaque, int ret){ /* do nothing. Masters do not directly interact with the backing store, * only the working copy so no mutexing required. */} |
0 | set_phy_ctrl(E1000State *s, int index, uint16_t val){ /* * QEMU 1.3 does not support link auto-negotiation emulation, so if we * migrate during auto negotiation, after migration the link will be * down. */ if (!(s->compat_flags & E1000_FLAG_AUTONEG)) { return; } if ((val & MII_CR_AUTO_NEG_EN) && (val & MII_CR_RESTART_A... |
0 | static void vtd_address_space_unmap(VTDAddressSpace *as, IOMMUNotifier *n){ IOMMUTLBEntry entry; hwaddr size; hwaddr start = n->start; hwaddr end = n->end; /* * Note: all the codes in this function has a assumption that IOVA * bits are no more than VTD_MGAW bits (which is restricted by * VT-d spec), otherwise we need t... |
0 | static int megasas_ld_get_info_submit(SCSIDevice *sdev, int lun, MegasasCmd *cmd){ struct mfi_ld_info *info = cmd->iov_buf; size_t dcmd_size = sizeof(struct mfi_ld_info); uint8_t cdb[6]; SCSIRequest *req; ssize_t len, resid; BlockConf *conf = &sdev->conf; uint16_t sdev_id = ((sdev->id & 0xFF) >> 8) | (lun & 0xFF); uint... |
0 | static void do_interrupt_protected(int intno, int is_int, int error_code, unsigned int next_eip){ SegmentCache *dt; uint8_t *ptr, *ssp; int type, dpl, selector, ss_dpl; int has_error_code, new_stack, shift; uint32_t e1, e2, offset, ss, esp, ss_e1, ss_e2, push_size; uint32_t old_cs, old_ss, old_esp, old_eip; dt = &env->... |
0 | static inline void gen_evmergehilo(DisasContext *ctx){ if (unlikely(!ctx->spe_enabled)) { gen_exception(ctx, POWERPC_EXCP_APU); return; }#if defined(TARGET_PPC64) TCGv t0 = tcg_temp_new(); TCGv t1 = tcg_temp_new(); tcg_gen_ext32u_tl(t0, cpu_gpr[rB(ctx->opcode)]); tcg_gen_andi_tl(t1, cpu_gpr[rA(ctx->opcode)], 0xFFFFFFFF... |
0 | void qjson_finish(QJSON *json){ json_end_object(json);} |
0 | static void arm_cache_flush(abi_ulong start, abi_ulong last){ abi_ulong addr, last1; if (last < start) return; addr = start; for(;;) { last1 = ((addr + TARGET_PAGE_SIZE) & TARGET_PAGE_MASK) - 1; if (last1 > last) last1 = last; tb_invalidate_page_range(addr, last1 + 1); if (last1 == last) break; addr = last1 + 1; }} |
0 | Object *object_dynamic_cast(Object *obj, const char *typename){ GSList *i; /* Check if typename is a direct ancestor */ if (object_is_type(obj, typename)) { return obj; } /* Check if obj has an interface of typename */ for (i = obj->interfaces; i; i = i->next) { Interface *iface = i->data; if (object_is_type(OBJECT(ifa... |
0 | void ioinst_handle_rchp(S390CPU *cpu, uint64_t reg1){ int cc; uint8_t cssid; uint8_t chpid; int ret; CPUS390XState *env = &cpu->env; if (RCHP_REG1_RES(reg1)) { program_interrupt(env, PGM_OPERAND, 2); return; } cssid = RCHP_REG1_CSSID(reg1); chpid = RCHP_REG1_CHPID(reg1); trace_ioinst_chp_id("rchp", cssid, chpid); ret =... |
0 | int s390_cpu_restart(S390CPU *cpu){ if (kvm_enabled()) { return kvm_s390_cpu_restart(cpu); } return -ENOSYS;} |
0 | static int parse_packet_header(WMAVoiceContext *s){ GetBitContext *gb = &s->gb; unsigned int res; if (get_bits_left(gb) < 11) return 1; skip_bits(gb, 4); // packet sequence number s->has_residual_lsps = get_bits1(gb); do { res = get_bits(gb, 6); // number of superframes per packet // (minus first one if there is spillo... |
0 | int xenstore_domain_init1(const char *kernel, const char *ramdisk, const char *cmdline){ char *dom, uuid_string[42], vm[256], path[256]; int i; snprintf(uuid_string, sizeof(uuid_string), UUID_FMT, qemu_uuid[0], qemu_uuid[1], qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5], qemu_uuid[6], qemu_uuid[7], qemu_uuid[8... |
0 | static av_always_inline void put_h264_qpel8or16_hv1_lowpass_sse2(int16_t *tmp, uint8_t *src, int tmpStride, int srcStride, int size){ int w = (size+8)>>3; src -= 2*srcStride+2; while(w--){ __asm__ volatile( "pxor %%xmm7, %%xmm7 \n\t" "movq (%0), %%xmm0 \n\t" "add %2, %0 \n\t" "movq (%0), %%xmm1 \n\t" "add %2, %0 \n\t" ... |
0 | static void pc_cpu_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev, Error **errp){ int idx; int node_id; CPUState *cs; CPUArchId *cpu_slot; X86CPUTopoInfo topo; X86CPU *cpu = X86_CPU(dev); PCMachineState *pcms = PC_MACHINE(hotplug_dev); /* if APIC ID is not set, set it based on socket/core/thread properties */ i... |
0 | void monitor_readline(const char *prompt, int is_password, char *buf, int buf_size){ int i; if (is_password) { for (i = 0; i < MAX_MON; i++) if (monitor_hd[i] && monitor_hd[i]->focus == 0) qemu_chr_send_event(monitor_hd[i], CHR_EVENT_FOCUS); } readline_start(prompt, is_password, monitor_readline_cb, NULL); monitor_read... |
0 | static void decode_422_bitstream(HYuvContext *s, int count){ int i; count /= 2; if (count >= (get_bits_left(&s->gb)) / (31 * 4)) { for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) { READ_2PIX(s->temp[0][2 * i ], s->temp[1][i], 1); READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2); } for (; i < count; i++) s->t... |
0 | static int oss_init_out (HWVoiceOut *hw, audsettings_t *as){ OSSVoiceOut *oss = (OSSVoiceOut *) hw; struct oss_params req, obt; int endianness; int err; int fd; audfmt_e effective_fmt; audsettings_t obt_as; oss->fd = -1; req.fmt = aud_to_ossfmt (as->fmt); req.freq = as->freq; req.nchannels = as->nchannels; req.fragsize... |
0 | void msi_notify(PCIDevice *dev, unsigned int vector){ uint16_t flags = pci_get_word(dev->config + msi_flags_off(dev)); bool msi64bit = flags & PCI_MSI_FLAGS_64BIT; unsigned int nr_vectors = msi_nr_vectors(flags); MSIMessage msg; assert(vector < nr_vectors); if (msi_is_masked(dev, vector)) { assert(flags & PCI_MSI_FLAGS... |
0 | int nbd_client_session_init(NbdClientSession *client, BlockDriverState *bs, int sock, const char *export, Error **errp){ int ret; /* NBD handshake */ logout("session init %s\n", export); qemu_set_block(sock); ret = nbd_receive_negotiate(sock, export, &client->nbdflags, &client->size, &client->blocksize, errp); if (ret ... |
0 | static void qmp_output_push_obj(QmpOutputVisitor *qov, QObject *value){ QStackEntry *e = g_malloc0(sizeof(*e)); assert(qov->root); assert(value); e->value = value; if (qobject_type(e->value) == QTYPE_QLIST) { e->is_list_head = true; } QTAILQ_INSERT_HEAD(&qov->stack, e, node);} |
0 | static bool enforce_config_section(void){ MachineState *machine = MACHINE(qdev_get_machine()); return machine->enforce_config_section;} |
0 | MSA_ST_DF(DF_BYTE, b, helper_ret_stb_mmu, oi, GETRA())MSA_ST_DF(DF_HALF, h, helper_ret_stw_mmu, oi, GETRA())MSA_ST_DF(DF_WORD, w, helper_ret_stl_mmu, oi, GETRA())MSA_ST_DF(DF_DOUBLE, d, helper_ret_stq_mmu, oi, GETRA())#elseMSA_ST_DF(DF_BYTE, b, cpu_stb_data)MSA_ST_DF(DF_HALF, h, cpu_stw_data)MSA_ST_DF(DF_WORD, w, cpu_s... |
0 | void qemu_spice_add_memslot(SimpleSpiceDisplay *ssd, QXLDevMemSlot *memslot, qxl_async_io async){ if (async != QXL_SYNC) {#if SPICE_INTERFACE_QXL_MINOR >= 1 spice_qxl_add_memslot_async(&ssd->qxl, memslot, 0);#else abort();#endif } else { ssd->worker->add_memslot(ssd->worker, memslot); }} |
0 | static void spapr_cpu_core_register(const SPAPRCoreInfo *info){ TypeInfo type_info = { .parent = TYPE_SPAPR_CPU_CORE, .instance_size = sizeof(sPAPRCPUCore), .instance_init = info->initfn, }; type_info.name = g_strdup_printf("%s-" TYPE_SPAPR_CPU_CORE, info->name); type_register(&type_info); g_free((void *)type_info.name... |
0 | static int aer915_init(I2CSlave *i2c){ /* Nothing to do. */ return 0;} |
0 | static void define_debug_regs(ARMCPU *cpu){ /* Define v7 and v8 architectural debug registers. * These are just dummy implementations for now. */ int i; define_arm_cp_regs(cpu, debug_cp_reginfo); if (arm_feature(&cpu->env, ARM_FEATURE_LPAE)) { define_arm_cp_regs(cpu, debug_lpae_cp_reginfo); } for (i = 0; i < 16; i++) {... |
0 | static inline unsigned int rgb_to_pixel8(unsigned int r, unsigned int g, unsigned b){ /* XXX: TODO */ return 0;} |
0 | static inline void gen_efsneg(DisasContext *ctx){ if (unlikely(!ctx->spe_enabled)) { gen_exception(ctx, POWERPC_EXCP_APU); return; } tcg_gen_xori_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], 0x80000000);} |
0 | VirtIOBlockReq *virtio_blk_alloc_request(VirtIOBlock *s){ VirtIOBlockReq *req = g_new(VirtIOBlockReq, 1); req->dev = s; req->qiov.size = 0; req->in_len = 0; req->next = NULL; req->mr_next = NULL; return req;} |
0 | static void uhci_reset(void *opaque){ UHCIState *s = opaque; uint8_t *pci_conf; int i; UHCIPort *port; DPRINTF("uhci: full reset\n"); pci_conf = s->dev.config; pci_conf[0x6a] = 0x01; /* usb clock */ pci_conf[0x6b] = 0x00; s->cmd = 0; s->status = 0; s->status2 = 0; s->intr = 0; s->fl_base_addr = 0; s->sof_timing = 64; f... |
0 | static int parse_block_size_shift(BDRVSheepdogState *s, QemuOpts *opt){ struct SheepdogInode *inode = &s->inode; uint64_t object_size; int obj_order; object_size = qemu_opt_get_size_del(opt, BLOCK_OPT_OBJECT_SIZE, 0); if (object_size) { if ((object_size - 1) & object_size) { /* not a power of 2? */ return -EINVAL; } ob... |
0 | static uint64_t mmio_ide_read(void *opaque, target_phys_addr_t addr, unsigned size){ MMIOState *s = opaque; addr >>= s->shift; if (addr & 7) return ide_ioport_read(&s->bus, addr); else return ide_data_readw(&s->bus, 0);} |
0 | static void dbdma_write(void *opaque, target_phys_addr_t addr, uint64_t value, unsigned size){ int channel = addr >> DBDMA_CHANNEL_SHIFT; DBDMAState *s = opaque; DBDMA_channel *ch = &s->channels[channel]; int reg = (addr - (channel << DBDMA_CHANNEL_SHIFT)) >> 2; DBDMA_DPRINTF("writel 0x" TARGET_FMT_plx " <= 0x%08x\n", ... |
0 | static void vfio_iommu_map_notify(IOMMUNotifier *n, IOMMUTLBEntry *iotlb){ VFIOGuestIOMMU *giommu = container_of(n, VFIOGuestIOMMU, n); VFIOContainer *container = giommu->container; hwaddr iova = iotlb->iova + giommu->iommu_offset; MemoryRegion *mr; hwaddr xlat; hwaddr len = iotlb->addr_mask + 1; void *vaddr; int ret; ... |
0 | static void flush_packet(AVFormatContext *ctx, int stream_index, int last_pkt){ MpegMuxContext *s = ctx->priv_data; StreamInfo *stream = ctx->streams[stream_index]->priv_data; uint8_t *buf_ptr; int size, payload_size, startcode, id, len, stuffing_size, i, header_len; int64_t timestamp; uint8_t buffer[128]; int last = l... |
0 | static int audio_decode_frame(VideoState *is, uint8_t *audio_buf, double *pts_ptr){ AVPacket *pkt = &is->audio_pkt; int n, len1, data_size; double pts; for(;;) { /* NOTE: the audio packet can contain several frames */ while (is->audio_pkt_size > 0) { len1 = avcodec_decode_audio(&is->audio_st->codec, (int16_t *)audio_bu... |
0 | static int rtp_write_header(AVFormatContext *s1){ RTPDemuxContext *s = s1->priv_data; int payload_type, max_packet_size, n; AVStream *st; if (s1->nb_streams != 1) return -1; st = s1->streams[0]; payload_type = rtp_get_payload_type(st->codec); if (payload_type < 0) payload_type = RTP_PT_PRIVATE; /* private payload type ... |
0 | int ff_v4l2_context_dequeue_packet(V4L2Context* ctx, AVPacket* pkt){ V4L2Buffer* avbuf = NULL; /* if we are draining, we are no longer inputing data, therefore enable a * timeout so we can dequeue and flag the last valid buffer. * * blocks until: * 1. encoded packet available * 2. an input buffer ready to be dequeued *... |
0 | static SlirpState *slirp_lookup(Monitor *mon, const char *vlan, const char *stack){ VLANClientState *vc; if (vlan) { vc = qemu_find_vlan_client_by_name(mon, strtol(vlan, NULL, 0), stack); if (!vc) { return NULL; } if (strcmp(vc->model, "user")) { monitor_printf(mon, "invalid device specified\n"); return NULL; } return ... |
0 | static void usb_host_speed_compat(USBHostDevice *s){ USBDevice *udev = USB_DEVICE(s); struct libusb_config_descriptor *conf; const struct libusb_interface_descriptor *intf; const struct libusb_endpoint_descriptor *endp;#ifdef HAVE_STREAMS struct libusb_ss_endpoint_companion_descriptor *endp_ss_comp;#endif bool compat_h... |
0 | static void find_best_tables(MpegEncContext * s){ int i; int best =-1, best_size =9999999; int chroma_best=-1, best_chroma_size=9999999; for(i=0; i<3; i++){ int level; int chroma_size=0; int size=0; if(i>0){// ;) size++; chroma_size++; } for(level=0; level<=MAX_LEVEL; level++){ int run; for(run=0; run<=MAX_RUN; run++){... |
0 | static always_inline void gen_qemu_ld32s(DisasContext *ctx, TCGv arg1, TCGv arg2){ if (unlikely(ctx->mem_idx)) { TCGv_i32 t0; tcg_gen_qemu_ld32u(arg1, arg2, ctx->mem_idx); t0 = tcg_temp_new_i32(); tcg_gen_trunc_tl_i32(t0, arg1); tcg_gen_bswap_i32(t0, t0); tcg_gen_ext_i32_tl(arg1, t0); tcg_temp_free_i32(t0); } else tcg_... |
0 | static inline void gen_ins(DisasContext *s, TCGMemOp ot){ if (use_icount) gen_io_start(); gen_string_movl_A0_EDI(s); /* Note: we must do this dummy write first to be restartable in case of page fault. */ tcg_gen_movi_tl(cpu_T[0], 0); gen_op_st_v(s, ot, cpu_T[0], cpu_A0); tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_regs[R_ED... |
0 | void qmp_block_stream(const char *device, bool has_base, const char *base, bool has_backing_file, const char *backing_file, bool has_speed, int64_t speed, bool has_on_error, BlockdevOnError on_error, Error **errp){ BlockDriverState *bs; BlockDriverState *base_bs = NULL; Error *local_err = NULL; const char *base_name = ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.