netfs: Add write_begin helper
Add a helper to do the pre-reading work for the netfs write_begin address space op. Changes v6: - Fixed a missing rreq put in netfs_write_begin()[3]. - Use DEFINE_READAHEAD()[4]. v5: - Made the wait for PG_fscache in netfs_write_begin() killable[2]. v4: - Added flag to netfs_subreq_terminated() to indicate that the caller may have been running async and stuff that might sleep needs punting to a workqueue (can't use in_softirq()[1]). Signed-off-by: David Howells <dhowells@redhat.com> Reviewed-and-tested-by: Jeff Layton <jlayton@kernel.org> Tested-by: Dave Wysochanski <dwysocha@redhat.com> Tested-By: Marc Dionne <marc.dionne@auristor.com> cc: Matthew Wilcox <willy@infradead.org> cc: linux-mm@kvack.org cc: linux-cachefs@redhat.com cc: linux-afs@lists.infradead.org cc: linux-nfs@vger.kernel.org cc: linux-cifs@vger.kernel.org cc: ceph-devel@vger.kernel.org cc: v9fs-developer@lists.sourceforge.net cc: linux-fsdevel@vger.kernel.org Link: https://lore.kernel.org/r/20210216084230.GA23669@lst.de/ [1] Link: https://lore.kernel.org/r/2499407.1616505440@warthog.procyon.org.uk/ [2] Link: https://lore.kernel.org/r/161781042127.463527.9154479794406046987.stgit@warthog.procyon.org.uk/ [3] Link: https://lore.kernel.org/r/1234933.1617886271@warthog.procyon.org.uk/ [4] Link: https://lore.kernel.org/r/160588543960.3465195.2792938973035886168.stgit@warthog.procyon.org.uk/ # rfc Link: https://lore.kernel.org/r/161118140165.1232039.16418853874312234477.stgit@warthog.procyon.org.uk/ # rfc Link: https://lore.kernel.org/r/161161035539.2537118.15674887534950908530.stgit@warthog.procyon.org.uk/ # v2 Link: https://lore.kernel.org/r/161340398368.1303470.11242918276563276090.stgit@warthog.procyon.org.uk/ # v3 Link: https://lore.kernel.org/r/161539541541.286939.1889738674057013729.stgit@warthog.procyon.org.uk/ # v4 Link: https://lore.kernel.org/r/161653798616.2770958.17213315845968485563.stgit@warthog.procyon.org.uk/ # v5 Link: https://lore.kernel.org/r/161789080530.6155.1011847312392330491.stgit@warthog.procyon.org.uk/ # v6
This commit is contained in:
David Howells
parent
289af54cc6
commit
e1b1240c1f
@ -34,8 +34,10 @@ extern atomic_t netfs_n_rh_read_failed;
|
||||
extern atomic_t netfs_n_rh_zero;
|
||||
extern atomic_t netfs_n_rh_short_read;
|
||||
extern atomic_t netfs_n_rh_write;
|
||||
extern atomic_t netfs_n_rh_write_begin;
|
||||
extern atomic_t netfs_n_rh_write_done;
|
||||
extern atomic_t netfs_n_rh_write_failed;
|
||||
extern atomic_t netfs_n_rh_write_zskip;
|
||||
|
||||
|
||||
static inline void netfs_stat(atomic_t *stat)
|
||||
|
||||
@ -772,3 +772,167 @@ int netfs_readpage(struct file *file,
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL(netfs_readpage);
|
||||
|
||||
static void netfs_clear_thp(struct page *page)
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < thp_nr_pages(page); i++)
|
||||
clear_highpage(page + i);
|
||||
}
|
||||
|
||||
/**
|
||||
* netfs_write_begin - Helper to prepare for writing
|
||||
* @file: The file to read from
|
||||
* @mapping: The mapping to read from
|
||||
* @pos: File position at which the write will begin
|
||||
* @len: The length of the write in this page
|
||||
* @flags: AOP_* flags
|
||||
* @_page: Where to put the resultant page
|
||||
* @_fsdata: Place for the netfs to store a cookie
|
||||
* @ops: The network filesystem's operations for the helper to use
|
||||
* @netfs_priv: Private netfs data to be retained in the request
|
||||
*
|
||||
* Pre-read data for a write-begin request by drawing data from the cache if
|
||||
* possible, or the netfs if not. Space beyond the EOF is zero-filled.
|
||||
* Multiple I/O requests from different sources will get munged together. If
|
||||
* necessary, the readahead window can be expanded in either direction to a
|
||||
* more convenient alighment for RPC efficiency or to make storage in the cache
|
||||
* feasible.
|
||||
*
|
||||
* The calling netfs must provide a table of operations, only one of which,
|
||||
* issue_op, is mandatory.
|
||||
*
|
||||
* The check_write_begin() operation can be provided to check for and flush
|
||||
* conflicting writes once the page is grabbed and locked. It is passed a
|
||||
* pointer to the fsdata cookie that gets returned to the VM to be passed to
|
||||
* write_end. It is permitted to sleep. It should return 0 if the request
|
||||
* should go ahead; unlock the page and return -EAGAIN to cause the page to be
|
||||
* regot; or return an error.
|
||||
*
|
||||
* This is usable whether or not caching is enabled.
|
||||
*/
|
||||
int netfs_write_begin(struct file *file, struct address_space *mapping,
|
||||
loff_t pos, unsigned int len, unsigned int flags,
|
||||
struct page **_page, void **_fsdata,
|
||||
const struct netfs_read_request_ops *ops,
|
||||
void *netfs_priv)
|
||||
{
|
||||
struct netfs_read_request *rreq;
|
||||
struct page *page, *xpage;
|
||||
struct inode *inode = file_inode(file);
|
||||
unsigned int debug_index = 0;
|
||||
pgoff_t index = pos >> PAGE_SHIFT;
|
||||
int pos_in_page = pos & ~PAGE_MASK;
|
||||
loff_t size;
|
||||
int ret;
|
||||
|
||||
DEFINE_READAHEAD(ractl, file, NULL, mapping, index);
|
||||
|
||||
retry:
|
||||
page = grab_cache_page_write_begin(mapping, index, 0);
|
||||
if (!page)
|
||||
return -ENOMEM;
|
||||
|
||||
if (ops->check_write_begin) {
|
||||
/* Allow the netfs (eg. ceph) to flush conflicts. */
|
||||
ret = ops->check_write_begin(file, pos, len, page, _fsdata);
|
||||
if (ret < 0) {
|
||||
if (ret == -EAGAIN)
|
||||
goto retry;
|
||||
goto error;
|
||||
}
|
||||
}
|
||||
|
||||
if (PageUptodate(page))
|
||||
goto have_page;
|
||||
|
||||
/* If the page is beyond the EOF, we want to clear it - unless it's
|
||||
* within the cache granule containing the EOF, in which case we need
|
||||
* to preload the granule.
|
||||
*/
|
||||
size = i_size_read(inode);
|
||||
if (!ops->is_cache_enabled(inode) &&
|
||||
((pos_in_page == 0 && len == thp_size(page)) ||
|
||||
(pos >= size) ||
|
||||
(pos_in_page == 0 && (pos + len) >= size))) {
|
||||
netfs_clear_thp(page);
|
||||
SetPageUptodate(page);
|
||||
netfs_stat(&netfs_n_rh_write_zskip);
|
||||
goto have_page_no_wait;
|
||||
}
|
||||
|
||||
ret = -ENOMEM;
|
||||
rreq = netfs_alloc_read_request(ops, netfs_priv, file);
|
||||
if (!rreq)
|
||||
goto error;
|
||||
rreq->mapping = page->mapping;
|
||||
rreq->start = page->index * PAGE_SIZE;
|
||||
rreq->len = thp_size(page);
|
||||
rreq->no_unlock_page = page->index;
|
||||
__set_bit(NETFS_RREQ_NO_UNLOCK_PAGE, &rreq->flags);
|
||||
netfs_priv = NULL;
|
||||
|
||||
netfs_stat(&netfs_n_rh_write_begin);
|
||||
trace_netfs_read(rreq, pos, len, netfs_read_trace_write_begin);
|
||||
|
||||
/* Expand the request to meet caching requirements and download
|
||||
* preferences.
|
||||
*/
|
||||
ractl._nr_pages = thp_nr_pages(page);
|
||||
netfs_rreq_expand(rreq, &ractl);
|
||||
netfs_get_read_request(rreq);
|
||||
|
||||
/* We hold the page locks, so we can drop the references */
|
||||
while ((xpage = readahead_page(&ractl)))
|
||||
if (xpage != page)
|
||||
put_page(xpage);
|
||||
|
||||
atomic_set(&rreq->nr_rd_ops, 1);
|
||||
do {
|
||||
if (!netfs_rreq_submit_slice(rreq, &debug_index))
|
||||
break;
|
||||
|
||||
} while (rreq->submitted < rreq->len);
|
||||
|
||||
/* Keep nr_rd_ops incremented so that the ref always belongs to us, and
|
||||
* the service code isn't punted off to a random thread pool to
|
||||
* process.
|
||||
*/
|
||||
for (;;) {
|
||||
wait_var_event(&rreq->nr_rd_ops, atomic_read(&rreq->nr_rd_ops) == 1);
|
||||
netfs_rreq_assess(rreq, false);
|
||||
if (!test_bit(NETFS_RREQ_IN_PROGRESS, &rreq->flags))
|
||||
break;
|
||||
cond_resched();
|
||||
}
|
||||
|
||||
ret = rreq->error;
|
||||
if (ret == 0 && rreq->submitted < rreq->len)
|
||||
ret = -EIO;
|
||||
netfs_put_read_request(rreq, false);
|
||||
if (ret < 0)
|
||||
goto error;
|
||||
|
||||
have_page:
|
||||
ret = wait_on_page_fscache_killable(page);
|
||||
if (ret < 0)
|
||||
goto error;
|
||||
have_page_no_wait:
|
||||
if (netfs_priv)
|
||||
ops->cleanup(netfs_priv, mapping);
|
||||
*_page = page;
|
||||
_leave(" = 0");
|
||||
return 0;
|
||||
|
||||
error_put:
|
||||
netfs_put_read_request(rreq, false);
|
||||
error:
|
||||
unlock_page(page);
|
||||
put_page(page);
|
||||
if (netfs_priv)
|
||||
ops->cleanup(netfs_priv, mapping);
|
||||
_leave(" = %d", ret);
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL(netfs_write_begin);
|
||||
|
||||
@ -24,19 +24,24 @@ atomic_t netfs_n_rh_read_failed;
|
||||
atomic_t netfs_n_rh_zero;
|
||||
atomic_t netfs_n_rh_short_read;
|
||||
atomic_t netfs_n_rh_write;
|
||||
atomic_t netfs_n_rh_write_begin;
|
||||
atomic_t netfs_n_rh_write_done;
|
||||
atomic_t netfs_n_rh_write_failed;
|
||||
atomic_t netfs_n_rh_write_zskip;
|
||||
|
||||
void netfs_stats_show(struct seq_file *m)
|
||||
{
|
||||
seq_printf(m, "RdHelp : RA=%u RP=%u rr=%u sr=%u\n",
|
||||
seq_printf(m, "RdHelp : RA=%u RP=%u WB=%u WBZ=%u rr=%u sr=%u\n",
|
||||
atomic_read(&netfs_n_rh_readahead),
|
||||
atomic_read(&netfs_n_rh_readpage),
|
||||
atomic_read(&netfs_n_rh_write_begin),
|
||||
atomic_read(&netfs_n_rh_write_zskip),
|
||||
atomic_read(&netfs_n_rh_rreq),
|
||||
atomic_read(&netfs_n_rh_sreq));
|
||||
seq_printf(m, "RdHelp : ZR=%u sh=%u\n",
|
||||
seq_printf(m, "RdHelp : ZR=%u sh=%u sk=%u\n",
|
||||
atomic_read(&netfs_n_rh_zero),
|
||||
atomic_read(&netfs_n_rh_short_read));
|
||||
atomic_read(&netfs_n_rh_short_read),
|
||||
atomic_read(&netfs_n_rh_write_zskip));
|
||||
seq_printf(m, "RdHelp : DL=%u ds=%u df=%u di=%u\n",
|
||||
atomic_read(&netfs_n_rh_download),
|
||||
atomic_read(&netfs_n_rh_download_done),
|
||||
|
||||
@ -147,11 +147,14 @@ struct netfs_read_request {
|
||||
* Operations the network filesystem can/must provide to the helpers.
|
||||
*/
|
||||
struct netfs_read_request_ops {
|
||||
bool (*is_cache_enabled)(struct inode *inode);
|
||||
void (*init_rreq)(struct netfs_read_request *rreq, struct file *file);
|
||||
void (*expand_readahead)(struct netfs_read_request *rreq);
|
||||
bool (*clamp_length)(struct netfs_read_subrequest *subreq);
|
||||
void (*issue_op)(struct netfs_read_subrequest *subreq);
|
||||
bool (*is_still_valid)(struct netfs_read_request *rreq);
|
||||
int (*check_write_begin)(struct file *file, loff_t pos, unsigned len,
|
||||
struct page *page, void **_fsdata);
|
||||
void (*done)(struct netfs_read_request *rreq);
|
||||
void (*cleanup)(struct address_space *mapping, void *netfs_priv);
|
||||
};
|
||||
@ -164,6 +167,11 @@ extern int netfs_readpage(struct file *,
|
||||
struct page *,
|
||||
const struct netfs_read_request_ops *,
|
||||
void *);
|
||||
extern int netfs_write_begin(struct file *, struct address_space *,
|
||||
loff_t, unsigned int, unsigned int, struct page **,
|
||||
void **,
|
||||
const struct netfs_read_request_ops *,
|
||||
void *);
|
||||
|
||||
extern void netfs_subreq_terminated(struct netfs_read_subrequest *, ssize_t, bool);
|
||||
extern void netfs_stats_show(struct seq_file *);
|
||||
|
||||
@ -22,6 +22,7 @@ enum netfs_read_trace {
|
||||
netfs_read_trace_expanded,
|
||||
netfs_read_trace_readahead,
|
||||
netfs_read_trace_readpage,
|
||||
netfs_read_trace_write_begin,
|
||||
};
|
||||
|
||||
enum netfs_rreq_trace {
|
||||
@ -50,7 +51,8 @@ enum netfs_sreq_trace {
|
||||
#define netfs_read_traces \
|
||||
EM(netfs_read_trace_expanded, "EXPANDED ") \
|
||||
EM(netfs_read_trace_readahead, "READAHEAD") \
|
||||
E_(netfs_read_trace_readpage, "READPAGE ")
|
||||
EM(netfs_read_trace_readpage, "READPAGE ") \
|
||||
E_(netfs_read_trace_write_begin, "WRITEBEGN")
|
||||
|
||||
#define netfs_rreq_traces \
|
||||
EM(netfs_rreq_trace_assess, "ASSESS") \
|
||||
|
||||
Loading…
Reference in New Issue
Block a user