Fix splice from random/urandom
PATCH 1/2 random: convert to using fops->read_iter()
In reply to Jens AxboeThis is a pre-requisite to writing up splice() again for the random and urandom drivers.
--- drivers/char/random.c | 37 +++++++++++++++++++------------------ 1 file changed, 19 insertions(+), 18 deletions(-)
drivers/char/random.c +19 -18
@@ -528,11 +528,12 @@ void get_random_bytes(void *buf, size_t nbytes) }EXPORT_SYMBOL (get_random_bytes); -static ssize_t get_random_bytes_user (void __user *buf,size_t nbytes) +static ssize_t get_random_bytes_user (struct iov_iter *to) { -size_t len, left, ret =0 ; +size_t len, ret =0 ;u32 chacha_state[CHACHA_STATE_WORDS ];u8 output[CHACHA_BLOCK_SIZE ]; +size_t nbytes =iov_iter_count (to);if (!nbytes)return 0 ;
@@ -549,7 +550,7 @@ static ssize_t get_random_bytes_user(void __user *buf, size_t nbytes)* the user directly. */ if (nbytes <=CHACHA_KEY_SIZE ) { - ret = nbytes -copy_to_user (buf, &chacha_state[4 ], nbytes); + ret =copy_to_iter (&chacha_state[4 ], nbytes, to); goto out_zero_chacha; }
@@ -559,13 +560,10 @@ static ssize_t get_random_bytes_user(void __user *buf, size_t nbytes) ++chacha_state[13 ]; len =min_t (size_t, nbytes,CHACHA_BLOCK_SIZE ); - left =copy_to_user (buf, output, len); -if (left) { - ret += len - left; + len =copy_to_iter (output, len, to); +if (!len)break ; - } - buf += len; ret += len; nbytes -= len;if (!nbytes)
@@ -1466,6 +1464,9 @@ static void try_to_generate_entropy(void) SYSCALL_DEFINE3(getrandom, char __user *, buf, size_t, count, unsigned int, flags) { +struct iovec iov = { .iov_base = buf }; +struct iov_iter iter; +if (flags & ~(GRND_NONBLOCK |GRND_RANDOM |GRND_INSECURE ))return -EINVAL ;
@@ -1488,7 +1489,9 @@ SYSCALL_DEFINE3(getrandom, char __user *, buf, size_t, count, unsigned int,if (unlikely (ret))return ret; } -return get_random_bytes_user (buf, count); + iov.iov_len = count; +iov_iter_init (&iter,READ , &iov,1 , count); +return get_random_bytes_user (&iter); }static __poll_t random_poll (struct file *file,poll_table *wait)
@@ -1540,8 +1543,7 @@ static ssize_t random_write(struct file *file, const char __user *buffer,return (ssize_t )count; } -static ssize_t urandom_read (struct file *file,char __user *buf,size_t nbytes, -loff_t *ppos) +static ssize_t urandom_read_iter (struct kiocb *kiocb,struct iov_iter *to) {static int maxwarn =10 ;
@@ -1556,21 +1558,20 @@ static ssize_t urandom_read(struct file *file, char __user *buf, size_t nbytes, maxwarn--;if (__ratelimit (&urandom_warning))pr_notice ("%s: uninitialized urandom read (%zd bytes read)\n" , - current->comm, nbytes); + current->comm,iov_iter_count (to)); } -return get_random_bytes_user (buf, nbytes); +return get_random_bytes_user (to); } -static ssize_t random_read (struct file *file,char __user *buf,size_t nbytes, -loff_t *ppos) +static ssize_t random_read_iter (struct kiocb *kiocb,struct iov_iter *to) {int ret; ret =wait_for_random_bytes ();if (ret !=0 )return ret; -return get_random_bytes_user (buf, nbytes); +return get_random_bytes_user (to); }static long random_ioctl (struct file *f,unsigned int cmd,unsigned long arg)
@@ -1639,7 +1640,7 @@ static int random_fasync(int fd, struct file *filp, int on) }const struct file_operations random_fops = { - .read = random_read, + .read_iter = random_read_iter, .write = random_write, .poll = random_poll, .unlocked_ioctl = random_ioctl,
@@ -1649,7 +1650,7 @@ const struct file_operations random_fops = { };const struct file_operations urandom_fops = { - .read = urandom_read, + .read_iter = urandom_read_iter, .write = random_write, .unlocked_ioctl = random_ioctl, .compat_ioctl = compat_ptr_ioctl,
Signature · 1 line
2.35.1
cover Fix splice from random/urandom
Hi,
We recently had a failure on a kernel upgrade because splice no longer works on random/urandom. This is due to:
6e2c7421f02 ("fs: don't allow splice read/write without explicit ops")
which already has more than two handful of Fixes registered to its name...
Wire up read_iter handling and then hook up splice_read for both of them as well.
Signature · 1 line
Jens Axboe
PATCH 2/2 random: wire up fops->splice_read_iter()
Now that random/urandom is using read_iter, we can wire it up to using the generic splice read handler.
--- drivers/char/random.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/char/random.c +2 -0
@@ -1647,6 +1647,7 @@ const struct file_operations random_fops = { .compat_ioctl = compat_ptr_ioctl, .fasync = random_fasync, .llseek = noop_llseek, + .splice_read = generic_file_splice_read, };const struct file_operations urandom_fops = {
@@ -1656,6 +1657,7 @@ const struct file_operations urandom_fops = { .compat_ioctl = compat_ptr_ioctl, .fasync = random_fasync, .llseek = noop_llseek, + .splice_read = generic_file_splice_read, };
Signature · 1 line
2.35.1
Quoted 9 lines · Jens Axboe
Hi,
We recently had a failure on a kernel upgrade because splice no longer works on random/urandom. This is due to:
6e2c7421f02("fs: don't allow splice read/write without explicit ops")which already has more than two handful of Fixes registered to its name...
Yes. It was a hard break to get rid of set_fs and it's abuse.
Quoted 6 lines · Christoph Hellwig
Quoted 5 lines · Jens Axboe
Hi,
We recently had a failure on a kernel upgrade because splice no longer works on random/urandom. This is due to:
Quoted 6 lines
Quoted 4 lines
6e2c7421f02("fs: don't allow splice read/write without explicit ops")which already has more than two handful of Fixes registered to its name...
Yes. It was a hard break to get rid of
set_fsand it's abuse.
I'm a bit torn on this one, because I _really_ want us to get rid of read/write and make everything use read_iter/write_iter. Firstly because it's really stupid to have two interfaces, and secondly because even basic things like "can we block here" doesn't work in the older interface without fiddling with file flags which is a non-starter for certain things.
However, it's also problematic that we end up breaking real applications because of this change. Arguably we should've converted existing read/write first and avoid this grey zone we are in now (best solution), or provided splice read/write helpers that work with the non-iter based read/write handlers.
Signature · 1 line
Jens Axboe
Jason A. Donenfeld
maintainerHi Jens,
Quoted 6 lines · Jens Axboe
Hi,
We recently had a failure on a kernel upgrade because splice no longer works on random/urandom. This is due to:
6e2c7421f02("fs: don't allow splice read/write without explicit ops")
Thanks for this. I'd noticed this a few months ago and assumed it has just always been that way, and hadn't gotten to looking at what was up.
I'll take a look at these patches in detail when I'm home in a few hours, but one thing maybe you can answer more easily than my digging is:
There's a lot of attention in random.c devoted to not leaving any output around on the stack or in stray buffers. The explicit use of copy_to_user() makes it clear that the output isn't being copied anywhere other than what's the user's responsibility to cleanup. I'm wondering if the switch to copy_to_iter() introduces any buffering or gotchas that you might be aware of.
Also you may need to rebase this on the random.git tree at
https://git.kernel.org/pub/scm/linux/kernel/git/crng/random.git
Regards,
Jason
Quoted 8 lines · Jason A. Donenfeld
Hi Jens,
Quoted 5 lines · Jens Axboe
Hi,
We recently had a failure on a kernel upgrade because splice no longer works on random/urandom. This is due to:
Quoted 8 lines
Quoted 1 line
6e2c7421f02("fs: don't allow splice read/write without explicit ops")Thanks for this. I'd noticed this a few months ago and assumed it has just always been that way, and hadn't gotten to looking at what was up.
I'll take a look at these patches in detail when I'm home in a few hours, but one thing maybe you can answer more easily than my digging is:
Sounds good, thanks!
Quoted 6 lines
There's a lot of attention in
random.cdevoted to not leaving any output around on the stack or in stray buffers. The explicit use ofcopy_to_user()makes it clear that the output isn't being copied anywhere other than what's the user's responsibility to cleanup. I'm wondering if the switch tocopy_to_iter()introduces any buffering or gotchas that you might be aware of.
No, it's just a wrapper around copying to the user memory pointed to by the iov_iter. No extra buffering or anything like that. So I think it should be fine in that respect, and it actually cleans up the code a bit imho since the copy_to_iter() since the return value of "bytes copied" is easier to work with than the "bytes not copied".
Quoted 2 lines
Also you may need to rebase this on the random.git tree at
https://git.kernel.org/pub/scm/linux/kernel/git/crng/random.git
OK, I will rebase it on that branch, not a problem.
Signature · 1 line
Jens Axboe
Quoted 33 lines · Jens Axboe
Quoted 8 lines · Jason A. Donenfeld
Hi Jens,
Quoted 5 lines · Jens Axboe
Hi,
We recently had a failure on a kernel upgrade because splice no longer works on random/urandom. This is due to:
Quoted 8 lines
Quoted 1 line
6e2c7421f02("fs: don't allow splice read/write without explicit ops")Thanks for this. I'd noticed this a few months ago and assumed it has just always been that way, and hadn't gotten to looking at what was up.
I'll take a look at these patches in detail when I'm home in a few hours, but one thing maybe you can answer more easily than my digging is:
Sounds good, thanks!
Quoted 6 lines
There's a lot of attention in
random.cdevoted to not leaving any output around on the stack or in stray buffers. The explicit use ofcopy_to_user()makes it clear that the output isn't being copied anywhere other than what's the user's responsibility to cleanup. I'm wondering if the switch tocopy_to_iter()introduces any buffering or gotchas that you might be aware of.No, it's just a wrapper around copying to the user memory pointed to by the
iov_iter. No extra buffering or anything like that. So I think it should be fine in that respect, and it actually cleans up the code a bit imho since thecopy_to_iter()since the return value of "bytes copied" is easier to work with than the "bytes not copied".
Quoted 4 lines
Quoted 2 lines
Also you may need to rebase this on the random.git tree at
https://git.kernel.org/pub/scm/linux/kernel/git/crng/random.gitOK, I will rebase it on that branch, not a problem.
Rebased patches attached, you can also find them here:
https://git.kernel.dk/cgit/linux-block/log/?h=random-splice
Did some basic sanity checking (and with splice too), and seems fine rebased as well.
Signature · 1 line
Jens Axboe
From fd673dac9f7c905d95cbe334cc7519fb36ede678 Mon Sep 17 00:00:00 2001
From: Jens Axboe <[email protected]>
Date: Thu, 19 May 2022 13:26:55 -0600
Subject: [PATCH 2/2] random: wire up fops->splice_read_iter()
Now that random/urandom is using read_iter, we can wire it up to using the generic splice read handler.
--- drivers/char/random.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/char/random.c +2 -0
@@ -1415,6 +1415,7 @@ const struct file_operations random_fops = { .compat_ioctl = compat_ptr_ioctl, .fasync = random_fasync, .llseek = noop_llseek, + .splice_read = generic_file_splice_read, };const struct file_operations urandom_fops = {
@@ -1424,6 +1425,7 @@ const struct file_operations urandom_fops = { .compat_ioctl = compat_ptr_ioctl, .fasync = random_fasync, .llseek = noop_llseek, + .splice_read = generic_file_splice_read, };
Signature · 1 line
2.35.1
From c65f0221b72173c19398884f3f49ef775e2c668f Mon Sep 17 00:00:00 2001
From: Jens Axboe <[email protected]>
Date: Thu, 19 May 2022 14:55:37 -0600
Subject: [PATCH 1/2] random: convert to using fops->read_iter()
This is a pre-requisite to writing up splice() again for the random and urandom drivers.
--- drivers/char/random.c | 39 +++++++++++++++++++-------------------- 1 file changed, 19 insertions(+), 20 deletions(-)
drivers/char/random.c +19 -20
@@ -397,11 +397,12 @@ void get_random_bytes(void *buf, size_t len) }EXPORT_SYMBOL (get_random_bytes); -static ssize_t get_random_bytes_user (void __user *ubuf,size_t len) +static ssize_t get_random_bytes_user (struct iov_iter *to) { -size_t block_len, left, ret =0 ; +size_t block_len, ret =0 ;u32 chacha_state[CHACHA_STATE_WORDS ];u8 output[CHACHA_BLOCK_SIZE ]; +size_t len =iov_iter_count (to);if (!len)return 0 ;
@@ -418,7 +419,7 @@ static ssize_t get_random_bytes_user(void __user *ubuf, size_t len)* the user directly. */ if (len <=CHACHA_KEY_SIZE ) { - ret = len -copy_to_user (ubuf, &chacha_state[4 ], len); + ret =copy_to_iter (&chacha_state[4 ], len, to); goto out_zero_chacha; }
@@ -428,17 +429,12 @@ static ssize_t get_random_bytes_user(void __user *ubuf, size_t len) ++chacha_state[13 ]; block_len =min_t (size_t, len,CHACHA_BLOCK_SIZE ); - left =copy_to_user (ubuf, output, block_len); -if (left) { - ret += block_len - left; + block_len =copy_to_iter (output, block_len, to); +if (!block_len)break ; - } - ubuf += block_len; ret += block_len; len -= block_len; -if (!len) -break ;BUILD_BUG_ON (PAGE_SIZE %CHACHA_BLOCK_SIZE !=0 );if (ret %PAGE_SIZE ==0 ) {
@@ -1248,6 +1244,9 @@ static void __cold try_to_generate_entropy(void) SYSCALL_DEFINE3(getrandom, char __user *, ubuf, size_t, len, unsigned int, flags) { +struct iovec iov = { .iov_base = ubuf }; +struct iov_iter iter; +if (flags & ~(GRND_NONBLOCK |GRND_RANDOM |GRND_INSECURE ))return -EINVAL ;
@@ -1270,7 +1269,9 @@ SYSCALL_DEFINE3(getrandom, char __user *, ubuf, size_t, len, unsigned int, flagsif (unlikely (ret))return ret; } -return get_random_bytes_user (ubuf, len); + iov.iov_len = len; +iov_iter_init (&iter,READ , &iov,1 , len); +return get_random_bytes_user (&iter); }static __poll_t random_poll (struct file *file,poll_table *wait)
@@ -1314,8 +1315,7 @@ static ssize_t random_write(struct file *file, const char __user *ubuf,return (ssize_t )len; } -static ssize_t urandom_read (struct file *file,char __user *ubuf, -size_t len,loff_t *ppos) +static ssize_t urandom_read_iter (struct kiocb *kiocb,struct iov_iter *to) {static int maxwarn =10 ;
@@ -1332,22 +1332,21 @@ static ssize_t urandom_read(struct file *file, char __user *ubuf,else if (ratelimit_disable ||__ratelimit (&urandom_warning)) { --maxwarn;pr_notice ("%s: uninitialized urandom read (%zd bytes read)\n" , - current->comm, len); + current->comm,iov_iter_count (to)); } } -return get_random_bytes_user (ubuf, len); +return get_random_bytes_user (to); } -static ssize_t random_read (struct file *file,char __user *ubuf, -size_t len,loff_t *ppos) +static ssize_t random_read_iter (struct kiocb *kiocb,struct iov_iter *to) {int ret; ret =wait_for_random_bytes ();if (ret !=0 )return ret; -return get_random_bytes_user (ubuf, len); +return get_random_bytes_user (to); }static long random_ioctl (struct file *f,unsigned int cmd,unsigned long arg)
@@ -1409,7 +1408,7 @@ static int random_fasync(int fd, struct file *filp, int on) }const struct file_operations random_fops = { - .read = random_read, + .read_iter = random_read_iter, .write = random_write, .poll = random_poll, .unlocked_ioctl = random_ioctl,
@@ -1419,7 +1418,7 @@ const struct file_operations random_fops = { };const struct file_operations urandom_fops = { - .read = urandom_read, + .read_iter = urandom_read_iter, .write = random_write, .unlocked_ioctl = random_ioctl, .compat_ioctl = compat_ptr_ioctl,
Signature · 1 line
2.35.1
Jason A. Donenfeld
maintainerRe: [PATCH 1/2] random: convert to using fops->read_iter()
In reply to Jens AxboeHi Jens,
Quoted 17 lines · Jens Axboe
(quoted diff) +2
-5for (;;) { chacha20_block(chacha_state, output); if (unlikely(chacha_state[12] == 0)) ++chacha_state[13]; block_len = min_t(size_t, len, CHACHA_BLOCK_SIZE); - left = copy_to_user(ubuf, output, block_len); - if (left) { - ret += block_len - left; + block_len = copy_to_iter(output, block_len, to); + if (!block_len) break; - } - ubuf += block_len; ret += block_len; len -= block_len;
Review
Quoted 10 lines
(quoted diff) +0
-2- if (!len) - break; BUILD_BUG_ON(PAGE_SIZE % CHACHA_BLOCK_SIZE != 0); if (ret % PAGE_SIZE == 0) { if (signal_pending(current)) break; cond_resched(); } }
This isn't quite the same, is it? Before, it would immediately break out of the loop on any short copy. Now, it will only break out on a zero copy, which means it's possible that ret % PAGE_SIZE == 0, and there'll be an unnecessary cond_resched() before copy_to_iter() runs again and then breaks.
Jason
Jason A. Donenfeld
maintainerHi Jens,
Quoted 7 lines · Jens Axboe
Quoted 6 lines
There's a lot of attention in
random.cdevoted to not leaving any output around on the stack or in stray buffers. The explicit use ofcopy_to_user()makes it clear that the output isn't being copied anywhere other than what's the user's responsibility to cleanup. I'm wondering if the switch tocopy_to_iter()introduces any buffering or gotchas that you might be aware of.
Quoted 5 lines
No, it's just a wrapper around copying to the user memory pointed to by the
iov_iter. No extra buffering or anything like that. So I think it should be fine in that respect, and it actually cleans up the code a bit imho since thecopy_to_iter()since the return value of "bytes copied" is easier to work with than the "bytes not copied".
Alright, that's good to hear. So even for kernel->kernel writes, the argument is that what ever buffers are used in the process are the same ones that the user would be hitting anyway by calling write() on the destination if this roundtripped through userspace, so nothing changes?
Jason
Jason A. Donenfeld
maintainerHi Jens,
Quoted 6 lines · Jens Axboe
Rebased patches attached, you can also find them here:
https://git.kernel.dk/cgit/linux-block/log/?h=random-splice
Did some basic sanity checking (and with splice too), and seems fine rebased as well.
Thanks. I left one comment about patch 1 in that subthread. The general idea of this patchset seems fine, but: what about write_iter? Can't we convert both of them? 1/3 - read_iter, 2/3 - write_iter, 3/3 - add the generic splice helpers. I ask because it seems weird to keep around the old thing (which sounds like is being gradually removed?) alongside the new thing.
Jason
Quoted 16 lines · Jason A. Donenfeld
Hi Jens,
Quoted 7 lines · Jens Axboe
Quoted 6 lines
There's a lot of attention in
random.cdevoted to not leaving any output around on the stack or in stray buffers. The explicit use ofcopy_to_user()makes it clear that the output isn't being copied anywhere other than what's the user's responsibility to cleanup. I'm wondering if the switch tocopy_to_iter()introduces any buffering or gotchas that you might be aware of.Quoted 5 lines
No, it's just a wrapper around copying to the user memory pointed to by the
iov_iter. No extra buffering or anything like that. So I think it should be fine in that respect, and it actually cleans up the code a bit imho since thecopy_to_iter()since the return value of "bytes copied" is easier to work with than the "bytes not copied".
Quoted 4 lines
Alright, that's good to hear. So even for
kernel->kernelwrites, the argument is that what ever buffers are used in the process are the same ones that the user would be hitting anyway by callingwrite()on the destination if this roundtripped through userspace, so nothing changes?
The source and destination for the copies are exactly the same with the change as before, so no changes there. The non-user copy is a different helper.
Signature · 1 line
Jens Axboe
Jason A. Donenfeld
maintainerRe: [PATCH 1/2] random: convert to using fops->read_iter()
In reply to Jason A. DonenfeldQuoted 23 lines · Jason A. Donenfeld
Hi Jens,
Quoted 20 lines · Jens Axboe
(quoted diff) +2
-7for (;;) { chacha20_block(chacha_state, output); if (unlikely(chacha_state[12] == 0)) ++chacha_state[13]; block_len = min_t(size_t, len, CHACHA_BLOCK_SIZE); - left = copy_to_user(ubuf, output, block_len); - if (left) { - ret += block_len - left; + block_len = copy_to_iter(output, block_len, to); + if (!block_len) break; - } - ubuf += block_len; ret += block_len; len -= block_len; - if (!len) - break;
Quoted 13 lines
Review
Quoted 7 lines
(quoted diff) +0
-0BUILD_BUG_ON(PAGE_SIZE % CHACHA_BLOCK_SIZE != 0); if (ret % PAGE_SIZE == 0) { if (signal_pending(current)) break; cond_resched(); } }This isn't quite the same, is it? Before, it would immediately break out of the loop on any short copy. Now, it will only break out on a zero copy, which means it's possible that ret %
PAGE_SIZE== 0, and there'll be an unnecessarycond_resched()beforecopy_to_iter()runs again and then breaks.
Maybe something like the below would do the trick?
static ssize_t get_random_bytes_user(struct iov_iter *to)
{
size_t block_len, copied, ret = 0, len = iov_iter_count(to);
u32 chacha_state[CHACHA_STATE_WORDS];
u8 output[CHACHA_BLOCK_SIZE];
if (!len)
return 0;
/*
* Immediately overwrite the ChaCha key at index 4 with random
* bytes, in case userspace causes copy_to_user() below to sleep
* forever, so that we still retain forward secrecy in that case.
*/
crng_make_state(chacha_state, (u8 *)&chacha_state[4], CHACHA_KEY_SIZE);
/*
* However, if we're doing a read of len <= 32, we don't need to
* use chacha_state after, so we can simply return those bytes to
* the user directly.
*/
if (len <= CHACHA_KEY_SIZE) {
ret = copy_to_iter(&chacha_state[4], len, to);
goto out_zero_chacha;
}
for (;;) {
chacha20_block(chacha_state, output);
if (unlikely(chacha_state[12] == 0))
++chacha_state[13];
block_len = min_t(size_t, len, CHACHA_BLOCK_SIZE);
copied = copy_to_iter(output, block_len, to);
ret += copied;
if (block_len != copied)
break;
len -= copied;
BUILD_BUG_ON(PAGE_SIZE % CHACHA_BLOCK_SIZE != 0);
if (ret % PAGE_SIZE == 0) {
if (signal_pending(current))
break;
cond_resched();
}
}
memzero_explicit(output, sizeof(output));
out_zero_chacha:
memzero_explicit(chacha_state, sizeof(chacha_state));
return ret ? ret : -EFAULT;
}Re: [PATCH 1/2] random: convert to using fops->read_iter()
In reply to Jason A. DonenfeldQuoted 23 lines · Jason A. Donenfeld
Hi Jens,
Quoted 20 lines · Jens Axboe
(quoted diff) +2
-7for (;;) { chacha20_block(chacha_state, output); if (unlikely(chacha_state[12] == 0)) ++chacha_state[13]; block_len = min_t(size_t, len, CHACHA_BLOCK_SIZE); - left = copy_to_user(ubuf, output, block_len); - if (left) { - ret += block_len - left; + block_len = copy_to_iter(output, block_len, to); + if (!block_len) break; - } - ubuf += block_len; ret += block_len; len -= block_len; - if (!len) - break;
Quoted 13 lines
Review
Quoted 7 lines
(quoted diff) +0
-0BUILD_BUG_ON(PAGE_SIZE % CHACHA_BLOCK_SIZE != 0); if (ret % PAGE_SIZE == 0) { if (signal_pending(current)) break; cond_resched(); } }This isn't quite the same, is it? Before, it would immediately break out of the loop on any short copy. Now, it will only break out on a zero copy, which means it's possible that ret %
PAGE_SIZE== 0, and there'll be an unnecessarycond_resched()beforecopy_to_iter()runs again and then breaks.
True, we could just make that:
copied = copy_to_iter(output, block_len, to);
if (copied != block_len)
...
if that's important. Doesn't seem like it would, if you're passing in invalid memory ranges. Maybe that ret check makes it so that it is indeed important. I'll make the changes and send out a v2.
Signature · 1 line
Jens Axboe
Re: [PATCH 1/2] random: convert to using fops->read_iter()
In reply to Jason A. DonenfeldQuoted 69 lines · Jason A. Donenfeld
Quoted 23 lines · Jason A. Donenfeld
Hi Jens,
Quoted 20 lines · Jens Axboe
(quoted diff) +2
-7for (;;) { chacha20_block(chacha_state, output); if (unlikely(chacha_state[12] == 0)) ++chacha_state[13]; block_len = min_t(size_t, len, CHACHA_BLOCK_SIZE); - left = copy_to_user(ubuf, output, block_len); - if (left) { - ret += block_len - left; + block_len = copy_to_iter(output, block_len, to); + if (!block_len) break; - } - ubuf += block_len; ret += block_len; len -= block_len; - if (!len) - break;Quoted 13 lines
Review
Quoted 7 lines
(quoted diff) +0
-0BUILD_BUG_ON(PAGE_SIZE % CHACHA_BLOCK_SIZE != 0); if (ret % PAGE_SIZE == 0) { if (signal_pending(current)) break; cond_resched(); } }This isn't quite the same, is it? Before, it would immediately break out of the loop on any short copy. Now, it will only break out on a zero copy, which means it's possible that ret %
PAGE_SIZE== 0, and there'll be an unnecessarycond_resched()beforecopy_to_iter()runs again and then breaks.Maybe something like the below would do the trick?
static
ssize_tget_random_bytes_user(struct iov_iter *to){ size_t block_len, copied, ret = 0, len = iov_iter_count(to); u32 chacha_state[CHACHA_STATE_WORDS]; u8 output[CHACHA_BLOCK_SIZE]; if (!len) return 0; /* * Immediately overwrite the ChaCha key at index 4 with random * bytes, in case userspace causes copy_to_user() below to sleep * forever, so that we still retain forward secrecy in that case. */ crng_make_state(chacha_state, (u8 *)&chacha_state[4], CHACHA_KEY_SIZE); /* * However, if we're doing a read of len <= 32, we don't need to * use chacha_state after, so we can simply return those bytes to * the user directly. */ if (len <= CHACHA_KEY_SIZE) { ret = copy_to_iter(&chacha_state[4], len, to); goto out_zero_chacha; } for (;;) { chacha20_block(chacha_state, output); if (unlikely(chacha_state[12] == 0))
Quoted 8 lines
++chacha_state[13]; block_len = min_t(size_t, len, CHACHA_BLOCK_SIZE); copied = copy_to_iter(output, block_len, to); ret += copied; if (block_len != copied) break; len -= copied;
Yep, that looks good! Do you still want a v2?
Signature · 1 line
Jens Axboe
Jason A. Donenfeld
maintainerRe: [PATCH 1/2] random: convert to using fops->read_iter()
Quoted 73 lines · Jens Axboe
Quoted 71 lines · Jason A. Donenfeld
Quoted 31 lines · Jason A. Donenfeld
Hi Jens,
Quoted 17 lines · Jens Axboe
for (;;) { chacha20_block(chacha_state, output); if (unlikely(chacha_state[12] == 0)) ++chacha_state[13]; block_len = min_t(size_t, len, CHACHA_BLOCK_SIZE);(quoted diff) +2
-5- left = copy_to_user(ubuf, output, block_len); - if (left) { - ret += block_len - left; + block_len = copy_to_iter(output, block_len, to); + if (!block_len) break; - } - ubuf += block_len; ret += block_len; len -= block_len;Review
Quoted 10 lines
(quoted diff) +0
-2- if (!len) - break; BUILD_BUG_ON(PAGE_SIZE % CHACHA_BLOCK_SIZE != 0); if (ret % PAGE_SIZE == 0) { if (signal_pending(current)) break; cond_resched(); } }Quoted 5 lines
This isn't quite the same, is it? Before, it would immediately break out of the loop on any short copy. Now, it will only break out on a zero copy, which means it's possible that ret %
PAGE_SIZE== 0, and there'll be an unnecessarycond_resched()beforecopy_to_iter()runs again and then breaks.Maybe something like the below would do the trick?
static
ssize_tget_random_bytes_user(struct iov_iter *to){ size_t block_len, copied, ret = 0, len = iov_iter_count(to); u32 chacha_state[CHACHA_STATE_WORDS]; u8 output[CHACHA_BLOCK_SIZE]; if (!len) return 0; /* * Immediately overwrite the ChaCha key at index 4 with random * bytes, in case userspace causes copy_to_user() below to sleep * forever, so that we still retain forward secrecy in that case. */ crng_make_state(chacha_state, (u8 *)&chacha_state[4], CHACHA_KEY_SIZE); /* * However, if we're doing a read of len <= 32, we don't need to * use chacha_state after, so we can simply return those bytes to * the user directly. */ if (len <= CHACHA_KEY_SIZE) { ret = copy_to_iter(&chacha_state[4], len, to); goto out_zero_chacha; } for (;;) { chacha20_block(chacha_state, output); if (unlikely(chacha_state[12] == 0)) ++chacha_state[13];
Quoted 8 lines
Quoted 6 lines
block_len = min_t(size_t, len, CHACHA_BLOCK_SIZE); copied = copy_to_iter(output, block_len, to); ret += copied; if (block_len != copied) break; len -= copied;Yep, that looks good! Do you still want a v2?
Yes please, thanks.
Jason
Quoted 10 lines · Jason A. Donenfeld
Hi Jens,
Quoted 6 lines · Jens Axboe
Rebased patches attached, you can also find them here:
https://git.kernel.dk/cgit/linux-block/log/?h=random-splice
Did some basic sanity checking (and with splice too), and seems fine rebased as well.
Quoted 6 lines
Thanks. I left one comment about patch 1 in that subthread. The general idea of this patchset seems fine, but: what about
write_iter? Can't we convert both of them? 1/3 -read_iter, 2/3 -write_iter, 3/3 - add the generic splice helpers. I ask because it seems weird to keep around the old thing (which sounds like is being gradually removed?) alongside the new thing.
I can certainly do the write side too. To fix this regression, I just valued doing read_iter first and I'd hate to hold that up to do the write side too. I'll do the write side later today, but let's keep them separate.
In general, everyone using ->read and ->write should be converted so we can kill these handlers. Would be great if someone would take that on...
Signature · 1 line
Jens Axboe
Jason A. Donenfeld
maintainerHi Jens,
Quoted 3 lines · Jens Axboe
The source and destination for the copies are exactly the same with the change as before, so no changes there. The non-user copy is a different helper.
Oh, okay. Maybe a silly question but: should we wire up that helper too? (If I'm understanding your meaning right.) Seems like it'd be a good idea to just wire up all the things while we're at it.
Jason
Quoted 10 lines · Jason A. Donenfeld
Hi Jens,
Quoted 3 lines · Jens Axboe
The source and destination for the copies are exactly the same with the change as before, so no changes there. The non-user copy is a different helper.
Oh, okay. Maybe a silly question but: should we wire up that helper too? (If I'm understanding your meaning right.) Seems like it'd be a good idea to just wire up all the things while we're at it.
I'll leave that to you :-)
I'll do the write_iter though, just for completeness.
Signature · 1 line
Jens Axboe
Jason A. Donenfeld
maintainerHi Jens,
Quoted 4 lines · Jens Axboe
I can certainly do the write side too. To fix this regression, I just valued doing
read_iterfirst and I'd hate to hold that up to do the write side too. I'll do the write side later today, but let's keep them separate.
Excellent, thanks. I plan to queue these up all in a row.
Jason
Jason A. Donenfeld
maintainerHi Jens,
Quoted 1 line · Jens Axboe
I'll leave that to you :-)
Alright, I'll have a look. Which one do I want here? This series adds splice_read/splice_write. The new thing would be sendpage? Or copy_file_range? Or something else?
Jason
Quoted 9 lines · Jason A. Donenfeld
Hi Jens,
Quoted 4 lines · Jens Axboe
I can certainly do the write side too. To fix this regression, I just valued doing
read_iterfirst and I'd hate to hold that up to do the write side too. I'll do the write side later today, but let's keep them separate.Excellent, thanks. I plan to queue these up all in a row.
Built and tested v2, just sent it out. Note that it deviates from your proposal a bit since with that we lost the
if (!len)
break;
check, which is kind of important if you ever want to be done :-)
I'll do the write_iter side, but as mentioned, I'd prefer to keep it separate from this patchset as this one fixes a real regression that we need to get backported too.
Signature · 1 line
Jens Axboe
Jason A. Donenfeld
maintainerHi Jens,
Quoted 11 lines · Jens Axboe
Quoted 9 lines · Jason A. Donenfeld
Hi Jens,
Quoted 4 lines · Jens Axboe
I can certainly do the write side too. To fix this regression, I just valued doing
read_iterfirst and I'd hate to hold that up to do the write side too. I'll do the write side later today, but let's keep them separate.Excellent, thanks. I plan to queue these up all in a row.
Quoted 7 lines
Built and tested v2, just sent it out. Note that it deviates from your proposal a bit since with that we lost the
if (!len)
break;check, which is kind of important if you ever want to be done :-)
Heh, noticed that too, thanks.
Quoted 3 lines
I'll do the
write_iterside, but as mentioned, I'd prefer to keep it separate from this patchset as this one fixes a real regression that we need to get backported too.
No problem. Because of all the flux in random.c lately, I've been preparing a massive backports branch, 2 branches actually, so I'll make sure this is in there. Backport concern aside, though, I'll look for your write_iter patch today. Thanks a bunch for doing this.
Jason
Quoted 17 lines · Jason A. Donenfeld
Hi Jens,
Quoted 14 lines · Jens Axboe
Quoted 9 lines · Jason A. Donenfeld
Hi Jens,
Quoted 4 lines · Jens Axboe
I can certainly do the write side too. To fix this regression, I just valued doing
read_iterfirst and I'd hate to hold that up to do the write side too. I'll do the write side later today, but let's keep them separate.Excellent, thanks. I plan to queue these up all in a row.
Built and tested v2, just sent it out. Note that it deviates from your proposal a bit since with that we lost the
Quoted 6 lines
Quoted 4 lines
if (!len)
break;check, which is kind of important if you ever want to be done :-)
Heh, noticed that too, thanks.
:-)
Quoted 8 lines
Quoted 3 lines
I'll do the
write_iterside, but as mentioned, I'd prefer to keep it separate from this patchset as this one fixes a real regression that we need to get backported too.No problem. Because of all the flux in
random.clately, I've been preparing a massive backports branch, 2 branches actually, so I'll make sure this is in there. Backport concern aside, though, I'll look for yourwrite_iterpatch today. Thanks a bunch for doing this.
Sounds great, thanks - write patch has been sent out too.
Signature · 1 line
Jens Axboe
Quoted 8 lines · Jason A. Donenfeld
Hi Jens,
Quoted 1 line · Jens Axboe
I'll leave that to you :-)
Alright, I'll have a look. Which one do I want here? This series adds splice_read/splice_write. The new thing would be sendpage? Or
copy_file_range? Or something else?
For copying kernel memory? It's really the same thing, you just initialize the iter as an ITER_KVEC instead. The nice thing about the iov_iter iterator that it then hides that for you, call the same copy in/out helpers for it.
Signature · 1 line
Jens Axboe
Jason A. Donenfeld
maintainerHi Jens,
Quoted 7 lines · Jens Axboe
Quoted 5 lines · Jason A. Donenfeld
Hi Jens,
Quoted 1 line · Jens Axboe
I'll leave that to you :-)
Quoted 8 lines
Quoted 3 lines
Alright, I'll have a look. Which one do I want here? This series adds splice_read/splice_write. The new thing would be sendpage? Or
copy_file_range? Or something else?For copying kernel memory? It's really the same thing, you just initialize the iter as an
ITER_KVECinstead. The nice thing about theiov_iteriterator that it then hides that for you, call the same copy in/out helpers for it.
Err, maybe we're talking about different things? I was thinking about the plumbing to make splice/sendfile work on non-pipes.
get_random_bytes() itself doesn't need to become iovec'd, as that has no IO callers.
Jason
Quoted 14 lines · Jason A. Donenfeld
Hi Jens,
Quoted 11 lines · Jens Axboe
Quoted 8 lines · Jason A. Donenfeld
Hi Jens,
Quoted 1 line · Jens Axboe
I'll leave that to you :-)
Alright, I'll have a look. Which one do I want here? This series adds splice_read/splice_write. The new thing would be sendpage? Or
copy_file_range? Or something else?
Quoted 7 lines
Quoted 4 lines
For copying kernel memory? It's really the same thing, you just initialize the iter as an
ITER_KVECinstead. The nice thing about theiov_iteriterator that it then hides that for you, call the same copy in/out helpers for it.Err, maybe we're talking about different things? I was thinking about the plumbing to make splice/sendfile work on non-pipes.
Ah I see. sendfile() just uses splice() internally, so that'll work (again) with my changes. splice(), by definition, either moves to and from a pipe. Hence one of the fds must be a pipe. Does that answer the question?
Quoted 2 lines
get_random_bytes()itself doesn't need to become iovec'd, as that has no IO callers.
I was a little puzzled, but didn't look deeper and see if it would make sense to do so.
Signature · 1 line
Jens Axboe
Jason A. Donenfeld
maintainerHi Jens,
Quoted 20 lines · Jens Axboe
Quoted 19 lines · Jason A. Donenfeld
Hi Jens,
Quoted 15 lines · Jens Axboe
Quoted 8 lines · Jason A. Donenfeld
Hi Jens,
Quoted 1 line · Jens Axboe
I'll leave that to you :-)
Alright, I'll have a look. Which one do I want here? This series adds splice_read/splice_write. The new thing would be sendpage? Or
copy_file_range? Or something else?For copying kernel memory? It's really the same thing, you just initialize the iter as an
ITER_KVECinstead. The nice thing about theiov_iteriterator that it then hides that for you, call the same copy in/out helpers for it.
Quoted 7 lines
Quoted 2 lines
Err, maybe we're talking about different things? I was thinking about the plumbing to make splice/sendfile work on non-pipes.
Ah I see.
sendfile()just usessplice()internally, so that'll work (again) with my changes.splice(), by definition, either moves to and from a pipe. Hence one of the fds must be a pipe. Does that answer the question?
sendfile() returns -EINVAL even with your patches. Only splicing to pipes seems to work.
Jason
Quoted 26 lines · Jason A. Donenfeld
Hi Jens,
Quoted 23 lines · Jens Axboe
Quoted 21 lines · Jason A. Donenfeld
Hi Jens,
Quoted 7 lines · Jens Axboe
Quoted 5 lines · Jason A. Donenfeld
Hi Jens,
Quoted 1 line · Jens Axboe
I'll leave that to you :-)
Quoted 8 lines
Quoted 3 lines
Alright, I'll have a look. Which one do I want here? This series adds splice_read/splice_write. The new thing would be sendpage? Or
copy_file_range? Or something else?For copying kernel memory? It's really the same thing, you just initialize the iter as an
ITER_KVECinstead. The nice thing about theiov_iteriterator that it then hides that for you, call the same copy in/out helpers for it.Err, maybe we're talking about different things? I was thinking about the plumbing to make splice/sendfile work on non-pipes.
Quoted 7 lines
Quoted 4 lines
Ah I see.
sendfile()just usessplice()internally, so that'll work (again) with my changes.splice(), by definition, either moves to and from a pipe. Hence one of the fds must be a pipe. Does that answer the question?
sendfile()returns-EINVALeven with your patches. Only splicing to pipes seems to work.
Huh, that really should work. Are you trying to sendfile() to random? If so, you need that last write_iter patch too, and add the splice_write as I mentioned.
Signature · 1 line
Jens Axboe
Jason A. Donenfeld
maintainerHi Jens,
Quoted 7 lines · Jens Axboe
Quoted 2 lines · Jason A. Donenfeld
sendfile()returns-EINVALeven with your patches. Only splicing to pipes seems to work.Huh, that really should work. Are you trying to
sendfile()to random? If so, you need that lastwrite_iterpatch too, and add thesplice_writeas I mentioned.
No, I've only tried the read side so far. I made a little program:
#include <sys/sendfile.h>
#include <stdio.h>
int main(int argc, char *argv[])
{
ssize_t s = sendfile(1, 0, NULL, 0xffff);
fprintf(stderr, "ret: %zd\n", s);
return 0;
}Then I ran ./a.out < /dev/urandom > /dev/null. Fails. OTOH, if I replace /dev/urandom with an ordinary file, it succeeds.
Jason
Quoted 17 lines · Jason A. Donenfeld
Hi Jens,
Quoted 7 lines · Jens Axboe
Quoted 2 lines · Jason A. Donenfeld
sendfile()returns-EINVALeven with your patches. Only splicing to pipes seems to work.Huh, that really should work. Are you trying to
sendfile()to random? If so, you need that lastwrite_iterpatch too, and add thesplice_writeas I mentioned.No, I've only tried the read side so far. I made a little program:
#include <
sys/sendfile.h>
#include <stdio.h>int
main(int argc, char *argv[])
Quoted 8 lines
{ ssize_t s = sendfile(1, 0, NULL, 0xffff); fprintf(stderr, "ret: %zd\n", s); return 0; }Then I ran
./a.out < /dev/urandom > /dev/null. Fails. OTOH, if I replace/dev/urandomwith an ordinary file, it succeeds.
Yeah I reproduced the same, doing it the other way works fine. Curious enough to see what it is, looking into it.
Signature · 1 line
Jens Axboe
Quoted 17 lines · Jason A. Donenfeld
Hi Jens,
Quoted 7 lines · Jens Axboe
Quoted 2 lines · Jason A. Donenfeld
sendfile()returns-EINVALeven with your patches. Only splicing to pipes seems to work.Huh, that really should work. Are you trying to
sendfile()to random? If so, you need that lastwrite_iterpatch too, and add thesplice_writeas I mentioned.No, I've only tried the read side so far. I made a little program:
#include <
sys/sendfile.h>
#include <stdio.h>int
main(int argc, char *argv[])
Quoted 8 lines
{ ssize_t s = sendfile(1, 0, NULL, 0xffff); fprintf(stderr, "ret: %zd\n", s); return 0; }Then I ran
./a.out < /dev/urandom > /dev/null. Fails. OTOH, if I replace/dev/urandomwith an ordinary file, it succeeds.
Here's why, it's limited to regular files or block devices:
if (unlikely(!S_ISREG(i_mode) && !S_ISBLK(i_mode)))
return -EINVAL;
in splice_direct_to_actor().
Signature · 1 line
Jens Axboe
Quoted 6 lines · Jens Axboe
I'm a bit torn on this one, because I _really_ want us to get rid of read/write and make everything use read_iter/write_iter. Firstly because it's really stupid to have two interfaces, and secondly because even basic things like "can we block here" doesn't work in the older interface without fiddling with file flags which is a non-starter for certain things.
Converting everything was my initial plan, but Linus said no and just fix whatever breaks. And compared to my initial fears the fallout actually isn't that bad.
Jason A. Donenfeld
maintainerHi Jens,
Quoted 27 lines · Jens Axboe
Quoted 17 lines · Jason A. Donenfeld
Hi Jens,
Quoted 7 lines · Jens Axboe
Quoted 2 lines · Jason A. Donenfeld
sendfile()returns-EINVALeven with your patches. Only splicing to pipes seems to work.Huh, that really should work. Are you trying to
sendfile()to random? If so, you need that lastwrite_iterpatch too, and add thesplice_writeas I mentioned.No, I've only tried the read side so far. I made a little program:
#include <
sys/sendfile.h>
#include <stdio.h>int
main(int argc, char *argv[])Quoted 8 lines
{ ssize_t s = sendfile(1, 0, NULL, 0xffff); fprintf(stderr, "ret: %zd\n", s); return 0; }Then I ran
./a.out < /dev/urandom > /dev/null. Fails. OTOH, if I replace/dev/urandomwith an ordinary file, it succeeds.
Quoted 6 lines
Here's why, it's limited to regular files or block devices:
if (
unlikely(!S_ISREG(i_mode) && !S_ISBLK(i_mode)))return -EINVAL;in
splice_direct_to_actor().
Indeed. Looks like that was your code from long long ago!
I posted
https://lore.kernel.org/lkml/[email protected]/ to fix it if you'd like to review.
Jason
Quoted 30 lines · Jason A. Donenfeld
Hi Jens,
Quoted 27 lines · Jens Axboe
Quoted 25 lines · Jason A. Donenfeld
Hi Jens,
Quoted 7 lines · Jens Axboe
Quoted 2 lines · Jason A. Donenfeld
sendfile()returns-EINVALeven with your patches. Only splicing to pipes seems to work.Huh, that really should work. Are you trying to
sendfile()to random? If so, you need that lastwrite_iterpatch too, and add thesplice_writeas I mentioned.No, I've only tried the read side so far. I made a little program:
#include <
sys/sendfile.h>
#include <stdio.h>int
main(int argc, char *argv[]){ ssize_t s = sendfile(1, 0, NULL, 0xffff); fprintf(stderr, "ret: %zd\n", s); return 0; }Then I ran
./a.out < /dev/urandom > /dev/null. Fails. OTOH, if I replace/dev/urandomwith an ordinary file, it succeeds.
Quoted 8 lines
Quoted 6 lines
Here's why, it's limited to regular files or block devices:
if (
unlikely(!S_ISREG(i_mode) && !S_ISBLK(i_mode)))return -EINVAL;in
splice_direct_to_actor().Indeed. Looks like that was your code from long long ago!
Yep I would not be surprised if that is the case!
Quoted 3 lines
I posted
https://lore.kernel.org/lkml/[email protected]/ to fix it if you'd like to review.
Not in my inbox, but you also used an email that hasn't been valid in 16 years :-)
But looks fine to me, we can open this up to character devices, don't see an issue with that.
Signature · 1 line
Jens Axboe
Quoted 11 lines · Christoph Hellwig
Quoted 6 lines · Jens Axboe
I'm a bit torn on this one, because I _really_ want us to get rid of read/write and make everything use read_iter/write_iter. Firstly because it's really stupid to have two interfaces, and secondly because even basic things like "can we block here" doesn't work in the older interface without fiddling with file flags which is a non-starter for certain things.
Converting everything was my initial plan, but Linus said no and just fix whatever breaks. And compared to my initial fears the fallout actually isn't that bad.
That's a real shame, and very unlike Linus to advocate for just breaking applications willy nilly. It would be a considerable amount of work though, but it would really be great to not have ->read/->write anymore and solely use the iter variants.
Not sure if I agree with "that bad" though looking at the number of fixups, and we'll keep finding these going forward as well...
Signature · 1 line
Jens Axboe
Jason A. Donenfeld
maintainerHi Jens,
Quoted 9 lines · Jens Axboe
Quoted 3 lines
I posted
https://lore.kernel.org/lkml/[email protected]/ to fix it if you'd like to review.Not in my inbox, but you also used an email that hasn't been valid in 16 years :-)
But looks fine to me, we can open this up to character devices, don't see an issue with that.
Whoops! I'll bounce it to you so you can provide a Reviewed-by for Al over there.
Jason