[PATCH 1/5] vfs, overlayfs, cachefiles: Turn I_OVL_INUSE into something generic

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Turn overlayfs's I_OVL_INUSE into something generic that cachefiles can
also use for excluding access to its own cache files by renaming it to
I_EXCL_INUSE as suggested by Amir[1] and hoisting the helpers to generic
code.

Suggested-by: Amir Goldstein <amir73il@xxxxxxxxx>
Signed-off-by: David Howells <dhowells@xxxxxxxxxx>
cc: Amir Goldstein <amir73il@xxxxxxxxx>
cc: Miklos Szeredi <miklos@xxxxxxxxxx>
cc: linux-unionfs@xxxxxxxxxxxxxxx
cc: linux-cachefs@xxxxxxxxxx
Link: https://lore.kernel.org/r/CAOQ4uxhRS3MGEnCUDcsB1RL0d1Oy0g0Rzm75hVFAJw2dJ7uKSA@xxxxxxxxxxxxxx/ [1]
---

 fs/inode.c               |   43 +++++++++++++++++++++++++++++++++++++++++++
 fs/overlayfs/overlayfs.h |    3 ---
 fs/overlayfs/super.c     |   12 ++++++------
 fs/overlayfs/util.c      |   43 -------------------------------------------
 include/linux/fs.h       |   22 +++++++++++++++++++---
 5 files changed, 68 insertions(+), 55 deletions(-)

diff --git a/fs/inode.c b/fs/inode.c
index 63324df6fa27..954719f66113 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -2405,3 +2405,46 @@ struct timespec64 current_time(struct inode *inode)
 	return timestamp_truncate(now, inode);
 }
 EXPORT_SYMBOL(current_time);
+
+/**
+ * inode_excl_inuse_trylock - Try to exclusively lock an inode for kernel access
+ * @dentry: Reference to the inode to be locked
+ *
+ * Try to gain exclusive access to an inode for a kernel service, returning
+ * true if successful.
+ */
+bool inode_excl_inuse_trylock(struct dentry *dentry)
+{
+	struct inode *inode = d_inode(dentry);
+	bool locked = false;
+
+	spin_lock(&inode->i_lock);
+	if (!(inode->i_state & I_EXCL_INUSE)) {
+		inode->i_state |= I_EXCL_INUSE;
+		locked = true;
+	}
+	spin_unlock(&inode->i_lock);
+
+	return locked;
+}
+EXPORT_SYMBOL(inode_excl_inuse_trylock);
+
+/**
+ * inode_excl_inuse_unlock - Unlock exclusive kernel access to an inode
+ * @dentry: Reference to the inode to be unlocked
+ *
+ * Drop exclusive access to an inode for a kernel service.  A warning is given
+ * if the inode was not marked for exclusive access.
+ */
+void inode_excl_inuse_unlock(struct dentry *dentry)
+{
+	if (dentry) {
+		struct inode *inode = d_inode(dentry);
+
+		spin_lock(&inode->i_lock);
+		WARN_ON(!(inode->i_state & I_EXCL_INUSE));
+		inode->i_state &= ~I_EXCL_INUSE;
+		spin_unlock(&inode->i_lock);
+	}
+}
+EXPORT_SYMBOL(inode_excl_inuse_unlock);
diff --git a/fs/overlayfs/overlayfs.h b/fs/overlayfs/overlayfs.h
index 2cd5741c873b..8415c0c6d40c 100644
--- a/fs/overlayfs/overlayfs.h
+++ b/fs/overlayfs/overlayfs.h
@@ -337,9 +337,6 @@ int ovl_check_setxattr(struct ovl_fs *ofs, struct dentry *upperdentry,
 		       enum ovl_xattr ox, const void *value, size_t size,
 		       int xerr);
 int ovl_set_impure(struct dentry *dentry, struct dentry *upperdentry);
-bool ovl_inuse_trylock(struct dentry *dentry);
-void ovl_inuse_unlock(struct dentry *dentry);
-bool ovl_is_inuse(struct dentry *dentry);
 bool ovl_need_index(struct dentry *dentry);
 int ovl_nlink_start(struct dentry *dentry);
 void ovl_nlink_end(struct dentry *dentry);
diff --git a/fs/overlayfs/super.c b/fs/overlayfs/super.c
index 7bb0a47cb615..5c3361a2dc7c 100644
--- a/fs/overlayfs/super.c
+++ b/fs/overlayfs/super.c
@@ -224,10 +224,10 @@ static void ovl_free_fs(struct ovl_fs *ofs)
 	dput(ofs->indexdir);
 	dput(ofs->workdir);
 	if (ofs->workdir_locked)
-		ovl_inuse_unlock(ofs->workbasedir);
+		inode_excl_inuse_unlock(ofs->workbasedir);
 	dput(ofs->workbasedir);
 	if (ofs->upperdir_locked)
-		ovl_inuse_unlock(ovl_upper_mnt(ofs)->mnt_root);
+		inode_excl_inuse_unlock(ovl_upper_mnt(ofs)->mnt_root);
 
 	/* Hack!  Reuse ofs->layers as a vfsmount array before freeing it */
 	mounts = (struct vfsmount **) ofs->layers;
@@ -1239,7 +1239,7 @@ static int ovl_get_upper(struct super_block *sb, struct ovl_fs *ofs,
 	if (upper_mnt->mnt_sb->s_flags & SB_NOSEC)
 		sb->s_flags |= SB_NOSEC;
 
-	if (ovl_inuse_trylock(ovl_upper_mnt(ofs)->mnt_root)) {
+	if (inode_excl_inuse_trylock(ovl_upper_mnt(ofs)->mnt_root)) {
 		ofs->upperdir_locked = true;
 	} else {
 		err = ovl_report_in_use(ofs, "upperdir");
@@ -1499,7 +1499,7 @@ static int ovl_get_workdir(struct super_block *sb, struct ovl_fs *ofs,
 
 	ofs->workbasedir = dget(workpath.dentry);
 
-	if (ovl_inuse_trylock(ofs->workbasedir)) {
+	if (inode_excl_inuse_trylock(ofs->workbasedir)) {
 		ofs->workdir_locked = true;
 	} else {
 		err = ovl_report_in_use(ofs, "workdir");
@@ -1722,7 +1722,7 @@ static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs,
 		if (err)
 			goto out;
 
-		if (ovl_is_inuse(stack[i].dentry)) {
+		if (inode_is_excl_inuse(stack[i].dentry)) {
 			err = ovl_report_in_use(ofs, "lowerdir");
 			if (err) {
 				iput(trap);
@@ -1872,7 +1872,7 @@ static int ovl_check_layer(struct super_block *sb, struct ovl_fs *ofs,
 		if (is_lower && ovl_lookup_trap_inode(sb, parent)) {
 			err = -ELOOP;
 			pr_err("overlapping %s path\n", name);
-		} else if (ovl_is_inuse(parent)) {
+		} else if (inode_is_excl_inuse(parent)) {
 			err = ovl_report_in_use(ofs, name);
 		}
 		next = parent;
diff --git a/fs/overlayfs/util.c b/fs/overlayfs/util.c
index f48284a2a896..748c4b22deb3 100644
--- a/fs/overlayfs/util.c
+++ b/fs/overlayfs/util.c
@@ -724,49 +724,6 @@ int ovl_set_protattr(struct inode *inode, struct dentry *upper,
 	return 0;
 }
 
-/**
- * Caller must hold a reference to inode to prevent it from being freed while
- * it is marked inuse.
- */
-bool ovl_inuse_trylock(struct dentry *dentry)
-{
-	struct inode *inode = d_inode(dentry);
-	bool locked = false;
-
-	spin_lock(&inode->i_lock);
-	if (!(inode->i_state & I_OVL_INUSE)) {
-		inode->i_state |= I_OVL_INUSE;
-		locked = true;
-	}
-	spin_unlock(&inode->i_lock);
-
-	return locked;
-}
-
-void ovl_inuse_unlock(struct dentry *dentry)
-{
-	if (dentry) {
-		struct inode *inode = d_inode(dentry);
-
-		spin_lock(&inode->i_lock);
-		WARN_ON(!(inode->i_state & I_OVL_INUSE));
-		inode->i_state &= ~I_OVL_INUSE;
-		spin_unlock(&inode->i_lock);
-	}
-}
-
-bool ovl_is_inuse(struct dentry *dentry)
-{
-	struct inode *inode = d_inode(dentry);
-	bool inuse;
-
-	spin_lock(&inode->i_lock);
-	inuse = (inode->i_state & I_OVL_INUSE);
-	spin_unlock(&inode->i_lock);
-
-	return inuse;
-}
-
 /*
  * Does this overlay dentry need to be indexed on copy up?
  */
diff --git a/include/linux/fs.h b/include/linux/fs.h
index f3daaea16554..4c15e270f1ac 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2320,8 +2320,10 @@ static inline void kiocb_clone(struct kiocb *kiocb, struct kiocb *kiocb_src,
  *			wb stat updates to grab the i_pages lock.  See
  *			inode_switch_wbs_work_fn() for details.
  *
- * I_OVL_INUSE		Used by overlayfs to get exclusive ownership on upper
- *			and work dirs among overlayfs mounts.
+ * I_EXCL_INUSE		Marked for exclusive use by a kernel service.  Used by
+ *			overlayfs to get exclusive ownership on upper and work
+ *			dirs among overlayfs mounts and by cachefiles to prevent
+ *			multiple access to a cache file.
  *
  * I_CREATING		New object's inode in the middle of setting up.
  *
@@ -2351,7 +2353,7 @@ static inline void kiocb_clone(struct kiocb *kiocb, struct kiocb *kiocb_src,
 #define I_LINKABLE		(1 << 10)
 #define I_DIRTY_TIME		(1 << 11)
 #define I_WB_SWITCH		(1 << 13)
-#define I_OVL_INUSE		(1 << 14)
+#define I_EXCL_INUSE		(1 << 14)
 #define I_CREATING		(1 << 15)
 #define I_DONTCACHE		(1 << 16)
 #define I_SYNC_QUEUED		(1 << 17)
@@ -2387,6 +2389,20 @@ static inline bool inode_is_dirtytime_only(struct inode *inode)
 				  I_FREEING | I_WILL_FREE)) == I_DIRTY_TIME;
 }
 
+bool inode_excl_inuse_trylock(struct dentry *dentry);
+void inode_excl_inuse_unlock(struct dentry *dentry);
+
+static inline bool inode_is_excl_inuse(struct dentry *dentry)
+{
+	struct inode *inode = d_inode(dentry);
+	bool inuse;
+
+	spin_lock(&inode->i_lock);
+	inuse = (inode->i_state & I_EXCL_INUSE);
+	spin_unlock(&inode->i_lock);
+	return inuse;
+}
+
 extern void inc_nlink(struct inode *inode);
 extern void drop_nlink(struct inode *inode);
 extern void clear_nlink(struct inode *inode);





[Index of Archives]     [Linux Filesystems Devel]     [Linux NFS]     [Linux NILFS]     [Linux USB Devel]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]

  Powered by Linux