OpenE2K
/
qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

util: rename qemu_open() to qemu_open_old() 

We want to introduce a new version of qemu_open() that uses an Error
object for reporting problems and make this it the preferred interface.
Rename the existing method to release the namespace for the new impl.

Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
This commit is contained in:
Daniel P. Berrangé 2020-07-21 13:25:21 +01:00
parent c2069ff624
commit 448058aa99
24 changed files with 44 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
accel/kvm/kvm-all.c
View File

@ -2013,7 +2013,7 @@ static int kvm_init(MachineState *ms)
#endif #endif
QLIST_INIT(&s->kvm_parked_vcpus); QLIST_INIT(&s->kvm_parked_vcpus);
s->vmfd = -1; s->vmfd = -1;
s->fd = qemu_open("/dev/kvm", O_RDWR); s->fd = qemu_open_old("/dev/kvm", O_RDWR);
if (s->fd == -1) { if (s->fd == -1) {
fprintf(stderr, "Could not access KVM kernel module: %m\n"); fprintf(stderr, "Could not access KVM kernel module: %m\n");
ret = -errno; ret = -errno;

2
backends/rng-random.c
View File

@ -75,7 +75,7 @@ static void rng_random_opened(RngBackend *b, Error **errp)
error_setg(errp, QERR_INVALID_PARAMETER_VALUE, error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
"filename", "a valid filename"); "filename", "a valid filename");
} else { } else {
s->fd = qemu_open(s->filename, O_RDONLY | O_NONBLOCK); s->fd = qemu_open_old(s->filename, O_RDONLY | O_NONBLOCK);
if (s->fd == -1) { if (s->fd == -1) {
error_setg_file_open(errp, errno, s->filename); error_setg_file_open(errp, errno, s->filename);
} }

8
backends/tpm/tpm_passthrough.c
View File

@ -218,7 +218,7 @@ static int tpm_passthrough_open_sysfs_cancel(TPMPassthruState *tpm_pt)
char path[PATH_MAX]; char path[PATH_MAX];
if (tpm_pt->options->cancel_path) { if (tpm_pt->options->cancel_path) {
fd = qemu_open(tpm_pt->options->cancel_path, O_WRONLY); fd = qemu_open_old(tpm_pt->options->cancel_path, O_WRONLY);
if (fd < 0) { if (fd < 0) {
error_report("tpm_passthrough: Could not open TPM cancel path: %s", error_report("tpm_passthrough: Could not open TPM cancel path: %s",
strerror(errno)); strerror(errno));
@ -236,11 +236,11 @@ static int tpm_passthrough_open_sysfs_cancel(TPMPassthruState *tpm_pt)
dev++; dev++;
if (snprintf(path, sizeof(path), "/sys/class/tpm/%s/device/cancel", if (snprintf(path, sizeof(path), "/sys/class/tpm/%s/device/cancel",
dev) < sizeof(path)) { dev) < sizeof(path)) {
fd = qemu_open(path, O_WRONLY); fd = qemu_open_old(path, O_WRONLY);
if (fd < 0) { if (fd < 0) {
if (snprintf(path, sizeof(path), "/sys/class/misc/%s/device/cancel", if (snprintf(path, sizeof(path), "/sys/class/misc/%s/device/cancel",
dev) < sizeof(path)) { dev) < sizeof(path)) {
fd = qemu_open(path, O_WRONLY); fd = qemu_open_old(path, O_WRONLY);
} }
} }
} }
@ -272,7 +272,7 @@ tpm_passthrough_handle_device_opts(TPMPassthruState *tpm_pt, QemuOpts *opts)
} }
tpm_pt->tpm_dev = value ? value : TPM_PASSTHROUGH_DEFAULT_DEVICE; tpm_pt->tpm_dev = value ? value : TPM_PASSTHROUGH_DEFAULT_DEVICE;
tpm_pt->tpm_fd = qemu_open(tpm_pt->tpm_dev, O_RDWR); tpm_pt->tpm_fd = qemu_open_old(tpm_pt->tpm_dev, O_RDWR);
if (tpm_pt->tpm_fd < 0) { if (tpm_pt->tpm_fd < 0) {
error_report("Cannot access TPM device using '%s': %s", error_report("Cannot access TPM device using '%s': %s",
tpm_pt->tpm_dev, strerror(errno)); tpm_pt->tpm_dev, strerror(errno));

14
block/file-posix.c
View File

@ -630,7 +630,7 @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
raw_parse_flags(bdrv_flags, &s->open_flags, false); raw_parse_flags(bdrv_flags, &s->open_flags, false);
s->fd = -1; s->fd = -1;
fd = qemu_open(filename, s->open_flags, 0644); fd = qemu_open_old(filename, s->open_flags, 0644);
ret = fd < 0 ? -errno : 0; ret = fd < 0 ? -errno : 0;
if (ret < 0) { if (ret < 0) {
@ -1032,13 +1032,13 @@ static int raw_reconfigure_getfd(BlockDriverState *bs, int flags,
} }
} }
/* If we cannot use fcntl, or fcntl failed, fall back to qemu_open() */ /* If we cannot use fcntl, or fcntl failed, fall back to qemu_open_old() */
if (fd == -1) { if (fd == -1) {
const char *normalized_filename = bs->filename; const char *normalized_filename = bs->filename;
ret = raw_normalize_devicepath(&normalized_filename, errp); ret = raw_normalize_devicepath(&normalized_filename, errp);
if (ret >= 0) { if (ret >= 0) {
assert(!(*open_flags & O_CREAT)); assert(!(*open_flags & O_CREAT));
fd = qemu_open(normalized_filename, *open_flags); fd = qemu_open_old(normalized_filename, *open_flags);
if (fd == -1) { if (fd == -1) {
error_setg_errno(errp, errno, "Could not reopen file"); error_setg_errno(errp, errno, "Could not reopen file");
return -1; return -1;
@ -2411,7 +2411,7 @@ raw_co_create(BlockdevCreateOptions *options, Error **errp)
} }
/* Create file */ /* Create file */
fd = qemu_open(file_opts->filename, O_RDWR | O_CREAT | O_BINARY, 0644); fd = qemu_open_old(file_opts->filename, O_RDWR | O_CREAT | O_BINARY, 0644);
if (fd < 0) { if (fd < 0) {
result = -errno; result = -errno;
error_setg_errno(errp, -result, "Could not create file"); error_setg_errno(errp, -result, "Could not create file");
@ -3335,7 +3335,7 @@ static bool setup_cdrom(char *bsd_path, Error **errp)
for (index = 0; index < num_of_test_partitions; index++) { for (index = 0; index < num_of_test_partitions; index++) {
snprintf(test_partition, sizeof(test_partition), "%ss%d", bsd_path, snprintf(test_partition, sizeof(test_partition), "%ss%d", bsd_path,
index); index);
fd = qemu_open(test_partition, O_RDONLY | O_BINARY | O_LARGEFILE); fd = qemu_open_old(test_partition, O_RDONLY | O_BINARY | O_LARGEFILE);
if (fd >= 0) { if (fd >= 0) {
partition_found = true; partition_found = true;
qemu_close(fd); qemu_close(fd);
@ -3653,7 +3653,7 @@ static int cdrom_probe_device(const char *filename)
int prio = 0; int prio = 0;
struct stat st; struct stat st;
fd = qemu_open(filename, O_RDONLY | O_NONBLOCK); fd = qemu_open_old(filename, O_RDONLY | O_NONBLOCK);
if (fd < 0) { if (fd < 0) {
goto out; goto out;
} }
@ -3787,7 +3787,7 @@ static int cdrom_reopen(BlockDriverState *bs)
*/ */
if (s->fd >= 0) if (s->fd >= 0)
qemu_close(s->fd); qemu_close(s->fd);
fd = qemu_open(bs->filename, s->open_flags, 0644); fd = qemu_open_old(bs->filename, s->open_flags, 0644);
if (fd < 0) { if (fd < 0) {
s->fd = -1; s->fd = -1;
return -EIO; return -EIO;

5
block/file-win32.c
View File

@ -596,8 +596,9 @@ static int raw_co_create(BlockdevCreateOptions *options, Error **errp)
return -EINVAL; return -EINVAL;
} }
fd = qemu_open(file_opts->filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, fd = qemu_open_old(file_opts->filename,
0644); O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
0644);
if (fd < 0) { if (fd < 0) {
error_setg_errno(errp, errno, "Could not create file"); error_setg_errno(errp, errno, "Could not create file");
return -EIO; return -EIO;

5
block/vvfat.c
View File

@ -1352,7 +1352,8 @@ static int open_file(BDRVVVFATState* s,mapping_t* mapping)
if(!s->current_mapping || if(!s->current_mapping ||
strcmp(s->current_mapping->path,mapping->path)) { strcmp(s->current_mapping->path,mapping->path)) {
/* open file */ /* open file */
int fd = qemu_open(mapping->path, O_RDONLY | O_BINARY | O_LARGEFILE); int fd = qemu_open_old(mapping->path,
O_RDONLY | O_BINARY | O_LARGEFILE);
if(fd<0) if(fd<0)
return -1; return -1;
vvfat_close_current_file(s); vvfat_close_current_file(s);
@ -2513,7 +2514,7 @@ static int commit_one_file(BDRVVVFATState* s,
for (i = s->cluster_size; i < offset; i += s->cluster_size) for (i = s->cluster_size; i < offset; i += s->cluster_size)
c = modified_fat_get(s, c); c = modified_fat_get(s, c);
fd = qemu_open(mapping->path, O_RDWR | O_CREAT | O_BINARY, 0666); fd = qemu_open_old(mapping->path, O_RDWR | O_CREAT | O_BINARY, 0666);
if (fd < 0) { if (fd < 0) {
fprintf(stderr, "Could not open %s... (%s, %d)\n", mapping->path, fprintf(stderr, "Could not open %s... (%s, %d)\n", mapping->path,
strerror(errno), errno); strerror(errno), errno);

2
chardev/char-fd.c
View File

@ -119,7 +119,7 @@ int qmp_chardev_open_file_source(char *src, int flags, Error **errp)
{ {
int fd = -1; int fd = -1;
TFR(fd = qemu_open(src, flags, 0666)); TFR(fd = qemu_open_old(src, flags, 0666));
if (fd == -1) { if (fd == -1) {
error_setg_file_open(errp, errno, src); error_setg_file_open(errp, errno, src);
} }

6
chardev/char-pipe.c
View File

@ -132,8 +132,8 @@ static void qemu_chr_open_pipe(Chardev *chr,
filename_in = g_strdup_printf("%s.in", filename); filename_in = g_strdup_printf("%s.in", filename);
filename_out = g_strdup_printf("%s.out", filename); filename_out = g_strdup_printf("%s.out", filename);
TFR(fd_in = qemu_open(filename_in, O_RDWR | O_BINARY)); TFR(fd_in = qemu_open_old(filename_in, O_RDWR | O_BINARY));
TFR(fd_out = qemu_open(filename_out, O_RDWR | O_BINARY)); TFR(fd_out = qemu_open_old(filename_out, O_RDWR | O_BINARY));
g_free(filename_in); g_free(filename_in);
g_free(filename_out); g_free(filename_out);
if (fd_in < 0 || fd_out < 0) { if (fd_in < 0 || fd_out < 0) {
@ -143,7 +143,7 @@ static void qemu_chr_open_pipe(Chardev *chr,
if (fd_out >= 0) { if (fd_out >= 0) {
close(fd_out); close(fd_out);
} }
TFR(fd_in = fd_out = qemu_open(filename, O_RDWR | O_BINARY)); TFR(fd_in = fd_out = qemu_open_old(filename, O_RDWR | O_BINARY));
if (fd_in < 0) { if (fd_in < 0) {
error_setg_file_open(errp, errno, filename); error_setg_file_open(errp, errno, filename);
return; return;

2
chardev/char.c
View File

@ -235,7 +235,7 @@ static void qemu_char_open(Chardev *chr, ChardevBackend *backend,
} else { } else {
flags |= O_TRUNC; flags |= O_TRUNC;
} }
chr->logfd = qemu_open(common->logfile, flags, 0666); chr->logfd = qemu_open_old(common->logfile, flags, 0666);
if (chr->logfd < 0) { if (chr->logfd < 0) {
error_setg_errno(errp, errno, error_setg_errno(errp, errno,
"Unable to open logfile %s", "Unable to open logfile %s",

2
dump/dump.c
View File

@ -1994,7 +1994,7 @@ void qmp_dump_guest_memory(bool paging, const char *file,
#endif #endif
if (strstart(file, "file:", &p)) { if (strstart(file, "file:", &p)) {
fd = qemu_open(p, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IRUSR); fd = qemu_open_old(p, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IRUSR);
if (fd < 0) { if (fd < 0) {
error_setg_file_open(errp, errno, p); error_setg_file_open(errp, errno, p);
return; return;

2
hw/s390x/s390-skeys.c
View File

@ -125,7 +125,7 @@ void qmp_dump_skeys(const char *filename, Error **errp)
return; return;
} }
fd = qemu_open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0600); fd = qemu_open_old(filename, O_WRONLY | O_CREAT | O_TRUNC, 0600);
if (fd < 0) { if (fd < 0) {
error_setg_file_open(errp, errno, filename); error_setg_file_open(errp, errno, filename);
return; return;

2
hw/usb/host-libusb.c
View File

@ -1147,7 +1147,7 @@ static void usb_host_realize(USBDevice *udev, Error **errp)
if (s->hostdevice) { if (s->hostdevice) {
int fd; int fd;
s->needs_autoscan = false; s->needs_autoscan = false;
fd = qemu_open(s->hostdevice, O_RDWR); fd = qemu_open_old(s->hostdevice, O_RDWR);
if (fd < 0) { if (fd < 0) {
error_setg_errno(errp, errno, "failed to open %s", s->hostdevice); error_setg_errno(errp, errno, "failed to open %s", s->hostdevice);
return; return;

4
hw/usb/u2f-passthru.c
View File

@ -383,7 +383,7 @@ static int u2f_passthru_open_from_device(struct udev_device *device)
{ {
const char *devnode = udev_device_get_devnode(device); const char *devnode = udev_device_get_devnode(device);
int fd = qemu_open(devnode, O_RDWR); int fd = qemu_open_old(devnode, O_RDWR);
if (fd < 0) { if (fd < 0) {
return -1; return -1;
} else if (!u2f_passthru_is_u2f_device(fd)) { } else if (!u2f_passthru_is_u2f_device(fd)) {
@ -482,7 +482,7 @@ static void u2f_passthru_realize(U2FKeyState *base, Error **errp)
return; return;
#endif #endif
} else { } else {
fd = qemu_open(key->hidraw, O_RDWR); fd = qemu_open_old(key->hidraw, O_RDWR);
if (fd < 0) { if (fd < 0) {
error_setg(errp, "%s: Failed to open %s", TYPE_U2F_PASSTHRU, error_setg(errp, "%s: Failed to open %s", TYPE_U2F_PASSTHRU,
key->hidraw); key->hidraw);

4
hw/vfio/common.c
View File

@ -1254,7 +1254,7 @@ static int vfio_connect_container(VFIOGroup *group, AddressSpace *as,
} }
} }
fd = qemu_open("/dev/vfio/vfio", O_RDWR); fd = qemu_open_old("/dev/vfio/vfio", O_RDWR);
if (fd < 0) { if (fd < 0) {
error_setg_errno(errp, errno, "failed to open /dev/vfio/vfio"); error_setg_errno(errp, errno, "failed to open /dev/vfio/vfio");
ret = -errno; ret = -errno;
@ -1479,7 +1479,7 @@ VFIOGroup *vfio_get_group(int groupid, AddressSpace *as, Error **errp)
group = g_malloc0(sizeof(*group)); group = g_malloc0(sizeof(*group));
snprintf(path, sizeof(path), "/dev/vfio/%d", groupid); snprintf(path, sizeof(path), "/dev/vfio/%d", groupid);
group->fd = qemu_open(path, O_RDWR); group->fd = qemu_open_old(path, O_RDWR);
if (group->fd < 0) { if (group->fd < 0) {
error_setg_errno(errp, errno, "failed to open %s", path); error_setg_errno(errp, errno, "failed to open %s", path);
goto free_group_exit; goto free_group_exit;

2
include/qemu/osdep.h
View File

@ -497,7 +497,7 @@ int qemu_madvise(void *addr, size_t len, int advice);
int qemu_mprotect_rwx(void *addr, size_t size); int qemu_mprotect_rwx(void *addr, size_t size);
int qemu_mprotect_none(void *addr, size_t size); int qemu_mprotect_none(void *addr, size_t size);
int qemu_open(const char *name, int flags, ...); int qemu_open_old(const char *name, int flags, ...);
int qemu_close(int fd); int qemu_close(int fd);
int qemu_unlink(const char *name); int qemu_unlink(const char *name);
#ifndef _WIN32 #ifndef _WIN32

2
io/channel-file.c
View File

@ -51,7 +51,7 @@ qio_channel_file_new_path(const char *path,
ioc = QIO_CHANNEL_FILE(object_new(TYPE_QIO_CHANNEL_FILE)); ioc = QIO_CHANNEL_FILE(object_new(TYPE_QIO_CHANNEL_FILE));
ioc->fd = qemu_open(path, flags, mode); ioc->fd = qemu_open_old(path, flags, mode);
if (ioc->fd < 0) { if (ioc->fd < 0) {
object_unref(OBJECT(ioc)); object_unref(OBJECT(ioc));
error_setg_errno(errp, errno, error_setg_errno(errp, errno,

2
net/vhost-vdpa.c
View File

@ -184,7 +184,7 @@ static int net_vhost_vdpa_init(NetClientState *peer, const char *device,
snprintf(nc->info_str, sizeof(nc->info_str), TYPE_VHOST_VDPA); snprintf(nc->info_str, sizeof(nc->info_str), TYPE_VHOST_VDPA);
nc->queue_index = 0; nc->queue_index = 0;
s = DO_UPCAST(VhostVDPAState, nc, nc); s = DO_UPCAST(VhostVDPAState, nc, nc);
vdpa_device_fd = qemu_open(vhostdev, O_RDWR); vdpa_device_fd = qemu_open_old(vhostdev, O_RDWR);
if (vdpa_device_fd == -1) { if (vdpa_device_fd == -1) {
return -errno; return -errno;
} }

2
os-posix.c
View File

@ -297,7 +297,7 @@ void os_setup_post(void)
error_report("not able to chdir to /: %s", strerror(errno)); error_report("not able to chdir to /: %s", strerror(errno));
exit(1); exit(1);
} }
TFR(fd = qemu_open("/dev/null", O_RDWR)); TFR(fd = qemu_open_old("/dev/null", O_RDWR));
if (fd == -1) { if (fd == -1) {
exit(1); exit(1);
} }

4
qga/channel-posix.c
View File

@ -127,7 +127,7 @@ static gboolean ga_channel_open(GAChannel *c, const gchar *path,
switch (c->method) { switch (c->method) {
case GA_CHANNEL_VIRTIO_SERIAL: { case GA_CHANNEL_VIRTIO_SERIAL: {
assert(fd < 0); assert(fd < 0);
fd = qemu_open(path, O_RDWR | O_NONBLOCK fd = qemu_open_old(path, O_RDWR | O_NONBLOCK
#ifndef CONFIG_SOLARIS #ifndef CONFIG_SOLARIS
| O_ASYNC | O_ASYNC
#endif #endif
@ -157,7 +157,7 @@ static gboolean ga_channel_open(GAChannel *c, const gchar *path,
struct termios tio; struct termios tio;
assert(fd < 0); assert(fd < 0);
fd = qemu_open(path, O_RDWR | O_NOCTTY | O_NONBLOCK); fd = qemu_open_old(path, O_RDWR | O_NOCTTY | O_NONBLOCK);
if (fd == -1) { if (fd == -1) {
g_critical("error opening channel: %s", strerror(errno)); g_critical("error opening channel: %s", strerror(errno));
return false; return false;

6
qga/commands-posix.c
View File

@ -1365,7 +1365,7 @@ int64_t qmp_guest_fsfreeze_freeze_list(bool has_mountpoints,
} }
} }
fd = qemu_open(mount->dirname, O_RDONLY); fd = qemu_open_old(mount->dirname, O_RDONLY);
if (fd == -1) { if (fd == -1) {
error_setg_errno(errp, errno, "failed to open %s", mount->dirname); error_setg_errno(errp, errno, "failed to open %s", mount->dirname);
goto error; goto error;
@ -1432,7 +1432,7 @@ int64_t qmp_guest_fsfreeze_thaw(Error **errp)
QTAILQ_FOREACH(mount, &mounts, next) { QTAILQ_FOREACH(mount, &mounts, next) {
logged = false; logged = false;
fd = qemu_open(mount->dirname, O_RDONLY); fd = qemu_open_old(mount->dirname, O_RDONLY);
if (fd == -1) { if (fd == -1) {
continue; continue;
} }
@ -1522,7 +1522,7 @@ qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp)
list->next = response->paths; list->next = response->paths;
response->paths = list; response->paths = list;
fd = qemu_open(mount->dirname, O_RDONLY); fd = qemu_open_old(mount->dirname, O_RDONLY);
if (fd == -1) { if (fd == -1) {
result->error = g_strdup_printf("failed to open: %s", result->error = g_strdup_printf("failed to open: %s",
strerror(errno)); strerror(errno));

2
target/arm/kvm.c
View File

@ -71,7 +71,7 @@ bool kvm_arm_create_scratch_host_vcpu(const uint32_t *cpus_to_try,
{ {
int ret = 0, kvmfd = -1, vmfd = -1, cpufd = -1; int ret = 0, kvmfd = -1, vmfd = -1, cpufd = -1;
kvmfd = qemu_open("/dev/kvm", O_RDWR); kvmfd = qemu_open_old("/dev/kvm", O_RDWR);
if (kvmfd < 0) { if (kvmfd < 0) {
goto err; goto err;
} }

2
ui/console.c
View File

@ -373,7 +373,7 @@ void qmp_screendump(const char *filename, bool has_device, const char *device,
return; return;
} }
fd = qemu_open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666); fd = qemu_open_old(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
if (fd == -1) { if (fd == -1) {
error_setg(errp, "failed to open file '%s': %s", filename, error_setg(errp, "failed to open file '%s': %s", filename,
strerror(errno)); strerror(errno));

2
util/osdep.c
View File

@ -296,7 +296,7 @@ static int qemu_open_cloexec(const char *name, int flags, mode_t mode)
/* /*
* Opens a file with FD_CLOEXEC set * Opens a file with FD_CLOEXEC set
*/ */
int qemu_open(const char *name, int flags, ...) int qemu_open_old(const char *name, int flags, ...)
{ {
int ret; int ret;
int mode = 0; int mode = 0;

2
util/oslib-posix.c
View File

@ -125,7 +125,7 @@ bool qemu_write_pidfile(const char *path, Error **errp)
.l_len = 0, .l_len = 0,
}; };
fd = qemu_open(path, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR); fd = qemu_open_old(path, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
if (fd == -1) { if (fd == -1) {
error_setg_errno(errp, errno, "Cannot open pid file"); error_setg_errno(errp, errno, "Cannot open pid file");
return false; return false;