2 * openfs.c --- open an ext2 filesystem
4 * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
7 * This file may be redistributed under the terms of the GNU Library
8 * General Public License, version 2.
24 #include <sys/types.h>
35 blk64_t
ext2fs_descriptor_block_loc2(ext2_filsys fs
, blk64_t group_block
,
39 int has_super
= 0, group_zero_adjust
= 0;
43 * On a bigalloc FS with 1K blocks, block 0 is reserved for non-ext4
44 * stuff, so adjust for that if we're being asked for group 0.
46 if (i
== 0 && fs
->blocksize
== 1024 && EXT2FS_CLUSTER_RATIO(fs
) > 1)
47 group_zero_adjust
= 1;
49 if (!ext2fs_has_feature_meta_bg(fs
->super
) ||
50 (i
< fs
->super
->s_first_meta_bg
))
51 return group_block
+ i
+ 1 + group_zero_adjust
;
53 bg
= EXT2_DESC_PER_BLOCK(fs
->super
) * i
;
54 if (ext2fs_bg_has_super(fs
, bg
))
56 ret_blk
= ext2fs_group_first_block2(fs
, bg
);
58 * If group_block is not the normal value, we're trying to use
59 * the backup group descriptors and superblock --- so use the
60 * alternate location of the second block group in the
61 * metablock group. Ideally we should be testing each bg
62 * descriptor block individually for correctness, but we don't
63 * have the infrastructure in place to do that.
65 if (group_block
!= fs
->super
->s_first_data_block
&&
66 ((ret_blk
+ has_super
+ fs
->super
->s_blocks_per_group
) <
67 ext2fs_blocks_count(fs
->super
))) {
68 ret_blk
+= fs
->super
->s_blocks_per_group
;
71 * If we're going to jump forward a block group, make sure
72 * that we adjust has_super to account for the next group's
73 * backup superblock (or lack thereof).
75 if (ext2fs_bg_has_super(fs
, bg
+ 1))
80 return ret_blk
+ has_super
+ group_zero_adjust
;
83 blk_t
ext2fs_descriptor_block_loc(ext2_filsys fs
, blk_t group_block
, dgrp_t i
)
85 return ext2fs_descriptor_block_loc2(fs
, group_block
, i
);
88 errcode_t
ext2fs_open(const char *name
, int flags
, int superblock
,
89 unsigned int block_size
, io_manager manager
,
92 return ext2fs_open2(name
, 0, flags
, superblock
, block_size
,
96 static void block_sha_map_free_entry(void *data
)
103 * Note: if superblock is non-zero, block-size must also be non-zero.
104 * Superblock and block_size can be zero to use the default size.
106 * Valid flags for ext2fs_open()
108 * EXT2_FLAG_RW - Open the filesystem for read/write.
109 * EXT2_FLAG_FORCE - Open the filesystem even if some of the
110 * features aren't supported.
111 * EXT2_FLAG_JOURNAL_DEV_OK - Open an ext3 journal device
112 * EXT2_FLAG_SKIP_MMP - Open without multi-mount protection check.
113 * EXT2_FLAG_64BITS - Allow 64-bit bitfields (needed for large
116 errcode_t
ext2fs_open2(const char *name
, const char *io_options
,
117 int flags
, int superblock
,
118 unsigned int block_size
, io_manager manager
,
123 unsigned long i
, first_meta_bg
;
125 unsigned int blocks_per_group
, io_flags
;
126 blk64_t group_block
, blk
;
128 int group_zero_adjust
= 0;
129 unsigned int inode_size
;
131 #ifdef WORDS_BIGENDIAN
132 unsigned int groups_per_block
;
133 struct ext2_group_desc
*gdp
;
137 int csum_retries
= 0;
139 EXT2_CHECK_MAGIC(manager
, EXT2_ET_MAGIC_IO_MANAGER
);
141 retval
= ext2fs_get_mem(sizeof(struct struct_ext2_filsys
), &fs
);
145 memset(fs
, 0, sizeof(struct struct_ext2_filsys
));
146 fs
->magic
= EXT2_ET_MAGIC_EXT2FS_FILSYS
;
148 /* don't overwrite sb backups unless flag is explicitly cleared */
149 fs
->flags
|= EXT2_FLAG_MASTER_SB_ONLY
;
152 time_env
= ext2fs_safe_getenv("SOURCE_DATE_EPOCH");
154 fs
->now
= strtoul(time_env
, NULL
, 0);
155 fs
->flags2
|= EXT2_FLAG2_USE_FAKE_TIME
;
157 time_env
= ext2fs_safe_getenv("E2FSPROGS_FAKE_TIME");
159 fs
->now
= strtoul(time_env
, NULL
, 0);
162 retval
= ext2fs_get_mem(strlen(name
)+1, &fs
->device_name
);
165 strcpy(fs
->device_name
, name
);
166 cp
= strchr(fs
->device_name
, '?');
167 if (!io_options
&& cp
) {
173 if (flags
& EXT2_FLAG_RW
)
174 io_flags
|= IO_FLAG_RW
;
175 if (flags
& EXT2_FLAG_EXCLUSIVE
)
176 io_flags
|= IO_FLAG_EXCLUSIVE
;
177 if (flags
& EXT2_FLAG_DIRECT_IO
)
178 io_flags
|= IO_FLAG_DIRECT_IO
;
179 if (flags
& EXT2_FLAG_THREADS
)
180 io_flags
|= IO_FLAG_THREADS
;
181 retval
= manager
->open(fs
->device_name
, io_flags
, &fs
->io
);
185 (retval
= io_channel_set_options(fs
->io
, io_options
)))
187 fs
->image_io
= fs
->io
;
188 fs
->io
->app_data
= fs
;
189 retval
= io_channel_alloc_buf(fs
->io
, -SUPERBLOCK_SIZE
, &fs
->super
);
192 if (flags
& EXT2_FLAG_IMAGE_FILE
) {
193 retval
= ext2fs_get_mem(sizeof(struct ext2_image_hdr
),
197 retval
= io_channel_read_blk(fs
->io
, 0,
198 -(int)sizeof(struct ext2_image_hdr
),
202 if (ext2fs_le32_to_cpu(fs
->image_header
->magic_number
) != EXT2_ET_MAGIC_E2IMAGE
)
203 return EXT2_ET_MAGIC_E2IMAGE
;
205 block_size
= ext2fs_le32_to_cpu(fs
->image_header
->fs_blocksize
);
209 * If the user specifies a specific block # for the
210 * superblock, then he/she must also specify the block size!
211 * Otherwise, read the master superblock located at offset
212 * SUPERBLOCK_OFFSET from the start of the partition.
214 * Note: we only save a backup copy of the superblock if we
215 * are reading the superblock from the primary superblock location.
219 retval
= EXT2_ET_INVALID_ARGUMENT
;
222 io_channel_set_blksize(fs
->io
, block_size
);
223 group_block
= superblock
;
226 io_channel_set_blksize(fs
->io
, SUPERBLOCK_OFFSET
);
229 retval
= ext2fs_get_mem(SUPERBLOCK_SIZE
, &fs
->orig_super
);
234 retval
= io_channel_read_blk(fs
->io
, superblock
, -SUPERBLOCK_SIZE
,
239 memcpy(fs
->orig_super
, fs
->super
, SUPERBLOCK_SIZE
);
241 if (!(fs
->flags
& EXT2_FLAG_IGNORE_CSUM_ERRORS
)) {
243 if (!ext2fs_verify_csum_type(fs
, fs
->super
))
244 retval
= EXT2_ET_UNKNOWN_CSUM
;
245 if (!ext2fs_superblock_csum_verify(fs
, fs
->super
)) {
246 if (csum_retries
++ < 3)
248 retval
= EXT2_ET_SB_CSUM_INVALID
;
252 #ifdef WORDS_BIGENDIAN
253 fs
->flags
|= EXT2_FLAG_SWAP_BYTES
;
254 ext2fs_swap_super(fs
->super
);
256 if (fs
->flags
& EXT2_FLAG_SWAP_BYTES
) {
257 retval
= EXT2_ET_UNIMPLEMENTED
;
262 if (fs
->super
->s_magic
!= EXT2_SUPER_MAGIC
)
263 retval
= EXT2_ET_BAD_MAGIC
;
267 if (fs
->super
->s_rev_level
> EXT2_LIB_CURRENT_REV
) {
268 retval
= EXT2_ET_REV_TOO_HIGH
;
273 * Check for feature set incompatibility
275 if (!(flags
& EXT2_FLAG_FORCE
)) {
276 features
= fs
->super
->s_feature_incompat
;
277 #ifdef EXT2_LIB_SOFTSUPP_INCOMPAT
278 if (flags
& EXT2_FLAG_SOFTSUPP_FEATURES
)
279 features
&= ~EXT2_LIB_SOFTSUPP_INCOMPAT
;
281 if (features
& ~EXT2_LIB_FEATURE_INCOMPAT_SUPP
) {
282 retval
= EXT2_ET_UNSUPP_FEATURE
;
286 features
= fs
->super
->s_feature_ro_compat
;
287 #ifdef EXT2_LIB_SOFTSUPP_RO_COMPAT
288 if (flags
& EXT2_FLAG_SOFTSUPP_FEATURES
)
289 features
&= ~EXT2_LIB_SOFTSUPP_RO_COMPAT
;
291 if ((flags
& EXT2_FLAG_RW
) &&
292 (features
& ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP
)) {
293 retval
= EXT2_ET_RO_UNSUPP_FEATURE
;
297 if (!(flags
& EXT2_FLAG_JOURNAL_DEV_OK
) &&
298 ext2fs_has_feature_journal_dev(fs
->super
)) {
299 retval
= EXT2_ET_UNSUPP_FEATURE
;
304 if ((fs
->super
->s_log_block_size
>
305 (unsigned) (EXT2_MAX_BLOCK_LOG_SIZE
- EXT2_MIN_BLOCK_LOG_SIZE
)) ||
306 (fs
->super
->s_log_cluster_size
>
307 (unsigned) (EXT2_MAX_CLUSTER_LOG_SIZE
- EXT2_MIN_CLUSTER_LOG_SIZE
)) ||
308 (fs
->super
->s_log_block_size
> fs
->super
->s_log_cluster_size
) ||
309 (fs
->super
->s_log_groups_per_flex
> 31)) {
310 retval
= EXT2_ET_CORRUPT_SUPERBLOCK
;
315 * bigalloc requires cluster-aware bitfield operations, which at the
316 * moment means we need EXT2_FLAG_64BITS.
318 if (ext2fs_has_feature_bigalloc(fs
->super
) &&
319 !(flags
& EXT2_FLAG_64BITS
)) {
320 retval
= EXT2_ET_CANT_USE_LEGACY_BITMAPS
;
324 if (!ext2fs_has_feature_bigalloc(fs
->super
) &&
325 (fs
->super
->s_log_block_size
!= fs
->super
->s_log_cluster_size
)) {
326 retval
= EXT2_ET_CORRUPT_SUPERBLOCK
;
329 fs
->fragsize
= fs
->blocksize
= EXT2_BLOCK_SIZE(fs
->super
);
330 inode_size
= EXT2_INODE_SIZE(fs
->super
);
331 if ((inode_size
< EXT2_GOOD_OLD_INODE_SIZE
) ||
332 (inode_size
> fs
->blocksize
) ||
333 (inode_size
& (inode_size
- 1))) {
334 retval
= EXT2_ET_CORRUPT_SUPERBLOCK
;
338 /* Enforce the block group descriptor size */
339 if (ext2fs_has_feature_64bit(fs
->super
)) {
340 unsigned desc_size
= fs
->super
->s_desc_size
;
342 if (desc_size
== 0 ||
343 (!(flags
& EXT2_FLAG_IGNORE_SB_ERRORS
) &&
344 ((desc_size
> EXT2_MAX_DESC_SIZE
) ||
345 (desc_size
< EXT2_MIN_DESC_SIZE_64BIT
) ||
346 (desc_size
& (desc_size
- 1)) != 0))) {
347 retval
= EXT2_ET_BAD_DESC_SIZE
;
352 fs
->cluster_ratio_bits
= fs
->super
->s_log_cluster_size
-
353 fs
->super
->s_log_block_size
;
354 if (EXT2_BLOCKS_PER_GROUP(fs
->super
) !=
355 EXT2_CLUSTERS_PER_GROUP(fs
->super
) << fs
->cluster_ratio_bits
) {
356 retval
= EXT2_ET_CORRUPT_SUPERBLOCK
;
359 fs
->inode_blocks_per_group
= ((EXT2_INODES_PER_GROUP(fs
->super
) *
360 EXT2_INODE_SIZE(fs
->super
) +
361 EXT2_BLOCK_SIZE(fs
->super
) - 1) /
362 EXT2_BLOCK_SIZE(fs
->super
));
364 if (block_size
!= fs
->blocksize
) {
365 retval
= EXT2_ET_UNEXPECTED_BLOCK_SIZE
;
370 * Set the blocksize to the filesystem's blocksize.
372 io_channel_set_blksize(fs
->io
, fs
->blocksize
);
375 * If this is an external journal device, don't try to read
376 * the group descriptors, because they're not there.
378 if (ext2fs_has_feature_journal_dev(fs
->super
)) {
379 fs
->group_desc_count
= 0;
384 if (EXT2_INODES_PER_GROUP(fs
->super
) == 0) {
385 retval
= EXT2_ET_CORRUPT_SUPERBLOCK
;
388 /* Precompute the FS UUID to seed other checksums */
389 ext2fs_init_csum_seed(fs
);
392 * Read group descriptors
394 blocks_per_group
= EXT2_BLOCKS_PER_GROUP(fs
->super
);
395 if (blocks_per_group
< 8 ||
396 blocks_per_group
> EXT2_MAX_BLOCKS_PER_GROUP(fs
->super
) ||
397 fs
->inode_blocks_per_group
> EXT2_MAX_INODES_PER_GROUP(fs
->super
) ||
398 EXT2_DESC_PER_BLOCK(fs
->super
) == 0 ||
399 fs
->super
->s_first_data_block
>= ext2fs_blocks_count(fs
->super
)) {
400 retval
= EXT2_ET_CORRUPT_SUPERBLOCK
;
403 groups_cnt
= ext2fs_div64_ceil(ext2fs_blocks_count(fs
->super
) -
404 fs
->super
->s_first_data_block
,
406 if (groups_cnt
>> 32) {
407 retval
= EXT2_ET_CORRUPT_SUPERBLOCK
;
410 fs
->group_desc_count
= groups_cnt
;
411 if (!(flags
& EXT2_FLAG_IGNORE_SB_ERRORS
) &&
412 (__u64
)fs
->group_desc_count
* EXT2_INODES_PER_GROUP(fs
->super
) !=
413 fs
->super
->s_inodes_count
) {
414 retval
= EXT2_ET_CORRUPT_SUPERBLOCK
;
417 fs
->desc_blocks
= ext2fs_div_ceil(fs
->group_desc_count
,
418 EXT2_DESC_PER_BLOCK(fs
->super
));
419 if (ext2fs_has_feature_meta_bg(fs
->super
) &&
420 (fs
->super
->s_first_meta_bg
> fs
->desc_blocks
) &&
421 !(flags
& EXT2_FLAG_IGNORE_SB_ERRORS
)) {
422 retval
= EXT2_ET_CORRUPT_SUPERBLOCK
;
425 if (flags
& EXT2_FLAG_SUPER_ONLY
)
427 retval
= ext2fs_get_array(fs
->desc_blocks
, fs
->blocksize
,
432 group_block
= fs
->super
->s_first_data_block
;
434 * On a FS with a 1K blocksize, block 0 is reserved for bootloaders
435 * so we must increment block numbers to any group 0 items.
437 * However, we cannot touch group_block directly because in the meta_bg
438 * case, the ext2fs_descriptor_block_loc2() function will interpret
439 * group_block != s_first_data_block to mean that we want to access the
440 * backup group descriptors. This is not what we want if the caller
441 * set superblock == 0 (i.e. auto-detect the superblock), which is
442 * what's going on here.
444 if (group_block
== 0 && fs
->blocksize
== 1024)
445 group_zero_adjust
= 1;
446 dest
= (char *) fs
->group_desc
;
447 #ifdef WORDS_BIGENDIAN
448 groups_per_block
= EXT2_DESC_PER_BLOCK(fs
->super
);
450 if (ext2fs_has_feature_meta_bg(fs
->super
) &&
451 !(flags
& EXT2_FLAG_IMAGE_FILE
)) {
452 first_meta_bg
= fs
->super
->s_first_meta_bg
;
453 if (first_meta_bg
> fs
->desc_blocks
)
454 first_meta_bg
= fs
->desc_blocks
;
456 first_meta_bg
= fs
->desc_blocks
;
458 retval
= io_channel_read_blk(fs
->io
, group_block
+
459 group_zero_adjust
+ 1,
460 first_meta_bg
, dest
);
463 #ifdef WORDS_BIGENDIAN
464 gdp
= (struct ext2_group_desc
*) dest
;
465 for (j
=0; j
< groups_per_block
*first_meta_bg
; j
++) {
466 gdp
= ext2fs_group_desc(fs
, fs
->group_desc
, j
);
468 ext2fs_swap_group_desc2(fs
, gdp
);
471 dest
+= fs
->blocksize
*first_meta_bg
;
474 for (i
= first_meta_bg
; i
< fs
->desc_blocks
; i
++) {
475 blk
= ext2fs_descriptor_block_loc2(fs
, group_block
, i
);
476 io_channel_cache_readahead(fs
->io
, blk
, 1);
479 for (i
=first_meta_bg
; i
< fs
->desc_blocks
; i
++) {
480 blk
= ext2fs_descriptor_block_loc2(fs
, group_block
, i
);
481 retval
= io_channel_read_blk64(fs
->io
, blk
, 1, dest
);
484 #ifdef WORDS_BIGENDIAN
485 for (j
=0; j
< groups_per_block
; j
++) {
486 gdp
= ext2fs_group_desc(fs
, fs
->group_desc
,
487 i
* groups_per_block
+ j
);
489 ext2fs_swap_group_desc2(fs
, gdp
);
492 dest
+= fs
->blocksize
;
495 fs
->stride
= fs
->super
->s_raid_stride
;
498 * If recovery is from backup superblock, Clear _UNININT flags &
499 * reset bg_itable_unused to zero
501 if (superblock
> 1 && ext2fs_has_group_desc_csum(fs
)) {
504 for (group
= 0; group
< fs
->group_desc_count
; group
++) {
505 ext2fs_bg_flags_clear(fs
, group
, EXT2_BG_BLOCK_UNINIT
);
506 ext2fs_bg_flags_clear(fs
, group
, EXT2_BG_INODE_UNINIT
);
507 ext2fs_bg_itable_unused_set(fs
, group
, 0);
508 /* The checksum will be reset later, but fix it here
509 * anyway to avoid printing a lot of spurious errors. */
510 ext2fs_group_desc_csum_set(fs
, group
);
512 if (fs
->flags
& EXT2_FLAG_RW
)
513 ext2fs_mark_super_dirty(fs
);
516 if (ext2fs_has_feature_mmp(fs
->super
) &&
517 !(flags
& EXT2_FLAG_SKIP_MMP
) &&
518 (flags
& (EXT2_FLAG_RW
| EXT2_FLAG_EXCLUSIVE
))) {
519 retval
= ext2fs_mmp_start(fs
);
521 fs
->flags
|= EXT2_FLAG_SKIP_MMP
; /* just do cleanup */
527 if (fs
->flags
& EXT2_FLAG_SHARE_DUP
) {
528 fs
->block_sha_map
= ext2fs_hashmap_create(ext2fs_djb2_hash
,
529 block_sha_map_free_entry
, 4096);
530 if (!fs
->block_sha_map
) {
531 retval
= EXT2_ET_NO_MEMORY
;
534 ext2fs_set_feature_shared_blocks(fs
->super
);
537 if (ext2fs_has_feature_casefold(fs
->super
))
538 fs
->encoding
= ext2fs_load_nls_table(fs
->super
->s_encoding
);
540 fs
->flags
&= ~EXT2_FLAG_NOFREE_ON_ERROR
;
545 if (!(flags
& EXT2_FLAG_NOFREE_ON_ERROR
)) {
554 * Set/get the filesystem data I/O channel.
556 * These functions are only valid if EXT2_FLAG_IMAGE_FILE is true.
558 errcode_t
ext2fs_get_data_io(ext2_filsys fs
, io_channel
*old_io
)
560 if ((fs
->flags
& EXT2_FLAG_IMAGE_FILE
) == 0)
561 return EXT2_ET_NOT_IMAGE_FILE
;
563 *old_io
= (fs
->image_io
== fs
->io
) ? 0 : fs
->io
;
568 errcode_t
ext2fs_set_data_io(ext2_filsys fs
, io_channel new_io
)
570 if ((fs
->flags
& EXT2_FLAG_IMAGE_FILE
) == 0)
571 return EXT2_ET_NOT_IMAGE_FILE
;
572 fs
->io
= new_io
? new_io
: fs
->image_io
;
576 errcode_t
ext2fs_rewrite_to_io(ext2_filsys fs
, io_channel new_io
)
580 if ((fs
->flags
& EXT2_FLAG_IMAGE_FILE
) == 0)
581 return EXT2_ET_NOT_IMAGE_FILE
;
582 err
= io_channel_set_blksize(new_io
, fs
->blocksize
);
585 if ((new_io
== fs
->image_io
) || (new_io
== fs
->io
))
587 if ((fs
->image_io
!= fs
->io
) &&
589 io_channel_close(fs
->image_io
);
591 io_channel_close(fs
->io
);
592 fs
->io
= fs
->image_io
= new_io
;
593 fs
->flags
|= EXT2_FLAG_DIRTY
| EXT2_FLAG_RW
|
594 EXT2_FLAG_BB_DIRTY
| EXT2_FLAG_IB_DIRTY
;
595 fs
->flags
&= ~EXT2_FLAG_IMAGE_FILE
;