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