xfs: use generic get_unaligned_beXX helpers (218106a1) · Commits · e / devices / android_kernel_oneplus_sm7250

fs/xfs/linux-2.6/xfs_linux.h

+6 −1

Original line number	Original line	Diff line number	Diff line
	@@ -33,7 +33,6 @@
	#endif		#endif

	#include <xfs_types.h>		#include <xfs_types.h>
	#include <xfs_arch.h>

	#include <kmem.h>		#include <kmem.h>
	#include <mrlock.h>		#include <mrlock.h>
	@@ -88,6 +87,12 @@
	#include <xfs_buf.h>		#include <xfs_buf.h>
	#include <xfs_message.h>		#include <xfs_message.h>

			#ifdef __BIG_ENDIAN
			#define XFS_NATIVE_HOST 1
			#else
			#undef XFS_NATIVE_HOST
			#endif

	/*		/*
	* Feature macros (disable/enable)		* Feature macros (disable/enable)
	*/		*/

fs/xfs/xfs_arch.h

deleted100644 → 0

+0 −136

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
	* All Rights Reserved.
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License as
	* published by the Free Software Foundation.
	*
	* This program is distributed in the hope that it would be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*/
	#ifndef __XFS_ARCH_H__
	#define __XFS_ARCH_H__

	#ifndef XFS_BIG_INUMS
	# error XFS_BIG_INUMS must be defined true or false
	#endif

	#ifdef __KERNEL__

	#include <asm/byteorder.h>

	#ifdef __BIG_ENDIAN
	#define XFS_NATIVE_HOST 1
	#else
	#undef XFS_NATIVE_HOST
	#endif

	#else /* __KERNEL__ */

	#if __BYTE_ORDER == __BIG_ENDIAN
	#define XFS_NATIVE_HOST 1
	#else
	#undef XFS_NATIVE_HOST
	#endif

	#ifdef XFS_NATIVE_HOST
	#define cpu_to_be16(val) ((__force __be16)(__u16)(val))
	#define cpu_to_be32(val) ((__force __be32)(__u32)(val))
	#define cpu_to_be64(val) ((__force __be64)(__u64)(val))
	#define be16_to_cpu(val) ((__force __u16)(__be16)(val))
	#define be32_to_cpu(val) ((__force __u32)(__be32)(val))
	#define be64_to_cpu(val) ((__force __u64)(__be64)(val))
	#else
	#define cpu_to_be16(val) ((__force __be16)__swab16((__u16)(val)))
	#define cpu_to_be32(val) ((__force __be32)__swab32((__u32)(val)))
	#define cpu_to_be64(val) ((__force __be64)__swab64((__u64)(val)))
	#define be16_to_cpu(val) (__swab16((__force __u16)(__be16)(val)))
	#define be32_to_cpu(val) (__swab32((__force __u32)(__be32)(val)))
	#define be64_to_cpu(val) (__swab64((__force __u64)(__be64)(val)))
	#endif

	static inline void be16_add_cpu(__be16 *a, __s16 b)
	{
	a = cpu_to_be16(be16_to_cpu(a) + b);
	}

	static inline void be32_add_cpu(__be32 *a, __s32 b)
	{
	a = cpu_to_be32(be32_to_cpu(a) + b);
	}

	static inline void be64_add_cpu(__be64 *a, __s64 b)
	{
	a = cpu_to_be64(be64_to_cpu(a) + b);
	}

	#endif /* __KERNEL__ */

	/*
	* get and set integers from potentially unaligned locations
	*/

	#define INT_GET_UNALIGNED_16_BE(pointer) \
	((__u16)((((__u8)(pointer))[0] << 8) \| (((__u8)(pointer))[1])))
	#define INT_SET_UNALIGNED_16_BE(pointer,value) \
	{ \
	((__u8*)(pointer))[0] = (((value) >> 8) & 0xff); \
	((__u8*)(pointer))[1] = (((value) ) & 0xff); \
	}

	/*
	* In directories inode numbers are stored as unaligned arrays of unsigned
	* 8bit integers on disk.
	*
	* For v1 directories or v2 directories that contain inode numbers that
	* do not fit into 32bit the array has eight members, but the first member
	* is always zero:
	*
	* \|unused\|48-55\|40-47\|32-39\|24-31\|16-23\| 8-15\| 0- 7\|
	*
	* For v2 directories that only contain entries with inode numbers that fit
	* into 32bits a four-member array is used:
	*
	* \|24-31\|16-23\| 8-15\| 0- 7\|
	*/

	#define XFS_GET_DIR_INO4(di) \
	(((__u32)(di).i[0] << 24) \| ((di).i[1] << 16) \| ((di).i[2] << 8) \| ((di).i[3]))

	#define XFS_PUT_DIR_INO4(from, di) \
	do { \
	(di).i[0] = (((from) & 0xff000000ULL) >> 24); \
	(di).i[1] = (((from) & 0x00ff0000ULL) >> 16); \
	(di).i[2] = (((from) & 0x0000ff00ULL) >> 8); \
	(di).i[3] = ((from) & 0x000000ffULL); \
	} while (0)

	#define XFS_DI_HI(di) \
	(((__u32)(di).i[1] << 16) \| ((di).i[2] << 8) \| ((di).i[3]))
	#define XFS_DI_LO(di) \
	(((__u32)(di).i[4] << 24) \| ((di).i[5] << 16) \| ((di).i[6] << 8) \| ((di).i[7]))

	#define XFS_GET_DIR_INO8(di) \
	(((xfs_ino_t)XFS_DI_LO(di) & 0xffffffffULL) \| \
	((xfs_ino_t)XFS_DI_HI(di) << 32))

	#define XFS_PUT_DIR_INO8(from, di) \
	do { \
	(di).i[0] = 0; \
	(di).i[1] = (((from) & 0x00ff000000000000ULL) >> 48); \
	(di).i[2] = (((from) & 0x0000ff0000000000ULL) >> 40); \
	(di).i[3] = (((from) & 0x000000ff00000000ULL) >> 32); \
	(di).i[4] = (((from) & 0x00000000ff000000ULL) >> 24); \
	(di).i[5] = (((from) & 0x0000000000ff0000ULL) >> 16); \
	(di).i[6] = (((from) & 0x000000000000ff00ULL) >> 8); \
	(di).i[7] = ((from) & 0x00000000000000ffULL); \
	} while (0)

	#endif /* __XFS_ARCH_H__ */

fs/xfs/xfs_dir2_sf.c

+8 −5

Original line number	Original line	Diff line number	Diff line
	@@ -59,11 +59,12 @@ static void xfs_dir2_sf_toino4(xfs_da_args_t *args);
	static void xfs_dir2_sf_toino8(xfs_da_args_t *args);		static void xfs_dir2_sf_toino8(xfs_da_args_t *args);
	#endif /* XFS_BIG_INUMS */		#endif /* XFS_BIG_INUMS */


	/*		/*
	* Inode numbers in short-form directories can come in two versions,		* Inode numbers in short-form directories can come in two versions,
	* either 4 bytes or 8 bytes wide. These helpers deal with the		* either 4 bytes or 8 bytes wide. These helpers deal with the
	* two forms transparently by looking at the headers i8count field.		* two forms transparently by looking at the headers i8count field.
			*
			* For 64-bit inode number the most significant byte must be zero.
	*/		*/
	static xfs_ino_t		static xfs_ino_t
	xfs_dir2_sf_get_ino(		xfs_dir2_sf_get_ino(
	@@ -71,9 +72,9 @@ xfs_dir2_sf_get_ino(
	xfs_dir2_inou_t *from)		xfs_dir2_inou_t *from)
	{		{
	if (hdr->i8count)		if (hdr->i8count)
	return XFS_GET_DIR_INO8(from->i8);		return get_unaligned_be64(&from->i8.i) & 0x00ffffffffffffffULL;
	else		else
	return XFS_GET_DIR_INO4(from->i4);		return get_unaligned_be32(&from->i4.i);
	}		}

	static void		static void
	@@ -82,10 +83,12 @@ xfs_dir2_sf_put_ino(
	xfs_dir2_inou_t *to,		xfs_dir2_inou_t *to,
	xfs_ino_t ino)		xfs_ino_t ino)
	{		{
			ASSERT((ino & 0xff00000000000000ULL) == 0);

	if (hdr->i8count)		if (hdr->i8count)
	XFS_PUT_DIR_INO8(ino, to->i8);		put_unaligned_be64(ino, &to->i8.i);
	else		else
	XFS_PUT_DIR_INO4(ino, to->i4);		put_unaligned_be32(ino, &to->i4.i);
	}		}

	xfs_ino_t		xfs_ino_t

fs/xfs/xfs_dir2_sf.h

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -95,13 +95,13 @@ static inline int xfs_dir2_sf_hdr_size(int i8count)
	static inline xfs_dir2_data_aoff_t		static inline xfs_dir2_data_aoff_t
	xfs_dir2_sf_get_offset(xfs_dir2_sf_entry_t *sfep)		xfs_dir2_sf_get_offset(xfs_dir2_sf_entry_t *sfep)
	{		{
	return INT_GET_UNALIGNED_16_BE(&(sfep)->offset.i);		return get_unaligned_be16(&sfep->offset.i);
	}		}

	static inline void		static inline void
	xfs_dir2_sf_put_offset(xfs_dir2_sf_entry_t *sfep, xfs_dir2_data_aoff_t off)		xfs_dir2_sf_put_offset(xfs_dir2_sf_entry_t *sfep, xfs_dir2_data_aoff_t off)
	{		{
	INT_SET_UNALIGNED_16_BE(&(sfep)->offset.i, off);		put_unaligned_be16(off, &sfep->offset.i);
	}		}

	static inline int		static inline int