mirror of
https://github.com/torvalds/linux.git
synced 2024-12-11 13:41:55 +00:00
ffb4025961
The work of closing a file can have non-trivial cost. Doing it in a separate work queue thread means that cost isn't imposed on the nfsd threads and an imbalance can be created. This can result in files being queued for the work queue more quickly that the work queue can process them, resulting in unbounded growth of the queue and memory exhaustion. To avoid this work imbalance that exhausts memory, this patch moves all closing of files into the nfsd threads. This means that when the work imposes a cost, that cost appears where it would be expected - in the work of the nfsd thread. A subsequent patch will ensure the final __fput() is called in the same (nfsd) thread which calls filp_close(). Files opened for NFSv3 are never explicitly closed by the client and are kept open by the server in the "filecache", which responds to memory pressure, is garbage collected even when there is no pressure, and sometimes closes files when there is particular need such as for rename. These files currently have filp_close() called in a dedicated work queue, so their __fput() can have no effect on nfsd threads. This patch discards the work queue and instead has each nfsd thread call flip_close() on as many as 8 files from the filecache each time it acts on a client request (or finds there are no pending client requests). If there are more to be closed, more threads are woken. This spreads the work of __fput() over multiple threads and imposes any cost on those threads. The number 8 is somewhat arbitrary. It needs to be greater than 1 to ensure that files are closed more quickly than they can be added to the cache. It needs to be small enough to limit the per-request delays that will be imposed on clients when all threads are busy closing files. Signed-off-by: NeilBrown <neilb@suse.de> Reviewed-by: Jeff Layton <jlayton@kernel.org> Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
70 lines
2.6 KiB
C
70 lines
2.6 KiB
C
#ifndef _FS_NFSD_FILECACHE_H
|
|
#define _FS_NFSD_FILECACHE_H
|
|
|
|
#include <linux/fsnotify_backend.h>
|
|
|
|
/*
|
|
* This is the fsnotify_mark container that nfsd attaches to the files that it
|
|
* is holding open. Note that we have a separate refcount here aside from the
|
|
* one in the fsnotify_mark. We only want a single fsnotify_mark attached to
|
|
* the inode, and for each nfsd_file to hold a reference to it.
|
|
*
|
|
* The fsnotify_mark is itself refcounted, but that's not sufficient to tell us
|
|
* how to put that reference. If there are still outstanding nfsd_files that
|
|
* reference the mark, then we would want to call fsnotify_put_mark on it.
|
|
* If there were not, then we'd need to call fsnotify_destroy_mark. Since we
|
|
* can't really tell the difference, we use the nfm_mark to keep track of how
|
|
* many nfsd_files hold references to the mark. When that counter goes to zero
|
|
* then we know to call fsnotify_destroy_mark on it.
|
|
*/
|
|
struct nfsd_file_mark {
|
|
struct fsnotify_mark nfm_mark;
|
|
refcount_t nfm_ref;
|
|
};
|
|
|
|
/*
|
|
* A representation of a file that has been opened by knfsd. These are hashed
|
|
* in the hashtable by inode pointer value. Note that this object doesn't
|
|
* hold a reference to the inode by itself, so the nf_inode pointer should
|
|
* never be dereferenced, only used for comparison.
|
|
*/
|
|
struct nfsd_file {
|
|
struct rhlist_head nf_rlist;
|
|
void *nf_inode;
|
|
struct file *nf_file;
|
|
const struct cred *nf_cred;
|
|
struct net *nf_net;
|
|
#define NFSD_FILE_HASHED (0)
|
|
#define NFSD_FILE_PENDING (1)
|
|
#define NFSD_FILE_REFERENCED (2)
|
|
#define NFSD_FILE_GC (3)
|
|
unsigned long nf_flags;
|
|
refcount_t nf_ref;
|
|
unsigned char nf_may;
|
|
|
|
struct nfsd_file_mark *nf_mark;
|
|
struct list_head nf_lru;
|
|
struct rcu_head nf_rcu;
|
|
ktime_t nf_birthtime;
|
|
};
|
|
|
|
int nfsd_file_cache_init(void);
|
|
void nfsd_file_cache_purge(struct net *);
|
|
void nfsd_file_cache_shutdown(void);
|
|
int nfsd_file_cache_start_net(struct net *net);
|
|
void nfsd_file_cache_shutdown_net(struct net *net);
|
|
void nfsd_file_put(struct nfsd_file *nf);
|
|
struct nfsd_file *nfsd_file_get(struct nfsd_file *nf);
|
|
void nfsd_file_close_inode_sync(struct inode *inode);
|
|
void nfsd_file_net_dispose(struct nfsd_net *nn);
|
|
bool nfsd_file_is_cached(struct inode *inode);
|
|
__be32 nfsd_file_acquire_gc(struct svc_rqst *rqstp, struct svc_fh *fhp,
|
|
unsigned int may_flags, struct nfsd_file **nfp);
|
|
__be32 nfsd_file_acquire(struct svc_rqst *rqstp, struct svc_fh *fhp,
|
|
unsigned int may_flags, struct nfsd_file **nfp);
|
|
__be32 nfsd_file_acquire_opened(struct svc_rqst *rqstp, struct svc_fh *fhp,
|
|
unsigned int may_flags, struct file *file,
|
|
struct nfsd_file **nfp);
|
|
int nfsd_file_cache_stats_show(struct seq_file *m, void *v);
|
|
#endif /* _FS_NFSD_FILECACHE_H */
|