[821] | 1 | /*
|
---|
| 2 | * openfs.c --- open an ext2 filesystem
|
---|
| 3 | *
|
---|
| 4 | * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
|
---|
| 5 | *
|
---|
| 6 | * %Begin-Header%
|
---|
| 7 | * This file may be redistributed under the terms of the GNU Public
|
---|
| 8 | * License.
|
---|
| 9 | * %End-Header%
|
---|
| 10 | */
|
---|
| 11 |
|
---|
| 12 | #include <stdio.h>
|
---|
| 13 | #include <string.h>
|
---|
| 14 | #if HAVE_UNISTD_H
|
---|
| 15 | #include <unistd.h>
|
---|
| 16 | #endif
|
---|
| 17 | #include <fcntl.h>
|
---|
| 18 | #include <time.h>
|
---|
| 19 | #if HAVE_SYS_STAT_H
|
---|
| 20 | #include <sys/stat.h>
|
---|
| 21 | #endif
|
---|
| 22 | #if HAVE_SYS_TYPES_H
|
---|
| 23 | #include <sys/types.h>
|
---|
| 24 | #endif
|
---|
| 25 |
|
---|
| 26 | #include "ext2_fs.h"
|
---|
| 27 |
|
---|
| 28 |
|
---|
| 29 | #include "ext2fs.h"
|
---|
| 30 | #include "e2image.h"
|
---|
| 31 |
|
---|
| 32 | blk_t ext2fs_descriptor_block_loc(ext2_filsys fs, blk_t group_block, dgrp_t i)
|
---|
| 33 | {
|
---|
| 34 | int bg;
|
---|
| 35 | int has_super = 0;
|
---|
| 36 | int ret_blk;
|
---|
| 37 |
|
---|
| 38 | if (!(fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_META_BG) ||
|
---|
| 39 | (i < fs->super->s_first_meta_bg))
|
---|
| 40 | return (group_block + i + 1);
|
---|
| 41 |
|
---|
| 42 | bg = (fs->blocksize / sizeof (struct ext2_group_desc)) * i;
|
---|
| 43 | if (ext2fs_bg_has_super(fs, bg))
|
---|
| 44 | has_super = 1;
|
---|
| 45 | ret_blk = (fs->super->s_first_data_block + has_super +
|
---|
| 46 | (bg * fs->super->s_blocks_per_group));
|
---|
| 47 | /*
|
---|
| 48 | * If group_block is not the normal value, we're trying to use
|
---|
| 49 | * the backup group descriptors and superblock --- so use the
|
---|
| 50 | * alternate location of the second block group in the
|
---|
| 51 | * metablock group. Ideally we should be testing each bg
|
---|
| 52 | * descriptor block individually for correctness, but we don't
|
---|
| 53 | * have the infrastructure in place to do that.
|
---|
| 54 | */
|
---|
| 55 | if (group_block != fs->super->s_first_data_block &&
|
---|
| 56 | ((ret_blk + fs->super->s_blocks_per_group) <
|
---|
| 57 | fs->super->s_blocks_count))
|
---|
| 58 | ret_blk += fs->super->s_blocks_per_group;
|
---|
| 59 | return ret_blk;
|
---|
| 60 | }
|
---|
| 61 |
|
---|
| 62 | errcode_t ext2fs_open(const char *name, int flags, int superblock,
|
---|
| 63 | unsigned int block_size, io_manager manager,
|
---|
| 64 | ext2_filsys *ret_fs)
|
---|
| 65 | {
|
---|
| 66 | return ext2fs_open2(name, 0, flags, superblock, block_size,
|
---|
| 67 | manager, ret_fs);
|
---|
| 68 | }
|
---|
| 69 |
|
---|
| 70 | /*
|
---|
| 71 | * Note: if superblock is non-zero, block-size must also be non-zero.
|
---|
| 72 | * Superblock and block_size can be zero to use the default size.
|
---|
| 73 | *
|
---|
| 74 | * Valid flags for ext2fs_open()
|
---|
| 75 | *
|
---|
| 76 | * EXT2_FLAG_RW - Open the filesystem for read/write.
|
---|
| 77 | * EXT2_FLAG_FORCE - Open the filesystem even if some of the
|
---|
| 78 | * features aren't supported.
|
---|
| 79 | * EXT2_FLAG_JOURNAL_DEV_OK - Open an ext3 journal device
|
---|
| 80 | */
|
---|
| 81 | errcode_t ext2fs_open2(const char *name, const char *io_options,
|
---|
| 82 | int flags, int superblock,
|
---|
| 83 | unsigned int block_size, io_manager manager,
|
---|
| 84 | ext2_filsys *ret_fs)
|
---|
| 85 | {
|
---|
| 86 | ext2_filsys fs;
|
---|
| 87 | errcode_t retval;
|
---|
| 88 | unsigned long i;
|
---|
| 89 | int groups_per_block, blocks_per_group;
|
---|
| 90 | blk_t group_block, blk;
|
---|
| 91 | char *dest, *cp;
|
---|
| 92 | #if BB_BIG_ENDIAN
|
---|
| 93 | int j;
|
---|
| 94 | struct ext2_group_desc *gdp;
|
---|
| 95 | #endif
|
---|
| 96 |
|
---|
| 97 | EXT2_CHECK_MAGIC(manager, EXT2_ET_MAGIC_IO_MANAGER);
|
---|
| 98 |
|
---|
| 99 | retval = ext2fs_get_mem(sizeof(struct struct_ext2_filsys), &fs);
|
---|
| 100 | if (retval)
|
---|
| 101 | return retval;
|
---|
| 102 |
|
---|
| 103 | memset(fs, 0, sizeof(struct struct_ext2_filsys));
|
---|
| 104 | fs->magic = EXT2_ET_MAGIC_EXT2FS_FILSYS;
|
---|
| 105 | fs->flags = flags;
|
---|
| 106 | fs->umask = 022;
|
---|
| 107 | retval = ext2fs_get_mem(strlen(name)+1, &fs->device_name);
|
---|
| 108 | if (retval)
|
---|
| 109 | goto cleanup;
|
---|
| 110 | strcpy(fs->device_name, name);
|
---|
| 111 | cp = strchr(fs->device_name, '?');
|
---|
| 112 | if (!io_options && cp) {
|
---|
| 113 | *cp++ = 0;
|
---|
| 114 | io_options = cp;
|
---|
| 115 | }
|
---|
| 116 |
|
---|
| 117 | retval = manager->open(fs->device_name,
|
---|
| 118 | (flags & EXT2_FLAG_RW) ? IO_FLAG_RW : 0,
|
---|
| 119 | &fs->io);
|
---|
| 120 | if (retval)
|
---|
| 121 | goto cleanup;
|
---|
| 122 | if (io_options &&
|
---|
| 123 | (retval = io_channel_set_options(fs->io, io_options)))
|
---|
| 124 | goto cleanup;
|
---|
| 125 | fs->image_io = fs->io;
|
---|
| 126 | fs->io->app_data = fs;
|
---|
| 127 | retval = ext2fs_get_mem(SUPERBLOCK_SIZE, &fs->super);
|
---|
| 128 | if (retval)
|
---|
| 129 | goto cleanup;
|
---|
| 130 | if (flags & EXT2_FLAG_IMAGE_FILE) {
|
---|
| 131 | retval = ext2fs_get_mem(sizeof(struct ext2_image_hdr),
|
---|
| 132 | &fs->image_header);
|
---|
| 133 | if (retval)
|
---|
| 134 | goto cleanup;
|
---|
| 135 | retval = io_channel_read_blk(fs->io, 0,
|
---|
| 136 | -(int)sizeof(struct ext2_image_hdr),
|
---|
| 137 | fs->image_header);
|
---|
| 138 | if (retval)
|
---|
| 139 | goto cleanup;
|
---|
| 140 | if (fs->image_header->magic_number != EXT2_ET_MAGIC_E2IMAGE)
|
---|
| 141 | return EXT2_ET_MAGIC_E2IMAGE;
|
---|
| 142 | superblock = 1;
|
---|
| 143 | block_size = fs->image_header->fs_blocksize;
|
---|
| 144 | }
|
---|
| 145 |
|
---|
| 146 | /*
|
---|
| 147 | * If the user specifies a specific block # for the
|
---|
| 148 | * superblock, then he/she must also specify the block size!
|
---|
| 149 | * Otherwise, read the master superblock located at offset
|
---|
| 150 | * SUPERBLOCK_OFFSET from the start of the partition.
|
---|
| 151 | *
|
---|
| 152 | * Note: we only save a backup copy of the superblock if we
|
---|
| 153 | * are reading the superblock from the primary superblock location.
|
---|
| 154 | */
|
---|
| 155 | if (superblock) {
|
---|
| 156 | if (!block_size) {
|
---|
| 157 | retval = EXT2_ET_INVALID_ARGUMENT;
|
---|
| 158 | goto cleanup;
|
---|
| 159 | }
|
---|
| 160 | io_channel_set_blksize(fs->io, block_size);
|
---|
| 161 | group_block = superblock;
|
---|
| 162 | fs->orig_super = 0;
|
---|
| 163 | } else {
|
---|
| 164 | io_channel_set_blksize(fs->io, SUPERBLOCK_OFFSET);
|
---|
| 165 | superblock = 1;
|
---|
| 166 | group_block = 0;
|
---|
| 167 | retval = ext2fs_get_mem(SUPERBLOCK_SIZE, &fs->orig_super);
|
---|
| 168 | if (retval)
|
---|
| 169 | goto cleanup;
|
---|
| 170 | }
|
---|
| 171 | retval = io_channel_read_blk(fs->io, superblock, -SUPERBLOCK_SIZE,
|
---|
| 172 | fs->super);
|
---|
| 173 | if (retval)
|
---|
| 174 | goto cleanup;
|
---|
| 175 | if (fs->orig_super)
|
---|
| 176 | memcpy(fs->orig_super, fs->super, SUPERBLOCK_SIZE);
|
---|
| 177 |
|
---|
| 178 | #if BB_BIG_ENDIAN
|
---|
| 179 | if ((fs->super->s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC)) ||
|
---|
| 180 | (fs->flags & EXT2_FLAG_SWAP_BYTES)) {
|
---|
| 181 | fs->flags |= EXT2_FLAG_SWAP_BYTES;
|
---|
| 182 |
|
---|
| 183 | ext2fs_swap_super(fs->super);
|
---|
| 184 | }
|
---|
| 185 | #endif
|
---|
| 186 |
|
---|
| 187 | if (fs->super->s_magic != EXT2_SUPER_MAGIC) {
|
---|
| 188 | retval = EXT2_ET_BAD_MAGIC;
|
---|
| 189 | goto cleanup;
|
---|
| 190 | }
|
---|
| 191 | if (fs->super->s_rev_level > EXT2_LIB_CURRENT_REV) {
|
---|
| 192 | retval = EXT2_ET_REV_TOO_HIGH;
|
---|
| 193 | goto cleanup;
|
---|
| 194 | }
|
---|
| 195 |
|
---|
| 196 | /*
|
---|
| 197 | * Check for feature set incompatibility
|
---|
| 198 | */
|
---|
| 199 | if (!(flags & EXT2_FLAG_FORCE)) {
|
---|
| 200 | if (fs->super->s_feature_incompat &
|
---|
| 201 | ~EXT2_LIB_FEATURE_INCOMPAT_SUPP) {
|
---|
| 202 | retval = EXT2_ET_UNSUPP_FEATURE;
|
---|
| 203 | goto cleanup;
|
---|
| 204 | }
|
---|
| 205 | if ((flags & EXT2_FLAG_RW) &&
|
---|
| 206 | (fs->super->s_feature_ro_compat &
|
---|
| 207 | ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP)) {
|
---|
| 208 | retval = EXT2_ET_RO_UNSUPP_FEATURE;
|
---|
| 209 | goto cleanup;
|
---|
| 210 | }
|
---|
| 211 | if (!(flags & EXT2_FLAG_JOURNAL_DEV_OK) &&
|
---|
| 212 | (fs->super->s_feature_incompat &
|
---|
| 213 | EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) {
|
---|
| 214 | retval = EXT2_ET_UNSUPP_FEATURE;
|
---|
| 215 | goto cleanup;
|
---|
| 216 | }
|
---|
| 217 | }
|
---|
| 218 |
|
---|
| 219 | fs->blocksize = EXT2_BLOCK_SIZE(fs->super);
|
---|
| 220 | if (fs->blocksize == 0) {
|
---|
| 221 | retval = EXT2_ET_CORRUPT_SUPERBLOCK;
|
---|
| 222 | goto cleanup;
|
---|
| 223 | }
|
---|
| 224 | fs->fragsize = EXT2_FRAG_SIZE(fs->super);
|
---|
| 225 | fs->inode_blocks_per_group = ((fs->super->s_inodes_per_group *
|
---|
| 226 | EXT2_INODE_SIZE(fs->super) +
|
---|
| 227 | EXT2_BLOCK_SIZE(fs->super) - 1) /
|
---|
| 228 | EXT2_BLOCK_SIZE(fs->super));
|
---|
| 229 | if (block_size) {
|
---|
| 230 | if (block_size != fs->blocksize) {
|
---|
| 231 | retval = EXT2_ET_UNEXPECTED_BLOCK_SIZE;
|
---|
| 232 | goto cleanup;
|
---|
| 233 | }
|
---|
| 234 | }
|
---|
| 235 | /*
|
---|
| 236 | * Set the blocksize to the filesystem's blocksize.
|
---|
| 237 | */
|
---|
| 238 | io_channel_set_blksize(fs->io, fs->blocksize);
|
---|
| 239 |
|
---|
| 240 | /*
|
---|
| 241 | * If this is an external journal device, don't try to read
|
---|
| 242 | * the group descriptors, because they're not there.
|
---|
| 243 | */
|
---|
| 244 | if (fs->super->s_feature_incompat &
|
---|
| 245 | EXT3_FEATURE_INCOMPAT_JOURNAL_DEV) {
|
---|
| 246 | fs->group_desc_count = 0;
|
---|
| 247 | *ret_fs = fs;
|
---|
| 248 | return 0;
|
---|
| 249 | }
|
---|
| 250 |
|
---|
| 251 | /*
|
---|
| 252 | * Read group descriptors
|
---|
| 253 | */
|
---|
| 254 | blocks_per_group = EXT2_BLOCKS_PER_GROUP(fs->super);
|
---|
| 255 | if (blocks_per_group == 0 ||
|
---|
| 256 | blocks_per_group > EXT2_MAX_BLOCKS_PER_GROUP(fs->super) ||
|
---|
| 257 | fs->inode_blocks_per_group > EXT2_MAX_INODES_PER_GROUP(fs->super)) {
|
---|
| 258 | retval = EXT2_ET_CORRUPT_SUPERBLOCK;
|
---|
| 259 | goto cleanup;
|
---|
| 260 | }
|
---|
| 261 | fs->group_desc_count = (fs->super->s_blocks_count -
|
---|
| 262 | fs->super->s_first_data_block +
|
---|
| 263 | blocks_per_group - 1) / blocks_per_group;
|
---|
| 264 | fs->desc_blocks = (fs->group_desc_count +
|
---|
| 265 | EXT2_DESC_PER_BLOCK(fs->super) - 1)
|
---|
| 266 | / EXT2_DESC_PER_BLOCK(fs->super);
|
---|
| 267 | retval = ext2fs_get_mem(fs->desc_blocks * fs->blocksize,
|
---|
| 268 | &fs->group_desc);
|
---|
| 269 | if (retval)
|
---|
| 270 | goto cleanup;
|
---|
| 271 | if (!group_block)
|
---|
| 272 | group_block = fs->super->s_first_data_block;
|
---|
| 273 | dest = (char *) fs->group_desc;
|
---|
| 274 | groups_per_block = fs->blocksize / sizeof(struct ext2_group_desc);
|
---|
| 275 | for (i=0 ; i < fs->desc_blocks; i++) {
|
---|
| 276 | blk = ext2fs_descriptor_block_loc(fs, group_block, i);
|
---|
| 277 | retval = io_channel_read_blk(fs->io, blk, 1, dest);
|
---|
| 278 | if (retval)
|
---|
| 279 | goto cleanup;
|
---|
| 280 | #if BB_BIG_ENDIAN
|
---|
| 281 | if (fs->flags & EXT2_FLAG_SWAP_BYTES) {
|
---|
| 282 | gdp = (struct ext2_group_desc *) dest;
|
---|
| 283 | for (j=0; j < groups_per_block; j++)
|
---|
| 284 | ext2fs_swap_group_desc(gdp++);
|
---|
| 285 | }
|
---|
| 286 | #endif
|
---|
| 287 | dest += fs->blocksize;
|
---|
| 288 | }
|
---|
| 289 |
|
---|
| 290 | *ret_fs = fs;
|
---|
| 291 | return 0;
|
---|
| 292 | cleanup:
|
---|
| 293 | ext2fs_free(fs);
|
---|
| 294 | return retval;
|
---|
| 295 | }
|
---|
| 296 |
|
---|
| 297 | /*
|
---|
| 298 | * Set/get the filesystem data I/O channel.
|
---|
| 299 | *
|
---|
| 300 | * These functions are only valid if EXT2_FLAG_IMAGE_FILE is true.
|
---|
| 301 | */
|
---|
| 302 | errcode_t ext2fs_get_data_io(ext2_filsys fs, io_channel *old_io)
|
---|
| 303 | {
|
---|
| 304 | if ((fs->flags & EXT2_FLAG_IMAGE_FILE) == 0)
|
---|
| 305 | return EXT2_ET_NOT_IMAGE_FILE;
|
---|
| 306 | if (old_io) {
|
---|
| 307 | *old_io = (fs->image_io == fs->io) ? 0 : fs->io;
|
---|
| 308 | }
|
---|
| 309 | return 0;
|
---|
| 310 | }
|
---|
| 311 |
|
---|
| 312 | errcode_t ext2fs_set_data_io(ext2_filsys fs, io_channel new_io)
|
---|
| 313 | {
|
---|
| 314 | if ((fs->flags & EXT2_FLAG_IMAGE_FILE) == 0)
|
---|
| 315 | return EXT2_ET_NOT_IMAGE_FILE;
|
---|
| 316 | fs->io = new_io ? new_io : fs->image_io;
|
---|
| 317 | return 0;
|
---|
| 318 | }
|
---|
| 319 |
|
---|
| 320 | errcode_t ext2fs_rewrite_to_io(ext2_filsys fs, io_channel new_io)
|
---|
| 321 | {
|
---|
| 322 | if ((fs->flags & EXT2_FLAG_IMAGE_FILE) == 0)
|
---|
| 323 | return EXT2_ET_NOT_IMAGE_FILE;
|
---|
| 324 | fs->io = fs->image_io = new_io;
|
---|
| 325 | fs->flags |= EXT2_FLAG_DIRTY | EXT2_FLAG_RW |
|
---|
| 326 | EXT2_FLAG_BB_DIRTY | EXT2_FLAG_IB_DIRTY;
|
---|
| 327 | fs->flags &= ~EXT2_FLAG_IMAGE_FILE;
|
---|
| 328 | return 0;
|
---|
| 329 | }
|
---|