1/*
2 * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17 */
18#ifndef __XFS_ARCH_H__
19#define __XFS_ARCH_H__
20
21#ifndef XFS_BIG_INUMS
22# error XFS_BIG_INUMS must be defined true or false
23#endif
24
25#include <sys/endian.h>
26
27#define	__LITTLE_ENDIAN	_LITTLE_ENDIAN
28#define	__BIG_ENDIAN	_BIG_ENDIAN
29#define	__BYTE_ORDER	_BYTE_ORDER
30#define __user
31/* Compatibiliy defines */
32#define	__swab16	__bswap16
33#define	__swab32	__bswap32
34#define	__swab64	__bswap64
35
36#define ARCH_NOCONVERT 1
37#if _BYTE_ORDER != _LITTLE_ENDIAN
38#define	XFS_NATIVE_HOST	1
39# define ARCH_CONVERT	ARCH_NOCONVERT
40#else
41#undef XFS_NATIVE_HOST
42#define ARCH_CONVERT	0
43#endif
44
45
46#ifdef XFS_NATIVE_HOST
47#define cpu_to_be16(val)	((__be16)(val))
48#define cpu_to_be32(val)	((__be32)(val))
49#define cpu_to_be64(val)	((__be64)(val))
50#define be16_to_cpu(val)	((__uint16_t)(val))
51#define be32_to_cpu(val)	((__uint32_t)(val))
52#define be64_to_cpu(val)	((__uint64_t)(val))
53#else
54#define cpu_to_be16(val)	(__swab16((__uint16_t)(val)))
55#define cpu_to_be32(val)	(__swab32((__uint32_t)(val)))
56#define cpu_to_be64(val)	(__swab64((__uint64_t)(val)))
57#define be16_to_cpu(val)	(__swab16((__be16)(val)))
58#define be32_to_cpu(val)	(__swab32((__be32)(val)))
59#define be64_to_cpu(val)	(__swab64((__be64)(val)))
60#endif
61
62//#endif	/* __KERNEL__ */
63
64/* do we need conversion? */
65//#define ARCH_NOCONVERT 1
66//#ifdef XFS_NATIVE_HOST
67//# define ARCH_CONVERT	ARCH_NOCONVERT
68//#else
69//# define ARCH_CONVERT	0
70//#endif
71
72/* generic swapping macros */
73
74#ifndef HAVE_SWABMACROS
75#define INT_SWAP16(type,var) ((typeof(type))(__swab16((__u16)(var))))
76#define INT_SWAP32(type,var) ((typeof(type))(__swab32((__u32)(var))))
77#define INT_SWAP64(type,var) ((typeof(type))(__swab64((__u64)(var))))
78#endif
79
80#define INT_SWAP(type, var) \
81    ((sizeof(type) == 8) ? INT_SWAP64(type,var) : \
82    ((sizeof(type) == 4) ? INT_SWAP32(type,var) : \
83    ((sizeof(type) == 2) ? INT_SWAP16(type,var) : \
84    (var))))
85
86/*
87 * get and set integers from potentially unaligned locations
88 */
89
90#define INT_GET_UNALIGNED_16_BE(pointer) \
91   ((__u16)((((__u8*)(pointer))[0] << 8) | (((__u8*)(pointer))[1])))
92#define INT_SET_UNALIGNED_16_BE(pointer,value) \
93    { \
94	((__u8*)(pointer))[0] = (((value) >> 8) & 0xff); \
95	((__u8*)(pointer))[1] = (((value)     ) & 0xff); \
96    }
97
98/* define generic INT_ macros */
99
100#define INT_GET(reference,arch) \
101    (((arch) == ARCH_NOCONVERT) \
102	? \
103	    (reference) \
104	: \
105	    INT_SWAP((reference),(reference)) \
106    )
107
108/* does not return a value */
109#define INT_SET(reference,arch,valueref) \
110    (__builtin_constant_p(valueref) ? \
111	(void)( (reference) = ( ((arch) != ARCH_NOCONVERT) ? (INT_SWAP((reference),(valueref))) : (valueref)) ) : \
112	(void)( \
113	    ((reference) = (valueref)), \
114	    ( ((arch) != ARCH_NOCONVERT) ? (reference) = INT_SWAP((reference),(reference)) : 0 ) \
115	) \
116    )
117
118/* does not return a value */
119#define INT_MOD_EXPR(reference,arch,code) \
120    (((arch) == ARCH_NOCONVERT) \
121	? \
122	    (void)((reference) code) \
123	: \
124	    (void)( \
125		(reference) = INT_GET((reference),arch) , \
126		((reference) code), \
127		INT_SET(reference, arch, reference) \
128	    ) \
129    )
130
131/* does not return a value */
132#define INT_MOD(reference,arch,delta) \
133    (void)( \
134	INT_MOD_EXPR(reference,arch,+=(delta)) \
135    )
136
137/*
138 * INT_COPY - copy a value between two locations with the
139 *	      _same architecture_ but _potentially different sizes_
140 *
141 *	    if the types of the two parameters are equal or they are
142 *		in native architecture, a simple copy is done
143 *
144 *	    otherwise, architecture conversions are done
145 *
146 */
147
148/* does not return a value */
149#define INT_COPY(dst,src,arch) \
150    ( \
151	((sizeof(dst) == sizeof(src)) || ((arch) == ARCH_NOCONVERT)) \
152	    ? \
153		(void)((dst) = (src)) \
154	    : \
155		INT_SET(dst, arch, INT_GET(src, arch)) \
156    )
157
158/*
159 * INT_XLATE - copy a value in either direction between two locations
160 *	       with different architectures
161 *
162 *		    dir < 0	- copy from memory to buffer (native to arch)
163 *		    dir > 0	- copy from buffer to memory (arch to native)
164 */
165
166/* does not return a value */
167#define INT_XLATE(buf,mem,dir,arch) {\
168    ASSERT(dir); \
169    if (dir>0) { \
170	(mem)=INT_GET(buf, arch); \
171    } else { \
172	INT_SET(buf, arch, mem); \
173    } \
174}
175
176static inline void be16_add(__be16 *a, __s16 b)
177{
178	*a = cpu_to_be16(be16_to_cpu(*a) + b);
179}
180
181static inline void be32_add(__be32 *a, __s32 b)
182{
183	*a = cpu_to_be32(be32_to_cpu(*a) + b);
184}
185
186static inline void be64_add(__be64 *a, __s64 b)
187{
188	*a = cpu_to_be64(be64_to_cpu(*a) + b);
189}
190
191/*
192 * In directories inode numbers are stored as unaligned arrays of unsigned
193 * 8bit integers on disk.
194 *
195 * For v1 directories or v2 directories that contain inode numbers that
196 * do not fit into 32bit the array has eight members, but the first member
197 * is always zero:
198 *
199 *  |unused|48-55|40-47|32-39|24-31|16-23| 8-15| 0- 7|
200 *
201 * For v2 directories that only contain entries with inode numbers that fit
202 * into 32bits a four-member array is used:
203 *
204 *  |24-31|16-23| 8-15| 0- 7|
205 */
206
207#define XFS_GET_DIR_INO4(di) \
208	(((__u32)(di).i[0] << 24) | ((di).i[1] << 16) | ((di).i[2] << 8) | ((di).i[3]))
209
210#define XFS_PUT_DIR_INO4(from, di) \
211do { \
212	(di).i[0] = (((from) & 0xff000000ULL) >> 24); \
213	(di).i[1] = (((from) & 0x00ff0000ULL) >> 16); \
214	(di).i[2] = (((from) & 0x0000ff00ULL) >> 8); \
215	(di).i[3] = ((from) & 0x000000ffULL); \
216} while (0)
217
218#define XFS_DI_HI(di) \
219	(((__u32)(di).i[1] << 16) | ((di).i[2] << 8) | ((di).i[3]))
220#define XFS_DI_LO(di) \
221	(((__u32)(di).i[4] << 24) | ((di).i[5] << 16) | ((di).i[6] << 8) | ((di).i[7]))
222
223#define XFS_GET_DIR_INO8(di)        \
224	(((xfs_ino_t)XFS_DI_LO(di) & 0xffffffffULL) | \
225	 ((xfs_ino_t)XFS_DI_HI(di) << 32))
226
227#define XFS_PUT_DIR_INO8(from, di) \
228do { \
229	(di).i[0] = 0; \
230	(di).i[1] = (((from) & 0x00ff000000000000ULL) >> 48); \
231	(di).i[2] = (((from) & 0x0000ff0000000000ULL) >> 40); \
232	(di).i[3] = (((from) & 0x000000ff00000000ULL) >> 32); \
233	(di).i[4] = (((from) & 0x00000000ff000000ULL) >> 24); \
234	(di).i[5] = (((from) & 0x0000000000ff0000ULL) >> 16); \
235	(di).i[6] = (((from) & 0x000000000000ff00ULL) >> 8); \
236	(di).i[7] = ((from) & 0x00000000000000ffULL); \
237} while (0)
238
239#endif	/* __XFS_ARCH_H__ */
240