bcachefs: rename bch_inode fields

8 files changed, 146 insertions, 147 deletions

diff --git a/fs/bcachefs/bcachefs_format.h b/fs/bcachefs/bcachefs_format.h
index 547a4e0bc8f0..16a1edd1895c 100644
--- a/fs/bcachefs/bcachefs_format.h
+++ b/fs/bcachefs/bcachefs_format.h
@@ -576,9 +576,9 @@ enum bch_inode_types {
 struct bch_inode {
 	struct bch_val		v;
 
-	__le64			i_hash_seed;
-	__le32			i_flags;
-	__le16			i_mode;
+	__le64			bi_hash_seed;
+	__le32			bi_flags;
+	__le16			bi_mode;
 	__u8			fields[0];
 } __attribute__((packed, aligned(8)));
 BKEY_VAL_TYPE(inode,		BCH_INODE_FS);
@@ -586,24 +586,23 @@ BKEY_VAL_TYPE(inode,		BCH_INODE_FS);
 struct bch_inode_generation {
 	struct bch_val		v;
 
-	__le32			i_generation;
+	__le32			bi_generation;
 	__le32			pad;
 } __attribute__((packed, aligned(8)));
 BKEY_VAL_TYPE(inode_generation,	BCH_INODE_GENERATION);
 
-
 #define BCH_INODE_FIELDS()				\
-	BCH_INODE_FIELD(i_atime,	64)		\
-	BCH_INODE_FIELD(i_ctime,	64)		\
-	BCH_INODE_FIELD(i_mtime,	64)		\
-	BCH_INODE_FIELD(i_otime,	64)		\
-	BCH_INODE_FIELD(i_size,		64)		\
-	BCH_INODE_FIELD(i_sectors,	64)		\
-	BCH_INODE_FIELD(i_uid,		32)		\
-	BCH_INODE_FIELD(i_gid,		32)		\
-	BCH_INODE_FIELD(i_nlink,	32)		\
-	BCH_INODE_FIELD(i_generation,	32)		\
-	BCH_INODE_FIELD(i_dev,		32)
+	BCH_INODE_FIELD(bi_atime,	64)		\
+	BCH_INODE_FIELD(bi_ctime,	64)		\
+	BCH_INODE_FIELD(bi_mtime,	64)		\
+	BCH_INODE_FIELD(bi_otime,	64)		\
+	BCH_INODE_FIELD(bi_size,	64)		\
+	BCH_INODE_FIELD(bi_sectors,	64)		\
+	BCH_INODE_FIELD(bi_uid,		32)		\
+	BCH_INODE_FIELD(bi_gid,		32)		\
+	BCH_INODE_FIELD(bi_nlink,	32)		\
+	BCH_INODE_FIELD(bi_generation,	32)		\
+	BCH_INODE_FIELD(bi_dev,		32)
 
 enum {
 	/*
@@ -634,8 +633,8 @@ enum {
 #define BCH_INODE_I_SECTORS_DIRTY (1 << __BCH_INODE_I_SECTORS_DIRTY)
 #define BCH_INODE_HAS_XATTRS	(1 << __BCH_INODE_HAS_XATTRS)
 
-LE32_BITMASK(INODE_STR_HASH,	struct bch_inode, i_flags, 20, 24);
-LE32_BITMASK(INODE_NR_FIELDS,	struct bch_inode, i_flags, 24, 32);
+LE32_BITMASK(INODE_STR_HASH,	struct bch_inode, bi_flags, 20, 24);
+LE32_BITMASK(INODE_NR_FIELDS,	struct bch_inode, bi_flags, 24, 32);
 
 struct bch_inode_blockdev {
 	struct bch_val		v;
diff --git a/fs/bcachefs/fs-io.c b/fs/bcachefs/fs-io.c
index 47d0f9a662ed..ee545bae0fea 100644
--- a/fs/bcachefs/fs-io.c
+++ b/fs/bcachefs/fs-io.c
@@ -70,12 +70,12 @@ static int inode_set_size(struct bch_inode_info *ei,
 
 	lockdep_assert_held(&ei->update_lock);
 
-	bi->i_size = *new_i_size;
+	bi->bi_size = *new_i_size;
 
 	if (atomic_long_read(&ei->i_size_dirty_count))
-		bi->i_flags |= BCH_INODE_I_SIZE_DIRTY;
+		bi->bi_flags |= BCH_INODE_I_SIZE_DIRTY;
 	else
-		bi->i_flags &= ~BCH_INODE_I_SIZE_DIRTY;
+		bi->bi_flags &= ~BCH_INODE_I_SIZE_DIRTY;
 
 	return 0;
 }
@@ -125,9 +125,9 @@ i_sectors_hook_fn(struct extent_insert_hook *hook,
 static int inode_set_i_sectors_dirty(struct bch_inode_info *ei,
 				    struct bch_inode_unpacked *bi, void *p)
 {
-	BUG_ON(bi->i_flags & BCH_INODE_I_SECTORS_DIRTY);
+	BUG_ON(bi->bi_flags & BCH_INODE_I_SECTORS_DIRTY);
 
-	bi->i_flags |= BCH_INODE_I_SECTORS_DIRTY;
+	bi->bi_flags |= BCH_INODE_I_SECTORS_DIRTY;
 	return 0;
 }
 
@@ -135,10 +135,10 @@ static int inode_clear_i_sectors_dirty(struct bch_inode_info *ei,
 				       struct bch_inode_unpacked *bi,
 				       void *p)
 {
-	BUG_ON(!(bi->i_flags & BCH_INODE_I_SECTORS_DIRTY));
+	BUG_ON(!(bi->bi_flags & BCH_INODE_I_SECTORS_DIRTY));
 
-	bi->i_sectors	= atomic64_read(&ei->i_sectors);
-	bi->i_flags	&= ~BCH_INODE_I_SECTORS_DIRTY;
+	bi->bi_sectors	= atomic64_read(&ei->i_sectors);
+	bi->bi_flags	&= ~BCH_INODE_I_SECTORS_DIRTY;
 	return 0;
 }
 
@@ -238,7 +238,7 @@ bchfs_extent_update_hook(struct extent_insert_hook *hook,
 			return BTREE_HOOK_RESTART_TRANS;
 		}
 
-		h->inode_u.i_size = offset;
+		h->inode_u.bi_size = offset;
 		do_pack = true;
 
 		ei->i_size = offset;
@@ -253,7 +253,7 @@ bchfs_extent_update_hook(struct extent_insert_hook *hook,
 			return BTREE_HOOK_RESTART_TRANS;
 		}
 
-		h->inode_u.i_sectors += sectors;
+		h->inode_u.bi_sectors += sectors;
 		do_pack = true;
 
 		atomic64_add(sectors, &ei->i_sectors);
diff --git a/fs/bcachefs/fs.c b/fs/bcachefs/fs.c
index 6a62ec86b262..6a13489dd9cb 100644
--- a/fs/bcachefs/fs.c
+++ b/fs/bcachefs/fs.c
@@ -114,14 +114,14 @@ int __must_check __bch2_write_inode(struct bch_fs *c,
 
 		BUG_ON(i_nlink < nlink_bias(inode->i_mode));
 
-		inode_u.i_mode	= inode->i_mode;
-		inode_u.i_uid	= i_uid_read(inode);
-		inode_u.i_gid	= i_gid_read(inode);
-		inode_u.i_nlink	= i_nlink - nlink_bias(inode->i_mode);
-		inode_u.i_dev	= inode->i_rdev;
-		inode_u.i_atime	= timespec_to_bch2_time(c, inode->i_atime);
-		inode_u.i_mtime	= timespec_to_bch2_time(c, inode->i_mtime);
-		inode_u.i_ctime	= timespec_to_bch2_time(c, inode->i_ctime);
+		inode_u.bi_mode	= inode->i_mode;
+		inode_u.bi_uid	= i_uid_read(inode);
+		inode_u.bi_gid	= i_gid_read(inode);
+		inode_u.bi_nlink= i_nlink - nlink_bias(inode->i_mode);
+		inode_u.bi_dev	= inode->i_rdev;
+		inode_u.bi_atime= timespec_to_bch2_time(c, inode->i_atime);
+		inode_u.bi_mtime= timespec_to_bch2_time(c, inode->i_mtime);
+		inode_u.bi_ctime= timespec_to_bch2_time(c, inode->i_ctime);
 
 		bch2_inode_pack(&inode_p, &inode_u);
 
@@ -132,8 +132,8 @@ int __must_check __bch2_write_inode(struct bch_fs *c,
 	} while (ret == -EINTR);
 
 	if (!ret) {
-		ei->i_size	= inode_u.i_size;
-		ei->i_flags	= inode_u.i_flags;
+		ei->i_size	= inode_u.bi_size;
+		ei->i_flags	= inode_u.bi_flags;
 	}
 out:
 	bch2_btree_iter_unlock(&iter);
@@ -803,7 +803,7 @@ static int bch2_inode_user_flags_set(struct bch_inode_info *ei,
 	 * We're relying on btree locking here for exclusion with other ioctl
 	 * calls - use the flags in the btree (@bi), not ei->i_flags:
 	 */
-	unsigned bch_flags = bi->i_flags;
+	unsigned bch_flags = bi->bi_flags;
 	unsigned oldflags = bch2_inode_flags_to_user_flags(bch_flags);
 	unsigned newflags = *((unsigned *) p);
 	unsigned i;
@@ -825,7 +825,7 @@ static int bch2_inode_user_flags_set(struct bch_inode_info *ei,
 	if (oldflags != newflags)
 		return -EOPNOTSUPP;
 
-	bi->i_flags = bch_flags;
+	bi->bi_flags = bch_flags;
 	ei->vfs_inode.i_ctime = current_time(&ei->vfs_inode);
 
 	return 0;
@@ -1077,26 +1077,26 @@ static void bch2_vfs_inode_init(struct bch_fs *c,
 	struct inode *inode = &ei->vfs_inode;
 
 	pr_debug("init inode %llu with mode %o",
-		 bi->inum, bi->i_mode);
-
-	ei->i_flags	= bi->i_flags;
-	ei->i_size	= bi->i_size;
-
-	inode->i_mode	= bi->i_mode;
-	i_uid_write(inode, bi->i_uid);
-	i_gid_write(inode, bi->i_gid);
-
-	atomic64_set(&ei->i_sectors, bi->i_sectors);
-	inode->i_blocks = bi->i_sectors;
-
-	inode->i_ino	= bi->inum;
-	set_nlink(inode, bi->i_nlink + nlink_bias(inode->i_mode));
-	inode->i_rdev	= bi->i_dev;
-	inode->i_generation = bi->i_generation;
-	inode->i_size	= bi->i_size;
-	inode->i_atime	= bch2_time_to_timespec(c, bi->i_atime);
-	inode->i_mtime	= bch2_time_to_timespec(c, bi->i_mtime);
-	inode->i_ctime	= bch2_time_to_timespec(c, bi->i_ctime);
+		 bi->bi_inum, bi->bi_mode);
+
+	ei->i_flags	= bi->bi_flags;
+	ei->i_size	= bi->bi_size;
+
+	inode->i_mode	= bi->bi_mode;
+	i_uid_write(inode, bi->bi_uid);
+	i_gid_write(inode, bi->bi_gid);
+
+	atomic64_set(&ei->i_sectors, bi->bi_sectors);
+	inode->i_blocks = bi->bi_sectors;
+
+	inode->i_ino	= bi->bi_inum;
+	set_nlink(inode, bi->bi_nlink + nlink_bias(inode->i_mode));
+	inode->i_rdev	= bi->bi_dev;
+	inode->i_generation = bi->bi_generation;
+	inode->i_size	= bi->bi_size;
+	inode->i_atime	= bch2_time_to_timespec(c, bi->bi_atime);
+	inode->i_mtime	= bch2_time_to_timespec(c, bi->bi_mtime);
+	inode->i_ctime	= bch2_time_to_timespec(c, bi->bi_ctime);
 	bch2_inode_flags_to_vfs(inode);
 
 	ei->str_hash = bch2_hash_info_init(c, bi);
diff --git a/fs/bcachefs/fsck.c b/fs/bcachefs/fsck.c
index df3e2fb6f284..5e870bf0c4e2 100644
--- a/fs/bcachefs/fsck.c
+++ b/fs/bcachefs/fsck.c
@@ -67,7 +67,7 @@ static int reattach_inode(struct bch_fs *c,
 	snprintf(name_buf, sizeof(name_buf), "%llu", inum);
 	name = (struct qstr) QSTR(name_buf);
 
-	lostfound_inode->i_nlink++;
+	lostfound_inode->bi_nlink++;
 
 	bch2_inode_pack(&packed, lostfound_inode);
 
@@ -80,7 +80,7 @@ static int reattach_inode(struct bch_fs *c,
 		return ret;
 	}
 
-	ret = bch2_dirent_create(c, lostfound_inode->inum,
+	ret = bch2_dirent_create(c, lostfound_inode->bi_inum,
 				 &lostfound_hash_info,
 				 DT_DIR, &name, inum, NULL,
 				 BTREE_INSERT_NOFAIL);
@@ -263,9 +263,9 @@ static int check_extents(struct bch_fs *c)
 			"extent type %u for missing inode %llu",
 			k.k->type, k.k->p.inode) ||
 		    fsck_err_on(w.have_inode &&
-			!S_ISREG(w.inode.i_mode) && !S_ISLNK(w.inode.i_mode), c,
+			!S_ISREG(w.inode.bi_mode) && !S_ISLNK(w.inode.bi_mode), c,
 			"extent type %u for non regular file, inode %llu mode %o",
-			k.k->type, k.k->p.inode, w.inode.i_mode)) {
+			k.k->type, k.k->p.inode, w.inode.bi_mode)) {
 			ret = bch2_btree_delete_at(&iter, 0);
 			if (ret)
 				goto err;
@@ -274,18 +274,18 @@ static int check_extents(struct bch_fs *c)
 
 		unfixable_fsck_err_on(w.first_this_inode &&
 			w.have_inode &&
-			!(w.inode.i_flags & BCH_INODE_I_SECTORS_DIRTY) &&
-			w.inode.i_sectors !=
+			!(w.inode.bi_flags & BCH_INODE_I_SECTORS_DIRTY) &&
+			w.inode.bi_sectors !=
 			(i_sectors = bch2_count_inode_sectors(c, w.cur_inum)),
 			c, "i_sectors wrong: got %llu, should be %llu",
-			w.inode.i_sectors, i_sectors);
+			w.inode.bi_sectors, i_sectors);
 
 		unfixable_fsck_err_on(w.have_inode &&
-			!(w.inode.i_flags & BCH_INODE_I_SIZE_DIRTY) &&
+			!(w.inode.bi_flags & BCH_INODE_I_SIZE_DIRTY) &&
 			k.k->type != BCH_RESERVATION &&
-			k.k->p.offset > round_up(w.inode.i_size, PAGE_SIZE) >> 9, c,
+			k.k->p.offset > round_up(w.inode.bi_size, PAGE_SIZE) >> 9, c,
 			"extent type %u offset %llu past end of inode %llu, i_size %llu",
-			k.k->type, k.k->p.offset, k.k->p.inode, w.inode.i_size);
+			k.k->type, k.k->p.offset, k.k->p.inode, w.inode.bi_size);
 	}
 err:
 fsck_err:
@@ -324,9 +324,9 @@ static int check_dirents(struct bch_fs *c)
 				"dirent in nonexisting directory:\n%s",
 				bch2_bkey_val_to_text(c, BTREE_ID_DIRENTS,
 						      buf, sizeof(buf), k)) ||
-		    fsck_err_on(!S_ISDIR(w.inode.i_mode), c,
+		    fsck_err_on(!S_ISDIR(w.inode.bi_mode), c,
 				"dirent in non directory inode type %u:\n%s",
-				mode_to_type(w.inode.i_mode),
+				mode_to_type(w.inode.bi_mode),
 				bch2_bkey_val_to_text(c, BTREE_ID_DIRENTS,
 						      buf, sizeof(buf), k))) {
 			ret = bch2_btree_delete_at(&iter, 0);
@@ -397,9 +397,9 @@ static int check_dirents(struct bch_fs *c)
 
 		if (fsck_err_on(have_target &&
 				d.v->d_type !=
-				mode_to_type(le16_to_cpu(target.i_mode)), c,
+				mode_to_type(le16_to_cpu(target.bi_mode)), c,
 				"incorrect d_type: should be %u:\n%s",
-				mode_to_type(le16_to_cpu(target.i_mode)),
+				mode_to_type(le16_to_cpu(target.bi_mode)),
 				bch2_bkey_val_to_text(c, BTREE_ID_DIRENTS,
 						      buf, sizeof(buf), k))) {
 			struct bkey_i_dirent *n;
@@ -411,7 +411,7 @@ static int check_dirents(struct bch_fs *c)
 			}
 
 			bkey_reassemble(&n->k_i, d.s_c);
-			n->v.d_type = mode_to_type(le16_to_cpu(target.i_mode));
+			n->v.d_type = mode_to_type(le16_to_cpu(target.bi_mode));
 
 			ret = bch2_btree_insert_at(c, NULL, NULL, NULL,
 					BTREE_INSERT_NOFAIL,
@@ -485,7 +485,7 @@ static int check_root(struct bch_fs *c, struct bch_inode_unpacked *root_inode)
 	if (fsck_err_on(ret, c, "root directory missing"))
 		goto create_root;
 
-	if (fsck_err_on(!S_ISDIR(root_inode->i_mode), c,
+	if (fsck_err_on(!S_ISDIR(root_inode->bi_mode), c,
 			"root inode not a directory"))
 		goto create_root;
 
@@ -494,7 +494,7 @@ fsck_err:
 	return ret;
 create_root:
 	bch2_inode_init(c, root_inode, 0, 0, S_IFDIR|S_IRWXU|S_IRUGO|S_IXUGO, 0);
-	root_inode->inum = BCACHEFS_ROOT_INO;
+	root_inode->bi_inum = BCACHEFS_ROOT_INO;
 
 	bch2_inode_pack(&packed, root_inode);
 
@@ -528,7 +528,7 @@ static int check_lostfound(struct bch_fs *c,
 	if (fsck_err_on(ret, c, "lost+found missing"))
 		goto create_lostfound;
 
-	if (fsck_err_on(!S_ISDIR(lostfound_inode->i_mode), c,
+	if (fsck_err_on(!S_ISDIR(lostfound_inode->bi_mode), c,
 			"lost+found inode not a directory"))
 		goto create_lostfound;
 
@@ -536,7 +536,7 @@ static int check_lostfound(struct bch_fs *c,
 fsck_err:
 	return ret;
 create_lostfound:
-	root_inode->i_nlink++;
+	root_inode->bi_nlink++;
 
 	bch2_inode_pack(&packed, root_inode);
 
@@ -553,7 +553,7 @@ create_lostfound:
 		return ret;
 
 	ret = bch2_dirent_create(c, BCACHEFS_ROOT_INO, &root_hash_info, DT_DIR,
-				 &lostfound, lostfound_inode->inum, NULL,
+				 &lostfound, lostfound_inode->bi_inum, NULL,
 				 BTREE_INSERT_NOFAIL);
 	if (ret)
 		return ret;
@@ -711,7 +711,7 @@ up:
 
 	for_each_btree_key(&iter, c, BTREE_ID_INODES, POS_MIN, 0, k) {
 		if (k.k->type != BCH_INODE_FS ||
-		    !S_ISDIR(le16_to_cpu(bkey_s_c_to_inode(k).v->i_mode)))
+		    !S_ISDIR(le16_to_cpu(bkey_s_c_to_inode(k).v->bi_mode)))
 			continue;
 
 		if (fsck_err_on(!inode_bitmap_test(&dirs_done, k.k->p.inode), c,
@@ -849,15 +849,15 @@ static int bch2_gc_do_inode(struct bch_fs *c,
 			 inode.k->p.inode))
 		return ret;
 
-	i_nlink = u.i_nlink + nlink_bias(u.i_mode);
+	i_nlink = u.bi_nlink + nlink_bias(u.bi_mode);
 
 	fsck_err_on(i_nlink < link.count, c,
 		    "inode %llu i_link too small (%u < %u, type %i)",
 		    inode.k->p.inode, i_nlink,
-		    link.count, mode_to_type(u.i_mode));
+		    link.count, mode_to_type(u.bi_mode));
 
 	/* These should have been caught/fixed by earlier passes: */
-	if (S_ISDIR(u.i_mode)) {
+	if (S_ISDIR(u.bi_mode)) {
 		need_fsck_err_on(link.count > 1, c,
 			"directory %llu with multiple hardlinks: %u",
 			inode.k->p.inode, link.count);
@@ -877,7 +877,7 @@ static int bch2_gc_do_inode(struct bch_fs *c,
 			    "but found orphaned inode %llu",
 			    inode.k->p.inode);
 
-		if (fsck_err_on(S_ISDIR(u.i_mode) &&
+		if (fsck_err_on(S_ISDIR(u.bi_mode) &&
 				bch2_empty_dir(c, inode.k->p.inode), c,
 				"non empty directory with link count 0, "
 				"inode nlink %u, dir links found %u",
@@ -897,7 +897,7 @@ static int bch2_gc_do_inode(struct bch_fs *c,
 		return ret;
 	}
 
-	if (u.i_flags & BCH_INODE_I_SIZE_DIRTY) {
+	if (u.bi_flags & BCH_INODE_I_SIZE_DIRTY) {
 		fsck_err_on(c->sb.clean, c,
 			    "filesystem marked clean, "
 			    "but inode %llu has i_size dirty",
@@ -911,7 +911,7 @@ static int bch2_gc_do_inode(struct bch_fs *c,
 		 */
 
 		ret = bch2_inode_truncate(c, inode.k->p.inode,
-				round_up(u.i_size, PAGE_SIZE) >> 9,
+				round_up(u.bi_size, PAGE_SIZE) >> 9,
 				NULL, NULL);
 		if (ret) {
 			bch_err(c, "error in fs gc: error %i "
@@ -923,13 +923,13 @@ static int bch2_gc_do_inode(struct bch_fs *c,
 		 * We truncated without our normal sector accounting hook, just
 		 * make sure we recalculate it:
 		 */
-		u.i_flags |= BCH_INODE_I_SECTORS_DIRTY;
+		u.bi_flags |= BCH_INODE_I_SECTORS_DIRTY;
 
-		u.i_flags &= ~BCH_INODE_I_SIZE_DIRTY;
+		u.bi_flags &= ~BCH_INODE_I_SIZE_DIRTY;
 		do_update = true;
 	}
 
-	if (u.i_flags & BCH_INODE_I_SECTORS_DIRTY) {
+	if (u.bi_flags & BCH_INODE_I_SECTORS_DIRTY) {
 		s64 sectors;
 
 		fsck_err_on(c->sb.clean, c,
@@ -948,8 +948,8 @@ static int bch2_gc_do_inode(struct bch_fs *c,
 			return sectors;
 		}
 
-		u.i_sectors = sectors;
-		u.i_flags &= ~BCH_INODE_I_SECTORS_DIRTY;
+		u.bi_sectors = sectors;
+		u.bi_flags &= ~BCH_INODE_I_SECTORS_DIRTY;
 		do_update = true;
 	}
 
@@ -958,12 +958,12 @@ static int bch2_gc_do_inode(struct bch_fs *c,
 			    "filesystem marked clean, "
 			    "but inode %llu has wrong i_nlink "
 			    "(type %u i_nlink %u, should be %u)",
-			    inode.k->p.inode, mode_to_type(u.i_mode),
+			    inode.k->p.inode, mode_to_type(u.bi_mode),
 			    i_nlink, real_i_nlink);
 
 		bch_verbose(c, "setting inode %llu nlinks from %u to %u",
 			    inode.k->p.inode, i_nlink, real_i_nlink);
-		u.i_nlink = real_i_nlink - nlink_bias(u.i_mode);;
+		u.bi_nlink = real_i_nlink - nlink_bias(u.bi_mode);
 		do_update = true;
 	}
 
diff --git a/fs/bcachefs/inode.c b/fs/bcachefs/inode.c
index 2957de800b7c..aaf8d13dbb96 100644
--- a/fs/bcachefs/inode.c
+++ b/fs/bcachefs/inode.c
@@ -92,10 +92,10 @@ void bch2_inode_pack(struct bkey_inode_buf *packed,
 	unsigned nr_fields = 0, last_nonzero_fieldnr = 0;
 
 	bkey_inode_init(&packed->inode.k_i);
-	packed->inode.k.p.inode		= inode->inum;
-	packed->inode.v.i_hash_seed	= inode->i_hash_seed;
-	packed->inode.v.i_flags		= cpu_to_le32(inode->i_flags);
-	packed->inode.v.i_mode		= cpu_to_le16(inode->i_mode);
+	packed->inode.k.p.inode		= inode->bi_inum;
+	packed->inode.v.bi_hash_seed	= inode->bi_hash_seed;
+	packed->inode.v.bi_flags	= cpu_to_le32(inode->bi_flags);
+	packed->inode.v.bi_mode		= cpu_to_le16(inode->bi_mode);
 
 #define BCH_INODE_FIELD(_name, _bits)					\
 	out += inode_encode_field(out, end, 0, inode->_name);		\
@@ -125,9 +125,9 @@ void bch2_inode_pack(struct bkey_inode_buf *packed,
 		int ret = bch2_inode_unpack(inode_i_to_s_c(&packed->inode),
 					   &unpacked);
 		BUG_ON(ret);
-		BUG_ON(unpacked.inum		!= inode->inum);
-		BUG_ON(unpacked.i_hash_seed	!= inode->i_hash_seed);
-		BUG_ON(unpacked.i_mode		!= inode->i_mode);
+		BUG_ON(unpacked.bi_inum		!= inode->bi_inum);
+		BUG_ON(unpacked.bi_hash_seed	!= inode->bi_hash_seed);
+		BUG_ON(unpacked.bi_mode		!= inode->bi_mode);
 
 #define BCH_INODE_FIELD(_name, _bits)	BUG_ON(unpacked._name != inode->_name);
 		BCH_INODE_FIELDS()
@@ -144,10 +144,10 @@ int bch2_inode_unpack(struct bkey_s_c_inode inode,
 	unsigned fieldnr = 0, field_bits;
 	int ret;
 
-	unpacked->inum		= inode.k->p.inode;
-	unpacked->i_hash_seed	= inode.v->i_hash_seed;
-	unpacked->i_flags	= le32_to_cpu(inode.v->i_flags);
-	unpacked->i_mode	= le16_to_cpu(inode.v->i_mode);
+	unpacked->bi_inum	= inode.k->p.inode;
+	unpacked->bi_hash_seed	= inode.v->bi_hash_seed;
+	unpacked->bi_flags	= le32_to_cpu(inode.v->bi_flags);
+	unpacked->bi_mode	= le16_to_cpu(inode.v->bi_mode);
 
 #define BCH_INODE_FIELD(_name, _bits)					\
 	if (fieldnr++ == INODE_NR_FIELDS(inode.v)) {			\
@@ -232,7 +232,7 @@ static void bch2_inode_to_text(struct bch_fs *c, char *buf,
 			break;
 		}
 
-		scnprintf(buf, size, "i_size %llu", unpacked.i_size);
+		scnprintf(buf, size, "i_size %llu", unpacked.bi_size);
 		break;
 	}
 }
@@ -252,17 +252,17 @@ void bch2_inode_init(struct bch_fs *c, struct bch_inode_unpacked *inode_u,
 	memset(inode_u, 0, sizeof(*inode_u));
 
 	/* ick */
-	inode_u->i_flags |= c->opts.str_hash << INODE_STR_HASH_OFFSET;
-	get_random_bytes(&inode_u->i_hash_seed, sizeof(inode_u->i_hash_seed));
-
-	inode_u->i_mode		= mode;
-	inode_u->i_uid		= uid;
-	inode_u->i_gid		= gid;
-	inode_u->i_dev		= rdev;
-	inode_u->i_atime	= now;
-	inode_u->i_mtime	= now;
-	inode_u->i_ctime	= now;
-	inode_u->i_otime	= now;
+	inode_u->bi_flags |= c->opts.str_hash << INODE_STR_HASH_OFFSET;
+	get_random_bytes(&inode_u->bi_hash_seed, sizeof(inode_u->bi_hash_seed));
+
+	inode_u->bi_mode	= mode;
+	inode_u->bi_uid		= uid;
+	inode_u->bi_gid		= gid;
+	inode_u->bi_dev		= rdev;
+	inode_u->bi_atime	= now;
+	inode_u->bi_mtime	= now;
+	inode_u->bi_ctime	= now;
+	inode_u->bi_otime	= now;
 }
 
 int bch2_inode_create(struct bch_fs *c, struct bch_inode_unpacked *inode_u,
@@ -290,7 +290,7 @@ again:
 
 	while (1) {
 		struct bkey_s_c k = bch2_btree_iter_peek_with_holes(&iter);
-		u32 i_generation = 0;
+		u32 bi_generation = 0;
 
 		ret = btree_iter_err(k);
 		if (ret) {
@@ -311,11 +311,11 @@ again:
 		case BCH_INODE_GENERATION: {
 			struct bkey_s_c_inode_generation g =
 				bkey_s_c_to_inode_generation(k);
-			i_generation = le32_to_cpu(g.v->i_generation);
+			bi_generation = le32_to_cpu(g.v->bi_generation);
 			/* fallthrough: */
 		}
 		default:
-			inode_u->i_generation = i_generation;
+			inode_u->bi_generation = bi_generation;
 
 			bch2_inode_pack(&inode_p, inode_u);
 			inode_p.inode.k.p = k.k->p;
@@ -329,7 +329,7 @@ again:
 				bch2_btree_iter_unlock(&iter);
 
 				if (!ret) {
-					inode_u->inum =
+					inode_u->bi_inum =
 						inode_p.inode.k.p.inode;
 					*hint = inode_p.inode.k.p.inode + 1;
 				}
@@ -401,7 +401,7 @@ int bch2_inode_rm(struct bch_fs *c, u64 inode_nr)
 			     BTREE_ITER_INTENT);
 	do {
 		struct bkey_s_c k = bch2_btree_iter_peek_with_holes(&iter);
-		u32 i_generation = 0;
+		u32 bi_generation = 0;
 
 		ret = btree_iter_err(k);
 		if (ret) {
@@ -418,24 +418,24 @@ int bch2_inode_rm(struct bch_fs *c, u64 inode_nr)
 			struct bch_inode_unpacked inode_u;
 
 			if (!bch2_inode_unpack(bkey_s_c_to_inode(k), &inode_u))
-				i_generation = cpu_to_le32(inode_u.i_generation) + 1;
+				bi_generation = cpu_to_le32(inode_u.bi_generation) + 1;
 			break;
 		}
 		case BCH_INODE_GENERATION: {
 			struct bkey_s_c_inode_generation g =
 				bkey_s_c_to_inode_generation(k);
-			i_generation = le32_to_cpu(g.v->i_generation);
+			bi_generation = le32_to_cpu(g.v->bi_generation);
 			break;
 		}
 		}
 
-		if (!i_generation) {
+		if (!bi_generation) {
 			bkey_init(&delete.k);
 			delete.k.p.inode = inode_nr;
 		} else {
 			bkey_inode_generation_init(&delete.k_i);
 			delete.k.p.inode = inode_nr;
-			delete.v.i_generation = cpu_to_le32(i_generation);
+			delete.v.bi_generation = cpu_to_le32(bi_generation);
 		}
 
 		ret = bch2_btree_insert_at(c, NULL, NULL, NULL,
@@ -511,17 +511,17 @@ void bch2_inode_pack_test(void)
 {
 	struct bch_inode_unpacked *u, test_inodes[] = {
 		{
-			.i_atime	= U64_MAX,
-			.i_ctime	= U64_MAX,
-			.i_mtime	= U64_MAX,
-			.i_otime	= U64_MAX,
-			.i_size		= U64_MAX,
-			.i_sectors	= U64_MAX,
-			.i_uid		= U32_MAX,
-			.i_gid		= U32_MAX,
-			.i_nlink	= U32_MAX,
-			.i_generation	= U32_MAX,
-			.i_dev		= U32_MAX,
+			.bi_atime	= U64_MAX,
+			.bi_ctime	= U64_MAX,
+			.bi_mtime	= U64_MAX,
+			.bi_otime	= U64_MAX,
+			.bi_size	= U64_MAX,
+			.bi_sectors	= U64_MAX,
+			.bi_uid		= U32_MAX,
+			.bi_gid		= U32_MAX,
+			.bi_nlink	= U32_MAX,
+			.bi_generation	= U32_MAX,
+			.bi_dev		= U32_MAX,
 		},
 	};
 
diff --git a/fs/bcachefs/inode.h b/fs/bcachefs/inode.h
index 22aac3e695b0..53c70617b289 100644
--- a/fs/bcachefs/inode.h
+++ b/fs/bcachefs/inode.h
@@ -6,10 +6,10 @@
 extern const struct bkey_ops bch2_bkey_inode_ops;
 
 struct bch_inode_unpacked {
-	u64			inum;
-	__le64			i_hash_seed;
-	u32			i_flags;
-	u16			i_mode;
+	u64			bi_inum;
+	__le64			bi_hash_seed;
+	u32			bi_flags;
+	u16			bi_mode;
 
 #define BCH_INODE_FIELD(_name, _bits)	u##_bits _name;
 	BCH_INODE_FIELDS()
@@ -22,7 +22,7 @@ struct bkey_inode_buf {
 #define BCH_INODE_FIELD(_name, _bits)		+ 8 + _bits / 8
 	u8		_pad[0 + BCH_INODE_FIELDS()];
 #undef  BCH_INODE_FIELD
-};
+} __attribute__((packed, aligned(8)));
 
 void bch2_inode_pack(struct bkey_inode_buf *, const struct bch_inode_unpacked *);
 int bch2_inode_unpack(struct bkey_s_c_inode, struct bch_inode_unpacked *);
diff --git a/fs/bcachefs/str_hash.h b/fs/bcachefs/str_hash.h
index d91fbdf13846..530cf0a49c84 100644
--- a/fs/bcachefs/str_hash.h
+++ b/fs/bcachefs/str_hash.h
@@ -26,14 +26,14 @@ bch2_hash_info_init(struct bch_fs *c,
 {
 	/* XXX ick */
 	struct bch_hash_info info = {
-		.type = (bi->i_flags >> INODE_STR_HASH_OFFSET) &
+		.type = (bi->bi_flags >> INODE_STR_HASH_OFFSET) &
 			~(~0U << INODE_STR_HASH_BITS)
 	};
 
 	switch (info.type) {
 	case BCH_STR_HASH_CRC32C:
 	case BCH_STR_HASH_CRC64:
-		info.crc_key = bi->i_hash_seed;
+		info.crc_key = bi->bi_hash_seed;
 		break;
 	case BCH_STR_HASH_SIPHASH: {
 		SHASH_DESC_ON_STACK(desc, c->sha256);
@@ -42,8 +42,8 @@ bch2_hash_info_init(struct bch_fs *c,
 		desc->tfm = c->sha256;
 		desc->flags = 0;
 
-		crypto_shash_digest(desc, (void *) &bi->i_hash_seed,
-				    sizeof(bi->i_hash_seed), digest);
+		crypto_shash_digest(desc, (void *) &bi->bi_hash_seed,
+				    sizeof(bi->bi_hash_seed), digest);
 		memcpy(&info.siphash_key, digest, sizeof(info.siphash_key));
 		break;
 	}
diff --git a/fs/bcachefs/super.c b/fs/bcachefs/super.c
index 9ef81f19c2a8..afff79ccf149 100644
--- a/fs/bcachefs/super.c
+++ b/fs/bcachefs/super.c
@@ -827,7 +827,7 @@ static const char *__bch2_fs_start(struct bch_fs *c)
 
 		bch2_inode_init(c, &inode, 0, 0,
 			       S_IFDIR|S_IRWXU|S_IRUGO|S_IXUGO, 0);
-		inode.inum = BCACHEFS_ROOT_INO;
+		inode.bi_inum = BCACHEFS_ROOT_INO;
 
 		bch2_inode_pack(&packed_inode, &inode);