Skip to contentSkip to conversation

vfs: reorder checks in may_create_in_sticky

PATCH Applied Mateusz Guzik 3 participants 6 messages Jun 20, 2024 – Jun 21, 2024 VFS

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 vfs: reorder checks in may_create_in_sticky

The routine is called for all directories on file creation and weirdly postpones the check if the dir is sticky to begin with. Instead it first checks fifos and regular files (in that order), while avoidably pulling globals.

No functional changes.

---
 fs/namei.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
fs/namei.c +3 -3
index 63d1fb06da6b..b1600060ecfb 100644
@@ -1246,9 +1246,9 @@ static int may_create_in_sticky(struct mnt_idmap *idmap,
 	umode_t dir_mode = nd->dir_mode;
 	vfsuid_t dir_vfsuid = nd->dir_vfsuid;
 
-	if ((!sysctl_protected_fifos && S_ISFIFO(inode->i_mode)) ||
-	    (!sysctl_protected_regular && S_ISREG(inode->i_mode)) ||
-	    likely(!(dir_mode & S_ISVTX)) ||
+	if (likely(!(dir_mode & S_ISVTX)) ||
+	    (S_ISREG(inode->i_mode) && !sysctl_protected_regular) ||
+	    (S_ISFIFO(inode->i_mode) && !sysctl_protected_fifos) ||
 	    vfsuid_eq(i_uid_into_vfsuid(idmap, inode), dir_vfsuid) ||
 	    vfsuid_eq_kuid(i_uid_into_vfsuid(idmap, inode), current_fsuid()))
 		return 0;
Signature · 1 line
2.43.0
reviewer Reviewed-by on v1 1/1
#1 lore raw
Quoted 8 lines · Mateusz Guzik

The routine is called for all directories on file creation and weirdly postpones the check if the dir is sticky to begin with. Instead it first checks fifos and regular files (in that order), while avoidably pulling globals.

No functional changes.

Yeah, putting the sticky bit check first makes sense also logically. Feel free to add:

Honza

Quoted 24 lines
---
 fs/namei.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
fs/namei.c +3 -3
index 63d1fb06da6b..b1600060ecfb 100644
@@ -1246,9 +1246,9 @@ static int may_create_in_sticky(struct mnt_idmap *idmap,
 	umode_t dir_mode = nd->dir_mode;
 	vfsuid_t dir_vfsuid = nd->dir_vfsuid;
 
-	if ((!sysctl_protected_fifos && S_ISFIFO(inode->i_mode)) ||
-	    (!sysctl_protected_regular && S_ISREG(inode->i_mode)) ||
-	    likely(!(dir_mode & S_ISVTX)) ||
+	if (likely(!(dir_mode & S_ISVTX)) ||
+	    (S_ISREG(inode->i_mode) && !sysctl_protected_regular) ||
+	    (S_ISFIFO(inode->i_mode) && !sysctl_protected_fifos) ||
 	    vfsuid_eq(i_uid_into_vfsuid(idmap, inode), dir_vfsuid) ||
 	    vfsuid_eq_kuid(i_uid_into_vfsuid(idmap, inode), current_fsuid()))
 		return 0;
Signature · 1 line
2.43.0
Signature · 2 lines
Jan Kara <[email protected]>
SUSE Labs, CR
maintainer Applied
#2 lore raw
In reply to Mateusz Guzik
Quoted 8 lines · Mateusz Guzik

The routine is called for all directories on file creation and weirdly postpones the check if the dir is sticky to begin with. Instead it first checks fifos and regular files (in that order), while avoidably pulling globals.

No functional changes.

[...]

The list of checks is unspeakably irritating. I really dislike looking at this function.

---

Applied to the vfs.misc branch of the vfs/vfs.git tree. Patches in the vfs.misc branch should appear in linux-next soon.

Please report any outstanding bugs that were missed during review in a new review to the original patch series allowing us to drop it.

It's encouraged to provide Acked-bys and Reviewed-bys even though the patch has now been applied. If possible patch trailers will be updated.

Note that commit hashes shown below are subject to change due to rebase, trailer updates or similar. If in doubt, please check the listed branch.

tree:   https://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs.git
branch: vfs.misc

[1/1] vfs: reorder checks in may_create_in_sticky

      https://git.kernel.org/vfs/vfs/c/6cc620b3a050
#3 lore raw
In reply to Mateusz Guzik
Quoted 19 lines · Mateusz Guzik

The routine is called for all directories on file creation and weirdly postpones the check if the dir is sticky to begin with. Instead it first checks fifos and regular files (in that order), while avoidably pulling globals.

No functional changes.

---
 fs/namei.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
fs/namei.c +0 -0
index 63d1fb06da6b..b1600060ecfb 100644
@@ -1246,9 +1246,9 @@ static int may_create_in_sticky(struct mnt_idmap *idmap,
 	umode_t dir_mode = nd->dir_mode;
 	vfsuid_t dir_vfsuid = nd->dir_vfsuid;

fs/namei.c static int may_create_in_sticky(struct mnt_idmap *idmap, · line 1254

Quoted 10 lines
fs/namei.c +3 -3
 
-	if ((!sysctl_protected_fifos && S_ISFIFO(inode->i_mode)) ||
-	    (!sysctl_protected_regular && S_ISREG(inode->i_mode)) ||
-	    likely(!(dir_mode & S_ISVTX)) ||
+	if (likely(!(dir_mode & S_ISVTX)) ||
+	    (S_ISREG(inode->i_mode) && !sysctl_protected_regular) ||
+	    (S_ISFIFO(inode->i_mode) && !sysctl_protected_fifos) ||
 	    vfsuid_eq(i_uid_into_vfsuid(idmap, inode), dir_vfsuid) ||
 	    vfsuid_eq_kuid(i_uid_into_vfsuid(idmap, inode), current_fsuid()))
 		return 0;

I think we really need to unroll this unoly mess to make it more readable?

fs/namei.c +32 -14
index 3e23fbb8b029..1dd2d328bae3 100644
@@ -1244,25 +1244,43 @@ static int may_create_in_sticky(struct mnt_idmap *idmap,
                                struct nameidata *nd, struct inode *const inode)
 {
        umode_t dir_mode = nd->dir_mode;
-       vfsuid_t dir_vfsuid = nd->dir_vfsuid;
+       vfsuid_t dir_vfsuid = nd->dir_vfsuid, i_vfsuid;
+       int ret;
+
+       if (likely(!(dir_mode & S_ISVTX)))
+               return 0;
+
+       if (S_ISREG(inode->i_mode) && !sysctl_protected_regular)
+               return 0;
+
+       if (S_ISFIFO(inode->i_mode) && !sysctl_protected_fifos)
+               return 0;
+
+       i_vfsuid = i_uid_into_vfsuid(idmap, inode);
+
+       if (vfsuid_eq(i_vfsuid, dir_vfsuid))
+               return 0;
 
-       if (likely(!(dir_mode & S_ISVTX)) ||
-           (S_ISREG(inode->i_mode) && !sysctl_protected_regular) ||
-           (S_ISFIFO(inode->i_mode) && !sysctl_protected_fifos) ||
-           vfsuid_eq(i_uid_into_vfsuid(idmap, inode), dir_vfsuid) ||
-           vfsuid_eq_kuid(i_uid_into_vfsuid(idmap, inode), current_fsuid()))
+       if (vfsuid_eq_kuid(i_vfsuid, current_fsuid()))
                return 0;
 
-       if (likely(dir_mode & 0002) ||
-           (dir_mode & 0020 &&
-            ((sysctl_protected_fifos >= 2 && S_ISFIFO(inode->i_mode)) ||
-             (sysctl_protected_regular >= 2 && S_ISREG(inode->i_mode))))) {
-               const char *operation = S_ISFIFO(inode->i_mode) ?
-                                       "sticky_create_fifo" :
-                                       "sticky_create_regular";
-               audit_log_path_denied(AUDIT_ANOM_CREAT, operation);
+       if (likely(dir_mode & 0002)) {
+               audit_log_path_denied(AUDIT_ANOM_CREAT, "sticky_create");
                return -EACCES;
        }
+
+       if (dir_mode & 0020) {
+               if (sysctl_protected_fifos >= 2 && S_ISFIFO(inode->i_mode)) {
+                       audit_log_path_denied(AUDIT_ANOM_CREAT, "sticky_create_fifo");
+                       return -EACCES;
+               }
+
+               if (sysctl_protected_regular >= 2 && S_ISREG(inode->i_mode)) {
+                       audit_log_path_denied(AUDIT_ANOM_CREAT, "sticky_create_regular");
+                       return -EACCES;
+               }
+       }
+
        return 0;
 }
 

That gives us:

static int may_create_in_sticky(struct mnt_idmap *idmap,
struct nameidata *nd, struct inode *const inode)

{
	umode_t dir_mode = nd->dir_mode;
	vfsuid_t dir_vfsuid = nd->dir_vfsuid, i_vfsuid;
	int ret;

	if (likely(!(dir_mode & S_ISVTX)))
		return 0;

	if (S_ISREG(inode->i_mode) && !sysctl_protected_regular)
		return 0;

	if (S_ISFIFO(inode->i_mode) && !sysctl_protected_fifos)
		return 0;

	i_vfsuid = i_uid_into_vfsuid(idmap, inode);

	if (vfsuid_eq(i_vfsuid, dir_vfsuid))
		return 0;

	if (vfsuid_eq_kuid(i_vfsuid, current_fsuid()))
		return 0;

	if (likely(dir_mode & 0002)) {
		audit_log_path_denied(AUDIT_ANOM_CREAT, "sticky_create");
		return -EACCES;
	}

	if (dir_mode & 0020) {
		if (sysctl_protected_fifos >= 2 && S_ISFIFO(inode->i_mode)) {
			audit_log_path_denied(AUDIT_ANOM_CREAT, "sticky_create_fifo");
			return -EACCES;
		}

		if (sysctl_protected_regular >= 2 && S_ISREG(inode->i_mode)) {
			audit_log_path_denied(AUDIT_ANOM_CREAT, "sticky_create_regular");
			return -EACCES;
		}
	}

	return 0;
}
#4 lore raw
Quoted 133 lines · Christian Brauner
Quoted 19 lines · Mateusz Guzik

The routine is called for all directories on file creation and weirdly postpones the check if the dir is sticky to begin with. Instead it first checks fifos and regular files (in that order), while avoidably pulling globals.

No functional changes.

---
 fs/namei.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
fs/namei.c +0 -0
index 63d1fb06da6b..b1600060ecfb 100644
@@ -1246,9 +1246,9 @@ static int may_create_in_sticky(struct mnt_idmap *idmap,
      umode_t dir_mode = nd->dir_mode;
      vfsuid_t dir_vfsuid = nd->dir_vfsuid;

fs/namei.c static int may_create_in_sticky(struct mnt_idmap *idmap, · line 1254

Quoted 10 lines
fs/namei.c +3 -3
 
-     if ((!sysctl_protected_fifos && S_ISFIFO(inode->i_mode)) ||
-         (!sysctl_protected_regular && S_ISREG(inode->i_mode)) ||
-         likely(!(dir_mode & S_ISVTX)) ||
+     if (likely(!(dir_mode & S_ISVTX)) ||
+         (S_ISREG(inode->i_mode) && !sysctl_protected_regular) ||
+         (S_ISFIFO(inode->i_mode) && !sysctl_protected_fifos) ||
          vfsuid_eq(i_uid_into_vfsuid(idmap, inode), dir_vfsuid) ||
          vfsuid_eq_kuid(i_uid_into_vfsuid(idmap, inode), current_fsuid()))
              return 0;

I think we really need to unroll this unoly mess to make it more readable?

fs/namei.c +32 -14
index 3e23fbb8b029..1dd2d328bae3 100644
@@ -1244,25 +1244,43 @@ static int may_create_in_sticky(struct mnt_idmap *idmap,
                                struct nameidata *nd, struct inode *const inode)
 {
        umode_t dir_mode = nd->dir_mode;
-       vfsuid_t dir_vfsuid = nd->dir_vfsuid;
+       vfsuid_t dir_vfsuid = nd->dir_vfsuid, i_vfsuid;
+       int ret;
+
+       if (likely(!(dir_mode & S_ISVTX)))
+               return 0;
+
+       if (S_ISREG(inode->i_mode) && !sysctl_protected_regular)
+               return 0;
+
+       if (S_ISFIFO(inode->i_mode) && !sysctl_protected_fifos)
+               return 0;
+
+       i_vfsuid = i_uid_into_vfsuid(idmap, inode);
+
+       if (vfsuid_eq(i_vfsuid, dir_vfsuid))
+               return 0;
 
-       if (likely(!(dir_mode & S_ISVTX)) ||
-           (S_ISREG(inode->i_mode) && !sysctl_protected_regular) ||
-           (S_ISFIFO(inode->i_mode) && !sysctl_protected_fifos) ||
-           vfsuid_eq(i_uid_into_vfsuid(idmap, inode), dir_vfsuid) ||
-           vfsuid_eq_kuid(i_uid_into_vfsuid(idmap, inode), current_fsuid()))
+       if (vfsuid_eq_kuid(i_vfsuid, current_fsuid()))
                return 0;
 
-       if (likely(dir_mode & 0002) ||
-           (dir_mode & 0020 &&
-            ((sysctl_protected_fifos >= 2 && S_ISFIFO(inode->i_mode)) ||
-             (sysctl_protected_regular >= 2 && S_ISREG(inode->i_mode))))) {
-               const char *operation = S_ISFIFO(inode->i_mode) ?
-                                       "sticky_create_fifo" :
-                                       "sticky_create_regular";
-               audit_log_path_denied(AUDIT_ANOM_CREAT, operation);
+       if (likely(dir_mode & 0002)) {
+               audit_log_path_denied(AUDIT_ANOM_CREAT, "sticky_create");
                return -EACCES;
        }
+
+       if (dir_mode & 0020) {
+               if (sysctl_protected_fifos >= 2 && S_ISFIFO(inode->i_mode)) {
+                       audit_log_path_denied(AUDIT_ANOM_CREAT, "sticky_create_fifo");
+                       return -EACCES;
+               }
+
+               if (sysctl_protected_regular >= 2 && S_ISREG(inode->i_mode)) {
+                       audit_log_path_denied(AUDIT_ANOM_CREAT, "sticky_create_regular");
+                       return -EACCES;
+               }
+       }
+
        return 0;
 }
 

That gives us:

static int may_create_in_sticky(struct mnt_idmap *idmap,
struct nameidata *nd, struct inode *const inode)

{
        umode_t dir_mode = nd->dir_mode;
        vfsuid_t dir_vfsuid = nd->dir_vfsuid, i_vfsuid;
        int ret;

        if (likely(!(dir_mode & S_ISVTX)))
                return 0;

        if (S_ISREG(inode->i_mode) && !sysctl_protected_regular)
                return 0;

        if (S_ISFIFO(inode->i_mode) && !sysctl_protected_fifos)
                return 0;

        i_vfsuid = i_uid_into_vfsuid(idmap, inode);

        if (vfsuid_eq(i_vfsuid, dir_vfsuid))
                return 0;

        if (vfsuid_eq_kuid(i_vfsuid, current_fsuid()))
                return 0;

        if (likely(dir_mode & 0002)) {
                audit_log_path_denied(AUDIT_ANOM_CREAT, "sticky_create");
                return -EACCES;
        }

        if (dir_mode & 0020) {
                if (sysctl_protected_fifos >= 2 && S_ISFIFO(inode->i_mode)) {
                        audit_log_path_denied(AUDIT_ANOM_CREAT, "sticky_create_fifo");
                        return -EACCES;
                }
Quoted 8 lines
                if (sysctl_protected_regular >= 2 && S_ISREG(inode->i_mode)) {
                        audit_log_path_denied(AUDIT_ANOM_CREAT, "sticky_create_regular");
                        return -EACCES;
                }
        }

        return 0;
}

That does look better. :)

So as far as I'm concerned my patch can be just dropped, just in case I'll note there is no need to mention me anywhere near this.

Signature · 1 line
Mateusz Guzik <mjguzik gmail.com>
reviewer Reviewed-by
#5 lore raw
In reply to Christian Brauner
Quoted 21 lines · Christian Brauner
Quoted 20 lines · Mateusz Guzik

The routine is called for all directories on file creation and weirdly postpones the check if the dir is sticky to begin with. Instead it first checks fifos and regular files (in that order), while avoidably pulling globals.

No functional changes.

---
 fs/namei.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
fs/namei.c +0 -0
index 63d1fb06da6b..b1600060ecfb 100644
@@ -1246,9 +1246,9 @@ static int may_create_in_sticky(struct mnt_idmap *idmap,
 	umode_t dir_mode = nd->dir_mode;
 	vfsuid_t dir_vfsuid = nd->dir_vfsuid;
 
Quoted 11 lines

fs/namei.c static int may_create_in_sticky(struct mnt_idmap *idmap, · line 1254

Quoted 9 lines
fs/namei.c +3 -3
-	if ((!sysctl_protected_fifos && S_ISFIFO(inode->i_mode)) ||
-	    (!sysctl_protected_regular && S_ISREG(inode->i_mode)) ||
-	    likely(!(dir_mode & S_ISVTX)) ||
+	if (likely(!(dir_mode & S_ISVTX)) ||
+	    (S_ISREG(inode->i_mode) && !sysctl_protected_regular) ||
+	    (S_ISFIFO(inode->i_mode) && !sysctl_protected_fifos) ||
 	    vfsuid_eq(i_uid_into_vfsuid(idmap, inode), dir_vfsuid) ||
 	    vfsuid_eq_kuid(i_uid_into_vfsuid(idmap, inode), current_fsuid()))
 		return 0;

I think we really need to unroll this unoly mess to make it more readable?

I guess my neural network has adapted to these kind of things in the kernel :)

Quoted 51 lines
fs/namei.c +24 -14
index 3e23fbb8b029..1dd2d328bae3 100644
@@ -1244,25 +1244,43 @@ static int may_create_in_sticky(struct mnt_idmap *idmap,
                                struct nameidata *nd, struct inode *const inode)
 {
        umode_t dir_mode = nd->dir_mode;
-       vfsuid_t dir_vfsuid = nd->dir_vfsuid;
+       vfsuid_t dir_vfsuid = nd->dir_vfsuid, i_vfsuid;
+       int ret;
+
+       if (likely(!(dir_mode & S_ISVTX)))
+               return 0;
+
+       if (S_ISREG(inode->i_mode) && !sysctl_protected_regular)
+               return 0;
+
+       if (S_ISFIFO(inode->i_mode) && !sysctl_protected_fifos)
+               return 0;
+
+       i_vfsuid = i_uid_into_vfsuid(idmap, inode);
+
+       if (vfsuid_eq(i_vfsuid, dir_vfsuid))
+               return 0;
 
-       if (likely(!(dir_mode & S_ISVTX)) ||
-           (S_ISREG(inode->i_mode) && !sysctl_protected_regular) ||
-           (S_ISFIFO(inode->i_mode) && !sysctl_protected_fifos) ||
-           vfsuid_eq(i_uid_into_vfsuid(idmap, inode), dir_vfsuid) ||
-           vfsuid_eq_kuid(i_uid_into_vfsuid(idmap, inode), current_fsuid()))
+       if (vfsuid_eq_kuid(i_vfsuid, current_fsuid()))
                return 0;
 
-       if (likely(dir_mode & 0002) ||
-           (dir_mode & 0020 &&
-            ((sysctl_protected_fifos >= 2 && S_ISFIFO(inode->i_mode)) ||
-             (sysctl_protected_regular >= 2 && S_ISREG(inode->i_mode))))) {
-               const char *operation = S_ISFIFO(inode->i_mode) ?
-                                       "sticky_create_fifo" :
-                                       "sticky_create_regular";
-               audit_log_path_denied(AUDIT_ANOM_CREAT, operation);
+       if (likely(dir_mode & 0002)) {
+               audit_log_path_denied(AUDIT_ANOM_CREAT, "sticky_create");
                return -EACCES;
        }
+
+       if (dir_mode & 0020) {
+               if (sysctl_protected_fifos >= 2 && S_ISFIFO(inode->i_mode)) {
+                       audit_log_path_denied(AUDIT_ANOM_CREAT, "sticky_create_fifo");
+                       return -EACCES;

fs/namei.c static int may_create_in_sticky(struct mnt_idmap *idmap, · line 1285

Quoted 10 lines
fs/namei.c +8 -0
+               }
+
+               if (sysctl_protected_regular >= 2 && S_ISREG(inode->i_mode)) {
+                       audit_log_path_denied(AUDIT_ANOM_CREAT, "sticky_create_regular");
+                       return -EACCES;
+               }
+       }
+
        return 0;
 }

But this definitely looks nicer to read... Feel free to add:

Honza

Signature · 2 lines
Jan Kara <[email protected]>
SUSE Labs, CR