static char * _lookup_error(char const * filename) { error_set("%s%s%s%s", "Cannot include <", filename, ">: ", strerror(errno)); return NULL; }
static int stream_get(stream_t *stream, json_error_t *error) { int c; if(stream->state != STREAM_STATE_OK) return stream->state; if(!stream->buffer[stream->buffer_pos]) { c = stream->get(stream->data); if(c == EOF) { stream->state = STREAM_STATE_EOF; return STREAM_STATE_EOF; } stream->buffer[0] = c; stream->buffer_pos = 0; if(0x80 <= c && c <= 0xFF) { /* multi-byte UTF-8 sequence */ int i, count; count = utf8_check_first(c); if(!count) goto out; assert(count >= 2); for(i = 1; i < count; i++) stream->buffer[i] = stream->get(stream->data); if(!utf8_check_full(stream->buffer, count, NULL)) goto out; stream->buffer[count] = '\0'; } else stream->buffer[1] = '\0'; } c = stream->buffer[stream->buffer_pos++]; stream->position++; if(c == '\n') { stream->line++; stream->last_column = stream->column; stream->column = 0; } else if(utf8_check_first(c)) { /* track the Unicode character column, so increment only if this is the first character of a UTF-8 sequence */ stream->column++; } return c; out: stream->state = STREAM_STATE_ERROR; error_set(error, stream_to_lex(stream), "unable to decode byte 0x%x", c); return STREAM_STATE_ERROR; }
static int lex_scan_number(lex_t *lex, int c, json_error_t *error) { const char *saved_text; char *end; double doubleval; lex->token = TOKEN_INVALID; if(c == '-') c = lex_get_save(lex, error); if(c == '0') { c = lex_get_save(lex, error); if(l_isdigit(c)) { lex_unget_unsave(lex, c); goto out; } } else if(l_isdigit(c)) { c = lex_get_save(lex, error); while(l_isdigit(c)) c = lex_get_save(lex, error); } else { lex_unget_unsave(lex, c); goto out; } if(c != '.' && c != 'E' && c != 'e') { json_int_t intval; lex_unget_unsave(lex, c); saved_text = strbuffer_value(&lex->saved_text); errno = 0; intval = json_strtoint(saved_text, &end, 10); if(errno == ERANGE) { if(intval < 0) error_set(error, lex, "too big negative integer"); else error_set(error, lex, "too big integer"); goto out; } assert(end == saved_text + lex->saved_text.length); lex->token = TOKEN_INTEGER; lex->value.integer = intval; return 0; } if(c == '.') { c = lex_get(lex, error); if(!l_isdigit(c)) { lex_unget(lex, c); goto out; } lex_save(lex, c); c = lex_get_save(lex, error); while(l_isdigit(c)) c = lex_get_save(lex, error); } if(c == 'E' || c == 'e') { c = lex_get_save(lex, error); if(c == '+' || c == '-') c = lex_get_save(lex, error); if(!l_isdigit(c)) { lex_unget_unsave(lex, c); goto out; } c = lex_get_save(lex, error); while(l_isdigit(c)) c = lex_get_save(lex, error); } lex_unget_unsave(lex, c); if(jsonp_strtod(&lex->saved_text, &doubleval)) { error_set(error, lex, "real number overflow"); goto out; } lex->token = TOKEN_REAL; lex->value.real = doubleval; return 0; out: return -1; }
adv_error fb_mode_set(const fb_video_mode* mode) { unsigned req_xres; unsigned req_yres; unsigned req_bits_per_pixel; assert(fb_is_active() && !fb_mode_is_active()); log_std(("video:fb: fb_mode_set()\n")); log_std(("video:fb: get old\n")); /* get the current info */ if (fb_getvar(&fb_state.oldinfo, 0) != 0) { error_set("Error getting the variable video mode information.\n"); goto err; } fb_log(0, &fb_state.oldinfo); fb_preset(&fb_state.varinfo, mode->crtc.pixelclock, mode->crtc.hde, mode->crtc.hrs, mode->crtc.hre, mode->crtc.ht, mode->crtc.vde, mode->crtc.vrs, mode->crtc.vre, mode->crtc.vt, crtc_is_doublescan(&mode->crtc), crtc_is_interlace(&mode->crtc), crtc_is_nhsync(&mode->crtc), crtc_is_nvsync(&mode->crtc), mode->index, FB_ACTIVATE_NOW ); log_std(("video:fb: set new\n")); fb_log(0, &fb_state.varinfo); /* save the minimun required data */ req_xres = fb_state.varinfo.xres; req_yres = fb_state.varinfo.yres; req_bits_per_pixel = fb_state.varinfo.bits_per_pixel; /* set the mode */ if (fb_setvar(&fb_state.varinfo) != 0) { error_set("Error setting the variable video mode information.\n"); goto err; } log_std(("video:fb: get new\n")); /* get the fixed info */ if (fb_getfix(&fb_state.fixinfo) != 0) { error_set("Error getting the fixed video mode information.\n"); goto err_restore; } /* get the variable info */ if (fb_getvar(&fb_state.varinfo, mode->index) != 0) { error_set("Error getting the variable video mode information.\n"); goto err_restore; } fb_state.freq = fb_state.varinfo.pixclock; fb_state.freq *= fb_state.varinfo.xres + fb_state.varinfo.left_margin + fb_state.varinfo.right_margin + fb_state.varinfo.hsync_len; fb_state.freq *= fb_state.varinfo.yres + fb_state.varinfo.upper_margin + fb_state.varinfo.lower_margin + fb_state.varinfo.vsync_len; if (fb_state.freq != 0) { fb_state.freq = 1000000000000LL / fb_state.freq; } log_std(("video:fb: frequency %g\n", fb_state.freq)); fb_log(&fb_state.fixinfo, &fb_state.varinfo); /* check the validity of the resulting video mode */ if (req_xres > fb_state.varinfo.xres || req_yres > fb_state.varinfo.yres || req_bits_per_pixel != fb_state.varinfo.bits_per_pixel ) { log_std(("ERROR:video:fb: request for mode %dx%d %d bits resulted in mode %dx%dx %d bits\n", req_xres, req_yres, req_bits_per_pixel, fb_state.varinfo.xres, fb_state.varinfo.yres, fb_state.varinfo.bits_per_pixel)); error_set("Error setting the requested video mode.\n"); goto err_restore; } if (req_xres != fb_state.varinfo.xres || req_yres != fb_state.varinfo.yres ) { /* allow bigger modes */ log_std(("WARNING:video:fb: request for mode %dx%d resulted in mode %dx%dx\n", req_xres, req_yres, fb_state.varinfo.xres, fb_state.varinfo.yres)); } if (fb_setup_color() != 0) { error_set("Error setting the color information.\n"); goto err_restore; } fb_write_line = fb_linear_write_line; fb_state.bytes_per_pixel = (fb_state.varinfo.bits_per_pixel + 7) / 8; fb_state.bytes_per_scanline = fb_state.fixinfo.line_length; fb_state.index = mode->index; fb_state.ptr = mmap(0, fb_state.fixinfo.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, fb_state.fd, 0 ); if (fb_state.ptr == MAP_FAILED) { error_set("Error mapping the video memory.\n"); goto err_restore; } fb_state.wait_last = 0; fb_state.wait = fb_wait_detect; /* reset the wait mode */ fb_state.wait_error = 0; fb_state.mode_active = 1; return 0; err_restore: fb_setvar(&fb_state.oldinfo); /* ignore error */ err: return -1; }
/*! * Take an arbitrary mixed list of integers and floats and add all numbers, * returning the resulting sum. * * \param[in] req Request * \param[in,out] res Result * \param[in,out] drv_state Driver state * \param[in,out] trd_state Thread state */ static void handle_sum(gd_req_t *req, gd_res_t *res, gdt_drv_t *drv, gdt_trd_t *trd) { int type, size; /* Determine type and size */ if (ei_get_type(req->buf, &req->index, &type, &size) || size <= 0) return error_set(res, GDE_ERR_TYPE); /* Allocate memory for numbers */ double *values, sum = 0; if (!(values = driver_alloc(sizeof(double) * size))) return error_set(res, GDE_ERR_MEMORY); /* Decode list */ switch (type) { /* Decode integer list interpreted as string */ case ERL_STRING_EXT: { char value[size]; if (ei_decode_string(req->buf, &req->index, (char *)&value)) return error_set(res, GDE_ERR_DECODE); for (int v = 0; v < size; v++) values[v] = (double)value[v]; break; } /* Decode ordinary integer/double list */ case ERL_LIST_EXT: { if (ei_decode_list_header(req->buf, &req->index, &size)) return error_set(res, GDE_ERR_DECODE); for (int v = 0, temp; v < size; v++) { ei_get_type(req->buf, &req->index, &type, &temp); switch (type) { /* Decode integer */ case ERL_SMALL_INTEGER_EXT: case ERL_INTEGER_EXT: { long value; if (ei_decode_long(req->buf, &req->index, &value)) return error_set(res, GDE_ERR_DECODE); values[v] = (double)value; break; } /* Decode double */ case ERL_FLOAT_EXT: { double value; if (ei_decode_double(req->buf, &req->index, &value)) return error_set(res, GDE_ERR_DECODE); values[v] = (double)value; break; } /* Unsupported type */ default: return error_set(res, GDE_ERR_TYPE); } } /* A list always contains an empty list at the end */ if (ei_decode_list_header(req->buf, &req->index, NULL)) return error_set(res, GDE_ERR_DECODE); break; } /* Unsupported type */ default: return error_set(res, GDE_ERR_TYPE); } /* Sum up values */ for (int v = 0; v < size; v++) sum += values[v]; /* Free allocated memory */ driver_free(values); /* Encode resulting sum and return tuple */ ei_encode_tuple_header(res->buf, &res->index, 2); ei_encode_atom(res->buf, &res->index, "ok"); ei_encode_double(res->buf, &res->index, sum); /* Update counters */ drv->count++; trd->count++; }
GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp) { error_set(errp, QERR_UNSUPPORTED); return NULL; }
static gboolean _battery_get(Battery * battery, gdouble * level, gboolean * charging) { int i; envsys_basic_info_t info; envsys_tre_data_t tre; unsigned int rate = 0; unsigned int charge = 0; unsigned int maxcharge = 0; *charging = FALSE; if(battery->fd < 0 && (battery->fd = open(_PATH_SYSMON, O_RDONLY)) < 0) { error_set("%s: %s: %s", applet.name, _PATH_SYSMON, strerror(errno)); *level = -1.0; return TRUE; } for(i = 0; i >= 0; i++) { memset(&info, 0, sizeof(info)); info.sensor = i; if(ioctl(battery->fd, ENVSYS_GTREINFO, &info) == -1) { close(battery->fd); battery->fd = -1; error_set("%s: %s: %s", applet.name, "ENVSYS_GTREINFO", strerror(errno)); *level = -1.0; return TRUE; } if(!(info.validflags & ENVSYS_FVALID)) break; #ifdef DEBUG fprintf(stderr, "DEBUG: %s() %d \"%s\"\n", __func__, i, info.desc); #endif if(strcmp("acpiacad0 connected", info.desc) == 0 && _get_tre(battery->fd, i, &tre) == 0 && tre.validflags & ENVSYS_FCURVALID) /* FIXME implement */ continue; if(strncmp("acpibat", info.desc, 7) != 0 || info.desc[7] == '\0' || info.desc[8] != ' ') continue; if(strcmp("charge", &info.desc[9]) == 0 && _get_tre(battery->fd, i, &tre) == 0 && tre.validflags & ENVSYS_FCURVALID && tre.validflags & ENVSYS_FMAXVALID) { charge += tre.cur.data_us; maxcharge += tre.max.data_us; } else if(strcmp("charge rate", &info.desc[9]) == 0 && _get_tre(battery->fd, i, &tre) == 0 && tre.validflags & ENVSYS_FCURVALID) rate += tre.cur.data_us; else if(strcmp("charging", &info.desc[9]) == 0 && _get_tre(battery->fd, i, &tre) == 0 && tre.validflags & ENVSYS_FCURVALID && tre.cur.data_us > 0) { *charging = TRUE; continue; } else if(strcmp("discharge rate", &info.desc[9]) == 0 && _get_tre(battery->fd, i, &tre) == 0 && tre.validflags & ENVSYS_FCURVALID) rate += tre.cur.data_us; } *level = (charge * 100.0) / maxcharge; return TRUE; }
GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count, int64_t count, Error **err) { error_set(err, QERR_UNSUPPORTED); return 0; }
GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64, bool has_count, int64_t count, Error **err) { error_set(err, QERR_UNSUPPORTED); return 0; }
static json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error) { json_t *json; switch(lex->token) { case TOKEN_STRING: { const char *value = lex->value.string.val; size_t len = lex->value.string.len; if(!(flags & JSON_ALLOW_NUL)) { if(memchr(value, '\0', len)) { error_set(error, lex, "\\u0000 is not allowed without JSON_ALLOW_NUL"); return NULL; } } json = jsonp_stringn_nocheck_own(value, len); if(json) { lex->value.string.val = NULL; lex->value.string.len = 0; } break; } case TOKEN_INTEGER: { json = json_integer(lex->value.integer); break; } case TOKEN_REAL: { json = json_real(lex->value.real); break; } case TOKEN_TRUE: json = json_true(); break; case TOKEN_FALSE: json = json_false(); break; case TOKEN_NULL: json = json_null(); break; case '{': json = parse_object(lex, flags, error); break; case '[': json = parse_array(lex, flags, error); break; case TOKEN_INVALID: error_set(error, lex, "invalid token"); return NULL; default: error_set(error, lex, "unexpected token"); return NULL; } if(!json) return NULL; return json; }
int64_t qmp_guest_file_open(const char *path, bool has_mode, const char *mode, Error **err) { error_set(err, QERR_UNSUPPORTED); return 0; }
static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, Error **errp) { BDRVVHDXState *s = bs->opaque; int ret = 0; uint32_t i; uint64_t signature; uint32_t data_blocks_cnt, bitmap_blocks_cnt; s->bat = NULL; qemu_co_mutex_init(&s->lock); /* validate the file signature */ ret = bdrv_pread(bs->file, 0, &signature, sizeof(uint64_t)); if (ret < 0) { goto fail; } if (memcmp(&signature, "vhdxfile", 8)) { ret = -EINVAL; goto fail; } ret = vhdx_parse_header(bs, s); if (ret) { goto fail; } ret = vhdx_parse_log(bs, s); if (ret) { goto fail; } ret = vhdx_open_region_tables(bs, s); if (ret) { goto fail; } ret = vhdx_parse_metadata(bs, s); if (ret) { goto fail; } s->block_size = s->params.block_size; /* the VHDX spec dictates that virtual_disk_size is always a multiple of * logical_sector_size */ bs->total_sectors = s->virtual_disk_size >> s->logical_sector_size_bits; data_blocks_cnt = s->virtual_disk_size >> s->block_size_bits; if (s->virtual_disk_size - (data_blocks_cnt << s->block_size_bits)) { data_blocks_cnt++; } bitmap_blocks_cnt = data_blocks_cnt >> s->chunk_ratio_bits; if (data_blocks_cnt - (bitmap_blocks_cnt << s->chunk_ratio_bits)) { bitmap_blocks_cnt++; } if (s->parent_entries) { s->bat_entries = bitmap_blocks_cnt * (s->chunk_ratio + 1); } else { s->bat_entries = data_blocks_cnt + ((data_blocks_cnt - 1) >> s->chunk_ratio_bits); } s->bat_offset = s->bat_rt.file_offset; if (s->bat_entries > s->bat_rt.length / sizeof(VHDXBatEntry)) { /* BAT allocation is not large enough for all entries */ ret = -EINVAL; goto fail; } s->bat = qemu_blockalign(bs, s->bat_rt.length); ret = bdrv_pread(bs->file, s->bat_offset, s->bat, s->bat_rt.length); if (ret < 0) { goto fail; } for (i = 0; i < s->bat_entries; i++) { le64_to_cpus(&s->bat[i]); } if (flags & BDRV_O_RDWR) { ret = -ENOTSUP; goto fail; } /* TODO: differencing files, write */ /* Disable migration when VHDX images are used */ error_set(&s->migration_blocker, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, "vhdx", bs->device_name, "live migration"); migrate_add_blocker(s->migration_blocker); return 0; fail: qemu_vfree(s->headers[0]); qemu_vfree(s->headers[1]); qemu_vfree(s->bat); qemu_vfree(s->parent_entries); return ret; }
static void freq_scheduler_set_error(FreqScheduler *sch, int code, const char *message) { error_set(sch->error, code, message); }
adv_error mouseb_rawinput_init(int mouseb_id) { #if defined(USE_SDL) && SDL_MAJOR_VERSION != 1 error_set("Incompatible with SDL2.\n"); return -1; #else unsigned i; HMODULE h; UINT n; UINT size; RAWINPUTDEVICELIST* l; log_std(("mouseb:rawinput: mouseb_rawinput_init(id:%d)\n", mouseb_id)); h = GetModuleHandle("user32.dll"); if (!h) { error_set("Error loading the user32 library.\n"); return -1; } RegisterRawInputDevices_ptr = (RegisterRawInputDevices_type)GetProcAddress(h, "RegisterRawInputDevices"); GetRawInputDeviceList_ptr = (GetRawInputDeviceList_type)GetProcAddress(h, "GetRawInputDeviceList"); GetRawInputDeviceInfoA_ptr = (GetRawInputDeviceInfoA_type)GetProcAddress(h, "GetRawInputDeviceInfoA"); GetRawInputData_ptr = (GetRawInputData_type)GetProcAddress(h, "GetRawInputData"); if (!RegisterRawInputDevices_ptr || !GetRawInputDeviceList_ptr || !GetRawInputDeviceInfoA_ptr || !GetRawInputData_ptr) { error_set("Raw input devices not supported on your system.\n"); return -1; } if (GetRawInputDeviceList_ptr(NULL, &n, sizeof(RAWINPUTDEVICELIST)) != 0) { error_set("Error getting the number of raw devices.\n"); return -1; } if (n == 0) { error_set("No input device found.\n"); return -1; } size = n * sizeof(RAWINPUTDEVICELIST); l = malloc(size); n = GetRawInputDeviceList_ptr(l, &size, sizeof(RAWINPUTDEVICELIST)); if (n == -1) { free(l); error_set("Error getting the list of raw devices.\n"); return -1; } log_std(("mouseb:rawinput: GetRawInputDeviceList() -> %d\n", (unsigned)n)); raw_state.mac = 0; for (i = 0; i < n; ++i) { if (raw_state.mac < RAW_MOUSE_MAX) { UINT size; unsigned vid, pid, rev; struct raw_context* context = &raw_state.map[raw_state.mac].context; size = sizeof(RID_DEVICE_INFO); context->info.cbSize = sizeof(RID_DEVICE_INFO); if (GetRawInputDeviceInfoA_ptr(l[i].hDevice, RIDI_DEVICEINFO, &context->info, &size) == -1) { continue; } size = sizeof(context->name); if (GetRawInputDeviceInfoA_ptr(l[i].hDevice, RIDI_DEVICENAME, context->name, &size) < 0) { continue; } /* Get the VID/PID */ if (GetRawInputDeviceHIDInfo(context->name, &vid, &pid, &rev) < 0) { /* on error use fake value, for not HID devices it's ok to fail */ vid = 0; pid = 0; rev = 0; } log_std(("mouseb:rawinput: GetRawInputDeviceInfo(%d) -> type:%d,vid:%04x,pid:%04x,rev:%04x,%s\n", i, (unsigned)context->info.dwType, vid, pid, rev, context->name)); /* HACK skip the global mouse which is the combination of all the others */ if (strstr(context->name, "#RDP_MOU#") != 0) { continue; } if (context->info.dwType != RIM_TYPEMOUSE) { continue; } if ( /* SMOG Lightgun (http://lightgun.splinder.com/) */ (vid == 0x0b9a && pid == 0x016a) /* Acts Labs Lightgun (http://www.act-labs.com/) */ || (vid == 0x061c && pid == 0xa800) || (vid == 0x061c && pid == 0xa700) ) { /* ignore known lightguns */ continue; } raw_state.map[raw_state.mac].context.h = l[i].hDevice; log_std(("mouseb:rawinput: mouse id:%d,vid:%04x,pid:%04x,rev:%04x,buttons:%d,samplerate:%d\n", (unsigned)context->info.mouse.dwId, vid, pid, rev, (unsigned)context->info.mouse.dwNumberOfButtons, (unsigned)context->info.mouse.dwSampleRate)); mouseb_setup(&raw_state.map[raw_state.mac], context->info.mouse.dwNumberOfButtons); ++raw_state.mac; } } free(l); if (raw_state.mac == 0) { error_set("No mouse found.\n"); return -1; } qsort(raw_state.map, raw_state.mac, sizeof(raw_state.map[0]), mouseb_compare); return 0; #endif }
int64_t qmp_guest_get_time(Error **errp) { error_set(errp, QERR_UNSUPPORTED); return -1; }
GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset, int64_t whence, Error **err) { error_set(err, QERR_UNSUPPORTED); return 0; }
void qmp_guest_set_time(int64_t time_ns, Error **errp) { error_set(errp, QERR_UNSUPPORTED); }
void qmp_guest_file_flush(int64_t handle, Error **err) { error_set(err, QERR_UNSUPPORTED); }
int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp) { error_set(errp, QERR_UNSUPPORTED); return -1; }
/* * Return status of freeze/thaw */ GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **err) { error_set(err, QERR_UNSUPPORTED); return 0; }
adv_error fb_init(int device_id, adv_output output, unsigned overlay_size, adv_cursor cursor) { const char* fb; char id_buffer[64]; char* term; (void)cursor; (void)overlay_size; assert(!fb_is_active()); log_std(("video:fb: fb_init()\n")); if (sizeof(fb_video_mode) > MODE_DRIVER_MODE_SIZE_MAX) return -1; if (os_internal_wm_active()) { error_set("Unsupported in X. Try with the SDL library.\n"); return -1; } term = getenv("TERM"); if (!term || strcmp(term, "linux")!=0) { error_set("Works only with TERM=linux terminals.\n"); return -1; } if (output != adv_output_auto && output != adv_output_fullscreen) { error_set("Only fullscreen output is supported.\n"); return -1; } fb = getenv("FRAMEBUFFER"); if (fb && fb[0]) { fb_state.fd = open(fb, O_RDWR); } else { fb = "/dev/fb0"; fb_state.fd = open(fb, O_RDWR); if (fb_state.fd < 0 && errno == ENOENT) { fb = "/dev/fb/0"; fb_state.fd = open(fb, O_RDWR); } } if (fb_state.fd < 0) { if (errno == ENODEV) { error_set("Video board not supported. Error %d (%s).\n", errno, strerror(errno)); } else { error_set("Error opening the frame buffer %s. Error %d (%s).\n", fb, errno, strerror(errno)); } return -1; } /* get the fixed info */ if (fb_getfix(&fb_state.fixinfo) != 0) { error_set("Error getting the fixed video mode information.\n"); goto err_close; } /* get the variable info */ if (fb_getvar(&fb_state.varinfo, 0) != 0) { error_set("Error getting the variable video mode information.\n"); goto err_close; } /* copy the id in a safe way, it may be not 0 terminated */ sncpyn(id_buffer, sizeof(id_buffer), fb_state.fixinfo.id, sizeof(fb_state.fixinfo.id)); log_std(("video:fb: id %s\n", id_buffer)); fb_log(&fb_state.fixinfo, &fb_state.varinfo); if (strcmp(id_buffer, "VESA VGA")==0) { error_set("The 'vesafb' FrameBuffer driver doesn't allow the creation of new video modes.\n"); goto err_close; } fb_state.flags = VIDEO_DRIVER_FLAGS_MODE_PALETTE8 | VIDEO_DRIVER_FLAGS_MODE_BGR15 | VIDEO_DRIVER_FLAGS_MODE_BGR16 | VIDEO_DRIVER_FLAGS_MODE_BGR24 | VIDEO_DRIVER_FLAGS_MODE_BGR32 | VIDEO_DRIVER_FLAGS_PROGRAMMABLE_ALL | VIDEO_DRIVER_FLAGS_OUTPUT_FULLSCREEN; if (fb_detect() != 0) { goto err_close; } if ((fb_state.flags & (VIDEO_DRIVER_FLAGS_MODE_PALETTE8 | VIDEO_DRIVER_FLAGS_MODE_BGR15 | VIDEO_DRIVER_FLAGS_MODE_BGR16 | VIDEO_DRIVER_FLAGS_MODE_BGR24 | VIDEO_DRIVER_FLAGS_MODE_BGR32)) == 0) { error_set("This '%s' FrameBuffer driver doesn't seem to allow the creation of new video modes.\n", id_buffer); goto err_close; } fb_state.active = 1; return 0; err_close: close(fb_state.fd); return -1; }
/* * Walk list of frozen file systems in the guest, and thaw them. */ int64_t qmp_guest_fsfreeze_thaw(Error **err) { error_set(err, QERR_UNSUPPORTED); return 0; }
static int bdrv_qed_open(BlockDriverState *bs, QDict *options, int flags, Error **errp) { BDRVQEDState *s = bs->opaque; QEDHeader le_header; int64_t file_size; int ret; s->bs = bs; QSIMPLEQ_INIT(&s->allocating_write_reqs); ret = bdrv_pread(bs->file, 0, &le_header, sizeof(le_header)); if (ret < 0) { return ret; } qed_header_le_to_cpu(&le_header, &s->header); if (s->header.magic != QED_MAGIC) { error_setg(errp, "Image not in QED format"); return -EINVAL; } if (s->header.features & ~QED_FEATURE_MASK) { /* image uses unsupported feature bits */ char buf[64]; snprintf(buf, sizeof(buf), "%" PRIx64, s->header.features & ~QED_FEATURE_MASK); error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE, bs->device_name, "QED", buf); return -ENOTSUP; } if (!qed_is_cluster_size_valid(s->header.cluster_size)) { return -EINVAL; } /* Round down file size to the last cluster */ file_size = bdrv_getlength(bs->file); if (file_size < 0) { return file_size; } s->file_size = qed_start_of_cluster(s, file_size); if (!qed_is_table_size_valid(s->header.table_size)) { return -EINVAL; } if (!qed_is_image_size_valid(s->header.image_size, s->header.cluster_size, s->header.table_size)) { return -EINVAL; } if (!qed_check_table_offset(s, s->header.l1_table_offset)) { return -EINVAL; } s->table_nelems = (s->header.cluster_size * s->header.table_size) / sizeof(uint64_t); s->l2_shift = ffs(s->header.cluster_size) - 1; s->l2_mask = s->table_nelems - 1; s->l1_shift = s->l2_shift + ffs(s->table_nelems) - 1; if ((s->header.features & QED_F_BACKING_FILE)) { if ((uint64_t)s->header.backing_filename_offset + s->header.backing_filename_size > s->header.cluster_size * s->header.header_size) { return -EINVAL; } ret = qed_read_string(bs->file, s->header.backing_filename_offset, s->header.backing_filename_size, bs->backing_file, sizeof(bs->backing_file)); if (ret < 0) { return ret; } if (s->header.features & QED_F_BACKING_FORMAT_NO_PROBE) { pstrcpy(bs->backing_format, sizeof(bs->backing_format), "raw"); } } /* Reset unknown autoclear feature bits. This is a backwards * compatibility mechanism that allows images to be opened by older * programs, which "knock out" unknown feature bits. When an image is * opened by a newer program again it can detect that the autoclear * feature is no longer valid. */ if ((s->header.autoclear_features & ~QED_AUTOCLEAR_FEATURE_MASK) != 0 && !bdrv_is_read_only(bs->file) && !(flags & BDRV_O_INCOMING)) { s->header.autoclear_features &= QED_AUTOCLEAR_FEATURE_MASK; ret = qed_write_header_sync(s); if (ret) { return ret; } /* From here on only known autoclear feature bits are valid */ bdrv_flush(bs->file); } s->l1_table = qed_alloc_table(s); qed_init_l2_cache(&s->l2_cache); ret = qed_read_l1_table_sync(s); if (ret) { goto out; } /* If image was not closed cleanly, check consistency */ if (!(flags & BDRV_O_CHECK) && (s->header.features & QED_F_NEED_CHECK)) { /* Read-only images cannot be fixed. There is no risk of corruption * since write operations are not possible. Therefore, allow * potentially inconsistent images to be opened read-only. This can * aid data recovery from an otherwise inconsistent image. */ if (!bdrv_is_read_only(bs->file) && !(flags & BDRV_O_INCOMING)) { BdrvCheckResult result = {0}; ret = qed_check(s, &result, true); if (ret) { goto out; } } } bdrv_qed_attach_aio_context(bs, bdrv_get_aio_context(bs)); out: if (ret) { qed_free_l2_cache(&s->l2_cache); qemu_vfree(s->l1_table); } return ret; }
/* * Walk list of mounted file systems in the guest, and discard unused * areas. */ void qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **err) { error_set(err, QERR_UNSUPPORTED); }
static json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error) { json_t *json; double value; switch(lex->token) { case TOKEN_STRING: { json = json_string_nocheck(lex->value.string); break; } case TOKEN_INTEGER: { if (flags & JSON_DECODE_INT_AS_REAL) { if(jsonp_strtod(&lex->saved_text, &value)) { error_set(error, lex, "real number overflow"); return NULL; } json = json_real(value); } else if (flags & JSON_DECODE_SNUMBER) { json = json_snumber_nocheck(lex->value.string); } else { json = json_integer(lex->value.integer); } break; } case TOKEN_REAL: { if (flags & JSON_DECODE_SNUMBER) { json = json_snumber_nocheck(lex->value.string); } else { json = json_real(lex->value.real); } break; } case TOKEN_TRUE: json = json_true(); break; case TOKEN_FALSE: json = json_false(); break; case TOKEN_NULL: json = json_null(); break; case '{': json = parse_object(lex, flags, error); break; case '[': json = parse_array(lex, flags, error); break; case TOKEN_INVALID: error_set(error, lex, "invalid token"); return NULL; default: error_set(error, lex, "unexpected token"); return NULL; } if(!json) return NULL; return json; }
void qmp_guest_suspend_hybrid(Error **err) { error_set(err, QERR_UNSUPPORTED); }
static void lex_scan_string(lex_t *lex, json_error_t *error) { int c; const char *p; char *t; int i; lex->value.string.val = NULL; lex->token = TOKEN_INVALID; c = lex_get_save(lex, error); while(c != '"') { if(c == STREAM_STATE_ERROR) goto out; else if(c == STREAM_STATE_EOF) { error_set(error, lex, "premature end of input"); goto out; } else if(0 <= c && c <= 0x1F) { /* control character */ lex_unget_unsave(lex, c); if(c == '\n') error_set(error, lex, "unexpected newline", c); else error_set(error, lex, "control character 0x%x", c); goto out; } else if(c == '\\') { c = lex_get_save(lex, error); if(c == 'u') { c = lex_get_save(lex, error); for(i = 0; i < 4; i++) { if(!l_isxdigit(c)) { error_set(error, lex, "invalid escape"); goto out; } c = lex_get_save(lex, error); } } else if(c == '"' || c == '\\' || c == '/' || c == 'b' || c == 'f' || c == 'n' || c == 'r' || c == 't') c = lex_get_save(lex, error); else { error_set(error, lex, "invalid escape"); goto out; } } else c = lex_get_save(lex, error); } /* the actual value is at most of the same length as the source string, because: - shortcut escapes (e.g. "\t") (length 2) are converted to 1 byte - a single \uXXXX escape (length 6) is converted to at most 3 bytes - two \uXXXX escapes (length 12) forming an UTF-16 surrogate pair are converted to 4 bytes */ t = (char *)jsonp_malloc(lex->saved_text.length + 1); if(!t) { /* this is not very nice, since TOKEN_INVALID is returned */ goto out; } lex->value.string.val = t; /* + 1 to skip the " */ p = strbuffer_value(&lex->saved_text) + 1; while(*p != '"') { if(*p == '\\') { p++; if(*p == 'u') { size_t length; int32_t value; value = decode_unicode_escape(p); if(value < 0) { error_set(error, lex, "invalid Unicode escape '%.6s'", p - 1); goto out; } p += 5; if(0xD800 <= value && value <= 0xDBFF) { /* surrogate pair */ if(*p == '\\' && *(p + 1) == 'u') { int32_t value2 = decode_unicode_escape(++p); if(value2 < 0) { error_set(error, lex, "invalid Unicode escape '%.6s'", p - 1); goto out; } p += 5; if(0xDC00 <= value2 && value2 <= 0xDFFF) { /* valid second surrogate */ value = ((value - 0xD800) << 10) + (value2 - 0xDC00) + 0x10000; } else { /* invalid second surrogate */ error_set(error, lex, "invalid Unicode '\\u%04X\\u%04X'", value, value2); goto out; } } else { /* no second surrogate */ error_set(error, lex, "invalid Unicode '\\u%04X'", value); goto out; } } else if(0xDC00 <= value && value <= 0xDFFF) { error_set(error, lex, "invalid Unicode '\\u%04X'", value); goto out; } if(utf8_encode(value, t, &length)) assert(0); t += length; } else { switch(*p) { case '"': case '\\': case '/': *t = *p; break; case 'b': *t = '\b'; break; case 'f': *t = '\f'; break; case 'n': *t = '\n'; break; case 'r': *t = '\r'; break; case 't': *t = '\t'; break; default: assert(0); } t++; p++; } } else *(t++) = *(p++); } *t = '\0'; lex->value.string.len = t - lex->value.string.val; lex->token = TOKEN_STRING; return; out: lex_free_string(lex); }
GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **err) { error_set(err, QERR_UNSUPPORTED); return NULL; }
static json_t *parse_object(lex_t *lex, size_t flags, json_error_t *error) { json_t *object = json_object(); if(!object) return NULL; lex_scan(lex, error); if(lex->token == '}') return object; while(1) { char *key; size_t len; json_t *value; if(lex->token != TOKEN_STRING) { error_set(error, lex, "string or '}' expected"); goto error; } key = lex_steal_string(lex, &len); if(!key) return NULL; if (memchr(key, '\0', len)) { jsonp_free(key); error_set(error, lex, "NUL byte in object key not supported"); goto error; } if(flags & JSON_REJECT_DUPLICATES) { if(json_object_get(object, key)) { jsonp_free(key); error_set(error, lex, "duplicate object key"); goto error; } } lex_scan(lex, error); if(lex->token != ':') { jsonp_free(key); error_set(error, lex, "':' expected"); goto error; } lex_scan(lex, error); value = parse_value(lex, flags, error); if(!value) { jsonp_free(key); goto error; } if(json_object_set_nocheck(object, key, value)) { jsonp_free(key); json_decref(value); goto error; } json_decref(value); jsonp_free(key); lex_scan(lex, error); if(lex->token != ',') break; lex_scan(lex, error); } if(lex->token != '}') { error_set(error, lex, "'}' expected"); goto error; } return object; error: json_decref(object); return NULL; }
static json_t *parse_object(lex_t *lex, json_error_t *error) { json_t *object = json_object(); if(!object) return NULL; lex_scan(lex, error); if(lex->token == '}') return object; while(1) { char *key; json_t *value; if(lex->token != TOKEN_STRING) { error_set(error, lex, "string or '}' expected"); goto error; } key = lex_steal_string(lex); if(!key) return NULL; lex_scan(lex, error); if(lex->token != ':') { free(key); error_set(error, lex, "':' expected"); goto error; } lex_scan(lex, error); value = parse_value(lex, error); if(!value) { free(key); goto error; } if(json_object_set_nocheck(object, key, value)) { free(key); json_decref(value); goto error; } json_decref(value); free(key); lex_scan(lex, error); if(lex->token != ',') break; lex_scan(lex, error); } if(lex->token != '}') { error_set(error, lex, "'}' expected"); goto error; } return object; error: json_decref(object); return NULL; }