forked from Minki/linux
bc899ee1c8
Add a netfs_i_context struct that should be included in the network
filesystem's own inode struct wrapper, directly after the VFS's inode
struct, e.g.:
struct my_inode {
struct {
/* These must be contiguous */
struct inode vfs_inode;
struct netfs_i_context netfs_ctx;
};
};
The netfs_i_context struct so far contains a single field for the network
filesystem to use - the cache cookie:
struct netfs_i_context {
...
struct fscache_cookie *cache;
};
Three functions are provided to help with this:
(1) void netfs_i_context_init(struct inode *inode,
const struct netfs_request_ops *ops);
Initialise the netfs context and set the operations.
(2) struct netfs_i_context *netfs_i_context(struct inode *inode);
Find the netfs context from the VFS inode.
(3) struct inode *netfs_inode(struct netfs_i_context *ctx);
Find the VFS inode from the netfs context.
Changes
=======
ver #4)
- Fix netfs_is_cache_enabled() to check cookie->cache_priv to see if a
cache is present[3].
- Fix netfs_skip_folio_read() to zero out all of the page, not just some
of it[3].
ver #3)
- Split out the bit to move ceph cap-getting on readahead into
ceph_init_request()[1].
- Stick in a comment to the netfs inode structs indicating the contiguity
requirements[2].
ver #2)
- Adjust documentation to match.
- Use "#if IS_ENABLED()" in netfs_i_cookie(), not "#ifdef".
- Move the cap check from ceph_readahead() to ceph_init_request() to be
called from netfslib.
- Remove ceph_readahead() and use netfs_readahead() directly instead.
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Jeff Layton <jlayton@kernel.org>
cc: linux-cachefs@redhat.com
Link: https://lore.kernel.org/r/8af0d47f17d89c06bbf602496dd845f2b0bf25b3.camel@kernel.org/ [1]
Link: https://lore.kernel.org/r/beaf4f6a6c2575ed489adb14b257253c868f9a5c.camel@kernel.org/ [2]
Link: https://lore.kernel.org/r/3536452.1647421585@warthog.procyon.org.uk/ [3]
Link: https://lore.kernel.org/r/164622984545.3564931.15691742939278418580.stgit@warthog.procyon.org.uk/ # v1
Link: https://lore.kernel.org/r/164678213320.1200972.16807551936267647470.stgit@warthog.procyon.org.uk/ # v2
Link: https://lore.kernel.org/r/164692909854.2099075.9535537286264248057.stgit@warthog.procyon.org.uk/ # v3
Link: https://lore.kernel.org/r/306388.1647595110@warthog.procyon.org.uk/ # v4
111 lines
2.8 KiB
C
111 lines
2.8 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)
|
|
*/
|
|
|
|
#include <linux/ceph/ceph_debug.h>
|
|
|
|
#include <linux/fs_context.h>
|
|
#include "super.h"
|
|
#include "cache.h"
|
|
|
|
void ceph_fscache_register_inode_cookie(struct inode *inode)
|
|
{
|
|
struct ceph_inode_info *ci = ceph_inode(inode);
|
|
struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
|
|
|
|
/* No caching for filesystem? */
|
|
if (!fsc->fscache)
|
|
return;
|
|
|
|
/* Regular files only */
|
|
if (!S_ISREG(inode->i_mode))
|
|
return;
|
|
|
|
/* Only new inodes! */
|
|
if (!(inode->i_state & I_NEW))
|
|
return;
|
|
|
|
WARN_ON_ONCE(ci->netfs_ctx.cache);
|
|
|
|
ci->netfs_ctx.cache =
|
|
fscache_acquire_cookie(fsc->fscache, 0,
|
|
&ci->i_vino, sizeof(ci->i_vino),
|
|
&ci->i_version, sizeof(ci->i_version),
|
|
i_size_read(inode));
|
|
}
|
|
|
|
void ceph_fscache_unregister_inode_cookie(struct ceph_inode_info *ci)
|
|
{
|
|
fscache_relinquish_cookie(ceph_fscache_cookie(ci), false);
|
|
}
|
|
|
|
void ceph_fscache_use_cookie(struct inode *inode, bool will_modify)
|
|
{
|
|
struct ceph_inode_info *ci = ceph_inode(inode);
|
|
|
|
fscache_use_cookie(ceph_fscache_cookie(ci), will_modify);
|
|
}
|
|
|
|
void ceph_fscache_unuse_cookie(struct inode *inode, bool update)
|
|
{
|
|
struct ceph_inode_info *ci = ceph_inode(inode);
|
|
|
|
if (update) {
|
|
loff_t i_size = i_size_read(inode);
|
|
|
|
fscache_unuse_cookie(ceph_fscache_cookie(ci),
|
|
&ci->i_version, &i_size);
|
|
} else {
|
|
fscache_unuse_cookie(ceph_fscache_cookie(ci), NULL, NULL);
|
|
}
|
|
}
|
|
|
|
void ceph_fscache_update(struct inode *inode)
|
|
{
|
|
struct ceph_inode_info *ci = ceph_inode(inode);
|
|
loff_t i_size = i_size_read(inode);
|
|
|
|
fscache_update_cookie(ceph_fscache_cookie(ci), &ci->i_version, &i_size);
|
|
}
|
|
|
|
void ceph_fscache_invalidate(struct inode *inode, bool dio_write)
|
|
{
|
|
struct ceph_inode_info *ci = ceph_inode(inode);
|
|
|
|
fscache_invalidate(ceph_fscache_cookie(ci),
|
|
&ci->i_version, i_size_read(inode),
|
|
dio_write ? FSCACHE_INVAL_DIO_WRITE : 0);
|
|
}
|
|
|
|
int ceph_fscache_register_fs(struct ceph_fs_client* fsc, struct fs_context *fc)
|
|
{
|
|
const struct ceph_fsid *fsid = &fsc->client->fsid;
|
|
const char *fscache_uniq = fsc->mount_options->fscache_uniq;
|
|
size_t uniq_len = fscache_uniq ? strlen(fscache_uniq) : 0;
|
|
char *name;
|
|
int err = 0;
|
|
|
|
name = kasprintf(GFP_KERNEL, "ceph,%pU%s%s", fsid, uniq_len ? "," : "",
|
|
uniq_len ? fscache_uniq : "");
|
|
if (!name)
|
|
return -ENOMEM;
|
|
|
|
fsc->fscache = fscache_acquire_volume(name, NULL, NULL, 0);
|
|
if (IS_ERR_OR_NULL(fsc->fscache)) {
|
|
errorfc(fc, "Unable to register fscache cookie for %s", name);
|
|
err = fsc->fscache ? PTR_ERR(fsc->fscache) : -EOPNOTSUPP;
|
|
fsc->fscache = NULL;
|
|
}
|
|
kfree(name);
|
|
return err;
|
|
}
|
|
|
|
void ceph_fscache_unregister_fs(struct ceph_fs_client* fsc)
|
|
{
|
|
fscache_relinquish_volume(fsc->fscache, NULL, false);
|
|
}
|