lkml.org 
[lkml]   [2022]   [May]   [27]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 5.17 107/111] random: convert to using fops->write_iter()
    Date
    From: Jens Axboe <axboe@kernel.dk>

    commit 22b0a222af4df8ee9bb8e07013ab44da9511b047 upstream.

    Now that the read side has been converted to fix a regression with
    splice, convert the write side as well to have some symmetry in the
    interface used (and help deprecate ->write()).

    Signed-off-by: Jens Axboe <axboe@kernel.dk>
    [Jason: cleaned up random_ioctl a bit, require full writes in
    RNDADDENTROPY since it's crediting entropy, simplify control flow of
    write_pool(), and incorporate suggestions from Al.]
    Cc: Al Viro <viro@zeniv.linux.org.uk>
    Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
    Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
    ---
    drivers/char/random.c | 67 ++++++++++++++++++++++++++------------------------
    1 file changed, 35 insertions(+), 32 deletions(-)

    --- a/drivers/char/random.c
    +++ b/drivers/char/random.c
    @@ -1253,39 +1253,31 @@ static __poll_t random_poll(struct file
    return crng_ready() ? EPOLLIN | EPOLLRDNORM : EPOLLOUT | EPOLLWRNORM;
    }

    -static int write_pool(const char __user *ubuf, size_t len)
    +static ssize_t write_pool(struct iov_iter *iter)
    {
    - size_t block_len;
    - int ret = 0;
    u8 block[BLAKE2S_BLOCK_SIZE];
    + ssize_t ret = 0;
    + size_t copied;

    - while (len) {
    - block_len = min(len, sizeof(block));
    - if (copy_from_user(block, ubuf, block_len)) {
    - ret = -EFAULT;
    - goto out;
    - }
    - len -= block_len;
    - ubuf += block_len;
    - mix_pool_bytes(block, block_len);
    + if (unlikely(!iov_iter_count(iter)))
    + return 0;
    +
    + for (;;) {
    + copied = copy_from_iter(block, sizeof(block), iter);
    + ret += copied;
    + mix_pool_bytes(block, copied);
    + if (!iov_iter_count(iter) || copied != sizeof(block))
    + break;
    cond_resched();
    }

    -out:
    memzero_explicit(block, sizeof(block));
    - return ret;
    + return ret ? ret : -EFAULT;
    }

    -static ssize_t random_write(struct file *file, const char __user *ubuf,
    - size_t len, loff_t *ppos)
    +static ssize_t random_write_iter(struct kiocb *kiocb, struct iov_iter *iter)
    {
    - int ret;
    -
    - ret = write_pool(ubuf, len);
    - if (ret)
    - return ret;
    -
    - return (ssize_t)len;
    + return write_pool(iter);
    }

    static ssize_t urandom_read_iter(struct kiocb *kiocb, struct iov_iter *iter)
    @@ -1317,9 +1309,8 @@ static ssize_t random_read_iter(struct k

    static long random_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
    {
    - int size, ent_count;
    int __user *p = (int __user *)arg;
    - int retval;
    + int ent_count;

    switch (cmd) {
    case RNDGETENTCNT:
    @@ -1336,20 +1327,32 @@ static long random_ioctl(struct file *f,
    return -EINVAL;
    credit_init_bits(ent_count);
    return 0;
    - case RNDADDENTROPY:
    + case RNDADDENTROPY: {
    + struct iov_iter iter;
    + struct iovec iov;
    + ssize_t ret;
    + int len;
    +
    if (!capable(CAP_SYS_ADMIN))
    return -EPERM;
    if (get_user(ent_count, p++))
    return -EFAULT;
    if (ent_count < 0)
    return -EINVAL;
    - if (get_user(size, p++))
    + if (get_user(len, p++))
    + return -EFAULT;
    + ret = import_single_range(WRITE, p, len, &iov, &iter);
    + if (unlikely(ret))
    + return ret;
    + ret = write_pool(&iter);
    + if (unlikely(ret < 0))
    + return ret;
    + /* Since we're crediting, enforce that it was all written into the pool. */
    + if (unlikely(ret != len))
    return -EFAULT;
    - retval = write_pool((const char __user *)p, size);
    - if (retval < 0)
    - return retval;
    credit_init_bits(ent_count);
    return 0;
    + }
    case RNDZAPENTCNT:
    case RNDCLEARPOOL:
    /* No longer has any effect. */
    @@ -1375,7 +1378,7 @@ static int random_fasync(int fd, struct

    const struct file_operations random_fops = {
    .read_iter = random_read_iter,
    - .write = random_write,
    + .write_iter = random_write_iter,
    .poll = random_poll,
    .unlocked_ioctl = random_ioctl,
    .compat_ioctl = compat_ptr_ioctl,
    @@ -1385,7 +1388,7 @@ const struct file_operations random_fops

    const struct file_operations urandom_fops = {
    .read_iter = urandom_read_iter,
    - .write = random_write,
    + .write_iter = random_write_iter,
    .unlocked_ioctl = random_ioctl,
    .compat_ioctl = compat_ptr_ioctl,
    .fasync = random_fasync,

    \
     
     \ /
      Last update: 2022-05-27 13:57    [W:3.000 / U:0.072 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site