2019-05-19 12:08:55 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* linux/fs/nfs/write.c
|
|
|
|
*
|
2006-12-13 20:23:48 +00:00
|
|
|
* Write file data over NFS.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Copyright (C) 1996, 1997, Olaf Kirch <okir@monad.swb.de>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include <linux/file.h>
|
|
|
|
#include <linux/writeback.h>
|
2007-03-16 21:38:26 +00:00
|
|
|
#include <linux/swap.h>
|
2009-08-10 12:54:13 +00:00
|
|
|
#include <linux/migrate.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <linux/sunrpc/clnt.h>
|
|
|
|
#include <linux/nfs_fs.h>
|
|
|
|
#include <linux/nfs_mount.h>
|
|
|
|
#include <linux/nfs_page.h>
|
2006-10-20 06:28:16 +00:00
|
|
|
#include <linux/backing-dev.h>
|
2011-05-26 20:00:52 +00:00
|
|
|
#include <linux/export.h>
|
2015-09-30 00:34:05 +00:00
|
|
|
#include <linux/freezer.h>
|
|
|
|
#include <linux/wait.h>
|
2018-01-09 13:21:17 +00:00
|
|
|
#include <linux/iversion.h>
|
2006-10-20 06:28:16 +00:00
|
|
|
|
2016-12-24 19:46:01 +00:00
|
|
|
#include <linux/uaccess.h>
|
2019-02-18 18:06:54 +00:00
|
|
|
#include <linux/sched/mm.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include "delegation.h"
|
2006-12-05 05:35:38 +00:00
|
|
|
#include "internal.h"
|
2006-03-20 18:44:14 +00:00
|
|
|
#include "iostat.h"
|
2009-04-01 13:22:26 +00:00
|
|
|
#include "nfs4_fs.h"
|
2009-08-10 12:54:13 +00:00
|
|
|
#include "fscache.h"
|
2011-03-01 01:34:14 +00:00
|
|
|
#include "pnfs.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-08-19 22:59:33 +00:00
|
|
|
#include "nfstrace.h"
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define NFSDBG_FACILITY NFSDBG_PAGECACHE
|
|
|
|
|
|
|
|
#define MIN_POOL_WRITE (32)
|
|
|
|
#define MIN_POOL_COMMIT (4)
|
|
|
|
|
2017-06-20 23:35:37 +00:00
|
|
|
struct nfs_io_completion {
|
|
|
|
void (*complete)(void *data);
|
|
|
|
void *data;
|
|
|
|
struct kref refcount;
|
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Local function declarations
|
|
|
|
*/
|
nfs: don't ignore return value from nfs_pageio_add_request
Ignoring the return value from nfs_pageio_add_request can cause deadlocks.
In read path:
call nfs_pageio_add_request from readpage_async_filler
assume at this point that there are requests already in desc, that
can't be merged with the current request.
so nfs_pageio_doio is fired up to clear out desc.
assume something goes wrong in setting up the io, so desc->pg_error is set.
This causes nfs_pageio_add_request to return 0, *WITHOUT* adding the original
request.
BUT, since return code is ignored, readpage_async_filler assumes it has
been added, and does nothing further, leaving page locked.
do_generic_mapping_read will eventually call lock_page, resulting in deadlock
In write path:
page is marked dirty by generic_perform_write
nfs_writepages is called
call nfs_pageio_add_request from nfs_page_async_flush
assume at this point that there are requests already in desc, that
can't be merged with the current request.
so nfs_pageio_doio is fired up to clear out desc.
assume something goes wrong in setting up the io, so desc->pg_error is set.
This causes nfs_page_async_flush to return 0, *WITHOUT* adding the original
request, yet marking the request as locked (PG_BUSY) and in writeback,
clearing dirty marks.
The next time a write is done to the page, deadlock will result as
nfs_write_end calls nfs_update_request
Signed-off-by: Fred Isaman <iisaman@citi.umich.edu>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2008-03-19 15:24:39 +00:00
|
|
|
static void nfs_redirty_request(struct nfs_page *req);
|
2006-03-20 18:44:27 +00:00
|
|
|
static const struct rpc_call_ops nfs_commit_ops;
|
2012-04-20 18:47:48 +00:00
|
|
|
static const struct nfs_pgio_completion_ops nfs_async_write_completion_ops;
|
2012-04-20 18:47:54 +00:00
|
|
|
static const struct nfs_commit_completion_ops nfs_commit_completion_ops;
|
2014-05-06 13:12:30 +00:00
|
|
|
static const struct nfs_rw_ops nfs_rw_write_ops;
|
2019-08-14 19:42:43 +00:00
|
|
|
static void nfs_inode_remove_request(struct nfs_page *req);
|
2014-07-11 14:20:48 +00:00
|
|
|
static void nfs_clear_request_commit(struct nfs_page *req);
|
2014-07-18 00:42:17 +00:00
|
|
|
static void nfs_init_cinfo_from_inode(struct nfs_commit_info *cinfo,
|
|
|
|
struct inode *inode);
|
2014-09-09 05:21:00 +00:00
|
|
|
static struct nfs_page *
|
|
|
|
nfs_page_search_commits_for_head_request_locked(struct nfs_inode *nfsi,
|
|
|
|
struct page *page);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-07 04:33:20 +00:00
|
|
|
static struct kmem_cache *nfs_wdata_cachep;
|
2006-03-20 18:44:37 +00:00
|
|
|
static mempool_t *nfs_wdata_mempool;
|
2012-04-20 18:47:39 +00:00
|
|
|
static struct kmem_cache *nfs_cdata_cachep;
|
2005-04-16 22:20:36 +00:00
|
|
|
static mempool_t *nfs_commit_mempool;
|
|
|
|
|
2022-03-21 16:34:19 +00:00
|
|
|
struct nfs_commit_data *nfs_commitdata_alloc(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
NFS: fix usage of mempools.
When passed GFP flags that allow sleeping (such as
GFP_NOIO), mempool_alloc() will never return NULL, it will
wait until memory is available.
This means that we don't need to handle failure, but that we
do need to ensure one thread doesn't call mempool_alloc()
twice on the one pool without queuing or freeing the first
allocation. If multiple threads did this during times of
high memory pressure, the pool could be exhausted and a
deadlock could result.
pnfs_generic_alloc_ds_commits() attempts to allocate from
the nfs_commit_mempool while already holding an allocation
from that pool. This is not safe. So change
nfs_commitdata_alloc() to take a flag that indicates whether
failure is acceptable.
In pnfs_generic_alloc_ds_commits(), accept failure and
handle it as we currently do. Else where, do not accept
failure, and do not handle it.
Even when failure is acceptable, we want to succeed if
possible. That means both
- using an entry from the pool if there is one
- waiting for direct reclaim is there isn't.
We call mempool_alloc(GFP_NOWAIT) to achieve the first, then
kmem_cache_alloc(GFP_NOIO|__GFP_NORETRY) to achieve the
second. Each of these can fail, but together they do the
best they can without blocking indefinitely.
The objects returned by kmem_cache_alloc() will still be freed
by mempool_free(). This is safe as mempool_alloc() uses
exactly the same function to allocate objects (since the mempool
was created with mempool_create_slab_pool()). The object returned
by mempool_alloc() and kmem_cache_alloc() are indistinguishable
so mempool_free() will handle both identically, either adding to the
pool or calling kmem_cache_free().
Also, don't test for failure when allocating from
nfs_wdata_mempool.
Signed-off-by: NeilBrown <neilb@suse.com>
Signed-off-by: Trond Myklebust <trond.myklebust@primarydata.com>
2017-04-10 02:22:09 +00:00
|
|
|
struct nfs_commit_data *p;
|
2005-11-30 23:09:02 +00:00
|
|
|
|
2022-03-21 16:34:19 +00:00
|
|
|
p = kmem_cache_zalloc(nfs_cdata_cachep, nfs_io_gfp_mask());
|
|
|
|
if (!p) {
|
NFS: fix usage of mempools.
When passed GFP flags that allow sleeping (such as
GFP_NOIO), mempool_alloc() will never return NULL, it will
wait until memory is available.
This means that we don't need to handle failure, but that we
do need to ensure one thread doesn't call mempool_alloc()
twice on the one pool without queuing or freeing the first
allocation. If multiple threads did this during times of
high memory pressure, the pool could be exhausted and a
deadlock could result.
pnfs_generic_alloc_ds_commits() attempts to allocate from
the nfs_commit_mempool while already holding an allocation
from that pool. This is not safe. So change
nfs_commitdata_alloc() to take a flag that indicates whether
failure is acceptable.
In pnfs_generic_alloc_ds_commits(), accept failure and
handle it as we currently do. Else where, do not accept
failure, and do not handle it.
Even when failure is acceptable, we want to succeed if
possible. That means both
- using an entry from the pool if there is one
- waiting for direct reclaim is there isn't.
We call mempool_alloc(GFP_NOWAIT) to achieve the first, then
kmem_cache_alloc(GFP_NOIO|__GFP_NORETRY) to achieve the
second. Each of these can fail, but together they do the
best they can without blocking indefinitely.
The objects returned by kmem_cache_alloc() will still be freed
by mempool_free(). This is safe as mempool_alloc() uses
exactly the same function to allocate objects (since the mempool
was created with mempool_create_slab_pool()). The object returned
by mempool_alloc() and kmem_cache_alloc() are indistinguishable
so mempool_free() will handle both identically, either adding to the
pool or calling kmem_cache_free().
Also, don't test for failure when allocating from
nfs_wdata_mempool.
Signed-off-by: NeilBrown <neilb@suse.com>
Signed-off-by: Trond Myklebust <trond.myklebust@primarydata.com>
2017-04-10 02:22:09 +00:00
|
|
|
p = mempool_alloc(nfs_commit_mempool, GFP_NOWAIT);
|
|
|
|
if (!p)
|
|
|
|
return NULL;
|
2022-03-21 16:34:19 +00:00
|
|
|
memset(p, 0, sizeof(*p));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
NFS: fix usage of mempools.
When passed GFP flags that allow sleeping (such as
GFP_NOIO), mempool_alloc() will never return NULL, it will
wait until memory is available.
This means that we don't need to handle failure, but that we
do need to ensure one thread doesn't call mempool_alloc()
twice on the one pool without queuing or freeing the first
allocation. If multiple threads did this during times of
high memory pressure, the pool could be exhausted and a
deadlock could result.
pnfs_generic_alloc_ds_commits() attempts to allocate from
the nfs_commit_mempool while already holding an allocation
from that pool. This is not safe. So change
nfs_commitdata_alloc() to take a flag that indicates whether
failure is acceptable.
In pnfs_generic_alloc_ds_commits(), accept failure and
handle it as we currently do. Else where, do not accept
failure, and do not handle it.
Even when failure is acceptable, we want to succeed if
possible. That means both
- using an entry from the pool if there is one
- waiting for direct reclaim is there isn't.
We call mempool_alloc(GFP_NOWAIT) to achieve the first, then
kmem_cache_alloc(GFP_NOIO|__GFP_NORETRY) to achieve the
second. Each of these can fail, but together they do the
best they can without blocking indefinitely.
The objects returned by kmem_cache_alloc() will still be freed
by mempool_free(). This is safe as mempool_alloc() uses
exactly the same function to allocate objects (since the mempool
was created with mempool_create_slab_pool()). The object returned
by mempool_alloc() and kmem_cache_alloc() are indistinguishable
so mempool_free() will handle both identically, either adding to the
pool or calling kmem_cache_free().
Also, don't test for failure when allocating from
nfs_wdata_mempool.
Signed-off-by: NeilBrown <neilb@suse.com>
Signed-off-by: Trond Myklebust <trond.myklebust@primarydata.com>
2017-04-10 02:22:09 +00:00
|
|
|
INIT_LIST_HEAD(&p->pages);
|
2005-04-16 22:20:36 +00:00
|
|
|
return p;
|
|
|
|
}
|
2011-03-23 13:27:53 +00:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_commitdata_alloc);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-04-20 18:47:39 +00:00
|
|
|
void nfs_commit_free(struct nfs_commit_data *p)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
mempool_free(p, nfs_commit_mempool);
|
|
|
|
}
|
2011-03-23 13:27:53 +00:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_commit_free);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-06-09 15:48:33 +00:00
|
|
|
static struct nfs_pgio_header *nfs_writehdr_alloc(void)
|
2006-03-20 18:44:37 +00:00
|
|
|
{
|
2022-03-21 17:48:36 +00:00
|
|
|
struct nfs_pgio_header *p;
|
2012-04-20 18:47:44 +00:00
|
|
|
|
2022-03-21 17:48:36 +00:00
|
|
|
p = kmem_cache_zalloc(nfs_wdata_cachep, nfs_io_gfp_mask());
|
|
|
|
if (!p) {
|
|
|
|
p = mempool_alloc(nfs_wdata_mempool, GFP_NOWAIT);
|
|
|
|
if (!p)
|
|
|
|
return NULL;
|
|
|
|
memset(p, 0, sizeof(*p));
|
|
|
|
}
|
2017-08-18 07:12:51 +00:00
|
|
|
p->rw_mode = FMODE_WRITE;
|
2006-03-20 18:44:37 +00:00
|
|
|
return p;
|
|
|
|
}
|
2012-04-20 18:47:47 +00:00
|
|
|
|
2014-06-09 15:48:33 +00:00
|
|
|
static void nfs_writehdr_free(struct nfs_pgio_header *hdr)
|
2006-03-20 18:44:37 +00:00
|
|
|
{
|
2014-06-09 15:48:33 +00:00
|
|
|
mempool_free(hdr, nfs_wdata_mempool);
|
2006-03-20 18:44:37 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-06-20 23:35:37 +00:00
|
|
|
static struct nfs_io_completion *nfs_io_completion_alloc(gfp_t gfp_flags)
|
|
|
|
{
|
|
|
|
return kmalloc(sizeof(struct nfs_io_completion), gfp_flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nfs_io_completion_init(struct nfs_io_completion *ioc,
|
|
|
|
void (*complete)(void *), void *data)
|
|
|
|
{
|
|
|
|
ioc->complete = complete;
|
|
|
|
ioc->data = data;
|
|
|
|
kref_init(&ioc->refcount);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nfs_io_completion_release(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct nfs_io_completion *ioc = container_of(kref,
|
|
|
|
struct nfs_io_completion, refcount);
|
|
|
|
ioc->complete(ioc->data);
|
|
|
|
kfree(ioc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nfs_io_completion_get(struct nfs_io_completion *ioc)
|
|
|
|
{
|
|
|
|
if (ioc != NULL)
|
|
|
|
kref_get(&ioc->refcount);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nfs_io_completion_put(struct nfs_io_completion *ioc)
|
|
|
|
{
|
|
|
|
if (ioc != NULL)
|
|
|
|
kref_put(&ioc->refcount, nfs_io_completion_release);
|
|
|
|
}
|
|
|
|
|
2020-03-30 16:40:47 +00:00
|
|
|
static void
|
|
|
|
nfs_page_set_inode_ref(struct nfs_page *req, struct inode *inode)
|
|
|
|
{
|
|
|
|
if (!test_and_set_bit(PG_INODE_REF, &req->wb_flags)) {
|
|
|
|
kref_get(&req->wb_kref);
|
|
|
|
atomic_long_inc(&NFS_I(inode)->nrequests);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
nfs_cancel_remove_inode(struct nfs_page *req, struct inode *inode)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!test_bit(PG_REMOVE, &req->wb_flags))
|
|
|
|
return 0;
|
|
|
|
ret = nfs_page_group_lock(req);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
if (test_and_clear_bit(PG_REMOVE, &req->wb_flags))
|
|
|
|
nfs_page_set_inode_ref(req, inode);
|
|
|
|
nfs_page_group_unlock(req);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-08-01 16:06:30 +00:00
|
|
|
static struct nfs_page *
|
|
|
|
nfs_page_private_request(struct page *page)
|
|
|
|
{
|
|
|
|
if (!PagePrivate(page))
|
|
|
|
return NULL;
|
|
|
|
return (struct nfs_page *)page_private(page);
|
|
|
|
}
|
|
|
|
|
2014-07-11 14:20:47 +00:00
|
|
|
/*
|
|
|
|
* nfs_page_find_head_request_locked - find head request associated with @page
|
|
|
|
*
|
|
|
|
* must be called while holding the inode lock.
|
|
|
|
*
|
|
|
|
* returns matching head request with reference held, or NULL if not found.
|
|
|
|
*/
|
2012-07-31 23:45:10 +00:00
|
|
|
static struct nfs_page *
|
2017-08-01 16:26:53 +00:00
|
|
|
nfs_page_find_private_request(struct page *page)
|
2006-12-05 05:35:35 +00:00
|
|
|
{
|
2017-08-01 16:34:44 +00:00
|
|
|
struct address_space *mapping = page_file_mapping(page);
|
2017-08-01 16:06:30 +00:00
|
|
|
struct nfs_page *req;
|
2006-12-05 05:35:35 +00:00
|
|
|
|
2017-08-01 16:26:53 +00:00
|
|
|
if (!PagePrivate(page))
|
|
|
|
return NULL;
|
2017-08-01 16:34:44 +00:00
|
|
|
spin_lock(&mapping->private_lock);
|
2017-08-01 16:06:30 +00:00
|
|
|
req = nfs_page_private_request(page);
|
2014-07-11 14:20:47 +00:00
|
|
|
if (req) {
|
|
|
|
WARN_ON_ONCE(req->wb_head != req);
|
2012-07-31 23:45:10 +00:00
|
|
|
kref_get(&req->wb_kref);
|
2014-07-11 14:20:47 +00:00
|
|
|
}
|
2017-08-01 16:34:44 +00:00
|
|
|
spin_unlock(&mapping->private_lock);
|
2017-08-01 16:26:53 +00:00
|
|
|
return req;
|
|
|
|
}
|
2012-07-31 23:45:10 +00:00
|
|
|
|
2017-08-01 16:26:53 +00:00
|
|
|
static struct nfs_page *
|
|
|
|
nfs_page_find_swap_request(struct page *page)
|
|
|
|
{
|
|
|
|
struct inode *inode = page_file_mapping(page)->host;
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
struct nfs_page *req = NULL;
|
|
|
|
if (!PageSwapCache(page))
|
|
|
|
return NULL;
|
2017-08-01 15:53:49 +00:00
|
|
|
mutex_lock(&nfsi->commit_mutex);
|
2017-08-01 16:26:53 +00:00
|
|
|
if (PageSwapCache(page)) {
|
|
|
|
req = nfs_page_search_commits_for_head_request_locked(nfsi,
|
|
|
|
page);
|
|
|
|
if (req) {
|
|
|
|
WARN_ON_ONCE(req->wb_head != req);
|
|
|
|
kref_get(&req->wb_kref);
|
|
|
|
}
|
|
|
|
}
|
2017-08-01 15:53:49 +00:00
|
|
|
mutex_unlock(&nfsi->commit_mutex);
|
2006-12-05 05:35:35 +00:00
|
|
|
return req;
|
|
|
|
}
|
|
|
|
|
2014-07-11 14:20:47 +00:00
|
|
|
/*
|
|
|
|
* nfs_page_find_head_request - find head request associated with @page
|
|
|
|
*
|
|
|
|
* returns matching head request with reference held, or NULL if not found.
|
|
|
|
*/
|
|
|
|
static struct nfs_page *nfs_page_find_head_request(struct page *page)
|
2006-12-05 05:35:35 +00:00
|
|
|
{
|
2017-08-01 16:26:53 +00:00
|
|
|
struct nfs_page *req;
|
2006-12-05 05:35:35 +00:00
|
|
|
|
2017-08-01 16:26:53 +00:00
|
|
|
req = nfs_page_find_private_request(page);
|
|
|
|
if (!req)
|
|
|
|
req = nfs_page_find_swap_request(page);
|
2006-12-05 05:35:35 +00:00
|
|
|
return req;
|
|
|
|
}
|
|
|
|
|
2020-03-30 16:40:47 +00:00
|
|
|
static struct nfs_page *nfs_find_and_lock_page_request(struct page *page)
|
|
|
|
{
|
|
|
|
struct inode *inode = page_file_mapping(page)->host;
|
|
|
|
struct nfs_page *req, *head;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
req = nfs_page_find_head_request(page);
|
|
|
|
if (!req)
|
|
|
|
return req;
|
|
|
|
head = nfs_page_group_lock_head(req);
|
|
|
|
if (head != req)
|
|
|
|
nfs_release_request(req);
|
|
|
|
if (IS_ERR(head))
|
|
|
|
return head;
|
|
|
|
ret = nfs_cancel_remove_inode(head, inode);
|
|
|
|
if (ret < 0) {
|
|
|
|
nfs_unlock_and_release_request(head);
|
|
|
|
return ERR_PTR(ret);
|
|
|
|
}
|
|
|
|
/* Ensure that nobody removed the request before we locked it */
|
|
|
|
if (head == nfs_page_private_request(page))
|
|
|
|
break;
|
|
|
|
if (PageSwapCache(page))
|
|
|
|
break;
|
|
|
|
nfs_unlock_and_release_request(head);
|
|
|
|
}
|
|
|
|
return head;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Adjust the file length if we're writing beyond the end */
|
|
|
|
static void nfs_grow_file(struct page *page, unsigned int offset, unsigned int count)
|
|
|
|
{
|
2012-07-31 23:45:06 +00:00
|
|
|
struct inode *inode = page_file_mapping(page)->host;
|
2008-06-11 16:21:19 +00:00
|
|
|
loff_t end, i_size;
|
|
|
|
pgoff_t end_index;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-06-11 16:21:19 +00:00
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
i_size = i_size_read(inode);
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
end_index = (i_size - 1) >> PAGE_SHIFT;
|
2016-10-08 00:00:24 +00:00
|
|
|
if (i_size > 0 && page_index(page) < end_index)
|
2008-06-11 16:21:19 +00:00
|
|
|
goto out;
|
2012-07-31 23:45:06 +00:00
|
|
|
end = page_file_offset(page) + ((loff_t)offset+count);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (i_size >= end)
|
2008-06-11 16:21:19 +00:00
|
|
|
goto out;
|
2021-10-04 14:10:16 +00:00
|
|
|
trace_nfs_size_grow(inode, end);
|
2005-04-16 22:20:36 +00:00
|
|
|
i_size_write(inode, end);
|
2018-03-27 21:10:42 +00:00
|
|
|
NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_SIZE;
|
2008-06-11 16:21:19 +00:00
|
|
|
nfs_inc_stats(inode, NFSIOS_EXTENDWRITE);
|
|
|
|
out:
|
|
|
|
spin_unlock(&inode->i_lock);
|
nfs: Convert to new fscache volume/cookie API
Change the nfs filesystem to support fscache's indexing rewrite and
reenable caching in nfs.
The following changes have been made:
(1) The fscache_netfs struct is no more, and there's no need to register
the filesystem as a whole.
(2) The session cookie is now an fscache_volume cookie, allocated with
fscache_acquire_volume(). That takes three parameters: a string
representing the "volume" in the index, a string naming the cache to
use (or NULL) and a u64 that conveys coherency metadata for the
volume.
For nfs, I've made it render the volume name string as:
"nfs,<ver>,<family>,<address>,<port>,<fsidH>,<fsidL>*<,param>[,<uniq>]"
(3) The fscache_cookie_def is no more and needed information is passed
directly to fscache_acquire_cookie(). The cache no longer calls back
into the filesystem, but rather metadata changes are indicated at
other times.
fscache_acquire_cookie() is passed the same keying and coherency
information as before.
(4) fscache_enable/disable_cookie() have been removed.
Call fscache_use_cookie() and fscache_unuse_cookie() when a file is
opened or closed to prevent a cache file from being culled and to keep
resources to hand that are needed to do I/O.
If a file is opened for writing, we invalidate it with
FSCACHE_INVAL_DIO_WRITE in lieu of doing writeback to the cache,
thereby making it cease caching until all currently open files are
closed. This should give the same behaviour as the uptream code.
Making the cache store local modifications isn't straightforward for
NFS, so that's left for future patches.
(5) fscache_invalidate() now needs to be given uptodate auxiliary data and
a file size. It also takes a flag to indicate if this was due to a
DIO write.
(6) Call nfs_fscache_invalidate() with FSCACHE_INVAL_DIO_WRITE on a file
to which a DIO write is made.
(7) Call fscache_note_page_release() from nfs_release_page().
(8) Use a killable wait in nfs_vm_page_mkwrite() when waiting for
PG_fscache to be cleared.
(9) The functions to read and write data to/from the cache are stubbed out
pending a conversion to use netfslib.
Changes
=======
ver #3:
- Added missing =n fallback for nfs_fscache_release_file()[1][2].
ver #2:
- Use gfpflags_allow_blocking() rather than using flag directly.
- fscache_acquire_volume() now returns errors.
- Remove NFS_INO_FSCACHE as it's no longer used.
- Need to unuse a cookie on file-release, not inode-clear.
Signed-off-by: Dave Wysochanski <dwysocha@redhat.com>
Co-developed-by: David Howells <dhowells@redhat.com>
Signed-off-by: David Howells <dhowells@redhat.com>
Tested-by: Dave Wysochanski <dwysocha@redhat.com>
Acked-by: Jeff Layton <jlayton@kernel.org>
cc: Trond Myklebust <trond.myklebust@hammerspace.com>
cc: Anna Schumaker <anna.schumaker@netapp.com>
cc: linux-nfs@vger.kernel.org
cc: linux-cachefs@redhat.com
Link: https://lore.kernel.org/r/202112100804.nksO8K4u-lkp@intel.com/ [1]
Link: https://lore.kernel.org/r/202112100957.2oEDT20W-lkp@intel.com/ [2]
Link: https://lore.kernel.org/r/163819668938.215744.14448852181937731615.stgit@warthog.procyon.org.uk/ # v1
Link: https://lore.kernel.org/r/163906979003.143852.2601189243864854724.stgit@warthog.procyon.org.uk/ # v2
Link: https://lore.kernel.org/r/163967182112.1823006.7791504655391213379.stgit@warthog.procyon.org.uk/ # v3
Link: https://lore.kernel.org/r/164021575950.640689.12069642327533368467.stgit@warthog.procyon.org.uk/ # v4
2020-11-14 18:43:54 +00:00
|
|
|
nfs_fscache_invalidate(inode, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-02-06 19:07:15 +00:00
|
|
|
/* A writeback failed: mark the page as bad, and invalidate the page cache */
|
2019-02-06 11:09:43 +00:00
|
|
|
static void nfs_set_pageerror(struct address_space *mapping)
|
2007-02-06 19:07:15 +00:00
|
|
|
{
|
2020-01-06 20:25:00 +00:00
|
|
|
struct inode *inode = mapping->host;
|
|
|
|
|
2019-02-06 11:09:43 +00:00
|
|
|
nfs_zap_mapping(mapping->host, mapping);
|
2020-01-06 20:25:00 +00:00
|
|
|
/* Force file size revalidation */
|
|
|
|
spin_lock(&inode->i_lock);
|
2021-03-08 19:42:54 +00:00
|
|
|
nfs_set_cache_invalid(inode, NFS_INO_REVAL_FORCED |
|
2022-02-09 18:22:48 +00:00
|
|
|
NFS_INO_INVALID_CHANGE |
|
2021-03-08 19:42:54 +00:00
|
|
|
NFS_INO_INVALID_SIZE);
|
2020-01-06 20:25:00 +00:00
|
|
|
spin_unlock(&inode->i_lock);
|
2007-02-06 19:07:15 +00:00
|
|
|
}
|
|
|
|
|
2019-04-07 17:59:05 +00:00
|
|
|
static void nfs_mapping_set_error(struct page *page, int error)
|
|
|
|
{
|
2020-01-06 20:25:01 +00:00
|
|
|
struct address_space *mapping = page_file_mapping(page);
|
|
|
|
|
2019-04-07 17:59:05 +00:00
|
|
|
SetPageError(page);
|
2022-02-15 20:58:38 +00:00
|
|
|
filemap_set_wb_err(mapping, error);
|
|
|
|
if (mapping->host)
|
|
|
|
errseq_set(&mapping->host->i_sb->s_wb_err,
|
|
|
|
error == -ENOSPC ? -ENOSPC : -EIO);
|
2020-01-06 20:25:01 +00:00
|
|
|
nfs_set_pageerror(mapping);
|
2019-04-07 17:59:05 +00:00
|
|
|
}
|
|
|
|
|
2014-05-15 15:56:48 +00:00
|
|
|
/*
|
|
|
|
* nfs_page_group_search_locked
|
|
|
|
* @head - head request of page group
|
|
|
|
* @page_offset - offset into page
|
|
|
|
*
|
|
|
|
* Search page group with head @head to find a request that contains the
|
|
|
|
* page offset @page_offset.
|
|
|
|
*
|
|
|
|
* Returns a pointer to the first matching nfs request, or NULL if no
|
|
|
|
* match is found.
|
|
|
|
*
|
|
|
|
* Must be called with the page group lock held
|
|
|
|
*/
|
|
|
|
static struct nfs_page *
|
|
|
|
nfs_page_group_search_locked(struct nfs_page *head, unsigned int page_offset)
|
|
|
|
{
|
|
|
|
struct nfs_page *req;
|
|
|
|
|
|
|
|
req = head;
|
|
|
|
do {
|
|
|
|
if (page_offset >= req->wb_pgbase &&
|
|
|
|
page_offset < (req->wb_pgbase + req->wb_bytes))
|
|
|
|
return req;
|
|
|
|
|
|
|
|
req = req->wb_this_page;
|
|
|
|
} while (req != head);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs_page_group_covers_page
|
|
|
|
* @head - head request of page group
|
|
|
|
*
|
|
|
|
* Return true if the page group with head @head covers the whole page,
|
|
|
|
* returns false otherwise
|
|
|
|
*/
|
|
|
|
static bool nfs_page_group_covers_page(struct nfs_page *req)
|
|
|
|
{
|
|
|
|
struct nfs_page *tmp;
|
|
|
|
unsigned int pos = 0;
|
|
|
|
unsigned int len = nfs_page_length(req->wb_page);
|
|
|
|
|
2017-07-17 14:54:14 +00:00
|
|
|
nfs_page_group_lock(req);
|
2014-05-15 15:56:48 +00:00
|
|
|
|
2017-07-17 20:58:07 +00:00
|
|
|
for (;;) {
|
2014-05-15 15:56:48 +00:00
|
|
|
tmp = nfs_page_group_search_locked(req->wb_head, pos);
|
2017-07-17 20:58:07 +00:00
|
|
|
if (!tmp)
|
|
|
|
break;
|
|
|
|
pos = tmp->wb_pgbase + tmp->wb_bytes;
|
|
|
|
}
|
2014-05-15 15:56:48 +00:00
|
|
|
|
|
|
|
nfs_page_group_unlock(req);
|
2017-07-17 20:58:07 +00:00
|
|
|
return pos >= len;
|
2014-05-15 15:56:48 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* We can set the PG_uptodate flag if we see that a write request
|
|
|
|
* covers the full page.
|
|
|
|
*/
|
2014-05-15 15:56:48 +00:00
|
|
|
static void nfs_mark_uptodate(struct nfs_page *req)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2014-05-15 15:56:48 +00:00
|
|
|
if (PageUptodate(req->wb_page))
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
2014-05-15 15:56:48 +00:00
|
|
|
if (!nfs_page_group_covers_page(req))
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
2014-05-15 15:56:48 +00:00
|
|
|
SetPageUptodate(req->wb_page);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int wb_priority(struct writeback_control *wbc)
|
|
|
|
{
|
2014-09-18 06:09:27 +00:00
|
|
|
int ret = 0;
|
2016-05-16 21:42:45 +00:00
|
|
|
|
2014-09-18 06:09:27 +00:00
|
|
|
if (wbc->sync_mode == WB_SYNC_ALL)
|
|
|
|
ret = FLUSH_COND_STABLE;
|
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-03-16 21:38:26 +00:00
|
|
|
/*
|
|
|
|
* NFS congestion control
|
|
|
|
*/
|
|
|
|
|
|
|
|
int nfs_congestion_kb;
|
|
|
|
|
|
|
|
#define NFS_CONGESTION_ON_THRESH (nfs_congestion_kb >> (PAGE_SHIFT-10))
|
|
|
|
#define NFS_CONGESTION_OFF_THRESH \
|
|
|
|
(NFS_CONGESTION_ON_THRESH - (NFS_CONGESTION_ON_THRESH >> 2))
|
|
|
|
|
2012-10-15 19:02:01 +00:00
|
|
|
static void nfs_set_page_writeback(struct page *page)
|
2007-03-16 21:38:26 +00:00
|
|
|
{
|
2017-04-12 10:24:45 +00:00
|
|
|
struct inode *inode = page_file_mapping(page)->host;
|
|
|
|
struct nfs_server *nfss = NFS_SERVER(inode);
|
2007-04-14 23:10:12 +00:00
|
|
|
int ret = test_set_page_writeback(page);
|
|
|
|
|
2012-10-15 19:02:01 +00:00
|
|
|
WARN_ON_ONCE(ret != 0);
|
2007-03-16 21:38:26 +00:00
|
|
|
|
2012-10-15 19:02:01 +00:00
|
|
|
if (atomic_long_inc_return(&nfss->writeback) >
|
2017-04-12 10:24:45 +00:00
|
|
|
NFS_CONGESTION_ON_THRESH)
|
2022-03-22 21:39:01 +00:00
|
|
|
nfss->write_congested = 1;
|
2007-03-16 21:38:26 +00:00
|
|
|
}
|
|
|
|
|
2014-05-15 15:56:47 +00:00
|
|
|
static void nfs_end_page_writeback(struct nfs_page *req)
|
2007-03-16 21:38:26 +00:00
|
|
|
{
|
2014-05-15 15:56:47 +00:00
|
|
|
struct inode *inode = page_file_mapping(req->wb_page)->host;
|
2007-03-16 21:38:26 +00:00
|
|
|
struct nfs_server *nfss = NFS_SERVER(inode);
|
2017-07-18 23:18:49 +00:00
|
|
|
bool is_done;
|
2007-03-16 21:38:26 +00:00
|
|
|
|
2017-07-18 23:18:49 +00:00
|
|
|
is_done = nfs_page_group_sync_on_bit(req, PG_WB_END);
|
|
|
|
nfs_unlock_request(req);
|
|
|
|
if (!is_done)
|
2014-05-15 15:56:47 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
end_page_writeback(req->wb_page);
|
2007-10-17 06:25:41 +00:00
|
|
|
if (atomic_long_dec_return(&nfss->writeback) < NFS_CONGESTION_OFF_THRESH)
|
2022-03-22 21:39:01 +00:00
|
|
|
nfss->write_congested = 0;
|
2007-03-16 21:38:26 +00:00
|
|
|
}
|
|
|
|
|
2014-07-11 14:20:48 +00:00
|
|
|
/*
|
|
|
|
* nfs_destroy_unlinked_subrequests - destroy recently unlinked subrequests
|
|
|
|
*
|
|
|
|
* @destroy_list - request list (using wb_this_page) terminated by @old_head
|
|
|
|
* @old_head - the old head of the list
|
|
|
|
*
|
|
|
|
* All subrequests must be locked and removed from all lists, so at this point
|
|
|
|
* they are only "active" in this function, and possibly in nfs_wait_on_request
|
|
|
|
* with a reference held by some other context.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
nfs_destroy_unlinked_subrequests(struct nfs_page *destroy_list,
|
2017-07-18 19:22:12 +00:00
|
|
|
struct nfs_page *old_head,
|
|
|
|
struct inode *inode)
|
2014-07-11 14:20:48 +00:00
|
|
|
{
|
|
|
|
while (destroy_list) {
|
|
|
|
struct nfs_page *subreq = destroy_list;
|
|
|
|
|
|
|
|
destroy_list = (subreq->wb_this_page == old_head) ?
|
|
|
|
NULL : subreq->wb_this_page;
|
|
|
|
|
2020-04-01 17:04:49 +00:00
|
|
|
/* Note: lock subreq in order to change subreq->wb_head */
|
|
|
|
nfs_page_set_headlock(subreq);
|
2014-07-11 14:20:48 +00:00
|
|
|
WARN_ON_ONCE(old_head != subreq->wb_head);
|
|
|
|
|
|
|
|
/* make sure old group is not used */
|
|
|
|
subreq->wb_this_page = subreq;
|
2020-04-01 17:04:49 +00:00
|
|
|
subreq->wb_head = subreq;
|
2014-07-11 14:20:48 +00:00
|
|
|
|
2017-07-19 17:50:07 +00:00
|
|
|
clear_bit(PG_REMOVE, &subreq->wb_flags);
|
|
|
|
|
2017-07-19 14:06:36 +00:00
|
|
|
/* Note: races with nfs_page_group_destroy() */
|
|
|
|
if (!kref_read(&subreq->wb_kref)) {
|
|
|
|
/* Check if we raced with nfs_page_group_destroy() */
|
2020-04-01 17:04:49 +00:00
|
|
|
if (test_and_clear_bit(PG_TEARDOWN, &subreq->wb_flags)) {
|
|
|
|
nfs_page_clear_headlock(subreq);
|
2017-07-19 14:06:36 +00:00
|
|
|
nfs_free_request(subreq);
|
2020-04-01 17:04:49 +00:00
|
|
|
} else
|
|
|
|
nfs_page_clear_headlock(subreq);
|
2017-07-19 14:06:36 +00:00
|
|
|
continue;
|
|
|
|
}
|
2020-04-01 17:04:49 +00:00
|
|
|
nfs_page_clear_headlock(subreq);
|
2014-07-11 14:20:48 +00:00
|
|
|
|
2020-04-01 14:07:16 +00:00
|
|
|
nfs_release_request(old_head);
|
2017-07-19 14:06:36 +00:00
|
|
|
|
|
|
|
if (test_and_clear_bit(PG_INODE_REF, &subreq->wb_flags)) {
|
|
|
|
nfs_release_request(subreq);
|
2017-08-01 19:39:46 +00:00
|
|
|
atomic_long_dec(&NFS_I(inode)->nrequests);
|
2014-07-11 14:20:48 +00:00
|
|
|
}
|
2017-07-19 14:06:36 +00:00
|
|
|
|
|
|
|
/* subreq is now totally disconnected from page group or any
|
|
|
|
* write / commit lists. last chance to wake any waiters */
|
|
|
|
nfs_unlock_and_release_request(subreq);
|
2014-07-11 14:20:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2020-03-30 16:40:47 +00:00
|
|
|
* nfs_join_page_group - destroy subrequests of the head req
|
|
|
|
* @head: the page used to lookup the "page group" of nfs_page structures
|
|
|
|
* @inode: Inode to which the request belongs.
|
2014-07-11 14:20:48 +00:00
|
|
|
*
|
|
|
|
* This function joins all sub requests to the head request by first
|
|
|
|
* locking all requests in the group, cancelling any pending operations
|
|
|
|
* and finally updating the head request to cover the whole range covered by
|
|
|
|
* the (former) group. All subrequests are removed from any write or commit
|
|
|
|
* lists, unlinked from the group and destroyed.
|
|
|
|
*/
|
2020-03-31 00:57:49 +00:00
|
|
|
void
|
2020-03-30 16:40:47 +00:00
|
|
|
nfs_join_page_group(struct nfs_page *head, struct inode *inode)
|
2006-12-05 05:35:41 +00:00
|
|
|
{
|
2020-03-30 16:40:47 +00:00
|
|
|
struct nfs_page *subreq;
|
2014-07-11 14:20:48 +00:00
|
|
|
struct nfs_page *destroy_list = NULL;
|
2020-03-30 15:12:16 +00:00
|
|
|
unsigned int pgbase, off, bytes;
|
|
|
|
|
|
|
|
pgbase = head->wb_pgbase;
|
|
|
|
bytes = head->wb_bytes;
|
|
|
|
off = head->wb_offset;
|
2017-07-17 14:29:32 +00:00
|
|
|
for (subreq = head->wb_this_page; subreq != head;
|
|
|
|
subreq = subreq->wb_this_page) {
|
2020-03-30 15:12:16 +00:00
|
|
|
/* Subrequests should always form a contiguous range */
|
|
|
|
if (pgbase > subreq->wb_pgbase) {
|
|
|
|
off -= pgbase - subreq->wb_pgbase;
|
|
|
|
bytes += pgbase - subreq->wb_pgbase;
|
|
|
|
pgbase = subreq->wb_pgbase;
|
2014-09-05 20:34:29 +00:00
|
|
|
}
|
2020-03-30 15:12:16 +00:00
|
|
|
bytes = max(subreq->wb_pgbase + subreq->wb_bytes
|
|
|
|
- pgbase, bytes);
|
2017-07-17 14:29:32 +00:00
|
|
|
}
|
2014-07-11 14:20:48 +00:00
|
|
|
|
2020-03-30 15:12:16 +00:00
|
|
|
/* Set the head request's range to cover the former page group */
|
|
|
|
head->wb_pgbase = pgbase;
|
|
|
|
head->wb_bytes = bytes;
|
|
|
|
head->wb_offset = off;
|
|
|
|
|
2014-07-11 14:20:48 +00:00
|
|
|
/* Now that all requests are locked, make sure they aren't on any list.
|
|
|
|
* Commit list removal accounting is done after locks are dropped */
|
|
|
|
subreq = head;
|
|
|
|
do {
|
2014-07-18 00:42:19 +00:00
|
|
|
nfs_clear_request_commit(subreq);
|
2014-07-11 14:20:48 +00:00
|
|
|
subreq = subreq->wb_this_page;
|
|
|
|
} while (subreq != head);
|
|
|
|
|
|
|
|
/* unlink subrequests from head, destroy them later */
|
|
|
|
if (head->wb_this_page != head) {
|
|
|
|
/* destroy list will be terminated by head */
|
|
|
|
destroy_list = head->wb_this_page;
|
|
|
|
head->wb_this_page = head;
|
2006-12-05 05:35:41 +00:00
|
|
|
}
|
2014-07-11 14:20:48 +00:00
|
|
|
|
2020-03-30 16:40:47 +00:00
|
|
|
nfs_destroy_unlinked_subrequests(destroy_list, head, inode);
|
|
|
|
}
|
2017-07-18 19:22:12 +00:00
|
|
|
|
2020-03-30 16:40:47 +00:00
|
|
|
/*
|
|
|
|
* nfs_lock_and_join_requests - join all subreqs to the head req
|
|
|
|
* @page: the page used to lookup the "page group" of nfs_page structures
|
|
|
|
*
|
|
|
|
* This function joins all sub requests to the head request by first
|
|
|
|
* locking all requests in the group, cancelling any pending operations
|
|
|
|
* and finally updating the head request to cover the whole range covered by
|
|
|
|
* the (former) group. All subrequests are removed from any write or commit
|
|
|
|
* lists, unlinked from the group and destroyed.
|
|
|
|
*
|
|
|
|
* Returns a locked, referenced pointer to the head request - which after
|
|
|
|
* this call is guaranteed to be the only request associated with the page.
|
|
|
|
* Returns NULL if no requests are found for @page, or a ERR_PTR if an
|
|
|
|
* error was encountered.
|
|
|
|
*/
|
|
|
|
static struct nfs_page *
|
|
|
|
nfs_lock_and_join_requests(struct page *page)
|
|
|
|
{
|
|
|
|
struct inode *inode = page_file_mapping(page)->host;
|
|
|
|
struct nfs_page *head;
|
|
|
|
int ret;
|
2014-07-11 14:20:48 +00:00
|
|
|
|
2020-03-30 16:40:47 +00:00
|
|
|
/*
|
|
|
|
* A reference is taken only on the head request which acts as a
|
|
|
|
* reference to the whole page group - the group will not be destroyed
|
|
|
|
* until the head reference is released.
|
|
|
|
*/
|
|
|
|
head = nfs_find_and_lock_page_request(page);
|
|
|
|
if (IS_ERR_OR_NULL(head))
|
|
|
|
return head;
|
2014-07-11 14:20:48 +00:00
|
|
|
|
2020-03-30 16:40:47 +00:00
|
|
|
/* lock each request in the page group */
|
|
|
|
ret = nfs_page_group_lock_subrequests(head);
|
|
|
|
if (ret < 0) {
|
2017-07-17 14:34:21 +00:00
|
|
|
nfs_unlock_and_release_request(head);
|
2020-03-30 16:40:47 +00:00
|
|
|
return ERR_PTR(ret);
|
2017-07-17 14:34:21 +00:00
|
|
|
}
|
|
|
|
|
2020-03-30 16:40:47 +00:00
|
|
|
nfs_join_page_group(head, inode);
|
2017-11-07 07:51:00 +00:00
|
|
|
|
2020-03-30 16:40:47 +00:00
|
|
|
return head;
|
2009-08-10 12:54:13 +00:00
|
|
|
}
|
|
|
|
|
2019-04-07 17:59:05 +00:00
|
|
|
static void nfs_write_error(struct nfs_page *req, int error)
|
2015-12-05 07:57:31 +00:00
|
|
|
{
|
2022-08-09 16:50:28 +00:00
|
|
|
trace_nfs_write_error(page_file_mapping(req->wb_page)->host, req,
|
|
|
|
error);
|
2019-04-07 17:59:05 +00:00
|
|
|
nfs_mapping_set_error(req->wb_page, error);
|
2019-08-14 19:42:43 +00:00
|
|
|
nfs_inode_remove_request(req);
|
2015-12-05 07:57:31 +00:00
|
|
|
nfs_end_page_writeback(req);
|
2017-04-14 18:24:28 +00:00
|
|
|
nfs_release_request(req);
|
2015-12-05 07:57:31 +00:00
|
|
|
}
|
|
|
|
|
2009-08-10 12:54:13 +00:00
|
|
|
/*
|
|
|
|
* Find an associated nfs write request, and prepare to flush it out
|
|
|
|
* May return an error if the user signalled nfs_wait_on_request().
|
|
|
|
*/
|
2022-05-14 14:08:12 +00:00
|
|
|
static int nfs_page_async_flush(struct page *page,
|
|
|
|
struct writeback_control *wbc,
|
|
|
|
struct nfs_pageio_descriptor *pgio)
|
2009-08-10 12:54:13 +00:00
|
|
|
{
|
|
|
|
struct nfs_page *req;
|
|
|
|
int ret = 0;
|
|
|
|
|
2017-07-09 17:45:27 +00:00
|
|
|
req = nfs_lock_and_join_requests(page);
|
2009-08-10 12:54:13 +00:00
|
|
|
if (!req)
|
|
|
|
goto out;
|
|
|
|
ret = PTR_ERR(req);
|
|
|
|
if (IS_ERR(req))
|
|
|
|
goto out;
|
|
|
|
|
2012-10-15 19:02:01 +00:00
|
|
|
nfs_set_page_writeback(page);
|
|
|
|
WARN_ON_ONCE(test_bit(PG_CLEAN, &req->wb_flags));
|
2009-08-10 12:54:13 +00:00
|
|
|
|
2017-04-25 16:06:00 +00:00
|
|
|
/* If there is a fatal error that covers this write, just exit */
|
2019-08-24 14:39:00 +00:00
|
|
|
ret = pgio->pg_error;
|
|
|
|
if (nfs_error_is_fatal_on_server(ret))
|
2017-04-25 16:06:00 +00:00
|
|
|
goto out_launder;
|
|
|
|
|
2019-08-24 14:39:00 +00:00
|
|
|
ret = 0;
|
nfs: don't ignore return value from nfs_pageio_add_request
Ignoring the return value from nfs_pageio_add_request can cause deadlocks.
In read path:
call nfs_pageio_add_request from readpage_async_filler
assume at this point that there are requests already in desc, that
can't be merged with the current request.
so nfs_pageio_doio is fired up to clear out desc.
assume something goes wrong in setting up the io, so desc->pg_error is set.
This causes nfs_pageio_add_request to return 0, *WITHOUT* adding the original
request.
BUT, since return code is ignored, readpage_async_filler assumes it has
been added, and does nothing further, leaving page locked.
do_generic_mapping_read will eventually call lock_page, resulting in deadlock
In write path:
page is marked dirty by generic_perform_write
nfs_writepages is called
call nfs_pageio_add_request from nfs_page_async_flush
assume at this point that there are requests already in desc, that
can't be merged with the current request.
so nfs_pageio_doio is fired up to clear out desc.
assume something goes wrong in setting up the io, so desc->pg_error is set.
This causes nfs_page_async_flush to return 0, *WITHOUT* adding the original
request, yet marking the request as locked (PG_BUSY) and in writeback,
clearing dirty marks.
The next time a write is done to the page, deadlock will result as
nfs_write_end calls nfs_update_request
Signed-off-by: Fred Isaman <iisaman@citi.umich.edu>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2008-03-19 15:24:39 +00:00
|
|
|
if (!nfs_pageio_add_request(pgio, req)) {
|
2009-08-10 12:54:13 +00:00
|
|
|
ret = pgio->pg_error;
|
2015-12-05 07:57:31 +00:00
|
|
|
/*
|
2017-04-26 16:26:22 +00:00
|
|
|
* Remove the problematic req upon fatal errors on the server
|
2015-12-05 07:57:31 +00:00
|
|
|
*/
|
2022-05-14 14:08:12 +00:00
|
|
|
if (nfs_error_is_fatal_on_server(ret))
|
|
|
|
goto out_launder;
|
|
|
|
if (wbc->sync_mode == WB_SYNC_NONE)
|
|
|
|
ret = AOP_WRITEPAGE_ACTIVATE;
|
|
|
|
redirty_page_for_writepage(wbc, page);
|
2015-12-05 08:20:43 +00:00
|
|
|
nfs_redirty_request(req);
|
2019-08-24 14:39:00 +00:00
|
|
|
pgio->pg_error = 0;
|
2015-10-01 15:36:38 +00:00
|
|
|
} else
|
|
|
|
nfs_add_stats(page_file_mapping(page)->host,
|
|
|
|
NFSIOS_WRITEPAGES, 1);
|
2009-08-10 12:54:13 +00:00
|
|
|
out:
|
|
|
|
return ret;
|
2017-04-25 16:06:00 +00:00
|
|
|
out_launder:
|
2019-04-07 17:59:05 +00:00
|
|
|
nfs_write_error(req, ret);
|
2019-04-07 17:59:02 +00:00
|
|
|
return 0;
|
2006-12-05 05:35:41 +00:00
|
|
|
}
|
|
|
|
|
2015-12-05 08:20:43 +00:00
|
|
|
static int nfs_do_writepage(struct page *page, struct writeback_control *wbc,
|
2017-04-26 16:26:22 +00:00
|
|
|
struct nfs_pageio_descriptor *pgio)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-10-08 00:00:24 +00:00
|
|
|
nfs_pageio_cond_complete(pgio, page_index(page));
|
2022-05-14 14:08:12 +00:00
|
|
|
return nfs_page_async_flush(page, wbc, pgio);
|
2007-07-22 23:27:32 +00:00
|
|
|
}
|
2007-05-20 14:18:27 +00:00
|
|
|
|
2007-07-22 23:27:32 +00:00
|
|
|
/*
|
|
|
|
* Write an mmapped page to the server.
|
|
|
|
*/
|
2015-12-05 08:20:43 +00:00
|
|
|
static int nfs_writepage_locked(struct page *page,
|
2017-04-26 16:26:22 +00:00
|
|
|
struct writeback_control *wbc)
|
2007-07-22 23:27:32 +00:00
|
|
|
{
|
|
|
|
struct nfs_pageio_descriptor pgio;
|
2015-10-01 15:36:38 +00:00
|
|
|
struct inode *inode = page_file_mapping(page)->host;
|
2007-07-22 23:27:32 +00:00
|
|
|
int err;
|
2006-12-05 05:35:38 +00:00
|
|
|
|
2022-03-22 21:39:01 +00:00
|
|
|
if (wbc->sync_mode == WB_SYNC_NONE &&
|
|
|
|
NFS_SERVER(inode)->write_congested)
|
|
|
|
return AOP_WRITEPAGE_ACTIVATE;
|
|
|
|
|
2015-10-01 15:36:38 +00:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGE);
|
2016-06-01 22:25:56 +00:00
|
|
|
nfs_pageio_init_write(&pgio, inode, 0,
|
2014-04-16 13:07:21 +00:00
|
|
|
false, &nfs_async_write_completion_ops);
|
2017-04-26 16:26:22 +00:00
|
|
|
err = nfs_do_writepage(page, wbc, &pgio);
|
2019-08-24 14:39:00 +00:00
|
|
|
pgio.pg_error = 0;
|
2007-07-22 23:27:32 +00:00
|
|
|
nfs_pageio_complete(&pgio);
|
2022-05-14 14:27:04 +00:00
|
|
|
return err;
|
2006-12-05 05:35:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int nfs_writepage(struct page *page, struct writeback_control *wbc)
|
|
|
|
{
|
2007-07-22 23:27:32 +00:00
|
|
|
int ret;
|
2006-12-05 05:35:41 +00:00
|
|
|
|
2017-04-26 16:26:22 +00:00
|
|
|
ret = nfs_writepage_locked(page, wbc);
|
2019-08-24 14:39:00 +00:00
|
|
|
if (ret != AOP_WRITEPAGE_ACTIVATE)
|
|
|
|
unlock_page(page);
|
2007-07-22 23:27:32 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nfs_writepages_callback(struct page *page, struct writeback_control *wbc, void *data)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2017-04-26 16:26:22 +00:00
|
|
|
ret = nfs_do_writepage(page, wbc, data);
|
2019-08-24 14:39:00 +00:00
|
|
|
if (ret != AOP_WRITEPAGE_ACTIVATE)
|
|
|
|
unlock_page(page);
|
2007-07-22 23:27:32 +00:00
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2017-06-20 23:35:37 +00:00
|
|
|
static void nfs_io_completion_commit(void *inode)
|
|
|
|
{
|
|
|
|
nfs_commit_inode(inode, 0);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
int nfs_writepages(struct address_space *mapping, struct writeback_control *wbc)
|
|
|
|
{
|
|
|
|
struct inode *inode = mapping->host;
|
2007-04-02 23:29:52 +00:00
|
|
|
struct nfs_pageio_descriptor pgio;
|
2021-02-12 21:49:48 +00:00
|
|
|
struct nfs_io_completion *ioc = NULL;
|
|
|
|
unsigned int mntflags = NFS_SERVER(inode)->flags;
|
|
|
|
int priority = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
int err;
|
|
|
|
|
2022-03-22 21:39:01 +00:00
|
|
|
if (wbc->sync_mode == WB_SYNC_NONE &&
|
|
|
|
NFS_SERVER(inode)->write_congested)
|
|
|
|
return 0;
|
|
|
|
|
2006-03-20 18:44:14 +00:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGES);
|
|
|
|
|
2021-02-12 21:49:48 +00:00
|
|
|
if (!(mntflags & NFS_MOUNT_WRITE_EAGER) || wbc->for_kupdate ||
|
|
|
|
wbc->for_background || wbc->for_sync || wbc->for_reclaim) {
|
|
|
|
ioc = nfs_io_completion_alloc(GFP_KERNEL);
|
|
|
|
if (ioc)
|
|
|
|
nfs_io_completion_init(ioc, nfs_io_completion_commit,
|
|
|
|
inode);
|
|
|
|
priority = wb_priority(wbc);
|
|
|
|
}
|
2017-06-20 23:35:37 +00:00
|
|
|
|
2022-05-14 14:08:12 +00:00
|
|
|
do {
|
|
|
|
nfs_pageio_init_write(&pgio, inode, priority, false,
|
|
|
|
&nfs_async_write_completion_ops);
|
|
|
|
pgio.pg_io_completion = ioc;
|
|
|
|
err = write_cache_pages(mapping, wbc, nfs_writepages_callback,
|
|
|
|
&pgio);
|
|
|
|
pgio.pg_error = 0;
|
|
|
|
nfs_pageio_complete(&pgio);
|
|
|
|
} while (err < 0 && !nfs_error_is_fatal(err));
|
2017-06-20 23:35:37 +00:00
|
|
|
nfs_io_completion_put(ioc);
|
2009-03-11 18:10:30 +00:00
|
|
|
|
2007-07-22 23:27:32 +00:00
|
|
|
if (err < 0)
|
2009-03-11 18:10:30 +00:00
|
|
|
goto out_err;
|
2007-04-02 23:29:52 +00:00
|
|
|
return 0;
|
2009-03-11 18:10:30 +00:00
|
|
|
out_err:
|
|
|
|
return err;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Insert a write request into an inode
|
|
|
|
*/
|
2012-03-08 22:29:35 +00:00
|
|
|
static void nfs_inode_add_request(struct inode *inode, struct nfs_page *req)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-08-01 16:34:44 +00:00
|
|
|
struct address_space *mapping = page_file_mapping(req->wb_page);
|
2005-04-16 22:20:36 +00:00
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
2008-06-13 16:12:32 +00:00
|
|
|
|
2014-05-15 15:56:45 +00:00
|
|
|
WARN_ON_ONCE(req->wb_this_page != req);
|
|
|
|
|
2008-06-13 16:12:32 +00:00
|
|
|
/* Lock the request! */
|
2012-05-09 17:19:15 +00:00
|
|
|
nfs_lock_request(req);
|
2008-06-13 16:12:32 +00:00
|
|
|
|
2012-07-31 23:45:10 +00:00
|
|
|
/*
|
|
|
|
* Swap-space should not get truncated. Hence no need to plug the race
|
|
|
|
* with invalidate/truncate.
|
|
|
|
*/
|
2017-08-01 16:34:44 +00:00
|
|
|
spin_lock(&mapping->private_lock);
|
2012-07-31 23:45:10 +00:00
|
|
|
if (likely(!PageSwapCache(req->wb_page))) {
|
|
|
|
set_bit(PG_MAPPED, &req->wb_flags);
|
|
|
|
SetPagePrivate(req->wb_page);
|
|
|
|
set_page_private(req->wb_page, (unsigned long)req);
|
|
|
|
}
|
2017-08-01 16:34:44 +00:00
|
|
|
spin_unlock(&mapping->private_lock);
|
2017-08-01 19:39:46 +00:00
|
|
|
atomic_long_inc(&nfsi->nrequests);
|
2014-07-11 14:20:45 +00:00
|
|
|
/* this a head request for a page group - mark it as having an
|
2014-11-12 17:08:00 +00:00
|
|
|
* extra reference so sub groups can follow suit.
|
|
|
|
* This flag also informs pgio layer when to bump nrequests when
|
|
|
|
* adding subrequests. */
|
2014-07-11 14:20:45 +00:00
|
|
|
WARN_ON(test_and_set_bit(PG_INODE_REF, &req->wb_flags));
|
2007-06-17 17:26:38 +00:00
|
|
|
kref_get(&req->wb_kref);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2007-03-16 21:38:26 +00:00
|
|
|
* Remove a write request from an inode
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
static void nfs_inode_remove_request(struct nfs_page *req)
|
|
|
|
{
|
2017-08-01 16:34:44 +00:00
|
|
|
struct address_space *mapping = page_file_mapping(req->wb_page);
|
|
|
|
struct inode *inode = mapping->host;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
2014-05-15 15:56:47 +00:00
|
|
|
struct nfs_page *head;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-05-15 15:56:47 +00:00
|
|
|
if (nfs_page_group_sync_on_bit(req, PG_REMOVE)) {
|
|
|
|
head = req->wb_head;
|
|
|
|
|
2017-08-01 16:34:44 +00:00
|
|
|
spin_lock(&mapping->private_lock);
|
2016-01-19 19:37:30 +00:00
|
|
|
if (likely(head->wb_page && !PageSwapCache(head->wb_page))) {
|
2014-05-15 15:56:47 +00:00
|
|
|
set_page_private(head->wb_page, 0);
|
|
|
|
ClearPagePrivate(head->wb_page);
|
|
|
|
clear_bit(PG_MAPPED, &head->wb_flags);
|
|
|
|
}
|
2017-08-01 16:34:44 +00:00
|
|
|
spin_unlock(&mapping->private_lock);
|
2012-07-31 23:45:10 +00:00
|
|
|
}
|
2014-07-11 14:20:45 +00:00
|
|
|
|
2019-09-26 06:29:38 +00:00
|
|
|
if (test_and_clear_bit(PG_INODE_REF, &req->wb_flags)) {
|
2014-07-11 14:20:45 +00:00
|
|
|
nfs_release_request(req);
|
2019-09-26 06:29:38 +00:00
|
|
|
atomic_long_dec(&nfsi->nrequests);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-12-05 05:35:42 +00:00
|
|
|
static void
|
2008-03-19 15:24:38 +00:00
|
|
|
nfs_mark_request_dirty(struct nfs_page *req)
|
2006-12-05 05:35:42 +00:00
|
|
|
{
|
2016-01-19 19:37:30 +00:00
|
|
|
if (req->wb_page)
|
|
|
|
__set_page_dirty_nobuffers(req->wb_page);
|
2006-12-05 05:35:42 +00:00
|
|
|
}
|
|
|
|
|
2014-09-09 05:21:00 +00:00
|
|
|
/*
|
|
|
|
* nfs_page_search_commits_for_head_request_locked
|
|
|
|
*
|
|
|
|
* Search through commit lists on @inode for the head request for @page.
|
|
|
|
* Must be called while holding the inode (which is cinfo) lock.
|
|
|
|
*
|
|
|
|
* Returns the head request if found, or NULL if not found.
|
|
|
|
*/
|
|
|
|
static struct nfs_page *
|
|
|
|
nfs_page_search_commits_for_head_request_locked(struct nfs_inode *nfsi,
|
|
|
|
struct page *page)
|
|
|
|
{
|
|
|
|
struct nfs_page *freq, *t;
|
|
|
|
struct nfs_commit_info cinfo;
|
|
|
|
struct inode *inode = &nfsi->vfs_inode;
|
|
|
|
|
|
|
|
nfs_init_cinfo_from_inode(&cinfo, inode);
|
|
|
|
|
|
|
|
/* search through pnfs commit lists */
|
|
|
|
freq = pnfs_search_commit_reqs(inode, &cinfo, page);
|
|
|
|
if (freq)
|
|
|
|
return freq->wb_head;
|
|
|
|
|
|
|
|
/* Linearly search the commit list for the correct request */
|
|
|
|
list_for_each_entry_safe(freq, t, &cinfo.mds->list, wb_list) {
|
|
|
|
if (freq->wb_page == page)
|
|
|
|
return freq->wb_head;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-07-31 20:24:30 +00:00
|
|
|
/**
|
|
|
|
* nfs_request_add_commit_list_locked - add request to a commit list
|
|
|
|
* @req: pointer to a struct nfs_page
|
|
|
|
* @dst: commit list head
|
|
|
|
* @cinfo: holds list lock and accounting info
|
|
|
|
*
|
|
|
|
* This sets the PG_CLEAN bit, updates the cinfo count of
|
|
|
|
* number of outstanding requests requiring a commit as well as
|
|
|
|
* the MM page stats.
|
|
|
|
*
|
2017-08-01 15:53:49 +00:00
|
|
|
* The caller must hold NFS_I(cinfo->inode)->commit_mutex, and the
|
|
|
|
* nfs_page lock.
|
2015-07-31 20:24:30 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
nfs_request_add_commit_list_locked(struct nfs_page *req, struct list_head *dst,
|
|
|
|
struct nfs_commit_info *cinfo)
|
|
|
|
{
|
|
|
|
set_bit(PG_CLEAN, &req->wb_flags);
|
|
|
|
nfs_list_add_request(req, dst);
|
2017-08-01 21:04:12 +00:00
|
|
|
atomic_long_inc(&cinfo->mds->ncommit);
|
2015-07-31 20:24:30 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nfs_request_add_commit_list_locked);
|
|
|
|
|
2012-03-15 21:16:40 +00:00
|
|
|
/**
|
|
|
|
* nfs_request_add_commit_list - add request to a commit list
|
|
|
|
* @req: pointer to a struct nfs_page
|
2012-04-20 18:47:53 +00:00
|
|
|
* @cinfo: holds list lock and accounting info
|
2012-03-15 21:16:40 +00:00
|
|
|
*
|
2012-04-20 18:47:53 +00:00
|
|
|
* This sets the PG_CLEAN bit, updates the cinfo count of
|
2012-03-15 21:16:40 +00:00
|
|
|
* number of outstanding requests requiring a commit as well as
|
|
|
|
* the MM page stats.
|
|
|
|
*
|
2012-04-20 18:47:53 +00:00
|
|
|
* The caller must _not_ hold the cinfo->lock, but must be
|
2012-03-15 21:16:40 +00:00
|
|
|
* holding the nfs_page lock.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2012-03-15 21:16:40 +00:00
|
|
|
void
|
2016-01-15 21:54:15 +00:00
|
|
|
nfs_request_add_commit_list(struct nfs_page *req, struct nfs_commit_info *cinfo)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-08-01 15:53:49 +00:00
|
|
|
mutex_lock(&NFS_I(cinfo->inode)->commit_mutex);
|
2016-01-15 21:54:15 +00:00
|
|
|
nfs_request_add_commit_list_locked(req, &cinfo->mds->list, cinfo);
|
2017-08-01 15:53:49 +00:00
|
|
|
mutex_unlock(&NFS_I(cinfo->inode)->commit_mutex);
|
2016-01-19 19:37:30 +00:00
|
|
|
if (req->wb_page)
|
|
|
|
nfs_mark_page_unstable(req->wb_page, cinfo);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2012-03-15 21:16:40 +00:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_request_add_commit_list);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* nfs_request_remove_commit_list - Remove request from a commit list
|
|
|
|
* @req: pointer to a nfs_page
|
2012-04-20 18:47:53 +00:00
|
|
|
* @cinfo: holds list lock and accounting info
|
2012-03-15 21:16:40 +00:00
|
|
|
*
|
2012-04-20 18:47:53 +00:00
|
|
|
* This clears the PG_CLEAN bit, and updates the cinfo's count of
|
2012-03-15 21:16:40 +00:00
|
|
|
* number of outstanding requests requiring a commit
|
|
|
|
* It does not update the MM page stats.
|
|
|
|
*
|
2012-04-20 18:47:53 +00:00
|
|
|
* The caller _must_ hold the cinfo->lock and the nfs_page lock.
|
2012-03-15 21:16:40 +00:00
|
|
|
*/
|
|
|
|
void
|
2012-04-20 18:47:53 +00:00
|
|
|
nfs_request_remove_commit_list(struct nfs_page *req,
|
|
|
|
struct nfs_commit_info *cinfo)
|
2012-03-15 21:16:40 +00:00
|
|
|
{
|
|
|
|
if (!test_and_clear_bit(PG_CLEAN, &(req)->wb_flags))
|
|
|
|
return;
|
|
|
|
nfs_list_remove_request(req);
|
2017-08-01 21:04:12 +00:00
|
|
|
atomic_long_dec(&cinfo->mds->ncommit);
|
2012-03-15 21:16:40 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nfs_request_remove_commit_list);
|
|
|
|
|
2012-04-20 18:47:53 +00:00
|
|
|
static void nfs_init_cinfo_from_inode(struct nfs_commit_info *cinfo,
|
|
|
|
struct inode *inode)
|
|
|
|
{
|
2016-04-01 17:45:09 +00:00
|
|
|
cinfo->inode = inode;
|
2012-04-20 18:47:53 +00:00
|
|
|
cinfo->mds = &NFS_I(inode)->commit_info;
|
|
|
|
cinfo->ds = pnfs_get_ds_info(inode);
|
2012-04-20 18:47:55 +00:00
|
|
|
cinfo->dreq = NULL;
|
2012-04-20 18:47:54 +00:00
|
|
|
cinfo->completion_ops = &nfs_commit_completion_ops;
|
2012-04-20 18:47:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void nfs_init_cinfo(struct nfs_commit_info *cinfo,
|
|
|
|
struct inode *inode,
|
|
|
|
struct nfs_direct_req *dreq)
|
|
|
|
{
|
2012-04-20 18:47:57 +00:00
|
|
|
if (dreq)
|
|
|
|
nfs_init_cinfo_from_dreq(cinfo, dreq);
|
|
|
|
else
|
|
|
|
nfs_init_cinfo_from_inode(cinfo, inode);
|
2012-04-20 18:47:53 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nfs_init_cinfo);
|
2012-03-15 21:16:40 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Add a request to the inode's commit list.
|
|
|
|
*/
|
2012-04-20 18:47:57 +00:00
|
|
|
void
|
2012-04-20 18:47:53 +00:00
|
|
|
nfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg,
|
2014-09-05 22:20:21 +00:00
|
|
|
struct nfs_commit_info *cinfo, u32 ds_commit_idx)
|
2012-03-15 21:16:40 +00:00
|
|
|
{
|
2014-09-05 22:20:21 +00:00
|
|
|
if (pnfs_mark_request_commit(req, lseg, cinfo, ds_commit_idx))
|
2012-03-15 21:16:40 +00:00
|
|
|
return;
|
2016-01-15 21:54:15 +00:00
|
|
|
nfs_request_add_commit_list(req, cinfo);
|
2012-03-15 21:16:40 +00:00
|
|
|
}
|
2007-04-20 20:12:34 +00:00
|
|
|
|
2012-03-08 22:29:35 +00:00
|
|
|
static void
|
|
|
|
nfs_clear_page_commit(struct page *page)
|
|
|
|
{
|
2020-06-02 04:48:21 +00:00
|
|
|
dec_node_page_state(page, NR_WRITEBACK);
|
2015-05-22 21:13:27 +00:00
|
|
|
dec_wb_stat(&inode_to_bdi(page_file_mapping(page)->host)->wb,
|
2020-06-02 04:48:21 +00:00
|
|
|
WB_WRITEBACK);
|
2012-03-08 22:29:35 +00:00
|
|
|
}
|
|
|
|
|
2017-07-17 14:34:21 +00:00
|
|
|
/* Called holding the request lock on @req */
|
2012-03-15 21:16:40 +00:00
|
|
|
static void
|
2008-06-13 17:25:22 +00:00
|
|
|
nfs_clear_request_commit(struct nfs_page *req)
|
|
|
|
{
|
2012-03-15 21:16:40 +00:00
|
|
|
if (test_bit(PG_CLEAN, &req->wb_flags)) {
|
2019-04-07 17:59:11 +00:00
|
|
|
struct nfs_open_context *ctx = nfs_req_openctx(req);
|
|
|
|
struct inode *inode = d_inode(ctx->dentry);
|
2012-04-20 18:47:53 +00:00
|
|
|
struct nfs_commit_info cinfo;
|
2008-06-13 17:25:22 +00:00
|
|
|
|
2012-04-20 18:47:53 +00:00
|
|
|
nfs_init_cinfo_from_inode(&cinfo, inode);
|
2017-08-01 15:53:49 +00:00
|
|
|
mutex_lock(&NFS_I(inode)->commit_mutex);
|
2012-04-20 18:47:53 +00:00
|
|
|
if (!pnfs_clear_request_commit(req, &cinfo)) {
|
|
|
|
nfs_request_remove_commit_list(req, &cinfo);
|
2012-03-15 21:16:40 +00:00
|
|
|
}
|
2017-08-01 15:53:49 +00:00
|
|
|
mutex_unlock(&NFS_I(inode)->commit_mutex);
|
2012-03-08 22:29:35 +00:00
|
|
|
nfs_clear_page_commit(req->wb_page);
|
2008-06-13 17:25:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-09 15:48:35 +00:00
|
|
|
int nfs_write_need_commit(struct nfs_pgio_header *hdr)
|
2007-04-20 20:12:34 +00:00
|
|
|
{
|
2014-06-09 15:48:36 +00:00
|
|
|
if (hdr->verf.committed == NFS_DATA_SYNC)
|
2014-06-09 15:48:35 +00:00
|
|
|
return hdr->lseg == NULL;
|
2014-06-09 15:48:36 +00:00
|
|
|
return hdr->verf.committed != NFS_FILE_SYNC;
|
2007-04-20 20:12:34 +00:00
|
|
|
}
|
|
|
|
|
2017-06-20 23:35:37 +00:00
|
|
|
static void nfs_async_write_init(struct nfs_pgio_header *hdr)
|
|
|
|
{
|
|
|
|
nfs_io_completion_get(hdr->io_completion);
|
|
|
|
}
|
|
|
|
|
2012-04-20 18:47:48 +00:00
|
|
|
static void nfs_write_completion(struct nfs_pgio_header *hdr)
|
2007-04-20 20:12:34 +00:00
|
|
|
{
|
2012-04-20 18:47:53 +00:00
|
|
|
struct nfs_commit_info cinfo;
|
2012-04-20 18:47:47 +00:00
|
|
|
unsigned long bytes = 0;
|
|
|
|
|
|
|
|
if (test_bit(NFS_IOHDR_REDO, &hdr->flags))
|
|
|
|
goto out;
|
2012-04-20 18:47:53 +00:00
|
|
|
nfs_init_cinfo_from_inode(&cinfo, hdr->inode);
|
2012-04-20 18:47:47 +00:00
|
|
|
while (!list_empty(&hdr->pages)) {
|
|
|
|
struct nfs_page *req = nfs_list_entry(hdr->pages.next);
|
|
|
|
|
|
|
|
bytes += req->wb_bytes;
|
|
|
|
nfs_list_remove_request(req);
|
|
|
|
if (test_bit(NFS_IOHDR_ERROR, &hdr->flags) &&
|
|
|
|
(hdr->good_bytes < bytes)) {
|
2022-08-09 16:50:28 +00:00
|
|
|
trace_nfs_comp_error(hdr->inode, req, hdr->error);
|
2019-04-07 17:59:05 +00:00
|
|
|
nfs_mapping_set_error(req->wb_page, hdr->error);
|
2012-04-20 18:47:47 +00:00
|
|
|
goto remove_req;
|
|
|
|
}
|
2014-06-09 15:48:36 +00:00
|
|
|
if (nfs_write_need_commit(hdr)) {
|
2019-04-07 17:59:08 +00:00
|
|
|
/* Reset wb_nio, since the write was successful. */
|
|
|
|
req->wb_nio = 0;
|
2014-05-06 13:12:28 +00:00
|
|
|
memcpy(&req->wb_verf, &hdr->verf.verifier, sizeof(req->wb_verf));
|
2014-09-05 22:20:21 +00:00
|
|
|
nfs_mark_request_commit(req, hdr->lseg, &cinfo,
|
2014-09-19 14:55:07 +00:00
|
|
|
hdr->pgio_mirror_idx);
|
2012-04-20 18:47:47 +00:00
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
remove_req:
|
|
|
|
nfs_inode_remove_request(req);
|
|
|
|
next:
|
2014-05-15 15:56:47 +00:00
|
|
|
nfs_end_page_writeback(req);
|
2012-05-09 18:30:35 +00:00
|
|
|
nfs_release_request(req);
|
2012-04-20 18:47:47 +00:00
|
|
|
}
|
|
|
|
out:
|
2017-06-20 23:35:37 +00:00
|
|
|
nfs_io_completion_put(hdr->io_completion);
|
2012-04-20 18:47:47 +00:00
|
|
|
hdr->release(hdr);
|
2007-04-20 20:12:34 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-05-06 13:12:34 +00:00
|
|
|
unsigned long
|
2012-04-20 18:47:53 +00:00
|
|
|
nfs_reqs_to_commit(struct nfs_commit_info *cinfo)
|
2009-03-11 18:10:29 +00:00
|
|
|
{
|
2017-08-01 21:04:12 +00:00
|
|
|
return atomic_long_read(&cinfo->mds->ncommit);
|
2012-03-08 22:29:35 +00:00
|
|
|
}
|
|
|
|
|
2017-08-01 15:53:49 +00:00
|
|
|
/* NFS_I(cinfo->inode)->commit_mutex held by caller */
|
2012-04-20 18:47:57 +00:00
|
|
|
int
|
2012-04-20 18:47:53 +00:00
|
|
|
nfs_scan_commit_list(struct list_head *src, struct list_head *dst,
|
|
|
|
struct nfs_commit_info *cinfo, int max)
|
2012-03-08 22:29:35 +00:00
|
|
|
{
|
2017-09-09 16:28:01 +00:00
|
|
|
struct nfs_page *req, *tmp;
|
2012-03-08 22:29:35 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
2017-09-09 16:28:01 +00:00
|
|
|
list_for_each_entry_safe(req, tmp, src, wb_list) {
|
2012-05-09 17:19:15 +00:00
|
|
|
kref_get(&req->wb_kref);
|
2017-08-01 21:29:29 +00:00
|
|
|
if (!nfs_lock_request(req)) {
|
|
|
|
nfs_release_request(req);
|
2021-10-04 19:44:16 +00:00
|
|
|
continue;
|
2017-08-01 21:29:29 +00:00
|
|
|
}
|
2012-04-20 18:47:53 +00:00
|
|
|
nfs_request_remove_commit_list(req, cinfo);
|
2017-09-09 16:40:38 +00:00
|
|
|
clear_bit(PG_COMMIT_TO_DS, &req->wb_flags);
|
2012-03-15 21:16:40 +00:00
|
|
|
nfs_list_add_request(req, dst);
|
|
|
|
ret++;
|
2012-04-20 18:47:57 +00:00
|
|
|
if ((ret == max) && !cinfo->dreq)
|
2012-03-15 21:16:40 +00:00
|
|
|
break;
|
2017-08-01 15:53:49 +00:00
|
|
|
cond_resched();
|
2012-03-08 22:29:35 +00:00
|
|
|
}
|
|
|
|
return ret;
|
2009-03-11 18:10:29 +00:00
|
|
|
}
|
2017-09-09 16:40:38 +00:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_scan_commit_list);
|
2009-03-11 18:10:29 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* nfs_scan_commit - Scan an inode for commit requests
|
|
|
|
* @inode: NFS inode to scan
|
2012-04-20 18:47:53 +00:00
|
|
|
* @dst: mds destination list
|
|
|
|
* @cinfo: mds and ds lists of reqs ready to commit
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Moves requests from the inode's 'commit' request list.
|
|
|
|
* The requests are *not* checked to ensure that they form a contiguous set.
|
|
|
|
*/
|
2012-04-20 18:47:57 +00:00
|
|
|
int
|
2012-04-20 18:47:53 +00:00
|
|
|
nfs_scan_commit(struct inode *inode, struct list_head *dst,
|
|
|
|
struct nfs_commit_info *cinfo)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2012-03-08 22:29:35 +00:00
|
|
|
int ret = 0;
|
2009-03-11 18:10:29 +00:00
|
|
|
|
2017-08-01 21:04:12 +00:00
|
|
|
if (!atomic_long_read(&cinfo->mds->ncommit))
|
|
|
|
return 0;
|
2017-08-01 15:53:49 +00:00
|
|
|
mutex_lock(&NFS_I(cinfo->inode)->commit_mutex);
|
2017-08-01 21:04:12 +00:00
|
|
|
if (atomic_long_read(&cinfo->mds->ncommit) > 0) {
|
2012-03-15 21:16:40 +00:00
|
|
|
const int max = INT_MAX;
|
2012-03-08 22:29:35 +00:00
|
|
|
|
2012-04-20 18:47:53 +00:00
|
|
|
ret = nfs_scan_commit_list(&cinfo->mds->list, dst,
|
|
|
|
cinfo, max);
|
|
|
|
ret += pnfs_scan_commit_lists(inode, cinfo, max - ret);
|
2012-03-08 22:29:35 +00:00
|
|
|
}
|
2017-08-01 15:53:49 +00:00
|
|
|
mutex_unlock(&NFS_I(cinfo->inode)->commit_mutex);
|
2010-02-20 00:53:39 +00:00
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2012-03-08 22:29:35 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2008-06-13 16:12:32 +00:00
|
|
|
* Search for an existing write request, and attempt to update
|
|
|
|
* it to reflect a new dirty region on a given page.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2008-06-13 16:12:32 +00:00
|
|
|
* If the attempt fails, then the existing request is flushed out
|
|
|
|
* to disk.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-06-13 16:12:32 +00:00
|
|
|
static struct nfs_page *nfs_try_to_update_request(struct inode *inode,
|
|
|
|
struct page *page,
|
|
|
|
unsigned int offset,
|
|
|
|
unsigned int bytes)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-06-13 16:12:32 +00:00
|
|
|
struct nfs_page *req;
|
|
|
|
unsigned int rqend;
|
|
|
|
unsigned int end;
|
|
|
|
int error;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
end = offset + bytes;
|
|
|
|
|
2017-07-17 23:50:23 +00:00
|
|
|
req = nfs_lock_and_join_requests(page);
|
|
|
|
if (IS_ERR_OR_NULL(req))
|
|
|
|
return req;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-07-17 23:50:23 +00:00
|
|
|
rqend = req->wb_offset + req->wb_bytes;
|
|
|
|
/*
|
|
|
|
* Tell the caller to flush out the request if
|
|
|
|
* the offsets are non-contiguous.
|
|
|
|
* Note: nfs_flush_incompatible() will already
|
|
|
|
* have flushed out requests having wrong owners.
|
|
|
|
*/
|
|
|
|
if (offset > rqend || end < req->wb_offset)
|
|
|
|
goto out_flushme;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Okay, the request matches. Update the region */
|
|
|
|
if (offset < req->wb_offset) {
|
|
|
|
req->wb_offset = offset;
|
|
|
|
req->wb_pgbase = offset;
|
|
|
|
}
|
|
|
|
if (end > rqend)
|
|
|
|
req->wb_bytes = end - req->wb_offset;
|
2008-06-13 16:12:32 +00:00
|
|
|
else
|
|
|
|
req->wb_bytes = rqend - req->wb_offset;
|
2019-04-07 17:59:08 +00:00
|
|
|
req->wb_nio = 0;
|
2008-06-13 16:12:32 +00:00
|
|
|
return req;
|
|
|
|
out_flushme:
|
2017-07-17 23:50:23 +00:00
|
|
|
/*
|
|
|
|
* Note: we mark the request dirty here because
|
|
|
|
* nfs_lock_and_join_requests() cannot preserve
|
|
|
|
* commit flags, so we have to replay the write.
|
|
|
|
*/
|
|
|
|
nfs_mark_request_dirty(req);
|
|
|
|
nfs_unlock_and_release_request(req);
|
2008-06-13 16:12:32 +00:00
|
|
|
error = nfs_wb_page(inode, page);
|
2017-07-17 23:50:23 +00:00
|
|
|
return (error < 0) ? ERR_PTR(error) : NULL;
|
2008-06-13 16:12:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to update an existing write request, or create one if there is none.
|
|
|
|
*
|
|
|
|
* Note: Should always be called with the Page Lock held to prevent races
|
|
|
|
* if we have to add a new request. Also assumes that the caller has
|
|
|
|
* already called nfs_flush_incompatible() if necessary.
|
|
|
|
*/
|
|
|
|
static struct nfs_page * nfs_setup_write_request(struct nfs_open_context* ctx,
|
|
|
|
struct page *page, unsigned int offset, unsigned int bytes)
|
|
|
|
{
|
2012-07-31 23:45:06 +00:00
|
|
|
struct inode *inode = page_file_mapping(page)->host;
|
2008-06-13 16:12:32 +00:00
|
|
|
struct nfs_page *req;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-06-13 16:12:32 +00:00
|
|
|
req = nfs_try_to_update_request(inode, page, offset, bytes);
|
|
|
|
if (req != NULL)
|
|
|
|
goto out;
|
2019-04-07 17:59:07 +00:00
|
|
|
req = nfs_create_request(ctx, page, offset, bytes);
|
2008-06-13 16:12:32 +00:00
|
|
|
if (IS_ERR(req))
|
|
|
|
goto out;
|
2012-03-08 22:29:35 +00:00
|
|
|
nfs_inode_add_request(inode, req);
|
2008-06-10 22:31:00 +00:00
|
|
|
out:
|
2007-10-18 21:08:05 +00:00
|
|
|
return req;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-06-13 16:12:32 +00:00
|
|
|
static int nfs_writepage_setup(struct nfs_open_context *ctx, struct page *page,
|
|
|
|
unsigned int offset, unsigned int count)
|
|
|
|
{
|
|
|
|
struct nfs_page *req;
|
|
|
|
|
|
|
|
req = nfs_setup_write_request(ctx, page, offset, count);
|
|
|
|
if (IS_ERR(req))
|
|
|
|
return PTR_ERR(req);
|
|
|
|
/* Update file length */
|
|
|
|
nfs_grow_file(page, offset, count);
|
2014-05-15 15:56:48 +00:00
|
|
|
nfs_mark_uptodate(req);
|
2010-04-09 23:07:08 +00:00
|
|
|
nfs_mark_request_dirty(req);
|
2012-05-09 18:04:55 +00:00
|
|
|
nfs_unlock_and_release_request(req);
|
2008-06-13 16:12:32 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
int nfs_flush_incompatible(struct file *file, struct page *page)
|
|
|
|
{
|
2007-08-10 21:44:32 +00:00
|
|
|
struct nfs_open_context *ctx = nfs_file_open_context(file);
|
2012-08-13 22:54:45 +00:00
|
|
|
struct nfs_lock_context *l_ctx;
|
2015-01-16 20:05:55 +00:00
|
|
|
struct file_lock_context *flctx = file_inode(file)->i_flctx;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct nfs_page *req;
|
2006-12-05 05:35:40 +00:00
|
|
|
int do_flush, status;
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Look for a request corresponding to this page. If there
|
|
|
|
* is one, and it belongs to another file, we flush it out
|
|
|
|
* before we try to copy anything into the page. Do this
|
|
|
|
* due to the lack of an ACCESS-type call in NFSv2.
|
|
|
|
* Also do the same if we find a request from an existing
|
|
|
|
* dropped page.
|
|
|
|
*/
|
2006-12-05 05:35:40 +00:00
|
|
|
do {
|
2014-07-11 14:20:47 +00:00
|
|
|
req = nfs_page_find_head_request(page);
|
2006-12-05 05:35:40 +00:00
|
|
|
if (req == NULL)
|
|
|
|
return 0;
|
2012-08-13 22:54:45 +00:00
|
|
|
l_ctx = req->wb_lock_context;
|
2015-10-01 21:17:06 +00:00
|
|
|
do_flush = req->wb_page != page ||
|
2019-04-07 17:59:11 +00:00
|
|
|
!nfs_match_open_context(nfs_req_openctx(req), ctx);
|
2015-01-16 20:05:55 +00:00
|
|
|
if (l_ctx && flctx &&
|
|
|
|
!(list_empty_careful(&flctx->flc_posix) &&
|
|
|
|
list_empty_careful(&flctx->flc_flock))) {
|
2016-10-13 04:26:47 +00:00
|
|
|
do_flush |= l_ctx->lockowner != current->files;
|
2015-01-16 20:05:55 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
nfs_release_request(req);
|
2006-12-05 05:35:40 +00:00
|
|
|
if (!do_flush)
|
|
|
|
return 0;
|
2012-07-31 23:45:06 +00:00
|
|
|
status = nfs_wb_page(page_file_mapping(page)->host, page);
|
2006-12-05 05:35:40 +00:00
|
|
|
} while (status == 0);
|
|
|
|
return status;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-08-14 15:59:16 +00:00
|
|
|
/*
|
|
|
|
* Avoid buffered writes when a open context credential's key would
|
|
|
|
* expire soon.
|
|
|
|
*
|
|
|
|
* Returns -EACCES if the key will expire within RPC_KEY_EXPIRE_FAIL.
|
|
|
|
*
|
|
|
|
* Return 0 and set a credential flag which triggers the inode to flush
|
|
|
|
* and performs NFS_FILE_SYNC writes if the key will expired within
|
|
|
|
* RPC_KEY_EXPIRE_TIMEO.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
nfs_key_timeout_notify(struct file *filp, struct inode *inode)
|
|
|
|
{
|
|
|
|
struct nfs_open_context *ctx = nfs_file_open_context(filp);
|
|
|
|
|
2018-12-03 00:30:30 +00:00
|
|
|
if (nfs_ctx_key_to_expire(ctx, inode) &&
|
2021-07-10 22:07:14 +00:00
|
|
|
!rcu_access_pointer(ctx->ll_cred))
|
2018-12-03 00:30:30 +00:00
|
|
|
/* Already expired! */
|
|
|
|
return -EACCES;
|
|
|
|
return 0;
|
2013-08-14 15:59:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Test if the open context credential key is marked to expire soon.
|
|
|
|
*/
|
sunrpc: move NO_CRKEY_TIMEOUT to the auth->au_flags
A generic_cred can be used to look up a unx_cred or a gss_cred, so it's
not really safe to use the the generic_cred->acred->ac_flags to store
the NO_CRKEY_TIMEOUT flag. A lookup for a unx_cred triggered while the
KEY_EXPIRE_SOON flag is already set will cause both NO_CRKEY_TIMEOUT and
KEY_EXPIRE_SOON to be set in the ac_flags, leaving the user associated
with the auth_cred to be in a state where they're perpetually doing 4K
NFS_FILE_SYNC writes.
This can be reproduced as follows:
1. Mount two NFS filesystems, one with sec=krb5 and one with sec=sys.
They do not need to be the same export, nor do they even need to be from
the same NFS server. Also, v3 is fine.
$ sudo mount -o v3,sec=krb5 server1:/export /mnt/krb5
$ sudo mount -o v3,sec=sys server2:/export /mnt/sys
2. As the normal user, before accessing the kerberized mount, kinit with
a short lifetime (but not so short that renewing the ticket would leave
you within the 4-minute window again by the time the original ticket
expires), e.g.
$ kinit -l 10m -r 60m
3. Do some I/O to the kerberized mount and verify that the writes are
wsize, UNSTABLE:
$ dd if=/dev/zero of=/mnt/krb5/file bs=1M count=1
4. Wait until you're within 4 minutes of key expiry, then do some more
I/O to the kerberized mount to ensure that RPC_CRED_KEY_EXPIRE_SOON gets
set. Verify that the writes are 4K, FILE_SYNC:
$ dd if=/dev/zero of=/mnt/krb5/file bs=1M count=1
5. Now do some I/O to the sec=sys mount. This will cause
RPC_CRED_NO_CRKEY_TIMEOUT to be set:
$ dd if=/dev/zero of=/mnt/sys/file bs=1M count=1
6. Writes for that user will now be permanently 4K, FILE_SYNC for that
user, regardless of which mount is being written to, until you reboot
the client. Renewing the kerberos ticket (assuming it hasn't already
expired) will have no effect. Grabbing a new kerberos ticket at this
point will have no effect either.
Move the flag to the auth->au_flags field (which is currently unused)
and rename it slightly to reflect that it's no longer associated with
the auth_cred->ac_flags. Add the rpc_auth to the arg list of
rpcauth_cred_key_to_expire and check the au_flags there too. Finally,
add the inode to the arg list of nfs_ctx_key_to_expire so we can
determine the rpc_auth to pass to rpcauth_cred_key_to_expire.
Signed-off-by: Scott Mayhew <smayhew@redhat.com>
Signed-off-by: Trond Myklebust <trond.myklebust@primarydata.com>
2016-06-07 19:14:48 +00:00
|
|
|
bool nfs_ctx_key_to_expire(struct nfs_open_context *ctx, struct inode *inode)
|
2013-08-14 15:59:16 +00:00
|
|
|
{
|
sunrpc: move NO_CRKEY_TIMEOUT to the auth->au_flags
A generic_cred can be used to look up a unx_cred or a gss_cred, so it's
not really safe to use the the generic_cred->acred->ac_flags to store
the NO_CRKEY_TIMEOUT flag. A lookup for a unx_cred triggered while the
KEY_EXPIRE_SOON flag is already set will cause both NO_CRKEY_TIMEOUT and
KEY_EXPIRE_SOON to be set in the ac_flags, leaving the user associated
with the auth_cred to be in a state where they're perpetually doing 4K
NFS_FILE_SYNC writes.
This can be reproduced as follows:
1. Mount two NFS filesystems, one with sec=krb5 and one with sec=sys.
They do not need to be the same export, nor do they even need to be from
the same NFS server. Also, v3 is fine.
$ sudo mount -o v3,sec=krb5 server1:/export /mnt/krb5
$ sudo mount -o v3,sec=sys server2:/export /mnt/sys
2. As the normal user, before accessing the kerberized mount, kinit with
a short lifetime (but not so short that renewing the ticket would leave
you within the 4-minute window again by the time the original ticket
expires), e.g.
$ kinit -l 10m -r 60m
3. Do some I/O to the kerberized mount and verify that the writes are
wsize, UNSTABLE:
$ dd if=/dev/zero of=/mnt/krb5/file bs=1M count=1
4. Wait until you're within 4 minutes of key expiry, then do some more
I/O to the kerberized mount to ensure that RPC_CRED_KEY_EXPIRE_SOON gets
set. Verify that the writes are 4K, FILE_SYNC:
$ dd if=/dev/zero of=/mnt/krb5/file bs=1M count=1
5. Now do some I/O to the sec=sys mount. This will cause
RPC_CRED_NO_CRKEY_TIMEOUT to be set:
$ dd if=/dev/zero of=/mnt/sys/file bs=1M count=1
6. Writes for that user will now be permanently 4K, FILE_SYNC for that
user, regardless of which mount is being written to, until you reboot
the client. Renewing the kerberos ticket (assuming it hasn't already
expired) will have no effect. Grabbing a new kerberos ticket at this
point will have no effect either.
Move the flag to the auth->au_flags field (which is currently unused)
and rename it slightly to reflect that it's no longer associated with
the auth_cred->ac_flags. Add the rpc_auth to the arg list of
rpcauth_cred_key_to_expire and check the au_flags there too. Finally,
add the inode to the arg list of nfs_ctx_key_to_expire so we can
determine the rpc_auth to pass to rpcauth_cred_key_to_expire.
Signed-off-by: Scott Mayhew <smayhew@redhat.com>
Signed-off-by: Trond Myklebust <trond.myklebust@primarydata.com>
2016-06-07 19:14:48 +00:00
|
|
|
struct rpc_auth *auth = NFS_SERVER(inode)->client->cl_auth;
|
2021-07-10 22:07:14 +00:00
|
|
|
struct rpc_cred *cred, *new, *old = NULL;
|
2018-12-03 00:30:30 +00:00
|
|
|
struct auth_cred acred = {
|
2018-12-03 00:30:31 +00:00
|
|
|
.cred = ctx->cred,
|
2018-12-03 00:30:30 +00:00
|
|
|
};
|
2021-07-10 22:07:14 +00:00
|
|
|
bool ret = false;
|
2018-12-03 00:30:30 +00:00
|
|
|
|
2021-07-10 22:07:14 +00:00
|
|
|
rcu_read_lock();
|
|
|
|
cred = rcu_dereference(ctx->ll_cred);
|
|
|
|
if (cred && !(cred->cr_ops->crkey_timeout &&
|
|
|
|
cred->cr_ops->crkey_timeout(cred)))
|
|
|
|
goto out;
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
new = auth->au_ops->lookup_cred(auth, &acred, 0);
|
|
|
|
if (new == cred) {
|
|
|
|
put_rpccred(new);
|
2018-12-03 00:30:30 +00:00
|
|
|
return true;
|
2021-07-10 22:07:14 +00:00
|
|
|
}
|
|
|
|
if (IS_ERR_OR_NULL(new)) {
|
|
|
|
new = NULL;
|
|
|
|
ret = true;
|
|
|
|
} else if (new->cr_ops->crkey_timeout &&
|
|
|
|
new->cr_ops->crkey_timeout(new))
|
|
|
|
ret = true;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
old = rcu_dereference_protected(xchg(&ctx->ll_cred,
|
|
|
|
RCU_INITIALIZER(new)), 1);
|
|
|
|
out:
|
|
|
|
rcu_read_unlock();
|
|
|
|
put_rpccred(old);
|
|
|
|
return ret;
|
2013-08-14 15:59:16 +00:00
|
|
|
}
|
|
|
|
|
NFS: Fix a potential file corruption issue when writing
If the inode is flagged as having an invalid mapping, then we can't rely on
the PageUptodate() flag. Ensure that we don't use the "anti-fragmentation"
write optimisation in nfs_updatepage(), since that will cause NFS to write
out areas of the page that are no longer guaranteed to be up to date.
A potential corruption could occur in the following scenario:
client 1 client 2
=============== ===============
fd=open("f",O_CREAT|O_WRONLY,0644);
write(fd,"fubar\n",6); // cache last page
close(fd);
fd=open("f",O_WRONLY|O_APPEND);
write(fd,"foo\n",4);
close(fd);
fd=open("f",O_WRONLY|O_APPEND);
write(fd,"bar\n",4);
close(fd);
-----
The bug may lead to the file "f" reading 'fubar\n\0\0\0\nbar\n' because
client 2 does not update the cached page after re-opening the file for
write. Instead it keeps it marked as PageUptodate() until someone calls
invaldate_inode_pages2() (typically by calling read()).
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2008-02-07 22:24:07 +00:00
|
|
|
/*
|
|
|
|
* If the page cache is marked as unsafe or invalid, then we can't rely on
|
|
|
|
* the PageUptodate() flag. In this case, we will need to turn off
|
|
|
|
* write optimisations that depend on the page contents being correct.
|
|
|
|
*/
|
2021-02-08 13:55:46 +00:00
|
|
|
static bool nfs_write_pageuptodate(struct page *page, struct inode *inode,
|
|
|
|
unsigned int pagelen)
|
NFS: Fix a potential file corruption issue when writing
If the inode is flagged as having an invalid mapping, then we can't rely on
the PageUptodate() flag. Ensure that we don't use the "anti-fragmentation"
write optimisation in nfs_updatepage(), since that will cause NFS to write
out areas of the page that are no longer guaranteed to be up to date.
A potential corruption could occur in the following scenario:
client 1 client 2
=============== ===============
fd=open("f",O_CREAT|O_WRONLY,0644);
write(fd,"fubar\n",6); // cache last page
close(fd);
fd=open("f",O_WRONLY|O_APPEND);
write(fd,"foo\n",4);
close(fd);
fd=open("f",O_WRONLY|O_APPEND);
write(fd,"bar\n",4);
close(fd);
-----
The bug may lead to the file "f" reading 'fubar\n\0\0\0\nbar\n' because
client 2 does not update the cached page after re-opening the file for
write. Instead it keeps it marked as PageUptodate() until someone calls
invaldate_inode_pages2() (typically by calling read()).
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2008-02-07 22:24:07 +00:00
|
|
|
{
|
NFS: fix the handling of NFS_INO_INVALID_DATA flag in nfs_revalidate_mapping
There is a possible race in how the nfs_invalidate_mapping function is
handled. Currently, we go and invalidate the pages in the file and then
clear NFS_INO_INVALID_DATA.
The problem is that it's possible for a stale page to creep into the
mapping after the page was invalidated (i.e., via readahead). If another
writer comes along and sets the flag after that happens but before
invalidate_inode_pages2 returns then we could clear the flag
without the cache having been properly invalidated.
So, we must clear the flag first and then invalidate the pages. Doing
this however, opens another race:
It's possible to have two concurrent read() calls that end up in
nfs_revalidate_mapping at the same time. The first one clears the
NFS_INO_INVALID_DATA flag and then goes to call nfs_invalidate_mapping.
Just before calling that though, the other task races in, checks the
flag and finds it cleared. At that point, it trusts that the mapping is
good and gets the lock on the page, allowing the read() to be satisfied
from the cache even though the data is no longer valid.
These effects are easily manifested by running diotest3 from the LTP
test suite on NFS. That program does a series of DIO writes and buffered
reads. The operations are serialized and page-aligned but the existing
code fails the test since it occasionally allows a read to come out of
the cache incorrectly. While mixing direct and buffered I/O isn't
recommended, I believe it's possible to hit this in other ways that just
use buffered I/O, though that situation is much harder to reproduce.
The problem is that the checking/clearing of that flag and the
invalidation of the mapping really need to be atomic. Fix this by
serializing concurrent invalidations with a bitlock.
At the same time, we also need to allow other places that check
NFS_INO_INVALID_DATA to check whether we might be in the middle of
invalidating the file, so fix up a couple of places that do that
to look for the new NFS_INO_INVALIDATING flag.
Doing this requires us to be careful not to set the bitlock
unnecessarily, so this code only does that if it believes it will
be doing an invalidation.
Signed-off-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: Trond Myklebust <trond.myklebust@primarydata.com>
2014-01-27 18:46:15 +00:00
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
|
2012-04-29 16:50:01 +00:00
|
|
|
if (nfs_have_delegated_attributes(inode))
|
|
|
|
goto out;
|
2021-02-08 13:55:46 +00:00
|
|
|
if (nfsi->cache_validity &
|
2021-03-26 01:07:21 +00:00
|
|
|
(NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_SIZE))
|
NFS: fix the handling of NFS_INO_INVALID_DATA flag in nfs_revalidate_mapping
There is a possible race in how the nfs_invalidate_mapping function is
handled. Currently, we go and invalidate the pages in the file and then
clear NFS_INO_INVALID_DATA.
The problem is that it's possible for a stale page to creep into the
mapping after the page was invalidated (i.e., via readahead). If another
writer comes along and sets the flag after that happens but before
invalidate_inode_pages2 returns then we could clear the flag
without the cache having been properly invalidated.
So, we must clear the flag first and then invalidate the pages. Doing
this however, opens another race:
It's possible to have two concurrent read() calls that end up in
nfs_revalidate_mapping at the same time. The first one clears the
NFS_INO_INVALID_DATA flag and then goes to call nfs_invalidate_mapping.
Just before calling that though, the other task races in, checks the
flag and finds it cleared. At that point, it trusts that the mapping is
good and gets the lock on the page, allowing the read() to be satisfied
from the cache even though the data is no longer valid.
These effects are easily manifested by running diotest3 from the LTP
test suite on NFS. That program does a series of DIO writes and buffered
reads. The operations are serialized and page-aligned but the existing
code fails the test since it occasionally allows a read to come out of
the cache incorrectly. While mixing direct and buffered I/O isn't
recommended, I believe it's possible to hit this in other ways that just
use buffered I/O, though that situation is much harder to reproduce.
The problem is that the checking/clearing of that flag and the
invalidation of the mapping really need to be atomic. Fix this by
serializing concurrent invalidations with a bitlock.
At the same time, we also need to allow other places that check
NFS_INO_INVALID_DATA to check whether we might be in the middle of
invalidating the file, so fix up a couple of places that do that
to look for the new NFS_INO_INVALIDATING flag.
Doing this requires us to be careful not to set the bitlock
unnecessarily, so this code only does that if it believes it will
be doing an invalidation.
Signed-off-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: Trond Myklebust <trond.myklebust@primarydata.com>
2014-01-27 18:46:15 +00:00
|
|
|
return false;
|
2014-01-28 18:47:46 +00:00
|
|
|
smp_rmb();
|
2021-02-08 13:55:46 +00:00
|
|
|
if (test_bit(NFS_INO_INVALIDATING, &nfsi->flags) && pagelen != 0)
|
2012-04-29 16:50:01 +00:00
|
|
|
return false;
|
|
|
|
out:
|
2021-02-08 13:55:46 +00:00
|
|
|
if (nfsi->cache_validity & NFS_INO_INVALID_DATA && pagelen != 0)
|
2014-06-20 12:44:42 +00:00
|
|
|
return false;
|
2012-04-29 16:50:01 +00:00
|
|
|
return PageUptodate(page) != 0;
|
NFS: Fix a potential file corruption issue when writing
If the inode is flagged as having an invalid mapping, then we can't rely on
the PageUptodate() flag. Ensure that we don't use the "anti-fragmentation"
write optimisation in nfs_updatepage(), since that will cause NFS to write
out areas of the page that are no longer guaranteed to be up to date.
A potential corruption could occur in the following scenario:
client 1 client 2
=============== ===============
fd=open("f",O_CREAT|O_WRONLY,0644);
write(fd,"fubar\n",6); // cache last page
close(fd);
fd=open("f",O_WRONLY|O_APPEND);
write(fd,"foo\n",4);
close(fd);
fd=open("f",O_WRONLY|O_APPEND);
write(fd,"bar\n",4);
close(fd);
-----
The bug may lead to the file "f" reading 'fubar\n\0\0\0\nbar\n' because
client 2 does not update the cached page after re-opening the file for
write. Instead it keeps it marked as PageUptodate() until someone calls
invaldate_inode_pages2() (typically by calling read()).
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2008-02-07 22:24:07 +00:00
|
|
|
}
|
|
|
|
|
2015-01-16 20:05:55 +00:00
|
|
|
static bool
|
|
|
|
is_whole_file_wrlock(struct file_lock *fl)
|
|
|
|
{
|
|
|
|
return fl->fl_start == 0 && fl->fl_end == OFFSET_MAX &&
|
|
|
|
fl->fl_type == F_WRLCK;
|
|
|
|
}
|
|
|
|
|
2013-07-05 21:33:19 +00:00
|
|
|
/* If we know the page is up to date, and we're not using byte range locks (or
|
|
|
|
* if we have the whole file locked for writing), it may be more efficient to
|
|
|
|
* extend the write to cover the entire page in order to avoid fragmentation
|
|
|
|
* inefficiencies.
|
|
|
|
*
|
2014-01-17 20:12:05 +00:00
|
|
|
* If the file is opened for synchronous writes then we can just skip the rest
|
|
|
|
* of the checks.
|
2013-07-05 21:33:19 +00:00
|
|
|
*/
|
2021-02-08 13:55:46 +00:00
|
|
|
static int nfs_can_extend_write(struct file *file, struct page *page,
|
|
|
|
struct inode *inode, unsigned int pagelen)
|
2013-07-05 21:33:19 +00:00
|
|
|
{
|
2015-01-16 20:05:55 +00:00
|
|
|
int ret;
|
|
|
|
struct file_lock_context *flctx = inode->i_flctx;
|
|
|
|
struct file_lock *fl;
|
|
|
|
|
2013-07-05 21:33:19 +00:00
|
|
|
if (file->f_flags & O_DSYNC)
|
|
|
|
return 0;
|
2021-02-08 13:55:46 +00:00
|
|
|
if (!nfs_write_pageuptodate(page, inode, pagelen))
|
2014-01-17 20:12:05 +00:00
|
|
|
return 0;
|
2013-07-05 21:33:19 +00:00
|
|
|
if (NFS_PROTO(inode)->have_delegation(inode, FMODE_WRITE))
|
|
|
|
return 1;
|
2015-01-16 20:05:55 +00:00
|
|
|
if (!flctx || (list_empty_careful(&flctx->flc_flock) &&
|
|
|
|
list_empty_careful(&flctx->flc_posix)))
|
2015-10-01 22:38:27 +00:00
|
|
|
return 1;
|
2015-01-16 20:05:55 +00:00
|
|
|
|
|
|
|
/* Check to see if there are whole file write locks */
|
|
|
|
ret = 0;
|
2015-01-16 20:05:57 +00:00
|
|
|
spin_lock(&flctx->flc_lock);
|
2015-01-16 20:05:55 +00:00
|
|
|
if (!list_empty(&flctx->flc_posix)) {
|
|
|
|
fl = list_first_entry(&flctx->flc_posix, struct file_lock,
|
|
|
|
fl_list);
|
|
|
|
if (is_whole_file_wrlock(fl))
|
|
|
|
ret = 1;
|
|
|
|
} else if (!list_empty(&flctx->flc_flock)) {
|
2015-01-16 20:05:55 +00:00
|
|
|
fl = list_first_entry(&flctx->flc_flock, struct file_lock,
|
|
|
|
fl_list);
|
|
|
|
if (fl->fl_type == F_WRLCK)
|
|
|
|
ret = 1;
|
|
|
|
}
|
2015-01-16 20:05:57 +00:00
|
|
|
spin_unlock(&flctx->flc_lock);
|
2015-01-16 20:05:55 +00:00
|
|
|
return ret;
|
2013-07-05 21:33:19 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Update and possibly write a cached page of an NFS file.
|
|
|
|
*
|
|
|
|
* XXX: Keep an eye on generic_file_read to make sure it doesn't do bad
|
|
|
|
* things with a page scheduled for an RPC call (e.g. invalidate it).
|
|
|
|
*/
|
|
|
|
int nfs_updatepage(struct file *file, struct page *page,
|
|
|
|
unsigned int offset, unsigned int count)
|
|
|
|
{
|
2007-08-10 21:44:32 +00:00
|
|
|
struct nfs_open_context *ctx = nfs_file_open_context(file);
|
2019-02-06 11:09:43 +00:00
|
|
|
struct address_space *mapping = page_file_mapping(page);
|
|
|
|
struct inode *inode = mapping->host;
|
2021-02-08 13:55:46 +00:00
|
|
|
unsigned int pagelen = nfs_page_length(page);
|
2005-04-16 22:20:36 +00:00
|
|
|
int status = 0;
|
|
|
|
|
2006-03-20 18:44:14 +00:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSUPDATEPAGE);
|
|
|
|
|
2013-09-16 14:53:17 +00:00
|
|
|
dprintk("NFS: nfs_updatepage(%pD2 %d@%lld)\n",
|
|
|
|
file, count, (long long)(page_file_offset(page) + offset));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-07-18 14:41:57 +00:00
|
|
|
if (!count)
|
|
|
|
goto out;
|
|
|
|
|
2021-02-08 13:55:46 +00:00
|
|
|
if (nfs_can_extend_write(file, page, inode, pagelen)) {
|
|
|
|
count = max(count + offset, pagelen);
|
2005-04-16 22:20:36 +00:00
|
|
|
offset = 0;
|
|
|
|
}
|
|
|
|
|
2006-12-05 05:35:39 +00:00
|
|
|
status = nfs_writepage_setup(ctx, page, offset, count);
|
2008-06-05 20:02:35 +00:00
|
|
|
if (status < 0)
|
2019-02-06 11:09:43 +00:00
|
|
|
nfs_set_pageerror(mapping);
|
2016-07-18 14:41:57 +00:00
|
|
|
out:
|
2008-06-11 21:56:05 +00:00
|
|
|
dprintk("NFS: nfs_updatepage returns %d (isize %lld)\n",
|
2005-04-16 22:20:36 +00:00
|
|
|
status, (long long)i_size_read(inode));
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2007-07-14 19:40:00 +00:00
|
|
|
static int flush_task_priority(int how)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
switch (how & (FLUSH_HIGHPRI|FLUSH_LOWPRI)) {
|
|
|
|
case FLUSH_HIGHPRI:
|
|
|
|
return RPC_PRIORITY_HIGH;
|
|
|
|
case FLUSH_LOWPRI:
|
|
|
|
return RPC_PRIORITY_LOW;
|
|
|
|
}
|
|
|
|
return RPC_PRIORITY_NORMAL;
|
|
|
|
}
|
|
|
|
|
2014-06-09 15:48:35 +00:00
|
|
|
static void nfs_initiate_write(struct nfs_pgio_header *hdr,
|
|
|
|
struct rpc_message *msg,
|
2014-06-09 20:12:20 +00:00
|
|
|
const struct nfs_rpc_ops *rpc_ops,
|
2014-05-06 13:12:37 +00:00
|
|
|
struct rpc_task_setup *task_setup_data, int how)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-07-14 19:40:00 +00:00
|
|
|
int priority = flush_task_priority(how);
|
2011-03-03 15:13:41 +00:00
|
|
|
|
2022-03-06 23:41:44 +00:00
|
|
|
if (IS_SWAPFILE(hdr->inode))
|
|
|
|
task_setup_data->flags |= RPC_TASK_SWAPPER;
|
2014-05-06 13:12:37 +00:00
|
|
|
task_setup_data->priority = priority;
|
2018-05-04 20:22:48 +00:00
|
|
|
rpc_ops->write_setup(hdr, msg, &task_setup_data->rpc_client);
|
2020-01-06 20:25:09 +00:00
|
|
|
trace_nfs_initiate_write(hdr);
|
2011-07-12 17:42:02 +00:00
|
|
|
}
|
|
|
|
|
2008-03-19 15:24:38 +00:00
|
|
|
/* If a nfs_flush_* function fails, it should remove reqs from @head and
|
|
|
|
* call this on each, which will prepare them to be retried on next
|
|
|
|
* writeback using standard nfs.
|
|
|
|
*/
|
|
|
|
static void nfs_redirty_request(struct nfs_page *req)
|
|
|
|
{
|
2022-08-13 12:22:25 +00:00
|
|
|
struct nfs_inode *nfsi = NFS_I(page_file_mapping(req->wb_page)->host);
|
|
|
|
|
2019-04-07 17:59:08 +00:00
|
|
|
/* Bump the transmission count */
|
|
|
|
req->wb_nio++;
|
2008-03-19 15:24:38 +00:00
|
|
|
nfs_mark_request_dirty(req);
|
2022-08-13 12:22:25 +00:00
|
|
|
atomic_long_inc(&nfsi->redirtied_pages);
|
2014-05-15 15:56:47 +00:00
|
|
|
nfs_end_page_writeback(req);
|
2012-05-09 18:30:35 +00:00
|
|
|
nfs_release_request(req);
|
2008-03-19 15:24:38 +00:00
|
|
|
}
|
|
|
|
|
2019-02-13 15:39:39 +00:00
|
|
|
static void nfs_async_write_error(struct list_head *head, int error)
|
2012-04-20 18:47:47 +00:00
|
|
|
{
|
|
|
|
struct nfs_page *req;
|
|
|
|
|
|
|
|
while (!list_empty(head)) {
|
|
|
|
req = nfs_list_entry(head->next);
|
|
|
|
nfs_list_remove_request(req);
|
2022-05-14 14:27:00 +00:00
|
|
|
if (nfs_error_is_fatal_on_server(error))
|
2019-04-07 17:59:05 +00:00
|
|
|
nfs_write_error(req, error);
|
|
|
|
else
|
|
|
|
nfs_redirty_request(req);
|
2012-04-20 18:47:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-31 16:44:06 +00:00
|
|
|
static void nfs_async_write_reschedule_io(struct nfs_pgio_header *hdr)
|
|
|
|
{
|
2019-02-13 15:39:39 +00:00
|
|
|
nfs_async_write_error(&hdr->pages, 0);
|
2015-12-31 16:44:06 +00:00
|
|
|
}
|
|
|
|
|
2012-04-20 18:47:48 +00:00
|
|
|
static const struct nfs_pgio_completion_ops nfs_async_write_completion_ops = {
|
2017-06-20 23:35:37 +00:00
|
|
|
.init_hdr = nfs_async_write_init,
|
2012-04-20 18:47:48 +00:00
|
|
|
.error_cleanup = nfs_async_write_error,
|
|
|
|
.completion = nfs_write_completion,
|
2015-12-31 16:44:06 +00:00
|
|
|
.reschedule_io = nfs_async_write_reschedule_io,
|
2012-04-20 18:47:48 +00:00
|
|
|
};
|
|
|
|
|
2012-06-20 19:53:48 +00:00
|
|
|
void nfs_pageio_init_write(struct nfs_pageio_descriptor *pgio,
|
2014-04-16 13:07:21 +00:00
|
|
|
struct inode *inode, int ioflags, bool force_mds,
|
2012-04-20 18:47:48 +00:00
|
|
|
const struct nfs_pgio_completion_ops *compl_ops)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2014-04-16 13:07:21 +00:00
|
|
|
struct nfs_server *server = NFS_SERVER(inode);
|
2014-05-06 13:12:40 +00:00
|
|
|
const struct nfs_pageio_ops *pg_ops = &nfs_pgio_rw_ops;
|
2014-04-16 13:07:21 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_NFS_V4_1
|
|
|
|
if (server->pnfs_curr_ld && !force_mds)
|
|
|
|
pg_ops = server->pnfs_curr_ld->pg_write_ops;
|
|
|
|
#endif
|
2014-05-06 13:12:30 +00:00
|
|
|
nfs_pageio_init(pgio, inode, pg_ops, compl_ops, &nfs_rw_write_ops,
|
2017-08-20 15:33:25 +00:00
|
|
|
server->wsize, ioflags);
|
2011-06-10 17:30:23 +00:00
|
|
|
}
|
2012-07-30 20:05:23 +00:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_pageio_init_write);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-07-13 19:59:19 +00:00
|
|
|
void nfs_pageio_reset_write_mds(struct nfs_pageio_descriptor *pgio)
|
|
|
|
{
|
2014-09-19 14:55:07 +00:00
|
|
|
struct nfs_pgio_mirror *mirror;
|
|
|
|
|
2015-09-20 15:03:28 +00:00
|
|
|
if (pgio->pg_ops && pgio->pg_ops->pg_cleanup)
|
|
|
|
pgio->pg_ops->pg_cleanup(pgio);
|
|
|
|
|
2014-05-06 13:12:40 +00:00
|
|
|
pgio->pg_ops = &nfs_pgio_rw_ops;
|
2014-09-19 14:55:07 +00:00
|
|
|
|
|
|
|
nfs_pageio_stop_mirroring(pgio);
|
|
|
|
|
|
|
|
mirror = &pgio->pg_mirrors[0];
|
|
|
|
mirror->pg_bsize = NFS_SERVER(pgio->pg_inode)->wsize;
|
2011-07-13 19:59:19 +00:00
|
|
|
}
|
2011-07-13 19:59:57 +00:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_pageio_reset_write_mds);
|
2011-07-13 19:59:19 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-04-20 18:47:39 +00:00
|
|
|
void nfs_commit_prepare(struct rpc_task *task, void *calldata)
|
|
|
|
{
|
|
|
|
struct nfs_commit_data *data = calldata;
|
|
|
|
|
|
|
|
NFS_PROTO(data->inode)->commit_rpc_prepare(task, data);
|
|
|
|
}
|
|
|
|
|
2015-02-26 22:36:09 +00:00
|
|
|
static void nfs_writeback_check_extend(struct nfs_pgio_header *hdr,
|
|
|
|
struct nfs_fattr *fattr)
|
|
|
|
{
|
|
|
|
struct nfs_pgio_args *argp = &hdr->args;
|
|
|
|
struct nfs_pgio_res *resp = &hdr->res;
|
2015-07-06 00:06:38 +00:00
|
|
|
u64 size = argp->offset + resp->count;
|
2015-02-26 22:36:09 +00:00
|
|
|
|
|
|
|
if (!(fattr->valid & NFS_ATTR_FATTR_SIZE))
|
2015-07-06 00:06:38 +00:00
|
|
|
fattr->size = size;
|
|
|
|
if (nfs_size_to_loff_t(fattr->size) < i_size_read(hdr->inode)) {
|
|
|
|
fattr->valid &= ~NFS_ATTR_FATTR_SIZE;
|
2015-02-26 22:36:09 +00:00
|
|
|
return;
|
2015-07-06 00:06:38 +00:00
|
|
|
}
|
|
|
|
if (size != fattr->size)
|
2015-02-26 22:36:09 +00:00
|
|
|
return;
|
|
|
|
/* Set attribute barrier */
|
|
|
|
nfs_fattr_set_barrier(fattr);
|
2015-07-06 00:06:38 +00:00
|
|
|
/* ...and update size */
|
|
|
|
fattr->valid |= NFS_ATTR_FATTR_SIZE;
|
2015-02-26 22:36:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void nfs_writeback_update_inode(struct nfs_pgio_header *hdr)
|
|
|
|
{
|
2015-07-06 00:06:38 +00:00
|
|
|
struct nfs_fattr *fattr = &hdr->fattr;
|
2015-02-26 22:36:09 +00:00
|
|
|
struct inode *inode = hdr->inode;
|
|
|
|
|
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
nfs_writeback_check_extend(hdr, fattr);
|
|
|
|
nfs_post_op_update_inode_force_wcc_locked(inode, fattr);
|
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nfs_writeback_update_inode);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* This function is called when the WRITE call is complete.
|
|
|
|
*/
|
2014-06-09 15:48:35 +00:00
|
|
|
static int nfs_writeback_done(struct rpc_task *task,
|
|
|
|
struct nfs_pgio_header *hdr,
|
2014-05-06 13:12:32 +00:00
|
|
|
struct inode *inode)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-03-20 18:44:27 +00:00
|
|
|
int status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-09-20 18:33:04 +00:00
|
|
|
/*
|
|
|
|
* ->write_done will attempt to use post-op attributes to detect
|
|
|
|
* conflicting writes by other clients. A strict interpretation
|
|
|
|
* of close-to-open would allow us to continue caching even if
|
|
|
|
* another writer had changed the file, but some applications
|
|
|
|
* depend on tighter cache coherency when writing.
|
|
|
|
*/
|
2014-06-09 15:48:35 +00:00
|
|
|
status = NFS_PROTO(inode)->write_done(task, hdr);
|
2006-03-20 18:44:27 +00:00
|
|
|
if (status != 0)
|
2014-05-06 13:12:32 +00:00
|
|
|
return status;
|
2017-08-21 19:00:49 +00:00
|
|
|
|
2014-06-09 15:48:35 +00:00
|
|
|
nfs_add_stats(inode, NFSIOS_SERVERWRITTENBYTES, hdr->res.count);
|
2020-01-06 20:25:09 +00:00
|
|
|
trace_nfs_writeback_done(task, hdr);
|
2006-03-20 18:44:14 +00:00
|
|
|
|
2022-07-22 18:12:20 +00:00
|
|
|
if (task->tk_status >= 0) {
|
|
|
|
enum nfs3_stable_how committed = hdr->res.verf->committed;
|
|
|
|
|
|
|
|
if (committed == NFS_UNSTABLE) {
|
|
|
|
/*
|
|
|
|
* We have some uncommitted data on the server at
|
|
|
|
* this point, so ensure that we keep track of that
|
|
|
|
* fact irrespective of what later writes do.
|
|
|
|
*/
|
|
|
|
set_bit(NFS_IOHDR_UNSTABLE_WRITES, &hdr->flags);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2022-07-22 18:12:20 +00:00
|
|
|
if (committed < hdr->args.stable) {
|
|
|
|
/* We tried a write call, but the server did not
|
|
|
|
* commit data to stable storage even though we
|
|
|
|
* requested it.
|
|
|
|
* Note: There is a known bug in Tru64 < 5.0 in which
|
|
|
|
* the server reports NFS_DATA_SYNC, but performs
|
|
|
|
* NFS_FILE_SYNC. We therefore implement this checking
|
|
|
|
* as a dprintk() in order to avoid filling syslog.
|
|
|
|
*/
|
|
|
|
static unsigned long complain;
|
|
|
|
|
|
|
|
/* Note this will print the MDS for a DS write */
|
|
|
|
if (time_before(complain, jiffies)) {
|
|
|
|
dprintk("NFS: faulty NFS server %s:"
|
|
|
|
" (committed = %d) != (stable = %d)\n",
|
|
|
|
NFS_SERVER(inode)->nfs_client->cl_hostname,
|
|
|
|
committed, hdr->args.stable);
|
|
|
|
complain = jiffies + 300 * HZ;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
2014-04-13 15:11:31 +00:00
|
|
|
|
|
|
|
/* Deal with the suid/sgid bit corner case */
|
2018-03-20 20:53:31 +00:00
|
|
|
if (nfs_should_remove_suid(inode)) {
|
|
|
|
spin_lock(&inode->i_lock);
|
2021-04-13 13:41:16 +00:00
|
|
|
nfs_set_cache_invalid(inode, NFS_INO_INVALID_MODE);
|
2018-03-20 20:53:31 +00:00
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
}
|
2014-05-06 13:12:32 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function is called when the WRITE call is complete.
|
|
|
|
*/
|
2014-06-09 15:48:35 +00:00
|
|
|
static void nfs_writeback_result(struct rpc_task *task,
|
|
|
|
struct nfs_pgio_header *hdr)
|
2014-05-06 13:12:32 +00:00
|
|
|
{
|
2014-06-09 15:48:35 +00:00
|
|
|
struct nfs_pgio_args *argp = &hdr->args;
|
|
|
|
struct nfs_pgio_res *resp = &hdr->res;
|
2014-04-13 15:11:31 +00:00
|
|
|
|
|
|
|
if (resp->count < argp->count) {
|
2005-04-16 22:20:36 +00:00
|
|
|
static unsigned long complain;
|
|
|
|
|
2012-04-20 18:47:47 +00:00
|
|
|
/* This a short write! */
|
2014-06-09 15:48:35 +00:00
|
|
|
nfs_inc_stats(hdr->inode, NFSIOS_SHORTWRITE);
|
2006-03-20 18:44:14 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Has the server at least made some progress? */
|
2012-04-20 18:47:47 +00:00
|
|
|
if (resp->count == 0) {
|
|
|
|
if (time_before(complain, jiffies)) {
|
|
|
|
printk(KERN_WARNING
|
|
|
|
"NFS: Server wrote zero bytes, expected %u.\n",
|
|
|
|
argp->count);
|
|
|
|
complain = jiffies + 300 * HZ;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2014-06-09 15:48:35 +00:00
|
|
|
nfs_set_pgio_error(hdr, -EIO, argp->offset);
|
2012-04-20 18:47:47 +00:00
|
|
|
task->tk_status = -EIO;
|
2011-02-11 15:42:38 +00:00
|
|
|
return;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2015-10-16 09:23:29 +00:00
|
|
|
|
|
|
|
/* For non rpc-based layout drivers, retry-through-MDS */
|
|
|
|
if (!task->tk_ops) {
|
|
|
|
hdr->pnfs_error = -EAGAIN;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-04-20 18:47:47 +00:00
|
|
|
/* Was this an NFSv2 write or an NFSv3 stable write? */
|
|
|
|
if (resp->verf->committed != NFS_UNSTABLE) {
|
|
|
|
/* Resend from where the server left off */
|
2014-06-09 15:48:35 +00:00
|
|
|
hdr->mds_offset += resp->count;
|
2012-04-20 18:47:47 +00:00
|
|
|
argp->offset += resp->count;
|
|
|
|
argp->pgbase += resp->count;
|
|
|
|
argp->count -= resp->count;
|
|
|
|
} else {
|
|
|
|
/* Resend as a stable write in order to avoid
|
|
|
|
* headaches in the case of a server crash.
|
|
|
|
*/
|
|
|
|
argp->stable = NFS_FILE_SYNC;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2020-01-06 20:25:13 +00:00
|
|
|
resp->count = 0;
|
|
|
|
resp->verf->committed = 0;
|
2012-04-20 18:47:47 +00:00
|
|
|
rpc_restart_call_prepare(task);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-30 00:34:05 +00:00
|
|
|
static int wait_on_commit(struct nfs_mds_commit_info *cinfo)
|
2010-04-22 19:35:57 +00:00
|
|
|
{
|
2018-03-15 10:44:34 +00:00
|
|
|
return wait_var_event_killable(&cinfo->rpcs_out,
|
|
|
|
!atomic_read(&cinfo->rpcs_out));
|
2015-09-30 00:34:05 +00:00
|
|
|
}
|
2011-03-21 19:37:01 +00:00
|
|
|
|
2015-09-30 00:34:05 +00:00
|
|
|
static void nfs_commit_begin(struct nfs_mds_commit_info *cinfo)
|
|
|
|
{
|
|
|
|
atomic_inc(&cinfo->rpcs_out);
|
2010-04-22 19:35:57 +00:00
|
|
|
}
|
|
|
|
|
2021-10-04 19:37:42 +00:00
|
|
|
bool nfs_commit_end(struct nfs_mds_commit_info *cinfo)
|
2010-04-22 19:35:57 +00:00
|
|
|
{
|
2021-10-04 19:37:42 +00:00
|
|
|
if (atomic_dec_and_test(&cinfo->rpcs_out)) {
|
2018-03-15 10:44:34 +00:00
|
|
|
wake_up_var(&cinfo->rpcs_out);
|
2021-10-04 19:37:42 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
2010-04-22 19:35:57 +00:00
|
|
|
}
|
|
|
|
|
2012-04-20 18:47:39 +00:00
|
|
|
void nfs_commitdata_release(struct nfs_commit_data *data)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2012-04-20 18:47:39 +00:00
|
|
|
put_nfs_open_context(data->context);
|
|
|
|
nfs_commit_free(data);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2011-03-23 13:27:53 +00:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_commitdata_release);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-04-20 18:47:39 +00:00
|
|
|
int nfs_initiate_commit(struct rpc_clnt *clnt, struct nfs_commit_data *data,
|
2014-06-08 23:10:14 +00:00
|
|
|
const struct nfs_rpc_ops *nfs_ops,
|
2011-03-23 13:27:45 +00:00
|
|
|
const struct rpc_call_ops *call_ops,
|
2012-04-27 21:53:44 +00:00
|
|
|
int how, int flags)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-10-25 22:42:54 +00:00
|
|
|
struct rpc_task *task;
|
2011-03-23 13:27:45 +00:00
|
|
|
int priority = flush_task_priority(how);
|
2007-07-14 19:40:00 +00:00
|
|
|
struct rpc_message msg = {
|
|
|
|
.rpc_argp = &data->args,
|
|
|
|
.rpc_resp = &data->res,
|
2011-03-23 13:27:45 +00:00
|
|
|
.rpc_cred = data->cred,
|
2007-07-14 19:40:00 +00:00
|
|
|
};
|
2007-07-14 19:39:59 +00:00
|
|
|
struct rpc_task_setup task_setup_data = {
|
2007-10-25 22:42:54 +00:00
|
|
|
.task = &data->task,
|
2011-03-23 13:27:45 +00:00
|
|
|
.rpc_client = clnt,
|
2007-07-14 19:40:00 +00:00
|
|
|
.rpc_message = &msg,
|
2011-03-23 13:27:45 +00:00
|
|
|
.callback_ops = call_ops,
|
2007-07-14 19:39:59 +00:00
|
|
|
.callback_data = data,
|
2008-02-20 01:04:23 +00:00
|
|
|
.workqueue = nfsiod_workqueue,
|
2020-05-13 13:55:36 +00:00
|
|
|
.flags = RPC_TASK_ASYNC | flags,
|
2007-07-14 19:40:00 +00:00
|
|
|
.priority = priority,
|
2007-07-14 19:39:59 +00:00
|
|
|
};
|
2022-05-25 16:12:59 +00:00
|
|
|
|
|
|
|
if (nfs_server_capable(data->inode, NFS_CAP_MOVEABLE))
|
|
|
|
task_setup_data.flags |= RPC_TASK_MOVEABLE;
|
|
|
|
|
2011-03-23 13:27:45 +00:00
|
|
|
/* Set up the initial task struct. */
|
2018-05-04 20:22:49 +00:00
|
|
|
nfs_ops->commit_setup(data, &msg, &task_setup_data.rpc_client);
|
2017-08-21 19:00:49 +00:00
|
|
|
trace_nfs_initiate_commit(data);
|
2011-03-23 13:27:45 +00:00
|
|
|
|
2015-07-01 04:00:13 +00:00
|
|
|
dprintk("NFS: initiated commit call\n");
|
2011-03-23 13:27:45 +00:00
|
|
|
|
|
|
|
task = rpc_run_task(&task_setup_data);
|
|
|
|
if (IS_ERR(task))
|
|
|
|
return PTR_ERR(task);
|
|
|
|
if (how & FLUSH_SYNC)
|
|
|
|
rpc_wait_for_completion_task(task);
|
|
|
|
rpc_put_task(task);
|
|
|
|
return 0;
|
|
|
|
}
|
2011-03-23 13:27:53 +00:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_initiate_commit);
|
2011-03-23 13:27:45 +00:00
|
|
|
|
2014-08-07 02:15:02 +00:00
|
|
|
static loff_t nfs_get_lwb(struct list_head *head)
|
|
|
|
{
|
|
|
|
loff_t lwb = 0;
|
|
|
|
struct nfs_page *req;
|
|
|
|
|
|
|
|
list_for_each_entry(req, head, wb_list)
|
|
|
|
if (lwb < (req_offset(req) + req->wb_bytes))
|
|
|
|
lwb = req_offset(req) + req->wb_bytes;
|
|
|
|
|
|
|
|
return lwb;
|
|
|
|
}
|
|
|
|
|
2011-03-23 13:27:45 +00:00
|
|
|
/*
|
|
|
|
* Set up the argument/result storage required for the RPC call.
|
|
|
|
*/
|
2012-04-20 18:47:39 +00:00
|
|
|
void nfs_init_commit(struct nfs_commit_data *data,
|
2012-04-20 18:47:54 +00:00
|
|
|
struct list_head *head,
|
|
|
|
struct pnfs_layout_segment *lseg,
|
|
|
|
struct nfs_commit_info *cinfo)
|
2011-03-23 13:27:45 +00:00
|
|
|
{
|
2020-03-19 21:29:12 +00:00
|
|
|
struct nfs_page *first;
|
|
|
|
struct nfs_open_context *ctx;
|
|
|
|
struct inode *inode;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Set up the RPC argument and reply structs
|
|
|
|
* NB: take care not to mess about with data->commit et al. */
|
|
|
|
|
2020-03-19 21:29:12 +00:00
|
|
|
if (head)
|
|
|
|
list_splice_init(head, &data->pages);
|
|
|
|
|
|
|
|
first = nfs_list_entry(data->pages.next);
|
|
|
|
ctx = nfs_req_openctx(first);
|
|
|
|
inode = d_inode(ctx->dentry);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
data->inode = inode;
|
2019-04-07 17:59:11 +00:00
|
|
|
data->cred = ctx->cred;
|
2011-03-23 13:27:52 +00:00
|
|
|
data->lseg = lseg; /* reference transferred */
|
2014-08-07 02:15:02 +00:00
|
|
|
/* only set lwb for pnfs commit */
|
|
|
|
if (lseg)
|
|
|
|
data->lwb = nfs_get_lwb(&data->pages);
|
2011-03-23 13:27:45 +00:00
|
|
|
data->mds_ops = &nfs_commit_ops;
|
2012-04-20 18:47:54 +00:00
|
|
|
data->completion_ops = cinfo->completion_ops;
|
2012-04-20 18:47:55 +00:00
|
|
|
data->dreq = cinfo->dreq;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
data->args.fh = NFS_FH(data->inode);
|
2005-06-22 17:16:31 +00:00
|
|
|
/* Note: we always request a commit of the entire inode */
|
|
|
|
data->args.offset = 0;
|
|
|
|
data->args.count = 0;
|
2019-04-07 17:59:11 +00:00
|
|
|
data->context = get_nfs_open_context(ctx);
|
2005-04-16 22:20:36 +00:00
|
|
|
data->res.fattr = &data->fattr;
|
|
|
|
data->res.verf = &data->verf;
|
2005-10-28 02:12:38 +00:00
|
|
|
nfs_fattr_init(&data->fattr);
|
2021-10-04 19:37:42 +00:00
|
|
|
nfs_commit_begin(cinfo->mds);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2011-03-23 13:27:53 +00:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_init_commit);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-03-23 13:27:53 +00:00
|
|
|
void nfs_retry_commit(struct list_head *page_list,
|
2012-04-20 18:47:53 +00:00
|
|
|
struct pnfs_layout_segment *lseg,
|
2014-09-05 22:20:21 +00:00
|
|
|
struct nfs_commit_info *cinfo,
|
|
|
|
u32 ds_commit_idx)
|
2011-03-23 13:27:47 +00:00
|
|
|
{
|
|
|
|
struct nfs_page *req;
|
|
|
|
|
|
|
|
while (!list_empty(page_list)) {
|
|
|
|
req = nfs_list_entry(page_list->next);
|
|
|
|
nfs_list_remove_request(req);
|
2014-09-05 22:20:21 +00:00
|
|
|
nfs_mark_request_commit(req, lseg, cinfo, ds_commit_idx);
|
2015-02-13 21:19:54 +00:00
|
|
|
if (!cinfo->dreq)
|
|
|
|
nfs_clear_page_commit(req->wb_page);
|
2012-05-09 18:04:55 +00:00
|
|
|
nfs_unlock_and_release_request(req);
|
2011-03-23 13:27:47 +00:00
|
|
|
}
|
|
|
|
}
|
2011-03-23 13:27:53 +00:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_retry_commit);
|
2011-03-23 13:27:47 +00:00
|
|
|
|
2015-12-31 14:28:06 +00:00
|
|
|
static void
|
|
|
|
nfs_commit_resched_write(struct nfs_commit_info *cinfo,
|
|
|
|
struct nfs_page *req)
|
|
|
|
{
|
|
|
|
__set_page_dirty_nobuffers(req->wb_page);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Commit dirty pages
|
|
|
|
*/
|
|
|
|
static int
|
2012-04-20 18:47:53 +00:00
|
|
|
nfs_commit_list(struct inode *inode, struct list_head *head, int how,
|
|
|
|
struct nfs_commit_info *cinfo)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2012-04-20 18:47:39 +00:00
|
|
|
struct nfs_commit_data *data;
|
2021-06-24 03:28:51 +00:00
|
|
|
unsigned short task_flags = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-05-25 14:07:23 +00:00
|
|
|
/* another commit raced with us */
|
|
|
|
if (list_empty(head))
|
|
|
|
return 0;
|
|
|
|
|
2022-03-21 16:34:19 +00:00
|
|
|
data = nfs_commitdata_alloc();
|
|
|
|
if (!data) {
|
|
|
|
nfs_retry_commit(head, NULL, cinfo, -1);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Set up the argument struct */
|
2012-04-20 18:47:54 +00:00
|
|
|
nfs_init_commit(data, head, NULL, cinfo);
|
2021-06-24 03:28:51 +00:00
|
|
|
if (NFS_SERVER(inode)->nfs_client->cl_minorversion)
|
|
|
|
task_flags = RPC_TASK_MOVEABLE;
|
2014-06-08 23:10:14 +00:00
|
|
|
return nfs_initiate_commit(NFS_CLIENT(inode), data, NFS_PROTO(inode),
|
2021-06-24 03:28:51 +00:00
|
|
|
data->mds_ops, how,
|
|
|
|
RPC_TASK_CRED_NOREF | task_flags);
|
2016-01-19 19:37:30 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* COMMIT call returned
|
|
|
|
*/
|
2006-03-20 18:44:27 +00:00
|
|
|
static void nfs_commit_done(struct rpc_task *task, void *calldata)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2012-04-20 18:47:39 +00:00
|
|
|
struct nfs_commit_data *data = calldata;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-03-20 18:44:27 +00:00
|
|
|
/* Call the NFS version-specific code */
|
2011-04-12 16:29:15 +00:00
|
|
|
NFS_PROTO(data->inode)->commit_done(task, data);
|
2020-01-06 20:25:10 +00:00
|
|
|
trace_nfs_commit_done(task, data);
|
2008-04-15 20:56:39 +00:00
|
|
|
}
|
|
|
|
|
2012-04-20 18:47:54 +00:00
|
|
|
static void nfs_commit_release_pages(struct nfs_commit_data *data)
|
2008-04-15 20:56:39 +00:00
|
|
|
{
|
2020-01-06 20:25:04 +00:00
|
|
|
const struct nfs_writeverf *verf = data->res.verf;
|
2011-03-23 13:27:48 +00:00
|
|
|
struct nfs_page *req;
|
2008-04-15 20:56:39 +00:00
|
|
|
int status = data->task.tk_status;
|
2012-04-20 18:47:54 +00:00
|
|
|
struct nfs_commit_info cinfo;
|
2014-09-24 01:28:32 +00:00
|
|
|
struct nfs_server *nfss;
|
2006-03-20 18:44:27 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
while (!list_empty(&data->pages)) {
|
|
|
|
req = nfs_list_entry(data->pages.next);
|
|
|
|
nfs_list_remove_request(req);
|
2016-01-19 19:37:30 +00:00
|
|
|
if (req->wb_page)
|
|
|
|
nfs_clear_page_commit(req->wb_page);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-12-17 17:20:16 +00:00
|
|
|
dprintk("NFS: commit (%s/%llu %d@%lld)",
|
2019-04-07 17:59:11 +00:00
|
|
|
nfs_req_openctx(req)->dentry->d_sb->s_id,
|
|
|
|
(unsigned long long)NFS_FILEID(d_inode(nfs_req_openctx(req)->dentry)),
|
2005-04-16 22:20:36 +00:00
|
|
|
req->wb_bytes,
|
|
|
|
(long long)req_offset(req));
|
2008-04-15 20:56:39 +00:00
|
|
|
if (status < 0) {
|
2019-04-07 17:59:05 +00:00
|
|
|
if (req->wb_page) {
|
2022-08-09 16:50:28 +00:00
|
|
|
trace_nfs_commit_error(data->inode, req,
|
|
|
|
status);
|
2019-04-07 17:59:05 +00:00
|
|
|
nfs_mapping_set_error(req->wb_page, status);
|
2017-03-09 03:36:36 +00:00
|
|
|
nfs_inode_remove_request(req);
|
2019-04-07 17:59:05 +00:00
|
|
|
}
|
2016-10-15 20:59:03 +00:00
|
|
|
dprintk_cont(", error = %d\n", status);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Okay, COMMIT succeeded, apparently. Check the verifier
|
|
|
|
* returned by the server against all stored verfs. */
|
2020-03-21 13:27:46 +00:00
|
|
|
if (nfs_write_match_verf(verf, req)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* We have a match */
|
2017-03-09 03:36:36 +00:00
|
|
|
if (req->wb_page)
|
|
|
|
nfs_inode_remove_request(req);
|
2016-10-15 20:59:03 +00:00
|
|
|
dprintk_cont(" OK\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
/* We have a mismatch. Write the page again */
|
2016-10-15 20:59:03 +00:00
|
|
|
dprintk_cont(" mismatch\n");
|
2008-03-19 15:24:38 +00:00
|
|
|
nfs_mark_request_dirty(req);
|
2022-08-13 12:22:25 +00:00
|
|
|
atomic_long_inc(&NFS_I(data->inode)->redirtied_pages);
|
2005-04-16 22:20:36 +00:00
|
|
|
next:
|
2012-05-09 18:04:55 +00:00
|
|
|
nfs_unlock_and_release_request(req);
|
2017-12-18 19:39:13 +00:00
|
|
|
/* Latency breaker */
|
|
|
|
cond_resched();
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2014-09-24 01:28:32 +00:00
|
|
|
nfss = NFS_SERVER(data->inode);
|
|
|
|
if (atomic_long_read(&nfss->writeback) < NFS_CONGESTION_OFF_THRESH)
|
2022-03-22 21:39:01 +00:00
|
|
|
nfss->write_congested = 0;
|
2014-09-24 01:28:32 +00:00
|
|
|
|
2012-04-20 18:47:54 +00:00
|
|
|
nfs_init_cinfo(&cinfo, data->inode, data->dreq);
|
2015-09-30 00:34:05 +00:00
|
|
|
nfs_commit_end(cinfo.mds);
|
2011-03-23 13:27:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void nfs_commit_release(void *calldata)
|
|
|
|
{
|
2012-04-20 18:47:39 +00:00
|
|
|
struct nfs_commit_data *data = calldata;
|
2011-03-23 13:27:48 +00:00
|
|
|
|
2012-04-20 18:47:54 +00:00
|
|
|
data->completion_ops->completion(data);
|
2008-04-15 20:56:39 +00:00
|
|
|
nfs_commitdata_release(calldata);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2006-03-20 18:44:27 +00:00
|
|
|
|
|
|
|
static const struct rpc_call_ops nfs_commit_ops = {
|
2012-04-20 18:47:39 +00:00
|
|
|
.rpc_call_prepare = nfs_commit_prepare,
|
2006-03-20 18:44:27 +00:00
|
|
|
.rpc_call_done = nfs_commit_done,
|
|
|
|
.rpc_release = nfs_commit_release,
|
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-04-20 18:47:54 +00:00
|
|
|
static const struct nfs_commit_completion_ops nfs_commit_completion_ops = {
|
|
|
|
.completion = nfs_commit_release_pages,
|
2015-12-31 14:28:06 +00:00
|
|
|
.resched_write = nfs_commit_resched_write,
|
2012-04-20 18:47:54 +00:00
|
|
|
};
|
|
|
|
|
2012-04-20 18:47:57 +00:00
|
|
|
int nfs_generic_commit_list(struct inode *inode, struct list_head *head,
|
|
|
|
int how, struct nfs_commit_info *cinfo)
|
2012-04-20 18:47:52 +00:00
|
|
|
{
|
|
|
|
int status;
|
|
|
|
|
2012-04-20 18:47:53 +00:00
|
|
|
status = pnfs_commit_list(inode, head, how, cinfo);
|
2012-04-20 18:47:52 +00:00
|
|
|
if (status == PNFS_NOT_ATTEMPTED)
|
2012-04-20 18:47:53 +00:00
|
|
|
status = nfs_commit_list(inode, head, how, cinfo);
|
2012-04-20 18:47:52 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2018-03-07 20:22:31 +00:00
|
|
|
static int __nfs_commit_inode(struct inode *inode, int how,
|
|
|
|
struct writeback_control *wbc)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
LIST_HEAD(head);
|
2012-04-20 18:47:53 +00:00
|
|
|
struct nfs_commit_info cinfo;
|
2010-04-22 19:35:57 +00:00
|
|
|
int may_wait = how & FLUSH_SYNC;
|
2018-03-07 20:22:31 +00:00
|
|
|
int ret, nscan;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-10-04 19:44:16 +00:00
|
|
|
how &= ~FLUSH_SYNC;
|
2012-04-20 18:47:53 +00:00
|
|
|
nfs_init_cinfo_from_inode(&cinfo, inode);
|
2015-09-30 00:34:05 +00:00
|
|
|
nfs_commit_begin(cinfo.mds);
|
2018-03-07 20:22:31 +00:00
|
|
|
for (;;) {
|
|
|
|
ret = nscan = nfs_scan_commit(inode, &head, &cinfo);
|
|
|
|
if (ret <= 0)
|
|
|
|
break;
|
|
|
|
ret = nfs_generic_commit_list(inode, &head, how, &cinfo);
|
|
|
|
if (ret < 0)
|
|
|
|
break;
|
|
|
|
ret = 0;
|
|
|
|
if (wbc && wbc->sync_mode == WB_SYNC_NONE) {
|
|
|
|
if (nscan < wbc->nr_to_write)
|
|
|
|
wbc->nr_to_write -= nscan;
|
|
|
|
else
|
|
|
|
wbc->nr_to_write = 0;
|
|
|
|
}
|
|
|
|
if (nscan < INT_MAX)
|
|
|
|
break;
|
|
|
|
cond_resched();
|
|
|
|
}
|
2015-09-30 00:34:05 +00:00
|
|
|
nfs_commit_end(cinfo.mds);
|
2018-03-07 20:22:31 +00:00
|
|
|
if (ret || !may_wait)
|
|
|
|
return ret;
|
|
|
|
return wait_on_commit(cinfo.mds);
|
|
|
|
}
|
|
|
|
|
|
|
|
int nfs_commit_inode(struct inode *inode, int how)
|
|
|
|
{
|
|
|
|
return __nfs_commit_inode(inode, how, NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2015-12-31 14:28:06 +00:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_commit_inode);
|
2010-02-20 00:46:56 +00:00
|
|
|
|
2015-07-13 18:01:32 +00:00
|
|
|
int nfs_write_inode(struct inode *inode, struct writeback_control *wbc)
|
2010-02-20 00:46:56 +00:00
|
|
|
{
|
2010-02-20 01:00:02 +00:00
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
int flags = FLUSH_SYNC;
|
|
|
|
int ret = 0;
|
2010-02-20 00:46:56 +00:00
|
|
|
|
2010-09-28 13:14:01 +00:00
|
|
|
if (wbc->sync_mode == WB_SYNC_NONE) {
|
2018-03-07 20:22:31 +00:00
|
|
|
/* no commits means nothing needs to be done */
|
|
|
|
if (!atomic_long_read(&nfsi->commit_info.ncommit))
|
|
|
|
goto check_requests_outstanding;
|
|
|
|
|
2010-09-28 13:14:01 +00:00
|
|
|
/* Don't commit yet if this is a non-blocking flush and there
|
|
|
|
* are a lot of outstanding writes for this mapping.
|
|
|
|
*/
|
2017-06-20 23:35:38 +00:00
|
|
|
if (mapping_tagged(inode->i_mapping, PAGECACHE_TAG_WRITEBACK))
|
2010-09-28 13:14:01 +00:00
|
|
|
goto out_mark_dirty;
|
2010-02-20 01:00:02 +00:00
|
|
|
|
2010-09-28 13:14:01 +00:00
|
|
|
/* don't wait for the COMMIT response */
|
2010-02-20 01:00:02 +00:00
|
|
|
flags = 0;
|
2010-09-28 13:14:01 +00:00
|
|
|
}
|
|
|
|
|
2018-03-07 20:22:31 +00:00
|
|
|
ret = __nfs_commit_inode(inode, flags, wbc);
|
|
|
|
if (!ret) {
|
|
|
|
if (flags & FLUSH_SYNC)
|
|
|
|
return 0;
|
|
|
|
} else if (atomic_long_read(&nfsi->commit_info.ncommit))
|
|
|
|
goto out_mark_dirty;
|
|
|
|
|
|
|
|
check_requests_outstanding:
|
|
|
|
if (!atomic_read(&nfsi->commit_info.rpcs_out))
|
|
|
|
return ret;
|
2010-02-20 01:00:02 +00:00
|
|
|
out_mark_dirty:
|
2010-02-20 00:46:56 +00:00
|
|
|
__mark_inode_dirty(inode, I_DIRTY_DATASYNC);
|
|
|
|
return ret;
|
|
|
|
}
|
2012-07-30 20:05:25 +00:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_write_inode);
|
2012-06-20 19:53:49 +00:00
|
|
|
|
2016-06-25 22:12:03 +00:00
|
|
|
/*
|
|
|
|
* Wrapper for filemap_write_and_wait_range()
|
|
|
|
*
|
|
|
|
* Needed for pNFS in order to ensure data becomes visible to the
|
|
|
|
* client.
|
|
|
|
*/
|
|
|
|
int nfs_filemap_write_and_wait_range(struct address_space *mapping,
|
|
|
|
loff_t lstart, loff_t lend)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = filemap_write_and_wait_range(mapping, lstart, lend);
|
|
|
|
if (ret == 0)
|
|
|
|
ret = pnfs_sync_inode(mapping->host, true);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nfs_filemap_write_and_wait_range);
|
|
|
|
|
2010-02-20 01:03:26 +00:00
|
|
|
/*
|
|
|
|
* flush the inode to disk.
|
|
|
|
*/
|
|
|
|
int nfs_wb_all(struct inode *inode)
|
2007-07-25 18:09:54 +00:00
|
|
|
{
|
2013-08-19 22:59:33 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
trace_nfs_writeback_inode_enter(inode);
|
|
|
|
|
2015-03-25 18:14:42 +00:00
|
|
|
ret = filemap_write_and_wait(inode->i_mapping);
|
2015-05-06 22:26:58 +00:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
ret = nfs_commit_inode(inode, FLUSH_SYNC);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
pnfs_sync_inode(inode, true);
|
|
|
|
ret = 0;
|
2007-07-25 18:09:54 +00:00
|
|
|
|
2015-05-06 22:26:58 +00:00
|
|
|
out:
|
2013-08-19 22:59:33 +00:00
|
|
|
trace_nfs_writeback_inode_exit(inode, ret);
|
|
|
|
return ret;
|
2006-10-09 20:18:38 +00:00
|
|
|
}
|
2012-07-30 20:05:23 +00:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_wb_all);
|
2006-10-09 20:18:38 +00:00
|
|
|
|
2022-02-09 20:21:47 +00:00
|
|
|
int nfs_wb_folio_cancel(struct inode *inode, struct folio *folio)
|
2007-08-28 14:29:36 +00:00
|
|
|
{
|
|
|
|
struct nfs_page *req;
|
|
|
|
int ret = 0;
|
|
|
|
|
2022-02-09 20:21:47 +00:00
|
|
|
folio_wait_writeback(folio);
|
2014-07-11 14:20:49 +00:00
|
|
|
|
|
|
|
/* blocking call to cancel all requests and join to a single (head)
|
|
|
|
* request */
|
2022-02-09 20:21:47 +00:00
|
|
|
req = nfs_lock_and_join_requests(&folio->page);
|
2014-07-11 14:20:49 +00:00
|
|
|
|
|
|
|
if (IS_ERR(req)) {
|
|
|
|
ret = PTR_ERR(req);
|
|
|
|
} else if (req) {
|
2022-02-09 20:21:47 +00:00
|
|
|
/* all requests from this folio have been cancelled by
|
2014-07-11 14:20:49 +00:00
|
|
|
* nfs_lock_and_join_requests, so just remove the head
|
|
|
|
* request from the inode / page_private pointer and
|
|
|
|
* release it */
|
|
|
|
nfs_inode_remove_request(req);
|
|
|
|
nfs_unlock_and_release_request(req);
|
2007-08-28 14:29:36 +00:00
|
|
|
}
|
2014-07-11 14:20:49 +00:00
|
|
|
|
2007-08-28 14:29:36 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-02-20 01:03:28 +00:00
|
|
|
/*
|
|
|
|
* Write back all requests on one page - we do this before reading it.
|
|
|
|
*/
|
2017-04-26 16:26:22 +00:00
|
|
|
int nfs_wb_page(struct inode *inode, struct page *page)
|
2006-10-09 20:18:38 +00:00
|
|
|
{
|
2012-07-31 23:45:10 +00:00
|
|
|
loff_t range_start = page_file_offset(page);
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
loff_t range_end = range_start + (loff_t)(PAGE_SIZE - 1);
|
2006-12-05 05:35:41 +00:00
|
|
|
struct writeback_control wbc = {
|
|
|
|
.sync_mode = WB_SYNC_ALL,
|
2010-02-20 01:03:28 +00:00
|
|
|
.nr_to_write = 0,
|
2006-12-05 05:35:41 +00:00
|
|
|
.range_start = range_start,
|
|
|
|
.range_end = range_end,
|
|
|
|
};
|
|
|
|
int ret;
|
2006-10-09 20:18:38 +00:00
|
|
|
|
2013-08-19 22:59:33 +00:00
|
|
|
trace_nfs_writeback_page_enter(inode);
|
|
|
|
|
2010-05-26 12:42:24 +00:00
|
|
|
for (;;) {
|
2010-04-27 22:33:54 +00:00
|
|
|
wait_on_page_writeback(page);
|
2008-04-11 20:03:54 +00:00
|
|
|
if (clear_page_dirty_for_io(page)) {
|
2017-04-26 16:26:22 +00:00
|
|
|
ret = nfs_writepage_locked(page, &wbc);
|
2008-04-11 20:03:54 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto out_error;
|
2010-05-26 12:42:24 +00:00
|
|
|
continue;
|
2010-02-20 01:03:28 +00:00
|
|
|
}
|
2013-08-19 22:59:33 +00:00
|
|
|
ret = 0;
|
2010-05-26 12:42:24 +00:00
|
|
|
if (!PagePrivate(page))
|
|
|
|
break;
|
|
|
|
ret = nfs_commit_inode(inode, FLUSH_SYNC);
|
2010-04-27 22:33:54 +00:00
|
|
|
if (ret < 0)
|
2008-04-11 20:03:54 +00:00
|
|
|
goto out_error;
|
2010-02-20 01:03:28 +00:00
|
|
|
}
|
2008-04-11 20:03:54 +00:00
|
|
|
out_error:
|
2013-08-19 22:59:33 +00:00
|
|
|
trace_nfs_writeback_page_exit(inode, ret);
|
2006-12-05 05:35:41 +00:00
|
|
|
return ret;
|
2006-10-09 20:18:38 +00:00
|
|
|
}
|
|
|
|
|
2009-08-10 12:54:13 +00:00
|
|
|
#ifdef CONFIG_MIGRATION
|
2022-06-06 13:22:19 +00:00
|
|
|
int nfs_migrate_folio(struct address_space *mapping, struct folio *dst,
|
|
|
|
struct folio *src, enum migrate_mode mode)
|
2009-08-10 12:54:13 +00:00
|
|
|
{
|
2011-10-12 14:57:42 +00:00
|
|
|
/*
|
2022-06-06 13:22:19 +00:00
|
|
|
* If the private flag is set, the folio is currently associated with
|
2011-10-12 14:57:42 +00:00
|
|
|
* an in-progress read or write request. Don't try to migrate it.
|
|
|
|
*
|
|
|
|
* FIXME: we could do this in principle, but we'll need a way to ensure
|
|
|
|
* that we can safely release the inode reference while holding
|
2022-06-06 13:22:19 +00:00
|
|
|
* the folio lock.
|
2011-10-12 14:57:42 +00:00
|
|
|
*/
|
2022-06-06 13:22:19 +00:00
|
|
|
if (folio_test_private(src))
|
2011-10-12 14:57:42 +00:00
|
|
|
return -EBUSY;
|
2009-08-10 12:54:13 +00:00
|
|
|
|
2022-06-06 13:22:19 +00:00
|
|
|
if (folio_test_fscache(src)) {
|
2021-08-27 14:19:34 +00:00
|
|
|
if (mode == MIGRATE_ASYNC)
|
|
|
|
return -EBUSY;
|
2022-06-06 13:22:19 +00:00
|
|
|
folio_wait_fscache(src);
|
2021-08-27 14:19:34 +00:00
|
|
|
}
|
2009-08-10 12:54:13 +00:00
|
|
|
|
2022-06-06 14:27:41 +00:00
|
|
|
return migrate_folio(mapping, dst, src, mode);
|
2009-08-10 12:54:13 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
NFS: Split fs/nfs/inode.c
As fs/nfs/inode.c is rather large, heterogenous and unwieldy, the attached
patch splits it up into a number of files:
(*) fs/nfs/inode.c
Strictly inode specific functions.
(*) fs/nfs/super.c
Superblock management functions for NFS and NFS4, normal access, clones
and referrals. The NFS4 superblock functions _could_ move out into a
separate conditionally compiled file, but it's probably not worth it as
there're so many common bits.
(*) fs/nfs/namespace.c
Some namespace-specific functions have been moved here.
(*) fs/nfs/nfs4namespace.c
NFS4-specific namespace functions (this could be merged into the previous
file). This file is conditionally compiled.
(*) fs/nfs/internal.h
Inter-file declarations, plus a few simple utility functions moved from
fs/nfs/inode.c.
Additionally, all the in-.c-file externs have been moved here, and those
files they were moved from now includes this file.
For the most part, the functions have not been changed, only some multiplexor
functions have changed significantly.
I've also:
(*) Added some extra banner comments above some functions.
(*) Rearranged the function order within the files to be more logical and
better grouped (IMO), though someone may prefer a different order.
(*) Reduced the number of #ifdefs in .c files.
(*) Added missing __init and __exit directives.
Signed-Off-By: David Howells <dhowells@redhat.com>
2006-06-09 13:34:33 +00:00
|
|
|
int __init nfs_init_writepagecache(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
nfs_wdata_cachep = kmem_cache_create("nfs_write_data",
|
2014-06-09 15:48:33 +00:00
|
|
|
sizeof(struct nfs_pgio_header),
|
2005-04-16 22:20:36 +00:00
|
|
|
0, SLAB_HWCACHE_ALIGN,
|
2007-07-20 01:11:58 +00:00
|
|
|
NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (nfs_wdata_cachep == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2006-03-26 09:37:50 +00:00
|
|
|
nfs_wdata_mempool = mempool_create_slab_pool(MIN_POOL_WRITE,
|
|
|
|
nfs_wdata_cachep);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (nfs_wdata_mempool == NULL)
|
2012-08-02 18:30:56 +00:00
|
|
|
goto out_destroy_write_cache;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-04-20 18:47:39 +00:00
|
|
|
nfs_cdata_cachep = kmem_cache_create("nfs_commit_data",
|
|
|
|
sizeof(struct nfs_commit_data),
|
|
|
|
0, SLAB_HWCACHE_ALIGN,
|
|
|
|
NULL);
|
|
|
|
if (nfs_cdata_cachep == NULL)
|
2012-08-02 18:30:56 +00:00
|
|
|
goto out_destroy_write_mempool;
|
2012-04-20 18:47:39 +00:00
|
|
|
|
2006-03-26 09:37:50 +00:00
|
|
|
nfs_commit_mempool = mempool_create_slab_pool(MIN_POOL_COMMIT,
|
2012-11-12 01:27:37 +00:00
|
|
|
nfs_cdata_cachep);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (nfs_commit_mempool == NULL)
|
2012-08-02 18:30:56 +00:00
|
|
|
goto out_destroy_commit_cache;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-03-16 21:38:26 +00:00
|
|
|
/*
|
|
|
|
* NFS congestion size, scale with available memory.
|
|
|
|
*
|
|
|
|
* 64MB: 8192k
|
|
|
|
* 128MB: 11585k
|
|
|
|
* 256MB: 16384k
|
|
|
|
* 512MB: 23170k
|
|
|
|
* 1GB: 32768k
|
|
|
|
* 2GB: 46340k
|
|
|
|
* 4GB: 65536k
|
|
|
|
* 8GB: 92681k
|
|
|
|
* 16GB: 131072k
|
|
|
|
*
|
|
|
|
* This allows larger machines to have larger/more transfers.
|
|
|
|
* Limit the default to 256M
|
|
|
|
*/
|
2018-12-28 08:34:29 +00:00
|
|
|
nfs_congestion_kb = (16*int_sqrt(totalram_pages())) << (PAGE_SHIFT-10);
|
2007-03-16 21:38:26 +00:00
|
|
|
if (nfs_congestion_kb > 256*1024)
|
|
|
|
nfs_congestion_kb = 256*1024;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
2012-08-02 18:30:56 +00:00
|
|
|
|
|
|
|
out_destroy_commit_cache:
|
|
|
|
kmem_cache_destroy(nfs_cdata_cachep);
|
|
|
|
out_destroy_write_mempool:
|
|
|
|
mempool_destroy(nfs_wdata_mempool);
|
|
|
|
out_destroy_write_cache:
|
|
|
|
kmem_cache_destroy(nfs_wdata_cachep);
|
|
|
|
return -ENOMEM;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-06-27 19:59:15 +00:00
|
|
|
void nfs_destroy_writepagecache(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
mempool_destroy(nfs_commit_mempool);
|
2012-08-02 18:30:56 +00:00
|
|
|
kmem_cache_destroy(nfs_cdata_cachep);
|
2005-04-16 22:20:36 +00:00
|
|
|
mempool_destroy(nfs_wdata_mempool);
|
2006-09-27 08:49:40 +00:00
|
|
|
kmem_cache_destroy(nfs_wdata_cachep);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2014-05-06 13:12:30 +00:00
|
|
|
static const struct nfs_rw_ops nfs_rw_write_ops = {
|
|
|
|
.rw_alloc_header = nfs_writehdr_alloc,
|
|
|
|
.rw_free_header = nfs_writehdr_free,
|
2014-05-06 13:12:32 +00:00
|
|
|
.rw_done = nfs_writeback_done,
|
|
|
|
.rw_result = nfs_writeback_result,
|
2014-05-06 13:12:37 +00:00
|
|
|
.rw_initiate = nfs_initiate_write,
|
2014-05-06 13:12:30 +00:00
|
|
|
};
|