forked from Minki/linux
f008b1d6e1
-----BEGIN PGP SIGNATURE-----
iQIzBAABCAAdFiEEqG5UsNXhtOCrfGQP+7dXa6fLC2sFAmI1HOwACgkQ+7dXa6fL
C2u9mA/+LUdXHqlvET/PAtFTg75bUPeOFGLnuDnYl1Ng2FCKMSodAohpbVtENxsK
E/gTVS7uiVZFQgC+YmNA00z6eIQkAaDVyvKyEcUbKREBbUgONfJ/HLeaK/NvVKxx
TY5gx/POdG6yHRQXL6JGBqSJUB8bZrGKwnJm8ebzeKOji9n7GSJBYiMlYBA7EAhs
Aut/P7Y39ISHLw3y+y5czBeRoubljmTyznbP20xUZEzrRwhTpNwpJVzBGUZU635T
93Sqcp//0U5LIdn6Pg6DUGHBMBTNDNJChb21ZoBusF/HHswXsOOnf/mcRUBSJUTI
M1WSpNLk8PRBgajMdIymQpGU1sCZZzJ3krrSA3RcXdN6GPHwZg8kKjoroHsLDL6l
igPbDSMJ5wfiwA2A2gXbY1CkAl3ik5ccb7ZqhTwS0WBk0vOnHmAsE9cs/bBo7Xii
GTiWXEFOgtJiXANPMS2P9DiOS3ZQNf+wxotCYdkGPOXuX9wnIo1Kmy8XfujQ1bXf
pJsEZKfeyROKrzyKWgqLI64/Kg5xNueoFQZfDpOlZYzF1uDstynADPUt0eQD706q
jcuKaXLN3rn5gSPun5mWOYbRtXVgOLdFL/7zptMVJwFKBFguQENhjG4UMNZcjkVA
3Mr0kGocsgoCSk1oDBkFlrw1wIsXxWbkRBL1Pww6kovivuGUwoo=
=j0yx
-----END PGP SIGNATURE-----
Merge tag 'netfs-prep-20220318' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs
Pull netfs updates from David Howells:
"Netfs prep for write helpers.
Having had a go at implementing write helpers and content encryption
support in netfslib, it seems that the netfs_read_{,sub}request
structs and the equivalent write request structs were almost the same
and so should be merged, thereby requiring only one set of
alloc/get/put functions and a common set of tracepoints.
Merging the structs also has the advantage that if a bounce buffer is
added to the request struct, a read operation can be performed to fill
the bounce buffer, the contents of the buffer can be modified and then
a write operation can be performed on it to send the data wherever it
needs to go using the same request structure all the way through. The
I/O handlers would then transparently perform any required crypto.
This should make it easier to perform RMW cycles if needed.
The potentially common functions and structs, however, by their names
all proclaim themselves to be associated with the read side of things.
The bulk of these changes alter this in the following ways:
- Rename struct netfs_read_{,sub}request to netfs_io_{,sub}request.
- Rename some enums, members and flags to make them more appropriate.
- Adjust some comments to match.
- Drop "read"/"rreq" from the names of common functions. For
instance, netfs_get_read_request() becomes netfs_get_request().
- The ->init_rreq() and ->issue_op() methods become ->init_request()
and ->issue_read(). I've kept the latter as a read-specific
function and in another branch added an ->issue_write() method.
The driver source is then reorganised into a number of files:
fs/netfs/buffered_read.c Create read reqs to the pagecache
fs/netfs/io.c Dispatchers for read and write reqs
fs/netfs/main.c Some general miscellaneous bits
fs/netfs/objects.c Alloc, get and put functions
fs/netfs/stats.c Optional procfs statistics.
and future development can be fitted into this scheme, e.g.:
fs/netfs/buffered_write.c Modify the pagecache
fs/netfs/buffered_flush.c Writeback from the pagecache
fs/netfs/direct_read.c DIO read support
fs/netfs/direct_write.c DIO write support
fs/netfs/unbuffered_write.c Write modifications directly back
Beyond the above changes, there are also some changes that affect how
things work:
- Make fscache_end_operation() generally available.
- In the netfs tracing header, generate enums from the symbol ->
string mapping tables rather than manually coding them.
- Add a struct for filesystems that uses netfslib to put into their
inode wrapper structs to hold extra state that netfslib is
interested in, such as the fscache cookie. This allows netfslib
functions to be set in filesystem operation tables and jumped to
directly without having to have a filesystem wrapper.
- Add a member to the struct added above to track the remote inode
length as that may differ if local modifications are buffered. We
may need to supply an appropriate EOF pointer when storing data (in
AFS for example).
- Pass extra information to netfs_alloc_request() so that the
->init_request() hook can access it and retain information to
indicate the origin of the operation.
- Make the ->init_request() hook return an error, thereby allowing a
filesystem that isn't allowed to cache an inode (ceph or cifs, for
example) to skip readahead.
- Switch to using refcount_t for subrequests and add tracepoints to
log refcount changes for the request and subrequest structs.
- Add a function to consolidate dispatching a read request. Similar
code is used in three places and another couple are likely to be
added in the future"
Link: https://lore.kernel.org/all/2639515.1648483225@warthog.procyon.org.uk/
* tag 'netfs-prep-20220318' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs:
afs: Maintain netfs_i_context::remote_i_size
netfs: Keep track of the actual remote file size
netfs: Split some core bits out into their own file
netfs: Split fs/netfs/read_helper.c
netfs: Rename read_helper.c to io.c
netfs: Prepare to split read_helper.c
netfs: Add a function to consolidate beginning a read
netfs: Add a netfs inode context
ceph: Make ceph_init_request() check caps on readahead
netfs: Change ->init_request() to return an error code
netfs: Refactor arguments for netfs_alloc_read_request
netfs: Adjust the netfs_failure tracepoint to indicate non-subreq lines
netfs: Trace refcounting on the netfs_io_subrequest struct
netfs: Trace refcounting on the netfs_io_request struct
netfs: Adjust the netfs_rreq tracepoint slightly
netfs: Split netfs_io_* object handling out
netfs: Finish off rename of netfs_read_request to netfs_io_request
netfs: Rename netfs_read_*request to netfs_io_*request
netfs: Generate enums from trace symbol mapping lists
fscache: export fscache_end_operation()
149 lines
3.6 KiB
C
149 lines
3.6 KiB
C
/* SPDX-License-Identifier: GPL-2.0-only */
|
|
/*
|
|
* Ceph cache definitions.
|
|
*
|
|
* Copyright (C) 2013 by Adfin Solutions, Inc. All Rights Reserved.
|
|
* Written by Milosz Tanski (milosz@adfin.com)
|
|
*/
|
|
|
|
#ifndef _CEPH_CACHE_H
|
|
#define _CEPH_CACHE_H
|
|
|
|
#include <linux/netfs.h>
|
|
|
|
#ifdef CONFIG_CEPH_FSCACHE
|
|
#include <linux/fscache.h>
|
|
|
|
int ceph_fscache_register_fs(struct ceph_fs_client* fsc, struct fs_context *fc);
|
|
void ceph_fscache_unregister_fs(struct ceph_fs_client* fsc);
|
|
|
|
void ceph_fscache_register_inode_cookie(struct inode *inode);
|
|
void ceph_fscache_unregister_inode_cookie(struct ceph_inode_info* ci);
|
|
|
|
void ceph_fscache_use_cookie(struct inode *inode, bool will_modify);
|
|
void ceph_fscache_unuse_cookie(struct inode *inode, bool update);
|
|
|
|
void ceph_fscache_update(struct inode *inode);
|
|
void ceph_fscache_invalidate(struct inode *inode, bool dio_write);
|
|
|
|
static inline struct fscache_cookie *ceph_fscache_cookie(struct ceph_inode_info *ci)
|
|
{
|
|
return netfs_i_cookie(&ci->vfs_inode);
|
|
}
|
|
|
|
static inline void ceph_fscache_resize(struct inode *inode, loff_t to)
|
|
{
|
|
struct ceph_inode_info *ci = ceph_inode(inode);
|
|
struct fscache_cookie *cookie = ceph_fscache_cookie(ci);
|
|
|
|
if (cookie) {
|
|
ceph_fscache_use_cookie(inode, true);
|
|
fscache_resize_cookie(cookie, to);
|
|
ceph_fscache_unuse_cookie(inode, true);
|
|
}
|
|
}
|
|
|
|
static inline void ceph_fscache_unpin_writeback(struct inode *inode,
|
|
struct writeback_control *wbc)
|
|
{
|
|
fscache_unpin_writeback(wbc, ceph_fscache_cookie(ceph_inode(inode)));
|
|
}
|
|
|
|
static inline int ceph_fscache_dirty_folio(struct address_space *mapping,
|
|
struct folio *folio)
|
|
{
|
|
struct ceph_inode_info *ci = ceph_inode(mapping->host);
|
|
|
|
return fscache_dirty_folio(mapping, folio, ceph_fscache_cookie(ci));
|
|
}
|
|
|
|
static inline int ceph_begin_cache_operation(struct netfs_io_request *rreq)
|
|
{
|
|
struct fscache_cookie *cookie = ceph_fscache_cookie(ceph_inode(rreq->inode));
|
|
|
|
return fscache_begin_read_operation(&rreq->cache_resources, cookie);
|
|
}
|
|
|
|
static inline bool ceph_is_cache_enabled(struct inode *inode)
|
|
{
|
|
return fscache_cookie_enabled(ceph_fscache_cookie(ceph_inode(inode)));
|
|
}
|
|
|
|
static inline void ceph_fscache_note_page_release(struct inode *inode)
|
|
{
|
|
struct ceph_inode_info *ci = ceph_inode(inode);
|
|
|
|
fscache_note_page_release(ceph_fscache_cookie(ci));
|
|
}
|
|
#else /* CONFIG_CEPH_FSCACHE */
|
|
static inline int ceph_fscache_register_fs(struct ceph_fs_client* fsc,
|
|
struct fs_context *fc)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline void ceph_fscache_unregister_fs(struct ceph_fs_client* fsc)
|
|
{
|
|
}
|
|
|
|
static inline void ceph_fscache_register_inode_cookie(struct inode *inode)
|
|
{
|
|
}
|
|
|
|
static inline void ceph_fscache_unregister_inode_cookie(struct ceph_inode_info* ci)
|
|
{
|
|
}
|
|
|
|
static inline void ceph_fscache_use_cookie(struct inode *inode, bool will_modify)
|
|
{
|
|
}
|
|
|
|
static inline void ceph_fscache_unuse_cookie(struct inode *inode, bool update)
|
|
{
|
|
}
|
|
|
|
static inline void ceph_fscache_update(struct inode *inode)
|
|
{
|
|
}
|
|
|
|
static inline void ceph_fscache_invalidate(struct inode *inode, bool dio_write)
|
|
{
|
|
}
|
|
|
|
static inline struct fscache_cookie *ceph_fscache_cookie(struct ceph_inode_info *ci)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static inline void ceph_fscache_resize(struct inode *inode, loff_t to)
|
|
{
|
|
}
|
|
|
|
static inline void ceph_fscache_unpin_writeback(struct inode *inode,
|
|
struct writeback_control *wbc)
|
|
{
|
|
}
|
|
|
|
static inline int ceph_fscache_dirty_folio(struct address_space *mapping,
|
|
struct folio *folio)
|
|
{
|
|
return filemap_dirty_folio(mapping, folio);
|
|
}
|
|
|
|
static inline bool ceph_is_cache_enabled(struct inode *inode)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline int ceph_begin_cache_operation(struct netfs_io_request *rreq)
|
|
{
|
|
return -ENOBUFS;
|
|
}
|
|
|
|
static inline void ceph_fscache_note_page_release(struct inode *inode)
|
|
{
|
|
}
|
|
#endif /* CONFIG_CEPH_FSCACHE */
|
|
|
|
#endif
|