2 * initialize.c --- initialize a filesystem handle given superblock
3 * parameters. Used by mke2fs when initializing a filesystem.
5 * Copyright (C) 1994, 1995, 1996 Theodore Ts'o.
8 * This file may be redistributed under the terms of the GNU Library
9 * General Public License, version 2.
25 #include <sys/types.h>
31 #if defined(__linux__) && defined(EXT2_OS_LINUX)
32 #define CREATOR_OS EXT2_OS_LINUX
34 #if defined(__GNU__) && defined(EXT2_OS_HURD)
35 #define CREATOR_OS EXT2_OS_HURD
37 #if defined(__FreeBSD__) && defined(EXT2_OS_FREEBSD)
38 #define CREATOR_OS EXT2_OS_FREEBSD
40 #if defined(LITES) && defined(EXT2_OS_LITES)
41 #define CREATOR_OS EXT2_OS_LITES
43 #define CREATOR_OS EXT2_OS_LINUX /* by default */
44 #endif /* defined(LITES) && defined(EXT2_OS_LITES) */
45 #endif /* defined(__FreeBSD__) && defined(EXT2_OS_FREEBSD) */
46 #endif /* defined(__GNU__) && defined(EXT2_OS_HURD) */
47 #endif /* defined(__linux__) && defined(EXT2_OS_LINUX) */
50 * Calculate the number of GDT blocks to reserve for online filesystem growth.
51 * The absolute maximum number of GDT blocks we can reserve is determined by
52 * the number of block pointers that can fit into a single block.
54 static unsigned int calc_reserved_gdt_blocks(ext2_filsys fs
)
56 struct ext2_super_block
*sb
= fs
->super
;
57 unsigned long bpg
= sb
->s_blocks_per_group
;
58 unsigned int gdpb
= EXT2_DESC_PER_BLOCK(sb
);
59 unsigned long max_blocks
= 0xffffffff;
60 unsigned long rsv_groups
;
63 /* We set it at 1024x the current filesystem size, or
64 * the upper block count limit (2^32), whichever is lower.
66 if (ext2fs_blocks_count(sb
) < max_blocks
/ 1024)
67 max_blocks
= ext2fs_blocks_count(sb
) * 1024;
69 * ext2fs_div64_ceil() is unnecessary because max_blocks is
70 * max _GDT_ blocks, which is limited to 32 bits.
72 rsv_groups
= ext2fs_div_ceil(max_blocks
- sb
->s_first_data_block
, bpg
);
73 rsv_gdb
= ext2fs_div_ceil(rsv_groups
, gdpb
) - fs
->desc_blocks
;
74 if (rsv_gdb
> EXT2_ADDR_PER_BLOCK(sb
))
75 rsv_gdb
= EXT2_ADDR_PER_BLOCK(sb
);
77 printf("max_blocks %lu, rsv_groups = %lu, rsv_gdb = %u\n",
78 max_blocks
, rsv_groups
, rsv_gdb
);
84 errcode_t
ext2fs_initialize(const char *name
, int flags
,
85 struct ext2_super_block
*param
,
86 io_manager manager
, ext2_filsys
*ret_fs
)
90 struct ext2_super_block
*super
;
92 unsigned int overhead
= 0;
101 unsigned reserved_inos
;
104 double reserved_ratio
;
106 if (!param
|| !ext2fs_blocks_count(param
))
107 return EXT2_ET_INVALID_ARGUMENT
;
109 retval
= ext2fs_get_mem(sizeof(struct struct_ext2_filsys
), &fs
);
113 memset(fs
, 0, sizeof(struct struct_ext2_filsys
));
114 fs
->magic
= EXT2_ET_MAGIC_EXT2FS_FILSYS
;
115 fs
->flags
= flags
| EXT2_FLAG_RW
;
117 fs
->default_bitmap_type
= EXT2FS_BMAP64_RBTREE
;
118 #ifdef WORDS_BIGENDIAN
119 fs
->flags
|= EXT2_FLAG_SWAP_BYTES
;
121 io_flags
= IO_FLAG_RW
;
122 if (flags
& EXT2_FLAG_EXCLUSIVE
)
123 io_flags
|= IO_FLAG_EXCLUSIVE
;
124 if (flags
& EXT2_FLAG_DIRECT_IO
)
125 io_flags
|= IO_FLAG_DIRECT_IO
;
126 retval
= manager
->open(name
, io_flags
, &fs
->io
);
129 fs
->image_io
= fs
->io
;
130 fs
->io
->app_data
= fs
;
131 retval
= ext2fs_get_mem(strlen(name
)+1, &fs
->device_name
);
135 strcpy(fs
->device_name
, name
);
136 retval
= ext2fs_get_mem(SUPERBLOCK_SIZE
, &super
);
141 memset(super
, 0, SUPERBLOCK_SIZE
);
143 #define set_field(field, default) (super->field = param->field ? \
144 param->field : (default))
145 #define assign_field(field) (super->field = param->field)
147 super
->s_magic
= EXT2_SUPER_MAGIC
;
148 super
->s_state
= EXT2_VALID_FS
;
150 bigalloc_flag
= ext2fs_has_feature_bigalloc(param
);
152 assign_field(s_log_block_size
);
155 set_field(s_log_cluster_size
, super
->s_log_block_size
+4);
156 if (super
->s_log_block_size
> super
->s_log_cluster_size
) {
157 retval
= EXT2_ET_INVALID_ARGUMENT
;
161 super
->s_log_cluster_size
= super
->s_log_block_size
;
163 set_field(s_first_data_block
, super
->s_log_cluster_size
? 0 : 1);
164 set_field(s_max_mnt_count
, 0);
165 set_field(s_errors
, EXT2_ERRORS_DEFAULT
);
166 set_field(s_feature_compat
, 0);
167 set_field(s_feature_incompat
, 0);
168 set_field(s_feature_ro_compat
, 0);
169 set_field(s_default_mount_opts
, 0);
170 set_field(s_first_meta_bg
, 0);
171 set_field(s_raid_stride
, 0); /* default stride size: 0 */
172 set_field(s_raid_stripe_width
, 0); /* default stripe width: 0 */
173 set_field(s_log_groups_per_flex
, 0);
174 set_field(s_flags
, 0);
175 assign_field(s_backup_bgs
[0]);
176 assign_field(s_backup_bgs
[1]);
177 if (super
->s_feature_incompat
& ~EXT2_LIB_FEATURE_INCOMPAT_SUPP
) {
178 retval
= EXT2_ET_UNSUPP_FEATURE
;
181 if (super
->s_feature_ro_compat
& ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP
) {
182 retval
= EXT2_ET_RO_UNSUPP_FEATURE
;
186 set_field(s_rev_level
, EXT2_GOOD_OLD_REV
);
187 if (super
->s_rev_level
>= EXT2_DYNAMIC_REV
) {
188 set_field(s_first_ino
, EXT2_GOOD_OLD_FIRST_INO
);
189 set_field(s_inode_size
, EXT2_GOOD_OLD_INODE_SIZE
);
190 if (super
->s_inode_size
>= sizeof(struct ext2_inode_large
)) {
191 int extra_isize
= sizeof(struct ext2_inode_large
) -
192 EXT2_GOOD_OLD_INODE_SIZE
;
193 set_field(s_min_extra_isize
, extra_isize
);
194 set_field(s_want_extra_isize
, extra_isize
);
197 super
->s_first_ino
= EXT2_GOOD_OLD_FIRST_INO
;
198 super
->s_inode_size
= EXT2_GOOD_OLD_INODE_SIZE
;
201 set_field(s_checkinterval
, 0);
202 super
->s_mkfs_time
= super
->s_lastcheck
= fs
->now
? fs
->now
: time(NULL
);
204 super
->s_creator_os
= CREATOR_OS
;
206 fs
->fragsize
= fs
->blocksize
= EXT2_BLOCK_SIZE(super
);
207 fs
->cluster_ratio_bits
= super
->s_log_cluster_size
-
208 super
->s_log_block_size
;
211 unsigned long long bpg
;
213 if (param
->s_blocks_per_group
&&
214 param
->s_clusters_per_group
&&
215 ((param
->s_clusters_per_group
* EXT2FS_CLUSTER_RATIO(fs
)) !=
216 param
->s_blocks_per_group
)) {
217 retval
= EXT2_ET_INVALID_ARGUMENT
;
220 if (param
->s_clusters_per_group
)
221 assign_field(s_clusters_per_group
);
222 else if (param
->s_blocks_per_group
)
223 super
->s_clusters_per_group
=
224 param
->s_blocks_per_group
/
225 EXT2FS_CLUSTER_RATIO(fs
);
226 else if (super
->s_log_cluster_size
+ 15 < 32)
227 super
->s_clusters_per_group
= fs
->blocksize
* 8;
229 super
->s_clusters_per_group
= (fs
->blocksize
- 1) * 8;
230 if (super
->s_clusters_per_group
> EXT2_MAX_CLUSTERS_PER_GROUP(super
))
231 super
->s_clusters_per_group
= EXT2_MAX_CLUSTERS_PER_GROUP(super
);
233 (unsigned long long) super
->s_clusters_per_group
);
234 if (bpg
>= (((unsigned long long) 1) << 32)) {
235 retval
= EXT2_ET_INVALID_ARGUMENT
;
238 super
->s_blocks_per_group
= bpg
;
240 set_field(s_blocks_per_group
, fs
->blocksize
* 8);
241 if (super
->s_blocks_per_group
> EXT2_MAX_BLOCKS_PER_GROUP(super
))
242 super
->s_blocks_per_group
= EXT2_MAX_BLOCKS_PER_GROUP(super
);
243 super
->s_clusters_per_group
= super
->s_blocks_per_group
;
246 ext2fs_blocks_count_set(super
, ext2fs_blocks_count(param
) &
247 ~((blk64_t
) EXT2FS_CLUSTER_MASK(fs
)));
248 ext2fs_r_blocks_count_set(super
, ext2fs_r_blocks_count(param
));
249 if (ext2fs_r_blocks_count(super
) >= ext2fs_blocks_count(param
)) {
250 retval
= EXT2_ET_INVALID_ARGUMENT
;
254 set_field(s_mmp_update_interval
, 0);
257 * If we're creating an external journal device, we don't need
258 * to bother with the rest.
260 if (ext2fs_has_feature_journal_dev(super
)) {
261 fs
->group_desc_count
= 0;
262 ext2fs_mark_super_dirty(fs
);
268 fs
->group_desc_count
= (dgrp_t
) ext2fs_div64_ceil(
269 ext2fs_blocks_count(super
) - super
->s_first_data_block
,
270 EXT2_BLOCKS_PER_GROUP(super
));
271 if (fs
->group_desc_count
== 0) {
272 retval
= EXT2_ET_TOOSMALL
;
276 set_field(s_desc_size
,
277 ext2fs_has_feature_64bit(super
) ?
278 EXT2_MIN_DESC_SIZE_64BIT
: 0);
280 fs
->desc_blocks
= ext2fs_div_ceil(fs
->group_desc_count
,
281 EXT2_DESC_PER_BLOCK(super
));
283 i
= fs
->blocksize
>= 4096 ? 1 : 4096 / fs
->blocksize
;
285 if (ext2fs_has_feature_64bit(super
) &&
286 (ext2fs_blocks_count(super
) / i
) > (1ULL << 32))
287 set_field(s_inodes_count
, ~0U);
289 set_field(s_inodes_count
, ext2fs_blocks_count(super
) / i
);
292 * Make sure we have at least EXT2_FIRST_INO + 1 inodes, so
293 * that we have enough inodes for the filesystem(!)
295 if (super
->s_inodes_count
< EXT2_FIRST_INODE(super
)+1)
296 super
->s_inodes_count
= EXT2_FIRST_INODE(super
)+1;
299 * There should be at least as many inodes as the user
300 * requested. Figure out how many inodes per group that
301 * should be. But make sure that we don't allocate more than
302 * one bitmap's worth of inodes each group.
304 ipg
= ext2fs_div_ceil(super
->s_inodes_count
, fs
->group_desc_count
);
305 if (ipg
> fs
->blocksize
* 8) {
306 if (!bigalloc_flag
&& super
->s_blocks_per_group
>= 256) {
307 /* Try again with slightly different parameters */
308 super
->s_blocks_per_group
-= 8;
309 ext2fs_blocks_count_set(super
,
310 ext2fs_blocks_count(param
));
311 super
->s_clusters_per_group
= super
->s_blocks_per_group
;
314 retval
= EXT2_ET_TOO_MANY_INODES
;
319 if (ipg
> (unsigned) EXT2_MAX_INODES_PER_GROUP(super
))
320 ipg
= EXT2_MAX_INODES_PER_GROUP(super
);
323 super
->s_inodes_per_group
= ipg
;
326 * Make sure the number of inodes per group completely fills
327 * the inode table blocks in the descriptor. If not, add some
328 * additional inodes/group. Waste not, want not...
330 fs
->inode_blocks_per_group
= (((super
->s_inodes_per_group
*
331 EXT2_INODE_SIZE(super
)) +
332 EXT2_BLOCK_SIZE(super
) - 1) /
333 EXT2_BLOCK_SIZE(super
));
334 super
->s_inodes_per_group
= ((fs
->inode_blocks_per_group
*
335 EXT2_BLOCK_SIZE(super
)) /
336 EXT2_INODE_SIZE(super
));
338 * Finally, make sure the number of inodes per group is a
339 * multiple of 8. This is needed to simplify the bitmap
342 if (super
->s_inodes_per_group
< 8)
343 super
->s_inodes_per_group
= 8;
344 super
->s_inodes_per_group
&= ~7;
345 fs
->inode_blocks_per_group
= (((super
->s_inodes_per_group
*
346 EXT2_INODE_SIZE(super
)) +
347 EXT2_BLOCK_SIZE(super
) - 1) /
348 EXT2_BLOCK_SIZE(super
));
351 * adjust inode count to reflect the adjusted inodes_per_group
353 if ((__u64
)super
->s_inodes_per_group
* fs
->group_desc_count
> ~0U) {
357 super
->s_inodes_count
= super
->s_inodes_per_group
*
358 fs
->group_desc_count
;
359 super
->s_free_inodes_count
= super
->s_inodes_count
;
362 * check the number of reserved group descriptor table blocks
364 if (ext2fs_has_feature_resize_inode(super
))
365 rsv_gdt
= calc_reserved_gdt_blocks(fs
);
368 set_field(s_reserved_gdt_blocks
, rsv_gdt
);
369 if (super
->s_reserved_gdt_blocks
> EXT2_ADDR_PER_BLOCK(super
)) {
370 retval
= EXT2_ET_RES_GDT_BLOCKS
;
375 * Calculate the maximum number of bookkeeping blocks per
376 * group. It includes the superblock, the block group
377 * descriptors, the block bitmap, the inode bitmap, the inode
378 * table, and the reserved gdt blocks.
380 overhead
= (int) (3 + fs
->inode_blocks_per_group
+
381 super
->s_reserved_gdt_blocks
);
383 /* Enable meta_bg if we'd lose more than 3/4 of a BG to GDT blocks. */
384 if (super
->s_reserved_gdt_blocks
+ fs
->desc_blocks
>
385 super
->s_blocks_per_group
* 3 / 4)
386 ext2fs_set_feature_meta_bg(fs
->super
);
388 if (ext2fs_has_feature_meta_bg(fs
->super
))
391 overhead
+= fs
->desc_blocks
;
393 /* This can only happen if the user requested too many inodes */
394 if (overhead
> super
->s_blocks_per_group
) {
395 retval
= EXT2_ET_TOO_MANY_INODES
;
400 * See if the last group is big enough to support the
401 * necessary data structures. If not, we need to get rid of
402 * it. We need to recalculate the overhead for the last block
403 * group, since it might or might not have a superblock
406 overhead
= (int) (2 + fs
->inode_blocks_per_group
);
407 if (ext2fs_bg_has_super(fs
, fs
->group_desc_count
- 1))
408 overhead
+= 1 + fs
->desc_blocks
+ super
->s_reserved_gdt_blocks
;
409 rem
= ((ext2fs_blocks_count(super
) - super
->s_first_data_block
) %
410 super
->s_blocks_per_group
);
411 if ((fs
->group_desc_count
== 1) && rem
&& (rem
< overhead
)) {
412 retval
= EXT2_ET_TOOSMALL
;
415 if (rem
&& (rem
< overhead
+50)) {
416 ext2fs_blocks_count_set(super
, ext2fs_blocks_count(super
) -
419 * If blocks count is changed, we need to recalculate
420 * reserved blocks count not to exceed 50%.
422 reserved_ratio
= 100.0 * ext2fs_r_blocks_count(param
) /
423 ext2fs_blocks_count(param
);
424 ext2fs_r_blocks_count_set(super
, reserved_ratio
*
425 ext2fs_blocks_count(super
) / 100.0);
431 * At this point we know how big the filesystem will be. So
432 * we can do any and all allocations that depend on the block
436 /* Set up the locations of the backup superblocks */
437 if (ext2fs_has_feature_sparse_super2(super
)) {
438 if (super
->s_backup_bgs
[0] >= fs
->group_desc_count
)
439 super
->s_backup_bgs
[0] = fs
->group_desc_count
- 1;
440 if (super
->s_backup_bgs
[1] >= fs
->group_desc_count
)
441 super
->s_backup_bgs
[1] = fs
->group_desc_count
- 1;
442 if (super
->s_backup_bgs
[0] == super
->s_backup_bgs
[1])
443 super
->s_backup_bgs
[1] = 0;
444 if (super
->s_backup_bgs
[0] > super
->s_backup_bgs
[1]) {
445 __u32 t
= super
->s_backup_bgs
[0];
446 super
->s_backup_bgs
[0] = super
->s_backup_bgs
[1];
447 super
->s_backup_bgs
[1] = t
;
451 retval
= ext2fs_get_mem(strlen(fs
->device_name
) + 80, &buf
);
455 strcpy(buf
, "block bitmap for ");
456 strcat(buf
, fs
->device_name
);
457 retval
= ext2fs_allocate_subcluster_bitmap(fs
, buf
, &fs
->block_map
);
461 strcpy(buf
, "inode bitmap for ");
462 strcat(buf
, fs
->device_name
);
463 retval
= ext2fs_allocate_inode_bitmap(fs
, buf
, &fs
->inode_map
);
467 ext2fs_free_mem(&buf
);
469 retval
= ext2fs_get_array(fs
->desc_blocks
, fs
->blocksize
,
474 memset(fs
->group_desc
, 0, (size_t) fs
->desc_blocks
* fs
->blocksize
);
477 * Reserve the superblock and group descriptors for each
478 * group, and fill in the correct group statistics for group.
479 * Note that although the block bitmap, inode bitmap, and
480 * inode table have not been allocated (and in fact won't be
481 * by this routine), they are accounted for nevertheless.
483 * If FLEX_BG meta-data grouping is used, only account for the
484 * superblock and group descriptors (the inode tables and
485 * bitmaps will be accounted for when allocated).
488 csum_flag
= ext2fs_has_group_desc_csum(fs
);
489 reserved_inos
= super
->s_first_ino
;
490 for (i
= 0; i
< fs
->group_desc_count
; i
++) {
492 * Don't set the BLOCK_UNINIT group for the last group
493 * because the block bitmap needs to be padded.
496 if (i
!= fs
->group_desc_count
- 1)
497 ext2fs_bg_flags_set(fs
, i
,
498 EXT2_BG_BLOCK_UNINIT
);
499 ext2fs_bg_flags_set(fs
, i
, EXT2_BG_INODE_UNINIT
);
500 numblocks
= super
->s_inodes_per_group
;
502 if (numblocks
> reserved_inos
) {
503 numblocks
-= reserved_inos
;
506 reserved_inos
-= numblocks
;
510 ext2fs_bg_itable_unused_set(fs
, i
, numblocks
);
512 numblocks
= ext2fs_reserve_super_and_bgd(fs
, i
, fs
->block_map
);
513 if (fs
->super
->s_log_groups_per_flex
)
514 numblocks
+= 2 + fs
->inode_blocks_per_group
;
516 free_blocks
+= numblocks
;
517 ext2fs_bg_free_blocks_count_set(fs
, i
, numblocks
);
518 ext2fs_bg_free_inodes_count_set(fs
, i
, fs
->super
->s_inodes_per_group
);
519 ext2fs_bg_used_dirs_count_set(fs
, i
, 0);
520 ext2fs_group_desc_csum_set(fs
, i
);
522 free_blocks
&= ~EXT2FS_CLUSTER_MASK(fs
);
523 ext2fs_free_blocks_count_set(super
, free_blocks
);
526 if (((int) c
) == -1) {
527 super
->s_flags
|= EXT2_FLAGS_SIGNED_HASH
;
529 super
->s_flags
|= EXT2_FLAGS_UNSIGNED_HASH
;
532 ext2fs_mark_super_dirty(fs
);
533 ext2fs_mark_bb_dirty(fs
);
534 ext2fs_mark_ib_dirty(fs
);
536 io_channel_set_blksize(fs
->io
, fs
->blocksize
);