ext4_utils/ext4_utils.c

   1 /*
   2  * Copyright (C) 2010 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "ext4_utils/ext4_utils.h"
  18
  19 #include <fcntl.h>
  20 #include <inttypes.h>
  21 #include <stddef.h>
  22 #include <string.h>
  23 #include <sys/stat.h>
  24 #include <sys/types.h>
  25
  26 #ifdef _WIN32
  27 #include <winsock2.h>
  28 #else
  29 #include <arpa/inet.h>
  30 #include <sys/ioctl.h>
  31 #endif
  32
  33 #if defined(__linux__)
  34 #include <linux/fs.h>
  35 #elif defined(__APPLE__) && defined(__MACH__)
  36 #include <sys/disk.h>
  37 #endif
  38
  39 int force = 0;
  40 struct fs_info info;
  41 struct fs_aux_info aux_info;
  42
  43 jmp_buf setjmp_env;
  44
  45 /* returns 1 if a is a power of b */
  46 static int is_power_of(int a, int b)
  47 {
  48         while (a > b) {
  49                 if (a % b)
  50                         return 0;
  51                 a /= b;
  52         }
  53
  54         return (a == b) ? 1 : 0;
  55 }
  56
  57 int bitmap_get_bit(u8 *bitmap, u32 bit)
  58 {
  59         if (bitmap[bit / 8] & (1 << (bit % 8)))
  60                 return 1;
  61
  62         return 0;
  63 }
  64
  65 void bitmap_clear_bit(u8 *bitmap, u32 bit)
  66 {
  67         bitmap[bit / 8] &= ~(1 << (bit % 8));
  68
  69         return;
  70 }
  71
  72 /* Returns 1 if the bg contains a backup superblock.  On filesystems with
  73    the sparse_super feature, only block groups 0, 1, and powers of 3, 5,
  74    and 7 have backup superblocks.  Otherwise, all block groups have backup
  75    superblocks */
  76 int ext4_bg_has_super_block(int bg)
  77 {
  78         /* Without sparse_super, every block group has a superblock */
  79         if (!(info.feat_ro_compat & EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER))
  80                 return 1;
  81
  82         if (bg == 0 || bg == 1)
  83                 return 1;
  84
  85         if (is_power_of(bg, 3) || is_power_of(bg, 5) || is_power_of(bg, 7))
  86                 return 1;
  87
  88         return 0;
  89 }
  90
  91 /* Function to read the primary superblock */
  92 void read_sb(int fd, struct ext4_super_block *sb)
  93 {
  94         off64_t ret;
  95
  96         ret = lseek64(fd, 1024, SEEK_SET);
  97         if (ret < 0)
  98                 critical_error_errno("failed to seek to superblock");
  99
 100         ret = read(fd, sb, sizeof(*sb));
 101         if (ret < 0)
 102                 critical_error_errno("failed to read superblock");
 103         if (ret != sizeof(*sb))
 104                 critical_error("failed to read all of superblock");
 105 }
 106
 107 /* Compute the rest of the parameters of the filesystem from the basic info */
 108 void ext4_create_fs_aux_info()
 109 {
 110         aux_info.first_data_block = (info.block_size > 1024) ? 0 : 1;
 111         aux_info.len_blocks = info.len / info.block_size;
 112         aux_info.inode_table_blocks = DIV_ROUND_UP(info.inodes_per_group * info.inode_size,
 113                 info.block_size);
 114         aux_info.groups = DIV_ROUND_UP(aux_info.len_blocks - aux_info.first_data_block,
 115                 info.blocks_per_group);
 116         aux_info.blocks_per_ind = info.block_size / sizeof(u32);
 117         aux_info.blocks_per_dind = aux_info.blocks_per_ind * aux_info.blocks_per_ind;
 118         aux_info.blocks_per_tind = aux_info.blocks_per_dind * aux_info.blocks_per_dind;
 119
 120         aux_info.bg_desc_blocks =
 121                 DIV_ROUND_UP(aux_info.groups * sizeof(struct ext2_group_desc),
 122                         info.block_size);
 123
 124         aux_info.default_i_flags = EXT4_NOATIME_FL;
 125
 126         u32 last_group_size = aux_info.len_blocks % info.blocks_per_group;
 127         u32 last_header_size = 2 + aux_info.inode_table_blocks;
 128         if (ext4_bg_has_super_block((int)aux_info.groups - 1))
 129                 last_header_size += 1 + aux_info.bg_desc_blocks +
 130                         info.bg_desc_reserve_blocks;
 131         if (aux_info.groups <= 1 && last_group_size < last_header_size) {
 132                 critical_error("filesystem size too small");
 133         }
 134         if (last_group_size > 0 && last_group_size < last_header_size) {
 135                 aux_info.groups--;
 136                 aux_info.len_blocks -= last_group_size;
 137         }
 138
 139         /* A zero-filled superblock to be written firstly to the block
 140          * device to mark the file-system as invalid
 141          */
 142         aux_info.sb_zero = calloc(1, info.block_size);
 143         if (!aux_info.sb_zero)
 144                 critical_error_errno("calloc");
 145
 146         /* The write_data* functions expect only block aligned calls.
 147          * This is not an issue, except when we write out the super
 148          * block on a system with a block size > 1K.  So, we need to
 149          * deal with that here.
 150          */
 151         aux_info.sb_block = calloc(1, info.block_size);
 152         if (!aux_info.sb_block)
 153                 critical_error_errno("calloc");
 154
 155         if (info.block_size > 1024)
 156                 aux_info.sb = (struct ext4_super_block *)((char *)aux_info.sb_block + 1024);
 157         else
 158                 aux_info.sb = aux_info.sb_block;
 159
 160         /* Alloc an array to hold the pointers to the backup superblocks */
 161         aux_info.backup_sb = calloc(aux_info.groups, sizeof(char *));
 162
 163         if (!aux_info.sb)
 164                 critical_error_errno("calloc");
 165
 166         aux_info.bg_desc = calloc(info.block_size, aux_info.bg_desc_blocks);
 167         if (!aux_info.bg_desc)
 168                 critical_error_errno("calloc");
 169         aux_info.xattrs = NULL;
 170 }
 171
 172 void ext4_free_fs_aux_info()
 173 {
 174         unsigned int i;
 175
 176         for (i=0; i<aux_info.groups; i++) {
 177                 if (aux_info.backup_sb[i])
 178                         free(aux_info.backup_sb[i]);
 179         }
 180         free(aux_info.sb_block);
 181         free(aux_info.sb_zero);
 182         free(aux_info.bg_desc);
 183 }
 184
 185 void ext4_parse_sb_info(struct ext4_super_block *sb)
 186 {
 187         if (sb->s_magic != EXT4_SUPER_MAGIC)
 188                 error("superblock magic incorrect");
 189
 190         if ((sb->s_state & EXT4_VALID_FS) != EXT4_VALID_FS)
 191                 error("filesystem state not valid");
 192
 193         ext4_parse_sb(sb, &info);
 194
 195         ext4_create_fs_aux_info();
 196
 197         memcpy(aux_info.sb, sb, sizeof(*sb));
 198
 199         if (aux_info.first_data_block != sb->s_first_data_block)
 200                 critical_error("first data block does not match");
 201 }
 202
 203 u64 get_block_device_size(int fd)
 204 {
 205         u64 size = 0;
 206         int ret;
 207
 208 #if defined(__linux__)
 209         ret = ioctl(fd, BLKGETSIZE64, &size);
 210 #elif defined(__APPLE__) && defined(__MACH__)
 211         ret = ioctl(fd, DKIOCGETBLOCKCOUNT, &size);
 212 #else
 213         close(fd);
 214         return 0;
 215 #endif
 216
 217         if (ret)
 218                 return 0;
 219
 220         return size;
 221 }
 222
 223 int is_block_device_fd(int fd)
 224 {
 225 #ifdef _WIN32
 226         return 0;
 227 #else
 228         struct stat st;
 229         int ret = fstat(fd, &st);
 230         if (ret < 0)
 231                 return 0;
 232
 233         return S_ISBLK(st.st_mode);
 234 #endif
 235 }
 236
 237 u64 get_file_size(int fd)
 238 {
 239         struct stat buf;
 240         int ret;
 241         u64 reserve_len = 0;
 242         s64 computed_size;
 243
 244         ret = fstat(fd, &buf);
 245         if (ret)
 246                 return 0;
 247
 248         if (info.len < 0)
 249                 reserve_len = -info.len;
 250
 251         if (S_ISREG(buf.st_mode))
 252                 computed_size = buf.st_size - reserve_len;
 253         else if (S_ISBLK(buf.st_mode))
 254                 computed_size = get_block_device_size(fd) - reserve_len;
 255         else
 256                 computed_size = 0;
 257
 258         if (computed_size < 0) {
 259                 warn("Computed filesystem size less than 0");
 260                 computed_size = 0;
 261         }
 262
 263         return computed_size;
 264 }
 265
 266 int read_ext(int fd, int verbose)
 267 {
 268         off64_t ret;
 269         struct ext4_super_block sb;
 270
 271         read_sb(fd, &sb);
 272
 273         ext4_parse_sb_info(&sb);
 274
 275         ret = lseek64(fd, info.len, SEEK_SET);
 276         if (ret < 0)
 277                 critical_error_errno("failed to seek to end of input image");
 278
 279         ret = lseek64(fd, info.block_size * (aux_info.first_data_block + 1), SEEK_SET);
 280         if (ret < 0)
 281                 critical_error_errno("failed to seek to block group descriptors");
 282
 283         ret = read(fd, aux_info.bg_desc, info.block_size * aux_info.bg_desc_blocks);
 284         if (ret < 0)
 285                 critical_error_errno("failed to read block group descriptors");
 286         if (ret != (int)info.block_size * (int)aux_info.bg_desc_blocks)
 287                 critical_error("failed to read all of block group descriptors");
 288
 289         if (verbose) {
 290                 printf("Found filesystem with parameters:\n");
 291                 printf("    Size: %"PRIu64"\n", info.len);
 292                 printf("    Block size: %d\n", info.block_size);
 293                 printf("    Blocks per group: %d\n", info.blocks_per_group);
 294                 printf("    Inodes per group: %d\n", info.inodes_per_group);
 295                 printf("    Inode size: %d\n", info.inode_size);
 296                 printf("    Label: %s\n", info.label);
 297                 printf("    Blocks: %"PRIext4u64"\n", aux_info.len_blocks);
 298                 printf("    Block groups: %d\n", aux_info.groups);
 299                 printf("    Reserved block group size: %d\n", info.bg_desc_reserve_blocks);
 300                 printf("    Used %d/%d inodes and %d/%d blocks\n",
 301                         aux_info.sb->s_inodes_count - aux_info.sb->s_free_inodes_count,
 302                         aux_info.sb->s_inodes_count,
 303                         aux_info.sb->s_blocks_count_lo - aux_info.sb->s_free_blocks_count_lo,
 304                         aux_info.sb->s_blocks_count_lo);
 305         }
 306
 307         return 0;
 308 }
 309