[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: [Qemu-devel] [PATCH v8 16/16] block/io_uring: adds fd registration
From: |
Stefan Hajnoczi |
Subject: |
Re: [Qemu-devel] [PATCH v8 16/16] block/io_uring: adds fd registration |
Date: |
Wed, 31 Jul 2019 11:26:34 +0100 |
User-agent: |
Mutt/1.12.0 (2019-05-25) |
On Tue, Jul 30, 2019 at 11:04:41PM +0530, Aarushi Mehta wrote:
I'm concerned about file descriptor leaks. fd_array[] keeps file
descriptors basically forever, even after the file is no longer in use
by the rest of QEMU. There needs to be a call to unregister whenever a
file is closed elsewhere in QEMU. For benchmarking and experimentation
the current code is okay, but for production usage the leak must be
prevented.
> +/**
> + * luring_fd_register:
> + *
> + * Register and unregisters file descriptors, see luring_fd_lookup
> + */
> +static int luring_fd_register(struct io_uring *ring, LuringFd *fd_reg, int
> fd)
> +{
> + int ret, nr;
> + GHashTable *lookup = fd_reg->fd_lookup;
> + nr = g_hash_table_size(lookup);
> +
> + /* Unregister */
> + if (!fd) {
> + ret = io_uring_unregister_files(ring);
> + g_hash_table_remove_all(lookup);
Is it correct to clear the hash table be cleared if there was an error?
> + return ret;
> + }
Please make unregistering all files a separate function. It's not
necessary to overload this function since this is a completely separate
operation.
> +
> + /* If adding new, API requires older registrations to be removed */
> + if (nr) {
> + io_uring_unregister_files(ring);
> + }
> +
> + fd_reg->fd_array = g_realloc_n(fd_reg->fd_array, nr + 1, sizeof(int));
> + fd_reg->fd_array[nr] = fd;
> + fd_reg->fd_index = g_realloc_n(fd_reg->fd_index, nr + 1, sizeof(int));
> + fd_reg->fd_index[nr] = nr;
> +
> + g_hash_table_insert(lookup, &fd_reg->fd_array[nr],
> &fd_reg->fd_index[nr]);
fd_index[] is not necessary, you can cast nr to a gpointer instead to
store the data directly inside GHashTable:
g_hash_table_insert(lookup, &fd_reg->fd_array[nr],
GINT_TO_POINTER(nr));
The hash table accesses can be made slightly more efficient by avoiding
the pointer dereference for keys as well:
g_hash_table_insert(lookup, GINT_TO_POINTER(fd),
GINT_TO_POINTER(nr));
In this case fd_array[] is only used for the io_uring_register_files()
call and nothing else. Remember to switch to g_direct_equal() and
g_direct_hash() in g_hash_table_new_full() if you make the key a direct
gpointer.
> + trace_luring_fd_register(fd, nr);
> + return io_uring_register_files(ring, fd_reg->fd_array, nr + 1);
> +}
> +
> +/**
> + * luring_fd_lookup:
> + *
> + * Used to lookup fd index in registered array at submission time
> + * If the lookup table has not been created or the fd is not in the table,
> + * the fd is registered.
> + *
> + * If registration errors, the hash is cleared and the fd used directly
> + *
> + * Unregistering is done at luring_detach_aio_context
> + */
> +static int luring_fd_lookup(LuringState *s, int fd)
> +{
> + int *index, ret;
> + if (!s->fd_reg.fd_lookup) {
> + s->fd_reg.fd_lookup = g_hash_table_new_full(g_int_hash, g_int_equal,
> + g_free, g_free);
fd_array[] and fd_index[] are allocated in single allocations for the
entire array, therefore g_free(key) and g_free(value) on individual
elements is undefined behavior and could crash the program. There
should be no destroy function for them.
Missing g_hash_table_unref() to free fd_lookup.
> + luring_fd_register(&s->ring, &s->fd_reg, fd);
> + }
> + index = g_hash_table_lookup(s->fd_reg.fd_lookup, &fd);
> +
> + if (!index) {
> + ret = luring_fd_register(&s->ring, &s->fd_reg, fd);
> + if (ret < 0) {
> + g_hash_table_remove_all(s->fd_reg.fd_lookup);
Why is the hash table cleared and why are fd_array[]/fd_index[] left
behind?
> + return ret;
> + }
> + index = g_hash_table_lookup(s->fd_reg.fd_lookup, &fd);
> + }
> + return *index;
> +}
What are the concerns about in-flight requests and how are they
addressed? For example, if a request is in-flight and another request
wants to add a new fd then io_uring_unregister_files() and
io_uring_register_files() are called while a request is still in-flight.
How does the io_uring kernel code handle this?
signature.asc
Description: PGP signature
- [Qemu-devel] [PATCH v8 07/16] blockdev: adds bdrv_parse_aio to use io_uring, (continued)
- [Qemu-devel] [PATCH v8 07/16] blockdev: adds bdrv_parse_aio to use io_uring, Aarushi Mehta, 2019/07/30
- [Qemu-devel] [PATCH v8 08/16] block/file-posix.c: extend to use io_uring, Aarushi Mehta, 2019/07/30
- [Qemu-devel] [PATCH v8 09/16] block: add trace events for io_uring, Aarushi Mehta, 2019/07/30
- [Qemu-devel] [PATCH v8 10/16] block/io_uring: adds userspace completion polling, Aarushi Mehta, 2019/07/30
- [Qemu-devel] [PATCH v8 11/16] qemu-io: adds option to use aio engine, Aarushi Mehta, 2019/07/30
- [Qemu-devel] [PATCH v8 12/16] qemu-img: adds option to use aio engine for benchmarking, Aarushi Mehta, 2019/07/30
- [Qemu-devel] [PATCH v8 13/16] qemu-nbd: adds option for aio engines, Aarushi Mehta, 2019/07/30
- [Qemu-devel] [PATCH v8 14/16] tests/qemu-iotests: enable testing with aio options, Aarushi Mehta, 2019/07/30
- [Qemu-devel] [PATCH v8 15/16] tests/qemu-iotests: use AIOMODE with various tests, Aarushi Mehta, 2019/07/30
- [Qemu-devel] [PATCH v8 16/16] block/io_uring: adds fd registration, Aarushi Mehta, 2019/07/30
- Re: [Qemu-devel] [PATCH v8 16/16] block/io_uring: adds fd registration,
Stefan Hajnoczi <=