Skip to contentSkip to conversation

ovl: whiteout inode sharing

PATCH Superseded Chengguang Xu 3 participants 11 messages Apr 14, 2020 – Apr 16, 2020 Overlay filesystem

v3 of 5 Superseded Latest is v5 →

lore
Share & tools
lore
#0 lore raw

PATCH v3 1/1 ovl: whiteout inode sharing

Sharing inode with different whiteout files for saving inode and speeding up deleting operation.

---
v1->v2:
- Address Amir's comments in v1

v2->v3:
- Address Amir's comments in v2
- Rebase on Amir's "Overlayfs use index dir as work dir" patch set
- Keep at most one whiteout tmpfile in work dir

 fs/overlayfs/dir.c       | 35 ++++++++++++++++++++++++++++-------
 fs/overlayfs/overlayfs.h |  9 +++++++--
 fs/overlayfs/ovl_entry.h |  4 ++++
 fs/overlayfs/readdir.c   |  3 ++-
 fs/overlayfs/super.c     |  9 +++++++++
 fs/overlayfs/util.c      |  3 ++-
 6 files changed, 52 insertions(+), 11 deletions(-)
fs/overlayfs/dir.c +28 -7
index 279009dee366..dbe5e54dcb16 100644
@@ -62,35 +62,55 @@ struct dentry *ovl_lookup_temp(struct dentry *workdir)
 }
 
 /* caller holds i_mutex on workdir */
-static struct dentry *ovl_whiteout(struct dentry *workdir)
+static struct dentry *ovl_whiteout(struct ovl_fs *ofs, struct dentry *workdir)
 {
 	int err;
+	bool retried = false;
+	bool should_link = (ofs->whiteout_link_max > 1);
 	struct dentry *whiteout;
 	struct inode *wdir = workdir->d_inode;
 
+retry:
 	whiteout = ovl_lookup_temp(workdir);
 	if (IS_ERR(whiteout))
 		return whiteout;
 
+	if (should_link && ofs->whiteout) {
+		err = ovl_do_link(ofs->whiteout, wdir, whiteout);
+		if (err || !ovl_whiteout_linkable(ofs)) {
+			ovl_cleanup(wdir, ofs->whiteout);
+			dput(ofs->whiteout);
+			ofs->whiteout = NULL;
+		}
+
+		if (!err)
+			return whiteout;
+	}
+
 	err = ovl_do_whiteout(wdir, whiteout);
 	if (err) {
 		dput(whiteout);
-		whiteout = ERR_PTR(err);
+		return ERR_PTR(err);
 	}
 
-	return whiteout;
+	if (!should_link || retried)
+		return whiteout;
+
+	ofs->whiteout = whiteout;
+	retried = true;
+	goto retry;
 }
 
 /* Caller must hold i_mutex on both workdir and dir */
-int ovl_cleanup_and_whiteout(struct dentry *workdir, struct inode *dir,
-			     struct dentry *dentry)
+int ovl_cleanup_and_whiteout(struct ovl_fs *ofs, struct dentry *workdir,
+			     struct inode *dir, struct dentry *dentry)
 {
 	struct inode *wdir = workdir->d_inode;
 	struct dentry *whiteout;
 	int err;
 	int flags = 0;
 
-	whiteout = ovl_whiteout(workdir);
+	whiteout = ovl_whiteout(ofs, workdir);
 	err = PTR_ERR(whiteout);
 	if (IS_ERR(whiteout))
 		return err;
@@ -715,6 +735,7 @@ static bool ovl_matches_upper(struct dentry *dentry, struct dentry *upper)
 static int ovl_remove_and_whiteout(struct dentry *dentry,
 				   struct list_head *list)
 {
+	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
 	struct dentry *workdir = ovl_workdir(dentry);
 	struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
 	struct dentry *upper;
@@ -748,7 +769,7 @@ static int ovl_remove_and_whiteout(struct dentry *dentry,
 		goto out_dput_upper;
 	}
 
-	err = ovl_cleanup_and_whiteout(workdir, d_inode(upperdir), upper);
+	err = ovl_cleanup_and_whiteout(ofs, workdir, d_inode(upperdir), upper);
 	if (err)
 		goto out_d_drop;
 
fs/overlayfs/overlayfs.h +7 -2
index e00b1ff6dea9..3d7e0e342dae 100644
@@ -225,6 +225,11 @@ static inline bool ovl_open_flags_need_copy_up(int flags)
 	return ((OPEN_FMODE(flags) & FMODE_WRITE) || (flags & O_TRUNC));
 }
 
+static inline bool ovl_whiteout_linkable(struct ovl_fs *ofs)
+{
+	return ofs->whiteout->d_inode->i_nlink <= ofs->whiteout_link_max;
+}
+
 /* util.c */
 int ovl_want_write(struct dentry *dentry);
 void ovl_drop_write(struct dentry *dentry);
@@ -455,8 +460,8 @@ static inline void ovl_copyflags(struct inode *from, struct inode *to)
 
 /* dir.c */
 extern const struct inode_operations ovl_dir_inode_operations;
-int ovl_cleanup_and_whiteout(struct dentry *workdir, struct inode *dir,
-			     struct dentry *dentry);
+int ovl_cleanup_and_whiteout(struct ovl_fs *ofs, struct dentry *workdir,
+			     struct inode *dir, struct dentry *dentry);
 struct ovl_cattr {
 	dev_t rdev;
 	umode_t mode;
fs/overlayfs/ovl_entry.h +4 -0
index 5762d802fe01..de5f230b6e6b 100644
@@ -77,6 +77,10 @@ struct ovl_fs {
 	int xino_mode;
 	/* For allocation of non-persistent inode numbers */
 	atomic_long_t last_ino;
+	/* Whiteout dentry cache */
+	struct dentry *whiteout;
+	/* Whiteout max link count */
+	unsigned int whiteout_link_max;
 };
 
 static inline struct ovl_fs *OVL_FS(struct super_block *sb)
fs/overlayfs/readdir.c +2 -1
index d6b601caf122..eb4683e58cff 100644
@@ -1147,7 +1147,8 @@ int ovl_indexdir_cleanup(struct ovl_fs *ofs)
 			 * Whiteout orphan index to block future open by
 			 * handle after overlay nlink dropped to zero.
 			 */
-			err = ovl_cleanup_and_whiteout(indexdir, dir, index);
+			err = ovl_cleanup_and_whiteout(ofs, indexdir, dir,
+						       index);
 		} else {
 			/* Cleanup orphan index entries */
 			err = ovl_cleanup(dir, index);
fs/overlayfs/super.c +9 -0
index b91b23a0366c..b6f2393ec111 100644
@@ -26,6 +26,10 @@ struct ovl_dir_cache;
 
 #define OVL_MAX_STACK 500
 
+static unsigned int ovl_whiteout_link_max_def = 60000;
+module_param_named(whiteout_link_max, ovl_whiteout_link_max_def, uint, 0644);
+MODULE_PARM_DESC(whiteout_link_max, "Maximum count of whiteout file link");
+
 static bool ovl_redirect_dir_def = IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_DIR);
 module_param_named(redirect_dir, ovl_redirect_dir_def, bool, 0644);
 MODULE_PARM_DESC(redirect_dir,
@@ -219,6 +223,7 @@ static void ovl_free_fs(struct ovl_fs *ofs)
 	iput(ofs->upperdir_trap);
 	dput(ofs->indexdir);
 	dput(ofs->workdir);
+	dput(ofs->whiteout);
 	if (ofs->workdir_locked)
 		ovl_inuse_unlock(ofs->workbasedir);
 	dput(ofs->workbasedir);
@@ -1762,6 +1767,10 @@ static int ovl_fill_super(struct super_block *sb, void *data, int silent)
 
 		if (!ofs->workdir)
 			sb->s_flags |= SB_RDONLY;
+		else
+			ofs->whiteout_link_max = min_not_zero(
+					ofs->workdir->d_sb->s_max_links,
+					ovl_whiteout_link_max_def ?: 1);
 
 		sb->s_stack_depth = ofs->upper_mnt->mnt_sb->s_stack_depth;
 		sb->s_time_gran = ofs->upper_mnt->mnt_sb->s_time_gran;
fs/overlayfs/util.c +2 -1
index 36b60788ee47..18df65ee81a8 100644
@@ -669,6 +669,7 @@ bool ovl_need_index(struct dentry *dentry)
 /* Caller must hold OVL_I(inode)->lock */
 static void ovl_cleanup_index(struct dentry *dentry)
 {
+	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
 	struct dentry *indexdir = ovl_indexdir(dentry->d_sb);
 	struct inode *dir = indexdir->d_inode;
 	struct dentry *lowerdentry = ovl_dentry_lower(dentry);
@@ -707,7 +708,7 @@ static void ovl_cleanup_index(struct dentry *dentry)
 		index = NULL;
 	} else if (ovl_index_all(dentry->d_sb)) {
 		/* Whiteout orphan index to block future open by handle */
-		err = ovl_cleanup_and_whiteout(indexdir, dir, index);
+		err = ovl_cleanup_and_whiteout(ofs, indexdir, dir, index);
 	} else {
 		/* Cleanup orphan index entries */
 		err = ovl_cleanup(dir, index);
Signature · 1 line
2.20.1
maintainer
#1 lore raw
Quoted 35 lines · Chengguang Xu

Sharing inode with different whiteout files for saving inode and speeding up deleting operation.

---
v1->v2:
- Address Amir's comments in v1

v2->v3:
- Address Amir's comments in v2
- Rebase on Amir's "Overlayfs use index dir as work dir" patch set
- Keep at most one whiteout tmpfile in work dir

 fs/overlayfs/dir.c       | 35 ++++++++++++++++++++++++++++-------
 fs/overlayfs/overlayfs.h |  9 +++++++--
 fs/overlayfs/ovl_entry.h |  4 ++++
 fs/overlayfs/readdir.c   |  3 ++-
 fs/overlayfs/super.c     |  9 +++++++++
 fs/overlayfs/util.c      |  3 ++-
 6 files changed, 52 insertions(+), 11 deletions(-)
fs/overlayfs/dir.c +2 -1
index 279009dee366..dbe5e54dcb16 100644
@@ -62,35 +62,55 @@ struct dentry *ovl_lookup_temp(struct dentry *workdir)
 }
 
 /* caller holds i_mutex on workdir */
-static struct dentry *ovl_whiteout(struct dentry *workdir)
+static struct dentry *ovl_whiteout(struct ovl_fs *ofs, struct dentry *workdir)
 {
        int err;
+       bool retried = false;

fs/overlayfs/dir.c struct dentry *ovl_lookup_temp(struct dentry *workdir) · line 78

Quoted 10 lines
fs/overlayfs/dir.c +3 -0
+       bool should_link = (ofs->whiteout_link_max > 1);
        struct dentry *whiteout;
        struct inode *wdir = workdir->d_inode;
 
+retry:
        whiteout = ovl_lookup_temp(workdir);
        if (IS_ERR(whiteout))
                return whiteout;
 
+       if (should_link && ofs->whiteout) {

What happens with ofs->whiteout_link_max == 2 is that half of the times, whiteout gets linked and then unlinked.
That is not needed.
I think code would look better like this:

          if (ovl_whiteout_linkable(ofs)) {
                  err = ovl_do_link(ofs->whiteout, wdir, whiteout);
...
          } else if (ofs->whiteout) {
                  ovl_cleanup(wdir, ofs->whiteout);

....

With:

static inline bool ovl_whiteout_linkable(struct ovl_fs *ofs)

{
       return ofs->whiteout &&
                 ofs->whiteout->d_inode->i_nlink < ofs->whiteout_link_max;
}
Quoted 11 lines
fs/overlayfs/dir.c +11 -0
+               err = ovl_do_link(ofs->whiteout, wdir, whiteout);
+               if (err || !ovl_whiteout_linkable(ofs)) {
+                       ovl_cleanup(wdir, ofs->whiteout);
+                       dput(ofs->whiteout);
+                       ofs->whiteout = NULL;
+               }
+
+               if (!err)
+                       return whiteout;
+       }
+

...

fs/overlayfs/dir.c static int ovl_fill_super(struct super_block *sb, void *data, int silent) · line 1774

Quoted 9 lines
fs/overlayfs/dir.c +4 -0
@@ -1762,6 +1767,10 @@ static int ovl_fill_super(struct super_block *sb, void *data, int silent)
 
                if (!ofs->workdir)
                        sb->s_flags |= SB_RDONLY;
+               else
+                       ofs->whiteout_link_max = min_not_zero(
+                                       ofs->workdir->d_sb->s_max_links,
+                                       ovl_whiteout_link_max_def ?: 1);
 

Please leave that code inside ovl_get_workdir() or ovl_make_workdir().

Thanks,
Amir.

#2 lore raw

---- 在 星期二, 2020-04-14 21:44:39 Amir Goldstein <[email protected]> 撰写 ----

Quoted 59 lines · Chengguang Xu
Quoted 35 lines

Sharing inode with different whiteout files for saving inode and speeding up deleting operation.

---
v1->v2:
- Address Amir's comments in v1

v2->v3:
- Address Amir's comments in v2
- Rebase on Amir's "Overlayfs use index dir as work dir" patch set
- Keep at most one whiteout tmpfile in work dir

 fs/overlayfs/dir.c       | 35 ++++++++++++++++++++++++++++-------
 fs/overlayfs/overlayfs.h |  9 +++++++--
 fs/overlayfs/ovl_entry.h |  4 ++++
 fs/overlayfs/readdir.c   |  3 ++-
 fs/overlayfs/super.c     |  9 +++++++++
 fs/overlayfs/util.c      |  3 ++-
 6 files changed, 52 insertions(+), 11 deletions(-)
fs/overlayfs/dir.c +2 -1
index 279009dee366..dbe5e54dcb16 100644
@@ -62,35 +62,55 @@ struct dentry *ovl_lookup_temp(struct dentry *workdir)
 }
 
 /* caller holds i_mutex on workdir */
-static struct dentry *ovl_whiteout(struct dentry *workdir)
+static struct dentry *ovl_whiteout(struct ovl_fs *ofs, struct dentry *workdir)
 {
        int err;
+       bool retried = false;

fs/overlayfs/dir.c struct dentry *ovl_lookup_temp(struct dentry *workdir) · line 78

Quoted 10 lines
fs/overlayfs/dir.c +3 -0
+       bool should_link = (ofs->whiteout_link_max > 1);
        struct dentry *whiteout;
        struct inode *wdir = workdir->d_inode;
 
+retry:
        whiteout = ovl_lookup_temp(workdir);
        if (IS_ERR(whiteout))
                return whiteout;
 
+       if (should_link && ofs->whiteout) {

What happens with ofs->whiteout_link_max == 2 is that half of the times, whiteout gets linked and then unlinked.
That is not needed.
I think code would look better like this:

          if (ovl_whiteout_linkable(ofs)) {
                  err = ovl_do_link(ofs->whiteout, wdir, whiteout);
...
          } else if (ofs->whiteout) {
                  ovl_cleanup(wdir, ofs->whiteout);

....

Quoted 8 lines

With:

static inline bool ovl_whiteout_linkable(struct ovl_fs *ofs)

{
       return ofs->whiteout &&
                 ofs->whiteout->d_inode->i_nlink < ofs->whiteout_link_max;
}

tmpfile has occupied one link, so the maximum link count of whiteout inode in your code will be ofs->whiteout_link_max - 1, right?

Thanks,
cgxu

maintainer
#3 lore raw
Quoted 70 lines · Chengguang Xu

---- 在 星期二, 2020-04-14 21:44:39 Amir Goldstein <[email protected]> 撰写 ----

Quoted 59 lines · Chengguang Xu
Quoted 35 lines

Sharing inode with different whiteout files for saving inode and speeding up deleting operation.

---
v1->v2:
- Address Amir's comments in v1

v2->v3:
- Address Amir's comments in v2
- Rebase on Amir's "Overlayfs use index dir as work dir" patch set
- Keep at most one whiteout tmpfile in work dir

 fs/overlayfs/dir.c       | 35 ++++++++++++++++++++++++++++-------
 fs/overlayfs/overlayfs.h |  9 +++++++--
 fs/overlayfs/ovl_entry.h |  4 ++++
 fs/overlayfs/readdir.c   |  3 ++-
 fs/overlayfs/super.c     |  9 +++++++++
 fs/overlayfs/util.c      |  3 ++-
 6 files changed, 52 insertions(+), 11 deletions(-)
fs/overlayfs/dir.c +2 -1
index 279009dee366..dbe5e54dcb16 100644
@@ -62,35 +62,55 @@ struct dentry *ovl_lookup_temp(struct dentry *workdir)
 }
 
 /* caller holds i_mutex on workdir */
-static struct dentry *ovl_whiteout(struct dentry *workdir)
+static struct dentry *ovl_whiteout(struct ovl_fs *ofs, struct dentry *workdir)
 {
        int err;
+       bool retried = false;

fs/overlayfs/dir.c struct dentry *ovl_lookup_temp(struct dentry *workdir) · line 78

Quoted 10 lines
fs/overlayfs/dir.c +3 -0
+       bool should_link = (ofs->whiteout_link_max > 1);
        struct dentry *whiteout;
        struct inode *wdir = workdir->d_inode;
 
+retry:
        whiteout = ovl_lookup_temp(workdir);
        if (IS_ERR(whiteout))
                return whiteout;
 
+       if (should_link && ofs->whiteout) {

What happens with ofs->whiteout_link_max == 2 is that half of the times, whiteout gets linked and then unlinked.
That is not needed.
I think code would look better like this:

          if (ovl_whiteout_linkable(ofs)) {
                  err = ovl_do_link(ofs->whiteout, wdir, whiteout);
...
          } else if (ofs->whiteout) {
                  ovl_cleanup(wdir, ofs->whiteout);

....

Quoted 8 lines

With:

static inline bool ovl_whiteout_linkable(struct ovl_fs *ofs)

{
       return ofs->whiteout &&
                 ofs->whiteout->d_inode->i_nlink < ofs->whiteout_link_max;
}
Quoted 3 lines

tmpfile has occupied one link, so the maximum link count of whiteout inode in your code will be ofs->whiteout_link_max - 1, right?

Right, but I wrote wrong pseudo code to use this helper.
The intention is that ovl_whiteout_linkable(ofs) means there is a tmp whiteout and it may be linked to a new tmp whiteout.
The only reason to cleanup tmp whiteout is if link has unexpectedly failed and in this case I think we should disable whiteout sharing.

Let me try again:

+ err = -EMLINK;
+ if (ovl_whiteout_linkable(ofs)) {
+ err = ovl_do_link(ofs->whiteout, wdir, whiteout);
+ if (!err)
+ return whiteout;
+ }
+ if (err && ofs->whiteout) {
+ pr_warn("failed to link whiteout - disabling whiteout
sharing (nlink=%u, err = %i)\n",
+ ofs->whiteout->d_inode->i_nlink, err);

+               ofs->whiteout_link_max = 0;
+               should_link = false;
+               ovl_cleanup(wdir, ofs->whiteout);
+               dput(ofs->whiteout);
+               ofs->whiteout = NULL;
+       }
+
         err = ovl_do_whiteout(wdir, whiteout);

Is that better?

Thanks,
Amir.

#4 lore raw

---- 在 星期三, 2020-04-15 15:03:09 Amir Goldstein <[email protected]> 撰写 ----

Quoted 102 lines · Chengguang Xu
Quoted 70 lines

---- 在 星期二, 2020-04-14 21:44:39 Amir Goldstein <[email protected]> 撰写 ----

Quoted 59 lines · Chengguang Xu
Quoted 35 lines

Sharing inode with different whiteout files for saving inode and speeding up deleting operation.

---
v1->v2:
- Address Amir's comments in v1

v2->v3:
- Address Amir's comments in v2
- Rebase on Amir's "Overlayfs use index dir as work dir" patch set
- Keep at most one whiteout tmpfile in work dir

 fs/overlayfs/dir.c       | 35 ++++++++++++++++++++++++++++-------
 fs/overlayfs/overlayfs.h |  9 +++++++--
 fs/overlayfs/ovl_entry.h |  4 ++++
 fs/overlayfs/readdir.c   |  3 ++-
 fs/overlayfs/super.c     |  9 +++++++++
 fs/overlayfs/util.c      |  3 ++-
 6 files changed, 52 insertions(+), 11 deletions(-)
fs/overlayfs/dir.c +2 -1
index 279009dee366..dbe5e54dcb16 100644
@@ -62,35 +62,55 @@ struct dentry *ovl_lookup_temp(struct dentry *workdir)
 }
 
 /* caller holds i_mutex on workdir */
-static struct dentry *ovl_whiteout(struct dentry *workdir)
+static struct dentry *ovl_whiteout(struct ovl_fs *ofs, struct dentry *workdir)
 {
        int err;
+       bool retried = false;

fs/overlayfs/dir.c struct dentry *ovl_lookup_temp(struct dentry *workdir) · line 78

Quoted 10 lines
fs/overlayfs/dir.c +3 -0
+       bool should_link = (ofs->whiteout_link_max > 1);
        struct dentry *whiteout;
        struct inode *wdir = workdir->d_inode;
 
+retry:
        whiteout = ovl_lookup_temp(workdir);
        if (IS_ERR(whiteout))
                return whiteout;
 
+       if (should_link && ofs->whiteout) {

What happens with ofs->whiteout_link_max == 2 is that half of the times, whiteout gets linked and then unlinked.
That is not needed.
I think code would look better like this:

          if (ovl_whiteout_linkable(ofs)) {
                  err = ovl_do_link(ofs->whiteout, wdir, whiteout);
...
          } else if (ofs->whiteout) {
                  ovl_cleanup(wdir, ofs->whiteout);

....

Quoted 8 lines

With:

static inline bool ovl_whiteout_linkable(struct ovl_fs *ofs)

{
       return ofs->whiteout &&
                 ofs->whiteout->d_inode->i_nlink < ofs->whiteout_link_max;
}
Quoted 3 lines

tmpfile has occupied one link, so the maximum link count of whiteout inode in your code will be ofs->whiteout_link_max - 1, right?

Right, but I wrote wrong pseudo code to use this helper.
The intention is that ovl_whiteout_linkable(ofs) means there is a tmp whiteout and it may be linked to a new tmp whiteout.
The only reason to cleanup tmp whiteout is if link has unexpectedly failed and in this case I think we should disable whiteout sharing.

Let me try again:

fs/overlayfs/dir.c +8 -0
+       err = -EMLINK;
+       if (ovl_whiteout_linkable(ofs)) {
+               err = ovl_do_link(ofs->whiteout, wdir, whiteout);
+               if (!err)
+                       return whiteout;
+        }
+        if (err && ofs->whiteout) {
+               pr_warn("failed to link whiteout - disabling whiteout

sharing (nlink=%u, err = %i)\n",

fs/overlayfs/dir.c +8 -0
+                             ofs->whiteout->d_inode->i_nlink, err);
+               ofs->whiteout_link_max = 0;
+               should_link = false;
+               ovl_cleanup(wdir, ofs->whiteout);
+               dput(ofs->whiteout);
+               ofs->whiteout = NULL;
+       }
+
         err = ovl_do_whiteout(wdir, whiteout);
Quoted 2 lines

Is that better?

I don't fully understand why should we limit to share only one inode for whiteout files. Consider deleting a lot of files(not dir) in lowerdir, we will get -EMLINK error because the link count of shared inode exceeds the maximum link limit in underlying file system. In this case, we can choose another whiteout inode for sharing.

Thanks,
cgxu

maintainer
#5 lore raw
Quoted 104 lines · Chengguang Xu

---- 在 星期三, 2020-04-15 15:03:09 Amir Goldstein <[email protected]> 撰写 ----

Quoted 102 lines · Chengguang Xu
Quoted 70 lines

---- 在 星期二, 2020-04-14 21:44:39 Amir Goldstein <[email protected]> 撰写 ----

Quoted 59 lines · Chengguang Xu
Quoted 35 lines

Sharing inode with different whiteout files for saving inode and speeding up deleting operation.

---
v1->v2:
- Address Amir's comments in v1

v2->v3:
- Address Amir's comments in v2
- Rebase on Amir's "Overlayfs use index dir as work dir" patch set
- Keep at most one whiteout tmpfile in work dir

 fs/overlayfs/dir.c       | 35 ++++++++++++++++++++++++++++-------
 fs/overlayfs/overlayfs.h |  9 +++++++--
 fs/overlayfs/ovl_entry.h |  4 ++++
 fs/overlayfs/readdir.c   |  3 ++-
 fs/overlayfs/super.c     |  9 +++++++++
 fs/overlayfs/util.c      |  3 ++-
 6 files changed, 52 insertions(+), 11 deletions(-)
fs/overlayfs/dir.c +2 -1
index 279009dee366..dbe5e54dcb16 100644
@@ -62,35 +62,55 @@ struct dentry *ovl_lookup_temp(struct dentry *workdir)
 }
 
 /* caller holds i_mutex on workdir */
-static struct dentry *ovl_whiteout(struct dentry *workdir)
+static struct dentry *ovl_whiteout(struct ovl_fs *ofs, struct dentry *workdir)
 {
        int err;
+       bool retried = false;

fs/overlayfs/dir.c struct dentry *ovl_lookup_temp(struct dentry *workdir) · line 78

Quoted 10 lines
fs/overlayfs/dir.c +3 -0
+       bool should_link = (ofs->whiteout_link_max > 1);
        struct dentry *whiteout;
        struct inode *wdir = workdir->d_inode;
 
+retry:
        whiteout = ovl_lookup_temp(workdir);
        if (IS_ERR(whiteout))
                return whiteout;
 
+       if (should_link && ofs->whiteout) {

What happens with ofs->whiteout_link_max == 2 is that half of the times, whiteout gets linked and then unlinked.
That is not needed.
I think code would look better like this:

          if (ovl_whiteout_linkable(ofs)) {
                  err = ovl_do_link(ofs->whiteout, wdir, whiteout);
...
          } else if (ofs->whiteout) {
                  ovl_cleanup(wdir, ofs->whiteout);

....

Quoted 8 lines

With:

static inline bool ovl_whiteout_linkable(struct ovl_fs *ofs)

{
       return ofs->whiteout &&
                 ofs->whiteout->d_inode->i_nlink < ofs->whiteout_link_max;
}
Quoted 3 lines

tmpfile has occupied one link, so the maximum link count of whiteout inode in your code will be ofs->whiteout_link_max - 1, right?

Right, but I wrote wrong pseudo code to use this helper.
The intention is that ovl_whiteout_linkable(ofs) means there is a tmp whiteout and it may be linked to a new tmp whiteout.
The only reason to cleanup tmp whiteout is if link has unexpectedly failed and in this case I think we should disable whiteout sharing.

Let me try again:

fs/overlayfs/dir.c +8 -0
+       err = -EMLINK;
+       if (ovl_whiteout_linkable(ofs)) {
+               err = ovl_do_link(ofs->whiteout, wdir, whiteout);
+               if (!err)
+                       return whiteout;
+        }
+        if (err && ofs->whiteout) {
+               pr_warn("failed to link whiteout - disabling whiteout

sharing (nlink=%u, err = %i)\n",

fs/overlayfs/dir.c +8 -0
+                             ofs->whiteout->d_inode->i_nlink, err);
+               ofs->whiteout_link_max = 0;
+               should_link = false;
+               ovl_cleanup(wdir, ofs->whiteout);
+               dput(ofs->whiteout);
+               ofs->whiteout = NULL;
+       }
+
         err = ovl_do_whiteout(wdir, whiteout);
Quoted 8 lines
Quoted 2 lines

Is that better?

I don't fully understand why should we limit to share only one inode for whiteout files. Consider deleting a lot of files(not dir) in lowerdir, we will get -EMLINK error because the link count of shared inode exceeds the maximum link limit in underlying file system. In this case, we can choose another whiteout inode for sharing.

I got it wrong again. I forgot the maxed out case. Take #3:

+ err = 0;
+ if (ovl_whiteout_linkable(ofs)) {
+ err = ovl_do_link(ofs->whiteout, wdir, whiteout);
+ if (!err)
+ return whiteout;
+ } else if (ofs->whiteout) {

+               dput(whiteout);
+               whiteout = ofs->whiteout;
+               ofs->whiteout = NULL;
+               return whiteout;

+ }
+ if (err) {
+ pr_warn("failed to link whiteout - disabling whiteout
sharing (nlink=%u, err = %i)\n",
+ ofs->whiteout->d_inode->i_nlink, err);

+               ofs->whiteout_link_max = 0;
+               should_link = false;
+               ovl_cleanup(wdir, ofs->whiteout);
+       }
+
         err = ovl_do_whiteout(wdir, whiteout);

I hope I got the logic right this time.
Feel free to organize differently.
Disabling should be in the case where failure is not expected so we want to avoid having every whiteout creation try and fail. For example if filesystem reported s_max_links is incorrect.

Thanks,
Amir.

#6 lore raw

---- 在 星期三, 2020-04-15 16:12:04 Amir Goldstein <[email protected]> 撰写 ----

Quoted 139 lines · Chengguang Xu
Quoted 104 lines

---- 在 星期三, 2020-04-15 15:03:09 Amir Goldstein <[email protected]> 撰写 ----

Quoted 102 lines · Chengguang Xu
Quoted 70 lines

---- 在 星期二, 2020-04-14 21:44:39 Amir Goldstein <[email protected]> 撰写 ----

Quoted 59 lines · Chengguang Xu
Quoted 35 lines

Sharing inode with different whiteout files for saving inode and speeding up deleting operation.

---
v1->v2:
- Address Amir's comments in v1

v2->v3:
- Address Amir's comments in v2
- Rebase on Amir's "Overlayfs use index dir as work dir" patch set
- Keep at most one whiteout tmpfile in work dir

 fs/overlayfs/dir.c       | 35 ++++++++++++++++++++++++++++-------
 fs/overlayfs/overlayfs.h |  9 +++++++--
 fs/overlayfs/ovl_entry.h |  4 ++++
 fs/overlayfs/readdir.c   |  3 ++-
 fs/overlayfs/super.c     |  9 +++++++++
 fs/overlayfs/util.c      |  3 ++-
 6 files changed, 52 insertions(+), 11 deletions(-)
fs/overlayfs/dir.c +2 -1
index 279009dee366..dbe5e54dcb16 100644
@@ -62,35 +62,55 @@ struct dentry *ovl_lookup_temp(struct dentry *workdir)
 }
 
 /* caller holds i_mutex on workdir */
-static struct dentry *ovl_whiteout(struct dentry *workdir)
+static struct dentry *ovl_whiteout(struct ovl_fs *ofs, struct dentry *workdir)
 {
        int err;
+       bool retried = false;

fs/overlayfs/dir.c struct dentry *ovl_lookup_temp(struct dentry *workdir) · line 78

Quoted 10 lines
fs/overlayfs/dir.c +3 -0
+       bool should_link = (ofs->whiteout_link_max > 1);
        struct dentry *whiteout;
        struct inode *wdir = workdir->d_inode;
 
+retry:
        whiteout = ovl_lookup_temp(workdir);
        if (IS_ERR(whiteout))
                return whiteout;
 
+       if (should_link && ofs->whiteout) {

What happens with ofs->whiteout_link_max == 2 is that half of the times, whiteout gets linked and then unlinked.
That is not needed.
I think code would look better like this:

          if (ovl_whiteout_linkable(ofs)) {
                  err = ovl_do_link(ofs->whiteout, wdir, whiteout);
...
          } else if (ofs->whiteout) {
                  ovl_cleanup(wdir, ofs->whiteout);

....

Quoted 8 lines

With:

static inline bool ovl_whiteout_linkable(struct ovl_fs *ofs)

{
       return ofs->whiteout &&
                 ofs->whiteout->d_inode->i_nlink < ofs->whiteout_link_max;
}
Quoted 3 lines

tmpfile has occupied one link, so the maximum link count of whiteout inode in your code will be ofs->whiteout_link_max - 1, right?

Right, but I wrote wrong pseudo code to use this helper.
The intention is that ovl_whiteout_linkable(ofs) means there is a tmp whiteout and it may be linked to a new tmp whiteout.
The only reason to cleanup tmp whiteout is if link has unexpectedly failed and in this case I think we should disable whiteout sharing.

Let me try again:

fs/overlayfs/dir.c +8 -0
+       err = -EMLINK;
+       if (ovl_whiteout_linkable(ofs)) {
+               err = ovl_do_link(ofs->whiteout, wdir, whiteout);
+               if (!err)
+                       return whiteout;
+        }
+        if (err && ofs->whiteout) {
+               pr_warn("failed to link whiteout - disabling whiteout

sharing (nlink=%u, err = %i)\n",

fs/overlayfs/dir.c +8 -0
+                             ofs->whiteout->d_inode->i_nlink, err);
+               ofs->whiteout_link_max = 0;
+               should_link = false;
+               ovl_cleanup(wdir, ofs->whiteout);
+               dput(ofs->whiteout);
+               ofs->whiteout = NULL;
+       }
+
         err = ovl_do_whiteout(wdir, whiteout);
Quoted 8 lines
Quoted 2 lines

Is that better?

I don't fully understand why should we limit to share only one inode for whiteout files. Consider deleting a lot of files(not dir) in lowerdir, we will get -EMLINK error because the link count of shared inode exceeds the maximum link limit in underlying file system. In this case, we can choose another whiteout inode for sharing.

I got it wrong again. I forgot the maxed out case. Take #3:

(quoted diff) +13 -0
+       err = 0;
+       if (ovl_whiteout_linkable(ofs)) {
+               err = ovl_do_link(ofs->whiteout, wdir, whiteout);
+               if (!err)
+                       return whiteout;
+        } else if (ofs->whiteout) {
+               dput(whiteout);
+               whiteout = ofs->whiteout;
+               ofs->whiteout = NULL;
+               return whiteout;
+        }
+        if (err) {
+               pr_warn("failed to link whiteout - disabling whiteout

sharing (nlink=%u, err = %i)\n",

fs/overlayfs/dir.c +6 -0
+                             ofs->whiteout->d_inode->i_nlink, err);
+               ofs->whiteout_link_max = 0;
+               should_link = false;
+               ovl_cleanup(wdir, ofs->whiteout);
+       }
+
         err = ovl_do_whiteout(wdir, whiteout);
Quoted 6 lines

I hope I got the logic right this time.
Feel free to organize differently.
Disabling should be in the case where failure is not expected so we want to avoid having every whiteout creation try and fail. For example if filesystem reported s_max_links is incorrect.

In case of any unexpected errors, we could set a error limit(for example, 10), if link error count exceeds the limit then we disable the feature.

Thanks,
cgxu

maintainer
#7 lore raw
Quoted 148 lines · Chengguang Xu

---- 在 星期三, 2020-04-15 16:12:04 Amir Goldstein <[email protected]> 撰写 ----

Quoted 139 lines · Chengguang Xu
Quoted 104 lines

---- 在 星期三, 2020-04-15 15:03:09 Amir Goldstein <[email protected]> 撰写 ----

Quoted 102 lines · Chengguang Xu
Quoted 70 lines

---- 在 星期二, 2020-04-14 21:44:39 Amir Goldstein <[email protected]> 撰写 ----

Quoted 59 lines · Chengguang Xu
Quoted 35 lines

Sharing inode with different whiteout files for saving inode and speeding up deleting operation.

---
v1->v2:
- Address Amir's comments in v1

v2->v3:
- Address Amir's comments in v2
- Rebase on Amir's "Overlayfs use index dir as work dir" patch set
- Keep at most one whiteout tmpfile in work dir

 fs/overlayfs/dir.c       | 35 ++++++++++++++++++++++++++++-------
 fs/overlayfs/overlayfs.h |  9 +++++++--
 fs/overlayfs/ovl_entry.h |  4 ++++
 fs/overlayfs/readdir.c   |  3 ++-
 fs/overlayfs/super.c     |  9 +++++++++
 fs/overlayfs/util.c      |  3 ++-
 6 files changed, 52 insertions(+), 11 deletions(-)
fs/overlayfs/dir.c +2 -1
index 279009dee366..dbe5e54dcb16 100644
@@ -62,35 +62,55 @@ struct dentry *ovl_lookup_temp(struct dentry *workdir)
 }
 
 /* caller holds i_mutex on workdir */
-static struct dentry *ovl_whiteout(struct dentry *workdir)
+static struct dentry *ovl_whiteout(struct ovl_fs *ofs, struct dentry *workdir)
 {
        int err;
+       bool retried = false;

fs/overlayfs/dir.c struct dentry *ovl_lookup_temp(struct dentry *workdir) · line 78

Quoted 10 lines
fs/overlayfs/dir.c +3 -0
+       bool should_link = (ofs->whiteout_link_max > 1);
        struct dentry *whiteout;
        struct inode *wdir = workdir->d_inode;
 
+retry:
        whiteout = ovl_lookup_temp(workdir);
        if (IS_ERR(whiteout))
                return whiteout;
 
+       if (should_link && ofs->whiteout) {

What happens with ofs->whiteout_link_max == 2 is that half of the times, whiteout gets linked and then unlinked.
That is not needed.
I think code would look better like this:

          if (ovl_whiteout_linkable(ofs)) {
                  err = ovl_do_link(ofs->whiteout, wdir, whiteout);
...
          } else if (ofs->whiteout) {
                  ovl_cleanup(wdir, ofs->whiteout);

....

Quoted 8 lines

With:

static inline bool ovl_whiteout_linkable(struct ovl_fs *ofs)

{
       return ofs->whiteout &&
                 ofs->whiteout->d_inode->i_nlink < ofs->whiteout_link_max;
}
Quoted 3 lines

tmpfile has occupied one link, so the maximum link count of whiteout inode in your code will be ofs->whiteout_link_max - 1, right?

Right, but I wrote wrong pseudo code to use this helper.
The intention is that ovl_whiteout_linkable(ofs) means there is a tmp whiteout and it may be linked to a new tmp whiteout.
The only reason to cleanup tmp whiteout is if link has unexpectedly failed and in this case I think we should disable whiteout sharing.

Let me try again:

(quoted diff) +8 -0
+       err = -EMLINK;
+       if (ovl_whiteout_linkable(ofs)) {
+               err = ovl_do_link(ofs->whiteout, wdir, whiteout);
+               if (!err)
+                       return whiteout;
+        }
+        if (err && ofs->whiteout) {
+               pr_warn("failed to link whiteout - disabling whiteout

sharing (nlink=%u, err = %i)\n",

(quoted diff) +8 -0
+                             ofs->whiteout->d_inode->i_nlink, err);
+               ofs->whiteout_link_max = 0;
+               should_link = false;
+               ovl_cleanup(wdir, ofs->whiteout);
+               dput(ofs->whiteout);
+               ofs->whiteout = NULL;
+       }
+
         err = ovl_do_whiteout(wdir, whiteout);
Quoted 8 lines
Quoted 2 lines

Is that better?

I don't fully understand why should we limit to share only one inode for whiteout files. Consider deleting a lot of files(not dir) in lowerdir, we will get -EMLINK error because the link count of shared inode exceeds the maximum link limit in underlying file system. In this case, we can choose another whiteout inode for sharing.

I got it wrong again. I forgot the maxed out case. Take #3:

(quoted diff) +13 -0
+       err = 0;
+       if (ovl_whiteout_linkable(ofs)) {
+               err = ovl_do_link(ofs->whiteout, wdir, whiteout);
+               if (!err)
+                       return whiteout;
+        } else if (ofs->whiteout) {
+               dput(whiteout);
+               whiteout = ofs->whiteout;
+               ofs->whiteout = NULL;
+               return whiteout;
+        }
+        if (err) {
+               pr_warn("failed to link whiteout - disabling whiteout

sharing (nlink=%u, err = %i)\n",

(quoted diff) +6 -0
+                             ofs->whiteout->d_inode->i_nlink, err);
+               ofs->whiteout_link_max = 0;
+               should_link = false;
+               ovl_cleanup(wdir, ofs->whiteout);
+       }
+
         err = ovl_do_whiteout(wdir, whiteout);
Quoted 6 lines

I hope I got the logic right this time.
Feel free to organize differently.
Disabling should be in the case where failure is not expected so we want to avoid having every whiteout creation try and fail. For example if filesystem reported s_max_links is incorrect.

Quoted 3 lines

In case of any unexpected errors, we could set a error limit(for example, 10), if link error count exceeds the limit then we disable the feature.

As far as I am concerned, you may post the patch without auto disable, but I object to using an arbitrary number of errors (10) as trigger for auto disable.

I do think that it is important to communicate to admin that the whiteout sharing is not working as expected and it is not acceptable to flood log with warning on each and every whiteout creation, not even with pr_warn_ratelimited.

There are several ways you can go about this, but here is a suggestion:

+ if (err) {
+ ofs->whiteout_link_max >>= 1;
+ pr_warn("failed to link whiteout (nlink=%u, err = %i)
- lowering whiteout_link_max to %u\n",
+ ofs->whiteout->d_inode->i_nlink, err,
ofs->whiteout_link_max);
+ should_link = false;
+ ovl_cleanup(wdir, ofs->whiteout);
+ }

Thanks,
Amir.

#8 lore raw

---- 在 星期三, 2020-04-15 19:26:40 Amir Goldstein <[email protected]> 撰写 ----

Quoted 171 lines · Chengguang Xu
Quoted 148 lines

---- 在 星期三, 2020-04-15 16:12:04 Amir Goldstein <[email protected]> 撰写 ----

Quoted 139 lines · Chengguang Xu
Quoted 104 lines

---- 在 星期三, 2020-04-15 15:03:09 Amir Goldstein <[email protected]> 撰写 ----

Quoted 102 lines · Chengguang Xu
Quoted 70 lines

---- 在 星期二, 2020-04-14 21:44:39 Amir Goldstein <[email protected]> 撰写 ----

Quoted 59 lines · Chengguang Xu
Quoted 35 lines

Sharing inode with different whiteout files for saving inode and speeding up deleting operation.

---
v1->v2:
- Address Amir's comments in v1

v2->v3:
- Address Amir's comments in v2
- Rebase on Amir's "Overlayfs use index dir as work dir" patch set
- Keep at most one whiteout tmpfile in work dir

 fs/overlayfs/dir.c       | 35 ++++++++++++++++++++++++++++-------
 fs/overlayfs/overlayfs.h |  9 +++++++--
 fs/overlayfs/ovl_entry.h |  4 ++++
 fs/overlayfs/readdir.c   |  3 ++-
 fs/overlayfs/super.c     |  9 +++++++++
 fs/overlayfs/util.c      |  3 ++-
 6 files changed, 52 insertions(+), 11 deletions(-)
fs/overlayfs/dir.c +2 -1
index 279009dee366..dbe5e54dcb16 100644
@@ -62,35 +62,55 @@ struct dentry *ovl_lookup_temp(struct dentry *workdir)
 }
 
 /* caller holds i_mutex on workdir */
-static struct dentry *ovl_whiteout(struct dentry *workdir)
+static struct dentry *ovl_whiteout(struct ovl_fs *ofs, struct dentry *workdir)
 {
        int err;
+       bool retried = false;

fs/overlayfs/dir.c struct dentry *ovl_lookup_temp(struct dentry *workdir) · line 78

Quoted 10 lines
fs/overlayfs/dir.c +3 -0
+       bool should_link = (ofs->whiteout_link_max > 1);
        struct dentry *whiteout;
        struct inode *wdir = workdir->d_inode;
 
+retry:
        whiteout = ovl_lookup_temp(workdir);
        if (IS_ERR(whiteout))
                return whiteout;
 
+       if (should_link && ofs->whiteout) {

What happens with ofs->whiteout_link_max == 2 is that half of the times, whiteout gets linked and then unlinked.
That is not needed.
I think code would look better like this:

          if (ovl_whiteout_linkable(ofs)) {
                  err = ovl_do_link(ofs->whiteout, wdir, whiteout);
...
          } else if (ofs->whiteout) {
                  ovl_cleanup(wdir, ofs->whiteout);

....

Quoted 8 lines

With:

static inline bool ovl_whiteout_linkable(struct ovl_fs *ofs)

{
       return ofs->whiteout &&
                 ofs->whiteout->d_inode->i_nlink < ofs->whiteout_link_max;
}
Quoted 3 lines

tmpfile has occupied one link, so the maximum link count of whiteout inode in your code will be ofs->whiteout_link_max - 1, right?

Right, but I wrote wrong pseudo code to use this helper.
The intention is that ovl_whiteout_linkable(ofs) means there is a tmp whiteout and it may be linked to a new tmp whiteout.
The only reason to cleanup tmp whiteout is if link has unexpectedly failed and in this case I think we should disable whiteout sharing.

Let me try again:

(quoted diff) +8 -0
+       err = -EMLINK;
+       if (ovl_whiteout_linkable(ofs)) {
+               err = ovl_do_link(ofs->whiteout, wdir, whiteout);
+               if (!err)
+                       return whiteout;
+        }
+        if (err && ofs->whiteout) {
+               pr_warn("failed to link whiteout - disabling whiteout

sharing (nlink=%u, err = %i)\n",

(quoted diff) +8 -0
+                             ofs->whiteout->d_inode->i_nlink, err);
+               ofs->whiteout_link_max = 0;
+               should_link = false;
+               ovl_cleanup(wdir, ofs->whiteout);
+               dput(ofs->whiteout);
+               ofs->whiteout = NULL;
+       }
+
         err = ovl_do_whiteout(wdir, whiteout);
Quoted 8 lines
Quoted 2 lines

Is that better?

I don't fully understand why should we limit to share only one inode for whiteout files. Consider deleting a lot of files(not dir) in lowerdir, we will get -EMLINK error because the link count of shared inode exceeds the maximum link limit in underlying file system. In this case, we can choose another whiteout inode for sharing.

I got it wrong again. I forgot the maxed out case. Take #3:

(quoted diff) +13 -0
+       err = 0;
+       if (ovl_whiteout_linkable(ofs)) {
+               err = ovl_do_link(ofs->whiteout, wdir, whiteout);
+               if (!err)
+                       return whiteout;
+        } else if (ofs->whiteout) {
+               dput(whiteout);
+               whiteout = ofs->whiteout;
+               ofs->whiteout = NULL;
+               return whiteout;
+        }
+        if (err) {
+               pr_warn("failed to link whiteout - disabling whiteout

sharing (nlink=%u, err = %i)\n",

(quoted diff) +6 -0
+                             ofs->whiteout->d_inode->i_nlink, err);
+               ofs->whiteout_link_max = 0;
+               should_link = false;
+               ovl_cleanup(wdir, ofs->whiteout);
+       }
+
         err = ovl_do_whiteout(wdir, whiteout);
Quoted 6 lines

I hope I got the logic right this time.
Feel free to organize differently.
Disabling should be in the case where failure is not expected so we want to avoid having every whiteout creation try and fail. For example if filesystem reported s_max_links is incorrect.

Quoted 3 lines

In case of any unexpected errors, we could set a error limit(for example, 10), if link error count exceeds the limit then we disable the feature.

As far as I am concerned, you may post the patch without auto disable, but I object to using an arbitrary number of errors (10) as trigger for auto disable.

I do think that it is important to communicate to admin that the whiteout sharing is not working as expected and it is not acceptable to flood log with warning on each and every whiteout creation, not even with pr_warn_ratelimited.

There are several ways you can go about this, but here is a suggestion:

(quoted diff) +4 -1
+        if (err) {
+               ofs->whiteout_link_max >>= 1;
+               pr_warn("failed to link whiteout (nlink=%u, err = %i)
- lowering whiteout_link_max to %u\n",
+                             ofs->whiteout->d_inode->i_nlink, err,

ofs->whiteout_link_max);

Review

Quoted 3 lines
(quoted diff) +3 -0
+               should_link = false;
+               ovl_cleanup(wdir, ofs->whiteout);
+       }

Frankly speaking, I don't like heuristic method to automatically enable/disable feature,
so I perfer to disable the feature immediately after hitting any error just like your previous suggestion, and I also hope to add a mount option for this feature to mitigate global effect to different overlayfs instances.

Thanks,
cgxu

maintainer
#9 lore raw
Quoted 26 lines
Quoted 22 lines
Quoted 3 lines

In case of any unexpected errors, we could set a error limit(for example, 10), if link error count exceeds the limit then we disable the feature.

As far as I am concerned, you may post the patch without auto disable, but I object to using an arbitrary number of errors (10) as trigger for auto disable.

I do think that it is important to communicate to admin that the whiteout sharing is not working as expected and it is not acceptable to flood log with warning on each and every whiteout creation, not even with pr_warn_ratelimited.

There are several ways you can go about this, but here is a suggestion:

(quoted diff) +4 -1
+        if (err) {
+               ofs->whiteout_link_max >>= 1;
+               pr_warn("failed to link whiteout (nlink=%u, err = %i)
- lowering whiteout_link_max to %u\n",
+                             ofs->whiteout->d_inode->i_nlink, err,

ofs->whiteout_link_max);

Review

Quoted 3 lines
(quoted diff) +3 -0
+               should_link = false;
+               ovl_cleanup(wdir, ofs->whiteout);
+       }
Quoted 2 lines

Frankly speaking, I don't like heuristic method to automatically enable/disable feature, so I perfer to disable the feature immediately after hitting any error just like your previous suggestion,

Fine by me.

Quoted 2 lines

and I also hope to add a mount option for this feature to mitigate global effect to different overlayfs instances.

I think that would make sense.

Off topic: from system perspective, the fact that whiteouts take up inodes to begin with is a shame. If one had control over the underlying filesystem, whiteout should have been implemented as a constant and immutable special inode with no nlink count at all and getdents would return DT_WHITEOUT for those entries.

Thanks,
Amir.

maintainer
#10 lore raw
Quoted 35 lines · Amir Goldstein
Quoted 27 lines
Quoted 23 lines
Quoted 4 lines

In case of any unexpected errors, we could set a error limit(for example, 10), if link error count exceeds the limit then we disable the feature.

As far as I am concerned, you may post the patch without auto disable, but I object to using an arbitrary number of errors (10) as trigger for auto disable.

I do think that it is important to communicate to admin that the whiteout sharing is not working as expected and it is not acceptable to flood log with warning on each and every whiteout creation, not even with pr_warn_ratelimited.

There are several ways you can go about this, but here is a suggestion:

(quoted diff) +4 -1
+        if (err) {
+               ofs->whiteout_link_max >>= 1;
+               pr_warn("failed to link whiteout (nlink=%u, err = %i)
- lowering whiteout_link_max to %u\n",
+                             ofs->whiteout->d_inode->i_nlink, err,

ofs->whiteout_link_max);

Review

Quoted 3 lines
(quoted diff) +3 -0
+               should_link = false;
+               ovl_cleanup(wdir, ofs->whiteout);
+       }
Quoted 2 lines

Frankly speaking, I don't like heuristic method to automatically enable/disable feature, so I perfer to disable the feature immediately after hitting any error just like your previous suggestion,

Fine by me.

Quoted 2 lines

and I also hope to add a mount option for this feature to mitigate global effect to different overlayfs instances.

Quoted 7 lines

I think that would make sense.

Off topic: from system perspective, the fact that whiteouts take up inodes to begin with is a shame. If one had control over the underlying filesystem, whiteout should have been implemented as a constant and immutable special inode with no nlink count at all and getdents would return DT_WHITEOUT for those entries.

Yes, and filesystems are free to implement such a beast. The operations are given: mknod(S_IFCHR, 0) and RENAME_WHITEOUT. Adding DT_WHITEOUT handling to overlayfs would be trivial, I guess.

Thanks,
Miklos