mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 11:19:37 +00:00
![Jeff Layton](/assets/img/avatar_default.png)
Under ceph, clients can be independently updating iversion themselves, while working under comprehensive sets of caps on an inode. In that situation we always want to prefer the largest value of a change attribute. Add a new function that will update a raw value with a larger one, but otherwise leave it alone. Signed-off-by: Jeff Layton <jlayton@kernel.org> Reviewed-by: "Yan, Zheng" <zyan@redhat.com> Signed-off-by: Ilya Dryomov <idryomov@gmail.com>
361 lines
12 KiB
C
361 lines
12 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
#ifndef _LINUX_IVERSION_H
|
|
#define _LINUX_IVERSION_H
|
|
|
|
#include <linux/fs.h>
|
|
|
|
/*
|
|
* The inode->i_version field:
|
|
* ---------------------------
|
|
* The change attribute (i_version) is mandated by NFSv4 and is mostly for
|
|
* knfsd, but is also used for other purposes (e.g. IMA). The i_version must
|
|
* appear different to observers if there was a change to the inode's data or
|
|
* metadata since it was last queried.
|
|
*
|
|
* Observers see the i_version as a 64-bit number that never decreases. If it
|
|
* remains the same since it was last checked, then nothing has changed in the
|
|
* inode. If it's different then something has changed. Observers cannot infer
|
|
* anything about the nature or magnitude of the changes from the value, only
|
|
* that the inode has changed in some fashion.
|
|
*
|
|
* Not all filesystems properly implement the i_version counter. Subsystems that
|
|
* want to use i_version field on an inode should first check whether the
|
|
* filesystem sets the SB_I_VERSION flag (usually via the IS_I_VERSION macro).
|
|
*
|
|
* Those that set SB_I_VERSION will automatically have their i_version counter
|
|
* incremented on writes to normal files. If the SB_I_VERSION is not set, then
|
|
* the VFS will not touch it on writes, and the filesystem can use it how it
|
|
* wishes. Note that the filesystem is always responsible for updating the
|
|
* i_version on namespace changes in directories (mkdir, rmdir, unlink, etc.).
|
|
* We consider these sorts of filesystems to have a kernel-managed i_version.
|
|
*
|
|
* It may be impractical for filesystems to keep i_version updates atomic with
|
|
* respect to the changes that cause them. They should, however, guarantee
|
|
* that i_version updates are never visible before the changes that caused
|
|
* them. Also, i_version updates should never be delayed longer than it takes
|
|
* the original change to reach disk.
|
|
*
|
|
* This implementation uses the low bit in the i_version field as a flag to
|
|
* track when the value has been queried. If it has not been queried since it
|
|
* was last incremented, we can skip the increment in most cases.
|
|
*
|
|
* In the event that we're updating the ctime, we will usually go ahead and
|
|
* bump the i_version anyway. Since that has to go to stable storage in some
|
|
* fashion, we might as well increment it as well.
|
|
*
|
|
* With this implementation, the value should always appear to observers to
|
|
* increase over time if the file has changed. It's recommended to use
|
|
* inode_eq_iversion() helper to compare values.
|
|
*
|
|
* Note that some filesystems (e.g. NFS and AFS) just use the field to store
|
|
* a server-provided value (for the most part). For that reason, those
|
|
* filesystems do not set SB_I_VERSION. These filesystems are considered to
|
|
* have a self-managed i_version.
|
|
*
|
|
* Persistently storing the i_version
|
|
* ----------------------------------
|
|
* Queries of the i_version field are not gated on them hitting the backing
|
|
* store. It's always possible that the host could crash after allowing
|
|
* a query of the value but before it has made it to disk.
|
|
*
|
|
* To mitigate this problem, filesystems should always use
|
|
* inode_set_iversion_queried when loading an existing inode from disk. This
|
|
* ensures that the next attempted inode increment will result in the value
|
|
* changing.
|
|
*
|
|
* Storing the value to disk therefore does not count as a query, so those
|
|
* filesystems should use inode_peek_iversion to grab the value to be stored.
|
|
* There is no need to flag the value as having been queried in that case.
|
|
*/
|
|
|
|
/*
|
|
* We borrow the lowest bit in the i_version to use as a flag to tell whether
|
|
* it has been queried since we last incremented it. If it has, then we must
|
|
* increment it on the next change. After that, we can clear the flag and
|
|
* avoid incrementing it again until it has again been queried.
|
|
*/
|
|
#define I_VERSION_QUERIED_SHIFT (1)
|
|
#define I_VERSION_QUERIED (1ULL << (I_VERSION_QUERIED_SHIFT - 1))
|
|
#define I_VERSION_INCREMENT (1ULL << I_VERSION_QUERIED_SHIFT)
|
|
|
|
/**
|
|
* inode_set_iversion_raw - set i_version to the specified raw value
|
|
* @inode: inode to set
|
|
* @val: new i_version value to set
|
|
*
|
|
* Set @inode's i_version field to @val. This function is for use by
|
|
* filesystems that self-manage the i_version.
|
|
*
|
|
* For example, the NFS client stores its NFSv4 change attribute in this way,
|
|
* and the AFS client stores the data_version from the server here.
|
|
*/
|
|
static inline void
|
|
inode_set_iversion_raw(struct inode *inode, u64 val)
|
|
{
|
|
atomic64_set(&inode->i_version, val);
|
|
}
|
|
|
|
/**
|
|
* inode_peek_iversion_raw - grab a "raw" iversion value
|
|
* @inode: inode from which i_version should be read
|
|
*
|
|
* Grab a "raw" inode->i_version value and return it. The i_version is not
|
|
* flagged or converted in any way. This is mostly used to access a self-managed
|
|
* i_version.
|
|
*
|
|
* With those filesystems, we want to treat the i_version as an entirely
|
|
* opaque value.
|
|
*/
|
|
static inline u64
|
|
inode_peek_iversion_raw(const struct inode *inode)
|
|
{
|
|
return atomic64_read(&inode->i_version);
|
|
}
|
|
|
|
/**
|
|
* inode_set_max_iversion_raw - update i_version new value is larger
|
|
* @inode: inode to set
|
|
* @val: new i_version to set
|
|
*
|
|
* Some self-managed filesystems (e.g Ceph) will only update the i_version
|
|
* value if the new value is larger than the one we already have.
|
|
*/
|
|
static inline void
|
|
inode_set_max_iversion_raw(struct inode *inode, u64 val)
|
|
{
|
|
u64 cur, old;
|
|
|
|
cur = inode_peek_iversion_raw(inode);
|
|
for (;;) {
|
|
if (cur > val)
|
|
break;
|
|
old = atomic64_cmpxchg(&inode->i_version, cur, val);
|
|
if (likely(old == cur))
|
|
break;
|
|
cur = old;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* inode_set_iversion - set i_version to a particular value
|
|
* @inode: inode to set
|
|
* @val: new i_version value to set
|
|
*
|
|
* Set @inode's i_version field to @val. This function is for filesystems with
|
|
* a kernel-managed i_version, for initializing a newly-created inode from
|
|
* scratch.
|
|
*
|
|
* In this case, we do not set the QUERIED flag since we know that this value
|
|
* has never been queried.
|
|
*/
|
|
static inline void
|
|
inode_set_iversion(struct inode *inode, u64 val)
|
|
{
|
|
inode_set_iversion_raw(inode, val << I_VERSION_QUERIED_SHIFT);
|
|
}
|
|
|
|
/**
|
|
* inode_set_iversion_queried - set i_version to a particular value as quereied
|
|
* @inode: inode to set
|
|
* @val: new i_version value to set
|
|
*
|
|
* Set @inode's i_version field to @val, and flag it for increment on the next
|
|
* change.
|
|
*
|
|
* Filesystems that persistently store the i_version on disk should use this
|
|
* when loading an existing inode from disk.
|
|
*
|
|
* When loading in an i_version value from a backing store, we can't be certain
|
|
* that it wasn't previously viewed before being stored. Thus, we must assume
|
|
* that it was, to ensure that we don't end up handing out the same value for
|
|
* different versions of the same inode.
|
|
*/
|
|
static inline void
|
|
inode_set_iversion_queried(struct inode *inode, u64 val)
|
|
{
|
|
inode_set_iversion_raw(inode, (val << I_VERSION_QUERIED_SHIFT) |
|
|
I_VERSION_QUERIED);
|
|
}
|
|
|
|
/**
|
|
* inode_maybe_inc_iversion - increments i_version
|
|
* @inode: inode with the i_version that should be updated
|
|
* @force: increment the counter even if it's not necessary?
|
|
*
|
|
* Every time the inode is modified, the i_version field must be seen to have
|
|
* changed by any observer.
|
|
*
|
|
* If "force" is set or the QUERIED flag is set, then ensure that we increment
|
|
* the value, and clear the queried flag.
|
|
*
|
|
* In the common case where neither is set, then we can return "false" without
|
|
* updating i_version.
|
|
*
|
|
* If this function returns false, and no other metadata has changed, then we
|
|
* can avoid logging the metadata.
|
|
*/
|
|
static inline bool
|
|
inode_maybe_inc_iversion(struct inode *inode, bool force)
|
|
{
|
|
u64 cur, old, new;
|
|
|
|
/*
|
|
* The i_version field is not strictly ordered with any other inode
|
|
* information, but the legacy inode_inc_iversion code used a spinlock
|
|
* to serialize increments.
|
|
*
|
|
* Here, we add full memory barriers to ensure that any de-facto
|
|
* ordering with other info is preserved.
|
|
*
|
|
* This barrier pairs with the barrier in inode_query_iversion()
|
|
*/
|
|
smp_mb();
|
|
cur = inode_peek_iversion_raw(inode);
|
|
for (;;) {
|
|
/* If flag is clear then we needn't do anything */
|
|
if (!force && !(cur & I_VERSION_QUERIED))
|
|
return false;
|
|
|
|
/* Since lowest bit is flag, add 2 to avoid it */
|
|
new = (cur & ~I_VERSION_QUERIED) + I_VERSION_INCREMENT;
|
|
|
|
old = atomic64_cmpxchg(&inode->i_version, cur, new);
|
|
if (likely(old == cur))
|
|
break;
|
|
cur = old;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
/**
|
|
* inode_inc_iversion - forcibly increment i_version
|
|
* @inode: inode that needs to be updated
|
|
*
|
|
* Forcbily increment the i_version field. This always results in a change to
|
|
* the observable value.
|
|
*/
|
|
static inline void
|
|
inode_inc_iversion(struct inode *inode)
|
|
{
|
|
inode_maybe_inc_iversion(inode, true);
|
|
}
|
|
|
|
/**
|
|
* inode_iversion_need_inc - is the i_version in need of being incremented?
|
|
* @inode: inode to check
|
|
*
|
|
* Returns whether the inode->i_version counter needs incrementing on the next
|
|
* change. Just fetch the value and check the QUERIED flag.
|
|
*/
|
|
static inline bool
|
|
inode_iversion_need_inc(struct inode *inode)
|
|
{
|
|
return inode_peek_iversion_raw(inode) & I_VERSION_QUERIED;
|
|
}
|
|
|
|
/**
|
|
* inode_inc_iversion_raw - forcibly increment raw i_version
|
|
* @inode: inode that needs to be updated
|
|
*
|
|
* Forcbily increment the raw i_version field. This always results in a change
|
|
* to the raw value.
|
|
*
|
|
* NFS will use the i_version field to store the value from the server. It
|
|
* mostly treats it as opaque, but in the case where it holds a write
|
|
* delegation, it must increment the value itself. This function does that.
|
|
*/
|
|
static inline void
|
|
inode_inc_iversion_raw(struct inode *inode)
|
|
{
|
|
atomic64_inc(&inode->i_version);
|
|
}
|
|
|
|
/**
|
|
* inode_peek_iversion - read i_version without flagging it to be incremented
|
|
* @inode: inode from which i_version should be read
|
|
*
|
|
* Read the inode i_version counter for an inode without registering it as a
|
|
* query.
|
|
*
|
|
* This is typically used by local filesystems that need to store an i_version
|
|
* on disk. In that situation, it's not necessary to flag it as having been
|
|
* viewed, as the result won't be used to gauge changes from that point.
|
|
*/
|
|
static inline u64
|
|
inode_peek_iversion(const struct inode *inode)
|
|
{
|
|
return inode_peek_iversion_raw(inode) >> I_VERSION_QUERIED_SHIFT;
|
|
}
|
|
|
|
/**
|
|
* inode_query_iversion - read i_version for later use
|
|
* @inode: inode from which i_version should be read
|
|
*
|
|
* Read the inode i_version counter. This should be used by callers that wish
|
|
* to store the returned i_version for later comparison. This will guarantee
|
|
* that a later query of the i_version will result in a different value if
|
|
* anything has changed.
|
|
*
|
|
* In this implementation, we fetch the current value, set the QUERIED flag and
|
|
* then try to swap it into place with a cmpxchg, if it wasn't already set. If
|
|
* that fails, we try again with the newly fetched value from the cmpxchg.
|
|
*/
|
|
static inline u64
|
|
inode_query_iversion(struct inode *inode)
|
|
{
|
|
u64 cur, old, new;
|
|
|
|
cur = inode_peek_iversion_raw(inode);
|
|
for (;;) {
|
|
/* If flag is already set, then no need to swap */
|
|
if (cur & I_VERSION_QUERIED) {
|
|
/*
|
|
* This barrier (and the implicit barrier in the
|
|
* cmpxchg below) pairs with the barrier in
|
|
* inode_maybe_inc_iversion().
|
|
*/
|
|
smp_mb();
|
|
break;
|
|
}
|
|
|
|
new = cur | I_VERSION_QUERIED;
|
|
old = atomic64_cmpxchg(&inode->i_version, cur, new);
|
|
if (likely(old == cur))
|
|
break;
|
|
cur = old;
|
|
}
|
|
return cur >> I_VERSION_QUERIED_SHIFT;
|
|
}
|
|
|
|
/**
|
|
* inode_eq_iversion_raw - check whether the raw i_version counter has changed
|
|
* @inode: inode to check
|
|
* @old: old value to check against its i_version
|
|
*
|
|
* Compare the current raw i_version counter with a previous one. Returns true
|
|
* if they are the same or false if they are different.
|
|
*/
|
|
static inline bool
|
|
inode_eq_iversion_raw(const struct inode *inode, u64 old)
|
|
{
|
|
return inode_peek_iversion_raw(inode) == old;
|
|
}
|
|
|
|
/**
|
|
* inode_eq_iversion - check whether the i_version counter has changed
|
|
* @inode: inode to check
|
|
* @old: old value to check against its i_version
|
|
*
|
|
* Compare an i_version counter with a previous one. Returns true if they are
|
|
* the same, and false if they are different.
|
|
*
|
|
* Note that we don't need to set the QUERIED flag in this case, as the value
|
|
* in the inode is not being recorded for later use.
|
|
*/
|
|
static inline bool
|
|
inode_eq_iversion(const struct inode *inode, u64 old)
|
|
{
|
|
return inode_peek_iversion(inode) == old;
|
|
}
|
|
#endif
|