On Sun, Sep 15, 2024 at 08:34:43PM +0100, Al Viro wrote:
> FWIW, I toyed with the idea of having reservations kept per-thread;
> it is possible and it simplifies some things, but I hadn't been able to
> find a way to do that without buggering syscall latency for open() et.al.
Hmm... How about the following:
* add an equivalent of array of pairs (fd, file) to task_struct;
representation could be e.g. (a _VERY_ preliminary variant)
unsigned fd_count;
int fds[2];
struct file *fp[2];
void *spillover;
with 'spillover' being a separately allocated array of pairs to deal with
the moments when we have more than 2 simultaneously reserved descriptors.
Initially NULL, allocated the first time we need more than 2. Always empty
outside of syscall.
* inline primitives:
count_reserved_fds()
reserved_descriptor(index)
reserved_file(index)
* int reserve_fd(flags)
returns -E... or index.
slot = current->fd_count
if (unlikely(slot == 2) && !current->spillover) {
allocate spillover
if failed
return -ENOMEM
set current->spillover
}
if slot is maximal allowed (2 + how much fits into allocated part?)
return -E<something>
fd = get_unused_fd_flags(flags);
if (unlikely(fd < 0))
return fd;
if (likely(slot < 2)) {
current->fds[slot] = fd;
current->fp[slot] = NULL;
} else {
store (fd, NULL) into element #(slot - 2) of current->spillover
}
current->fd_count = slot + 1;
* void install_file(index, file)
if (likely(slot < 2))
current->fp[slot] = file;
else
store file to element #(slot - 2) of current->spillover
* void __commit_reservations(unsigned count, bool failed)
// count == current->fd_count
while (count--) {
fd = reserved_descriptor(count);
file = reserved_file(count);
if (!file)
put_unused_fd(fd);
else if (!failed)
fd_install(fd, file);
else {
put_unused_fd(fd);
fput(file);
}
}
current->fd_count = 0;
* static inline void commit_fd_reservations(bool failed)
called in syscall glue, right after the syscall returns
unsigned slots = current->fd_count;
if (unlikely(slots))
__commit_reservations(slots, failed);
Then we can (in addition to the current use of get_unused_fd_flags() et.al. -
that still works) do e.g. things like
for (i = 0; i < 69; i++) {
index = reserve_fd(FD_CLOEXEC);
if (unlikely(index < 0))
return index;
file = some_driver_shite(some_shite, i);
if (IS_ERR(file))
return PTR_ERR(file);
install_file(index, file); // consumed file
ioctl_result.some_array[i] = reserved_descriptor(index);
....
}
...
if (copy_to_user(arg, &ioctl_result, sizeof(ioctl_result))
return -EFAULT;
...
return 0;
and have it DTRT on all failures, no matter how many files we have added,
etc. - on syscall return we will either commit all reservations
(on success) or release all reserved descriptors and drop all files we
had planned to put into descriptor table. Getting that right manually
is doable (drm has some examples), but it's _not_ pleasant.
The win here is in simpler cleanup code. And it can coexist with the
current API just fine. The PITA is in the need to add the call
of commit_fd_reservations() in syscall exit glue and have that done
on all architectures ;-/
FWIW, I suspect that it won't be slower than the current API, even
if used on hot paths. pipe(2) would be an interesting testcase
for that - converting it is easy, and there's a plenty of loads
where latency of pipe(2) would be visible.
Comments?
