Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 1 | /* |
| 2 | * initialize.c --- initialize a filesystem handle given superblock |
| 3 | * parameters. Used by mke2fs when initializing a filesystem. |
Theodore Ts'o | efc6f62 | 2008-08-27 23:07:54 -0400 | [diff] [blame] | 4 | * |
Theodore Ts'o | 1e3472c | 1997-04-29 14:53:37 +0000 | [diff] [blame] | 5 | * Copyright (C) 1994, 1995, 1996 Theodore Ts'o. |
Theodore Ts'o | efc6f62 | 2008-08-27 23:07:54 -0400 | [diff] [blame] | 6 | * |
Theodore Ts'o | 19c78dc | 1997-04-29 16:17:09 +0000 | [diff] [blame] | 7 | * %Begin-Header% |
Theodore Ts'o | 543547a | 2010-05-17 21:31:56 -0400 | [diff] [blame] | 8 | * This file may be redistributed under the terms of the GNU Library |
| 9 | * General Public License, version 2. |
Theodore Ts'o | 19c78dc | 1997-04-29 16:17:09 +0000 | [diff] [blame] | 10 | * %End-Header% |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 11 | */ |
| 12 | |
Theodore Ts'o | d1154eb | 2011-09-18 17:34:37 -0400 | [diff] [blame] | 13 | #include "config.h" |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 14 | #include <stdio.h> |
| 15 | #include <string.h> |
Theodore Ts'o | 4cbe8af | 1997-08-10 23:07:40 +0000 | [diff] [blame] | 16 | #if HAVE_UNISTD_H |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 17 | #include <unistd.h> |
Theodore Ts'o | 4cbe8af | 1997-08-10 23:07:40 +0000 | [diff] [blame] | 18 | #endif |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 19 | #include <fcntl.h> |
| 20 | #include <time.h> |
Theodore Ts'o | 1d2ff46 | 1997-10-19 23:00:21 +0000 | [diff] [blame] | 21 | #if HAVE_SYS_STAT_H |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 22 | #include <sys/stat.h> |
Theodore Ts'o | 1d2ff46 | 1997-10-19 23:00:21 +0000 | [diff] [blame] | 23 | #endif |
| 24 | #if HAVE_SYS_TYPES_H |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 25 | #include <sys/types.h> |
Theodore Ts'o | 1d2ff46 | 1997-10-19 23:00:21 +0000 | [diff] [blame] | 26 | #endif |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 27 | |
Theodore Ts'o | b5abe6f | 1998-01-19 14:47:53 +0000 | [diff] [blame] | 28 | #include "ext2_fs.h" |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 29 | #include "ext2fs.h" |
| 30 | |
Theodore Ts'o | 48e6e81 | 2003-07-06 00:36:48 -0400 | [diff] [blame] | 31 | #if defined(__linux__) && defined(EXT2_OS_LINUX) |
Theodore Ts'o | 50e1e10 | 1997-04-26 13:58:21 +0000 | [diff] [blame] | 32 | #define CREATOR_OS EXT2_OS_LINUX |
Theodore Ts'o | 48e6e81 | 2003-07-06 00:36:48 -0400 | [diff] [blame] | 33 | #else |
| 34 | #if defined(__GNU__) && defined(EXT2_OS_HURD) |
Theodore Ts'o | 50e1e10 | 1997-04-26 13:58:21 +0000 | [diff] [blame] | 35 | #define CREATOR_OS EXT2_OS_HURD |
Theodore Ts'o | 48e6e81 | 2003-07-06 00:36:48 -0400 | [diff] [blame] | 36 | #else |
| 37 | #if defined(__FreeBSD__) && defined(EXT2_OS_FREEBSD) |
Theodore Ts'o | 50e1e10 | 1997-04-26 13:58:21 +0000 | [diff] [blame] | 38 | #define CREATOR_OS EXT2_OS_FREEBSD |
Theodore Ts'o | 48e6e81 | 2003-07-06 00:36:48 -0400 | [diff] [blame] | 39 | #else |
| 40 | #if defined(LITES) && defined(EXT2_OS_LITES) |
Theodore Ts'o | 50e1e10 | 1997-04-26 13:58:21 +0000 | [diff] [blame] | 41 | #define CREATOR_OS EXT2_OS_LITES |
| 42 | #else |
| 43 | #define CREATOR_OS EXT2_OS_LINUX /* by default */ |
Theodore Ts'o | 48e6e81 | 2003-07-06 00:36:48 -0400 | [diff] [blame] | 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) */ |
Theodore Ts'o | efc6f62 | 2008-08-27 23:07:54 -0400 | [diff] [blame] | 48 | |
Theodore Ts'o | 1e3472c | 1997-04-29 14:53:37 +0000 | [diff] [blame] | 49 | /* |
Theodore Ts'o | d323f8f | 2004-12-15 14:39:16 -0500 | [diff] [blame] | 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. |
| 53 | */ |
Theodore Ts'o | a612f34 | 2006-03-17 20:39:52 -0500 | [diff] [blame] | 54 | static unsigned int calc_reserved_gdt_blocks(ext2_filsys fs) |
Theodore Ts'o | d323f8f | 2004-12-15 14:39:16 -0500 | [diff] [blame] | 55 | { |
| 56 | struct ext2_super_block *sb = fs->super; |
| 57 | unsigned long bpg = sb->s_blocks_per_group; |
Valerie Clement | f2de1d3 | 2007-08-30 17:38:13 +0200 | [diff] [blame] | 58 | unsigned int gdpb = EXT2_DESC_PER_BLOCK(sb); |
Theodore Ts'o | d323f8f | 2004-12-15 14:39:16 -0500 | [diff] [blame] | 59 | unsigned long max_blocks = 0xffffffff; |
| 60 | unsigned long rsv_groups; |
Theodore Ts'o | a612f34 | 2006-03-17 20:39:52 -0500 | [diff] [blame] | 61 | unsigned int rsv_gdb; |
Theodore Ts'o | d323f8f | 2004-12-15 14:39:16 -0500 | [diff] [blame] | 62 | |
| 63 | /* We set it at 1024x the current filesystem size, or |
| 64 | * the upper block count limit (2^32), whichever is lower. |
| 65 | */ |
Valerie Aurora Henson | 4efbac6 | 2009-09-07 20:46:34 -0400 | [diff] [blame] | 66 | if (ext2fs_blocks_count(sb) < max_blocks / 1024) |
| 67 | max_blocks = ext2fs_blocks_count(sb) * 1024; |
Theodore Ts'o | da3fc25 | 2010-06-13 09:00:00 -0400 | [diff] [blame] | 68 | /* |
| 69 | * ext2fs_div64_ceil() is unnecessary because max_blocks is |
| 70 | * max _GDT_ blocks, which is limited to 32 bits. |
| 71 | */ |
Theodore Ts'o | 69022e0 | 2006-08-30 01:57:00 -0400 | [diff] [blame] | 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; |
Theodore Ts'o | a612f34 | 2006-03-17 20:39:52 -0500 | [diff] [blame] | 74 | if (rsv_gdb > EXT2_ADDR_PER_BLOCK(sb)) |
Theodore Ts'o | d323f8f | 2004-12-15 14:39:16 -0500 | [diff] [blame] | 75 | rsv_gdb = EXT2_ADDR_PER_BLOCK(sb); |
Theodore Ts'o | 40abad6 | 2004-12-23 07:45:04 -0500 | [diff] [blame] | 76 | #ifdef RES_GDT_DEBUG |
Theodore Ts'o | a612f34 | 2006-03-17 20:39:52 -0500 | [diff] [blame] | 77 | printf("max_blocks %lu, rsv_groups = %lu, rsv_gdb = %u\n", |
Theodore Ts'o | d323f8f | 2004-12-15 14:39:16 -0500 | [diff] [blame] | 78 | max_blocks, rsv_groups, rsv_gdb); |
Theodore Ts'o | 40abad6 | 2004-12-23 07:45:04 -0500 | [diff] [blame] | 79 | #endif |
Theodore Ts'o | d323f8f | 2004-12-15 14:39:16 -0500 | [diff] [blame] | 80 | |
| 81 | return rsv_gdb; |
| 82 | } |
| 83 | |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 84 | errcode_t ext2fs_initialize(const char *name, int flags, |
| 85 | struct ext2_super_block *param, |
| 86 | io_manager manager, ext2_filsys *ret_fs) |
| 87 | { |
| 88 | ext2_filsys fs; |
| 89 | errcode_t retval; |
| 90 | struct ext2_super_block *super; |
Theodore Ts'o | 5443492 | 2003-12-07 01:28:50 -0500 | [diff] [blame] | 91 | unsigned int rem; |
| 92 | unsigned int overhead = 0; |
Theodore Ts'o | 5443492 | 2003-12-07 01:28:50 -0500 | [diff] [blame] | 93 | unsigned int ipg; |
| 94 | dgrp_t i; |
Theodore Ts'o | fe75afb | 2011-06-16 01:38:43 -0400 | [diff] [blame] | 95 | blk64_t free_blocks; |
Theodore Ts'o | 3cb6c50 | 1997-08-11 20:29:22 +0000 | [diff] [blame] | 96 | blk_t numblocks; |
Theodore Ts'o | d323f8f | 2004-12-15 14:39:16 -0500 | [diff] [blame] | 97 | int rsv_gdt; |
Theodore Ts'o | 5711ed2 | 2008-04-21 01:29:01 -0400 | [diff] [blame] | 98 | int csum_flag; |
Theodore Ts'o | c6ed60c | 2011-06-10 18:57:22 -0400 | [diff] [blame] | 99 | int bigalloc_flag; |
Theodore Ts'o | 39c47ce | 2006-03-18 19:16:10 -0500 | [diff] [blame] | 100 | int io_flags; |
Theodore Ts'o | 3aa8f60 | 2012-07-29 13:34:01 -0400 | [diff] [blame] | 101 | unsigned reserved_inos; |
Manish Katiyar | adc4e77 | 2008-07-11 14:42:57 -0400 | [diff] [blame] | 102 | char *buf = 0; |
Theodore Ts'o | f77704e | 2006-11-11 22:32:35 -0500 | [diff] [blame] | 103 | char c; |
Akira Fujita | 321649c | 2012-08-30 20:16:01 +0900 | [diff] [blame] | 104 | double reserved_ratio; |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 105 | |
Valerie Aurora Henson | 4efbac6 | 2009-09-07 20:46:34 -0400 | [diff] [blame] | 106 | if (!param || !ext2fs_blocks_count(param)) |
Theodore Ts'o | 1f0b6c1 | 1997-10-31 06:07:47 +0000 | [diff] [blame] | 107 | return EXT2_ET_INVALID_ARGUMENT; |
Theodore Ts'o | efc6f62 | 2008-08-27 23:07:54 -0400 | [diff] [blame] | 108 | |
Theodore Ts'o | c4e3d3f | 2003-08-01 09:41:07 -0400 | [diff] [blame] | 109 | retval = ext2fs_get_mem(sizeof(struct struct_ext2_filsys), &fs); |
Theodore Ts'o | 7b4e453 | 1997-10-26 03:41:24 +0000 | [diff] [blame] | 110 | if (retval) |
| 111 | return retval; |
Theodore Ts'o | efc6f62 | 2008-08-27 23:07:54 -0400 | [diff] [blame] | 112 | |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 113 | memset(fs, 0, sizeof(struct struct_ext2_filsys)); |
Theodore Ts'o | f3db356 | 1997-04-26 13:34:30 +0000 | [diff] [blame] | 114 | fs->magic = EXT2_ET_MAGIC_EXT2FS_FILSYS; |
Theodore Ts'o | 5df55d7 | 2001-06-11 07:00:04 +0000 | [diff] [blame] | 115 | fs->flags = flags | EXT2_FLAG_RW; |
Theodore Ts'o | 6a52506 | 2001-12-24 09:40:00 -0500 | [diff] [blame] | 116 | fs->umask = 022; |
Theodore Ts'o | 0ff7bf3 | 2011-12-16 11:26:00 -0500 | [diff] [blame] | 117 | fs->default_bitmap_type = EXT2FS_BMAP64_RBTREE; |
Theodore Ts'o | 5df55d7 | 2001-06-11 07:00:04 +0000 | [diff] [blame] | 118 | #ifdef WORDS_BIGENDIAN |
| 119 | fs->flags |= EXT2_FLAG_SWAP_BYTES; |
| 120 | #endif |
Theodore Ts'o | 39c47ce | 2006-03-18 19:16:10 -0500 | [diff] [blame] | 121 | io_flags = IO_FLAG_RW; |
| 122 | if (flags & EXT2_FLAG_EXCLUSIVE) |
| 123 | io_flags |= IO_FLAG_EXCLUSIVE; |
Theodore Ts'o | 37c8db7 | 2012-03-22 16:00:49 -0400 | [diff] [blame] | 124 | if (flags & EXT2_FLAG_DIRECT_IO) |
| 125 | io_flags |= IO_FLAG_DIRECT_IO; |
Theodore Ts'o | 39c47ce | 2006-03-18 19:16:10 -0500 | [diff] [blame] | 126 | retval = manager->open(name, io_flags, &fs->io); |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 127 | if (retval) |
| 128 | goto cleanup; |
Theodore Ts'o | 1ad54a9 | 2004-07-28 21:11:48 -0400 | [diff] [blame] | 129 | fs->image_io = fs->io; |
Theodore Ts'o | e9affb7 | 1997-08-24 02:57:55 +0000 | [diff] [blame] | 130 | fs->io->app_data = fs; |
Theodore Ts'o | c4e3d3f | 2003-08-01 09:41:07 -0400 | [diff] [blame] | 131 | retval = ext2fs_get_mem(strlen(name)+1, &fs->device_name); |
Theodore Ts'o | 7b4e453 | 1997-10-26 03:41:24 +0000 | [diff] [blame] | 132 | if (retval) |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 133 | goto cleanup; |
Theodore Ts'o | 7b4e453 | 1997-10-26 03:41:24 +0000 | [diff] [blame] | 134 | |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 135 | strcpy(fs->device_name, name); |
Theodore Ts'o | c4e3d3f | 2003-08-01 09:41:07 -0400 | [diff] [blame] | 136 | retval = ext2fs_get_mem(SUPERBLOCK_SIZE, &super); |
Theodore Ts'o | 7b4e453 | 1997-10-26 03:41:24 +0000 | [diff] [blame] | 137 | if (retval) |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 138 | goto cleanup; |
Theodore Ts'o | 7b4e453 | 1997-10-26 03:41:24 +0000 | [diff] [blame] | 139 | fs->super = super; |
| 140 | |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 141 | memset(super, 0, SUPERBLOCK_SIZE); |
| 142 | |
| 143 | #define set_field(field, default) (super->field = param->field ? \ |
| 144 | param->field : (default)) |
Theodore Ts'o | c6ed60c | 2011-06-10 18:57:22 -0400 | [diff] [blame] | 145 | #define assign_field(field) (super->field = param->field) |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 146 | |
| 147 | super->s_magic = EXT2_SUPER_MAGIC; |
| 148 | super->s_state = EXT2_VALID_FS; |
| 149 | |
Theodore Ts'o | c6ed60c | 2011-06-10 18:57:22 -0400 | [diff] [blame] | 150 | bigalloc_flag = EXT2_HAS_RO_COMPAT_FEATURE(param, |
| 151 | EXT4_FEATURE_RO_COMPAT_BIGALLOC); |
| 152 | |
| 153 | assign_field(s_log_block_size); |
| 154 | |
| 155 | if (bigalloc_flag) { |
| 156 | set_field(s_log_cluster_size, super->s_log_block_size+4); |
| 157 | if (super->s_log_block_size > super->s_log_cluster_size) { |
| 158 | retval = EXT2_ET_INVALID_ARGUMENT; |
| 159 | goto cleanup; |
| 160 | } |
| 161 | } else |
| 162 | super->s_log_cluster_size = super->s_log_block_size; |
| 163 | |
| 164 | set_field(s_first_data_block, super->s_log_cluster_size ? 0 : 1); |
Eric Sandeen | 3daf592 | 2011-02-17 15:55:15 -0600 | [diff] [blame] | 165 | set_field(s_max_mnt_count, 0); |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 166 | set_field(s_errors, EXT2_ERRORS_DEFAULT); |
Theodore Ts'o | a29f4d3 | 1997-04-29 21:26:48 +0000 | [diff] [blame] | 167 | set_field(s_feature_compat, 0); |
| 168 | set_field(s_feature_incompat, 0); |
| 169 | set_field(s_feature_ro_compat, 0); |
Eric Sandeen | 6a426c9 | 2011-02-17 15:56:17 -0600 | [diff] [blame] | 170 | set_field(s_default_mount_opts, 0); |
Theodore Ts'o | c046ac7 | 2002-10-20 00:38:57 -0400 | [diff] [blame] | 171 | set_field(s_first_meta_bg, 0); |
Theodore Ts'o | 0c17cb2 | 2008-02-18 22:56:25 -0500 | [diff] [blame] | 172 | set_field(s_raid_stride, 0); /* default stride size: 0 */ |
| 173 | set_field(s_raid_stripe_width, 0); /* default stripe width: 0 */ |
Theodore Ts'o | 9ba4000 | 2008-04-22 08:27:01 -0400 | [diff] [blame] | 174 | set_field(s_log_groups_per_flex, 0); |
Theodore Ts'o | 6cb2740 | 2008-01-26 19:06:35 -0500 | [diff] [blame] | 175 | set_field(s_flags, 0); |
Theodore Ts'o | d323f8f | 2004-12-15 14:39:16 -0500 | [diff] [blame] | 176 | if (super->s_feature_incompat & ~EXT2_LIB_FEATURE_INCOMPAT_SUPP) { |
| 177 | retval = EXT2_ET_UNSUPP_FEATURE; |
| 178 | goto cleanup; |
| 179 | } |
| 180 | if (super->s_feature_ro_compat & ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP) { |
| 181 | retval = EXT2_ET_RO_UNSUPP_FEATURE; |
| 182 | goto cleanup; |
| 183 | } |
Theodore Ts'o | 7f88b04 | 1997-04-26 14:48:50 +0000 | [diff] [blame] | 184 | |
Theodore Ts'o | 7f88b04 | 1997-04-26 14:48:50 +0000 | [diff] [blame] | 185 | set_field(s_rev_level, EXT2_GOOD_OLD_REV); |
| 186 | if (super->s_rev_level >= EXT2_DYNAMIC_REV) { |
| 187 | set_field(s_first_ino, EXT2_GOOD_OLD_FIRST_INO); |
| 188 | set_field(s_inode_size, EXT2_GOOD_OLD_INODE_SIZE); |
Theodore Ts'o | 00a9284 | 2008-04-20 16:02:13 -0400 | [diff] [blame] | 189 | if (super->s_inode_size >= sizeof(struct ext2_inode_large)) { |
| 190 | int extra_isize = sizeof(struct ext2_inode_large) - |
| 191 | EXT2_GOOD_OLD_INODE_SIZE; |
| 192 | set_field(s_min_extra_isize, extra_isize); |
| 193 | set_field(s_want_extra_isize, extra_isize); |
| 194 | } |
Theodore Ts'o | 0f2794c | 2008-04-22 23:18:37 -0400 | [diff] [blame] | 195 | } else { |
| 196 | super->s_first_ino = EXT2_GOOD_OLD_FIRST_INO; |
| 197 | super->s_inode_size = EXT2_GOOD_OLD_INODE_SIZE; |
Theodore Ts'o | 7f88b04 | 1997-04-26 14:48:50 +0000 | [diff] [blame] | 198 | } |
Theodore Ts'o | 7f88b04 | 1997-04-26 14:48:50 +0000 | [diff] [blame] | 199 | |
Eric Sandeen | 3daf592 | 2011-02-17 15:55:15 -0600 | [diff] [blame] | 200 | set_field(s_checkinterval, 0); |
Theodore Ts'o | 3213818 | 2005-09-24 20:14:51 -0400 | [diff] [blame] | 201 | super->s_mkfs_time = super->s_lastcheck = fs->now ? fs->now : time(NULL); |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 202 | |
Theodore Ts'o | 50e1e10 | 1997-04-26 13:58:21 +0000 | [diff] [blame] | 203 | super->s_creator_os = CREATOR_OS; |
Theodore Ts'o | f3db356 | 1997-04-26 13:34:30 +0000 | [diff] [blame] | 204 | |
Theodore Ts'o | 3fbfad5 | 2011-09-15 15:44:56 -0400 | [diff] [blame] | 205 | fs->fragsize = fs->blocksize = EXT2_BLOCK_SIZE(super); |
Theodore Ts'o | 1da5ef7 | 2011-06-04 10:20:47 -0400 | [diff] [blame] | 206 | fs->cluster_ratio_bits = super->s_log_cluster_size - |
| 207 | super->s_log_block_size; |
Andreas Dilger | b21bf26 | 2002-06-10 11:05:56 -0600 | [diff] [blame] | 208 | |
Theodore Ts'o | c6ed60c | 2011-06-10 18:57:22 -0400 | [diff] [blame] | 209 | if (bigalloc_flag) { |
Theodore Ts'o | dd4f565 | 2013-01-14 19:29:54 -0500 | [diff] [blame] | 210 | unsigned long long bpg; |
| 211 | |
Theodore Ts'o | c6ed60c | 2011-06-10 18:57:22 -0400 | [diff] [blame] | 212 | if (param->s_blocks_per_group && |
| 213 | param->s_clusters_per_group && |
| 214 | ((param->s_clusters_per_group * EXT2FS_CLUSTER_RATIO(fs)) != |
| 215 | param->s_blocks_per_group)) { |
| 216 | retval = EXT2_ET_INVALID_ARGUMENT; |
| 217 | goto cleanup; |
| 218 | } |
| 219 | if (param->s_clusters_per_group) |
| 220 | assign_field(s_clusters_per_group); |
| 221 | else if (param->s_blocks_per_group) |
| 222 | super->s_clusters_per_group = |
| 223 | param->s_blocks_per_group / |
| 224 | EXT2FS_CLUSTER_RATIO(fs); |
Theodore Ts'o | dd4f565 | 2013-01-14 19:29:54 -0500 | [diff] [blame] | 225 | else if (super->s_log_cluster_size + 15 < 32) |
Theodore Ts'o | c6ed60c | 2011-06-10 18:57:22 -0400 | [diff] [blame] | 226 | super->s_clusters_per_group = fs->blocksize * 8; |
Theodore Ts'o | dd4f565 | 2013-01-14 19:29:54 -0500 | [diff] [blame] | 227 | else |
| 228 | super->s_clusters_per_group = (fs->blocksize - 1) * 8; |
Theodore Ts'o | c6ed60c | 2011-06-10 18:57:22 -0400 | [diff] [blame] | 229 | if (super->s_clusters_per_group > EXT2_MAX_CLUSTERS_PER_GROUP(super)) |
Eric Sandeen | bfbeec0 | 2011-10-03 23:11:25 -0400 | [diff] [blame] | 230 | super->s_clusters_per_group = EXT2_MAX_CLUSTERS_PER_GROUP(super); |
Theodore Ts'o | dd4f565 | 2013-01-14 19:29:54 -0500 | [diff] [blame] | 231 | bpg = EXT2FS_C2B(fs, |
| 232 | (unsigned long long) super->s_clusters_per_group); |
| 233 | if (bpg >= (((unsigned long long) 1) << 32)) { |
| 234 | retval = EXT2_ET_INVALID_ARGUMENT; |
| 235 | goto cleanup; |
| 236 | } |
| 237 | super->s_blocks_per_group = bpg; |
Theodore Ts'o | c6ed60c | 2011-06-10 18:57:22 -0400 | [diff] [blame] | 238 | } else { |
| 239 | set_field(s_blocks_per_group, fs->blocksize * 8); |
| 240 | if (super->s_blocks_per_group > EXT2_MAX_BLOCKS_PER_GROUP(super)) |
| 241 | super->s_blocks_per_group = EXT2_MAX_BLOCKS_PER_GROUP(super); |
| 242 | super->s_clusters_per_group = super->s_blocks_per_group; |
| 243 | } |
Theodore Ts'o | efc6f62 | 2008-08-27 23:07:54 -0400 | [diff] [blame] | 244 | |
Theodore Ts'o | c6ed60c | 2011-06-10 18:57:22 -0400 | [diff] [blame] | 245 | ext2fs_blocks_count_set(super, ext2fs_blocks_count(param) & |
| 246 | ~((blk64_t) EXT2FS_CLUSTER_MASK(fs))); |
Valerie Aurora Henson | 4efbac6 | 2009-09-07 20:46:34 -0400 | [diff] [blame] | 247 | ext2fs_r_blocks_count_set(super, ext2fs_r_blocks_count(param)); |
| 248 | if (ext2fs_r_blocks_count(super) >= ext2fs_blocks_count(param)) { |
Theodore Ts'o | 1f0b6c1 | 1997-10-31 06:07:47 +0000 | [diff] [blame] | 249 | retval = EXT2_ET_INVALID_ARGUMENT; |
Theodore Ts'o | f3db356 | 1997-04-26 13:34:30 +0000 | [diff] [blame] | 250 | goto cleanup; |
| 251 | } |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 252 | |
Gregoire Pichon | 1564150 | 2012-10-17 16:57:32 +0200 | [diff] [blame] | 253 | set_field(s_mmp_update_interval, 0); |
| 254 | |
Theodore Ts'o | a112847 | 2001-01-16 06:56:14 +0000 | [diff] [blame] | 255 | /* |
| 256 | * If we're creating an external journal device, we don't need |
| 257 | * to bother with the rest. |
| 258 | */ |
Theodore Ts'o | d323f8f | 2004-12-15 14:39:16 -0500 | [diff] [blame] | 259 | if (super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV) { |
Theodore Ts'o | a112847 | 2001-01-16 06:56:14 +0000 | [diff] [blame] | 260 | fs->group_desc_count = 0; |
| 261 | ext2fs_mark_super_dirty(fs); |
| 262 | *ret_fs = fs; |
| 263 | return 0; |
| 264 | } |
| 265 | |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 266 | retry: |
Theodore Ts'o | 00ea586 | 2011-10-03 23:47:19 -0400 | [diff] [blame] | 267 | fs->group_desc_count = (dgrp_t) ext2fs_div64_ceil( |
Valerie Aurora Henson | 4efbac6 | 2009-09-07 20:46:34 -0400 | [diff] [blame] | 268 | ext2fs_blocks_count(super) - super->s_first_data_block, |
| 269 | EXT2_BLOCKS_PER_GROUP(super)); |
Theodore Ts'o | d323f8f | 2004-12-15 14:39:16 -0500 | [diff] [blame] | 270 | if (fs->group_desc_count == 0) { |
| 271 | retval = EXT2_ET_TOOSMALL; |
| 272 | goto cleanup; |
| 273 | } |
Theodore Ts'o | da3fc25 | 2010-06-13 09:00:00 -0400 | [diff] [blame] | 274 | |
| 275 | if (super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT) |
| 276 | super->s_desc_size = EXT2_MIN_DESC_SIZE_64BIT; |
| 277 | |
Theodore Ts'o | 69022e0 | 2006-08-30 01:57:00 -0400 | [diff] [blame] | 278 | fs->desc_blocks = ext2fs_div_ceil(fs->group_desc_count, |
| 279 | EXT2_DESC_PER_BLOCK(super)); |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 280 | |
Andreas Dilger | 932a489 | 2002-05-16 03:20:07 -0600 | [diff] [blame] | 281 | i = fs->blocksize >= 4096 ? 1 : 4096 / fs->blocksize; |
Theodore Ts'o | da3fc25 | 2010-06-13 09:00:00 -0400 | [diff] [blame] | 282 | |
| 283 | if (super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT && |
| 284 | (ext2fs_blocks_count(super) / i) > (1ULL << 32)) |
| 285 | set_field(s_inodes_count, ~0U); |
| 286 | else |
| 287 | set_field(s_inodes_count, ext2fs_blocks_count(super) / i); |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 288 | |
| 289 | /* |
Theodore Ts'o | 8d7e83b | 1998-09-23 00:27:26 +0000 | [diff] [blame] | 290 | * Make sure we have at least EXT2_FIRST_INO + 1 inodes, so |
| 291 | * that we have enough inodes for the filesystem(!) |
| 292 | */ |
Theodore Ts'o | 7a46952 | 1999-01-04 08:50:59 +0000 | [diff] [blame] | 293 | if (super->s_inodes_count < EXT2_FIRST_INODE(super)+1) |
| 294 | super->s_inodes_count = EXT2_FIRST_INODE(super)+1; |
Theodore Ts'o | efc6f62 | 2008-08-27 23:07:54 -0400 | [diff] [blame] | 295 | |
Theodore Ts'o | 8d7e83b | 1998-09-23 00:27:26 +0000 | [diff] [blame] | 296 | /* |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 297 | * There should be at least as many inodes as the user |
| 298 | * requested. Figure out how many inodes per group that |
Theodore Ts'o | 50e1e10 | 1997-04-26 13:58:21 +0000 | [diff] [blame] | 299 | * should be. But make sure that we don't allocate more than |
Andreas Dilger | b21bf26 | 2002-06-10 11:05:56 -0600 | [diff] [blame] | 300 | * one bitmap's worth of inodes each group. |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 301 | */ |
Theodore Ts'o | 69022e0 | 2006-08-30 01:57:00 -0400 | [diff] [blame] | 302 | ipg = ext2fs_div_ceil(super->s_inodes_count, fs->group_desc_count); |
Theodore Ts'o | 4564c72 | 2003-01-19 21:01:22 -0500 | [diff] [blame] | 303 | if (ipg > fs->blocksize * 8) { |
Theodore Ts'o | c6ed60c | 2011-06-10 18:57:22 -0400 | [diff] [blame] | 304 | if (!bigalloc_flag && super->s_blocks_per_group >= 256) { |
Theodore Ts'o | 4564c72 | 2003-01-19 21:01:22 -0500 | [diff] [blame] | 305 | /* Try again with slightly different parameters */ |
| 306 | super->s_blocks_per_group -= 8; |
Valerie Aurora Henson | 4efbac6 | 2009-09-07 20:46:34 -0400 | [diff] [blame] | 307 | ext2fs_blocks_count_set(super, |
| 308 | ext2fs_blocks_count(param)); |
Theodore Ts'o | 412376e | 2011-02-25 21:43:54 -0500 | [diff] [blame] | 309 | super->s_clusters_per_group = super->s_blocks_per_group; |
Theodore Ts'o | 4564c72 | 2003-01-19 21:01:22 -0500 | [diff] [blame] | 310 | goto retry; |
Manish Katiyar | baf8ab9 | 2008-08-23 17:11:07 +0530 | [diff] [blame] | 311 | } else { |
| 312 | retval = EXT2_ET_TOO_MANY_INODES; |
| 313 | goto cleanup; |
| 314 | } |
Theodore Ts'o | 4564c72 | 2003-01-19 21:01:22 -0500 | [diff] [blame] | 315 | } |
Andreas Dilger | b21bf26 | 2002-06-10 11:05:56 -0600 | [diff] [blame] | 316 | |
Theodore Ts'o | 5443492 | 2003-12-07 01:28:50 -0500 | [diff] [blame] | 317 | if (ipg > (unsigned) EXT2_MAX_INODES_PER_GROUP(super)) |
Andreas Dilger | b21bf26 | 2002-06-10 11:05:56 -0600 | [diff] [blame] | 318 | ipg = EXT2_MAX_INODES_PER_GROUP(super); |
| 319 | |
Eric Sandeen | f335864 | 2006-09-12 14:56:17 -0400 | [diff] [blame] | 320 | ipg_retry: |
Andreas Dilger | b21bf26 | 2002-06-10 11:05:56 -0600 | [diff] [blame] | 321 | super->s_inodes_per_group = ipg; |
Andreas Dilger | b21bf26 | 2002-06-10 11:05:56 -0600 | [diff] [blame] | 322 | |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 323 | /* |
| 324 | * Make sure the number of inodes per group completely fills |
| 325 | * the inode table blocks in the descriptor. If not, add some |
| 326 | * additional inodes/group. Waste not, want not... |
| 327 | */ |
Theodore Ts'o | 7f88b04 | 1997-04-26 14:48:50 +0000 | [diff] [blame] | 328 | fs->inode_blocks_per_group = (((super->s_inodes_per_group * |
| 329 | EXT2_INODE_SIZE(super)) + |
| 330 | EXT2_BLOCK_SIZE(super) - 1) / |
| 331 | EXT2_BLOCK_SIZE(super)); |
| 332 | super->s_inodes_per_group = ((fs->inode_blocks_per_group * |
| 333 | EXT2_BLOCK_SIZE(super)) / |
| 334 | EXT2_INODE_SIZE(super)); |
| 335 | /* |
| 336 | * Finally, make sure the number of inodes per group is a |
| 337 | * multiple of 8. This is needed to simplify the bitmap |
| 338 | * splicing code. |
| 339 | */ |
Tao Ma | 598d20c | 2011-05-09 23:38:42 +0800 | [diff] [blame] | 340 | if (super->s_inodes_per_group < 8) |
| 341 | super->s_inodes_per_group = 8; |
Theodore Ts'o | 7f88b04 | 1997-04-26 14:48:50 +0000 | [diff] [blame] | 342 | super->s_inodes_per_group &= ~7; |
| 343 | fs->inode_blocks_per_group = (((super->s_inodes_per_group * |
| 344 | EXT2_INODE_SIZE(super)) + |
| 345 | EXT2_BLOCK_SIZE(super) - 1) / |
| 346 | EXT2_BLOCK_SIZE(super)); |
| 347 | |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 348 | /* |
| 349 | * adjust inode count to reflect the adjusted inodes_per_group |
| 350 | */ |
Eric Sandeen | f335864 | 2006-09-12 14:56:17 -0400 | [diff] [blame] | 351 | if ((__u64)super->s_inodes_per_group * fs->group_desc_count > ~0U) { |
| 352 | ipg--; |
| 353 | goto ipg_retry; |
| 354 | } |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 355 | super->s_inodes_count = super->s_inodes_per_group * |
| 356 | fs->group_desc_count; |
| 357 | super->s_free_inodes_count = super->s_inodes_count; |
| 358 | |
| 359 | /* |
Theodore Ts'o | d323f8f | 2004-12-15 14:39:16 -0500 | [diff] [blame] | 360 | * check the number of reserved group descriptor table blocks |
| 361 | */ |
| 362 | if (super->s_feature_compat & EXT2_FEATURE_COMPAT_RESIZE_INODE) |
| 363 | rsv_gdt = calc_reserved_gdt_blocks(fs); |
| 364 | else |
| 365 | rsv_gdt = 0; |
| 366 | set_field(s_reserved_gdt_blocks, rsv_gdt); |
| 367 | if (super->s_reserved_gdt_blocks > EXT2_ADDR_PER_BLOCK(super)) { |
| 368 | retval = EXT2_ET_RES_GDT_BLOCKS; |
| 369 | goto cleanup; |
| 370 | } |
| 371 | |
| 372 | /* |
Theodore Ts'o | 5a92a62 | 2007-07-22 15:07:13 -0400 | [diff] [blame] | 373 | * Calculate the maximum number of bookkeeping blocks per |
| 374 | * group. It includes the superblock, the block group |
| 375 | * descriptors, the block bitmap, the inode bitmap, the inode |
| 376 | * table, and the reserved gdt blocks. |
Theodore Ts'o | 2ecc6fe | 1997-04-29 17:57:00 +0000 | [diff] [blame] | 377 | */ |
Theodore Ts'o | 5a92a62 | 2007-07-22 15:07:13 -0400 | [diff] [blame] | 378 | overhead = (int) (3 + fs->inode_blocks_per_group + |
| 379 | fs->desc_blocks + super->s_reserved_gdt_blocks); |
Theodore Ts'o | 4564c72 | 2003-01-19 21:01:22 -0500 | [diff] [blame] | 380 | |
| 381 | /* This can only happen if the user requested too many inodes */ |
Manish Katiyar | baf8ab9 | 2008-08-23 17:11:07 +0530 | [diff] [blame] | 382 | if (overhead > super->s_blocks_per_group) { |
| 383 | retval = EXT2_ET_TOO_MANY_INODES; |
| 384 | goto cleanup; |
| 385 | } |
Theodore Ts'o | 4564c72 | 2003-01-19 21:01:22 -0500 | [diff] [blame] | 386 | |
Theodore Ts'o | 2ecc6fe | 1997-04-29 17:57:00 +0000 | [diff] [blame] | 387 | /* |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 388 | * See if the last group is big enough to support the |
| 389 | * necessary data structures. If not, we need to get rid of |
Theodore Ts'o | 5a92a62 | 2007-07-22 15:07:13 -0400 | [diff] [blame] | 390 | * it. We need to recalculate the overhead for the last block |
| 391 | * group, since it might or might not have a superblock |
| 392 | * backup. |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 393 | */ |
Theodore Ts'o | 5a92a62 | 2007-07-22 15:07:13 -0400 | [diff] [blame] | 394 | overhead = (int) (2 + fs->inode_blocks_per_group); |
| 395 | if (ext2fs_bg_has_super(fs, fs->group_desc_count - 1)) |
| 396 | overhead += 1 + fs->desc_blocks + super->s_reserved_gdt_blocks; |
Valerie Aurora Henson | 4efbac6 | 2009-09-07 20:46:34 -0400 | [diff] [blame] | 397 | rem = ((ext2fs_blocks_count(super) - super->s_first_data_block) % |
Theodore Ts'o | 5443492 | 2003-12-07 01:28:50 -0500 | [diff] [blame] | 398 | super->s_blocks_per_group); |
Manish Katiyar | baf8ab9 | 2008-08-23 17:11:07 +0530 | [diff] [blame] | 399 | if ((fs->group_desc_count == 1) && rem && (rem < overhead)) { |
| 400 | retval = EXT2_ET_TOOSMALL; |
| 401 | goto cleanup; |
| 402 | } |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 403 | if (rem && (rem < overhead+50)) { |
Valerie Aurora Henson | 4efbac6 | 2009-09-07 20:46:34 -0400 | [diff] [blame] | 404 | ext2fs_blocks_count_set(super, ext2fs_blocks_count(super) - |
| 405 | rem); |
Akira Fujita | 321649c | 2012-08-30 20:16:01 +0900 | [diff] [blame] | 406 | /* |
| 407 | * If blocks count is changed, we need to recalculate |
| 408 | * reserved blocks count not to exceed 50%. |
| 409 | */ |
| 410 | reserved_ratio = 100.0 * ext2fs_r_blocks_count(param) / |
| 411 | ext2fs_blocks_count(param); |
| 412 | ext2fs_r_blocks_count_set(super, reserved_ratio * |
| 413 | ext2fs_blocks_count(super) / 100.0); |
Valerie Aurora Henson | 4efbac6 | 2009-09-07 20:46:34 -0400 | [diff] [blame] | 414 | |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 415 | goto retry; |
| 416 | } |
| 417 | |
| 418 | /* |
| 419 | * At this point we know how big the filesystem will be. So |
| 420 | * we can do any and all allocations that depend on the block |
| 421 | * count. |
| 422 | */ |
| 423 | |
Theodore Ts'o | c4e3d3f | 2003-08-01 09:41:07 -0400 | [diff] [blame] | 424 | retval = ext2fs_get_mem(strlen(fs->device_name) + 80, &buf); |
Theodore Ts'o | 7b4e453 | 1997-10-26 03:41:24 +0000 | [diff] [blame] | 425 | if (retval) |
Theodore Ts'o | f3db356 | 1997-04-26 13:34:30 +0000 | [diff] [blame] | 426 | goto cleanup; |
Theodore Ts'o | efc6f62 | 2008-08-27 23:07:54 -0400 | [diff] [blame] | 427 | |
Theodore Ts'o | 2d40a91 | 2008-08-22 10:37:18 -0400 | [diff] [blame] | 428 | strcpy(buf, "block bitmap for "); |
| 429 | strcat(buf, fs->device_name); |
Theodore Ts'o | c6ed60c | 2011-06-10 18:57:22 -0400 | [diff] [blame] | 430 | retval = ext2fs_allocate_subcluster_bitmap(fs, buf, &fs->block_map); |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 431 | if (retval) |
| 432 | goto cleanup; |
Theodore Ts'o | efc6f62 | 2008-08-27 23:07:54 -0400 | [diff] [blame] | 433 | |
Theodore Ts'o | 2d40a91 | 2008-08-22 10:37:18 -0400 | [diff] [blame] | 434 | strcpy(buf, "inode bitmap for "); |
| 435 | strcat(buf, fs->device_name); |
Theodore Ts'o | 5c57647 | 1997-04-29 15:29:49 +0000 | [diff] [blame] | 436 | retval = ext2fs_allocate_inode_bitmap(fs, buf, &fs->inode_map); |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 437 | if (retval) |
| 438 | goto cleanup; |
| 439 | |
Theodore Ts'o | c4e3d3f | 2003-08-01 09:41:07 -0400 | [diff] [blame] | 440 | ext2fs_free_mem(&buf); |
Theodore Ts'o | f3db356 | 1997-04-26 13:34:30 +0000 | [diff] [blame] | 441 | |
Theodore Ts'o | ee01079 | 2007-11-09 19:01:06 -0500 | [diff] [blame] | 442 | retval = ext2fs_get_array(fs->desc_blocks, fs->blocksize, |
Theodore Ts'o | c4e3d3f | 2003-08-01 09:41:07 -0400 | [diff] [blame] | 443 | &fs->group_desc); |
Theodore Ts'o | 7b4e453 | 1997-10-26 03:41:24 +0000 | [diff] [blame] | 444 | if (retval) |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 445 | goto cleanup; |
Theodore Ts'o | 7b4e453 | 1997-10-26 03:41:24 +0000 | [diff] [blame] | 446 | |
Theodore Ts'o | 3cb6c50 | 1997-08-11 20:29:22 +0000 | [diff] [blame] | 447 | memset(fs->group_desc, 0, (size_t) fs->desc_blocks * fs->blocksize); |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 448 | |
Theodore Ts'o | f3db356 | 1997-04-26 13:34:30 +0000 | [diff] [blame] | 449 | /* |
| 450 | * Reserve the superblock and group descriptors for each |
| 451 | * group, and fill in the correct group statistics for group. |
| 452 | * Note that although the block bitmap, inode bitmap, and |
| 453 | * inode table have not been allocated (and in fact won't be |
| 454 | * by this routine), they are accounted for nevertheless. |
Theodore Ts'o | 9ba4000 | 2008-04-22 08:27:01 -0400 | [diff] [blame] | 455 | * |
| 456 | * If FLEX_BG meta-data grouping is used, only account for the |
| 457 | * superblock and group descriptors (the inode tables and |
| 458 | * bitmaps will be accounted for when allocated). |
Theodore Ts'o | f3db356 | 1997-04-26 13:34:30 +0000 | [diff] [blame] | 459 | */ |
Theodore Ts'o | fe75afb | 2011-06-16 01:38:43 -0400 | [diff] [blame] | 460 | free_blocks = 0; |
Theodore Ts'o | 5711ed2 | 2008-04-21 01:29:01 -0400 | [diff] [blame] | 461 | csum_flag = EXT2_HAS_RO_COMPAT_FEATURE(fs->super, |
| 462 | EXT4_FEATURE_RO_COMPAT_GDT_CSUM); |
Theodore Ts'o | 3aa8f60 | 2012-07-29 13:34:01 -0400 | [diff] [blame] | 463 | reserved_inos = super->s_first_ino; |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 464 | for (i = 0; i < fs->group_desc_count; i++) { |
Theodore Ts'o | 5711ed2 | 2008-04-21 01:29:01 -0400 | [diff] [blame] | 465 | /* |
| 466 | * Don't set the BLOCK_UNINIT group for the last group |
| 467 | * because the block bitmap needs to be padded. |
| 468 | */ |
| 469 | if (csum_flag) { |
| 470 | if (i != fs->group_desc_count - 1) |
Eric Sandeen | e633b58 | 2009-10-25 21:41:32 -0400 | [diff] [blame] | 471 | ext2fs_bg_flags_set(fs, i, |
| 472 | EXT2_BG_BLOCK_UNINIT); |
| 473 | ext2fs_bg_flags_set(fs, i, EXT2_BG_INODE_UNINIT); |
Theodore Ts'o | 0f2794c | 2008-04-22 23:18:37 -0400 | [diff] [blame] | 474 | numblocks = super->s_inodes_per_group; |
Theodore Ts'o | 3aa8f60 | 2012-07-29 13:34:01 -0400 | [diff] [blame] | 475 | if (reserved_inos) { |
| 476 | if (numblocks > reserved_inos) { |
| 477 | numblocks -= reserved_inos; |
| 478 | reserved_inos = 0; |
| 479 | } else { |
| 480 | reserved_inos -= numblocks; |
| 481 | numblocks = 0; |
| 482 | } |
| 483 | } |
Valerie Aurora Henson | d7cca6b | 2009-10-25 21:43:47 -0400 | [diff] [blame] | 484 | ext2fs_bg_itable_unused_set(fs, i, numblocks); |
Theodore Ts'o | 5711ed2 | 2008-04-21 01:29:01 -0400 | [diff] [blame] | 485 | } |
Theodore Ts'o | ef344e1 | 2003-11-21 09:02:21 -0500 | [diff] [blame] | 486 | numblocks = ext2fs_reserve_super_and_bgd(fs, i, fs->block_map); |
Theodore Ts'o | 9ba4000 | 2008-04-22 08:27:01 -0400 | [diff] [blame] | 487 | if (fs->super->s_log_groups_per_flex) |
| 488 | numblocks += 2 + fs->inode_blocks_per_group; |
Theodore Ts'o | 521e368 | 1997-04-29 17:48:10 +0000 | [diff] [blame] | 489 | |
Theodore Ts'o | fe75afb | 2011-06-16 01:38:43 -0400 | [diff] [blame] | 490 | free_blocks += numblocks; |
Valerie Aurora Henson | d7cca6b | 2009-10-25 21:43:47 -0400 | [diff] [blame] | 491 | ext2fs_bg_free_blocks_count_set(fs, i, numblocks); |
| 492 | ext2fs_bg_free_inodes_count_set(fs, i, fs->super->s_inodes_per_group); |
| 493 | ext2fs_bg_used_dirs_count_set(fs, i, 0); |
Jose R. Santos | d4f34d4 | 2007-10-21 21:03:25 -0500 | [diff] [blame] | 494 | ext2fs_group_desc_csum_set(fs, i); |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 495 | } |
Theodore Ts'o | fe75afb | 2011-06-16 01:38:43 -0400 | [diff] [blame] | 496 | free_blocks &= ~EXT2FS_CLUSTER_MASK(fs); |
| 497 | ext2fs_free_blocks_count_set(super, free_blocks); |
Theodore Ts'o | efc6f62 | 2008-08-27 23:07:54 -0400 | [diff] [blame] | 498 | |
Theodore Ts'o | f77704e | 2006-11-11 22:32:35 -0500 | [diff] [blame] | 499 | c = (char) 255; |
| 500 | if (((int) c) == -1) { |
| 501 | super->s_flags |= EXT2_FLAGS_SIGNED_HASH; |
| 502 | } else { |
| 503 | super->s_flags |= EXT2_FLAGS_UNSIGNED_HASH; |
| 504 | } |
| 505 | |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 506 | ext2fs_mark_super_dirty(fs); |
| 507 | ext2fs_mark_bb_dirty(fs); |
| 508 | ext2fs_mark_ib_dirty(fs); |
Theodore Ts'o | efc6f62 | 2008-08-27 23:07:54 -0400 | [diff] [blame] | 509 | |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 510 | io_channel_set_blksize(fs->io, fs->blocksize); |
| 511 | |
| 512 | *ret_fs = fs; |
| 513 | return 0; |
| 514 | cleanup: |
Jim Meyering | 45e338f | 2009-02-23 18:07:50 +0100 | [diff] [blame] | 515 | free(buf); |
Theodore Ts'o | 3839e65 | 1997-04-26 13:21:57 +0000 | [diff] [blame] | 516 | ext2fs_free(fs); |
| 517 | return retval; |
| 518 | } |