Remove znode's z_uid/z_gid member

Remove 2 variables from struct znode which are already present
in the embedded inode. No need to duplicate information.

include/sys/trace_acl.h

@@ -31,6 +31,7 @@
 #define	_TRACE_ACL_H
 
 #include <linux/tracepoint.h>
+#include <linux/vfs_compat.h>
 #include <sys/types.h>
 
 /*
@@ -57,15 +58,15 @@ DECLARE_EVENT_CLASS(zfs_ace_class,
 	    __field(uint64_t,		z_size)
 	    __field(uint64_t,		z_links)
 	    __field(uint64_t,		z_pflags)
-	    __field(uint64_t,		z_uid)
-	    __field(uint64_t,		z_gid)
 	    __field(uint32_t,		z_sync_cnt)
 	    __field(mode_t,		z_mode)
 	    __field(boolean_t,		z_is_sa)
 	    __field(boolean_t,		z_is_mapped)
 	    __field(boolean_t,		z_is_ctldir)
 	    __field(boolean_t,		z_is_stale)
 
+	    __field(uint16_t,		i_uid)
+	    __field(uint16_t,		i_gid)
 	    __field(unsigned long,	i_ino)
 	    __field(unsigned int,	i_nlink)
 	    __field(u64,		i_version)
@@ -93,15 +94,15 @@ DECLARE_EVENT_CLASS(zfs_ace_class,
 	    __entry->z_size		= zn->z_size;
 	    __entry->z_links		= zn->z_links;
 	    __entry->z_pflags		= zn->z_pflags;
-	    __entry->z_uid		= zn->z_uid;
-	    __entry->z_gid		= zn->z_gid;
 	    __entry->z_sync_cnt		= zn->z_sync_cnt;
 	    __entry->z_mode		= zn->z_mode;
 	    __entry->z_is_sa		= zn->z_is_sa;
 	    __entry->z_is_mapped	= zn->z_is_mapped;
 	    __entry->z_is_ctldir	= zn->z_is_ctldir;
 	    __entry->z_is_stale		= zn->z_is_stale;
 
+	    __entry->i_uid		= zfs_uid_read(ZTOI(zn));
+	    __entry->i_gid		= zfs_gid_read(ZTOI(zn));
 	    __entry->i_ino		= zn->z_inode.i_ino;
 	    __entry->i_nlink		= zn->z_inode.i_nlink;
 	    __entry->i_version		= zn->z_inode.i_version;
@@ -120,22 +121,22 @@ DECLARE_EVENT_CLASS(zfs_ace_class,
 	TP_printk("zn { id %llu unlinked %u atime_dirty %u "
 	    "zn_prefetch %u moved %u blksz %u seq %u "
 	    "mapcnt %llu size %llu links %llu pflags %llu "
-	    "uid %llu gid %llu sync_cnt %u mode 0x%x is_sa %d "
-	    "is_mapped %d is_ctldir %d is_stale %d inode { "
-	    "ino %lu nlink %u version %llu size %lli blkbits %u "
-	    "bytes %u mode 0x%x generation %x } } ace { type %u "
-	    "flags %u access_mask %u } mask_matched %u",
+	    "sync_cnt %u mode 0x%x is_sa %d "
+	    "is_mapped %d is_ctldir %d is_stale %d "
+	    "inode { uid %u gid %u ino %lu nlink %u version %llu size %lli "
+	    "blkbits %u bytes %u mode 0x%x generation %x } } "
+	    "ace { type %u flags %u access_mask %u } mask_matched %u",
 	    __entry->z_id, __entry->z_unlinked, __entry->z_atime_dirty,
 	    __entry->z_zn_prefetch, __entry->z_moved, __entry->z_blksz,
 	    __entry->z_seq, __entry->z_mapcnt, __entry->z_size,
-	    __entry->z_links, __entry->z_pflags, __entry->z_uid,
-	    __entry->z_gid, __entry->z_sync_cnt, __entry->z_mode,
-	    __entry->z_is_sa, __entry->z_is_mapped,
-	    __entry->z_is_ctldir, __entry->z_is_stale, __entry->i_ino,
-	    __entry->i_nlink, __entry->i_version, __entry->i_size,
-	    __entry->i_blkbits, __entry->i_bytes, __entry->i_mode,
-	    __entry->i_generation, __entry->z_type, __entry->z_flags,
-	    __entry->z_access_mask, __entry->mask_matched)
+	    __entry->z_links, __entry->z_pflags, __entry->z_sync_cnt,
+		__entry->z_mode, __entry->z_is_sa, __entry->z_is_mapped,
+		__entry->z_is_ctldir, __entry->z_is_stale, __entry->i_uid,
+		__entry->i_gid, __entry->i_ino, __entry->i_nlink,
+		__entry->i_version, __entry->i_size, __entry->i_blkbits,
+		__entry->i_bytes, __entry->i_mode, __entry->i_generation,
+		__entry->z_type, __entry->z_flags, __entry->z_access_mask,
+		__entry->mask_matched)
 );
 
 #define	DEFINE_ACE_EVENT(name) \

include/sys/zfs_znode.h

@@ -199,8 +199,6 @@ typedef struct znode {
 	uint64_t	z_size;		/* file size (cached) */
 	uint64_t	z_links;	/* file links (cached) */
 	uint64_t	z_pflags;	/* pflags (cached) */
-	uint64_t	z_uid;		/* uid fuid (cached) */
-	uint64_t	z_gid;		/* gid fuid (cached) */
 	uint32_t	z_sync_cnt;	/* synchronous open count */
 	mode_t		z_mode;		/* mode (cached) */
 	kmutex_t	z_acl_lock;	/* acl data lock */

module/zfs/zfs_acl.c

@@ -53,6 +53,7 @@
 #include <sys/zap.h>
 #include <sys/sa.h>
 #include <sys/trace_acl.h>
+#include <linux/vfs_compat.h>
 #include "fs/fs_subr.h"
 
 #define	ALLOW	ACE_ACCESS_ALLOWED_ACE_TYPE
@@ -1166,7 +1167,8 @@ zfs_acl_chown_setattr(znode_t *zp)
 	error = zfs_acl_node_read(zp, B_TRUE, &aclp, B_FALSE);
 	if (error == 0 && aclp->z_acl_count > 0)
 		zp->z_mode = zfs_mode_compute(zp->z_mode, aclp,
-		    &zp->z_pflags, zp->z_uid, zp->z_gid);
+		    &zp->z_pflags, zfs_uid_read(ZTOI(zp)),
+			zfs_gid_read(ZTOI(zp)));
 
 	/*
 	 * Some ZFS implementations (ZEVO) create neither a ZNODE_ACL
@@ -1324,7 +1326,7 @@ zfs_aclset_common(znode_t *zp, zfs_acl_t *aclp, cred_t *cr, dmu_tx_t *tx)
 	mode = zp->z_mode;
 
 	mode = zfs_mode_compute(mode, aclp, &zp->z_pflags,
-	    zp->z_uid, zp->z_gid);
+	    zfs_uid_read(ZTOI(zp)), zfs_gid_read(ZTOI(zp)));
 
 	zp->z_mode = mode;
 	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zsb), NULL,
@@ -2338,7 +2340,8 @@ zfs_has_access(znode_t *zp, cred_t *cr)
 	if (zfs_zaccess_aces_check(zp, &have, B_TRUE, cr) != 0) {
 		uid_t owner;
 
-		owner = zfs_fuid_map_id(ZTOZSB(zp), zp->z_uid, cr, ZFS_OWNER);
+		owner = zfs_fuid_map_id(ZTOZSB(zp), zfs_uid_read(ZTOI(zp)),
+					cr, ZFS_OWNER);
 		return (secpolicy_vnode_any_access(cr, ZTOI(zp), owner) == 0);
 	}
 	return (B_TRUE);
@@ -2416,12 +2419,13 @@ zfs_fastaccesschk_execute(znode_t *zdp, cred_t *cr)
 		return (0);
 	}
 
-	if (FUID_INDEX(zdp->z_uid) != 0 || FUID_INDEX(zdp->z_gid) != 0) {
+	if (zfs_uid_read(ZTOI(zdp)) != 0 ||
+		zfs_gid_read(ZTOI(zdp)) != 0) {
 		mutex_exit(&zdp->z_acl_lock);
 		goto slow;
 	}
 
-	if (uid == zdp->z_uid) {
+	if (uid == zfs_uid_read(ZTOI(zdp))) {
 		owner = B_TRUE;
 		if (zdp->z_mode & S_IXUSR) {
 			mutex_exit(&zdp->z_acl_lock);
@@ -2431,7 +2435,7 @@ zfs_fastaccesschk_execute(znode_t *zdp, cred_t *cr)
 			goto slow;
 		}
 	}
-	if (groupmember(zdp->z_gid, cr)) {
+	if (groupmember(zfs_gid_read(ZTOI(zdp)), cr)) {
 		groupmbr = B_TRUE;
 		if (zdp->z_mode & S_IXGRP) {
 			mutex_exit(&zdp->z_acl_lock);
@@ -2531,7 +2535,8 @@ zfs_zaccess(znode_t *zp, int mode, int flags, boolean_t skipaclchk, cred_t *cr)
 		}
 	}
 
-	owner = zfs_fuid_map_id(ZTOZSB(zp), zp->z_uid, cr, ZFS_OWNER);
+	owner = zfs_fuid_map_id(ZTOZSB(zp), zfs_uid_read(ZTOI(zp)),
+			cr, ZFS_OWNER);
 	/*
 	 * Map the bits required to the standard inode flags
 	 * S_IRUSR|S_IWUSR|S_IXUSR in the needed_bits.  Map the bits
@@ -2653,7 +2658,8 @@ zfs_delete_final_check(znode_t *zp, znode_t *dzp,
 	int error;
 	uid_t downer;
 
-	downer = zfs_fuid_map_id(ZTOZSB(dzp), dzp->z_uid, cr, ZFS_OWNER);
+	downer = zfs_fuid_map_id(ZTOZSB(dzp), zfs_uid_read(ZTOI(dzp)),
+			cr, ZFS_OWNER);
 
 	error = secpolicy_vnode_access2(cr, ZTOI(dzp),
 	    downer, available_perms, S_IWUSR|S_IXUSR);

module/zfs/zfs_ctldir.c

@@ -480,8 +480,6 @@ zfsctl_inode_alloc(zfs_sb_t *zsb, uint64_t id,
 	zp->z_size = 0;
 	zp->z_links = 0;
 	zp->z_pflags = 0;
-	zp->z_uid = 0;
-	zp->z_gid = 0;
 	zp->z_mode = 0;
 	zp->z_sync_cnt = 0;
 	zp->z_is_mapped = B_FALSE;

module/zfs/zfs_dir.c

@@ -1088,8 +1088,8 @@ zfs_sticky_remove_access(znode_t *zdp, znode_t *zp, cred_t *cr)
 	if ((zdp->z_mode & S_ISVTX) == 0)
 		return (0);
 
-	downer = zfs_fuid_map_id(zsb, zdp->z_uid, cr, ZFS_OWNER);
-	fowner = zfs_fuid_map_id(zsb, zp->z_uid, cr, ZFS_OWNER);
+	downer = zfs_fuid_map_id(zsb, zfs_uid_read(ZTOI(zdp)), cr, ZFS_OWNER);
+	fowner = zfs_fuid_map_id(zsb, zfs_uid_read(ZTOI(zp)), cr, ZFS_OWNER);
 
 	if ((uid = crgetuid(cr)) == downer || uid == fowner ||
 	    (S_ISDIR(ZTOI(zp)->i_mode) &&

module/zfs/zfs_fuid.c

@@ -33,6 +33,7 @@
 #include <sys/sid.h>
 #include <sys/zfs_vfsops.h>
 #include <sys/zfs_znode.h>
+#include <linux/vfs_compat.h>
 #endif
 #include <sys/zfs_fuid.h>
 
@@ -387,8 +388,10 @@ zfs_fuid_find_by_idx(zfs_sb_t *zsb, uint32_t idx)
 void
 zfs_fuid_map_ids(znode_t *zp, cred_t *cr, uid_t *uidp, uid_t *gidp)
 {
-	*uidp = zfs_fuid_map_id(ZTOZSB(zp), zp->z_uid, cr, ZFS_OWNER);
-	*gidp = zfs_fuid_map_id(ZTOZSB(zp), zp->z_gid, cr, ZFS_GROUP);
+	*uidp = zfs_fuid_map_id(ZTOZSB(zp), zfs_uid_read(ZTOI(zp)),
+			cr, ZFS_OWNER);
+	*gidp = zfs_fuid_map_id(ZTOZSB(zp), zfs_gid_read(ZTOI(zp)),
+			cr, ZFS_GROUP);
 }
 
 uid_t

module/zfs/zfs_log.c

@@ -46,6 +46,7 @@
 #include <sys/zfs_fuid.h>
 #include <sys/ddi.h>
 #include <sys/dsl_dataset.h>
+#include <linux/vfs_compat.h>
 
 /*
  * These zfs_log_* functions must be called within a dmu tx, in one
@@ -280,13 +281,13 @@ zfs_log_create(zilog_t *zilog, dmu_tx_t *tx, uint64_t txtype,
 	lr->lr_doid = dzp->z_id;
 	lr->lr_foid = zp->z_id;
 	lr->lr_mode = zp->z_mode;
-	if (!IS_EPHEMERAL(zp->z_uid)) {
-		lr->lr_uid = (uint64_t)zp->z_uid;
+	if (!IS_EPHEMERAL(zfs_uid_read(ZTOI(zp)))) {
+		lr->lr_uid = (uint64_t)zfs_uid_read(ZTOI(zp));
 	} else {
 		lr->lr_uid = fuidp->z_fuid_owner;
 	}
-	if (!IS_EPHEMERAL(zp->z_gid)) {
-		lr->lr_gid = (uint64_t)zp->z_gid;
+	if (!IS_EPHEMERAL(zfs_gid_read(ZTOI(zp)))) {
+		lr->lr_gid = (uint64_t)zfs_gid_read(ZTOI(zp));
 	} else {
 		lr->lr_gid = fuidp->z_fuid_group;
 	}
@@ -405,8 +406,8 @@ zfs_log_symlink(zilog_t *zilog, dmu_tx_t *tx, uint64_t txtype,
 	lr = (lr_create_t *)&itx->itx_lr;
 	lr->lr_doid = dzp->z_id;
 	lr->lr_foid = zp->z_id;
-	lr->lr_uid = zp->z_uid;
-	lr->lr_gid = zp->z_gid;
+	lr->lr_uid = zfs_uid_read(ZTOI(zp));
+	lr->lr_gid = zfs_gid_read(ZTOI(zp));
 	lr->lr_mode = zp->z_mode;
 	(void) sa_lookup(zp->z_sa_hdl, SA_ZPL_GEN(ZTOZSB(zp)), &lr->lr_gen,
 	    sizeof (uint64_t));

module/zfs/zfs_vfsops.c

@@ -627,10 +627,11 @@ zfs_owner_overquota(zfs_sb_t *zsb, znode_t *zp, boolean_t isgroup)
 {
 	uint64_t fuid;
 	uint64_t quotaobj;
+	struct inode *ip = ZTOI(zp);
 
 	quotaobj = isgroup ? zsb->z_groupquota_obj : zsb->z_userquota_obj;
 
-	fuid = isgroup ? zp->z_gid : zp->z_uid;
+	fuid = isgroup ? zfs_gid_read(ip) : zfs_uid_read(ip);
 
 	if (quotaobj == 0 || zsb->z_replay)
 		return (B_FALSE);

module/zfs/zfs_vnops.c

@@ -602,6 +602,7 @@ zfs_write(struct inode *ip, uio_t *uio, int ioflag, cred_t *cr)
 	int		count = 0;
 	sa_bulk_attr_t	bulk[4];
 	uint64_t	mtime[2], ctime[2];
+	boolean_t retain_policy;
 	ASSERTV(int	iovcnt = uio->uio_iovcnt);
 
 	/*
@@ -862,11 +863,12 @@ zfs_write(struct inode *ip, uio_t *uio, int ioflag, cred_t *cr)
 		 * user 0 is not an ephemeral uid.
 		 */
 		mutex_enter(&zp->z_acl_lock);
+		retain_policy = ((zp->z_mode & S_ISUID) != 0 &&
+							zfs_uid_read(ip) == 0);
 		if ((zp->z_mode & (S_IXUSR | (S_IXUSR >> 3) |
 		    (S_IXUSR >> 6))) != 0 &&
 		    (zp->z_mode & (S_ISUID | S_ISGID)) != 0 &&
-		    secpolicy_vnode_setid_retain(cr,
-		    (zp->z_mode & S_ISUID) != 0 && zp->z_uid == 0) != 0) {
+		    secpolicy_vnode_setid_retain(cr, retain_policy) != 0) {
 			uint64_t newmode;
 			zp->z_mode &= ~(S_ISUID | S_ISGID);
 			newmode = zp->z_mode;
@@ -2842,7 +2844,7 @@ zfs_setattr(struct inode *ip, vattr_t *vap, int flags, cred_t *cr)
 		if (mask & ATTR_UID) {
 			new_uid = zfs_fuid_create(zsb,
 			    (uint64_t)vap->va_uid, cr, ZFS_OWNER, &fuidp);
-			if (new_uid != zp->z_uid &&
+			if (new_uid != zfs_uid_read(ZTOI(zp)) &&
 			    zfs_fuid_overquota(zsb, B_FALSE, new_uid)) {
 				if (attrzp)
 					iput(ZTOI(attrzp));
@@ -2854,7 +2856,7 @@ zfs_setattr(struct inode *ip, vattr_t *vap, int flags, cred_t *cr)
 		if (mask & ATTR_GID) {
 			new_gid = zfs_fuid_create(zsb, (uint64_t)vap->va_gid,
 			    cr, ZFS_GROUP, &fuidp);
-			if (new_gid != zp->z_gid &&
+			if (new_gid != zfs_gid_read(ZTOI(zp)) &&
 			    zfs_fuid_overquota(zsb, B_TRUE, new_gid)) {
 				if (attrzp)
 					iput(ZTOI(attrzp));
@@ -2948,24 +2950,24 @@ zfs_setattr(struct inode *ip, vattr_t *vap, int flags, cred_t *cr)
 		if (mask & ATTR_UID) {
 			SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_UID(zsb), NULL,
 			    &new_uid, sizeof (new_uid));
-			zp->z_uid = new_uid;
+			zfs_uid_write(ZTOI(zp), new_uid);
 			if (attrzp) {
 				SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
 				    SA_ZPL_UID(zsb), NULL, &new_uid,
 				    sizeof (new_uid));
-				attrzp->z_uid = new_uid;
+				zfs_uid_write(ZTOI(attrzp), new_uid);
 			}
 		}
 
 		if (mask & ATTR_GID) {
 			SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GID(zsb),
 			    NULL, &new_gid, sizeof (new_gid));
-			zp->z_gid = new_gid;
+			zfs_gid_write(ZTOI(zp), new_gid);
 			if (attrzp) {
 				SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
 				    SA_ZPL_GID(zsb), NULL, &new_gid,
 				    sizeof (new_gid));
-				attrzp->z_gid = new_gid;
+				zfs_gid_write(ZTOI(attrzp), new_gid);
 			}
 		}
 		if (!(mask & ATTR_MODE)) {
@@ -3845,7 +3847,7 @@ zfs_link(struct inode *tdip, struct inode *sip, char *name, cred_t *cr,
 		return (SET_ERROR(EINVAL));
 	}
 
-	owner = zfs_fuid_map_id(zsb, szp->z_uid, cr, ZFS_OWNER);
+	owner = zfs_fuid_map_id(zsb, zfs_uid_read(sip), cr, ZFS_OWNER);
 	if (owner != crgetuid(cr) && secpolicy_basic_link(cr) != 0) {
 		ZFS_EXIT(zsb);
 		return (SET_ERROR(EPERM));