188 #define LFS_SWAP_int16_t(fs, val) (val)  argument
189 #define LFS_SWAP_int32_t(fs, val) (val)  argument
190 #define LFS_SWAP_int64_t(fs, val) (val)  argument
191 #define LFS_SWAP_uint16_t(fs, val) (val)  argument
192 #define LFS_SWAP_uint32_t(fs, val) (val)  argument
193 #define LFS_SWAP_uint64_t(fs, val) (val)  argument
195 #define LFS_SWAP_int16_t(fs, val) \  argument
196 	((fs)->lfs_dobyteswap ? (int16_t)bswap16(val) : (val))
197 #define LFS_SWAP_int32_t(fs, val) \  argument
198 	((fs)->lfs_dobyteswap ? (int32_t)bswap32(val) : (val))
199 #define LFS_SWAP_int64_t(fs, val) \  argument
200 	((fs)->lfs_dobyteswap ? (int64_t)bswap64(val) : (val))
201 #define LFS_SWAP_uint16_t(fs, val) \  argument
202 	((fs)->lfs_dobyteswap ? bswap16(val) : (val))
203 #define LFS_SWAP_uint32_t(fs, val) \  argument
204 	((fs)->lfs_dobyteswap ? bswap32(val) : (val))
205 #define LFS_SWAP_uint64_t(fs, val) \  argument
206 	((fs)->lfs_dobyteswap ? bswap64(val) : (val))
214 #define LFS_LITTLE_ENDIAN_ONDISK(fs) (!(fs)->lfs_dobyteswap)  argument
216 #define LFS_LITTLE_ENDIAN_ONDISK(fs) ((fs)->lfs_dobyteswap)  argument
249 #define LFS_DIRHEADERSIZE(fs) \  argument
250 	((fs)->lfs_is64 ? sizeof(struct lfs_dirheader64) : sizeof(struct lfs_dirheader32))
258 #define	LFS_DIRECTSIZ(fs, namlen) \  argument
259 	(LFS_DIRHEADERSIZE(fs) + (((namlen)+1 + 3) &~ 3))
279 #define LFS_DIRSIZ(fs, dp) LFS_DIRECTSIZ(fs, lfs_dir_getnamlen(fs, dp))  argument
285 #define LFS_NEXTDIR(fs, dp) \  argument
286 	((LFS_DIRHEADER *)((char *)(dp) + lfs_dir_getreclen(fs, dp)))
289 lfs_dir_nameptr(const STRUCT_LFS *fs, LFS_DIRHEADER *dh)  in lfs_dir_nameptr()  argument
291 	if (fs->lfs_is64) {  in lfs_dir_nameptr()
299 lfs_dir_getino(const STRUCT_LFS *fs, const LFS_DIRHEADER *dh)  in lfs_dir_getino()  argument
301 	if (fs->lfs_is64) {  in lfs_dir_getino()
302 		return LFS_SWAP_uint64_t(fs, dh->u_64.dh_ino);  in lfs_dir_getino()
304 		return LFS_SWAP_uint32_t(fs, dh->u_32.dh_ino);  in lfs_dir_getino()
309 lfs_dir_getreclen(const STRUCT_LFS *fs, const LFS_DIRHEADER *dh)  in lfs_dir_getreclen()  argument
311 	if (fs->lfs_is64) {  in lfs_dir_getreclen()
312 		return LFS_SWAP_uint16_t(fs, dh->u_64.dh_reclen);  in lfs_dir_getreclen()
314 		return LFS_SWAP_uint16_t(fs, dh->u_32.dh_reclen);  in lfs_dir_getreclen()
319 lfs_dir_gettype(const STRUCT_LFS *fs, const LFS_DIRHEADER *dh)  in lfs_dir_gettype()  argument
321 	if (fs->lfs_is64) {  in lfs_dir_gettype()
322 		KASSERT(fs->lfs_hasolddirfmt == 0);  in lfs_dir_gettype()
324 	} else if (fs->lfs_hasolddirfmt) {  in lfs_dir_gettype()
332 lfs_dir_getnamlen(const STRUCT_LFS *fs, const LFS_DIRHEADER *dh)  in lfs_dir_getnamlen()  argument
334 	if (fs->lfs_is64) {  in lfs_dir_getnamlen()
335 		KASSERT(fs->lfs_hasolddirfmt == 0);  in lfs_dir_getnamlen()
337 	} else if (fs->lfs_hasolddirfmt && LFS_LITTLE_ENDIAN_ONDISK(fs)) {  in lfs_dir_getnamlen()
346 lfs_dir_setino(STRUCT_LFS *fs, LFS_DIRHEADER *dh, uint64_t ino)  in lfs_dir_setino()  argument
348 	if (fs->lfs_is64) {  in lfs_dir_setino()
349 		dh->u_64.dh_ino = LFS_SWAP_uint64_t(fs, ino);  in lfs_dir_setino()
351 		dh->u_32.dh_ino = LFS_SWAP_uint32_t(fs, ino);  in lfs_dir_setino()
356 lfs_dir_setreclen(STRUCT_LFS *fs, LFS_DIRHEADER *dh, uint16_t reclen)  in lfs_dir_setreclen()  argument
358 	if (fs->lfs_is64) {  in lfs_dir_setreclen()
359 		dh->u_64.dh_reclen = LFS_SWAP_uint16_t(fs, reclen);  in lfs_dir_setreclen()
361 		dh->u_32.dh_reclen = LFS_SWAP_uint16_t(fs, reclen);  in lfs_dir_setreclen()
366 lfs_dir_settype(const STRUCT_LFS *fs, LFS_DIRHEADER *dh, uint8_t type)  in lfs_dir_settype()  argument
368 	if (fs->lfs_is64) {  in lfs_dir_settype()
369 		KASSERT(fs->lfs_hasolddirfmt == 0);  in lfs_dir_settype()
371 	} else if (fs->lfs_hasolddirfmt) {  in lfs_dir_settype()
380 lfs_dir_setnamlen(const STRUCT_LFS *fs, LFS_DIRHEADER *dh, uint8_t namlen)  in lfs_dir_setnamlen()  argument
382 	if (fs->lfs_is64) {  in lfs_dir_setnamlen()
383 		KASSERT(fs->lfs_hasolddirfmt == 0);  in lfs_dir_setnamlen()
385 	} else if (fs->lfs_hasolddirfmt && LFS_LITTLE_ENDIAN_ONDISK(fs)) {  in lfs_dir_setnamlen()
394 lfs_copydirname(STRUCT_LFS *fs, char *dest, const char *src,  in lfs_copydirname()  argument
399 	KASSERT(reclen > LFS_DIRHEADERSIZE(fs));  in lfs_copydirname()
400 	spacelen = reclen - LFS_DIRHEADERSIZE(fs);  in lfs_copydirname()
410 lfs_dirtemplate_dotdot(STRUCT_LFS *fs, union lfs_dirtemplate *dt)  in lfs_dirtemplate_dotdot()  argument
413 	if (fs->lfs_is64) {  in lfs_dirtemplate_dotdot()
421 lfs_dirtemplate_dotdotname(STRUCT_LFS *fs, union lfs_dirtemplate *dt)  in lfs_dirtemplate_dotdotname()  argument
423 	if (fs->lfs_is64) {  in lfs_dirtemplate_dotdotname()
440 #define LFS_MAXSYMLINKLEN(fs) \  argument
441 	((fs)->lfs_is64 ? LFS64_MAXSYMLINKLEN : LFS32_MAXSYMLINKLEN)
443 #define DINOSIZE(fs) ((fs)->lfs_is64 ? sizeof(struct lfs64_dinode) : sizeof(struct lfs32_dinode))  argument
445 #define DINO_IN_BLOCK(fs, base, ix) \  argument
446 	((union lfs_dinode *)((char *)(base) + DINOSIZE(fs) * (ix)))
449 lfs_copy_dinode(STRUCT_LFS *fs,  in lfs_copy_dinode()  argument
458 	if (fs->lfs_is64) {  in lfs_copy_dinode()
467 	lfs_dino_get##field(STRUCT_LFS *fs, union lfs_dinode *dip) \
469 		if (fs->lfs_is64) {				\
470 			return LFS_SWAP_##type(fs, dip->u_64.di_##field); \
472 			return LFS_SWAP_##type32(fs, dip->u_32.di_##field); \
476 	lfs_dino_set##field(STRUCT_LFS *fs, union lfs_dinode *dip, type val) \
478 		if (fs->lfs_is64) {				\
481 			dip->u_64.di_##field = LFS_SWAP_##type(fs, val); \
485 			dip->u_32.di_##field = LFS_SWAP_##type32(fs, val); \
509 lfs_dino_getdb(STRUCT_LFS *fs, union lfs_dinode *dip, unsigned ix)  in LFS_DEF_DINO_ACCESSOR()
512 	if (fs->lfs_is64) {  in LFS_DEF_DINO_ACCESSOR()
513 		return LFS_SWAP_int64_t(fs, dip->u_64.di_db[ix]);  in LFS_DEF_DINO_ACCESSOR()
516 		return (int32_t)LFS_SWAP_int32_t(fs, dip->u_32.di_db[ix]);  in LFS_DEF_DINO_ACCESSOR()
521 lfs_dino_getib(STRUCT_LFS *fs, union lfs_dinode *dip, unsigned ix)  in lfs_dino_getib()  argument
524 	if (fs->lfs_is64) {  in lfs_dino_getib()
525 		return LFS_SWAP_int64_t(fs, dip->u_64.di_ib[ix]);  in lfs_dino_getib()
528 		return (int32_t)LFS_SWAP_int32_t(fs, dip->u_32.di_ib[ix]);  in lfs_dino_getib()
533 lfs_dino_setdb(STRUCT_LFS *fs, union lfs_dinode *dip, unsigned ix, daddr_t val)  in lfs_dino_setdb()  argument
536 	if (fs->lfs_is64) {  in lfs_dino_setdb()
537 		dip->u_64.di_db[ix] = LFS_SWAP_int64_t(fs, val);  in lfs_dino_setdb()
539 		dip->u_32.di_db[ix] = LFS_SWAP_uint32_t(fs, val);  in lfs_dino_setdb()
544 lfs_dino_setib(STRUCT_LFS *fs, union lfs_dinode *dip, unsigned ix, daddr_t val)  in lfs_dino_setib()  argument
547 	if (fs->lfs_is64) {  in lfs_dino_setib()
548 		dip->u_64.di_ib[ix] = LFS_SWAP_int64_t(fs, val);  in lfs_dino_setib()
550 		dip->u_32.di_ib[ix] = LFS_SWAP_uint32_t(fs, val);  in lfs_dino_setib()
556 lfs_dino_setbirthtime(STRUCT_LFS *fs, union lfs_dinode *dip,  in lfs_dino_setbirthtime()  argument
559 	if (fs->lfs_is64) {  in lfs_dino_setbirthtime()
572 lfs_iblock_get(STRUCT_LFS *fs, void *block, unsigned ix)  in lfs_iblock_get()  argument
574 	if (fs->lfs_is64) {  in lfs_iblock_get()
586 lfs_iblock_set(STRUCT_LFS *fs, void *block, unsigned ix, daddr_t val)  in lfs_iblock_set()  argument
588 	if (fs->lfs_is64) {  in lfs_iblock_set()
659 #define	SEGUPB(fs)	(lfs_sb_getsepb(fs))  argument
660 #define	SEGTABSIZE_SU(fs)						\  argument
661 	((lfs_sb_getnseg(fs) + SEGUPB(fs) - 1) / lfs_sb_getsepb(fs))
710 #define LFS_BLKPTRSIZE(fs) ((fs)->lfs_is64 ? sizeof(int64_t) : sizeof(int32_t))  argument
714 #define LFS_INUMSIZE(fs) ((fs)->lfs_is64 ? sizeof(int64_t) : sizeof(int32_t))  argument
717 #define	FINFOSIZE(fs)	((fs)->lfs_is64 ? sizeof(FINFO64) : sizeof(FINFO32))  argument
720 #define FINFO_FULLSIZE(fs, fip) \  argument
721 	(FINFOSIZE(fs) + lfs_fi_getnblocks(fs, fip) * LFS_BLKPTRSIZE(fs))
723 #define NEXT_FINFO(fs, fip) \  argument
724 	((FINFO *)((char *)(fip) + FINFO_FULLSIZE(fs, fip)))
728 	lfs_fi_get##field(STRUCT_LFS *fs, FINFO *fip)		\
730 		if (fs->lfs_is64) {				\
737 	lfs_fi_set##field(STRUCT_LFS *fs, FINFO *fip, type val) \
739 		if (fs->lfs_is64) {				\
756 lfs_fi_getblock(STRUCT_LFS *fs, FINFO *fip, unsigned idx)  in LFS_DEF_FI_ACCESSOR()
760 	firstblock = (char *)fip + FINFOSIZE(fs);  in LFS_DEF_FI_ACCESSOR()
761 	KASSERT(idx < lfs_fi_getnblocks(fs, fip));  in LFS_DEF_FI_ACCESSOR()
762 	if (fs->lfs_is64) {  in LFS_DEF_FI_ACCESSOR()
770 lfs_fi_setblock(STRUCT_LFS *fs, FINFO *fip, unsigned idx, daddr_t blk)  in lfs_fi_setblock()  argument
774 	firstblock = (char *)fip + FINFOSIZE(fs);  in lfs_fi_setblock()
775 	KASSERT(idx < lfs_fi_getnblocks(fs, fip));  in lfs_fi_setblock()
776 	if (fs->lfs_is64) {  in lfs_fi_setblock()
787 #define IINFOSIZE(fs)	((fs)->lfs_is64 ? sizeof(IINFO64) : sizeof(IINFO32))  argument
790 #define SEGSUM_IINFOSTART(fs, buf) \  argument
791 	((IINFO *)((char *)buf + lfs_sb_getsumsize(fs) - IINFOSIZE(fs)))
793 #define NEXTLOWER_IINFO(fs, iip) \  argument
794 	((IINFO *)((char *)(iip) - IINFOSIZE(fs)))
796 #define NTH_IINFO(fs, buf, n) \  argument
797 	((IINFO *)((char *)SEGSUM_IINFOSTART(fs, buf) - (n)*IINFOSIZE(fs)))
800 lfs_ii_getblock(STRUCT_LFS *fs, IINFO *iip)  in lfs_ii_getblock()  argument
802 	if (fs->lfs_is64) {  in lfs_ii_getblock()
810 lfs_ii_setblock(STRUCT_LFS *fs, IINFO *iip, uint64_t block)  in lfs_ii_setblock()  argument
812 	if (fs->lfs_is64) {  in lfs_ii_setblock()
823 #define IFILE_ENTRYSIZE(fs) \  argument
824 	((fs)->lfs_is64 ? sizeof(IFILE64) : sizeof(IFILE32))
863 	lfs_if_get##field(STRUCT_LFS *fs, IFILE *ifp)		\
865 		if (fs->lfs_is64) {				\
872 	lfs_if_set##field(STRUCT_LFS *fs, IFILE *ifp, type val) \
874 		if (fs->lfs_is64) {				\
896 #define	CLEANSIZE_SU(fs)						\  in LFS_DEF_IF_ACCESSOR()  argument
897 	((((fs)->lfs_is64 ? sizeof(CLEANERINFO64) : sizeof(CLEANERINFO32)) + \  in LFS_DEF_IF_ACCESSOR()
898 		lfs_sb_getbsize(fs) - 1) >> lfs_sb_getbshift(fs))  in LFS_DEF_IF_ACCESSOR()
902 	lfs_ci_get##field(STRUCT_LFS *fs, CLEANERINFO *cip)	\  in LFS_DEF_IF_ACCESSOR()
904 		if (fs->lfs_is64) {				\  in LFS_DEF_IF_ACCESSOR()
911 	lfs_ci_set##field(STRUCT_LFS *fs, CLEANERINFO *cip, type val) \
913 		if (fs->lfs_is64) {				\
933 lfs_ci_shiftcleantodirty(STRUCT_LFS *fs, CLEANERINFO *cip, unsigned num)
935 	lfs_ci_setclean(fs, cip, lfs_ci_getclean(fs, cip) - num);
936 	lfs_ci_setdirty(fs, cip, lfs_ci_getdirty(fs, cip) + num);
940 lfs_ci_shiftdirtytoclean(STRUCT_LFS *fs, CLEANERINFO *cip, unsigned num)  in lfs_ci_shiftdirtytoclean()  argument
942 	lfs_ci_setdirty(fs, cip, lfs_ci_getdirty(fs, cip) - num);  in lfs_ci_shiftdirtytoclean()
943 	lfs_ci_setclean(fs, cip, lfs_ci_getclean(fs, cip) + num);  in lfs_ci_shiftdirtytoclean()
962 #define LFS_SYNC_CLEANERINFO(cip, fs, bp, w) do {		 	\  argument
964     if ((w) || lfs_ci_getbfree(fs, cip) != lfs_sb_getbfree(fs) ||	\
965 	lfs_ci_getavail(fs, cip) != lfs_sb_getavail(fs) - fs->lfs_ravail - \
966 	fs->lfs_favail) {	 					\
967 	lfs_ci_setbfree(fs, cip, lfs_sb_getbfree(fs));		 	\
968 	lfs_ci_setavail(fs, cip, lfs_sb_getavail(fs) - fs->lfs_ravail -	\
969 		fs->lfs_favail);				 	\
971 		fs->lfs_flags |= LFS_IFDIRTY;				\
1025 #define SEGSUM_SIZE(fs) \  argument
1026 	(fs->lfs_is64 ? sizeof(SEGSUM64) : \
1027 	 lfs_sb_getversion(fs) > 1 ? sizeof(SEGSUM32) : sizeof(SEGSUM_V1))
1037 segsum_finfobase(STRUCT_LFS *fs, SEGSUM *ssp)
1039 	return (FINFO *)((char *)ssp + SEGSUM_SIZE(fs));
1042 #define SEGSUM_FINFOBASE(fs, ssp) \  argument
1043 	((FINFO *)((char *)(ssp) + SEGSUM_SIZE(fs)));
1048 	lfs_ss_get##field(STRUCT_LFS *fs, SEGSUM *ssp)		\
1050 		if (fs->lfs_is64) {				\
1057 	lfs_ss_set##field(STRUCT_LFS *fs, SEGSUM *ssp, type val) \
1059 		if (fs->lfs_is64) {				\
1083 lfs_ss_getsumstart(STRUCT_LFS *fs)  in LFS_DEF_SS_ACCESSOR()
1086 	if (fs->lfs_is64) {  in LFS_DEF_SS_ACCESSOR()
1100 lfs_ss_getocreate(STRUCT_LFS *fs, SEGSUM *ssp)  in lfs_ss_getocreate()  argument
1102 	KASSERT(fs->lfs_is64 == 0);  in lfs_ss_getocreate()
1110 lfs_ss_setocreate(STRUCT_LFS *fs, SEGSUM *ssp, uint32_t val)  in lfs_ss_setocreate()  argument
1112 	KASSERT(fs->lfs_is64 == 0);  in lfs_ss_setocreate()
1130 	lfs_sb_get##field(STRUCT_LFS *fs)			\
1132 		if (fs->lfs_is64) {				\
1133 			return fs->lfs_dlfs_u.u_64.dlfs_##field; \
1135 			return fs->lfs_dlfs_u.u_32.dlfs_##field; \
1139 	lfs_sb_set##field(STRUCT_LFS *fs, type val)		\
1141 		if (fs->lfs_is64) {				\
1142 			fs->lfs_dlfs_u.u_64.dlfs_##field = val;	\
1144 			fs->lfs_dlfs_u.u_32.dlfs_##field = val;	\
1148 	lfs_sb_add##field(STRUCT_LFS *fs, type val)		\
1150 		if (fs->lfs_is64) {				\
1151 			type *p64 = &fs->lfs_dlfs_u.u_64.dlfs_##field; \
1154 			type32 *p32 = &fs->lfs_dlfs_u.u_32.dlfs_##field; \
1159 	lfs_sb_sub##field(STRUCT_LFS *fs, type val)		\
1161 		if (fs->lfs_is64) {				\
1162 			type *p64 = &fs->lfs_dlfs_u.u_64.dlfs_##field; \
1165 			type32 *p32 = &fs->lfs_dlfs_u.u_32.dlfs_##field; \
1174 	lfs_sb_get##field(STRUCT_LFS *fs)			\
1176 		if (fs->lfs_is64) {				\
1179 			return fs->lfs_dlfs_u.u_32.dlfs_##field; \
1246 #define lfs_sb_getotstamp(fs) lfs_sb_getinopf(fs)  in LFS_DEF_SB_ACCESSOR()  argument
1247 #define lfs_sb_setotstamp(fs, val) lfs_sb_setinopf(fs, val)  in LFS_DEF_SB_ACCESSOR()  argument
1253 lfs_sb_getsboff(STRUCT_LFS *fs, unsigned n)  in LFS_DEF_SB_ACCESSOR()
1258 	if (fs->lfs_is64) {  in LFS_DEF_SB_ACCESSOR()
1259 		return fs->lfs_dlfs_u.u_64.dlfs_sboffs[n];  in LFS_DEF_SB_ACCESSOR()
1261 		return fs->lfs_dlfs_u.u_32.dlfs_sboffs[n];  in LFS_DEF_SB_ACCESSOR()
1265 lfs_sb_setsboff(STRUCT_LFS *fs, unsigned n, int32_t val)  in lfs_sb_setsboff()  argument
1270 	if (fs->lfs_is64) {  in lfs_sb_setsboff()
1271 		fs->lfs_dlfs_u.u_64.dlfs_sboffs[n] = val;  in lfs_sb_setsboff()
1273 		fs->lfs_dlfs_u.u_32.dlfs_sboffs[n] = val;  in lfs_sb_setsboff()
1281 lfs_sb_getfsmnt(STRUCT_LFS *fs)  in lfs_sb_getfsmnt()  argument
1283 	if (fs->lfs_is64) {  in lfs_sb_getfsmnt()
1284 		return (const char *)fs->lfs_dlfs_u.u_64.dlfs_fsmnt;  in lfs_sb_getfsmnt()
1286 		return (const char *)fs->lfs_dlfs_u.u_32.dlfs_fsmnt;  in lfs_sb_getfsmnt()
1291 lfs_sb_setfsmnt(STRUCT_LFS *fs, const char *str)  in lfs_sb_setfsmnt()  argument
1293 	if (fs->lfs_is64) {  in lfs_sb_setfsmnt()
1294 		(void)strncpy((char *)fs->lfs_dlfs_u.u_64.dlfs_fsmnt, str,  in lfs_sb_setfsmnt()
1295 			sizeof(fs->lfs_dlfs_u.u_64.dlfs_fsmnt));  in lfs_sb_setfsmnt()
1297 		(void)strncpy((char *)fs->lfs_dlfs_u.u_32.dlfs_fsmnt, str,  in lfs_sb_setfsmnt()
1298 			sizeof(fs->lfs_dlfs_u.u_32.dlfs_fsmnt));  in lfs_sb_setfsmnt()
1303 #define LFS_MAX_DADDR(fs) \  argument
1304 	((fs)->lfs_is64 ? 0x7fffffffffffffff : 0x7fffffff)
1307 #define	LFS_NINDIR(fs)	(lfs_sb_getnindir(fs))  argument
1310 #define	LFS_INOPB(fs)	(lfs_sb_getinopb(fs))  argument
1312 #define LFS_INOPF(fs)	(lfs_sb_getinopf(fs))  argument
1314 #define	lfs_blkoff(fs, loc)	((int)((loc) & lfs_sb_getbmask(fs)))  argument
1315 #define lfs_fragoff(fs, loc)    /* calculates (loc % fs->lfs_fsize) */ \  argument
1316     ((int)((loc) & lfs_sb_getffmask(fs)))
1321 LFS_FSBTODB(STRUCT_LFS *fs, uint64_t b)  in LFS_FSBTODB()  argument
1324 	return b << (lfs_sb_getffshift(fs) - DEV_BSHIFT);  in LFS_FSBTODB()
1326 	return b << lfs_sb_getfsbtodb(fs);  in LFS_FSBTODB()
1331 LFS_DBTOFSB(STRUCT_LFS *fs, uint64_t b)  in LFS_DBTOFSB()  argument
1334 	return b >> (lfs_sb_getffshift(fs) - DEV_BSHIFT);  in LFS_DBTOFSB()
1336 	return b >> lfs_sb_getfsbtodb(fs);  in LFS_DBTOFSB()
1340 #define	lfs_lblkno(fs, loc)	((loc) >> lfs_sb_getbshift(fs))  argument
1341 #define	lfs_lblktosize(fs, blk)	((blk) << lfs_sb_getbshift(fs))  argument
1345 lfs_fsbtob(STRUCT_LFS *fs, uint64_t b)  in lfs_fsbtob()  argument
1347 	return b << lfs_sb_getffshift(fs);  in lfs_fsbtob()
1351 lfs_btofsb(STRUCT_LFS *fs, uint64_t b)  in lfs_btofsb()  argument
1353 	return b >> lfs_sb_getffshift(fs);  in lfs_btofsb()
1356 #define lfs_numfrags(fs, loc)	/* calculates (loc / fs->lfs_fsize) */	\  argument
1357 	((loc) >> lfs_sb_getffshift(fs))
1358 #define lfs_blkroundup(fs, size)/* calculates roundup(size, lfs_sb_getbsize(fs)) */ \  argument
1359 	((off_t)(((size) + lfs_sb_getbmask(fs)) & (~lfs_sb_getbmask(fs))))
1360 #define lfs_fragroundup(fs, size)/* calculates roundup(size, fs->lfs_fsize) */ \  argument
1361 	((off_t)(((size) + lfs_sb_getffmask(fs)) & (~lfs_sb_getffmask(fs))))
1362 #define lfs_fragstoblks(fs, frags)/* calculates (frags / fs->fs_frag) */ \  argument
1363 	((frags) >> lfs_sb_getfbshift(fs))
1364 #define lfs_blkstofrags(fs, blks)/* calculates (blks * fs->fs_frag) */ \  argument
1365 	((blks) << lfs_sb_getfbshift(fs))
1366 #define lfs_fragnum(fs, fsb)	/* calculates (fsb % fs->lfs_frag) */	\  argument
1367 	((fsb) & ((fs)->lfs_frag - 1))
1368 #define lfs_blknum(fs, fsb)	/* calculates rounddown(fsb, fs->lfs_frag) */ \  argument
1369 	((fsb) &~ ((fs)->lfs_frag - 1))
1370 #define lfs_dblksize(fs, dp, lbn) \  argument
1371 	(((lbn) >= ULFS_NDADDR || lfs_dino_getsize(fs, dp) >= ((lbn) + 1) << lfs_sb_getbshift(fs)) \
1372 	    ? lfs_sb_getbsize(fs) \
1373 	    : (lfs_fragroundup(fs, lfs_blkoff(fs, lfs_dino_getsize(fs, dp)))))
1375 #define	lfs_segsize(fs)	(lfs_sb_getversion(fs) == 1 ?	     		\  argument
1376 			   lfs_lblktosize((fs), lfs_sb_getssize(fs)) :	\
1377 			   lfs_sb_getssize(fs))
1379 #define lfs_segtod(fs, seg) (lfs_btofsb(fs, lfs_segsize(fs)) * (seg))  argument
1380 #define	lfs_dtosn(fs, daddr)	/* block address to segment number */	\  argument
1381 	((uint32_t)(((daddr) - lfs_sb_gets0addr(fs)) / lfs_segtod((fs), 1)))
1382 #define lfs_sntod(fs, sn)	/* segment number to disk address */	\  argument
1383 	((daddr_t)(lfs_segtod((fs), (sn)) + lfs_sb_gets0addr(fs)))
1388 lfs_blksize(STRUCT_LFS *fs, struct inode *ip, uint64_t lbn)  in lfs_blksize()  argument
1390 	if (lbn >= ULFS_NDADDR || lfs_dino_getsize(fs, ip->i_din) >= (lbn + 1) << lfs_sb_getbshift(fs)) {  in lfs_blksize()
1391 		return lfs_sb_getbsize(fs);  in lfs_blksize()
1393 		return lfs_fragroundup(fs, lfs_blkoff(fs, lfs_dino_getsize(fs, ip->i_din)));  in lfs_blksize()
1403 lfs_blocks_fromvoid(STRUCT_LFS *fs, union lfs_blocks *bp, void *p)  in lfs_blocks_fromvoid()  argument
1405 	if (fs->lfs_is64) {  in lfs_blocks_fromvoid()
1413 lfs_blocks_fromfinfo(STRUCT_LFS *fs, union lfs_blocks *bp, FINFO *fip)  in lfs_blocks_fromfinfo()  argument
1417 	firstblock = (char *)fip + FINFOSIZE(fs);  in lfs_blocks_fromfinfo()
1418 	if (fs->lfs_is64) {  in lfs_blocks_fromfinfo()
1426 lfs_blocks_get(STRUCT_LFS *fs, union lfs_blocks *bp, unsigned idx)  in lfs_blocks_get()  argument
1428 	if (fs->lfs_is64) {  in lfs_blocks_get()
1436 lfs_blocks_set(STRUCT_LFS *fs, union lfs_blocks *bp, unsigned idx, daddr_t val)  in lfs_blocks_set()  argument
1438 	if (fs->lfs_is64) {  in lfs_blocks_set()
1446 lfs_blocks_inc(STRUCT_LFS *fs, union lfs_blocks *bp)  in lfs_blocks_inc()  argument
1448 	if (fs->lfs_is64) {  in lfs_blocks_inc()
1456 lfs_blocks_eq(STRUCT_LFS *fs, union lfs_blocks *bp1, union lfs_blocks *bp2)  in lfs_blocks_eq()  argument
1458 	if (fs->lfs_is64) {  in lfs_blocks_eq()
1466 lfs_blocks_sub(STRUCT_LFS *fs, union lfs_blocks *bp1, union lfs_blocks *bp2)  in lfs_blocks_sub()  argument
1469 	if (fs->lfs_is64) {  in lfs_blocks_sub()