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 (async || user_backed_iter(iter)) {
71 n = netfs_extract_user_iter(iter, len, &wreq->iter, 0);
72 if (n < 0) {
73 ret = n;
74 goto out;
75 }
76 wreq->direct_bv = (struct bio_vec *)wreq->iter.bvec;
77 wreq->direct_bv_count = n;
78 wreq->direct_bv_unpin = iov_iter_extract_will_pin(iter);
79 } else {
80 wreq->iter = *iter;
81 }
82
83 wreq->io_iter = wreq->iter;
84 }
85
86 __set_bit(NETFS_RREQ_USE_IO_ITER, &wreq->flags);
87
88 /* Copy the data into the bounce buffer and encrypt it. */
89 // TODO
90
91 /* Dispatch the write. */
92 __set_bit(NETFS_RREQ_UPLOAD_TO_SERVER, &wreq->flags);
93 if (async)
94 wreq->iocb = iocb;
95 wreq->len = iov_iter_count(&wreq->io_iter);
96 wreq->cleanup = netfs_cleanup_dio_write;
97 ret = netfs_unbuffered_write(wreq, is_sync_kiocb(iocb), wreq->len);
98 if (ret < 0) {
99 _debug("begin = %zd", ret);
100 goto out;
101 }
102
103 if (!async) {
104 trace_netfs_rreq(wreq, netfs_rreq_trace_wait_ip);
105 wait_on_bit(&wreq->flags, NETFS_RREQ_IN_PROGRESS,
106 TASK_UNINTERRUPTIBLE);
107 smp_rmb(); /* Read error/transferred after RIP flag */
108 ret = wreq->error;
109 if (ret == 0) {
110 ret = wreq->transferred;
111 iocb->ki_pos += ret;
112 }
113 } else {
114 ret = -EIOCBQUEUED;
115 }
116
117 out:
118 netfs_put_request(wreq, false, netfs_rreq_trace_put_return);
119 return ret;
120 }
121 EXPORT_SYMBOL(netfs_unbuffered_write_iter_locked);
122
123 /**
124 * netfs_unbuffered_write_iter - Unbuffered write to a file
125 * @iocb: IO state structure
126 * @from: iov_iter with data to write
127 *
128 * Do an unbuffered write to a file, writing the data directly to the server
129 * and not lodging the data in the pagecache.
130 *
131 * Return:
132 * * Negative error code if no data has been written at all of
133 * vfs_fsync_range() failed for a synchronous write
134 * * Number of bytes written, even for truncated writes
135 */
136 ssize_t netfs_unbuffered_write_iter(struct kiocb *iocb, struct iov_iter *from)
137 {
138 struct file *file = iocb->ki_filp;
139 struct address_space *mapping = file->f_mapping;
140 struct inode *inode = mapping->host;
141 struct netfs_inode *ictx = netfs_inode(inode);
142 ssize_t ret;
143 loff_t pos = iocb->ki_pos;
144 unsigned long long end = pos + iov_iter_count(from) - 1;
145
146 _enter("%llx,%zx,%llx", pos, iov_iter_count(from), i_size_read(inode));
147
148 if (!iov_iter_count(from))
149 return 0;
150
151 trace_netfs_write_iter(iocb, from);
152 netfs_stat(&netfs_n_wh_dio_write);
153
154 ret = netfs_start_io_direct(inode);
155 if (ret < 0)
156 return ret;
157 ret = generic_write_checks(iocb, from);
158 if (ret <= 0)
159 goto out;
160 ret = file_remove_privs(file);
161 if (ret < 0)
162 goto out;
163 ret = file_update_time(file);
164 if (ret < 0)
165 goto out;
166 if (iocb->ki_flags & IOCB_NOWAIT) {
167 /* We could block if there are any pages in the range. */
168 ret = -EAGAIN;
169 if (filemap_range_has_page(mapping, pos, end))
170 if (filemap_invalidate_inode(inode, true, pos, end))
171 goto out;
172 } else {
173 ret = filemap_write_and_wait_range(mapping, pos, end);
174 if (ret < 0)
175 goto out;
176 }
177
178 /*
179 * After a write we want buffered reads to be sure to go to disk to get
180 * the new data. We invalidate clean cached page from the region we're
181 * about to write. We do this *before* the write so that we can return
182 * without clobbering -EIOCBQUEUED from ->direct_IO().
183 */
184 ret = filemap_invalidate_inode(inode, true, pos, end);
185 if (ret < 0)
186 goto out;
187 end = iocb->ki_pos + iov_iter_count(from);
188 if (end > ictx->zero_point)
189 ictx->zero_point = end;
190
191 fscache_invalidate(netfs_i_cookie(ictx), NULL, i_size_read(inode),
192 FSCACHE_INVAL_DIO_WRITE);
193 ret = netfs_unbuffered_write_iter_locked(iocb, from, NULL);
194 out:
195 netfs_end_io_direct(inode);
196 return ret;
197 }
198 EXPORT_SYMBOL(netfs_unbuffered_write_iter);
199
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.