label int64 0 1 | func1 stringlengths 23 97k | id int64 0 27.3k |
|---|---|---|
1 | void esp_init(target_phys_addr_t espaddr, int it_shift, espdma_memory_read_write dma_memory_read, espdma_memory_read_write dma_memory_write, void *dma_opaque, qemu_irq irq, qemu_irq *reset) { DeviceState *dev; SysBusDevice *s; ESPState *esp; dev = qdev_create(NULL, "esp"); esp = DO_UPCAST(ESPState, busdev.qdev, dev); e... | 18,632 |
1 | static void mptsas_process_scsi_task_mgmt(MPTSASState *s, MPIMsgSCSITaskMgmt *req) { MPIMsgSCSITaskMgmtReply reply; MPIMsgSCSITaskMgmtReply *reply_async; int status, count; SCSIDevice *sdev; SCSIRequest *r, *next; BusChild *kid; mptsas_fix_scsi_task_mgmt_endianness(req); QEMU_BUILD_BUG_ON(MPTSAS_MAX_REQUEST_SIZE < size... | 18,633 |
1 | static void cpu_class_init(ObjectClass *oc, void *data) { SCLPEventClass *k = SCLP_EVENT_CLASS(oc); DeviceClass *dc = DEVICE_CLASS(oc); k->get_send_mask = send_mask; k->get_receive_mask = receive_mask; k->read_event_data = read_event_data; set_bit(DEVICE_CATEGORY_MISC, dc->categories); } | 18,634 |
1 | BlockDriverAIOCB *dma_bdrv_io( BlockDriverState *bs, QEMUSGList *sg, uint64_t sector_num, DMAIOFunc *io_func, BlockDriverCompletionFunc *cb, void *opaque, DMADirection dir) { DMAAIOCB *dbs = qemu_aio_get(&dma_aiocb_info, bs, cb, opaque); trace_dma_bdrv_io(dbs, bs, sector_num, (dir == DMA_DIRECTION_TO_DEVICE)); dbs->acb... | 18,635 |
1 | int nbd_client_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags) { NBDClientSession *client = nbd_get_client_session(bs); NBDRequest request = { .type = NBD_CMD_WRITE, .from = offset, .len = bytes, }; if (flags & BDRV_REQ_FUA) { assert(client->info.flags & NBD_FLAG_SEND_FU... | 18,636 |
1 | static abi_long host_to_target_data_route(struct nlmsghdr *nlh) { uint32_t nlmsg_len; struct ifinfomsg *ifi; struct ifaddrmsg *ifa; struct rtmsg *rtm; nlmsg_len = nlh->nlmsg_len; switch (nlh->nlmsg_type) { case RTM_NEWLINK: case RTM_DELLINK: case RTM_GETLINK: ifi = NLMSG_DATA(nlh); ifi->ifi_type = tswap16(ifi->ifi_type... | 18,637 |
0 | static int pcm_decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size) { PCMDecode *s = avctx->priv_data; int n; short *samples; uint8_t *src; samples = data; src = buf; if(buf_size > AVCODEC_MAX_AUDIO_FRAME_SIZE/2) buf_size = AVCODEC_MAX_AUDIO_FRAME_SIZE/2; switch(avctx->codec->id) ... | 18,638 |
0 | 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_MMX const uint8_t *mm_end; #endif uint16_t *d = (uint16_t *)dst; end = s + src_size; #ifdef HAVE_MMX mm_end = end - 15; #if 1 //is faster only if multiplies are reasonable fast... | 18,639 |
1 | static int64_t find_best_filter(const DCAADPCMEncContext *s, const int32_t *in, int len) { const premultiplied_coeffs *precalc_data = s->private_data; int i, j, k = 0; int vq; int64_t err; int64_t min_err = 1ll << 62; int64_t corr[15]; for (i = 0; i <= DCA_ADPCM_COEFFS; i++) for (j = i; j <= DCA_ADPCM_COEFFS; j++) corr... | 18,641 |
1 | static void dec_misc(DisasContext *dc, uint32_t insn) { uint32_t op0, op1; uint32_t ra, rb, rd; uint32_t L6, K5, K16, K5_11; int32_t I16, I5_11, N26; TCGMemOp mop; TCGv t0; op0 = extract32(insn, 26, 6); op1 = extract32(insn, 24, 2); ra = extract32(insn, 16, 5); rb = extract32(insn, 11, 5); rd = extract32(insn, 21, 5); ... | 18,642 |
1 | g_malloc0(size_t n_bytes) { void *mem; __coverity_negative_sink__(n_bytes); mem = calloc(1, n_bytes == 0 ? 1 : n_bytes); if (!mem) __coverity_panic__(); return mem; } | 18,644 |
1 | static ssize_t unix_writev_buffer(void *opaque, struct iovec *iov, int iovcnt, int64_t pos) { QEMUFileSocket *s = opaque; ssize_t len, offset; ssize_t size = iov_size(iov, iovcnt); ssize_t total = 0; assert(iovcnt > 0); offset = 0; while (size > 0) { /* Find the next start position; skip all full-sized vector elements ... | 18,645 |
0 | void ff_rfps_calculate(AVFormatContext *ic) { int i, j; for (i = 0; i < ic->nb_streams; i++) { AVStream *st = ic->streams[i]; if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO) continue; // the check for tb_unreliable() is not completely correct, since this is not about handling // a unreliable/inexact time base, but a t... | 18,647 |
0 | static int flac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt) { AVFrame *frame = data; ThreadFrame tframe = { .f = data }; const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; FLACContext *s = avctx->priv_data; int bytes_read = 0; int ret; *got_frame_ptr = 0; if (s->max_f... | 18,650 |
0 | static int nut_read_packet(AVFormatContext * avf, AVPacket * pkt) { NUTContext * priv = avf->priv_data; nut_packet_t pd; int ret; while ((ret = nut_read_next_packet(priv->nut, &pd)) < 0) av_log(avf, AV_LOG_ERROR, " NUT error: %s\n", nut_error(-ret)); if (ret || av_new_packet(pkt, pd.len) < 0) return -1; if (pd.flags & ... | 18,651 |
0 | void acpi_memory_unplug_request_cb(HotplugHandler *hotplug_dev, MemHotplugState *mem_st, DeviceState *dev, Error **errp) { MemStatus *mdev; mdev = acpi_memory_slot_status(mem_st, dev, errp); if (!mdev) { return; } /* nvdimm device hot unplug is not supported yet. */ assert(!object_dynamic_cast(OBJECT(dev), TYPE_NVDIMM)... | 18,652 |
0 | static inline uint32_t ne2000_mem_readl(NE2000State *s, uint32_t addr) { addr &= ~1; /* XXX: check exact behaviour if not even */ if (addr < 32 || (addr >= NE2000_PMEM_START && addr < NE2000_MEM_SIZE)) { return ldl_le_p(s->mem + addr); } else { return 0xffffffff; } } | 18,653 |
0 | static void jazz_led_write(void *opaque, target_phys_addr_t addr, uint64_t val, unsigned int size) { LedState *s = opaque; uint8_t new_val = val & 0xff; trace_jazz_led_write(addr, new_val); s->segments = new_val; s->state |= REDRAW_SEGMENTS; } | 18,654 |
0 | static void gd_grab_pointer(GtkDisplayState *s) { #if GTK_CHECK_VERSION(3, 0, 0) GdkDisplay *display = gtk_widget_get_display(s->drawing_area); GdkDeviceManager *mgr = gdk_display_get_device_manager(display); GList *devices = gdk_device_manager_list_devices(mgr, GDK_DEVICE_TYPE_MASTER); GList *tmp = devices; while (tmp... | 18,655 |
0 | static uint64_t virtio_pci_config_read(void *opaque, hwaddr addr, unsigned size) { VirtIOPCIProxy *proxy = opaque; uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev); uint64_t val = 0; if (addr < config) { return virtio_ioport_read(proxy, addr); } addr -= config; switch (size) { case 1: val = virtio_config_readb(prox... | 18,656 |
0 | void spapr_cpu_parse_features(sPAPRMachineState *spapr) { /* * Backwards compatibility hack: * * CPUs had a "compat=" property which didn't make sense for * anything except pseries. It was replaced by "max-cpu-compat" * machine option. This supports old command lines like * -cpu POWER8,compat=power7 * By stripping the ... | 18,657 |
0 | static void gen_debug(DisasContext *s, target_ulong cur_eip) { gen_update_cc_op(s); gen_jmp_im(cur_eip); gen_helper_debug(cpu_env); s->is_jmp = DISAS_TB_JUMP; } | 18,658 |
0 | int ff_request_frame(AVFilterLink *link) { int ret = -1; FF_TPRINTF_START(NULL, request_frame); ff_tlog_link(NULL, link, 1); if (link->closed) return AVERROR_EOF; av_assert0(!link->frame_requested); link->frame_requested = 1; while (link->frame_requested) { if (link->srcpad->request_frame) ret = link->srcpad->request_f... | 18,659 |
0 | static int pci_unin_agp_init_device(SysBusDevice *dev) { UNINState *s; int pci_mem_config, pci_mem_data; /* Uninorth AGP bus */ s = FROM_SYSBUS(UNINState, dev); pci_mem_config = cpu_register_io_memory(pci_unin_config_read, pci_unin_config_write, s); pci_mem_data = cpu_register_io_memory(pci_unin_main_read, pci_unin_mai... | 18,661 |
0 | nand_write(void *opaque, target_phys_addr_t addr, uint64_t value, unsigned size) { struct nand_state_t *s = opaque; int rdy; DNAND(printf("%s addr=%x v=%x\n", __func__, addr, (unsigned)value)); nand_setpins(s->nand, s->cle, s->ale, s->ce, 1, 0); nand_setio(s->nand, value); nand_getpins(s->nand, &rdy); s->rdy = rdy; } | 18,662 |
0 | static void omap_mpui_init(MemoryRegion *memory, target_phys_addr_t base, struct omap_mpu_state_s *mpu) { memory_region_init_io(&mpu->mpui_iomem, &omap_mpui_ops, mpu, "omap-mpui", 0x100); memory_region_add_subregion(memory, base, &mpu->mpui_iomem); omap_mpui_reset(mpu); } | 18,663 |
0 | static BusState *qbus_find(const char *path) { DeviceState *dev; BusState *bus; char elem[128], msg[256]; int pos, len; /* find start element */ if (path[0] == '/') { bus = main_system_bus; pos = 0; } else { if (sscanf(path, "%127[^/]%n", elem, &len) != 1) { qemu_error("path parse error (\"%s\")\n", path); return NULL;... | 18,664 |
0 | iscsi_aio_read16_cb(struct iscsi_context *iscsi, int status, void *command_data, void *opaque) { IscsiAIOCB *acb = opaque; trace_iscsi_aio_read16_cb(iscsi, status, acb, acb->canceled); if (acb->canceled != 0) { return; } acb->status = 0; if (status != 0) { if (status == SCSI_STATUS_CHECK_CONDITION && acb->task->sense.k... | 18,665 |
0 | void apic_sipi(CPUState *env) { APICState *s = env->apic_state; cpu_reset_interrupt(env, CPU_INTERRUPT_SIPI); if (!s->wait_for_sipi) return; env->eip = 0; cpu_x86_load_seg_cache(env, R_CS, s->sipi_vector << 8, s->sipi_vector << 12, 0xffff, 0); env->halted = 0; s->wait_for_sipi = 0; } | 18,666 |
0 | static int print_drive(DeviceState *dev, Property *prop, char *dest, size_t len) { DriveInfo **ptr = qdev_get_prop_ptr(dev, prop); return snprintf(dest, len, "%s", (*ptr) ? (*ptr)->id : "<null>"); } | 18,667 |
0 | static void pxa2xx_pic_mem_write(void *opaque, hwaddr offset, uint64_t value, unsigned size) { PXA2xxPICState *s = (PXA2xxPICState *) opaque; switch (offset) { case ICMR: /* Mask register */ s->int_enabled[0] = value; break; case ICMR2: /* Mask register 2 */ s->int_enabled[1] = value; break; case ICLR: /* Level registe... | 18,668 |
0 | static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp) { BDRVRawState *s = bs->opaque; char *buf; size_t max_align = MAX(MAX_BLOCKSIZE, getpagesize()); /* For SCSI generic devices the alignment is not really used. With buffered I/O, we don't have any restrictions. */ if (bdrv_is_sg(bs) || !s->needs... | 18,669 |
0 | static void filter_frame(H264Context *h) { int mb_x = 0; int mb_y = 0; for( mb_y = 0; mb_y < h->s.mb_height; mb_y++ ) { for( mb_x = 0; mb_x < h->s.mb_width; mb_x++ ) { filter_mb( h, mb_x, mb_y ); } } } | 18,670 |
0 | static int xen_pt_msgaddr64_reg_write(XenPCIPassthroughState *s, XenPTReg *cfg_entry, uint32_t *val, uint32_t dev_value, uint32_t valid_mask) { XenPTRegInfo *reg = cfg_entry->reg; uint32_t writable_mask = 0; uint32_t old_addr = cfg_entry->data; /* check whether the type is 64 bit or not */ if (!(s->msi->flags & PCI_MSI... | 18,671 |
0 | static int v9fs_synth_close(FsContext *ctx, V9fsFidOpenState *fs) { V9fsSynthOpenState *synth_open = fs->private; V9fsSynthNode *node = synth_open->node; node->open_count--; g_free(synth_open); fs->private = NULL; return 0; } | 18,672 |
0 | static void monitor_handle_command(Monitor *mon, const char *cmdline) { const char *p, *pstart, *typestr; char *q; int c, nb_args, len, i, has_arg; const mon_cmd_t *cmd; char cmdname[256]; char buf[1024]; void *str_allocated[MAX_ARGS]; void *args[MAX_ARGS]; void (*handler_0)(Monitor *mon); void (*handler_1)(Monitor *mo... | 18,674 |
0 | static void nvic_systick_trigger(void *opaque, int n, int level) { NVICState *s = opaque; if (level) { /* SysTick just asked us to pend its exception. * (This is different from an external interrupt line's * behaviour.) */ armv7m_nvic_set_pending(s, ARMV7M_EXCP_SYSTICK); } } | 18,676 |
0 | int32_t helper_fqtoi(CPUSPARCState *env) { int32_t ret; clear_float_exceptions(env); ret = float128_to_int32_round_to_zero(QT1, &env->fp_status); check_ieee_exceptions(env); return ret; } | 18,677 |
0 | void qemu_opts_print(QemuOpts *opts, const char *separator) { QemuOpt *opt; QemuOptDesc *desc = opts->list->desc; const char *sep = ""; if (opts->id) { printf("id=%s", opts->id); /* passed id_wellformed -> no commas */ sep = separator; } if (desc[0].name == NULL) { QTAILQ_FOREACH(opt, &opts->head, next) { printf("%s%s=... | 18,678 |
0 | static void adb_keyboard_event(DeviceState *dev, QemuConsole *src, InputEvent *evt) { KBDState *s = (KBDState *)dev; int qcode, keycode; qcode = qemu_input_key_value_to_qcode(evt->u.key.data->key); if (qcode >= ARRAY_SIZE(qcode_to_adb_keycode)) { return; } keycode = qcode_to_adb_keycode[qcode]; if (evt->u.key.data->dow... | 18,679 |
0 | static void nvram_writew (void *opaque, target_phys_addr_t addr, uint32_t value) { M48t59State *NVRAM = opaque; m48t59_write(NVRAM, addr, (value >> 8) & 0xff); m48t59_write(NVRAM, addr + 1, value & 0xff); } | 18,680 |
0 | void dsputilenc_init_mmx(DSPContext* c, AVCodecContext *avctx) { if (mm_flags & FF_MM_MMX) { const int dct_algo = avctx->dct_algo; if(dct_algo==FF_DCT_AUTO || dct_algo==FF_DCT_MMX){ if(mm_flags & FF_MM_SSE2){ c->fdct = ff_fdct_sse2; }else if(mm_flags & FF_MM_MMX2){ c->fdct = ff_fdct_mmx2; }else{ c->fdct = ff_fdct_mmx; ... | 18,681 |
0 | PCIINTxRoute pci_device_route_intx_to_irq(PCIDevice *dev, int pin) { PCIBus *bus; do { bus = dev->bus; pin = bus->map_irq(dev, pin); dev = bus->parent_dev; } while (dev); assert(bus->route_intx_to_irq); return bus->route_intx_to_irq(bus->irq_opaque, pin); } | 18,682 |
0 | static void uhci_frame_timer(void *opaque) { UHCIState *s = opaque; int64_t expire_time; uint32_t frame_addr, link, old_td_ctrl, val, int_mask; int cnt, ret; UHCI_TD td; UHCI_QH qh; uint32_t old_async_qh; if (!(s->cmd & UHCI_CMD_RS)) { qemu_del_timer(s->frame_timer); /* set hchalted bit in status - UHCI11D 2.1.2 */ s->... | 18,683 |
0 | static int block_save_iterate(QEMUFile *f, void *opaque) { int ret; DPRINTF("Enter save live iterate submitted %d transferred %d\n", block_mig_state.submitted, block_mig_state.transferred); ret = flush_blks(f); if (ret) { blk_mig_cleanup(); return ret; } blk_mig_reset_dirty_cursor(); /* control the rate of transfer */ ... | 18,684 |
0 | sdhci_readfn(void *opaque, hwaddr offset, unsigned size) { SDHCIState *s = (SDHCIState *)opaque; return SDHCI_GET_CLASS(s)->mem_read(s, offset, size); } | 18,685 |
0 | void migrate_fd_error(MigrationState *s) { DPRINTF("setting error state\n"); s->state = MIG_STATE_ERROR; notifier_list_notify(&migration_state_notifiers, s); migrate_fd_cleanup(s); } | 18,686 |
1 | static int virtio_scsi_load(QEMUFile *f, void *opaque, int version_id) { VirtIOSCSI *s = opaque; virtio_load(&s->vdev, f); return 0; } | 18,687 |
1 | static int ebml_read_ascii(AVIOContext *pb, int size, char **str) { av_free(*str); /* EBML strings are usually not 0-terminated, so we allocate one * byte more, read the string and NULL-terminate it ourselves. */ if (!(*str = av_malloc(size + 1))) return AVERROR(ENOMEM); if (avio_read(pb, (uint8_t *) *str, size) != siz... | 18,688 |
1 | ARITH3(addlv) ARITH3(sublv) ARITH3(addqv) ARITH3(subqv) ARITH3(umulh) ARITH3(mullv) ARITH3(mulqv) ARITH3(minub8) ARITH3(minsb8) ARITH3(minuw4) ARITH3(minsw4) ARITH3(maxub8) ARITH3(maxsb8) ARITH3(maxuw4) ARITH3(maxsw4) ARITH3(perr) #define MVIOP2(name) \ static inline void glue(gen_, name)(int rb, int rc) \ { \ if (unli... | 18,689 |
1 | void ppc_store_sdr1(CPUPPCState *env, target_ulong value) { LOG_MMU("%s: " TARGET_FMT_lx "\n", __func__, value); if (env->spr[SPR_SDR1] != value) { env->spr[SPR_SDR1] = value; #if defined(TARGET_PPC64) if (env->mmu_model & POWERPC_MMU_64) { target_ulong htabsize = value & SDR_64_HTABSIZE; if (htabsize > 28) { fprintf(s... | 18,690 |
1 | void stream_start(BlockDriverState *bs, BlockDriverState *base, const char *backing_file_str, int64_t speed, BlockdevOnError on_error, BlockCompletionFunc *cb, void *opaque, Error **errp) { StreamBlockJob *s; s = block_job_create(&stream_job_driver, bs, speed, cb, opaque, errp); if (!s) { return; } s->base = base; s->b... | 18,691 |
1 | static void clear_sel(IPMIBmcSim *ibs, uint8_t *cmd, unsigned int cmd_len, uint8_t *rsp, unsigned int *rsp_len, unsigned int max_rsp_len) { IPMI_CHECK_CMD_LEN(8); IPMI_CHECK_RESERVATION(2, ibs->sel.reservation); if (cmd[4] != 'C' || cmd[5] != 'L' || cmd[6] != 'R') { rsp[2] = IPMI_CC_INVALID_DATA_FIELD; return; } if (cm... | 18,692 |
1 | int ff_spatial_idwt_init2(DWTContext *d, IDWTELEM *buffer, int width, int height, int stride, enum dwt_type type, int decomposition_count, IDWTELEM *temp) { int level; d->buffer = buffer; d->width = width; d->height = height; d->stride = stride; d->decomposition_count = decomposition_count; d->temp = temp + 8; for(leve... | 18,693 |
1 | static void m68k_cpu_realizefn(DeviceState *dev, Error **errp) { M68kCPU *cpu = M68K_CPU(dev); M68kCPUClass *mcc = M68K_CPU_GET_CLASS(dev); m68k_cpu_init_gdb(cpu); cpu_reset(CPU(cpu)); mcc->parent_realize(dev, errp); } | 18,694 |
1 | void netdev_del_completion(ReadLineState *rs, int nb_args, const char *str) { int len, count, i; NetClientState *ncs[MAX_QUEUE_NUM]; if (nb_args != 2) { return; } len = strlen(str); readline_set_completion_index(rs, len); count = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_OPTIONS_KIND_NIC, MAX_QUEUE_NUM); for (... | 18,695 |
1 | static void caps_to_network(RDMACapabilities *cap) { cap->version = htonl(cap->version); cap->flags = htonl(cap->flags); } | 18,697 |
1 | static void piix4_acpi_system_hot_add_init(PCIBus *bus, PIIX4PMState *s) { register_ioport_write(GPE_BASE, GPE_LEN, 1, gpe_writeb, s); register_ioport_read(GPE_BASE, GPE_LEN, 1, gpe_readb, s); acpi_gpe_blk(&s->ar, GPE_BASE); register_ioport_read(PCI_UP_BASE, 4, 4, pci_up_read, s); register_ioport_read(PCI_DOWN_BASE, 4,... | 18,698 |
1 | void qmp_drive_backup(const char *device, const char *target, bool has_format, const char *format, enum MirrorSyncMode sync, bool has_mode, enum NewImageMode mode, bool has_speed, int64_t speed, bool has_on_source_error, BlockdevOnError on_source_error, bool has_on_target_error, BlockdevOnError on_target_error, Error *... | 18,699 |
1 | static uint32_t parse_enumeration(char *str, EnumTable *table, uint32_t not_found_value) { uint32_t ret = not_found_value; while (table->name != NULL) { if (strcmp(table->name, str) == 0) { ret = table->value; break; } table++; } return ret; } | 18,701 |
1 | static int mov_probe(AVProbeData *p) { unsigned int offset; uint32_t tag; int score = 0; /* check file header */ offset = 0; for (;;) { /* ignore invalid offset */ if ((offset + 8) > (unsigned int)p->buf_size) return score; tag = AV_RL32(p->buf + offset + 4); switch(tag) { /* check for obvious tags */ case MKTAG('j','P... | 18,703 |
1 | static void virtser_port_device_realize(DeviceState *dev, Error **errp) { VirtIOSerialPort *port = VIRTIO_SERIAL_PORT(dev); VirtIOSerialPortClass *vsc = VIRTIO_SERIAL_PORT_GET_CLASS(port); VirtIOSerialBus *bus = VIRTIO_SERIAL_BUS(qdev_get_parent_bus(dev)); VirtIODevice *vdev = VIRTIO_DEVICE(bus->vser); int max_nr_ports... | 18,704 |
1 | YUV2RGB(rgb8, uint8_t) YUV2RGB(rgb16, uint16_t) /* process exactly one decompressed row */ static void png_handle_row(PNGDecContext *s) { uint8_t *ptr, *last_row; int got_line; if (!s->interlace_type) { ptr = s->image_buf + s->image_linesize * (s->y + s->y_offset) + s->x_offset * s->bpp; if (s->y == 0) last_row = s->la... | 18,705 |
1 | static void gen_iccci(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 } | 18,707 |
1 | void qemu_savevm_state_complete_precopy(QEMUFile *f, bool iterable_only) { QJSON *vmdesc; int vmdesc_len; SaveStateEntry *se; int ret; bool in_postcopy = migration_in_postcopy(); trace_savevm_state_complete_precopy(); cpu_synchronize_all_states(); QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { if (!se->ops || (in_... | 18,708 |
1 | static void openrisc_cpu_initfn(Object *obj) { CPUState *cs = CPU(obj); OpenRISCCPU *cpu = OPENRISC_CPU(obj); static int inited; cs->env_ptr = &cpu->env; cpu_exec_init(cs, &error_abort); #ifndef CONFIG_USER_ONLY cpu_openrisc_mmu_init(cpu); #endif if (tcg_enabled() && !inited) { inited = 1; openrisc_translate_init(); } ... | 18,709 |
1 | int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id, int apply_defdispwin, AVBufferRef **vps_list, AVCodecContext *avctx) { HEVCWindow *ow; int ret = 0; int log2_diff_max_min_transform_block_size; int bit_depth_chroma, start, vui_present, sublayer_ordering_info; int i; // Coded parameters sps->v... | 18,710 |
1 | static int eject_device(Monitor *mon, BlockDriverState *bs, int force) { if (bdrv_is_inserted(bs)) { if (!force) { if (!bdrv_is_removable(bs)) { qerror_report(QERR_DEVICE_NOT_REMOVABLE, bdrv_get_device_name(bs)); return -1; } if (bdrv_is_locked(bs)) { qerror_report(QERR_DEVICE_LOCKED, bdrv_get_device_name(bs)); return ... | 18,711 |
1 | int vnc_display_open(DisplayState *ds, const char *display) { VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display; const char *options; int password = 0; int reverse = 0; int to_port = 0; #ifdef CONFIG_VNC_TLS int tls = 0, x509 = 0; #endif if (!vnc_display) return -1; vnc_display_close(ds); if (strcmp(display,... | 18,712 |
0 | static int need_output(void) { int i; for (i = 0; i < nb_output_streams; i++) { OutputStream *ost = output_streams[i]; OutputFile *of = output_files[ost->file_index]; AVFormatContext *os = output_files[ost->file_index]->ctx; if (ost->is_past_recording_time || (os->pb && avio_tell(os->pb) >= of->limit_filesize)) continu... | 18,713 |
1 | void qmp_migrate_set_speed(int64_t value, Error **errp) { MigrationState *s; if (value < 0) { value = 0; } if (value > SIZE_MAX) { value = SIZE_MAX; } s = migrate_get_current(); s->bandwidth_limit = value; if (s->file) { qemu_file_set_rate_limit(s->file, s->bandwidth_limit / XFER_LIMIT_RATIO); } } | 18,714 |
1 | void aio_set_event_notifier(AioContext *ctx, EventNotifier *e, bool is_external, EventNotifierHandler *io_notify) { AioHandler *node; QLIST_FOREACH(node, &ctx->aio_handlers, node) { if (node->e == e && !node->deleted) { break; } } /* Are we deleting the fd handler? */ if (!io_notify) { if (node) { g_source_remove_poll(... | 18,715 |
1 | static av_cold int ulti_decode_init(AVCodecContext *avctx) { UltimotionDecodeContext *s = avctx->priv_data; s->avctx = avctx; s->width = avctx->width; s->height = avctx->height; s->blocks = (s->width / 8) * (s->height / 8); avctx->pix_fmt = AV_PIX_FMT_YUV410P; s->ulti_codebook = ulti_codebook; s->frame = av_frame_alloc... | 18,716 |
1 | static void setup_vm_cmd(IVState *s, const char *cmd, bool msix) { uint64_t barsize; s->qtest = qtest_start(cmd); s->pcibus = qpci_init_pc(NULL); s->dev = get_device(s->pcibus); s->reg_base = qpci_iomap(s->dev, 0, &barsize); g_assert_nonnull(s->reg_base); g_assert_cmpuint(barsize, ==, 256); if (msix) { qpci_msix_enable... | 18,717 |
1 | static int xvag_read_header(AVFormatContext *s) { unsigned offset, big_endian, codec; AVStream *st; avio_skip(s->pb, 4); st = avformat_new_stream(s, NULL); if (!st) return AVERROR(ENOMEM); st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO; offset = avio_rl32(s->pb); big_endian = offset > av_bswap32(offset); if (big_endian)... | 18,718 |
1 | void ff_imdct_calc_sse(MDCTContext *s, FFTSample *output, const FFTSample *input, FFTSample *tmp) { x86_reg k; long n8, n4, n2, n; const uint16_t *revtab = s->fft.revtab; const FFTSample *tcos = s->tcos; const FFTSample *tsin = s->tsin; const FFTSample *in1, *in2; FFTComplex *z = (FFTComplex *)tmp; n = 1 << s->nbits; n... | 18,720 |
1 | static void nvme_init_sq(NvmeSQueue *sq, NvmeCtrl *n, uint64_t dma_addr, uint16_t sqid, uint16_t cqid, uint16_t size) { int i; NvmeCQueue *cq; sq->ctrl = n; sq->dma_addr = dma_addr; sq->sqid = sqid; sq->size = size; sq->cqid = cqid; sq->head = sq->tail = 0; sq->io_req = g_malloc(sq->size * sizeof(*sq->io_req)); QTAILQ_... | 18,721 |
1 | static int qemu_chr_open_pp(QemuOpts *opts, CharDriverState **_chr) { const char *filename = qemu_opt_get(opts, "path"); CharDriverState *chr; int fd; fd = qemu_open(filename, O_RDWR); if (fd < 0) { return -errno; } chr = g_malloc0(sizeof(CharDriverState)); chr->opaque = (void *)(intptr_t)fd; chr->chr_write = null_chr_... | 18,722 |
0 | static int kvm_put_fpu(X86CPU *cpu) { CPUX86State *env = &cpu->env; struct kvm_fpu fpu; int i; memset(&fpu, 0, sizeof fpu); fpu.fsw = env->fpus & ~(7 << 11); fpu.fsw |= (env->fpstt & 7) << 11; fpu.fcw = env->fpuc; fpu.last_opcode = env->fpop; fpu.last_ip = env->fpip; fpu.last_dp = env->fpdp; for (i = 0; i < 8; ++i) { f... | 18,725 |
0 | static void test_visitor_out_native_list_int64(TestOutputVisitorData *data, const void *unused) { test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_S64); } | 18,726 |
0 | static void v9fs_req_recv(P9Req *req, uint8_t id) { QVirtIO9P *v9p = req->v9p; P9Hdr hdr; int i; for (i = 0; i < 10; i++) { qvirtio_wait_queue_isr(v9p->dev, v9p->vq, 1000 * 1000); v9fs_memread(req, &hdr, 7); le32_to_cpus(&hdr.size); le16_to_cpus(&hdr.tag); if (hdr.size >= 7) { break; } v9fs_memrewind(req, 7); } g_asser... | 18,728 |
0 | static void set_algorythm( OPL_CH *CH) { INT32 *carrier = &outd[0]; CH->connect1 = CH->CON ? carrier : &feedback2; CH->connect2 = carrier; } | 18,729 |
0 | void bios_linker_loader_alloc(GArray *linker, const char *file, uint32_t alloc_align, bool alloc_fseg) { BiosLinkerLoaderEntry entry; memset(&entry, 0, sizeof entry); strncpy(entry.alloc.file, file, sizeof entry.alloc.file - 1); entry.command = cpu_to_le32(BIOS_LINKER_LOADER_COMMAND_ALLOCATE); entry.alloc.align = cpu_t... | 18,730 |
0 | static int count_contiguous_clusters(uint64_t nb_clusters, int cluster_size, uint64_t *l2_table, uint64_t stop_flags) { int i; uint64_t mask = stop_flags | L2E_OFFSET_MASK | QCOW_OFLAG_COMPRESSED; uint64_t first_entry = be64_to_cpu(l2_table[0]); uint64_t offset = first_entry & mask; if (!offset) return 0; assert(qcow2_... | 18,731 |
0 | START_TEST(qlist_iter_test) { int i; QList *qlist; qlist = qlist_new(); for (i = 0; i < iter_max; i++) qlist_append(qlist, qint_from_int(i)); iter_called = 0; qlist_iter(qlist, iter_func, NULL); fail_unless(iter_called == iter_max); QDECREF(qlist); } | 18,732 |
0 | static int setup_sigcontext(struct target_sigcontext *sc, CPUOpenRISCState *regs, unsigned long mask) { int err = 0; unsigned long usp = regs->gpr[1]; /* copy the regs. they are first in sc so we can use sc directly */ /*copy_to_user(&sc, regs, sizeof(struct target_pt_regs));*/ /* Set the frametype to CRIS_FRAME_NORMAL... | 18,733 |
0 | void ff_avg_h264_qpel16_mc11_msa(uint8_t *dst, const uint8_t *src, ptrdiff_t stride) { avc_luma_hv_qrt_and_aver_dst_16x16_msa(src - 2, src - (stride * 2), stride, dst, stride); } | 18,734 |
0 | build_fadt(GArray *table_data, BIOSLinker *linker, AcpiPmInfo *pm, unsigned facs_tbl_offset, unsigned dsdt_tbl_offset, const char *oem_id, const char *oem_table_id) { AcpiFadtDescriptorRev1 *fadt = acpi_data_push(table_data, sizeof(*fadt)); unsigned fw_ctrl_offset = (char *)&fadt->firmware_ctrl - table_data->data; unsi... | 18,735 |
0 | static void m68k_cpu_reset(CPUState *s) { M68kCPU *cpu = M68K_CPU(s); M68kCPUClass *mcc = M68K_CPU_GET_CLASS(cpu); CPUM68KState *env = &cpu->env; mcc->parent_reset(s); memset(env, 0, offsetof(CPUM68KState, end_reset_fields)); #if !defined(CONFIG_USER_ONLY) env->sr = 0x2700; #endif m68k_switch_sp(env); /* ??? FP regs sh... | 18,737 |
0 | static void subpage_ram_write(void *opaque, target_phys_addr_t addr, uint64_t value, unsigned size) { ram_addr_t raddr = addr; void *ptr = qemu_get_ram_ptr(raddr); switch (size) { case 1: return stb_p(ptr, value); case 2: return stw_p(ptr, value); case 4: return stl_p(ptr, value); default: abort(); } } | 18,738 |
0 | static bool vfio_listener_skipped_section(MemoryRegionSection *section) { return !memory_region_is_ram(section->mr); } | 18,739 |
0 | coroutine_fn iscsi_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int count, BdrvRequestFlags flags) { IscsiLun *iscsilun = bs->opaque; struct IscsiTask iTask; uint64_t lba; uint32_t nb_blocks; bool use_16_for_ws = iscsilun->use_16_for_rw; if (!is_byte_request_lun_aligned(offset, count, iscsilun)) { return -ENO... | 18,740 |
0 | void net_slirp_redir(const char *redir_str) { int is_udp; char buf[256], *r; const char *p; struct in_addr guest_addr; int host_port, guest_port; if (!slirp_inited) { slirp_inited = 1; slirp_init(0, NULL); } p = redir_str; if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) goto fail; if (!strcmp(buf, "tcp")) { is_udp = 0;... | 18,742 |
0 | static uint64_t omap2_inth_read(void *opaque, target_phys_addr_t addr, unsigned size) { struct omap_intr_handler_s *s = (struct omap_intr_handler_s *) opaque; int offset = addr; int bank_no, line_no; struct omap_intr_handler_bank_s *bank = NULL; if ((offset & 0xf80) == 0x80) { bank_no = (offset & 0x60) >> 5; if (bank_n... | 18,743 |
0 | static int wav_read_header(AVFormatContext *s) { int64_t size, av_uninit(data_size); int64_t sample_count = 0; int rf64; uint32_t tag; AVIOContext *pb = s->pb; AVStream *st = NULL; WAVDemuxContext *wav = s->priv_data; int ret, got_fmt = 0; int64_t next_tag_ofs, data_ofs = -1; wav->unaligned = avio_tell(s->pb) & 1; wav-... | 18,745 |
0 | static void pc_init1(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, int pci_enabled, const char *cpu_model) { char buf[1024]; int ret, linux_boot, i; ram_addr_t ram_addr, vga_ram_addr, bios_offset, v... | 18,746 |
0 | static void bonito_writel(void *opaque, target_phys_addr_t addr, uint32_t val) { PCIBonitoState *s = opaque; uint32_t saddr; int reset = 0; saddr = (addr - BONITO_REGBASE) >> 2; DPRINTF("bonito_writel "TARGET_FMT_plx" val %x saddr %x \n", addr, val, saddr); switch (saddr) { case BONITO_BONPONCFG: case BONITO_IODEVCFG: ... | 18,747 |
0 | int socket_dgram(SocketAddressLegacy *remote, SocketAddressLegacy *local, Error **errp) { int fd; /* * TODO SOCKET_ADDRESS_LEGACY_KIND_FD when fd is AF_INET or AF_INET6 * (although other address families can do SOCK_DGRAM, too) */ switch (remote->type) { case SOCKET_ADDRESS_LEGACY_KIND_INET: fd = inet_dgram_saddr(remot... | 18,748 |
0 | static void filter_line_c(uint8_t *dst, uint8_t *prev, uint8_t *cur, uint8_t *next, int w, int refs, int parity, int mode) { int x; uint8_t *prev2 = parity ? prev : cur ; uint8_t *next2 = parity ? cur : next; for (x = 0; x < w; x++) { int c = cur[-refs]; int d = (prev2[0] + next2[0])>>1; int e = cur[+refs]; int tempora... | 18,750 |
0 | static void opt_video_channel(const char *arg) { video_channel = strtol(arg, NULL, 0); } | 18,751 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.