id stringlengths 22 26 | content stringlengths 72 142k |
|---|---|
devign_test_set_data_22094 | int kvm_set_signal_mask(CPUState *env, const sigset_t *sigset)
{
struct kvm_signal_mask *sigmask;
int r;
if (!sigset)
return kvm_vcpu_ioctl(env, KVM_SET_SIGNAL_MASK, NULL);
sigmask = qemu_malloc(sizeof(*sigmask) + sizeof(*sigset));
sigmask->len = 8;
memcpy(sigmask->sigset, ... |
devign_test_set_data_22132 | static int unix_close(void *opaque)
{
QEMUFileSocket *s = opaque;
close(s->fd);
g_free(s);
return 0;
}
The vulnerability label is: Vulnerable |
devign_test_set_data_22137 | 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;
MpegEncConte... |
devign_test_set_data_22140 | static void fd_chr_read(void *opaque)
{
CharDriverState *chr = opaque;
FDCharDriver *s = chr->opaque;
int size, len;
uint8_t buf[1024];
len = sizeof(buf);
if (len > s->max_size)
len = s->max_size;
if (len == 0)
return;
size = read(s->fd_in, buf, len);
if... |
devign_test_set_data_22151 | static void smbios_build_type_1_fields(QemuOpts *opts)
{
const char *val;
val = qemu_opt_get(opts, "manufacturer");
if (val) {
smbios_add_field(1, offsetof(struct smbios_type_1, manufacturer_str),
val, strlen(val) + 1);
}
val = qemu_opt_get(opts, "product")... |
devign_test_set_data_22155 | static void vmsvga_fifo_run(struct vmsvga_state_s *s)
{
uint32_t cmd, colour;
int args, len;
int x, y, dx, dy, width, height;
struct vmsvga_cursor_definition_s cursor;
uint32_t cmd_start;
len = vmsvga_fifo_length(s);
while (len > 0) {
/* May need to go back to the start of... |
devign_test_set_data_22167 | static int hdev_get_max_segments(const struct stat *st)
{
#ifdef CONFIG_LINUX
char buf[32];
const char *end;
char *sysfspath;
int ret;
int fd = -1;
long max_segments;
sysfspath = g_strdup_printf("/sys/dev/block/%u:%u/queue/max_segments",
major(st->... |
devign_test_set_data_22201 | static void apic_update_irq(APICCommonState *s)
{
if (!(s->spurious_vec & APIC_SV_ENABLE)) {
return;
}
if (apic_irq_pending(s) > 0) {
cpu_interrupt(s->cpu_env, CPU_INTERRUPT_HARD);
} else if (apic_accept_pic_intr(&s->busdev.qdev) &&
pic_get_output(isa_pic)) {
... |
devign_test_set_data_22250 | PPC_OP(extsh)
{
T0 = (int32_t)((int16_t)(Ts0));
RETURN();
}
The vulnerability label is: Vulnerable |
devign_test_set_data_22265 | static int nfs_file_open(BlockDriverState *bs, QDict *options, int flags,
Error **errp) {
NFSClient *client = bs->opaque;
int64_t ret;
client->aio_context = bdrv_get_aio_context(bs);
ret = nfs_client_open(client, options,
(flags & BDRV_O_RDWR)... |
devign_test_set_data_22270 | static uint32_t pmac_ide_readb (void *opaque,target_phys_addr_t addr)
{
uint8_t retval;
MACIOIDEState *d = opaque;
addr = (addr & 0xFFF) >> 4;
switch (addr) {
case 1 ... 7:
retval = ide_ioport_read(&d->bus, addr);
break;
case 8:
case 22:
retval = ide_stat... |
devign_test_set_data_22276 | target_phys_addr_t booke206_tlb_to_page_size(CPUState *env, ppcmas_tlb_t *tlb)
{
uint32_t tlbncfg;
int tlbn = booke206_tlbm_to_tlbn(env, tlb);
int tlbm_size;
tlbncfg = env->spr[SPR_BOOKE_TLB0CFG + tlbn];
if (tlbncfg & TLBnCFG_AVAIL) {
tlbm_size = (tlb->mas1 & MAS1_TSIZE_MASK) >> M... |
devign_test_set_data_22279 | static int xhci_setup_packet(XHCITransfer *xfer, XHCIPort *port, int ep)
{
usb_packet_setup(&xfer->packet,
xfer->in_xfer ? USB_TOKEN_IN : USB_TOKEN_OUT,
xfer->xhci->slots[xfer->slotid-1].devaddr,
ep & 0x7f);
usb_packet_addbuf(&xfer->packet, xf... |
devign_test_set_data_22280 | static void thread_pool_cancel(BlockAIOCB *acb)
{
ThreadPoolElement *elem = (ThreadPoolElement *)acb;
ThreadPool *pool = elem->pool;
trace_thread_pool_cancel(elem, elem->common.opaque);
qemu_mutex_lock(&pool->lock);
if (elem->state == THREAD_QUEUED &&
/* No thread has yet started ... |
devign_test_set_data_22300 | static void monitor_protocol_event_init(void)
{
qemu_mutex_init(&monitor_event_state_lock);
/* Limit RTC & BALLOON events to 1 per second */
monitor_protocol_event_throttle(QEVENT_RTC_CHANGE, 1000);
monitor_protocol_event_throttle(QEVENT_BALLOON_CHANGE, 1000);
monitor_protocol_event_throttle(Q... |
devign_test_set_data_22316 | static int seek_test(const char *input_filename, const char *start, const char *end)
{
AVCodec *codec = NULL;
AVCodecContext *ctx= NULL;
AVCodecParameters *origin_par = NULL;
AVFrame *fr = NULL;
AVFormatContext *fmt_ctx = NULL;
int video_stream;
int result;
int i, j;
long i... |
devign_test_set_data_22330 | AUXReply aux_request(AUXBus *bus, AUXCommand cmd, uint32_t address,
uint8_t len, uint8_t *data)
{
AUXReply ret = AUX_NACK;
I2CBus *i2c_bus = aux_get_i2c_bus(bus);
size_t i;
bool is_write = false;
DPRINTF("request at address 0x%" PRIX32 ", command %u, len %u\n", address... |
devign_test_set_data_22361 | static inline void RENAME(yuv2yuvX_ar)(SwsContext *c, const int16_t *lumFilter,
const int16_t **lumSrc, int lumFilterSize,
const int16_t *chrFilter, const int16_t **chrUSrc,
const int16_t **chrVSrc,
... |
devign_test_set_data_22364 | MigrationInfo *qmp_query_migrate(Error **errp)
{
MigrationInfo *info = g_malloc0(sizeof(*info));
MigrationState *s = migrate_get_current();
switch (s->state) {
case MIG_STATE_NONE:
/* no migration has happened ever */
break;
case MIG_STATE_SETUP:
info->has_status =... |
devign_test_set_data_22365 | static inline int cow_set_bit(BlockDriverState *bs, int64_t bitnum)
{
uint64_t offset = sizeof(struct cow_header_v2) + bitnum / 8;
uint8_t bitmap;
if (bdrv_pread(bs->file, offset, &bitmap, sizeof(bitmap)) !=
sizeof(bitmap)) {
return -errno;
}
bitmap |= (1 << (bitnum % 8));
... |
devign_test_set_data_22369 | PPC_OP(cmpl)
{
if (T0 < T1) {
T0 = 0x08;
} else if (T0 > T1) {
T0 = 0x04;
} else {
T0 = 0x02;
}
RETURN();
}
The vulnerability label is: Vulnerable |
devign_test_set_data_22379 | static int voc_probe(AVProbeData *p)
{
int version, check;
if (p->buf_size < 26)
return 0;
if (memcmp(p->buf, voc_magic, sizeof(voc_magic) - 1))
return 0;
version = p->buf[22] | (p->buf[23] << 8);
check = p->buf[24] | (p->buf[25] << 8);
if (~version + 0x1234 != check)
... |
devign_test_set_data_22381 | int ram_load(QEMUFile *f, void *opaque, int version_id)
{
ram_addr_t addr;
int flags;
if (version_id < 3 || version_id > 4) {
return -EINVAL;
}
do {
addr = qemu_get_be64(f);
flags = addr & ~TARGET_PAGE_MASK;
addr &= TARGET_PAGE_MASK;
if (fla... |
devign_test_set_data_22387 | static void drive_backup_prepare(BlkActionState *common, Error **errp)
{
DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
BlockDriverState *bs;
DriveBackup *backup;
Error *local_err = NULL;
assert(common->action->type == TRANSACTION_ACTION_KIND_DRIVE_BACKUP);
backu... |
devign_test_set_data_22389 | static inline void RET_STOP (DisasContext *ctx)
{
gen_op_update_nip((ctx)->nip);
ctx->exception = EXCP_MTMSR;
}
The vulnerability label is: Vulnerable |
devign_test_set_data_22392 | static void term_exit(void)
{
#ifndef __MINGW32__
tcsetattr (0, TCSANOW, &oldtty);
#endif
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_22399 | static int get_segment64(CPUPPCState *env, struct mmu_ctx_hash64 *ctx,
target_ulong eaddr, int rw, int type)
{
hwaddr hash;
target_ulong vsid;
int pr, target_page_bits;
int ret, ret2;
pr = msr_pr;
ctx->eaddr = eaddr;
ppc_slb_t *slb;
target_ulong pagea... |
devign_test_set_data_22413 | static int v9fs_receivefd(int sockfd, int *status)
{
struct iovec iov;
struct msghdr msg;
struct cmsghdr *cmsg;
int retval, data, fd;
union MsgControl msg_control;
iov.iov_base = &data;
iov.iov_len = sizeof(data);
memset(&msg, 0, sizeof(msg));
msg.msg_iov = &iov;
m... |
devign_test_set_data_22417 | static void kvm_inject_x86_mce_on(CPUState *env, struct kvm_x86_mce *mce,
int flag)
{
struct kvm_x86_mce_data data = {
.env = env,
.mce = mce,
.abort_on_error = (flag & ABORT_ON_ERROR),
};
if (!env->mcg_cap) {
fprintf(stderr, "MCE ... |
devign_test_set_data_22418 | static AioHandler *find_aio_handler(AioContext *ctx, int fd)
{
AioHandler *node;
QLIST_FOREACH(node, &ctx->aio_handlers, node) {
if (node->pfd.fd == fd)
if (!node->deleted)
return node;
}
return NULL;
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_22421 | static void disas_xtensa_insn(CPUXtensaState *env, DisasContext *dc)
{
#define HAS_OPTION_BITS(opt) do { \
if (!option_bits_enabled(dc, opt)) { \
qemu_log("Option is not enabled %s:%d\n", \
__FILE__, __LINE__); \
goto invalid_opcode; \
} \
} while ... |
devign_test_set_data_22425 | static int end_frame(AVFilterLink *inlink)
{
AVFilterContext *ctx = inlink->dst;
FPSContext *s = ctx->priv;
AVFilterLink *outlink = ctx->outputs[0];
AVFilterBufferRef *buf = inlink->cur_buf;
int64_t delta;
int i, ret;
inlink->cur_buf = NULL;
s->frames_in++;
... |
devign_test_set_data_22426 | static int roq_read_packet(AVFormatContext *s,
AVPacket *pkt)
{
RoqDemuxContext *roq = s->priv_data;
AVIOContext *pb = s->pb;
int ret = 0;
unsigned int chunk_size;
unsigned int chunk_type;
unsigned int codebook_size;
unsigned char preamble[RoQ_CHUNK_PREAMB... |
devign_test_set_data_22429 | static inline void RENAME(hScale)(int16_t *dst, int dstW, uint8_t *src, int srcW, int xInc,
int16_t *filter, int16_t *filterPos, int filterSize)
{
#ifdef HAVE_MMX
assert(filterSize % 4 == 0 && filterSize>0);
if(filterSize==4) // allways true for upscaling, sometimes for down too
{
long counter= -2*dst... |
devign_test_set_data_22431 | void qemu_file_set_error(QEMUFile *f, int ret)
{
if (f->last_error == 0) {
f->last_error = ret;
}
}
The vulnerability label is: Vulnerable |
devign_test_set_data_22436 | static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
MpegEncContext * const s = avctx->priv_data;
MJpegContext * const m = s->mjpeg_ctx;
AVFrame *pict = data;
const int width= s->width;
const int height= s->height;
AVFrame * const p= (AVF... |
devign_test_set_data_22459 | static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
{
AVFormatContext *ic;
AVInputFormat *file_iformat = NULL;
int err, i, ret;
int64_t timestamp;
uint8_t buf[128];
AVDictionary **opts;
int orig_nb_streams; // number of streams befo... |
devign_test_set_data_22462 | uint64_t helper_efdctuidz (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_uint64_round_to_zero(u.d, &env->vec_status);
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_22465 | void bios_linker_loader_add_checksum(BIOSLinker *linker, const char *file_name,
void *start, unsigned size,
uint8_t *checksum)
{
BiosLinkerLoaderEntry entry;
const BiosLinkerFileEntry *file = bios_linker_find_file(linker, file_name);... |
devign_test_set_data_22503 | void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
{
PerThreadContext *p = avctx->internal->thread_ctx;
FrameThreadContext *fctx;
AVFrame *dst, *tmp;
FF_DISABLE_DEPRECATION_WARNINGS
int can_direct_free = !(avctx->active_thread_type & FF_THREAD_FRAME) ||
... |
devign_test_set_data_22531 | void ff_schro_queue_free(FFSchroQueue *queue, void (*free_func)(void *))
{
while (queue->p_head)
free_func(ff_schro_queue_pop(queue));
}
The vulnerability label is: Vulnerable |
devign_test_set_data_22534 | void qemu_mutex_lock_iothread(void)
{
if (!tcg_enabled()) {
qemu_mutex_lock(&qemu_global_mutex);
} else {
iothread_requesting_mutex = true;
if (qemu_mutex_trylock(&qemu_global_mutex)) {
qemu_cpu_kick_thread(first_cpu);
qemu_mutex_lock(&qemu_global_mutex);
... |
devign_test_set_data_22545 | static inline void gen_op_addl_ESP_im(int32_t val)
{
tcg_gen_ld_tl(cpu_tmp0, cpu_env, offsetof(CPUState, regs[R_ESP]));
tcg_gen_addi_tl(cpu_tmp0, cpu_tmp0, val);
#ifdef TARGET_X86_64
tcg_gen_andi_tl(cpu_tmp0, cpu_tmp0, 0xffffffff);
#endif
tcg_gen_st_tl(cpu_tmp0, cpu_env, offsetof(CPUState, regs[R... |
devign_test_set_data_22552 | static unsigned int dec_movu_r(DisasContext *dc)
{
TCGv t0;
int size = memsize_z(dc);
DIS(fprintf (logfile, "movu.%c $r%u, $r%u\n",
memsize_char(size),
dc->op1, dc->op2));
cris_cc_mask(dc, CC_MASK_NZ);
t0 = tcg_temp_new(TCG_TYPE_TL);
dec_prep_move_r(dc, dc->op1, dc->op2, size, 0, t0);
cri... |
devign_test_set_data_22559 | AVInputFormat *av_find_input_format(const char *short_name)
{
AVInputFormat *fmt = NULL;
while ((fmt = av_iformat_next(fmt)))
if (match_format(short_name, fmt->name))
return fmt;
return NULL;
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_22597 | static av_cold void dsputil_init_sse2(DSPContext *c, AVCodecContext *avctx,
int mm_flags)
{
#if HAVE_SSE2_INLINE
const int high_bit_depth = avctx->bits_per_raw_sample > 8;
if (!high_bit_depth && avctx->idct_algo == FF_IDCT_XVIDMMX) {
c->idct_put ... |
devign_test_set_data_22601 | static int au_probe(AVProbeData *p)
{
/* check file header */
if (p->buf_size <= 24)
return 0;
if (p->buf[0] == '.' && p->buf[1] == 's' &&
p->buf[2] == 'n' && p->buf[3] == 'd')
return AVPROBE_SCORE_MAX;
else
return 0;
}
The vulnerability label is: Non-vulnerab... |
devign_test_set_data_22615 | static void pc_fw_add_pflash_drv(void)
{
QemuOpts *opts;
QEMUMachine *machine;
char *filename;
if (bios_name == NULL) {
bios_name = BIOS_FILENAME;
}
filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
opts = drive_add(IF_PFLASH, -1, filename, "readonly=on");
... |
devign_test_set_data_22637 | void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts,
int *duration)
{
int64_t out_pts = AV_NOPTS_VALUE;
int removed_samples = 0;
#ifdef DEBUG
ff_af_queue_log_state(afq);
#endif
/* get output pts from the next frame or generated pts */
if (a... |
devign_test_set_data_22652 | void stream_start(BlockDriverState *bs, BlockDriverState *base,
const char *base_id, int64_t speed,
BlockDriverCompletionFunc *cb,
void *opaque, Error **errp)
{
StreamBlockJob *s;
Coroutine *co;
s = block_job_create(&stream_job_type, bs, speed, ... |
devign_test_set_data_22655 | static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q){
RateControlContext *rcc= &s->rc_context;
AVCodecContext *a= s->avctx;
const int pict_type= rce->new_pict_type;
const double last_p_q = rcc->last_qscale_for[P_TYPE];
const double last_non_b_q= rcc->last_qsca... |
devign_test_set_data_22662 | static int mov_write_hdlr_tag(AVIOContext *pb, MOVTrack *track)
{
const char *hdlr, *descr = NULL, *hdlr_type = NULL;
int64_t pos = avio_tell(pb);
if (!track) { /* no media --> data handler */
hdlr = "dhlr";
hdlr_type = "url ";
descr = "DataHandler";
} else {
... |
devign_test_set_data_22683 | PPC_OP(srawi)
{
T1 = T0;
T0 = (Ts0 >> PARAM(1));
if (Ts1 < 0 && (Ts1 & PARAM(2)) != 0) {
xer_ca = 1;
} else {
xer_ca = 0;
}
RETURN();
}
The vulnerability label is: Vulnerable |
devign_test_set_data_22693 | void trace_init_file(const char *file)
{
#ifdef CONFIG_TRACE_SIMPLE
st_set_trace_file(file);
#elif defined CONFIG_TRACE_LOG
/* If both the simple and the log backends are enabled, "-trace file"
* only applies to the simple backend; use "-D" for the log backend.
*/
if (file) {
qemu... |
devign_test_set_data_22702 | static int srt_probe(AVProbeData *p)
{
const unsigned char *ptr = p->buf;
int i, v, num = 0;
if (AV_RB24(ptr) == 0xEFBBBF)
ptr += 3; /* skip UTF-8 BOM */
while (*ptr == '\r' || *ptr == '\n')
ptr++;
for (i=0; i<2; i++) {
if ((num == i || num + 1 == i)
... |
devign_test_set_data_22705 | static void piix4_update_hotplug(PIIX4PMState *s)
{
PCIDevice *dev = &s->dev;
BusState *bus = qdev_get_parent_bus(&dev->qdev);
DeviceState *qdev, *next;
s->pci0_hotplug_enable = ~0;
QTAILQ_FOREACH_SAFE(qdev, &bus->children, sibling, next) {
PCIDevice *pdev = PCI_DEVICE(qdev);
... |
devign_test_set_data_22709 | static void stream_set_speed(BlockJob *job, int64_t speed, Error **errp)
{
StreamBlockJob *s = container_of(job, StreamBlockJob, common);
if (speed < 0) {
error_setg(errp, QERR_INVALID_PARAMETER, "speed");
return;
}
ratelimit_set_speed(&s->limit, speed / BDRV_SECTOR_SIZE, SLICE_... |
devign_test_set_data_22718 | static av_cold int dnxhd_decode_close(AVCodecContext *avctx)
{
DNXHDContext *ctx = avctx->priv_data;
ff_free_vlc(&ctx->ac_vlc);
ff_free_vlc(&ctx->dc_vlc);
ff_free_vlc(&ctx->run_vlc);
av_freep(&ctx->mb_scan_index);
av_freep(&ctx->rows);
return 0;
}
The vulnerability label is:... |
devign_test_set_data_22741 | int unix_start_incoming_migration(const char *path)
{
struct sockaddr_un un;
int sock;
dprintf("Attempting to start an incoming migration\n");
sock = socket(PF_UNIX, SOCK_STREAM, 0);
if (sock < 0) {
fprintf(stderr, "Could not open unix socket: %s\n", strerror(errno));
ret... |
devign_test_set_data_22752 | void bdrv_refresh_limits(BlockDriverState *bs, Error **errp)
{
BlockDriver *drv = bs->drv;
Error *local_err = NULL;
memset(&bs->bl, 0, sizeof(bs->bl));
if (!drv) {
return;
}
/* Default alignment based on whether driver has byte interface */
bs->request_alignment = drv-... |
devign_test_set_data_22759 | static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
BdrvCheckMode fix, bool *rebuild,
void **refcount_table, int64_t *nb_clusters)
{
BDRVQcow2State *s = bs->opaque;
int64_t i, size;
int ret;
for(i = 0; i < s->refcount_tabl... |
devign_test_set_data_22801 | DriveInfo *drive_init(QemuOpts *opts, BlockInterfaceType block_default_type)
{
const char *buf;
const char *file = NULL;
const char *serial;
const char *mediastr = "";
BlockInterfaceType type;
enum { MEDIA_DISK, MEDIA_CDROM } media;
int bus_id, unit_id;
int cyls, heads, secs, tr... |
devign_test_set_data_22815 | static const char *keyval_parse_one(QDict *qdict, const char *params,
const char *implied_key,
Error **errp)
{
const char *key, *key_end, *s;
size_t len;
char key_in_cur[128];
QDict *cur;
int ret;
QObject *next;
... |
devign_test_set_data_22826 | static void mdct_test(AC3MDCTContext *mdct, AVLFG *lfg)
{
int16_t input[MDCT_SAMPLES];
int32_t output[AC3_MAX_COEFS];
float input1[MDCT_SAMPLES];
float output1[AC3_MAX_COEFS];
float s, a, err, e, emax;
int i, k, n;
for (i = 0; i < MDCT_SAMPLES; i++) {
input[i] = (av_lfg_g... |
devign_test_set_data_22833 | static AVRational update_sar(int old_w, int old_h, AVRational sar, int new_w, int new_h)
{
// attempt to keep aspect during typical resolution switches
if (!sar.num)
sar = (AVRational){1, 1};
sar = av_mul_q(sar, (AVRational){new_h * old_w, new_w * old_h});
return sar;
}
The vulnerabil... |
devign_test_set_data_22834 | static uint32_t qpci_pc_config_readl(QPCIBus *bus, int devfn, uint8_t offset)
{
outl(0xcf8, (1 << 31) | (devfn << 8) | offset);
return inl(0xcfc);
}
The vulnerability label is: Vulnerable |
devign_test_set_data_22844 | static int decode_block(BinkAudioContext *s, float **out, int use_dct)
{
int ch, i, j, k;
float q, quant[25];
int width, coeff;
GetBitContext *gb = &s->gb;
if (use_dct)
skip_bits(gb, 2);
for (ch = 0; ch < s->channels; ch++) {
FFTSample *coeffs = out[ch];
i... |
devign_test_set_data_22875 | static int load_normal_reset(S390CPU *cpu)
{
S390CPUClass *scc = S390_CPU_GET_CLASS(cpu);
pause_all_vcpus();
cpu_synchronize_all_states();
cpu_reset_all();
io_subsystem_reset();
scc->initial_cpu_reset(CPU(cpu));
scc->load_normal(CPU(cpu));
cpu_synchronize_all_post_reset();
... |
devign_test_set_data_22876 | static void v9fs_post_lcreate(V9fsState *s, V9fsLcreateState *vs, int err)
{
if (err == 0) {
v9fs_string_copy(&vs->fidp->path, &vs->fullname);
stat_to_qid(&vs->stbuf, &vs->qid);
vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid,
&vs->iounit);
err = ... |
devign_test_set_data_22906 | static void get_xbzrle_cache_stats(MigrationInfo *info)
{
if (migrate_use_xbzrle()) {
info->has_xbzrle_cache = true;
info->xbzrle_cache = g_malloc0(sizeof(*info->xbzrle_cache));
info->xbzrle_cache->cache_size = migrate_xbzrle_cache_size();
info->xbzrle_cache->bytes = xbzrle_mig... |
devign_test_set_data_22931 | static PowerPCCPU *ppc440_init_xilinx(ram_addr_t *ram_size,
int do_init,
const char *cpu_model,
uint32_t sysclk)
{
PowerPCCPU *cpu;
CPUPPCState *env;
qemu_irq *irqs;
cpu = POWERPC_... |
devign_test_set_data_22944 | static void create_default_qtables(uint8_t *qtables, uint8_t q)
{
int factor = q;
int i;
factor = av_clip(q, 1, 99);
if (q < 50)
q = 5000 / factor;
else
q = 200 - factor * 2;
for (i = 0; i < 128; i++) {
int val = (default_quantizers[i] * q + 50) / 100;
... |
devign_test_set_data_22949 | void ff_af_queue_close(AudioFrameQueue *afq)
{
/* remove/free any remaining frames */
while (afq->frame_queue)
delete_next_frame(afq);
memset(afq, 0, sizeof(*afq));
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_22955 | static void lumRangeToJpeg16_c(int16_t *_dst, int width)
{
int i;
int32_t *dst = (int32_t *) _dst;
for (i = 0; i < width; i++)
dst[i] = (FFMIN(dst[i],30189<<4)*19077 - (39057361<<4))>>14;
}
The vulnerability label is: Vulnerable |
devign_test_set_data_22956 | static void fill_coding_method_array(sb_int8_array tone_level_idx,
sb_int8_array tone_level_idx_temp,
sb_int8_array coding_method,
int nb_channels,
int c, int superbloc... |
devign_test_set_data_22959 | static void find_motion(DeshakeContext *deshake, uint8_t *src1, uint8_t *src2,
int width, int height, int stride, Transform *t)
{
int x, y;
IntMotionVector mv = {0, 0};
int counts[128][128];
int count_max_value = 0;
int contrast;
int pos;
double *angles = a... |
devign_test_set_data_22966 | static int dirac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt)
{
DiracContext *s = avctx->priv_data;
AVFrame *picture = data;
uint8_t *buf = pkt->data;
int buf_size = pkt->size;
int i, data_unit_size, buf_idx = 0;
int ret;
/* re... |
devign_test_set_data_22969 | static TCGv gen_ea(CPUM68KState *env, DisasContext *s, uint16_t insn,
int opsize, TCGv val, TCGv *addrp, ea_what what)
{
TCGv reg;
TCGv result;
uint32_t offset;
switch ((insn >> 3) & 7) {
case 0: /* Data register direct. */
reg = DREG(insn, 0);
if (what... |
devign_test_set_data_22970 | static av_cold void nvenc_setup_rate_control(AVCodecContext *avctx)
{
NvencContext *ctx = avctx->priv_data;
if (avctx->bit_rate > 0) {
ctx->encode_config.rcParams.averageBitRate = avctx->bit_rate;
} else if (ctx->encode_config.rcParams.averageBitRate > 0) {
ctx->encode_config.rcParam... |
devign_test_set_data_22976 | static av_cold int vp3_decode_end(AVCodecContext *avctx)
{
Vp3DecodeContext *s = avctx->priv_data;
int i;
if (avctx->is_copy && !s->current_frame.data[0])
return 0;
av_free(s->superblock_coding);
av_free(s->all_fragments);
av_free(s->coded_fragment_list[0]);
av_free(s->d... |
devign_test_set_data_22980 | static void vnc_disconnect_finish(VncState *vs)
{
vnc_qmp_event(vs, QEVENT_VNC_DISCONNECTED);
buffer_free(&vs->input);
buffer_free(&vs->output);
qobject_decref(vs->info);
#ifdef CONFIG_VNC_TLS
vnc_tls_client_cleanup(vs);
#endif /* CONFIG_VNC_TLS */
#ifdef CONFIG_VNC_SASL
vnc_sasl_client_cleanup(... |
devign_test_set_data_22994 | void qemu_opts_print(QemuOpts *opts)
{
QemuOpt *opt;
QemuOptDesc *desc = opts->list->desc;
if (desc[0].name == NULL) {
QTAILQ_FOREACH(opt, &opts->head, next) {
printf("%s=\"%s\" ", opt->name, opt->str);
}
return;
}
for (; desc && desc->name; desc++) {
... |
devign_test_set_data_23016 | static uint32_t nvic_readl(nvic_state *s, uint32_t offset)
{
ARMCPU *cpu;
uint32_t val;
int irq;
switch (offset) {
case 4: /* Interrupt Control Type. */
return (s->num_irq / 32) - 1;
case 0x10: /* SysTick Control and Status. */
val = s->systick.control;
s->s... |
devign_test_set_data_23049 | static int gxf_write_header(AVFormatContext *s)
{
AVIOContext *pb = s->pb;
GXFContext *gxf = s->priv_data;
GXFStreamContext *vsc = NULL;
uint8_t tracks[255] = {0};
int i, media_info = 0;
if (!pb->seekable) {
av_log(s, AV_LOG_ERROR, "gxf muxer does not support streamed output, p... |
devign_test_set_data_23050 | static void qxl_render_update_area_unlocked(PCIQXLDevice *qxl)
{
VGACommonState *vga = &qxl->vga;
int i;
if (qxl->guest_primary.resized) {
qxl->guest_primary.resized = 0;
qxl->guest_primary.data = memory_region_get_ram_ptr(&qxl->vga.vram);
qxl_set_rect_to_surface(qxl, &qxl->... |
devign_test_set_data_23052 | static void page_init(void)
{
/* NOTE: we can always suppose that qemu_host_page_size >=
TARGET_PAGE_SIZE */
#ifdef _WIN32
{
SYSTEM_INFO system_info;
GetSystemInfo(&system_info);
qemu_real_host_page_size = system_info.dwPageSize;
}
#else
qemu_real_host_page_si... |
devign_test_set_data_23066 | static SocketAddress *tcp_build_address(const char *host_port, Error **errp)
{
InetSocketAddress *iaddr = g_new(InetSocketAddress, 1);
SocketAddress *saddr;
if (inet_parse(iaddr, host_port, errp)) {
qapi_free_InetSocketAddress(iaddr);
return NULL;
}
saddr = g_new0(SocketA... |
devign_test_set_data_23074 | static void nbd_close(BlockDriverState *bs)
{
BDRVNBDState *s = bs->opaque;
qemu_opts_del(s->socket_opts);
nbd_client_session_close(&s->client);
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_23076 | static void reset(DeviceState *d)
{
sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(d);
sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
trace_spapr_drc_reset(spapr_drc_index(drc));
g_free(drc->ccs);
drc->ccs = NULL;
/* immediately upon reset we can safely assume DRCs who... |
devign_test_set_data_23088 | int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
target_ulong len, int type)
{
struct kvm_sw_breakpoint *bp;
CPUState *env;
int err;
if (type == GDB_BREAKPOINT_SW) {
bp = kvm_find_sw_breakpoint(current_env, addr);
if (!bp)
... |
devign_test_set_data_23104 | void helper_fcmp_gt_DT(CPUSH4State *env, float64 t0, float64 t1)
{
int relation;
set_float_exception_flags(0, &env->fp_status);
relation = float64_compare(t0, t1, &env->fp_status);
if (unlikely(relation == float_relation_unordered)) {
update_fpscr(env, GETPC());
} else {
en... |
devign_test_set_data_23105 | static int img_info(int argc, char **argv)
{
int c;
OutputFormat output_format = OFORMAT_HUMAN;
const char *filename, *fmt, *output;
BlockDriverState *bs;
ImageInfo *info;
fmt = NULL;
output = NULL;
for(;;) {
int option_index = 0;
static const struct option l... |
devign_test_set_data_23108 | int qio_dns_resolver_lookup_sync(QIODNSResolver *resolver,
SocketAddressLegacy *addr,
size_t *naddrs,
SocketAddressLegacy ***addrs,
Error **errp)
{
switch (addr->type) {
cas... |
devign_test_set_data_23116 | static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
int nb_sectors, QEMUIOVector *qiov)
{
BDRVQcowState *s = bs->opaque;
int index_in_cluster;
int ret = 0, n;
uint64_t cluster_offset;
struct iovec hd_iov;
QEMUIOVector hd_qiov;
uin... |
devign_test_set_data_23123 | static int mpeg4_decode_gop_header(MpegEncContext *s, GetBitContext *gb)
{
int hours, minutes, seconds;
if (!show_bits(gb, 23)) {
av_log(s->avctx, AV_LOG_WARNING, "GOP header invalid\n");
return -1;
}
hours = get_bits(gb, 5);
minutes = get_bits(gb, 6);
skip_bits1(g... |
devign_test_set_data_23136 | static int ftp_restart(FTPContext *s, int64_t pos)
{
char command[CONTROL_BUFFER_SIZE];
const int rest_codes[] = {350, 0};
snprintf(command, sizeof(command), "REST %"PRId64"\r\n", pos);
if (!ftp_send_command(s, command, rest_codes, NULL))
return AVERROR(EIO);
return 0;
}
The vu... |
devign_test_set_data_23140 | static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
int64_t offset, unsigned int bytes, QEMUIOVector *qiov)
{
BlockDriverState *bs = child->bs;
/* Perform I/O through a temporary buffer so that users who scribble over
* their read buffer while the operation is in progress do n... |
devign_test_set_data_23145 | int kvm_ioctl(KVMState *s, int type, ...)
{
int ret;
void *arg;
va_list ap;
va_start(ap, type);
arg = va_arg(ap, void *);
va_end(ap);
ret = ioctl(s->fd, type, arg);
if (ret == -1)
ret = -errno;
return ret;
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_23155 | static uint64_t exynos4210_mct_read(void *opaque, target_phys_addr_t offset,
unsigned size)
{
Exynos4210MCTState *s = (Exynos4210MCTState *)opaque;
int index;
int shift;
uint64_t count;
uint32_t value;
int lt_i;
switch (offset) {
case MCT_CFG:
value = s->re... |
devign_test_set_data_23159 | theora_gptopts(AVFormatContext *ctx, int idx, uint64_t gp, int64_t *dts)
{
struct ogg *ogg = ctx->priv_data;
struct ogg_stream *os = ogg->streams + idx;
struct theora_params *thp = os->private;
uint64_t iframe = gp >> thp->gpshift;
uint64_t pframe = gp & thp->gpmask;
if (thp->version < ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.