forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-12-19 9370bb92b2d16684ee45cf24e879c93c509162da 
 kernel/fs/xfs/libxfs/xfs_dir2_block.c
....@@ -6,22 +6,19 @@
66  */
77 #include "xfs.h"
88 #include "xfs_fs.h"
9
+#include "xfs_shared.h"
910 #include "xfs_format.h"
1011 #include "xfs_log_format.h"
1112 #include "xfs_trans_resv.h"
1213 #include "xfs_mount.h"
13
-#include "xfs_da_format.h"
14
-#include "xfs_da_btree.h"
1514 #include "xfs_inode.h"
1615 #include "xfs_trans.h"
17
-#include "xfs_inode_item.h"
1816 #include "xfs_bmap.h"
1917 #include "xfs_buf_item.h"
2018 #include "xfs_dir2.h"
2119 #include "xfs_dir2_priv.h"
2220 #include "xfs_error.h"
2321 #include "xfs_trace.h"
24
-#include "xfs_cksum.h"
2522 #include "xfs_log.h"
2623 
2724 /*
....@@ -50,20 +47,18 @@
5047 xfs_dir3_block_verify(
5148 	struct xfs_buf		*bp)
5249 {
53
-	struct xfs_mount	*mp = bp->b_target->bt_mount;
50
+	struct xfs_mount	*mp = bp->b_mount;
5451 	struct xfs_dir3_blk_hdr	*hdr3 = bp->b_addr;
5552 
53
+	if (!xfs_verify_magic(bp, hdr3->magic))
54
+		return __this_address;
55
+
5656 	if (xfs_sb_version_hascrc(&mp->m_sb)) {
57
-		if (hdr3->magic != cpu_to_be32(XFS_DIR3_BLOCK_MAGIC))
58
-			return __this_address;
5957 		if (!uuid_equal(&hdr3->uuid, &mp->m_sb.sb_meta_uuid))
6058 			return __this_address;
6159 		if (be64_to_cpu(hdr3->blkno) != bp->b_bn)
6260 			return __this_address;
6361 		if (!xfs_log_check_lsn(mp, be64_to_cpu(hdr3->lsn)))
64
-			return __this_address;
65
-	} else {
66
-		if (hdr3->magic != cpu_to_be32(XFS_DIR2_BLOCK_MAGIC))
6762 			return __this_address;
6863 	}
6964 	return __xfs_dir3_data_check(NULL, bp);
....@@ -73,7 +68,7 @@
7368 xfs_dir3_block_read_verify(
7469 	struct xfs_buf	*bp)
7570 {
76
-	struct xfs_mount	*mp = bp->b_target->bt_mount;
71
+	struct xfs_mount	*mp = bp->b_mount;
7772 	xfs_failaddr_t		fa;
7873 
7974 	if (xfs_sb_version_hascrc(&mp->m_sb) &&
....@@ -90,7 +85,7 @@
9085 xfs_dir3_block_write_verify(
9186 	struct xfs_buf	*bp)
9287 {
93
-	struct xfs_mount	*mp = bp->b_target->bt_mount;
88
+	struct xfs_mount	*mp = bp->b_mount;
9489 	struct xfs_buf_log_item	*bip = bp->b_log_item;
9590 	struct xfs_dir3_blk_hdr	*hdr3 = bp->b_addr;
9691 	xfs_failaddr_t		fa;
....@@ -112,10 +107,29 @@
112107 
113108 const struct xfs_buf_ops xfs_dir3_block_buf_ops = {
114109 	.name = "xfs_dir3_block",
110
+	.magic = { cpu_to_be32(XFS_DIR2_BLOCK_MAGIC),
111
+		   cpu_to_be32(XFS_DIR3_BLOCK_MAGIC) },
115112 	.verify_read = xfs_dir3_block_read_verify,
116113 	.verify_write = xfs_dir3_block_write_verify,
117114 	.verify_struct = xfs_dir3_block_verify,
118115 };
116
+
117
+static xfs_failaddr_t
118
+xfs_dir3_block_header_check(
119
+	struct xfs_inode	*dp,
120
+	struct xfs_buf		*bp)
121
+{
122
+	struct xfs_mount	*mp = dp->i_mount;
123
+
124
+	if (xfs_sb_version_hascrc(&mp->m_sb)) {
125
+		struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
126
+
127
+		if (be64_to_cpu(hdr3->owner) != dp->i_ino)
128
+			return __this_address;
129
+	}
130
+
131
+	return NULL;
132
+}
119133 
120134 int
121135 xfs_dir3_block_read(
....@@ -124,12 +138,24 @@
124138 	struct xfs_buf		**bpp)
125139 {
126140 	struct xfs_mount	*mp = dp->i_mount;
141
+	xfs_failaddr_t		fa;
127142 	int			err;
128143 
129
-	err = xfs_da_read_buf(tp, dp, mp->m_dir_geo->datablk, -1, bpp,
144
+	err = xfs_da_read_buf(tp, dp, mp->m_dir_geo->datablk, 0, bpp,
130145 				XFS_DATA_FORK, &xfs_dir3_block_buf_ops);
131
-	if (!err && tp && *bpp)
132
-		xfs_trans_buf_set_type(tp, *bpp, XFS_BLFT_DIR_BLOCK_BUF);
146
+	if (err || !*bpp)
147
+		return err;
148
+
149
+	/* Check things that we can't do in the verifier. */
150
+	fa = xfs_dir3_block_header_check(dp, *bpp);
151
+	if (fa) {
152
+		__xfs_buf_mark_corrupt(*bpp, fa);
153
+		xfs_trans_brelse(tp, *bpp);
154
+		*bpp = NULL;
155
+		return -EFSCORRUPTED;
156
+	}
157
+
158
+	xfs_trans_buf_set_type(tp, *bpp, XFS_BLFT_DIR_BLOCK_BUF);
133159 	return err;
134160 }
135161 
....@@ -175,7 +201,7 @@
175201 	struct xfs_dir2_data_unused	*enddup = NULL;
176202 
177203 	*compact = 0;
178
-	bf = dp->d_ops->data_bestfree_p(hdr);
204
+	bf = xfs_dir2_data_bestfree_p(dp->i_mount, hdr);
179205 
180206 	/*
181207 	 * If there are stale entries we'll use one for the leaf.
....@@ -314,7 +340,7 @@
314340 	 * This needs to happen before the next call to use_free.
315341 	 */
316342 	if (needscan)
317
-		xfs_dir2_data_freescan(args->dp, hdr, needlog);
343
+		xfs_dir2_data_freescan(args->dp->i_mount, hdr, needlog);
318344 }
319345 
320346 /*
....@@ -358,7 +384,7 @@
358384 	if (error)
359385 		return error;
360386 
361
-	len = dp->d_ops->data_entsize(args->namelen);
387
+	len = xfs_dir2_data_entsize(dp->i_mount, args->namelen);
362388 
363389 	/*
364390 	 * Set up pointers to parts of the block.
....@@ -461,7 +487,7 @@
461487 		 * This needs to happen before the next call to use_free.
462488 		 */
463489 		if (needscan) {
464
-			xfs_dir2_data_freescan(dp, hdr, &needlog);
490
+			xfs_dir2_data_freescan(dp->i_mount, hdr, &needlog);
465491 			needscan = 0;
466492 		}
467493 		/*
....@@ -544,14 +570,14 @@
544570 	dep->inumber = cpu_to_be64(args->inumber);
545571 	dep->namelen = args->namelen;
546572 	memcpy(dep->name, args->name, args->namelen);
547
-	dp->d_ops->data_put_ftype(dep, args->filetype);
548
-	tagp = dp->d_ops->data_entry_tag_p(dep);
573
+	xfs_dir2_data_put_ftype(dp->i_mount, dep, args->filetype);
574
+	tagp = xfs_dir2_data_entry_tag_p(dp->i_mount, dep);
549575 	*tagp = cpu_to_be16((char *)dep - (char *)hdr);
550576 	/*
551577 	 * Clean up the bestfree array and log the header, tail, and entry.
552578 	 */
553579 	if (needscan)
554
-		xfs_dir2_data_freescan(dp, hdr, &needlog);
580
+		xfs_dir2_data_freescan(dp->i_mount, hdr, &needlog);
555581 	if (needlog)
556582 		xfs_dir2_data_log_header(args, bp);
557583 	xfs_dir2_block_log_tail(tp, bp);
....@@ -636,7 +662,7 @@
636662 	 * Fill in inode number, CI name if appropriate, release the block.
637663 	 */
638664 	args->inumber = be64_to_cpu(dep->inumber);
639
-	args->filetype = dp->d_ops->data_get_ftype(dep);
665
+	args->filetype = xfs_dir2_data_get_ftype(dp->i_mount, dep);
640666 	error = xfs_dir_cilookup_result(args, dep->name, dep->namelen);
641667 	xfs_trans_brelse(args->trans, bp);
642668 	return error;
....@@ -663,13 +689,11 @@
663689 	int			high;		/* binary search high index */
664690 	int			low;		/* binary search low index */
665691 	int			mid;		/* binary search current idx */
666
-	xfs_mount_t		*mp;		/* filesystem mount point */
667692 	xfs_trans_t		*tp;		/* transaction pointer */
668693 	enum xfs_dacmp		cmp;		/* comparison result */
669694 
670695 	dp = args->dp;
671696 	tp = args->trans;
672
-	mp = dp->i_mount;
673697 
674698 	error = xfs_dir3_block_read(tp, dp, &bp);
675699 	if (error)
....@@ -721,7 +745,7 @@
721745 		 * and buffer. If it's the first case-insensitive match, store
722746 		 * the index and buffer and continue looking for an exact match.
723747 		 */
724
-		cmp = mp->m_dirnameops->compname(args, dep->name, dep->namelen);
748
+		cmp = xfs_dir2_compname(args, dep->name, dep->namelen);
725749 		if (cmp != XFS_CMP_DIFFERENT && cmp != args->cmpresult) {
726750 			args->cmpresult = cmp;
727751 			*bpp = bp;
....@@ -794,7 +818,8 @@
794818 	needlog = needscan = 0;
795819 	xfs_dir2_data_make_free(args, bp,
796820 		(xfs_dir2_data_aoff_t)((char *)dep - (char *)hdr),
797
-		dp->d_ops->data_entsize(dep->namelen), &needlog, &needscan);
821
+		xfs_dir2_data_entsize(dp->i_mount, dep->namelen), &needlog,
822
+		&needscan);
798823 	/*
799824 	 * Fix up the block tail.
800825 	 */
....@@ -809,7 +834,7 @@
809834 	 * Fix up bestfree, log the header if necessary.
810835 	 */
811836 	if (needscan)
812
-		xfs_dir2_data_freescan(dp, hdr, &needlog);
837
+		xfs_dir2_data_freescan(dp->i_mount, hdr, &needlog);
813838 	if (needlog)
814839 		xfs_dir2_data_log_header(args, bp);
815840 	xfs_dir3_data_check(dp, bp);
....@@ -867,7 +892,7 @@
867892 	 * Change the inode number to the new value.
868893 	 */
869894 	dep->inumber = cpu_to_be64(args->inumber);
870
-	dp->d_ops->data_put_ftype(dep, args->filetype);
895
+	xfs_dir2_data_put_ftype(dp->i_mount, dep, args->filetype);
871896 	xfs_dir2_data_log_entry(args, bp, dep);
872897 	xfs_dir3_data_check(dp, bp);
873898 	return 0;
....@@ -917,7 +942,6 @@
917942 	__be16			*tagp;		/* end of entry (tag) */
918943 	int			to;		/* block/leaf to index */
919944 	xfs_trans_t		*tp;		/* transaction pointer */
920
-	struct xfs_dir2_leaf_entry *ents;
921945 	struct xfs_dir3_icleaf_hdr leafhdr;
922946 
923947 	trace_xfs_dir2_leaf_to_block(args);
....@@ -926,8 +950,7 @@
926950 	tp = args->trans;
927951 	mp = dp->i_mount;
928952 	leaf = lbp->b_addr;
929
-	dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
930
-	ents = dp->d_ops->leaf_ents_p(leaf);
953
+	xfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);
931954 	ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);
932955 
933956 	ASSERT(leafhdr.magic == XFS_DIR2_LEAF1_MAGIC ||
....@@ -941,7 +964,7 @@
941964 	while (dp->i_d.di_size > args->geo->blksize) {
942965 		int hdrsz;
943966 
944
-		hdrsz = dp->d_ops->data_entry_offset;
967
+		hdrsz = args->geo->data_entry_offset;
945968 		bestsp = xfs_dir2_leaf_bests_p(ltp);
946969 		if (be16_to_cpu(bestsp[be32_to_cpu(ltp->bestcount) - 1]) ==
947970 					    args->geo->blksize - hdrsz) {
....@@ -956,7 +979,7 @@
956979 	 * Read the data block if we don't already have it, give up if it fails.
957980 	 */
958981 	if (!dbp) {
959
-		error = xfs_dir3_data_read(tp, dp, args->geo->datablk, -1, &dbp);
982
+		error = xfs_dir3_data_read(tp, dp, args->geo->datablk, 0, &dbp);
960983 		if (error)
961984 			return error;
962985 	}
....@@ -1007,9 +1030,10 @@
10071030 	 */
10081031 	lep = xfs_dir2_block_leaf_p(btp);
10091032 	for (from = to = 0; from < leafhdr.count; from++) {
1010
-		if (ents[from].address == cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
1033
+		if (leafhdr.ents[from].address ==
1034
+		    cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
10111035 			continue;
1012
-		lep[to++] = ents[from];
1036
+		lep[to++] = leafhdr.ents[from];
10131037 	}
10141038 	ASSERT(to == be32_to_cpu(btp->count));
10151039 	xfs_dir2_block_log_leaf(tp, dbp, 0, be32_to_cpu(btp->count) - 1);
....@@ -1017,7 +1041,7 @@
10171041 	 * Scan the bestfree if we need it and log the data block header.
10181042 	 */
10191043 	if (needscan)
1020
-		xfs_dir2_data_freescan(dp, hdr, &needlog);
1044
+		xfs_dir2_data_freescan(dp->i_mount, hdr, &needlog);
10211045 	if (needlog)
10221046 		xfs_dir2_data_log_header(args, dbp);
10231047 	/*
....@@ -1042,64 +1066,55 @@
10421066  */
10431067 int						/* error */
10441068 xfs_dir2_sf_to_block(
1045
-	xfs_da_args_t		*args)		/* operation arguments */
1069
+	struct xfs_da_args	*args)
10461070 {
1071
+	struct xfs_trans	*tp = args->trans;
1072
+	struct xfs_inode	*dp = args->dp;
1073
+	struct xfs_mount	*mp = dp->i_mount;
1074
+	struct xfs_ifork	*ifp = XFS_IFORK_PTR(dp, XFS_DATA_FORK);
1075
+	struct xfs_da_geometry	*geo = args->geo;
10471076 	xfs_dir2_db_t		blkno;		/* dir-relative block # (0) */
10481077 	xfs_dir2_data_hdr_t	*hdr;		/* block header */
10491078 	xfs_dir2_leaf_entry_t	*blp;		/* block leaf entries */
10501079 	struct xfs_buf		*bp;		/* block buffer */
10511080 	xfs_dir2_block_tail_t	*btp;		/* block tail pointer */
10521081 	xfs_dir2_data_entry_t	*dep;		/* data entry pointer */
1053
-	xfs_inode_t		*dp;		/* incore directory inode */
10541082 	int			dummy;		/* trash */
10551083 	xfs_dir2_data_unused_t	*dup;		/* unused entry pointer */
10561084 	int			endoffset;	/* end of data objects */
10571085 	int			error;		/* error return value */
10581086 	int			i;		/* index */
1059
-	xfs_mount_t		*mp;		/* filesystem mount point */
10601087 	int			needlog;	/* need to log block header */
10611088 	int			needscan;	/* need to scan block freespc */
10621089 	int			newoffset;	/* offset from current entry */
1063
-	int			offset;		/* target block offset */
1090
+	unsigned int		offset = geo->data_entry_offset;
10641091 	xfs_dir2_sf_entry_t	*sfep;		/* sf entry pointer */
10651092 	xfs_dir2_sf_hdr_t	*oldsfp;	/* old shortform header  */
10661093 	xfs_dir2_sf_hdr_t	*sfp;		/* shortform header  */
10671094 	__be16			*tagp;		/* end of data entry */
1068
-	xfs_trans_t		*tp;		/* transaction pointer */
10691095 	struct xfs_name		name;
1070
-	struct xfs_ifork	*ifp;
10711096 
10721097 	trace_xfs_dir2_sf_to_block(args);
10731098 
1074
-	dp = args->dp;
1075
-	tp = args->trans;
1076
-	mp = dp->i_mount;
1077
-	ifp = XFS_IFORK_PTR(dp, XFS_DATA_FORK);
10781099 	ASSERT(ifp->if_flags & XFS_IFINLINE);
1079
-	/*
1080
-	 * Bomb out if the shortform directory is way too short.
1081
-	 */
1082
-	if (dp->i_d.di_size < offsetof(xfs_dir2_sf_hdr_t, parent)) {
1083
-		ASSERT(XFS_FORCED_SHUTDOWN(mp));
1084
-		return -EIO;
1085
-	}
1100
+	ASSERT(dp->i_d.di_size >= offsetof(struct xfs_dir2_sf_hdr, parent));
10861101 
10871102 	oldsfp = (xfs_dir2_sf_hdr_t *)ifp->if_u1.if_data;
10881103 
10891104 	ASSERT(ifp->if_bytes == dp->i_d.di_size);
10901105 	ASSERT(ifp->if_u1.if_data != NULL);
10911106 	ASSERT(dp->i_d.di_size >= xfs_dir2_sf_hdr_size(oldsfp->i8count));
1092
-	ASSERT(dp->i_d.di_nextents == 0);
1107
+	ASSERT(dp->i_df.if_nextents == 0);
10931108 
10941109 	/*
10951110 	 * Copy the directory into a temporary buffer.
10961111 	 * Then pitch the incore inode data so we can make extents.
10971112 	 */
1098
-	sfp = kmem_alloc(ifp->if_bytes, KM_SLEEP);
1113
+	sfp = kmem_alloc(ifp->if_bytes, 0);
10991114 	memcpy(sfp, oldsfp, ifp->if_bytes);
11001115 
11011116 	xfs_idata_realloc(dp, -ifp->if_bytes, XFS_DATA_FORK);
1102
-	xfs_bmap_local_to_extents_empty(dp, XFS_DATA_FORK);
1117
+	xfs_bmap_local_to_extents_empty(tp, dp, XFS_DATA_FORK);
11031118 	dp->i_d.di_size = 0;
11041119 
11051120 	/*
....@@ -1126,7 +1141,7 @@
11261141 	 * The whole thing is initialized to free by the init routine.
11271142 	 * Say we're using the leaf and tail area.
11281143 	 */
1129
-	dup = dp->d_ops->data_unused_p(hdr);
1144
+	dup = bp->b_addr + offset;
11301145 	needlog = needscan = 0;
11311146 	error = xfs_dir2_data_use_free(args, bp, dup, args->geo->blksize - i,
11321147 			i, &needlog, &needscan);
....@@ -1149,35 +1164,37 @@
11491164 			be16_to_cpu(dup->length), &needlog, &needscan);
11501165 	if (error)
11511166 		goto out_free;
1167
+
11521168 	/*
11531169 	 * Create entry for .
11541170 	 */
1155
-	dep = dp->d_ops->data_dot_entry_p(hdr);
1171
+	dep = bp->b_addr + offset;
11561172 	dep->inumber = cpu_to_be64(dp->i_ino);
11571173 	dep->namelen = 1;
11581174 	dep->name[0] = '.';
1159
-	dp->d_ops->data_put_ftype(dep, XFS_DIR3_FT_DIR);
1160
-	tagp = dp->d_ops->data_entry_tag_p(dep);
1161
-	*tagp = cpu_to_be16((char *)dep - (char *)hdr);
1175
+	xfs_dir2_data_put_ftype(mp, dep, XFS_DIR3_FT_DIR);
1176
+	tagp = xfs_dir2_data_entry_tag_p(mp, dep);
1177
+	*tagp = cpu_to_be16(offset);
11621178 	xfs_dir2_data_log_entry(args, bp, dep);
11631179 	blp[0].hashval = cpu_to_be32(xfs_dir_hash_dot);
1164
-	blp[0].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(
1165
-				(char *)dep - (char *)hdr));
1180
+	blp[0].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(offset));
1181
+	offset += xfs_dir2_data_entsize(mp, dep->namelen);
1182
+
11661183 	/*
11671184 	 * Create entry for ..
11681185 	 */
1169
-	dep = dp->d_ops->data_dotdot_entry_p(hdr);
1170
-	dep->inumber = cpu_to_be64(dp->d_ops->sf_get_parent_ino(sfp));
1186
+	dep = bp->b_addr + offset;
1187
+	dep->inumber = cpu_to_be64(xfs_dir2_sf_get_parent_ino(sfp));
11711188 	dep->namelen = 2;
11721189 	dep->name[0] = dep->name[1] = '.';
1173
-	dp->d_ops->data_put_ftype(dep, XFS_DIR3_FT_DIR);
1174
-	tagp = dp->d_ops->data_entry_tag_p(dep);
1175
-	*tagp = cpu_to_be16((char *)dep - (char *)hdr);
1190
+	xfs_dir2_data_put_ftype(mp, dep, XFS_DIR3_FT_DIR);
1191
+	tagp = xfs_dir2_data_entry_tag_p(mp, dep);
1192
+	*tagp = cpu_to_be16(offset);
11761193 	xfs_dir2_data_log_entry(args, bp, dep);
11771194 	blp[1].hashval = cpu_to_be32(xfs_dir_hash_dotdot);
1178
-	blp[1].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(
1179
-				(char *)dep - (char *)hdr));
1180
-	offset = dp->d_ops->data_first_offset;
1195
+	blp[1].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(offset));
1196
+	offset += xfs_dir2_data_entsize(mp, dep->namelen);
1197
+
11811198 	/*
11821199 	 * Loop over existing entries, stuff them in.
11831200 	 */
....@@ -1186,6 +1203,7 @@
11861203 		sfep = NULL;
11871204 	else
11881205 		sfep = xfs_dir2_sf_firstentry(sfp);
1206
+
11891207 	/*
11901208 	 * Need to preserve the existing offset values in the sf directory.
11911209 	 * Insert holes (unused entries) where necessary.
....@@ -1202,40 +1220,39 @@
12021220 		 * There should be a hole here, make one.
12031221 		 */
12041222 		if (offset < newoffset) {
1205
-			dup = (xfs_dir2_data_unused_t *)((char *)hdr + offset);
1223
+			dup = bp->b_addr + offset;
12061224 			dup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
12071225 			dup->length = cpu_to_be16(newoffset - offset);
1208
-			*xfs_dir2_data_unused_tag_p(dup) = cpu_to_be16(
1209
-				((char *)dup - (char *)hdr));
1226
+			*xfs_dir2_data_unused_tag_p(dup) = cpu_to_be16(offset);
12101227 			xfs_dir2_data_log_unused(args, bp, dup);
12111228 			xfs_dir2_data_freeinsert(hdr,
1212
-						 dp->d_ops->data_bestfree_p(hdr),
1213
-						 dup, &dummy);
1229
+					xfs_dir2_data_bestfree_p(mp, hdr),
1230
+					dup, &dummy);
12141231 			offset += be16_to_cpu(dup->length);
12151232 			continue;
12161233 		}
12171234 		/*
12181235 		 * Copy a real entry.
12191236 		 */
1220
-		dep = (xfs_dir2_data_entry_t *)((char *)hdr + newoffset);
1221
-		dep->inumber = cpu_to_be64(dp->d_ops->sf_get_ino(sfp, sfep));
1237
+		dep = bp->b_addr + newoffset;
1238
+		dep->inumber = cpu_to_be64(xfs_dir2_sf_get_ino(mp, sfp, sfep));
12221239 		dep->namelen = sfep->namelen;
1223
-		dp->d_ops->data_put_ftype(dep, dp->d_ops->sf_get_ftype(sfep));
1240
+		xfs_dir2_data_put_ftype(mp, dep,
1241
+				xfs_dir2_sf_get_ftype(mp, sfep));
12241242 		memcpy(dep->name, sfep->name, dep->namelen);
1225
-		tagp = dp->d_ops->data_entry_tag_p(dep);
1226
-		*tagp = cpu_to_be16((char *)dep - (char *)hdr);
1243
+		tagp = xfs_dir2_data_entry_tag_p(mp, dep);
1244
+		*tagp = cpu_to_be16(newoffset);
12271245 		xfs_dir2_data_log_entry(args, bp, dep);
12281246 		name.name = sfep->name;
12291247 		name.len = sfep->namelen;
1230
-		blp[2 + i].hashval = cpu_to_be32(mp->m_dirnameops->
1231
-							hashname(&name));
1232
-		blp[2 + i].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(
1233
-						 (char *)dep - (char *)hdr));
1248
+		blp[2 + i].hashval = cpu_to_be32(xfs_dir2_hashname(mp, &name));
1249
+		blp[2 + i].address =
1250
+			cpu_to_be32(xfs_dir2_byte_to_dataptr(newoffset));
12341251 		offset = (int)((char *)(tagp + 1) - (char *)hdr);
12351252 		if (++i == sfp->count)
12361253 			sfep = NULL;
12371254 		else
1238
-			sfep = dp->d_ops->sf_nextentry(sfp, sfep);
1255
+			sfep = xfs_dir2_sf_nextentry(mp, sfp, sfep);
12391256 	}
12401257 	/* Done with the temporary buffer */
12411258 	kmem_free(sfp);