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.
24 #include <sys/types.h>
30 #if defined(__linux__) && defined(EXT2_OS_LINUX)
31 #define CREATOR_OS EXT2_OS_LINUX
33 #if defined(__GNU__) && defined(EXT2_OS_HURD)
34 #define CREATOR_OS EXT2_OS_HURD
36 #if defined(__FreeBSD__) && defined(EXT2_OS_FREEBSD)
37 #define CREATOR_OS EXT2_OS_FREEBSD
39 #if defined(LITES) && defined(EXT2_OS_LITES)
40 #define CREATOR_OS EXT2_OS_LITES
42 #define CREATOR_OS EXT2_OS_LINUX /* by default */
43 #endif /* defined(LITES) && defined(EXT2_OS_LITES) */
44 #endif /* defined(__FreeBSD__) && defined(EXT2_OS_FREEBSD) */
45 #endif /* defined(__GNU__) && defined(EXT2_OS_HURD) */
46 #endif /* defined(__linux__) && defined(EXT2_OS_LINUX) */
49 * Calculate the number of GDT blocks to reserve for online filesystem growth.
50 * The absolute maximum number of GDT blocks we can reserve is determined by
51 * the number of block pointers that can fit into a single block.
53 static unsigned int calc_reserved_gdt_blocks(ext2_filsys fs
)
55 struct ext2_super_block
*sb
= fs
->super
;
56 unsigned long bpg
= sb
->s_blocks_per_group
;
57 unsigned int gdpb
= EXT2_DESC_PER_BLOCK(sb
);
58 unsigned long max_blocks
= 0xffffffff;
59 unsigned long rsv_groups
;
62 /* We set it at 1024x the current filesystem size, or
63 * the upper block count limit (2^32), whichever is lower.
65 if (sb
->s_blocks_count
< max_blocks
/ 1024)
66 max_blocks
= sb
->s_blocks_count
* 1024;
67 rsv_groups
= ext2fs_div_ceil(max_blocks
- sb
->s_first_data_block
, bpg
);
68 rsv_gdb
= ext2fs_div_ceil(rsv_groups
, gdpb
) - fs
->desc_blocks
;
69 if (rsv_gdb
> EXT2_ADDR_PER_BLOCK(sb
))
70 rsv_gdb
= EXT2_ADDR_PER_BLOCK(sb
);
72 printf("max_blocks %lu, rsv_groups = %lu, rsv_gdb = %u\n",
73 max_blocks
, rsv_groups
, rsv_gdb
);
79 errcode_t
ext2fs_initialize(const char *name
, int flags
,
80 struct ext2_super_block
*param
,
81 io_manager manager
, ext2_filsys
*ret_fs
)
85 struct ext2_super_block
*super
;
87 unsigned int overhead
= 0;
97 if (!param
|| !param
->s_blocks_count
)
98 return EXT2_ET_INVALID_ARGUMENT
;
100 retval
= ext2fs_get_mem(sizeof(struct struct_ext2_filsys
), &fs
);
104 memset(fs
, 0, sizeof(struct struct_ext2_filsys
));
105 fs
->magic
= EXT2_ET_MAGIC_EXT2FS_FILSYS
;
106 fs
->flags
= flags
| EXT2_FLAG_RW
;
108 #ifdef WORDS_BIGENDIAN
109 fs
->flags
|= EXT2_FLAG_SWAP_BYTES
;
111 io_flags
= IO_FLAG_RW
;
112 if (flags
& EXT2_FLAG_EXCLUSIVE
)
113 io_flags
|= IO_FLAG_EXCLUSIVE
;
114 retval
= manager
->open(name
, io_flags
, &fs
->io
);
117 fs
->image_io
= fs
->io
;
118 fs
->io
->app_data
= fs
;
119 retval
= ext2fs_get_mem(strlen(name
)+1, &fs
->device_name
);
123 strcpy(fs
->device_name
, name
);
124 retval
= ext2fs_get_mem(SUPERBLOCK_SIZE
, &super
);
129 memset(super
, 0, SUPERBLOCK_SIZE
);
131 #define set_field(field, default) (super->field = param->field ? \
132 param->field : (default))
134 super
->s_magic
= EXT2_SUPER_MAGIC
;
135 super
->s_state
= EXT2_VALID_FS
;
137 set_field(s_log_block_size
, 0); /* default blocksize: 1024 bytes */
138 set_field(s_log_cluster_size
, 0);
139 set_field(s_first_data_block
, super
->s_log_block_size
? 0 : 1);
140 set_field(s_max_mnt_count
, 0);
141 set_field(s_errors
, EXT2_ERRORS_DEFAULT
);
142 set_field(s_feature_compat
, 0);
143 set_field(s_feature_incompat
, 0);
144 set_field(s_feature_ro_compat
, 0);
145 set_field(s_default_mount_opts
, 0);
146 set_field(s_first_meta_bg
, 0);
147 set_field(s_raid_stride
, 0); /* default stride size: 0 */
148 set_field(s_raid_stripe_width
, 0); /* default stripe width: 0 */
149 set_field(s_log_groups_per_flex
, 0);
150 set_field(s_flags
, 0);
151 if (super
->s_feature_incompat
& ~EXT2_LIB_FEATURE_INCOMPAT_SUPP
) {
152 retval
= EXT2_ET_UNSUPP_FEATURE
;
155 if (super
->s_feature_ro_compat
& ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP
) {
156 retval
= EXT2_ET_RO_UNSUPP_FEATURE
;
160 set_field(s_rev_level
, EXT2_GOOD_OLD_REV
);
161 if (super
->s_rev_level
>= EXT2_DYNAMIC_REV
) {
162 set_field(s_first_ino
, EXT2_GOOD_OLD_FIRST_INO
);
163 set_field(s_inode_size
, EXT2_GOOD_OLD_INODE_SIZE
);
164 if (super
->s_inode_size
>= sizeof(struct ext2_inode_large
)) {
165 int extra_isize
= sizeof(struct ext2_inode_large
) -
166 EXT2_GOOD_OLD_INODE_SIZE
;
167 set_field(s_min_extra_isize
, extra_isize
);
168 set_field(s_want_extra_isize
, extra_isize
);
171 super
->s_first_ino
= EXT2_GOOD_OLD_FIRST_INO
;
172 super
->s_inode_size
= EXT2_GOOD_OLD_INODE_SIZE
;
175 set_field(s_checkinterval
, 0);
176 super
->s_mkfs_time
= super
->s_lastcheck
= fs
->now
? fs
->now
: time(NULL
);
178 super
->s_creator_os
= CREATOR_OS
;
180 fs
->blocksize
= EXT2_BLOCK_SIZE(super
);
181 fs
->clustersize
= EXT2_CLUSTER_SIZE(super
);
183 /* default: (fs->blocksize*8) blocks/group, up to 2^16 (GDT limit) */
184 set_field(s_blocks_per_group
, fs
->blocksize
* 8);
185 if (super
->s_blocks_per_group
> EXT2_MAX_BLOCKS_PER_GROUP(super
))
186 super
->s_blocks_per_group
= EXT2_MAX_BLOCKS_PER_GROUP(super
);
187 super
->s_clusters_per_group
= super
->s_blocks_per_group
;
189 super
->s_blocks_count
= param
->s_blocks_count
;
190 super
->s_r_blocks_count
= param
->s_r_blocks_count
;
191 if (super
->s_r_blocks_count
>= param
->s_blocks_count
) {
192 retval
= EXT2_ET_INVALID_ARGUMENT
;
197 * If we're creating an external journal device, we don't need
198 * to bother with the rest.
200 if (super
->s_feature_incompat
& EXT3_FEATURE_INCOMPAT_JOURNAL_DEV
) {
201 fs
->group_desc_count
= 0;
202 ext2fs_mark_super_dirty(fs
);
208 fs
->group_desc_count
= ext2fs_div_ceil(super
->s_blocks_count
-
209 super
->s_first_data_block
,
210 EXT2_BLOCKS_PER_GROUP(super
));
211 if (fs
->group_desc_count
== 0) {
212 retval
= EXT2_ET_TOOSMALL
;
215 fs
->desc_blocks
= ext2fs_div_ceil(fs
->group_desc_count
,
216 EXT2_DESC_PER_BLOCK(super
));
218 i
= fs
->blocksize
>= 4096 ? 1 : 4096 / fs
->blocksize
;
219 set_field(s_inodes_count
, super
->s_blocks_count
/ i
);
222 * Make sure we have at least EXT2_FIRST_INO + 1 inodes, so
223 * that we have enough inodes for the filesystem(!)
225 if (super
->s_inodes_count
< EXT2_FIRST_INODE(super
)+1)
226 super
->s_inodes_count
= EXT2_FIRST_INODE(super
)+1;
229 * There should be at least as many inodes as the user
230 * requested. Figure out how many inodes per group that
231 * should be. But make sure that we don't allocate more than
232 * one bitmap's worth of inodes each group.
234 ipg
= ext2fs_div_ceil(super
->s_inodes_count
, fs
->group_desc_count
);
235 if (ipg
> fs
->blocksize
* 8) {
236 if (super
->s_blocks_per_group
>= 256) {
237 /* Try again with slightly different parameters */
238 super
->s_blocks_per_group
-= 8;
239 super
->s_blocks_count
= param
->s_blocks_count
;
240 super
->s_clusters_per_group
= super
->s_blocks_per_group
;
243 retval
= EXT2_ET_TOO_MANY_INODES
;
248 if (ipg
> (unsigned) EXT2_MAX_INODES_PER_GROUP(super
))
249 ipg
= EXT2_MAX_INODES_PER_GROUP(super
);
252 super
->s_inodes_per_group
= ipg
;
255 * Make sure the number of inodes per group completely fills
256 * the inode table blocks in the descriptor. If not, add some
257 * additional inodes/group. Waste not, want not...
259 fs
->inode_blocks_per_group
= (((super
->s_inodes_per_group
*
260 EXT2_INODE_SIZE(super
)) +
261 EXT2_BLOCK_SIZE(super
) - 1) /
262 EXT2_BLOCK_SIZE(super
));
263 super
->s_inodes_per_group
= ((fs
->inode_blocks_per_group
*
264 EXT2_BLOCK_SIZE(super
)) /
265 EXT2_INODE_SIZE(super
));
267 * Finally, make sure the number of inodes per group is a
268 * multiple of 8. This is needed to simplify the bitmap
271 super
->s_inodes_per_group
&= ~7;
272 fs
->inode_blocks_per_group
= (((super
->s_inodes_per_group
*
273 EXT2_INODE_SIZE(super
)) +
274 EXT2_BLOCK_SIZE(super
) - 1) /
275 EXT2_BLOCK_SIZE(super
));
278 * adjust inode count to reflect the adjusted inodes_per_group
280 if ((__u64
)super
->s_inodes_per_group
* fs
->group_desc_count
> ~0U) {
284 super
->s_inodes_count
= super
->s_inodes_per_group
*
285 fs
->group_desc_count
;
286 super
->s_free_inodes_count
= super
->s_inodes_count
;
289 * check the number of reserved group descriptor table blocks
291 if (super
->s_feature_compat
& EXT2_FEATURE_COMPAT_RESIZE_INODE
)
292 rsv_gdt
= calc_reserved_gdt_blocks(fs
);
295 set_field(s_reserved_gdt_blocks
, rsv_gdt
);
296 if (super
->s_reserved_gdt_blocks
> EXT2_ADDR_PER_BLOCK(super
)) {
297 retval
= EXT2_ET_RES_GDT_BLOCKS
;
302 * Calculate the maximum number of bookkeeping blocks per
303 * group. It includes the superblock, the block group
304 * descriptors, the block bitmap, the inode bitmap, the inode
305 * table, and the reserved gdt blocks.
307 overhead
= (int) (3 + fs
->inode_blocks_per_group
+
308 fs
->desc_blocks
+ super
->s_reserved_gdt_blocks
);
310 /* This can only happen if the user requested too many inodes */
311 if (overhead
> super
->s_blocks_per_group
) {
312 retval
= EXT2_ET_TOO_MANY_INODES
;
317 * See if the last group is big enough to support the
318 * necessary data structures. If not, we need to get rid of
319 * it. We need to recalculate the overhead for the last block
320 * group, since it might or might not have a superblock
323 overhead
= (int) (2 + fs
->inode_blocks_per_group
);
324 if (ext2fs_bg_has_super(fs
, fs
->group_desc_count
- 1))
325 overhead
+= 1 + fs
->desc_blocks
+ super
->s_reserved_gdt_blocks
;
326 rem
= ((super
->s_blocks_count
- super
->s_first_data_block
) %
327 super
->s_blocks_per_group
);
328 if ((fs
->group_desc_count
== 1) && rem
&& (rem
< overhead
)) {
329 retval
= EXT2_ET_TOOSMALL
;
332 if (rem
&& (rem
< overhead
+50)) {
333 super
->s_blocks_count
-= rem
;
338 * At this point we know how big the filesystem will be. So
339 * we can do any and all allocations that depend on the block
343 retval
= ext2fs_get_mem(strlen(fs
->device_name
) + 80, &buf
);
347 strcpy(buf
, "block bitmap for ");
348 strcat(buf
, fs
->device_name
);
349 retval
= ext2fs_allocate_block_bitmap(fs
, buf
, &fs
->block_map
);
353 strcpy(buf
, "inode bitmap for ");
354 strcat(buf
, fs
->device_name
);
355 retval
= ext2fs_allocate_inode_bitmap(fs
, buf
, &fs
->inode_map
);
359 ext2fs_free_mem(&buf
);
361 retval
= ext2fs_get_array(fs
->desc_blocks
, fs
->blocksize
,
366 memset(fs
->group_desc
, 0, (size_t) fs
->desc_blocks
* fs
->blocksize
);
369 * Reserve the superblock and group descriptors for each
370 * group, and fill in the correct group statistics for group.
371 * Note that although the block bitmap, inode bitmap, and
372 * inode table have not been allocated (and in fact won't be
373 * by this routine), they are accounted for nevertheless.
375 * If FLEX_BG meta-data grouping is used, only account for the
376 * superblock and group descriptors (the inode tables and
377 * bitmaps will be accounted for when allocated).
379 super
->s_free_blocks_count
= 0;
380 csum_flag
= EXT2_HAS_RO_COMPAT_FEATURE(fs
->super
,
381 EXT4_FEATURE_RO_COMPAT_GDT_CSUM
);
382 for (i
= 0; i
< fs
->group_desc_count
; i
++) {
384 * Don't set the BLOCK_UNINIT group for the last group
385 * because the block bitmap needs to be padded.
388 if (i
!= fs
->group_desc_count
- 1)
389 fs
->group_desc
[i
].bg_flags
|=
390 EXT2_BG_BLOCK_UNINIT
;
391 fs
->group_desc
[i
].bg_flags
|= EXT2_BG_INODE_UNINIT
;
392 numblocks
= super
->s_inodes_per_group
;
394 numblocks
-= super
->s_first_ino
;
395 fs
->group_desc
[i
].bg_itable_unused
= numblocks
;
397 numblocks
= ext2fs_reserve_super_and_bgd(fs
, i
, fs
->block_map
);
398 if (fs
->super
->s_log_groups_per_flex
)
399 numblocks
+= 2 + fs
->inode_blocks_per_group
;
401 super
->s_free_blocks_count
+= numblocks
;
402 fs
->group_desc
[i
].bg_free_blocks_count
= numblocks
;
403 fs
->group_desc
[i
].bg_free_inodes_count
=
404 fs
->super
->s_inodes_per_group
;
405 fs
->group_desc
[i
].bg_used_dirs_count
= 0;
406 ext2fs_group_desc_csum_set(fs
, i
);
410 if (((int) c
) == -1) {
411 super
->s_flags
|= EXT2_FLAGS_SIGNED_HASH
;
413 super
->s_flags
|= EXT2_FLAGS_UNSIGNED_HASH
;
416 ext2fs_mark_super_dirty(fs
);
417 ext2fs_mark_bb_dirty(fs
);
418 ext2fs_mark_ib_dirty(fs
);
420 io_channel_set_blksize(fs
->io
, fs
->blocksize
);