mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-21 08:19:28 +00:00
![Goffredo Baroncelli](/assets/img/avatar_default.png)
The function inode_cmp_iversion{+raw} is counter-intuitive, because it returns true when the counters are different and false when these are equal. Rename it to inode_eq_iversion{+raw}, which will returns true when the counters are equal and false otherwise. Signed-off-by: Goffredo Baroncelli <kreijack@inwind.it> Signed-off-by: Jeff Layton <jlayton@redhat.com>
337 lines
12 KiB
C
337 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_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
|