paul@181 | 1 | /* |
paul@181 | 2 | * probe.h - constants and on-disk structures for extracting device data |
paul@181 | 3 | * |
paul@181 | 4 | * Copyright (C) 1999 by Andries Brouwer |
paul@181 | 5 | * Copyright (C) 1999, 2000, 2003 by Theodore Ts'o |
paul@181 | 6 | * Copyright (C) 2001 by Andreas Dilger |
paul@181 | 7 | * |
paul@181 | 8 | * %Begin-Header% |
paul@181 | 9 | * This file may be redistributed under the terms of the |
paul@181 | 10 | * GNU Lesser General Public License. |
paul@181 | 11 | * %End-Header% |
paul@181 | 12 | */ |
paul@181 | 13 | |
paul@181 | 14 | #ifndef _BLKID_PROBE_H |
paul@181 | 15 | #define _BLKID_PROBE_H |
paul@181 | 16 | |
paul@181 | 17 | #include <stdint.h> |
paul@181 | 18 | |
paul@181 | 19 | #include <blkid/blkid_types.h> |
paul@181 | 20 | |
paul@181 | 21 | struct blkid_magic; |
paul@181 | 22 | |
paul@181 | 23 | #define SB_BUFFER_SIZE 0x11000 |
paul@181 | 24 | |
paul@181 | 25 | struct blkid_probe { |
paul@181 | 26 | int fd; |
paul@181 | 27 | blkid_cache cache; |
paul@181 | 28 | blkid_dev dev; |
paul@181 | 29 | unsigned char *sbbuf; |
paul@181 | 30 | size_t sb_valid; |
paul@181 | 31 | unsigned char *buf; |
paul@181 | 32 | size_t buf_max; |
paul@181 | 33 | }; |
paul@181 | 34 | |
paul@181 | 35 | typedef int (*blkid_probe_t)(struct blkid_probe *probe, |
paul@181 | 36 | struct blkid_magic *id, unsigned char *buf); |
paul@181 | 37 | |
paul@181 | 38 | struct blkid_magic { |
paul@181 | 39 | const char *bim_type; /* type name for this magic */ |
paul@181 | 40 | long bim_kboff; /* kilobyte offset of superblock */ |
paul@181 | 41 | unsigned bim_sboff; /* byte offset within superblock */ |
paul@181 | 42 | unsigned bim_len; /* length of magic */ |
paul@181 | 43 | const char *bim_magic; /* magic string */ |
paul@181 | 44 | blkid_probe_t bim_probe; /* probe function */ |
paul@181 | 45 | }; |
paul@181 | 46 | |
paul@181 | 47 | /* |
paul@181 | 48 | * Structures for each of the content types we want to extract information |
paul@181 | 49 | * from. We do not necessarily need the magic field here, because we have |
paul@181 | 50 | * already identified the content type before we get this far. It may still |
paul@181 | 51 | * be useful if there are probe functions which handle multiple content types. |
paul@181 | 52 | */ |
paul@181 | 53 | struct ext2_super_block { |
paul@181 | 54 | __u32 s_inodes_count; |
paul@181 | 55 | __u32 s_blocks_count; |
paul@181 | 56 | __u32 s_r_blocks_count; |
paul@181 | 57 | __u32 s_free_blocks_count; |
paul@181 | 58 | __u32 s_free_inodes_count; |
paul@181 | 59 | __u32 s_first_data_block; |
paul@181 | 60 | __u32 s_log_block_size; |
paul@181 | 61 | __u32 s_dummy3[7]; |
paul@181 | 62 | unsigned char s_magic[2]; |
paul@181 | 63 | __u16 s_state; |
paul@181 | 64 | __u32 s_dummy5[8]; |
paul@181 | 65 | __u32 s_feature_compat; |
paul@181 | 66 | __u32 s_feature_incompat; |
paul@181 | 67 | __u32 s_feature_ro_compat; |
paul@181 | 68 | unsigned char s_uuid[16]; |
paul@181 | 69 | char s_volume_name[16]; |
paul@181 | 70 | char s_last_mounted[64]; |
paul@181 | 71 | __u32 s_algorithm_usage_bitmap; |
paul@181 | 72 | __u8 s_prealloc_blocks; |
paul@181 | 73 | __u8 s_prealloc_dir_blocks; |
paul@181 | 74 | __u16 s_reserved_gdt_blocks; |
paul@181 | 75 | __u8 s_journal_uuid[16]; |
paul@181 | 76 | __u32 s_journal_inum; |
paul@181 | 77 | __u32 s_journal_dev; |
paul@181 | 78 | __u32 s_last_orphan; |
paul@181 | 79 | __u32 s_hash_seed[4]; |
paul@181 | 80 | __u8 s_def_hash_version; |
paul@181 | 81 | __u8 s_jnl_backup_type; |
paul@181 | 82 | __u16 s_reserved_word_pad; |
paul@181 | 83 | __u32 s_default_mount_opts; |
paul@181 | 84 | __u32 s_first_meta_bg; |
paul@181 | 85 | __u32 s_mkfs_time; |
paul@181 | 86 | __u32 s_jnl_blocks[17]; |
paul@181 | 87 | __u32 s_blocks_count_hi; |
paul@181 | 88 | __u32 s_r_blocks_count_hi; |
paul@181 | 89 | __u32 s_free_blocks_hi; |
paul@181 | 90 | __u16 s_min_extra_isize; |
paul@181 | 91 | __u16 s_want_extra_isize; |
paul@181 | 92 | __u32 s_flags; |
paul@181 | 93 | __u16 s_raid_stride; |
paul@181 | 94 | __u16 s_mmp_interval; |
paul@181 | 95 | __u64 s_mmp_block; |
paul@181 | 96 | __u32 s_raid_stripe_width; |
paul@181 | 97 | __u32 s_reserved[163]; |
paul@181 | 98 | }; |
paul@181 | 99 | |
paul@181 | 100 | /* for s_flags */ |
paul@181 | 101 | #define EXT2_FLAGS_TEST_FILESYS 0x0004 |
paul@181 | 102 | |
paul@181 | 103 | /* for s_feature_compat */ |
paul@181 | 104 | #define EXT3_FEATURE_COMPAT_HAS_JOURNAL 0x0004 |
paul@181 | 105 | |
paul@181 | 106 | /* for s_feature_ro_compat */ |
paul@181 | 107 | #define EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER 0x0001 |
paul@181 | 108 | #define EXT2_FEATURE_RO_COMPAT_LARGE_FILE 0x0002 |
paul@181 | 109 | #define EXT2_FEATURE_RO_COMPAT_BTREE_DIR 0x0004 |
paul@181 | 110 | #define EXT4_FEATURE_RO_COMPAT_HUGE_FILE 0x0008 |
paul@181 | 111 | #define EXT4_FEATURE_RO_COMPAT_GDT_CSUM 0x0010 |
paul@181 | 112 | #define EXT4_FEATURE_RO_COMPAT_DIR_NLINK 0x0020 |
paul@181 | 113 | #define EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE 0x0040 |
paul@181 | 114 | #define EXT4_FEATURE_RO_COMPAT_QUOTA 0x0100 |
paul@181 | 115 | #define EXT4_FEATURE_RO_COMPAT_METADATA_CSUM 0x0400 |
paul@181 | 116 | |
paul@181 | 117 | /* for s_feature_incompat */ |
paul@181 | 118 | #define EXT2_FEATURE_INCOMPAT_FILETYPE 0x0002 |
paul@181 | 119 | #define EXT3_FEATURE_INCOMPAT_RECOVER 0x0004 |
paul@181 | 120 | #define EXT3_FEATURE_INCOMPAT_JOURNAL_DEV 0x0008 |
paul@181 | 121 | #define EXT2_FEATURE_INCOMPAT_META_BG 0x0010 |
paul@181 | 122 | #define EXT4_FEATURE_INCOMPAT_EXTENTS 0x0040 /* extents support */ |
paul@181 | 123 | #define EXT4_FEATURE_INCOMPAT_64BIT 0x0080 |
paul@181 | 124 | #define EXT4_FEATURE_INCOMPAT_MMP 0x0100 |
paul@181 | 125 | #define EXT4_FEATURE_INCOMPAT_FLEX_BG 0x0200 |
paul@181 | 126 | |
paul@181 | 127 | #define EXT2_FEATURE_RO_COMPAT_SUPP (EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER| \ |
paul@181 | 128 | EXT2_FEATURE_RO_COMPAT_LARGE_FILE| \ |
paul@181 | 129 | EXT2_FEATURE_RO_COMPAT_BTREE_DIR) |
paul@181 | 130 | #define EXT2_FEATURE_INCOMPAT_SUPP (EXT2_FEATURE_INCOMPAT_FILETYPE| \ |
paul@181 | 131 | EXT2_FEATURE_INCOMPAT_META_BG) |
paul@181 | 132 | #define EXT2_FEATURE_INCOMPAT_UNSUPPORTED ~EXT2_FEATURE_INCOMPAT_SUPP |
paul@181 | 133 | #define EXT2_FEATURE_RO_COMPAT_UNSUPPORTED ~EXT2_FEATURE_RO_COMPAT_SUPP |
paul@181 | 134 | |
paul@181 | 135 | #define EXT3_FEATURE_RO_COMPAT_SUPP (EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER| \ |
paul@181 | 136 | EXT2_FEATURE_RO_COMPAT_LARGE_FILE| \ |
paul@181 | 137 | EXT2_FEATURE_RO_COMPAT_BTREE_DIR) |
paul@181 | 138 | #define EXT3_FEATURE_INCOMPAT_SUPP (EXT2_FEATURE_INCOMPAT_FILETYPE| \ |
paul@181 | 139 | EXT3_FEATURE_INCOMPAT_RECOVER| \ |
paul@181 | 140 | EXT2_FEATURE_INCOMPAT_META_BG) |
paul@181 | 141 | #define EXT3_FEATURE_INCOMPAT_UNSUPPORTED ~EXT3_FEATURE_INCOMPAT_SUPP |
paul@181 | 142 | #define EXT3_FEATURE_RO_COMPAT_UNSUPPORTED ~EXT3_FEATURE_RO_COMPAT_SUPP |
paul@181 | 143 | |
paul@181 | 144 | |
paul@181 | 145 | struct xfs_super_block { |
paul@181 | 146 | unsigned char xs_magic[4]; |
paul@181 | 147 | __u32 xs_blocksize; |
paul@181 | 148 | __u64 xs_dblocks; |
paul@181 | 149 | __u64 xs_rblocks; |
paul@181 | 150 | __u32 xs_dummy1[2]; |
paul@181 | 151 | unsigned char xs_uuid[16]; |
paul@181 | 152 | __u32 xs_dummy2[15]; |
paul@181 | 153 | char xs_fname[12]; |
paul@181 | 154 | __u32 xs_dummy3[2]; |
paul@181 | 155 | __u64 xs_icount; |
paul@181 | 156 | __u64 xs_ifree; |
paul@181 | 157 | __u64 xs_fdblocks; |
paul@181 | 158 | }; |
paul@181 | 159 | |
paul@181 | 160 | struct reiserfs_super_block { |
paul@181 | 161 | __u32 rs_blocks_count; |
paul@181 | 162 | __u32 rs_free_blocks; |
paul@181 | 163 | __u32 rs_root_block; |
paul@181 | 164 | __u32 rs_journal_block; |
paul@181 | 165 | __u32 rs_journal_dev; |
paul@181 | 166 | __u32 rs_orig_journal_size; |
paul@181 | 167 | __u32 rs_dummy2[5]; |
paul@181 | 168 | __u16 rs_blocksize; |
paul@181 | 169 | __u16 rs_dummy3[3]; |
paul@181 | 170 | unsigned char rs_magic[12]; |
paul@181 | 171 | __u32 rs_dummy4[5]; |
paul@181 | 172 | unsigned char rs_uuid[16]; |
paul@181 | 173 | char rs_label[16]; |
paul@181 | 174 | }; |
paul@181 | 175 | |
paul@181 | 176 | struct reiser4_super_block { |
paul@181 | 177 | unsigned char rs4_magic[16]; |
paul@181 | 178 | __u16 rs4_dummy[2]; |
paul@181 | 179 | unsigned char rs4_uuid[16]; |
paul@181 | 180 | unsigned char rs4_label[16]; |
paul@181 | 181 | __u64 rs4_dummy2; |
paul@181 | 182 | }; |
paul@181 | 183 | |
paul@181 | 184 | struct jfs_super_block { |
paul@181 | 185 | unsigned char js_magic[4]; |
paul@181 | 186 | __u32 js_version; |
paul@181 | 187 | __u64 js_size; |
paul@181 | 188 | __u32 js_bsize; /* 4: aggregate block size in bytes */ |
paul@181 | 189 | __u16 js_l2bsize; /* 2: log2 of s_bsize */ |
paul@181 | 190 | __u16 js_l2bfactor; /* 2: log2(s_bsize/hardware block size) */ |
paul@181 | 191 | __u32 js_pbsize; /* 4: hardware/LVM block size in bytes */ |
paul@181 | 192 | __u16 js_l2pbsize; /* 2: log2 of s_pbsize */ |
paul@181 | 193 | __u16 js_pad; /* 2: padding necessary for alignment */ |
paul@181 | 194 | __u32 js_dummy2[26]; |
paul@181 | 195 | unsigned char js_uuid[16]; |
paul@181 | 196 | unsigned char js_label[16]; |
paul@181 | 197 | unsigned char js_loguuid[16]; |
paul@181 | 198 | }; |
paul@181 | 199 | |
paul@181 | 200 | struct romfs_super_block { |
paul@181 | 201 | unsigned char ros_magic[8]; |
paul@181 | 202 | __u32 ros_dummy1[2]; |
paul@181 | 203 | unsigned char ros_volume[16]; |
paul@181 | 204 | }; |
paul@181 | 205 | |
paul@181 | 206 | struct cramfs_super_block { |
paul@181 | 207 | __u8 magic[4]; |
paul@181 | 208 | __u32 size; |
paul@181 | 209 | __u32 flags; |
paul@181 | 210 | __u32 future; |
paul@181 | 211 | __u8 signature[16]; |
paul@181 | 212 | struct cramfs_info { |
paul@181 | 213 | __u32 crc; |
paul@181 | 214 | __u32 edition; |
paul@181 | 215 | __u32 blocks; |
paul@181 | 216 | __u32 files; |
paul@181 | 217 | } info; |
paul@181 | 218 | __u8 name[16]; |
paul@181 | 219 | }; |
paul@181 | 220 | |
paul@181 | 221 | struct swap_id_block { |
paul@181 | 222 | /* unsigned char sws_boot[1024]; */ |
paul@181 | 223 | __u32 sws_version; |
paul@181 | 224 | __u32 sws_lastpage; |
paul@181 | 225 | __u32 sws_nrbad; |
paul@181 | 226 | unsigned char sws_uuid[16]; |
paul@181 | 227 | char sws_volume[16]; |
paul@181 | 228 | unsigned char sws_pad[117]; |
paul@181 | 229 | __u32 sws_badpg; |
paul@181 | 230 | }; |
paul@181 | 231 | |
paul@181 | 232 | /* Yucky misaligned values */ |
paul@181 | 233 | struct vfat_super_block { |
paul@181 | 234 | /* 00*/ unsigned char vs_ignored[3]; |
paul@181 | 235 | /* 03*/ unsigned char vs_sysid[8]; |
paul@181 | 236 | /* 0b*/ unsigned char vs_sector_size[2]; |
paul@181 | 237 | /* 0d*/ __u8 vs_cluster_size; |
paul@181 | 238 | /* 0e*/ __u16 vs_reserved; |
paul@181 | 239 | /* 10*/ __u8 vs_fats; |
paul@181 | 240 | /* 11*/ unsigned char vs_dir_entries[2]; |
paul@181 | 241 | /* 13*/ unsigned char vs_sectors[2]; |
paul@181 | 242 | /* 15*/ unsigned char vs_media; |
paul@181 | 243 | /* 16*/ __u16 vs_fat_length; |
paul@181 | 244 | /* 18*/ __u16 vs_secs_track; |
paul@181 | 245 | /* 1a*/ __u16 vs_heads; |
paul@181 | 246 | /* 1c*/ __u32 vs_hidden; |
paul@181 | 247 | /* 20*/ __u32 vs_total_sect; |
paul@181 | 248 | /* 24*/ __u32 vs_fat32_length; |
paul@181 | 249 | /* 28*/ __u16 vs_flags; |
paul@181 | 250 | /* 2a*/ __u8 vs_version[2]; |
paul@181 | 251 | /* 2c*/ __u32 vs_root_cluster; |
paul@181 | 252 | /* 30*/ __u16 vs_insfo_sector; |
paul@181 | 253 | /* 32*/ __u16 vs_backup_boot; |
paul@181 | 254 | /* 34*/ __u16 vs_reserved2[6]; |
paul@181 | 255 | /* 40*/ unsigned char vs_unknown[3]; |
paul@181 | 256 | /* 43*/ unsigned char vs_serno[4]; |
paul@181 | 257 | /* 47*/ unsigned char vs_label[11]; |
paul@181 | 258 | /* 52*/ unsigned char vs_magic[8]; |
paul@181 | 259 | /* 5a*/ unsigned char vs_dummy2[164]; |
paul@181 | 260 | /*1fe*/ unsigned char vs_pmagic[2]; |
paul@181 | 261 | }; |
paul@181 | 262 | |
paul@181 | 263 | /* Yucky misaligned values */ |
paul@181 | 264 | struct msdos_super_block { |
paul@181 | 265 | /* 00*/ unsigned char ms_ignored[3]; |
paul@181 | 266 | /* 03*/ unsigned char ms_sysid[8]; |
paul@181 | 267 | /* 0b*/ unsigned char ms_sector_size[2]; |
paul@181 | 268 | /* 0d*/ __u8 ms_cluster_size; |
paul@181 | 269 | /* 0e*/ __u16 ms_reserved; |
paul@181 | 270 | /* 10*/ __u8 ms_fats; |
paul@181 | 271 | /* 11*/ unsigned char ms_dir_entries[2]; |
paul@181 | 272 | /* 13*/ unsigned char ms_sectors[2]; |
paul@181 | 273 | /* 15*/ unsigned char ms_media; |
paul@181 | 274 | /* 16*/ __u16 ms_fat_length; |
paul@181 | 275 | /* 18*/ __u16 ms_secs_track; |
paul@181 | 276 | /* 1a*/ __u16 ms_heads; |
paul@181 | 277 | /* 1c*/ __u32 ms_hidden; |
paul@181 | 278 | /* 20*/ __u32 ms_total_sect; |
paul@181 | 279 | /* 24*/ unsigned char ms_unknown[3]; |
paul@181 | 280 | /* 27*/ unsigned char ms_serno[4]; |
paul@181 | 281 | /* 2b*/ unsigned char ms_label[11]; |
paul@181 | 282 | /* 36*/ unsigned char ms_magic[8]; |
paul@181 | 283 | /* 3d*/ unsigned char ms_dummy2[192]; |
paul@181 | 284 | /*1fe*/ unsigned char ms_pmagic[2]; |
paul@181 | 285 | }; |
paul@181 | 286 | |
paul@181 | 287 | struct vfat_dir_entry { |
paul@181 | 288 | __u8 name[11]; |
paul@181 | 289 | __u8 attr; |
paul@181 | 290 | __u16 time_creat; |
paul@181 | 291 | __u16 date_creat; |
paul@181 | 292 | __u16 time_acc; |
paul@181 | 293 | __u16 date_acc; |
paul@181 | 294 | __u16 cluster_high; |
paul@181 | 295 | __u16 time_write; |
paul@181 | 296 | __u16 date_write; |
paul@181 | 297 | __u16 cluster_low; |
paul@181 | 298 | __u32 size; |
paul@181 | 299 | }; |
paul@181 | 300 | |
paul@181 | 301 | /* maximum number of clusters */ |
paul@181 | 302 | #define FAT12_MAX 0xFF4 |
paul@181 | 303 | #define FAT16_MAX 0xFFF4 |
paul@181 | 304 | #define FAT32_MAX 0x0FFFFFF6 |
paul@181 | 305 | |
paul@181 | 306 | struct minix_super_block { |
paul@181 | 307 | __u16 ms_ninodes; |
paul@181 | 308 | __u16 ms_nzones; |
paul@181 | 309 | __u16 ms_imap_blocks; |
paul@181 | 310 | __u16 ms_zmap_blocks; |
paul@181 | 311 | __u16 ms_firstdatazone; |
paul@181 | 312 | __u16 ms_log_zone_size; |
paul@181 | 313 | __u32 ms_max_size; |
paul@181 | 314 | unsigned char ms_magic[2]; |
paul@181 | 315 | __u16 ms_state; |
paul@181 | 316 | __u32 ms_zones; |
paul@181 | 317 | }; |
paul@181 | 318 | |
paul@181 | 319 | struct mdp_superblock_s { |
paul@181 | 320 | __u32 md_magic; |
paul@181 | 321 | __u32 major_version; |
paul@181 | 322 | __u32 minor_version; |
paul@181 | 323 | __u32 patch_version; |
paul@181 | 324 | __u32 gvalid_words; |
paul@181 | 325 | __u32 set_uuid0; |
paul@181 | 326 | __u32 ctime; |
paul@181 | 327 | __u32 level; |
paul@181 | 328 | __u32 size; |
paul@181 | 329 | __u32 nr_disks; |
paul@181 | 330 | __u32 raid_disks; |
paul@181 | 331 | __u32 md_minor; |
paul@181 | 332 | __u32 not_persistent; |
paul@181 | 333 | __u32 set_uuid1; |
paul@181 | 334 | __u32 set_uuid2; |
paul@181 | 335 | __u32 set_uuid3; |
paul@181 | 336 | }; |
paul@181 | 337 | |
paul@181 | 338 | struct hfs_super_block { |
paul@181 | 339 | char h_magic[2]; |
paul@181 | 340 | char h_dummy[18]; |
paul@181 | 341 | __u32 h_blksize; |
paul@181 | 342 | }; |
paul@181 | 343 | |
paul@181 | 344 | struct ocfs_volume_header { |
paul@181 | 345 | unsigned char minor_version[4]; |
paul@181 | 346 | unsigned char major_version[4]; |
paul@181 | 347 | unsigned char signature[128]; |
paul@181 | 348 | char mount[128]; |
paul@181 | 349 | unsigned char mount_len[2]; |
paul@181 | 350 | }; |
paul@181 | 351 | |
paul@181 | 352 | struct ocfs_volume_label { |
paul@181 | 353 | unsigned char disk_lock[48]; |
paul@181 | 354 | char label[64]; |
paul@181 | 355 | unsigned char label_len[2]; |
paul@181 | 356 | unsigned char vol_id[16]; |
paul@181 | 357 | unsigned char vol_id_len[2]; |
paul@181 | 358 | }; |
paul@181 | 359 | |
paul@181 | 360 | #define ocfsmajor(o) ((__u32)o.major_version[0] \ |
paul@181 | 361 | + (((__u32) o.major_version[1]) << 8) \ |
paul@181 | 362 | + (((__u32) o.major_version[2]) << 16) \ |
paul@181 | 363 | + (((__u32) o.major_version[3]) << 24)) |
paul@181 | 364 | #define ocfslabellen(o) ((__u32)o.label_len[0] + (((__u32) o.label_len[1]) << 8)) |
paul@181 | 365 | #define ocfsmountlen(o) ((__u32)o.mount_len[0] + (((__u32) o.mount_len[1])<<8)) |
paul@181 | 366 | |
paul@181 | 367 | #define OCFS_MAGIC "OracleCFS" |
paul@181 | 368 | |
paul@181 | 369 | struct ocfs2_super_block { |
paul@181 | 370 | unsigned char signature[8]; |
paul@181 | 371 | unsigned char s_dummy1[184]; |
paul@181 | 372 | unsigned char s_dummy2[80]; |
paul@181 | 373 | char s_label[64]; |
paul@181 | 374 | unsigned char s_uuid[16]; |
paul@181 | 375 | }; |
paul@181 | 376 | |
paul@181 | 377 | #define OCFS2_MIN_BLOCKSIZE 512 |
paul@181 | 378 | #define OCFS2_MAX_BLOCKSIZE 4096 |
paul@181 | 379 | |
paul@181 | 380 | #define OCFS2_SUPER_BLOCK_BLKNO 2 |
paul@181 | 381 | |
paul@181 | 382 | #define OCFS2_SUPER_BLOCK_SIGNATURE "OCFSV2" |
paul@181 | 383 | |
paul@181 | 384 | struct oracle_asm_disk_label { |
paul@181 | 385 | char dummy[32]; |
paul@181 | 386 | char dl_tag[8]; |
paul@181 | 387 | char dl_id[24]; |
paul@181 | 388 | }; |
paul@181 | 389 | |
paul@181 | 390 | #define ORACLE_ASM_DISK_LABEL_MARKED "ORCLDISK" |
paul@181 | 391 | #define ORACLE_ASM_DISK_LABEL_OFFSET 32 |
paul@181 | 392 | |
paul@181 | 393 | struct iso_volume_descriptor { |
paul@181 | 394 | unsigned char vd_type; |
paul@181 | 395 | unsigned char vd_id[5]; |
paul@181 | 396 | unsigned char vd_version; |
paul@181 | 397 | unsigned char flags; |
paul@181 | 398 | unsigned char system_id[32]; |
paul@181 | 399 | unsigned char volume_id[32]; |
paul@181 | 400 | unsigned char unused[8]; |
paul@181 | 401 | unsigned char space_size[8]; |
paul@181 | 402 | unsigned char escape_sequences[8]; |
paul@181 | 403 | }; |
paul@181 | 404 | |
paul@181 | 405 | /* Common gfs/gfs2 constants: */ |
paul@181 | 406 | #define GFS_MAGIC 0x01161970 |
paul@181 | 407 | #define GFS_DEFAULT_BSIZE 4096 |
paul@181 | 408 | #define GFS_SUPERBLOCK_OFFSET (0x10 * GFS_DEFAULT_BSIZE) |
paul@181 | 409 | #define GFS_METATYPE_SB 1 |
paul@181 | 410 | #define GFS_FORMAT_SB 100 |
paul@181 | 411 | #define GFS_LOCKNAME_LEN 64 |
paul@181 | 412 | |
paul@181 | 413 | /* gfs1 constants: */ |
paul@181 | 414 | #define GFS_FORMAT_FS 1309 |
paul@181 | 415 | #define GFS_FORMAT_MULTI 1401 |
paul@181 | 416 | /* gfs2 constants: */ |
paul@181 | 417 | #define GFS2_FORMAT_FS 1801 |
paul@181 | 418 | #define GFS2_FORMAT_MULTI 1900 |
paul@181 | 419 | |
paul@181 | 420 | struct gfs2_meta_header { |
paul@181 | 421 | __u32 mh_magic; |
paul@181 | 422 | __u32 mh_type; |
paul@181 | 423 | __u64 __pad0; /* Was generation number in gfs1 */ |
paul@181 | 424 | __u32 mh_format; |
paul@181 | 425 | __u32 __pad1; /* Was incarnation number in gfs1 */ |
paul@181 | 426 | }; |
paul@181 | 427 | |
paul@181 | 428 | struct gfs2_inum { |
paul@181 | 429 | __u64 no_formal_ino; |
paul@181 | 430 | __u64 no_addr; |
paul@181 | 431 | }; |
paul@181 | 432 | |
paul@181 | 433 | struct gfs2_sb { |
paul@181 | 434 | struct gfs2_meta_header sb_header; |
paul@181 | 435 | |
paul@181 | 436 | __u32 sb_fs_format; |
paul@181 | 437 | __u32 sb_multihost_format; |
paul@181 | 438 | __u32 __pad0; /* Was superblock flags in gfs1 */ |
paul@181 | 439 | |
paul@181 | 440 | __u32 sb_bsize; |
paul@181 | 441 | __u32 sb_bsize_shift; |
paul@181 | 442 | __u32 __pad1; /* Was journal segment size in gfs1 */ |
paul@181 | 443 | |
paul@181 | 444 | struct gfs2_inum sb_master_dir; /* Was jindex dinode in gfs1 */ |
paul@181 | 445 | struct gfs2_inum __pad2; /* Was rindex dinode in gfs1 */ |
paul@181 | 446 | struct gfs2_inum sb_root_dir; |
paul@181 | 447 | |
paul@181 | 448 | char sb_lockproto[GFS_LOCKNAME_LEN]; |
paul@181 | 449 | char sb_locktable[GFS_LOCKNAME_LEN]; |
paul@181 | 450 | /* In gfs1, quota and license dinodes followed */ |
paul@181 | 451 | }; |
paul@181 | 452 | |
paul@181 | 453 | struct ntfs_super_block { |
paul@181 | 454 | __u8 jump[3]; |
paul@181 | 455 | __u8 oem_id[8]; |
paul@181 | 456 | __u8 bios_parameter_block[25]; |
paul@181 | 457 | __u16 unused[2]; |
paul@181 | 458 | __u64 number_of_sectors; |
paul@181 | 459 | __u64 mft_cluster_location; |
paul@181 | 460 | __u64 mft_mirror_cluster_location; |
paul@181 | 461 | __s8 cluster_per_mft_record; |
paul@181 | 462 | __u8 reserved1[3]; |
paul@181 | 463 | __s8 cluster_per_index_record; |
paul@181 | 464 | __u8 reserved2[3]; |
paul@181 | 465 | __u64 volume_serial; |
paul@181 | 466 | __u16 checksum; |
paul@181 | 467 | }; |
paul@181 | 468 | |
paul@181 | 469 | struct master_file_table_record { |
paul@181 | 470 | __u32 magic; |
paul@181 | 471 | __u16 usa_ofs; |
paul@181 | 472 | __u16 usa_count; |
paul@181 | 473 | __u64 lsn; |
paul@181 | 474 | __u16 sequence_number; |
paul@181 | 475 | __u16 link_count; |
paul@181 | 476 | __u16 attrs_offset; |
paul@181 | 477 | __u16 flags; |
paul@181 | 478 | __u32 bytes_in_use; |
paul@181 | 479 | __u32 bytes_allocated; |
paul@181 | 480 | } __attribute__((__packed__)); |
paul@181 | 481 | |
paul@181 | 482 | struct file_attribute { |
paul@181 | 483 | __u32 type; |
paul@181 | 484 | __u32 len; |
paul@181 | 485 | __u8 non_resident; |
paul@181 | 486 | __u8 name_len; |
paul@181 | 487 | __u16 name_offset; |
paul@181 | 488 | __u16 flags; |
paul@181 | 489 | __u16 instance; |
paul@181 | 490 | __u32 value_len; |
paul@181 | 491 | __u16 value_offset; |
paul@181 | 492 | } __attribute__((__packed__)); |
paul@181 | 493 | |
paul@181 | 494 | #define MFT_RECORD_VOLUME 3 |
paul@181 | 495 | #define MFT_RECORD_ATTR_VOLUME_NAME 0x60 |
paul@181 | 496 | #define MFT_RECORD_ATTR_VOLUME_INFO 0x70 |
paul@181 | 497 | #define MFT_RECORD_ATTR_OBJECT_ID 0x40 |
paul@181 | 498 | #define MFT_RECORD_ATTR_END 0xffffffffu |
paul@181 | 499 | |
paul@181 | 500 | /* HFS / HFS+ */ |
paul@181 | 501 | struct hfs_finder_info { |
paul@181 | 502 | __u32 boot_folder; |
paul@181 | 503 | __u32 start_app; |
paul@181 | 504 | __u32 open_folder; |
paul@181 | 505 | __u32 os9_folder; |
paul@181 | 506 | __u32 reserved; |
paul@181 | 507 | __u32 osx_folder; |
paul@181 | 508 | __u8 id[8]; |
paul@181 | 509 | } __attribute__((packed)); |
paul@181 | 510 | |
paul@181 | 511 | struct hfs_mdb { |
paul@181 | 512 | __u8 signature[2]; |
paul@181 | 513 | __u32 cr_date; |
paul@181 | 514 | __u32 ls_Mod; |
paul@181 | 515 | __u16 atrb; |
paul@181 | 516 | __u16 nm_fls; |
paul@181 | 517 | __u16 vbm_st; |
paul@181 | 518 | __u16 alloc_ptr; |
paul@181 | 519 | __u16 nm_al_blks; |
paul@181 | 520 | __u32 al_blk_size; |
paul@181 | 521 | __u32 clp_size; |
paul@181 | 522 | __u16 al_bl_st; |
paul@181 | 523 | __u32 nxt_cnid; |
paul@181 | 524 | __u16 free_bks; |
paul@181 | 525 | __u8 label_len; |
paul@181 | 526 | __u8 label[27]; |
paul@181 | 527 | __u32 vol_bkup; |
paul@181 | 528 | __u16 vol_seq_num; |
paul@181 | 529 | __u32 wr_cnt; |
paul@181 | 530 | __u32 xt_clump_size; |
paul@181 | 531 | __u32 ct_clump_size; |
paul@181 | 532 | __u16 num_root_dirs; |
paul@181 | 533 | __u32 file_count; |
paul@181 | 534 | __u32 dir_count; |
paul@181 | 535 | struct hfs_finder_info finder_info; |
paul@181 | 536 | __u8 embed_sig[2]; |
paul@181 | 537 | __u16 embed_startblock; |
paul@181 | 538 | __u16 embed_blockcount; |
paul@181 | 539 | } __attribute__((packed)); |
paul@181 | 540 | |
paul@181 | 541 | |
paul@181 | 542 | #define HFS_NODE_LEAF 0xff |
paul@181 | 543 | #define HFSPLUS_POR_CNID 1 |
paul@181 | 544 | |
paul@181 | 545 | struct hfsplus_bnode_descriptor { |
paul@181 | 546 | __u32 next; |
paul@181 | 547 | __u32 prev; |
paul@181 | 548 | __u8 type; |
paul@181 | 549 | __u8 height; |
paul@181 | 550 | __u16 num_recs; |
paul@181 | 551 | __u16 reserved; |
paul@181 | 552 | } __attribute__((packed)); |
paul@181 | 553 | |
paul@181 | 554 | struct hfsplus_bheader_record { |
paul@181 | 555 | __u16 depth; |
paul@181 | 556 | __u32 root; |
paul@181 | 557 | __u32 leaf_count; |
paul@181 | 558 | __u32 leaf_head; |
paul@181 | 559 | __u32 leaf_tail; |
paul@181 | 560 | __u16 node_size; |
paul@181 | 561 | } __attribute__((packed)); |
paul@181 | 562 | |
paul@181 | 563 | struct hfsplus_catalog_key { |
paul@181 | 564 | __u16 key_len; |
paul@181 | 565 | __u32 parent_id; |
paul@181 | 566 | __u16 unicode_len; |
paul@181 | 567 | __u8 unicode[255 * 2]; |
paul@181 | 568 | } __attribute__((packed)); |
paul@181 | 569 | |
paul@181 | 570 | struct hfsplus_extent { |
paul@181 | 571 | __u32 start_block; |
paul@181 | 572 | __u32 block_count; |
paul@181 | 573 | } __attribute__((packed)); |
paul@181 | 574 | |
paul@181 | 575 | #define HFSPLUS_EXTENT_COUNT 8 |
paul@181 | 576 | struct hfsplus_fork { |
paul@181 | 577 | __u64 total_size; |
paul@181 | 578 | __u32 clump_size; |
paul@181 | 579 | __u32 total_blocks; |
paul@181 | 580 | struct hfsplus_extent extents[HFSPLUS_EXTENT_COUNT]; |
paul@181 | 581 | } __attribute__((packed)); |
paul@181 | 582 | |
paul@181 | 583 | struct hfsplus_vol_header { |
paul@181 | 584 | __u8 signature[2]; |
paul@181 | 585 | __u16 version; |
paul@181 | 586 | __u32 attributes; |
paul@181 | 587 | __u32 last_mount_vers; |
paul@181 | 588 | __u32 reserved; |
paul@181 | 589 | __u32 create_date; |
paul@181 | 590 | __u32 modify_date; |
paul@181 | 591 | __u32 backup_date; |
paul@181 | 592 | __u32 checked_date; |
paul@181 | 593 | __u32 file_count; |
paul@181 | 594 | __u32 folder_count; |
paul@181 | 595 | __u32 blocksize; |
paul@181 | 596 | __u32 total_blocks; |
paul@181 | 597 | __u32 free_blocks; |
paul@181 | 598 | __u32 next_alloc; |
paul@181 | 599 | __u32 rsrc_clump_sz; |
paul@181 | 600 | __u32 data_clump_sz; |
paul@181 | 601 | __u32 next_cnid; |
paul@181 | 602 | __u32 write_count; |
paul@181 | 603 | __u64 encodings_bmp; |
paul@181 | 604 | struct hfs_finder_info finder_info; |
paul@181 | 605 | struct hfsplus_fork alloc_file; |
paul@181 | 606 | struct hfsplus_fork ext_file; |
paul@181 | 607 | struct hfsplus_fork cat_file; |
paul@181 | 608 | struct hfsplus_fork attr_file; |
paul@181 | 609 | struct hfsplus_fork start_file; |
paul@181 | 610 | } __attribute__((packed)); |
paul@181 | 611 | |
paul@181 | 612 | |
paul@181 | 613 | /* this is lvm's label_header & pv_header combined. */ |
paul@181 | 614 | |
paul@181 | 615 | #define LVM2_ID_LEN 32 |
paul@181 | 616 | |
paul@181 | 617 | struct lvm2_pv_label_header { |
paul@181 | 618 | /* label_header */ |
paul@181 | 619 | __u8 id[8]; /* LABELONE */ |
paul@181 | 620 | __u64 sector_xl; /* Sector number of this label */ |
paul@181 | 621 | __u32 crc_xl; /* From next field to end of sector */ |
paul@181 | 622 | __u32 offset_xl; /* Offset from start of struct to contents */ |
paul@181 | 623 | __u8 type[8]; /* LVM2 001 */ |
paul@181 | 624 | /* pv_header */ |
paul@181 | 625 | __u8 pv_uuid[LVM2_ID_LEN]; |
paul@181 | 626 | } __attribute__ ((packed)); |
paul@181 | 627 | |
paul@181 | 628 | |
paul@181 | 629 | /* |
paul@181 | 630 | * this is a very generous portion of the super block, giving us |
paul@181 | 631 | * room to translate 14 chunks with 3 stripes each. |
paul@181 | 632 | */ |
paul@181 | 633 | #define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048 |
paul@181 | 634 | #define BTRFS_LABEL_SIZE 256 |
paul@181 | 635 | #define BTRFS_UUID_SIZE 16 |
paul@181 | 636 | #define BTRFS_FSID_SIZE 16 |
paul@181 | 637 | #define BTRFS_CSUM_SIZE 32 |
paul@181 | 638 | |
paul@181 | 639 | struct btrfs_dev_item { |
paul@181 | 640 | /* the internal btrfs device id */ |
paul@181 | 641 | __u64 devid; |
paul@181 | 642 | |
paul@181 | 643 | /* size of the device */ |
paul@181 | 644 | __u64 total_bytes; |
paul@181 | 645 | |
paul@181 | 646 | /* bytes used */ |
paul@181 | 647 | __u64 bytes_used; |
paul@181 | 648 | |
paul@181 | 649 | /* optimal io alignment for this device */ |
paul@181 | 650 | __u32 io_align; |
paul@181 | 651 | |
paul@181 | 652 | /* optimal io width for this device */ |
paul@181 | 653 | __u32 io_width; |
paul@181 | 654 | |
paul@181 | 655 | /* minimal io size for this device */ |
paul@181 | 656 | __u32 sector_size; |
paul@181 | 657 | |
paul@181 | 658 | /* type and info about this device */ |
paul@181 | 659 | __u64 type; |
paul@181 | 660 | |
paul@181 | 661 | /* expected generation for this device */ |
paul@181 | 662 | __u64 generation; |
paul@181 | 663 | |
paul@181 | 664 | /* |
paul@181 | 665 | * starting byte of this partition on the device, |
paul@181 | 666 | * to allow for stripe alignment in the future |
paul@181 | 667 | */ |
paul@181 | 668 | __u64 start_offset; |
paul@181 | 669 | |
paul@181 | 670 | /* grouping information for allocation decisions */ |
paul@181 | 671 | __u32 dev_group; |
paul@181 | 672 | |
paul@181 | 673 | /* seek speed 0-100 where 100 is fastest */ |
paul@181 | 674 | __u8 seek_speed; |
paul@181 | 675 | |
paul@181 | 676 | /* bandwidth 0-100 where 100 is fastest */ |
paul@181 | 677 | __u8 bandwidth; |
paul@181 | 678 | |
paul@181 | 679 | /* btrfs generated uuid for this device */ |
paul@181 | 680 | __u8 uuid[BTRFS_UUID_SIZE]; |
paul@181 | 681 | |
paul@181 | 682 | /* uuid of FS who owns this device */ |
paul@181 | 683 | __u8 fsid[BTRFS_UUID_SIZE]; |
paul@181 | 684 | } __attribute__ ((__packed__)); |
paul@181 | 685 | |
paul@181 | 686 | /* |
paul@181 | 687 | * the super block basically lists the main trees of the FS |
paul@181 | 688 | * it currently lacks any block count etc etc |
paul@181 | 689 | */ |
paul@181 | 690 | struct btrfs_super_block { |
paul@181 | 691 | __u8 csum[BTRFS_CSUM_SIZE]; |
paul@181 | 692 | /* the first 3 fields must match struct btrfs_header */ |
paul@181 | 693 | __u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */ |
paul@181 | 694 | __u64 bytenr; /* this block number */ |
paul@181 | 695 | __u64 flags; |
paul@181 | 696 | |
paul@181 | 697 | /* allowed to be different from the btrfs_header from here own down */ |
paul@181 | 698 | __u64 magic; |
paul@181 | 699 | __u64 generation; |
paul@181 | 700 | __u64 root; |
paul@181 | 701 | __u64 chunk_root; |
paul@181 | 702 | __u64 log_root; |
paul@181 | 703 | |
paul@181 | 704 | /* this will help find the new super based on the log root */ |
paul@181 | 705 | __u64 log_root_transid; |
paul@181 | 706 | __u64 total_bytes; |
paul@181 | 707 | __u64 bytes_used; |
paul@181 | 708 | __u64 root_dir_objectid; |
paul@181 | 709 | __u64 num_devices; |
paul@181 | 710 | __u32 sectorsize; |
paul@181 | 711 | __u32 nodesize; |
paul@181 | 712 | __u32 leafsize; |
paul@181 | 713 | __u32 stripesize; |
paul@181 | 714 | __u32 sys_chunk_array_size; |
paul@181 | 715 | __u64 chunk_root_generation; |
paul@181 | 716 | __u64 compat_flags; |
paul@181 | 717 | __u64 compat_ro_flags; |
paul@181 | 718 | __u64 incompat_flags; |
paul@181 | 719 | __u16 csum_type; |
paul@181 | 720 | __u8 root_level; |
paul@181 | 721 | __u8 chunk_root_level; |
paul@181 | 722 | __u8 log_root_level; |
paul@181 | 723 | struct btrfs_dev_item dev_item; |
paul@181 | 724 | |
paul@181 | 725 | char label[BTRFS_LABEL_SIZE]; |
paul@181 | 726 | |
paul@181 | 727 | /* future expansion */ |
paul@181 | 728 | __u64 reserved[32]; |
paul@181 | 729 | __u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE]; |
paul@181 | 730 | } __attribute__ ((__packed__)); |
paul@181 | 731 | |
paul@181 | 732 | #define F2FS_MAX_EXTENSION 64 /* # of extension entries */ |
paul@181 | 733 | |
paul@181 | 734 | struct f2fs_super_block { |
paul@181 | 735 | __u32 magic; /* Magic Number */ |
paul@181 | 736 | __u16 major_ver; /* Major Version */ |
paul@181 | 737 | __u16 minor_ver; /* Minor Version */ |
paul@181 | 738 | __u32 log_sectorsize; /* log2 sector size in bytes */ |
paul@181 | 739 | __u32 log_sectors_per_block; /* log2 # of sectors per block */ |
paul@181 | 740 | __u32 log_blocksize; /* log2 block size in bytes */ |
paul@181 | 741 | __u32 log_blocks_per_seg; /* log2 # of blocks per segment */ |
paul@181 | 742 | __u32 segs_per_sec; /* # of segments per section */ |
paul@181 | 743 | __u32 secs_per_zone; /* # of sections per zone */ |
paul@181 | 744 | __u32 checksum_offset; /* checksum offset inside super block */ |
paul@181 | 745 | __u64 block_count; /* total # of user blocks */ |
paul@181 | 746 | __u32 section_count; /* total # of sections */ |
paul@181 | 747 | __u32 segment_count; /* total # of segments */ |
paul@181 | 748 | __u32 segment_count_ckpt; /* # of segments for checkpoint */ |
paul@181 | 749 | __u32 segment_count_sit; /* # of segments for SIT */ |
paul@181 | 750 | __u32 segment_count_nat; /* # of segments for NAT */ |
paul@181 | 751 | __u32 segment_count_ssa; /* # of segments for SSA */ |
paul@181 | 752 | __u32 segment_count_main; /* # of segments for main area */ |
paul@181 | 753 | __u32 segment0_blkaddr; /* start block address of segment 0 */ |
paul@181 | 754 | __u32 cp_blkaddr; /* start block address of checkpoint */ |
paul@181 | 755 | __u32 sit_blkaddr; /* start block address of SIT */ |
paul@181 | 756 | __u32 nat_blkaddr; /* start block address of NAT */ |
paul@181 | 757 | __u32 ssa_blkaddr; /* start block address of SSA */ |
paul@181 | 758 | __u32 main_blkaddr; /* start block address of main area */ |
paul@181 | 759 | __u32 root_ino; /* root inode number */ |
paul@181 | 760 | __u32 node_ino; /* node inode number */ |
paul@181 | 761 | __u32 meta_ino; /* meta inode number */ |
paul@181 | 762 | __u8 uuid[16]; /* 128-bit uuid for volume */ |
paul@181 | 763 | __u16 volume_name[512]; /* volume name */ |
paul@181 | 764 | __u32 extension_count; /* # of extensions below */ |
paul@181 | 765 | __u8 extension_list[F2FS_MAX_EXTENSION][8]; /* extension array */ |
paul@181 | 766 | } __attribute__((__packed__)); |
paul@181 | 767 | |
paul@181 | 768 | struct exfat_super_block { |
paul@181 | 769 | uint8_t jump[3]; |
paul@181 | 770 | uint8_t oem_name[8]; |
paul@181 | 771 | uint8_t __unused1[53]; |
paul@181 | 772 | uint64_t block_start; |
paul@181 | 773 | uint64_t block_count; |
paul@181 | 774 | uint32_t fat_block_start; |
paul@181 | 775 | uint32_t fat_block_count; |
paul@181 | 776 | uint32_t cluster_block_start; |
paul@181 | 777 | uint32_t cluster_count; |
paul@181 | 778 | uint32_t rootdir_cluster; |
paul@181 | 779 | uint8_t volume_serial[4]; |
paul@181 | 780 | struct { |
paul@181 | 781 | uint8_t vermin; |
paul@181 | 782 | uint8_t vermaj; |
paul@181 | 783 | } version; |
paul@181 | 784 | uint16_t volume_state; |
paul@181 | 785 | uint8_t block_bits; |
paul@181 | 786 | uint8_t bpc_bits; |
paul@181 | 787 | uint8_t fat_count; |
paul@181 | 788 | uint8_t drive_no; |
paul@181 | 789 | uint8_t allocated_percent; |
paul@181 | 790 | } __attribute__((__packed__)); |
paul@181 | 791 | |
paul@181 | 792 | struct exfat_entry_label { |
paul@181 | 793 | uint8_t type; |
paul@181 | 794 | uint8_t length; |
paul@181 | 795 | uint8_t name[30]; |
paul@181 | 796 | } __attribute__((__packed__)); |
paul@181 | 797 | |
paul@181 | 798 | #define BLOCK_SIZE(sb) (1 << (sb)->block_bits) |
paul@181 | 799 | #define CLUSTER_SIZE(sb) (BLOCK_SIZE(sb) << (sb)->bpc_bits) |
paul@181 | 800 | |
paul@181 | 801 | #define EXFAT_FIRST_DATA_CLUSTER 2 |
paul@181 | 802 | #define EXFAT_LAST_DATA_CLUSTER 0xffffff6 |
paul@181 | 803 | #define EXFAT_ENTRY_SIZE 32 |
paul@181 | 804 | |
paul@181 | 805 | #define EXFAT_ENTRY_EOD 0x00 |
paul@181 | 806 | #define EXFAT_ENTRY_LABEL 0x83 |
paul@181 | 807 | |
paul@181 | 808 | /* |
paul@181 | 809 | * Byte swap functions |
paul@181 | 810 | */ |
paul@181 | 811 | #ifdef __GNUC__ |
paul@181 | 812 | #define _INLINE_ static __inline__ |
paul@181 | 813 | #else /* For Watcom C */ |
paul@181 | 814 | #define _INLINE_ static inline |
paul@181 | 815 | #endif |
paul@181 | 816 | |
paul@181 | 817 | static __u16 blkid_swab16(__u16 val); |
paul@181 | 818 | static __u32 blkid_swab32(__u32 val); |
paul@181 | 819 | static __u64 blkid_swab64(__u64 val); |
paul@181 | 820 | |
paul@181 | 821 | #if ((defined __GNUC__) && \ |
paul@181 | 822 | (defined(__i386__) || defined(__i486__) || defined(__i586__))) |
paul@181 | 823 | |
paul@181 | 824 | #define _BLKID_HAVE_ASM_BITOPS_ |
paul@181 | 825 | |
paul@181 | 826 | _INLINE_ __u32 blkid_swab32(__u32 val) |
paul@181 | 827 | { |
paul@181 | 828 | #ifdef EXT2FS_REQUIRE_486 |
paul@181 | 829 | __asm__("bswap %0" : "=r" (val) : "0" (val)); |
paul@181 | 830 | #else |
paul@181 | 831 | __asm__("xchgb %b0,%h0\n\t" /* swap lower bytes */ |
paul@181 | 832 | "rorl $16,%0\n\t" /* swap words */ |
paul@181 | 833 | "xchgb %b0,%h0" /* swap higher bytes */ |
paul@181 | 834 | :"=q" (val) |
paul@181 | 835 | : "0" (val)); |
paul@181 | 836 | #endif |
paul@181 | 837 | return val; |
paul@181 | 838 | } |
paul@181 | 839 | |
paul@181 | 840 | _INLINE_ __u16 blkid_swab16(__u16 val) |
paul@181 | 841 | { |
paul@181 | 842 | __asm__("xchgb %b0,%h0" /* swap bytes */ \ |
paul@181 | 843 | : "=q" (val) \ |
paul@181 | 844 | : "0" (val)); \ |
paul@181 | 845 | return val; |
paul@181 | 846 | } |
paul@181 | 847 | |
paul@181 | 848 | _INLINE_ __u64 blkid_swab64(__u64 val) |
paul@181 | 849 | { |
paul@181 | 850 | return (blkid_swab32(val >> 32) | |
paul@181 | 851 | (((__u64) blkid_swab32(val & 0xFFFFFFFFUL)) << 32)); |
paul@181 | 852 | } |
paul@181 | 853 | #endif |
paul@181 | 854 | |
paul@181 | 855 | #if !defined(_BLKID_HAVE_ASM_BITOPS_) |
paul@181 | 856 | |
paul@181 | 857 | _INLINE_ __u16 blkid_swab16(__u16 val) |
paul@181 | 858 | { |
paul@181 | 859 | return (val >> 8) | (val << 8); |
paul@181 | 860 | } |
paul@181 | 861 | |
paul@181 | 862 | _INLINE_ __u32 blkid_swab32(__u32 val) |
paul@181 | 863 | { |
paul@181 | 864 | return ((val>>24) | ((val>>8)&0xFF00) | |
paul@181 | 865 | ((val<<8)&0xFF0000) | (val<<24)); |
paul@181 | 866 | } |
paul@181 | 867 | |
paul@181 | 868 | _INLINE_ __u64 blkid_swab64(__u64 val) |
paul@181 | 869 | { |
paul@181 | 870 | return (blkid_swab32(val >> 32) | |
paul@181 | 871 | (((__u64) blkid_swab32(val & 0xFFFFFFFFUL)) << 32)); |
paul@181 | 872 | } |
paul@181 | 873 | #endif |
paul@181 | 874 | |
paul@181 | 875 | |
paul@181 | 876 | |
paul@181 | 877 | #ifdef WORDS_BIGENDIAN |
paul@181 | 878 | #define blkid_le16(x) blkid_swab16(x) |
paul@181 | 879 | #define blkid_le32(x) blkid_swab32(x) |
paul@181 | 880 | #define blkid_le64(x) blkid_swab64(x) |
paul@181 | 881 | #define blkid_be16(x) (x) |
paul@181 | 882 | #define blkid_be32(x) (x) |
paul@181 | 883 | #define blkid_be64(x) (x) |
paul@181 | 884 | #else |
paul@181 | 885 | #define blkid_le16(x) (x) |
paul@181 | 886 | #define blkid_le32(x) (x) |
paul@181 | 887 | #define blkid_le64(x) (x) |
paul@181 | 888 | #define blkid_be16(x) blkid_swab16(x) |
paul@181 | 889 | #define blkid_be32(x) blkid_swab32(x) |
paul@181 | 890 | #define blkid_be64(x) blkid_swab64(x) |
paul@181 | 891 | #endif |
paul@181 | 892 | |
paul@181 | 893 | #undef _INLINE_ |
paul@181 | 894 | |
paul@181 | 895 | #endif /* _BLKID_PROBE_H */ |