fs/netfs/direct_write.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* Unbuffered and direct write support.
   3  *
   4  * Copyright (C) 2023 Red Hat, Inc. All Rights Reserved.
   5  * Written by David Howells (dhowells@redhat.com)
   6  */
   7
   8 #include <linux/export.h>
   9 #include <linux/uio.h>
  10 #include "internal.h"
  11
  12 static void netfs_cleanup_dio_write(struct netfs_io_request *wreq)
  13 {
  14         struct inode *inode = wreq->inode;
  15         unsigned long long end = wreq->start + wreq->transferred;
  16
  17         if (!wreq->error &&
  18             i_size_read(inode) < end) {
  19                 if (wreq->netfs_ops->update_i_size)
  20                         wreq->netfs_ops->update_i_size(inode, end);
  21                 else
  22                         i_size_write(inode, end);
  23         }
  24 }
  25
  26 /*
  27  * Perform an unbuffered write where we may have to do an RMW operation on an
  28  * encrypted file.  This can also be used for direct I/O writes.
  29  */
  30 ssize_t netfs_unbuffered_write_iter_locked(struct kiocb *iocb, struct iov_iter *iter,
  31                                                   struct netfs_group *netfs_group)
  32 {
  33         struct netfs_io_request *wreq;
  34         unsigned long long start = iocb->ki_pos;
  35         unsigned long long end = start + iov_iter_count(iter);
  36         ssize_t ret, n;
  37         size_t len = iov_iter_count(iter);
  38         bool async = !is_sync_kiocb(iocb);
  39
  40         _enter("");
  41
  42         /* We're going to need a bounce buffer if what we transmit is going to
  43          * be different in some way to the source buffer, e.g. because it gets
  44          * encrypted/compressed or because it needs expanding to a block size.
  45          */
  46         // TODO
  47
  48         _debug("uw %llx-%llx", start, end);
  49
  50         wreq = netfs_create_write_req(iocb->ki_filp->f_mapping, iocb->ki_filp, start,
  51                                       iocb->ki_flags & IOCB_DIRECT ?
  52                                       NETFS_DIO_WRITE : NETFS_UNBUFFERED_WRITE);
  53         if (IS_ERR(wreq))
  54                 return PTR_ERR(wreq);
  55
  56         wreq->io_streams[0].avail = true;
  57         trace_netfs_write(wreq, (iocb->ki_flags & IOCB_DIRECT ?
  58                                  netfs_write_trace_dio_write :
  59                                  netfs_write_trace_unbuffered_write));
  60
  61         {
  62                 /* If this is an async op and we're not using a bounce buffer,
  63                  * we have to save the source buffer as the iterator is only
  64                  * good until we return.  In such a case, extract an iterator
  65                  * to represent as much of the the output buffer as we can
  66                  * manage.  Note that the extraction might not be able to
  67                  * allocate a sufficiently large bvec array and may shorten the
  68                  * request.
  69                  */
  70                 if (user_backed_iter(iter)) {
  71                         n = netfs_extract_user_iter(iter, len, &wreq->buffer.iter, 0);
  72                         if (n < 0) {
  73                                 ret = n;
  74                                 goto out;
  75                         }
  76                         wreq->direct_bv = (struct bio_vec *)wreq->buffer.iter.bvec;
  77                         wreq->direct_bv_count = n;
  78                         wreq->direct_bv_unpin = iov_iter_extract_will_pin(iter);
  79                 } else {
  80                         /* If this is a kernel-generated async DIO request,
  81                          * assume that any resources the iterator points to
  82                          * (eg. a bio_vec array) will persist till the end of
  83                          * the op.
  84                          */
  85                         wreq->buffer.iter = *iter;
  86                 }
  87         }
  88
  89         __set_bit(NETFS_RREQ_USE_IO_ITER, &wreq->flags);
  90
  91         /* Copy the data into the bounce buffer and encrypt it. */
  92         // TODO
  93
  94         /* Dispatch the write. */
  95         __set_bit(NETFS_RREQ_UPLOAD_TO_SERVER, &wreq->flags);
  96         if (async)
  97                 wreq->iocb = iocb;
  98         wreq->len = iov_iter_count(&wreq->buffer.iter);
  99         wreq->cleanup = netfs_cleanup_dio_write;
 100         ret = netfs_unbuffered_write(wreq, is_sync_kiocb(iocb), wreq->len);
 101         if (ret < 0) {
 102                 _debug("begin = %zd", ret);
 103                 goto out;
 104         }
 105
 106         if (!async) {
 107                 trace_netfs_rreq(wreq, netfs_rreq_trace_wait_ip);
 108                 wait_on_bit(&wreq->flags, NETFS_RREQ_IN_PROGRESS,
 109                             TASK_UNINTERRUPTIBLE);
 110                 ret = wreq->error;
 111                 if (ret == 0) {
 112                         ret = wreq->transferred;
 113                         iocb->ki_pos += ret;
 114                 }
 115         } else {
 116                 ret = -EIOCBQUEUED;
 117         }
 118
 119 out:
 120         netfs_put_request(wreq, false, netfs_rreq_trace_put_return);
 121         return ret;
 122 }
 123 EXPORT_SYMBOL(netfs_unbuffered_write_iter_locked);
 124
 125 /**
 126  * netfs_unbuffered_write_iter - Unbuffered write to a file
 127  * @iocb: IO state structure
 128  * @from: iov_iter with data to write
 129  *
 130  * Do an unbuffered write to a file, writing the data directly to the server
 131  * and not lodging the data in the pagecache.
 132  *
 133  * Return:
 134  * * Negative error code if no data has been written at all of
 135  *   vfs_fsync_range() failed for a synchronous write
 136  * * Number of bytes written, even for truncated writes
 137  */
 138 ssize_t netfs_unbuffered_write_iter(struct kiocb *iocb, struct iov_iter *from)
 139 {
 140         struct file *file = iocb->ki_filp;
 141         struct address_space *mapping = file->f_mapping;
 142         struct inode *inode = mapping->host;
 143         struct netfs_inode *ictx = netfs_inode(inode);
 144         ssize_t ret;
 145         loff_t pos = iocb->ki_pos;
 146         unsigned long long end = pos + iov_iter_count(from) - 1;
 147
 148         _enter("%llx,%zx,%llx", pos, iov_iter_count(from), i_size_read(inode));
 149
 150         if (!iov_iter_count(from))
 151                 return 0;
 152
 153         trace_netfs_write_iter(iocb, from);
 154         netfs_stat(&netfs_n_wh_dio_write);
 155
 156         ret = netfs_start_io_direct(inode);
 157         if (ret < 0)
 158                 return ret;
 159         ret = generic_write_checks(iocb, from);
 160         if (ret <= 0)
 161                 goto out;
 162         ret = file_remove_privs(file);
 163         if (ret < 0)
 164                 goto out;
 165         ret = file_update_time(file);
 166         if (ret < 0)
 167                 goto out;
 168         if (iocb->ki_flags & IOCB_NOWAIT) {
 169                 /* We could block if there are any pages in the range. */
 170                 ret = -EAGAIN;
 171                 if (filemap_range_has_page(mapping, pos, end))
 172                         if (filemap_invalidate_inode(inode, true, pos, end))
 173                                 goto out;
 174         } else {
 175                 ret = filemap_write_and_wait_range(mapping, pos, end);
 176                 if (ret < 0)
 177                         goto out;
 178         }
 179
 180         /*
 181          * After a write we want buffered reads to be sure to go to disk to get
 182          * the new data.  We invalidate clean cached page from the region we're
 183          * about to write.  We do this *before* the write so that we can return
 184          * without clobbering -EIOCBQUEUED from ->direct_IO().
 185          */
 186         ret = filemap_invalidate_inode(inode, true, pos, end);
 187         if (ret < 0)
 188                 goto out;
 189         end = iocb->ki_pos + iov_iter_count(from);
 190         if (end > ictx->zero_point)
 191                 ictx->zero_point = end;
 192
 193         fscache_invalidate(netfs_i_cookie(ictx), NULL, i_size_read(inode),
 194                            FSCACHE_INVAL_DIO_WRITE);
 195         ret = netfs_unbuffered_write_iter_locked(iocb, from, NULL);
 196 out:
 197         netfs_end_io_direct(inode);
 198         return ret;
 199 }
 200 EXPORT_SYMBOL(netfs_unbuffered_write_iter);