Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
qemu | fpu/softfloat.c | uint32 float64_to_uint32(float64 a STATUS_PARAM)
{
int64_t v;
uint32 res;
v = float64_to_int64(a STATUS_VAR);
if (v < 0) {
res = 0;
float_raise(float_flag_invalid STATUS_VAR);
} else if (v > 0xffffffff) {
res = 0xffffffff;
float_raise(float_flag_invalid STATUS_VAR);
} else {
... | [
1,
0
] |
qemu | hw/9pfs/9p.c | static void virtio_gpu_handle_cursor(VirtIODevice *vdev, VirtQueue *vq)
{
VirtIOGPU *g = VIRTIO_GPU(vdev);
VirtQueueElement elem;
size_t s;
struct virtio_gpu_update_cursor cursor_info;
if (!virtio_queue_ready(vq)) {
return;
}
while (virtqueue_pop(vq, &elem)) {
s = iov_to_buf(elem.out_sg, ... | [
1,
0
] |
qemu | block/dirty-bitmap.c | void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
int64_t cur_sector, int64_t nr_sectors)
{
assert(bdrv_dirty_bitmap_enabled(bitmap));
hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
} | [
0,
0
] |
FFmpeg | libavcodec/cook_parser.c | static int cook_parse(AVCodecParserContext *s1, AVCodecContext *avctx,
const uint8_t **poutbuf, int *poutbuf_size,
const uint8_t *buf, int buf_size)
{
CookParseContext *s = s1->priv_data;
if (s->duration)
s1->duration = s->duration;
else if (avctx->extradata ... | [
1,
0
] |
FFmpeg | avconv_opt.c | static int set_string(void *obj, const AVOption *o, const char *val,
uint8_t **dst)
{
av_freep(dst);
*dst = av_strdup(val);
return 0;
} | [
0,
0
] |
qemu | hw/char/pl011.c | static uint64_t pl011_read(void *opaque, hwaddr offset,
unsigned size)
{
PL011State *s = (PL011State *)opaque;
uint32_t c;
if (offset >= 0xfe0 && offset < 0x1000) {
return s->id[(offset - 0xfe0) >> 2];
}
switch (offset >> 2) {
case 0: /* UARTDR */
s->flags &= ~PL0... | [
1,
0
] |
qemu | block/blkdebug.c | static BlockAIOCB *inject_error(BlockDriverState *bs,
BlockCompletionFunc *cb, void *opaque,
BlkdebugRule *rule)
{
BDRVBlkdebugState *s = bs->opaque;
int error = rule->options.inject.error;
struct BlkdebugAIOCB *acb;
QEMUBH *bh;
if (rule->... | [
1,
0
] |
qemu | net/colo-compare.c | static void colo_old_packet_check_one_conn(void *opaque,
void *user_data)
{
Connection *conn = opaque;
GList *result = NULL;
int64_t check_time = REGULAR_PACKET_CHECK_MS;
result = g_queue_find_custom(&conn->primary_list,
&check_tim... | [
1,
1
] |
qemu | tests/tcg/cris/check_abs.c | static inline void cris_ftag_d(unsigned int x)
{
register unsigned int v asm("$r10") = x;
asm("ftagd\t[%0]\n" : : "r"(v));
} | [
1,
0
] |
qemu | hw/ppc/spapr.c | int spapr_h_cas_compose_response(sPAPRMachineState *spapr, target_ulong addr,
target_ulong size,
sPAPROptionVector *ov5_updates) {
void *fdt, *fdt_skel;
sPAPRDeviceTreeUpdateHeader hdr = {.version_id = 1};
if (spapr_hotplugged_dev_before_cas()) {
... | [
1,
0
] |
FFmpeg | libavformat/smoothstreamingenc.c | static int ism_write_packet(AVFormatContext *s, AVPacket *pkt)
{
SmoothStreamingContext *c = s->priv_data;
AVStream *st = s->streams[pkt->stream_index];
OutputStream *os = &c->streams[pkt->stream_index];
int64_t end_dts = (c->nb_fragments + 1) * c->min_frag_duration;
int ret;
if (st->first_dts == AV_... | [
1,
0
] |
FFmpeg | libswscale/swscale_template.c | static inline void RENAME(bgr16ToY)(uint8_t *dst, uint8_t *src, int width)
{
int i;
for (i = 0; i < width; i++)
{
int d = ((uint16_t *)src)[i];
int b = d & 0x1F;
int g = (d >> 5) & 0x3F;
int r = (d >> 11) & 0x1F;
dst[i] = ((2 * RY * r + GY * g + 2 * BY * b) >> (RGB2YUV_SHIFT - 2)) + 1... | [
1,
0
] |
qemu | block/crypto.c | static void qmp_output_end_struct(Visitor *v, Error **errp)
{
QmpOutputVisitor *qov = to_qov(v);
QObject *value = qmp_output_pop(qov);
assert(qobject_type(value) == QTYPE_QDICT);
} | [
1,
0
] |
qemu | tcg/s390/tcg-target.c | static void tcg_out_qemu_st(TCGContext *s, TCGReg data_reg, TCGReg addr_reg,
TCGMemOpIdx oi)
{
TCGMemOp opc = get_memop(oi);
#ifdef CONFIG_SOFTMMU
unsigned mem_index = get_mmuidx(oi);
tcg_insn_unit *label_ptr;
TCGReg base_reg;
base_reg = tcg_out_tlb_read(s, addr_reg, opc, m... | [
1,
0
] |
qemu | hw/net/e1000.c | putsum(uint8_t *data, uint32_t n, uint32_t sloc, uint32_t css, uint32_t cse)
{
uint32_t sum;
if (cse && cse < n)
n = cse + 1;
if (sloc < n - 1) {
sum = net_checksum_add(n - css, data + css);
stw_be_p(data + sloc, net_checksum_finish(sum));
}
} | [
1,
0
] |
qemu | target-sparc/translate.c | static inline void gen_op_sdivx(TCGv dst, TCGv src1, TCGv src2)
{
int l1, l2;
l1 = gen_new_label();
l2 = gen_new_label();
tcg_gen_mov_tl(cpu_cc_src, src1);
tcg_gen_mov_tl(cpu_cc_src2, src2);
gen_trap_ifdivzero_tl(cpu_cc_src2);
tcg_gen_brcondi_tl(TCG_COND_NE, cpu_cc_src, INT64_MIN, l1);
tcg_gen_... | [
1,
0
] |
qemu | hw/9pfs/9p.c | static void coroutine_fn v9fs_xattrcreate(void *opaque)
{
int flags;
int32_t fid;
int64_t size;
ssize_t err = 0;
V9fsString name;
size_t offset = 7;
V9fsFidState *file_fidp;
V9fsFidState *xattr_fidp;
V9fsPDU *pdu = opaque;
v9fs_string_init(&name);
err = pdu_unmarshal(pdu, offset, "dsqd... | [
1,
0
] |
qemu | include/qapi/error.h | static void test_visitor_in_int_overflow(TestInputVisitorData *data,
const void *unused)
{
int64_t res = 0;
Error *err = NULL;
Visitor *v;
/* this will overflow a Qint/int64, so should be deserialized into
* a QFloat/double field instead, leading to an error if... | [
1,
0
] |
FFmpeg | libavcodec/aacenc_tns.c | static inline void quantize_coefs(double *coef, int *idx, float *lpc, int order,
int c_bits)
{
int i;
const float *quant_arr = tns_tmp2_map[c_bits];
for (i = 0; i < order; i++) {
idx[i] = quant_array_idx((float)coef[i], quant_arr, c_bits ? 16 : 8);
lpc[i] = quant_a... | [
0,
0
] |
qemu | target-arm/translate-a64.c | static void write_fp_dreg(DisasContext *s, int reg, TCGv_i64 v)
{
TCGv_i64 tcg_zero = tcg_const_i64(0);
tcg_gen_st_i64(v, cpu_env, fp_reg_offset(reg, MO_64));
tcg_gen_st_i64(tcg_zero, cpu_env, fp_reg_hi_offset(reg));
tcg_temp_free_i64(tcg_zero);
} | [
0,
0
] |
qemu | target/s390x/mem_helper.c | uint32_t HELPER(clcle)(CPUS390XState *env, uint32_t r1, uint64_t a2,
uint32_t r3)
{
uintptr_t ra = GETPC();
uint64_t destlen = get_length(env, r1 + 1);
uint64_t dest = get_address(env, r1);
uint64_t srclen = get_length(env, r3 + 1);
uint64_t src = get_address(env, r3);
uint8_t... | [
1,
0
] |
qemu | blockjob.c | static void block_job_unref(BlockJob *job)
{
if (--job->refcnt == 0) {
BlockDriverState *bs = blk_bs(job->blk);
bs->job = NULL;
block_job_remove_all_bdrv(job);
blk_remove_aio_context_notifier(job->blk,
block_job_attached_aio_context,
... | [
1,
0
] |
FFmpeg | libavcodec/mpeg12.c | static int mpeg_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
Mpeg1Context *s = avctx->priv_data;
AVFrame *picture = data;
MpegEncContext *s2 = &... | [
1,
0
] |
FFmpeg | libavcodec/h264_refs.c | void ff_h264_remove_all_refs(H264Context *h)
{
int i;
for (i = 0; i < 16; i++) {
remove_long(h, i, 0);
}
assert(h->long_ref_count == 0);
if (h->short_ref_count && !h->last_pic_for_ec.f->data[0]) {
ff_h264_unref_picture(h, &h->last_pic_for_ec);
if (h->short_ref[0]->f->buf[0])
ff_h264... | [
1,
0
] |
qemu | audio/alsaaudio.c | static int oss_init_in(HWVoiceIn *hw, struct audsettings *as)
{
OSSVoiceIn *oss = (OSSVoiceIn *)hw;
struct oss_params req, obt;
int endianness;
int err;
int fd;
audfmt_e effective_fmt;
struct audsettings obt_as;
oss->fd = -1;
req.fmt = aud_to_ossfmt(as->fmt, as->endianness);
req.freq = as... | [
1,
0
] |
qemu | hw/intc/xics.c | static void pnv_icp_realize(DeviceState *dev, Error **errp)
{
PnvICPState *icp = PNV_ICP(dev);
memory_region_init_io(&icp->mmio, OBJECT(dev), &pnv_icp_ops,
icp, "icp-thread", 0x1000);
} | [
0,
0
] |
qemu | hw/usb/bus.c | static void usb_device_class_init(ObjectClass *klass, void *data)
{
DeviceClass *k = DEVICE_CLASS(klass);
k->bus_type = TYPE_USB_BUS;
k->init = usb_qdev_init;
k->unplug = qdev_simple_unplug_cb;
k->exit = usb_qdev_exit;
k->props = usb_props;
} | [
0,
0
] |
qemu | hw/ppc/spapr_hcall.c | const ppc_hash_pte64_t *ppc_hash64_map_hptes(PowerPCCPU *cpu,
hwaddr ptex, int n)
{
ppc_hash_pte64_t *hptes = NULL;
hwaddr pte_offset = ptex * HASH_PTE_SIZE_64;
if (cpu->env.external_htab == MMU_HASH64_KVM_MANAGED_HPT) {
/*
* HTAB is controlled by KVM. ... | [
1,
0
] |
qemu | hw/nseries.c | static struct omap_rtc_s *omap_rtc_init(MemoryRegion *system_memory,
target_phys_addr_t base,
qemu_irq *irq, omap_clk clk)
{
struct omap_rtc_s *s = (struct omap_rtc_s *)
g_malloc0(sizeof(struct omap_rtc_s));
s->irq = irq[0];... | [
0,
0
] |
qemu | block/vvfat.c | int tcp_ctl(struct socket *so)
{
Slirp *slirp = so->slirp;
struct sbuf *sb = &so->so_snd;
struct ex_list *ex_ptr;
int do_pty;
DEBUG_CALL("tcp_ctl");
DEBUG_ARG("so = %lx", (long)so);
if (so->so_faddr.s_addr != slirp->vhost_addr.s_addr) {
/* Check if it's pty_exec */
for (ex_ptr = slirp->e... | [
1,
0
] |
qemu | HACKING | e1000_mmio_read(void *opaque, target_phys_addr_t addr, unsigned size)
{
E1000State *s = opaque;
unsigned int index = (addr & 0x1ffff) >> 2;
if (index < NREADOPS && macreg_readops[index])
{
return macreg_readops[index](s, index);
}
DBGOUT(UNKNOWN, "MMIO unknown read addr=0x%08x\n", index << 2);
... | [
1,
0
] |
qemu | HACKING | static uint64_t dchip_read(void *opaque, target_phys_addr_t addr, unsigned size)
{
/* Skip this. It's all related to DRAM timing and setup. */
return 0;
} | [
0,
0
] |
qemu | net/socket.c | static int net_socket_listen_init(NetClientState *peer,
const char *model,
const char *name,
const char *host_str)
{
NetClientState *nc;
NetSocketState *s;
struct sockaddr_in saddr;
int fd, ret;
Erro... | [
1,
0
] |
qemu | hw/openpic.c | static PCIDevice *do_pci_register_device(PCIDevice *pci_dev, PCIBus *bus,
const char *name, int devfn,
PCIConfigReadFunc *config_read,
PCIConfigWriteFunc *config_write,
... | [
1,
0
] |
qemu | Makefile.objs | static void put_int8(QEMUFile *f, void *pv, size_t size)
{
int8_t *v = pv;
qemu_put_s8s(f, v);
} | [
1,
0
] |
qemu | hw/arm/omap1.c | static struct omap_mpuio_s *omap_mpuio_init(MemoryRegion *memory,
hwaddr base,
qemu_irq kbd_int, qemu_irq gpio_int,
qemu_irq wakeup,
omap_clk... | [
1,
0
] |
qemu | target-ppc/translate.c | static void ppc_cpu_unrealizefn(DeviceState *dev, Error **errp)
{
PowerPCCPU *cpu = POWERPC_CPU(dev);
CPUPPCState *env = &cpu->env;
opc_handler_t **table;
int i, j;
cpu_exec_exit(CPU(dev));
for (i = 0; i < PPC_CPU_OPCODES_LEN; i++) {
if (env->opcodes[i] == &invalid_handler) {
continue;
... | [
1,
0
] |
qemu | target-ppc/translate_init.c | static void init_proc_755(CPUPPCState *env)
{
gen_spr_ne_601(env);
gen_spr_7xx(env);
gen_spr_G2_755(env);
/* Time base */
gen_tbl(env);
/* L2 cache control */
/* XXX : not implemented */
spr_register(env, SPR_L2CR, "L2CR",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_ge... | [
1,
1
] |
qemu | linux-user/syscall.c | static inline abi_long target_to_host_timespec(struct timespec *host_ts,
abi_ulong target_addr)
{
struct target_timespec *target_ts;
if (!lock_user_struct(VERIFY_READ, target_ts, target_addr, 1))
return -TARGET_EFAULT;
host_ts->tv_sec = tswapal(target_ts->t... | [
1,
0
] |
FFmpeg | libavformat/gxfenc.c | static int gxf_write_trailer(AVFormatContext *s)
{
GXFContext *gxf = s->priv_data;
AVIOContext *pb = s->pb;
int64_t end;
int i;
ff_audio_interleave_close(s);
gxf_write_eos_packet(pb);
end = avio_tell(pb);
avio_seek(pb, 0, SEEK_SET);
/* overwrite map, flt and umf packets with new values */
... | [
0,
0
] |
qemu | hw/dma/i82374.c | void DMA_init(int high_page_enable, qemu_irq *cpu_request_exit)
{} | [
0,
0
] |
qemu | acl.c | static void do_getfd(Monitor *mon, const QDict *qdict)
{
const char *fdname = qdict_get_str(qdict, "fdname");
mon_fd_t *monfd;
int fd;
fd = qemu_chr_get_msgfd(mon->chr);
if (fd == -1) {
monitor_printf(mon, "getfd: no file descriptor supplied via SCM_RIGHTS\n");
return;
}
if (qemu_isdigit(... | [
0,
0
] |
qemu | hw/marvell_88w8618_audio.c | static void mv88w8618_register_devices(void)
{
#ifdef HAS_AUDIO
sysbus_register_withprop(&mv88w8618_audio_info);
#endif
} | [
0,
0
] |
qemu | hmp.c | static void monitor_find_completion(Monitor *mon,
const char *cmdline)
{
char *args[MAX_ARGS];
int nb_args, len;
/* 1. parse the cmdline */
if (parse_cmdline(cmdline, &nb_args, args) < 0) {
return;
}
#ifdef DEBUG_COMPLETION
for (i = 0; i < nb_args; i++) {
... | [
0,
0
] |
qemu | gdbstub.c | static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
{
#if defined(TARGET_I386)
cpu_synchronize_state(s->c_cpu);
s->c_cpu->eip = pc;
#elif defined(TARGET_PPC)
s->c_cpu->nip = pc;
#elif defined(TARGET_SPARC)
s->c_cpu->pc = pc;
s->c_cpu->npc = pc + 4;
#elif defined(TARGET_ARM)
s->c_cpu->regs[15... | [
1,
0
] |
qemu | block/qapi.c | static void dump_json_image_check(ImageCheck *check, bool quiet)
{
QString *str;
QObject *obj;
Visitor *v = qmp_output_visitor_new(&obj);
visit_type_ImageCheck(v, NULL, &check, &error_abort);
visit_complete(v, &obj);
str = qobject_to_json_pretty(obj);
assert(str != NULL);
qprintf(quiet, "%s\n",... | [
0,
0
] |
qemu | fpu/softfloat-specialize.h | INLINE bits32 extractFloat32Frac(float32 a)
{
return a & 0x007FFFFF;
} | [
0,
0
] |
qemu | hw/loader.c | int rom_load_fw(void *fw_cfg)
{
Rom *rom;
QTAILQ_FOREACH(rom, &roms, next) {
if (!rom->fw_file) {
continue;
}
fw_cfg_add_file(fw_cfg, rom->fw_dir, rom->fw_file, rom->data, rom->romsize);
}
return 0;
} | [
1,
0
] |
qemu | hw/unin_pci.c | static int u3_agp_pci_host_init(PCIDevice *d)
{
pci_config_set_vendor_id(d->config, PCI_VENDOR_ID_APPLE);
pci_config_set_device_id(d->config, PCI_DEVICE_ID_APPLE_U3_AGP);
/* revision */
d->config[0x08] = 0x00;
pci_config_set_class(d->config, PCI_CLASS_BRIDGE_HOST);
/* cache line size */
d->config[... | [
1,
0
] |
qemu | HACKING | static void intel_hda_mmio_writeb(void *opaque, target_phys_addr_t addr,
uint32_t val)
{
IntelHDAState *d = opaque;
const IntelHDAReg *reg = intel_hda_reg_find(d, addr);
intel_hda_reg_write(d, reg, val, 0xff);
} | [
0,
0
] |
qemu | target-unicore32/Makefile.objs | float32 HELPER(ucf64_df2sf)(float64 x, CPUUniCore32State *env)
{
return float64_to_float32(x, &env->ucf64.fp_status);
} | [
0,
0
] |
FFmpeg | libavutil/imgutils.c | int av_image_get_linesize(enum PixelFormat pix_fmt, int width, int plane)
{
const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt];
int max_step[4]; /* max pixel step for each plane */
int max_step_comp[4]; /* the component for each plane which has the max pixel
step */
... | [
1,
0
] |
FFmpeg | libavformat/rdt.c | rdt_parse_packet(AVFormatContext *ctx, PayloadContext *rdt, AVStream *st,
AVPacket *pkt, uint32_t *timestamp,
const uint8_t *buf, int len, uint16_t rtp_seq, int flags)
{
int seq = 1, res;
AVIOContext pb;
if (!rdt->rmctx)
return AVERROR(EINVAL);
if (rdt->audio_pkt_cn... | [
1,
0
] |
FFmpeg | libavformat/rmdec.c | ff_rm_retrieve_cache(AVFormatContext *s, AVIOContext *pb,
AVStream *st, RMStream *ast, AVPacket *pkt)
{
RMDemuxContext *rm = s->priv_data;
assert(rm->audio_pkt_cnt > 0);
if (ast->deint_id == DEINT_ID_VBRF ||
ast->deint_id == DEINT_ID_VBRS)
av_get_packet(
pb, pkt,
... | [
1,
1
] |
FFmpeg | libavcodec/bsf.c | int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
{
if (!pkt) {
ctx->internal->eof = 1;
return 0;
}
if (ctx->internal->eof) {
av_log(ctx, AV_LOG_ERROR, "A non-NULL packet sent after an EOF.\n");
return AVERROR(EINVAL);
}
if (ctx->internal->buffer_pkt->data ||
ctx->interna... | [
1,
0
] |
FFmpeg | postproc/swscale.c | void in_asm_used_var_warning_killer()
{
volatile int i = yCoeff + vrCoeff + ubCoeff + vgCoeff + ugCoeff + bF8 + bFC +
w400 + w80 + w10 +
bm00001111 + bm00000111 + bm11111000 + b16Mask + g16Mask +
r16Mask + b15Mask + g15Mask + r15Mask + asm_yalpha1 +
... | [
0,
0
] |
FFmpeg | ffplay.c | static int refresh_thread(void *opaque)
{
VideoState *is = opaque;
while (!is->abort_request) {
SDL_Event event;
event.type = FF_REFRESH_EVENT;
event.user.data1 = opaque;
if (!is->refresh && (!is->paused || is->force_refresh)) {
is->refresh = 1;
SDL_PushEvent(&event);
}
... | [
1,
1
] |
FFmpeg | libavcodec/snow.h | static av_always_inline int check_4block_inter(SnowContext *s, int mb_x,
int mb_y, int p0, int p1,
int ref, int *best_rd) {
const int b_stride = s->b_width << s->block_max_depth;
BlockNode *block = &s->block[mb_x + mb_y ... | [
1,
1
] |
qemu | hw/dma/xilinx_axidma.c | static void xilinx_axidma_realize(DeviceState *dev, Error **errp)
{
XilinxAXIDMA *s = XILINX_AXI_DMA(dev);
XilinxAXIDMAStreamSlave *ds = XILINX_AXI_DMA_DATA_STREAM(&s->rx_data_dev);
XilinxAXIDMAStreamSlave *cs = XILINX_AXI_DMA_CONTROL_STREAM(
&s->rx_control_dev);
Error *local_err = NULL;
object_p... | [
1,
0
] |
qemu | hw/char/serial.c | void serial_realize_core(SerialState *s, Error **errp)
{
if (!qemu_chr_fe_backend_connected(&s->chr)) {
error_setg(errp, "Can't create serial device, empty char device");
return;
}
s->modem_status_poll =
timer_new_ns(QEMU_CLOCK_VIRTUAL, (QEMUTimerCB *)serial_update_msl, s);
s->fifo_timeout_t... | [
0,
0
] |
qemu | hw/display/jazz_led.c | static DisplaySurface *qemu_create_message_surface(int w, int h,
const char *msg)
{
DisplaySurface *surface = qemu_create_displaysurface(w, h);
pixman_color_t bg = color_table_rgb[0][COLOR_BLACK];
pixman_color_t fg = color_table_rgb[0][COLOR_WHITE];
pixma... | [
1,
0
] |
qemu | hw/arm/nseries.c | static void l2cap_frame_in(struct l2cap_instance_s *l2cap,
const l2cap_hdr *frame)
{
uint16_t cid = le16_to_cpu(frame->cid);
uint16_t len = le16_to_cpu(frame->len);
if (unlikely(cid >= L2CAP_CID_MAX || !l2cap->cid[cid])) {
fprintf(stderr,
"%s: frame addressed to a ... | [
1,
0
] |
qemu | block/vvfat.c | static uint32_t superio_ioport_readb(void *opaque, uint32_t addr)
{
SuperIOConfig *superio_conf = opaque;
DPRINTF("superio_ioport_readb address 0x%x \n", addr);
return (superio_conf->config[superio_conf->index]);
} | [
0,
0
] |
qemu | qemu-char.c | static void qemu_chr_parse_parallel(QemuOpts *opts, ChardevBackend *backend,
Error **errp)
{
const char *device = qemu_opt_get(opts, "path");
if (device == NULL) {
error_setg(errp, "chardev: parallel: no device path given");
return;
}
backend->parallel = g_new0... | [
0,
0
] |
qemu | hw/virtio-net.c | static int do_virtio_net_can_receive(VirtIONet *n, int bufsize)
{
if (!virtio_queue_ready(n->rx_vq) ||
!(n->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK))
return 0;
if (virtio_queue_empty(n->rx_vq) ||
(n->mergeable_rx_bufs &&
!virtqueue_avail_bytes(n->rx_vq, bufsize, 0))) {
virtio_queu... | [
1,
0
] |
qemu | buffered_file.c | static void menelaus_pre_save(void *opaque)
{
MenelausState *s = opaque;
/* Should be <= 1000 */
s->rtc_next_vmstate = s->rtc.next - qemu_get_clock(rt_clock);
} | [
1,
0
] |
qemu | block.c | static inline uint64_t bdrv_get_align(BlockDriverState *bs)
{
/* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
return MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
} | [
0,
1
] |
qemu | net/net.c | void hmp_host_net_remove(Monitor *mon, const QDict *qdict)
{
NetClientState *nc;
int vlan_id = qdict_get_int(qdict, "vlan_id");
const char *device = qdict_get_str(qdict, "device");
nc = net_hub_find_client_by_name(vlan_id, device);
if (!nc) {
error_report("Host network device '%s' on hub '%d' not f... | [
0,
0
] |
FFmpeg | libavcodec/vp8.c | static enum AVPixelFormat webp_get_format(AVCodecContext *avctx,
const enum AVPixelFormat *formats)
{
WebPContext *s = avctx->priv_data;
if (s->has_alpha)
return AV_PIX_FMT_YUVA420P;
else
return AV_PIX_FMT_YUV420P;
} | [
0,
0
] |
qemu | compatfd.c | bool qemu_signalfd_available(void)
{
#ifdef CONFIG_SIGNALFD
errno = 0;
syscall(SYS_signalfd, -1, NULL, _NSIG / 8);
return errno != ENOSYS;
#else
return false;
#endif
} | [
0,
0
] |
qemu | cputlb.c | void tb_invalidate_phys_addr(hwaddr addr)
{
ram_addr_t ram_addr;
MemoryRegionSection *section;
section = phys_page_find(address_space_memory.dispatch,
addr >> TARGET_PAGE_BITS);
if (!(memory_region_is_ram(section->mr)
|| memory_region_is_romd(section->mr))) {
retur... | [
0,
0
] |
qemu | hw/ide/ich.c | static void lsi_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
k->init = lsi_scsi_init;
k->exit = lsi_scsi_uninit;
k->vendor_id = PCI_VENDOR_ID_LSI_LOGIC;
k->device_id = PCI_DEVICE_ID_LSI_53C895A;
k->class_id = PCI_C... | [
1,
0
] |
qemu | MAINTAINERS | static void sigp_stop(CPUState *cs, run_on_cpu_data arg)
{
S390CPU *cpu = S390_CPU(cs);
SigpInfo *si = arg.host_ptr;
if (s390_cpu_get_state(cpu) != CPU_STATE_OPERATING) {
si->cc = SIGP_CC_ORDER_CODE_ACCEPTED;
return;
}
/* disabled wait - sleeping in user space */
if (cs->halted) {
s390_... | [
0,
0
] |
qemu | acl.c | static struct vm_area_struct *vma_next(struct vm_area_struct *vma)
{
return (TAILQ_NEXT(vma, vma_link));
} | [
0,
0
] |
qemu | exec.c | void address_space_init_dispatch(AddressSpace *as)
{
AddressSpaceDispatch *d = g_new(AddressSpaceDispatch, 1);
d->phys_map = (PhysPageEntry){.ptr = PHYS_MAP_NODE_NIL, .is_leaf = 0};
d->listener = (MemoryListener){
.begin = mem_begin,
.region_add = mem_add,
.region_nop = mem_add,
.p... | [
0,
0
] |
qemu | hw/scsi/vhost-scsi.c | static int virtio_scsi_device_exit(DeviceState *qdev)
{
VirtIOSCSI *s = VIRTIO_SCSI(qdev);
VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(qdev);
unregister_savevm(qdev, "virtio-scsi", s);
return virtio_scsi_common_exit(vs);
} | [
1,
0
] |
qemu | hw/s390x/css.c | int s390_ccw_cmd_request(ORB *orb, SCSW *scsw, void *data)
{
S390CCWDeviceClass *cdc = S390_CCW_DEVICE_GET_CLASS(data);
if (cdc->handle_request) {
return cdc->handle_request(orb, scsw, data);
} else {
return -ENOSYS;
}
} | [
1,
0
] |
qemu | include/qemu/timer.h | bool qemu_run_timers(QEMUClock *clock)
{
return qemu_clock_run_timers(clock->type);
} | [
0,
0
] |
qemu | qga/Makefile.objs | int64_t qmp_guest_fsfreeze_freeze(Error **err)
{
error_set(err, QERR_UNSUPPORTED);
return 0;
} | [
0,
0
] |
qemu | hw/realview.c | static int pci_vpb_init(SysBusDevice *dev)
{
PCIVPBState *s = FROM_SYSBUS(PCIVPBState, dev);
PCIBus *bus;
int i;
for (i = 0; i < 4; i++) {
sysbus_init_irq(dev, &s->irq[i]);
}
bus = pci_register_bus(&dev->qdev, "pci",
pci_vpb_set_irq, pci_vpb_map_irq, s->irq,
... | [
0,
0
] |
qemu | backends/rng-random.c | static void rng_random_set_filename(Object *obj, const char *filename,
Error **errp)
{
RngBackend *b = RNG_BACKEND(obj);
RndRandom *s = RNG_RANDOM(obj);
if (b->opened) {
error_set(errp, QERR_PERMISSION_DENIED);
return;
}
if (s->filename) {
g_free(s->fil... | [
0,
0
] |
qemu | memory.c | static void memory_region_update_coalesced_range_as(MemoryRegion *mr,
AddressSpace *as)
{
FlatView *view;
FlatRange *fr;
CoalescedMemoryRange *cmr;
AddrRange tmp;
MemoryRegionSection section;
view = as->current_map;
FOR_EACH_FLAT_RANGE(fr, view) ... | [
0,
0
] |
qemu | block.c | void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
void *opaque)
{
BlockDriver *drv;
int count = 0;
int i;
const char **formats = NULL;
QLIST_FOREACH(drv, &bdrv_drivers, list) {
if (drv->format_name) {
bool found = false;
int i = count;
... | [
1,
0
] |
qemu | tcg/s390/tcg-target.inc.c | static int tcg_target_const_match(tcg_target_long val, TCGType type,
const TCGArgConstraint *arg_ct)
{
int ct = arg_ct->ct;
if (ct & TCG_CT_CONST) {
return 1;
}
if (type == TCG_TYPE_I32) {
val = (int32_t)val;
}
/* The following are mutually exclusive. */
... | [
1,
0
] |
qemu | cpu-exec.c | static void cpu_exec_nocache(CPUArchState *env, int max_cycles,
TranslationBlock *orig_tb)
{
CPUState *cpu = ENV_GET_CPU(env);
TranslationBlock *tb;
target_ulong pc = orig_tb->pc;
target_ulong cs_base = orig_tb->cs_base;
uint64_t flags = orig_tb->flags;
/* Should never h... | [
0,
0
] |
qemu | hw/usb-audio.c | static int usb_net_handle_data(USBDevice *dev, USBPacket *p)
{
USBNetState *s = (USBNetState *)dev;
int ret = 0;
switch (p->pid) {
case USB_TOKEN_IN:
switch (p->devep) {
case 1:
ret = usb_net_handle_statusin(s, p);
break;
case 2:
ret = usb_net_handle_datain(s, p);
... | [
0,
0
] |
qemu | hw/virtio-scsi.c | static void virtio_scsi_parse_req(VirtIOSCSI *s, VirtQueue *vq,
VirtIOSCSIReq *req)
{
assert(req->elem.out_num && req->elem.in_num);
req->vq = vq;
req->dev = s;
req->sreq = NULL;
req->req.buf = req->elem.out_sg[0].iov_base;
req->resp.buf = req->elem.in_sg[0].iov_bas... | [
1,
0
] |
qemu | linux-user/syscall.c | static int sys_openat(int dirfd, const char *pathname, int flags, ...)
{
/*
* open(2) has extra parameter 'mode' when called with
* flag O_CREAT.
*/
if ((flags & O_CREAT) != 0) {
va_list ap;
mode_t mode;
/*
* Get the 'mode' parameter and translate it to
* host bits.
*... | [
1,
0
] |
FFmpeg | libavcodec/mpegvideo_enc.c | static int estimate_qp(MpegEncContext *s, int dry_run) {
if (s->next_lambda) {
s->current_picture_ptr->quality =
s->current_picture.quality = s->next_lambda;
if (!dry_run)
s->next_lambda = 0;
} else if (!s->fixed_qscale) {
s->current_picture_ptr->quality =
s->current_picture... | [
1,
1
] |
qemu | hw/input/pckbd.c | static void outport_write(KBDState *s, uint32_t val)
{
DPRINTF("kbd: write outport=0x%02x\n", val);
s->outport = val;
if (s->a20_out) {
qemu_set_irq(*s->a20_out, (val >> 1) & 1);
}
if (!(val & 1)) {
qemu_system_reset_request();
}
} | [
0,
0
] |
qemu | hw/net/imx_fec.c | static void imx_fec_do_tx(IMXFECState *s)
{
int frame_size = 0;
uint8_t frame[ENET_MAX_FRAME_SIZE];
uint8_t *ptr = frame;
uint32_t addr = s->tx_descriptor;
while (1) {
IMXFECBufDesc bd;
int len;
imx_fec_read_bd(&bd, addr);
FEC_PRINTF("tx_bd %x flags %04x len %d data %08x\n",
... | [
1,
0
] |
FFmpeg | libavcodec/ra288.c | static void do_hybrid_window(int order, int n, int non_rec, const float *in,
float *out, float *hist, float *out2,
const float *window)
{
int i;
float buffer1[order + 1];
float buffer2[order + 1];
float work[order + n + non_rec];
/* update hist... | [
1,
0
] |
qemu | tcg/s390/tcg-target.h | static int tcg_match_ori(TCGType type, tcg_target_long val)
{
if (facilities & FACILITY_EXT_IMM) {
if (type == TCG_TYPE_I32) {
/* All 32-bit ORs can be performed with 1 48-bit insn. */
return 1;
}
}
/* Look for negative values. These are best to load with LGHI. */
if (val < 0) {
... | [
0,
0
] |
qemu | hmp.c | static void qemu_input_event_trace(QemuConsole *src, InputEvent *evt)
{
const char *name;
int qcode, idx = -1;
if (src) {
idx = qemu_console_get_index(src);
}
switch (evt->kind) {
case INPUT_EVENT_KIND_KEY:
switch (evt->key->key->kind) {
case KEY_VALUE_KIND_NUMBER:
qcode = qemu_i... | [
1,
0
] |
FFmpeg | libavcodec/aaccoder.c | void ff_aac_encode_tns_info(AACEncContext *s, SingleChannelElement *sce)
{
int i, w, filt, coef_len, coef_compress;
const int coef_res = MAX_LPC_PRECISION == 4 ? 1 : 0;
const int is8 = sce->ics.window_sequence[0] == EIGHT_SHORT_SEQUENCE;
put_bits(&s->pb, 1, !!sce->tns.present);
if (!sce->tns.present)
... | [
0,
0
] |
FFmpeg | libavcodec/aac_ac3_parser.h | AVFilterBufferRef *
avfilter_null_get_audio_buffer(AVFilterLink *link, int perms,
enum AVSampleFormat sample_fmt, int size,
int64_t channel_layout, int packed)
{
return avfilter_get_audio_buffer(link->dst->outputs[0], perms, sample_fmt,
... | [
0,
0
] |
qemu | include/sysemu/sysemu.h | void qemu_system_reset(ShutdownCause reason)
{
MachineClass *mc;
mc = current_machine ? MACHINE_GET_CLASS(current_machine) : NULL;
cpu_synchronize_all_states();
if (mc && mc->reset) {
mc->reset();
} else {
qemu_devices_reset();
}
if (reason) {
/* TODO update event based on reason */
... | [
1,
1
] |
FFmpeg | libavcodec/x86/dcadsp_init.c | av_cold void ff_volume_init_x86(VolumeContext *vol)
{
int cpu_flags = av_get_cpu_flags();
enum AVSampleFormat sample_fmt = av_get_packed_sample_fmt(vol->sample_fmt);
if (sample_fmt == AV_SAMPLE_FMT_S16) {
if (EXTERNAL_SSE2(cpu_flags) && vol->volume_i < 32768) {
vol->scale_samples = ff_scale_sample... | [
0,
0
] |
qemu | hw/eepro100.c | static void enable_interrupt(EEPRO100State *s)
{
if (!s->int_stat) {
logout("interrupt enabled\n");
qemu_irq_raise(s->pci_dev->irq[0]);
s->int_stat = 1;
}
} | [
0,
0
] |
qemu | block/block-backend.c | static int execute_command(BlockDriverState *bdrv,
SCSIGenericReq *r, int direction,
BlockCompletionFunc *complete)
{
r->io_header.interface_id = 'S';
r->io_header.dxfer_direction = direction;
r->io_header.dxferp = r->buf;
r->io_header.dxfer_len = r->... | [
1,
0
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.