Lines Matching +full:can +full:- +full:primary
1 // SPDX-License-Identifier: GPL-2.0
29 kvfree(ptr->ptr); in ext4_rcu_ptr_callback()
38 ptr->ptr = to_free; in ext4_kvfree_array_rcu()
39 call_rcu(&ptr->rcu, ext4_rcu_ptr_callback); in ext4_kvfree_array_rcu()
52 return -EPERM; in ext4_resize_begin()
55 * If the reserved GDT blocks is non-zero, the resize_inode feature in ext4_resize_begin()
58 if (sbi->s_es->s_reserved_gdt_blocks && in ext4_resize_begin()
60 ext4_error(sb, "resize_inode disabled but reserved GDT blocks non-zero"); in ext4_resize_begin()
61 return -EFSCORRUPTED; in ext4_resize_begin()
65 * If we are not using the primary superblock/GDT copy don't resize, in ext4_resize_begin()
69 if (EXT4_B2C(sbi, sbi->s_sbh->b_blocknr) != in ext4_resize_begin()
70 le32_to_cpu(sbi->s_es->s_first_data_block)) { in ext4_resize_begin()
72 (unsigned long long)sbi->s_sbh->b_blocknr); in ext4_resize_begin()
73 return -EPERM; in ext4_resize_begin()
77 * We are not allowed to do online-resizing on a filesystem mounted in ext4_resize_begin()
78 * with error, because it can destroy the filesystem easily. in ext4_resize_begin()
80 if (sbi->s_mount_state & EXT4_ERROR_FS) { in ext4_resize_begin()
83 return -EPERM; in ext4_resize_begin()
88 return -EOPNOTSUPP; in ext4_resize_begin()
92 &sbi->s_ext4_flags)) in ext4_resize_begin()
93 ret = -EBUSY; in ext4_resize_begin()
100 clear_bit_unlock(EXT4_FLAGS_RESIZING, &EXT4_SB(sb)->s_ext4_flags); in ext4_resize_end()
113 le16_to_cpu(EXT4_SB(sb)->s_es->s_reserved_gdt_blocks); in ext4_group_overhead_blocks()
124 struct ext4_super_block *es = sbi->s_es; in verify_group_input()
126 ext4_fsblk_t end = start + input->blocks_count; in verify_group_input()
127 ext4_group_t group = input->group; in verify_group_input()
128 ext4_fsblk_t itend = input->inode_table + sbi->s_itb_per_group; in verify_group_input()
133 int err = -EINVAL; in verify_group_input()
135 if (group != sbi->s_groups_count) { in verify_group_input()
137 input->group, sbi->s_groups_count); in verify_group_input()
138 return -EINVAL; in verify_group_input()
143 free_blocks_count = input->blocks_count - 2 - overhead - in verify_group_input()
144 sbi->s_itb_per_group; in verify_group_input()
145 input->free_clusters_count = EXT4_B2C(sbi, free_blocks_count); in verify_group_input()
148 printk(KERN_DEBUG "EXT4-fs: adding %s group %u: %u blocks " in verify_group_input()
150 ext4_bg_has_super(sb, input->group) ? "normal" : in verify_group_input()
151 "no-super", input->group, input->blocks_count, in verify_group_input()
152 free_blocks_count, input->reserved_blocks); in verify_group_input()
157 else if (input->reserved_blocks > input->blocks_count / 5) in verify_group_input()
159 input->reserved_blocks); in verify_group_input()
162 input->blocks_count); in verify_group_input()
163 else if (IS_ERR(bh = ext4_sb_bread(sb, end - 1, 0))) { in verify_group_input()
167 end - 1); in verify_group_input()
168 } else if (outside(input->block_bitmap, start, end)) in verify_group_input()
170 (unsigned long long)input->block_bitmap); in verify_group_input()
171 else if (outside(input->inode_bitmap, start, end)) in verify_group_input()
173 (unsigned long long)input->inode_bitmap); in verify_group_input()
174 else if (outside(input->inode_table, start, end) || in verify_group_input()
175 outside(itend - 1, start, end)) in verify_group_input()
176 ext4_warning(sb, "Inode table not in group (blocks %llu-%llu)", in verify_group_input()
177 (unsigned long long)input->inode_table, itend - 1); in verify_group_input()
178 else if (input->inode_bitmap == input->block_bitmap) in verify_group_input()
180 (unsigned long long)input->block_bitmap); in verify_group_input()
181 else if (inside(input->block_bitmap, input->inode_table, itend)) in verify_group_input()
183 "(%llu-%llu)", in verify_group_input()
184 (unsigned long long)input->block_bitmap, in verify_group_input()
185 (unsigned long long)input->inode_table, itend - 1); in verify_group_input()
186 else if (inside(input->inode_bitmap, input->inode_table, itend)) in verify_group_input()
188 "(%llu-%llu)", in verify_group_input()
189 (unsigned long long)input->inode_bitmap, in verify_group_input()
190 (unsigned long long)input->inode_table, itend - 1); in verify_group_input()
191 else if (inside(input->block_bitmap, start, metaend)) in verify_group_input()
192 ext4_warning(sb, "Block bitmap (%llu) in GDT table (%llu-%llu)", in verify_group_input()
193 (unsigned long long)input->block_bitmap, in verify_group_input()
194 start, metaend - 1); in verify_group_input()
195 else if (inside(input->inode_bitmap, start, metaend)) in verify_group_input()
196 ext4_warning(sb, "Inode bitmap (%llu) in GDT table (%llu-%llu)", in verify_group_input()
197 (unsigned long long)input->inode_bitmap, in verify_group_input()
198 start, metaend - 1); in verify_group_input()
199 else if (inside(input->inode_table, start, metaend) || in verify_group_input()
200 inside(itend - 1, start, metaend)) in verify_group_input()
201 ext4_warning(sb, "Inode table (%llu-%llu) overlaps GDT table " in verify_group_input()
202 "(%llu-%llu)", in verify_group_input()
203 (unsigned long long)input->inode_table, in verify_group_input()
204 itend - 1, start, metaend - 1); in verify_group_input()
213 * ext4_new_flex_group_data is used by 64bit-resize interface to add a flex
250 flex_gd->resize_bg = max_resize_bg; in alloc_flex_gd()
253 last_group = o_group | (flex_gd->resize_bg - 1); in alloc_flex_gd()
255 flex_gd->resize_bg = 1 << fls(n_group - o_group); in alloc_flex_gd()
256 else if (n_group - last_group < flex_gd->resize_bg) in alloc_flex_gd()
257 flex_gd->resize_bg = 1 << max(fls(last_group - o_group), in alloc_flex_gd()
258 fls(n_group - last_group)); in alloc_flex_gd()
260 if (WARN_ON_ONCE(flex_gd->resize_bg > max_resize_bg)) in alloc_flex_gd()
261 flex_gd->resize_bg = max_resize_bg; in alloc_flex_gd()
263 flex_gd->groups = kmalloc_array(flex_gd->resize_bg, in alloc_flex_gd()
266 if (flex_gd->groups == NULL) in alloc_flex_gd()
269 flex_gd->bg_flags = kmalloc_array(flex_gd->resize_bg, sizeof(__u16), in alloc_flex_gd()
271 if (flex_gd->bg_flags == NULL) in alloc_flex_gd()
277 kfree(flex_gd->groups); in alloc_flex_gd()
286 kfree(flex_gd->bg_flags); in free_flex_gd()
287 kfree(flex_gd->groups); in free_flex_gd()
295 * This function is used by 64bit-resize. Note that this function allocates
308 struct ext4_new_group_data *group_data = flex_gd->groups; in ext4_alloc_group_tables()
321 BUG_ON(flex_gd->count == 0 || group_data == NULL); in ext4_alloc_group_tables()
324 last_group = src_group + flex_gd->count - 1; in ext4_alloc_group_tables()
326 BUG_ON((flexbg_size > 1) && ((src_group & ~(flexbg_size - 1)) != in ext4_alloc_group_tables()
327 (last_group & ~(flexbg_size - 1)))); in ext4_alloc_group_tables()
330 if (src_group >= group_data[0].group + flex_gd->count) in ext4_alloc_group_tables()
331 return -ENOSPC; in ext4_alloc_group_tables()
333 last_blk = start_blk + group_data[src_group - group].blocks_count; in ext4_alloc_group_tables()
344 last_blk += group_data[src_group - group].blocks_count; in ext4_alloc_group_tables()
350 for (; bb_index < flex_gd->count; bb_index++) { in ext4_alloc_group_tables()
354 group = ext4_get_group_number(sb, start_blk - 1); in ext4_alloc_group_tables()
355 group -= group_data[0].group; in ext4_alloc_group_tables()
357 flex_gd->bg_flags[group] &= uninit_mask; in ext4_alloc_group_tables()
361 for (; ib_index < flex_gd->count; ib_index++) { in ext4_alloc_group_tables()
365 group = ext4_get_group_number(sb, start_blk - 1); in ext4_alloc_group_tables()
366 group -= group_data[0].group; in ext4_alloc_group_tables()
368 flex_gd->bg_flags[group] &= uninit_mask; in ext4_alloc_group_tables()
372 for (; it_index < flex_gd->count; it_index++) { in ext4_alloc_group_tables()
373 unsigned int itb = EXT4_SB(sb)->s_itb_per_group; in ext4_alloc_group_tables()
381 group -= group_data[0].group; in ext4_alloc_group_tables()
384 flex_gd->bg_flags[group + 1] &= uninit_mask; in ext4_alloc_group_tables()
385 overhead = start_blk + itb - next_group_start; in ext4_alloc_group_tables()
387 itb -= overhead; in ext4_alloc_group_tables()
391 flex_gd->bg_flags[group] &= uninit_mask; in ext4_alloc_group_tables()
392 start_blk += EXT4_SB(sb)->s_itb_per_group; in ext4_alloc_group_tables()
396 for (i = 0; i < flex_gd->count; i++) { in ext4_alloc_group_tables()
397 group_data[i].free_clusters_count -= in ext4_alloc_group_tables()
406 printk(KERN_DEBUG "EXT4-fs: adding a flex group with " in ext4_alloc_group_tables()
407 "%u groups, flexbg size is %u:\n", flex_gd->count, in ext4_alloc_group_tables()
410 for (i = 0; i < flex_gd->count; i++) { in ext4_alloc_group_tables()
414 "no-super", group + i, in ext4_alloc_group_tables()
431 return ERR_PTR(-ENOMEM); in bclean()
438 memset(bh->b_data, 0, sb->s_blocksize); in bclean()
465 ext4_group_t count = last_cluster - first_cluster + 1; in set_flexbg_block_bitmap()
468 ext4_debug("mark clusters [%llu-%llu] used\n", first_cluster, in set_flexbg_block_bitmap()
470 for (; count > 0; count -= count2, first_cluster += count2) { in set_flexbg_block_bitmap()
478 group -= flex_gd->groups[0].group; in set_flexbg_block_bitmap()
480 count2 = EXT4_CLUSTERS_PER_GROUP(sb) - (first_cluster - start); in set_flexbg_block_bitmap()
484 if (flex_gd->bg_flags[group] & EXT4_BG_BLOCK_UNINIT) { in set_flexbg_block_bitmap()
485 BUG_ON(flex_gd->count > 1); in set_flexbg_block_bitmap()
493 bh = sb_getblk(sb, flex_gd->groups[group].block_bitmap); in set_flexbg_block_bitmap()
495 return -ENOMEM; in set_flexbg_block_bitmap()
505 first_cluster, first_cluster - start, count2); in set_flexbg_block_bitmap()
506 mb_set_bits(bh->b_data, first_cluster - start, count2); in set_flexbg_block_bitmap()
534 int group_table_count[] = {1, 1, EXT4_SB(sb)->s_itb_per_group}; in setup_new_flex_group_blocks()
538 struct ext4_super_block *es = sbi->s_es; in setup_new_flex_group_blocks()
539 struct ext4_new_group_data *group_data = flex_gd->groups; in setup_new_flex_group_blocks()
540 __u16 *bg_flags = flex_gd->bg_flags; in setup_new_flex_group_blocks()
547 BUG_ON(!flex_gd->count || !group_data || in setup_new_flex_group_blocks()
548 group_data[0].group != sbi->s_groups_count); in setup_new_flex_group_blocks()
550 reserved_gdb = le16_to_cpu(es->s_reserved_gdt_blocks); in setup_new_flex_group_blocks()
559 for (i = 0; i < flex_gd->count; i++, group++) { in setup_new_flex_group_blocks()
584 err = -ENOMEM; in setup_new_flex_group_blocks()
595 memcpy(gdb->b_data, sbi_array_rcu_deref(sbi, in setup_new_flex_group_blocks()
596 s_group_desc, j)->b_data, gdb->b_size); in setup_new_flex_group_blocks()
624 ext4_debug("clear inode table blocks %#04llx -> %#04lx\n", in setup_new_flex_group_blocks()
625 block, sbi->s_itb_per_group); in setup_new_flex_group_blocks()
626 err = sb_issue_zeroout(sb, block, sbi->s_itb_per_group, in setup_new_flex_group_blocks()
650 mb_set_bits(bh->b_data, 0, in setup_new_flex_group_blocks()
654 sb->s_blocksize * 8, bh->b_data); in setup_new_flex_group_blocks()
677 sb->s_blocksize * 8, bh->b_data); in setup_new_flex_group_blocks()
689 for (i = 1; i < flex_gd->count; i++) { in setup_new_flex_group_blocks()
700 - 1)); in setup_new_flex_group_blocks()
713 - 1)); in setup_new_flex_group_blocks()
731 * For a non-sparse filesystem it will be every group: 1, 2, 3, 4, ...
736 struct ext4_super_block *es = EXT4_SB(sb)->s_es; in ext4_list_backups()
745 ret = le32_to_cpu(es->s_backup_bgs[*min - 1]); in ext4_list_backups()
773 * Check that all of the backup GDT blocks are held in the primary GDT block.
775 * groups in current filesystem that have BACKUPS, or -ve error code.
779 struct buffer_head *primary) in verify_reserved_gdb() argument
781 const ext4_fsblk_t blk = primary->b_blocknr; in verify_reserved_gdb()
786 __le32 *p = (__le32 *)primary->b_data; in verify_reserved_gdb()
798 return -EINVAL; in verify_reserved_gdb()
801 return -EFBIG; in verify_reserved_gdb()
809 * use from the resize inode. The primary copy of the new GDT block currently
823 struct super_block *sb = inode->i_sb; in add_new_gdb()
824 struct ext4_super_block *es = EXT4_SB(sb)->s_es; in add_new_gdb()
826 ext4_fsblk_t gdblock = EXT4_SB(sb)->s_sbh->b_blocknr + 1 + gdb_num; in add_new_gdb()
837 "EXT4-fs: ext4_add_new_gdb: adding group block %lu\n", in add_new_gdb()
850 data = EXT4_I(inode)->i_data + EXT4_DIND_BLOCK; in add_new_gdb()
858 data = (__le32 *)dind->b_data; in add_new_gdb()
862 err = -EINVAL; in add_new_gdb()
866 BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get_write_access"); in add_new_gdb()
867 err = ext4_journal_get_write_access(handle, sb, EXT4_SB(sb)->s_sbh, in add_new_gdb()
892 err = -ENOMEM; in add_new_gdb()
901 * Remove new GDT block from inode double-indirect block and clear out in add_new_gdb()
904 * these blocks, because they are marked as in-use from being in the in add_new_gdb()
905 * reserved inode, and will become GDT blocks (primary and backup). in add_new_gdb()
913 inode->i_blocks -= (gdbackups + 1) * sb->s_blocksize >> in add_new_gdb()
914 (9 - EXT4_SB(sb)->s_cluster_bits); in add_new_gdb()
916 memset(gdb_bh->b_data, 0, sb->s_blocksize); in add_new_gdb()
926 o_group_desc = rcu_dereference(EXT4_SB(sb)->s_group_desc); in add_new_gdb()
928 EXT4_SB(sb)->s_gdb_count * sizeof(struct buffer_head *)); in add_new_gdb()
931 rcu_assign_pointer(EXT4_SB(sb)->s_group_desc, n_group_desc); in add_new_gdb()
932 EXT4_SB(sb)->s_gdb_count++; in add_new_gdb()
935 lock_buffer(EXT4_SB(sb)->s_sbh); in add_new_gdb()
936 le16_add_cpu(&es->s_reserved_gdt_blocks, -1); in add_new_gdb()
938 unlock_buffer(EXT4_SB(sb)->s_sbh); in add_new_gdb()
939 err = ext4_handle_dirty_metadata(handle, NULL, EXT4_SB(sb)->s_sbh); in add_new_gdb()
956 * the meta_bg feature will get enabled, and es->s_first_meta_bg will get set
979 err = -ENOMEM; in add_new_gdb_meta_bg()
986 o_group_desc = rcu_dereference(EXT4_SB(sb)->s_group_desc); in add_new_gdb_meta_bg()
988 EXT4_SB(sb)->s_gdb_count * sizeof(struct buffer_head *)); in add_new_gdb_meta_bg()
1000 rcu_assign_pointer(EXT4_SB(sb)->s_group_desc, n_group_desc); in add_new_gdb_meta_bg()
1001 EXT4_SB(sb)->s_gdb_count++; in add_new_gdb_meta_bg()
1013 * The indirect blocks are actually the primary reserved GDT blocks,
1015 * double-indirect block to verify it is pointing to the primary reserved
1017 * backup GDT blocks are stored in their reserved primary GDT block.
1022 struct super_block *sb = inode->i_sb; in reserve_backup_gdb()
1023 int reserved_gdb =le16_to_cpu(EXT4_SB(sb)->s_es->s_reserved_gdt_blocks); in reserve_backup_gdb()
1024 int cluster_bits = EXT4_SB(sb)->s_cluster_bits; in reserve_backup_gdb()
1025 struct buffer_head **primary; in reserve_backup_gdb() local
1034 primary = kmalloc_array(reserved_gdb, sizeof(*primary), GFP_NOFS); in reserve_backup_gdb()
1035 if (!primary) in reserve_backup_gdb()
1036 return -ENOMEM; in reserve_backup_gdb()
1038 data = EXT4_I(inode)->i_data + EXT4_DIND_BLOCK; in reserve_backup_gdb()
1046 blk = EXT4_SB(sb)->s_sbh->b_blocknr + 1 + EXT4_SB(sb)->s_gdb_count; in reserve_backup_gdb()
1047 data = (__le32 *)dind->b_data + (EXT4_SB(sb)->s_gdb_count % in reserve_backup_gdb()
1049 end = (__le32 *)dind->b_data + EXT4_ADDR_PER_BLOCK(sb); in reserve_backup_gdb()
1051 /* Get each reserved primary GDT block and verify it holds backups */ in reserve_backup_gdb()
1057 (long)(data - (__le32 *)dind->b_data)); in reserve_backup_gdb()
1058 err = -EINVAL; in reserve_backup_gdb()
1061 primary[res] = ext4_sb_bread(sb, blk, 0); in reserve_backup_gdb()
1062 if (IS_ERR(primary[res])) { in reserve_backup_gdb()
1063 err = PTR_ERR(primary[res]); in reserve_backup_gdb()
1064 primary[res] = NULL; in reserve_backup_gdb()
1067 gdbackups = verify_reserved_gdb(sb, group, primary[res]); in reserve_backup_gdb()
1069 brelse(primary[res]); in reserve_backup_gdb()
1074 data = (__le32 *)dind->b_data; in reserve_backup_gdb()
1078 BUFFER_TRACE(primary[i], "get_write_access"); in reserve_backup_gdb()
1079 if ((err = ext4_journal_get_write_access(handle, sb, primary[i], in reserve_backup_gdb()
1088 * Finally we can add each of the reserved backup GDT blocks from in reserve_backup_gdb()
1089 * the new group to its reserved primary GDT block. in reserve_backup_gdb()
1094 data = (__le32 *)primary[i]->b_data; in reserve_backup_gdb()
1095 data[gdbackups] = cpu_to_le32(blk + primary[i]->b_blocknr); in reserve_backup_gdb()
1096 err2 = ext4_handle_dirty_metadata(handle, NULL, primary[i]); in reserve_backup_gdb()
1101 inode->i_blocks += reserved_gdb * sb->s_blocksize >> (9 - cluster_bits); in reserve_backup_gdb()
1105 while (--res >= 0) in reserve_backup_gdb()
1106 brelse(primary[res]); in reserve_backup_gdb()
1110 kfree(primary); in reserve_backup_gdb()
1120 es->s_block_group_nr = cpu_to_le16(group); in ext4_set_block_group_nr()
1122 es->s_checksum = ext4_superblock_csum(sb, es); in ext4_set_block_group_nr()
1127 * of the main resize transaction, because e2fsck will re-write them if there
1129 * _should_ update the backups if possible, in case the primary gets trashed
1137 * sbi->s_groups_count, because the worst that can happen is that we
1151 int rest = sb->s_blocksize - size; in update_backups()
1164 last = sbi->s_groups_count; in update_backups()
1167 last = (ext4_group_t)(group + EXT4_DESC_PER_BLOCK(sb) - 2); in update_backups()
1170 while (group < sbi->s_groups_count) { in update_backups()
1176 /* Out of journal space, and can't get more - abort - so sad */ in update_backups()
1188 err = -ENOMEM; in update_backups()
1192 backup_block, backup_block - in update_backups()
1201 memcpy(bh->b_data, data, size); in update_backups()
1203 memset(bh->b_data + size, 0, rest); in update_backups()
1205 ext4_set_block_group_nr(sb, bh->b_data, group); in update_backups()
1229 * can't really start a transaction to mark the superblock. in update_backups()
1231 * to disk, and if not - we will simply wait until next fsck. in update_backups()
1235 ext4_warning(sb, "can't update backup for group %u (err %d), " in update_backups()
1237 sbi->s_mount_state &= ~EXT4_VALID_FS; in update_backups()
1238 sbi->s_es->s_state &= cpu_to_le16(~EXT4_VALID_FS); in update_backups()
1239 mark_buffer_dirty(sbi->s_sbh); in update_backups()
1258 struct ext4_super_block *es = sbi->s_es; in ext4_add_new_descs()
1266 le16_to_cpu(es->s_reserved_gdt_blocks) : 0; in ext4_add_new_descs()
1275 * use non-sparse filesystems anymore. This is already checked above. in ext4_add_new_descs()
1321 bh = ext4_get_bitmap(sb, group_data->inode_bitmap); in ext4_set_bitmap_checksums()
1323 return -EIO; in ext4_set_bitmap_checksums()
1327 bh = ext4_get_bitmap(sb, group_data->block_bitmap); in ext4_set_bitmap_checksums()
1329 return -EIO; in ext4_set_bitmap_checksums()
1342 struct ext4_new_group_data *group_data = flex_gd->groups; in ext4_setup_new_descs()
1347 __u16 *bg_flags = flex_gd->bg_flags; in ext4_setup_new_descs()
1351 for (i = 0; i < flex_gd->count; i++, group_data++, bg_flags++) { in ext4_setup_new_descs()
1352 group = group_data->group; in ext4_setup_new_descs()
1362 gdp = (struct ext4_group_desc *)(gdb_bh->b_data + in ext4_setup_new_descs()
1366 ext4_block_bitmap_set(sb, gdp, group_data->block_bitmap); in ext4_setup_new_descs()
1367 ext4_inode_bitmap_set(sb, gdp, group_data->inode_bitmap); in ext4_setup_new_descs()
1374 ext4_inode_table_set(sb, gdp, group_data->inode_table); in ext4_setup_new_descs()
1376 group_data->free_clusters_count); in ext4_setup_new_descs()
1381 gdp->bg_flags = cpu_to_le16(*bg_flags); in ext4_setup_new_descs()
1391 * We can allocate memory for mb_alloc based on the new group in ext4_setup_new_descs()
1405 struct ext4_super_block *es = sbi->s_es; in ext4_add_overhead()
1407 sbi->s_overhead += overhead; in ext4_add_overhead()
1408 es->s_overhead_clusters = cpu_to_le32(sbi->s_overhead); in ext4_add_overhead()
1414 * groups can be seen by the filesystem.
1425 struct ext4_new_group_data *group_data = flex_gd->groups; in ext4_update_super()
1427 struct ext4_super_block *es = sbi->s_es; in ext4_update_super()
1430 BUG_ON(flex_gd->count == 0 || group_data == NULL); in ext4_update_super()
1436 * We always allocate group-by-group, then block-by-block or in ext4_update_super()
1437 * inode-by-inode within a group, so enabling these in ext4_update_super()
1441 for (i = 0; i < flex_gd->count; i++) { in ext4_update_super()
1451 lock_buffer(sbi->s_sbh); in ext4_update_super()
1454 le32_add_cpu(&es->s_inodes_count, EXT4_INODES_PER_GROUP(sb) * in ext4_update_super()
1455 flex_gd->count); in ext4_update_super()
1456 le32_add_cpu(&es->s_free_inodes_count, EXT4_INODES_PER_GROUP(sb) * in ext4_update_super()
1457 flex_gd->count); in ext4_update_super()
1472 * NB. These rules can be relaxed when checking the group count in ext4_update_super()
1473 * while freeing data, as we can only allocate from a block in ext4_update_super()
1474 * group after serialising against the group count, and we can in ext4_update_super()
1481 sbi->s_groups_count += flex_gd->count; in ext4_update_super()
1482 sbi->s_blockfile_groups = min_t(ext4_group_t, sbi->s_groups_count, in ext4_update_super()
1491 percpu_counter_add(&sbi->s_freeclusters_counter, in ext4_update_super()
1493 percpu_counter_add(&sbi->s_freeinodes_counter, in ext4_update_super()
1494 EXT4_INODES_PER_GROUP(sb) * flex_gd->count); in ext4_update_super()
1497 percpu_counter_read(&sbi->s_freeclusters_counter)); in ext4_update_super()
1498 if (ext4_has_feature_flex_bg(sb) && sbi->s_log_groups_per_flex) { in ext4_update_super()
1505 &fg->free_clusters); in ext4_update_super()
1506 atomic_add(EXT4_INODES_PER_GROUP(sb) * flex_gd->count, in ext4_update_super()
1507 &fg->free_inodes); in ext4_update_super()
1517 if (ext4_has_feature_bigalloc(sb) && (sbi->s_overhead != 0)) in ext4_update_super()
1519 EXT4_NUM_B2C(sbi, blocks_count - free_blocks)); in ext4_update_super()
1522 es->s_overhead_clusters = cpu_to_le32(sbi->s_overhead); in ext4_update_super()
1525 unlock_buffer(sbi->s_sbh); in ext4_update_super()
1527 printk(KERN_DEBUG "EXT4-fs: added group %u:" in ext4_update_super()
1528 "%llu blocks(%llu free %llu reserved)\n", flex_gd->count, in ext4_update_super()
1541 struct ext4_super_block *es = sbi->s_es; in ext4_flex_group_add()
1549 BUG_ON(!flex_gd->count || !flex_gd->groups || !flex_gd->bg_flags); in ext4_flex_group_add()
1551 reserved_gdb = le16_to_cpu(es->s_reserved_gdt_blocks); in ext4_flex_group_add()
1568 credit += 1 + DIV_ROUND_UP(flex_gd->count, EXT4_DESC_PER_BLOCK(sb)); in ext4_flex_group_add()
1576 BUFFER_TRACE(sbi->s_sbh, "get_write_access"); in ext4_flex_group_add()
1577 err = ext4_journal_get_write_access(handle, sb, sbi->s_sbh, in ext4_flex_group_add()
1582 group = flex_gd->groups[0].group; in ext4_flex_group_add()
1583 BUG_ON(group != sbi->s_groups_count); in ext4_flex_group_add()
1585 resize_inode, flex_gd->count); in ext4_flex_group_add()
1595 err = ext4_handle_dirty_metadata(handle, NULL, sbi->s_sbh); in ext4_flex_group_add()
1604 int gdb_num_end = ((group + flex_gd->count - 1) / in ext4_flex_group_add()
1607 gdb_num >= le32_to_cpu(es->s_first_meta_bg); in ext4_flex_group_add()
1608 sector_t padding_blocks = meta_bg ? 0 : sbi->s_sbh->b_blocknr - in ext4_flex_group_add()
1618 update_backups(sb, gdb_bh->b_blocknr - padding_blocks, in ext4_flex_group_add()
1619 gdb_bh->b_data, gdb_bh->b_size, meta_bg); in ext4_flex_group_add()
1631 struct ext4_super_block *es = sbi->s_es; in ext4_setup_next_flex_gd()
1632 struct ext4_new_group_data *group_data = flex_gd->groups; in ext4_setup_next_flex_gd()
1650 ext4_get_group_no_and_offset(sb, n_blocks_count - 1, &n_group, &last); in ext4_setup_next_flex_gd()
1652 last_group = group | (flex_gd->resize_bg - 1); in ext4_setup_next_flex_gd()
1656 flex_gd->count = last_group - group + 1; in ext4_setup_next_flex_gd()
1658 for (i = 0; i < flex_gd->count; i++) { in ext4_setup_next_flex_gd()
1667 flex_gd->bg_flags[i] = EXT4_BG_BLOCK_UNINIT | in ext4_setup_next_flex_gd()
1670 flex_gd->bg_flags[i] |= EXT4_BG_INODE_ZEROED; in ext4_setup_next_flex_gd()
1672 flex_gd->bg_flags[i] = EXT4_BG_INODE_ZEROED; in ext4_setup_next_flex_gd()
1677 flex_gd->bg_flags[i - 1] &= ~EXT4_BG_BLOCK_UNINIT; in ext4_setup_next_flex_gd()
1679 if ((last_group == n_group) && (last != clusters_per_group - 1)) { in ext4_setup_next_flex_gd()
1680 group_data[i - 1].blocks_count = EXT4_C2B(sbi, last + 1); in ext4_setup_next_flex_gd()
1681 group_data[i - 1].free_clusters_count -= clusters_per_group - in ext4_setup_next_flex_gd()
1682 last - 1; in ext4_setup_next_flex_gd()
1698 * not really "added" the group at all. We re-check that we are still
1705 struct ext4_super_block *es = sbi->s_es; in ext4_group_add()
1706 int reserved_gdb = ext4_bg_has_super(sb, input->group) ? in ext4_group_add()
1707 le16_to_cpu(es->s_reserved_gdt_blocks) : 0; in ext4_group_add()
1713 gdb_off = input->group % EXT4_DESC_PER_BLOCK(sb); in ext4_group_add()
1716 ext4_warning(sb, "Can't resize non-sparse filesystem further"); in ext4_group_add()
1717 return -EPERM; in ext4_group_add()
1720 if (ext4_blocks_count(es) + input->blocks_count < in ext4_group_add()
1723 return -EINVAL; in ext4_group_add()
1726 if (le32_to_cpu(es->s_inodes_count) + EXT4_INODES_PER_GROUP(sb) < in ext4_group_add()
1727 le32_to_cpu(es->s_inodes_count)) { in ext4_group_add()
1729 return -EINVAL; in ext4_group_add()
1734 !le16_to_cpu(es->s_reserved_gdt_blocks)) { in ext4_group_add()
1736 "No reserved GDT blocks, can't resize"); in ext4_group_add()
1737 return -EPERM; in ext4_group_add()
1751 err = ext4_alloc_flex_bg_array(sb, input->group + 1); in ext4_group_add()
1755 err = ext4_mb_alloc_groupinfo(sb, input->group + 1); in ext4_group_add()
1774 struct ext4_super_block *es = EXT4_SB(sb)->s_es; in ext4_group_extend_no_check()
1788 BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get_write_access"); in ext4_group_extend_no_check()
1789 err = ext4_journal_get_write_access(handle, sb, EXT4_SB(sb)->s_sbh, in ext4_group_extend_no_check()
1796 lock_buffer(EXT4_SB(sb)->s_sbh); in ext4_group_extend_no_check()
1800 unlock_buffer(EXT4_SB(sb)->s_sbh); in ext4_group_extend_no_check()
1807 ext4_handle_dirty_metadata(handle, NULL, EXT4_SB(sb)->s_sbh); in ext4_group_extend_no_check()
1817 printk(KERN_DEBUG "EXT4-fs: extended group to %llu " in ext4_group_extend_no_check()
1828 * existing group. It can be accessed via ioctl, or by "remount,resize=<size>"
1854 if (n_blocks_count > (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) { in ext4_group_extend()
1858 return -EINVAL; in ext4_group_extend()
1862 ext4_warning(sb, "can't shrink FS - resize aborted"); in ext4_group_extend()
1863 return -EINVAL; in ext4_group_extend()
1871 return -EPERM; in ext4_group_extend()
1874 add = EXT4_BLOCKS_PER_GROUP(sb) - last; in ext4_group_extend()
1878 return -EINVAL; in ext4_group_extend()
1882 add = n_blocks_count - o_blocks_count; in ext4_group_extend()
1889 bh = ext4_sb_bread(sb, o_blocks_count + add - 1, 0); in ext4_group_extend()
1891 ext4_warning(sb, "can't read last block, resize aborted"); in ext4_group_extend()
1892 return -ENOSPC; in ext4_group_extend()
1902 return (groups + EXT4_DESC_PER_BLOCK(sb) - 1) / EXT4_DESC_PER_BLOCK(sb); in num_desc_blocks()
1914 struct ext4_super_block *es = sbi->s_es; in ext4_convert_meta_bg()
1922 if (es->s_reserved_gdt_blocks) { in ext4_convert_meta_bg()
1923 ext4_error(sb, "Unexpected non-zero " in ext4_convert_meta_bg()
1925 return -EPERM; in ext4_convert_meta_bg()
1929 if (inode->i_blocks != 1 << (inode->i_blkbits - in ext4_convert_meta_bg()
1930 (9 - sbi->s_cluster_bits))) in ext4_convert_meta_bg()
1934 if (ei->i_data[i]) in ext4_convert_meta_bg()
1939 if (ei->i_data[i]) in ext4_convert_meta_bg()
1949 BUFFER_TRACE(sbi->s_sbh, "get_write_access"); in ext4_convert_meta_bg()
1950 err = ext4_journal_get_write_access(handle, sb, sbi->s_sbh, in ext4_convert_meta_bg()
1955 lock_buffer(sbi->s_sbh); in ext4_convert_meta_bg()
1958 sbi->s_es->s_first_meta_bg = in ext4_convert_meta_bg()
1959 cpu_to_le32(num_desc_blocks(sb, sbi->s_groups_count)); in ext4_convert_meta_bg()
1961 unlock_buffer(sbi->s_sbh); in ext4_convert_meta_bg()
1963 err = ext4_handle_dirty_metadata(handle, NULL, sbi->s_sbh); in ext4_convert_meta_bg()
1970 nr = le32_to_cpu(ei->i_data[EXT4_DIND_BLOCK]); in ext4_convert_meta_bg()
1974 ei->i_data[EXT4_DIND_BLOCK] = 0; in ext4_convert_meta_bg()
1975 inode->i_blocks = 0; in ext4_convert_meta_bg()
1988 return -EINVAL; in ext4_convert_meta_bg()
2001 struct ext4_super_block *es = sbi->s_es; in ext4_resize_fs()
2017 bh = ext4_sb_bread(sb, n_blocks_count - 1, 0); in ext4_resize_fs()
2019 ext4_warning(sb, "can't read last block, resize aborted"); in ext4_resize_fs()
2020 return -ENOSPC; in ext4_resize_fs()
2032 n_blocks_count &= ~((1 << EXT4_CLUSTER_BITS(sb)) - 1); in ext4_resize_fs()
2041 /* On-line shrinking not supported */ in ext4_resize_fs()
2042 ext4_warning(sb, "can't shrink FS - resize aborted"); in ext4_resize_fs()
2043 return -EINVAL; in ext4_resize_fs()
2050 n_group = ext4_get_group_number(sb, n_blocks_count - 1); in ext4_resize_fs()
2053 return -EINVAL; in ext4_resize_fs()
2055 ext4_get_group_no_and_offset(sb, o_blocks_count - 1, &o_group, &offset); in ext4_resize_fs()
2058 o_desc_blocks = num_desc_blocks(sb, sbi->s_groups_count); in ext4_resize_fs()
2066 return -EINVAL; in ext4_resize_fs()
2069 le16_to_cpu(es->s_reserved_gdt_blocks)) { in ext4_resize_fs()
2072 le16_to_cpu(es->s_reserved_gdt_blocks); in ext4_resize_fs()
2076 le32_to_cpu(es->s_first_data_block); in ext4_resize_fs()
2077 n_group--; /* set to last group number */ in ext4_resize_fs()
2113 sbi->s_itb_per_group + sbi->s_cluster_ratio) >= n_blocks_count) { in ext4_resize_fs()
2115 n_group--; in ext4_resize_fs()
2126 add = n_blocks_count - o_blocks_count; in ext4_resize_fs()
2128 add = EXT4_C2B(sbi, EXT4_CLUSTERS_PER_GROUP(sb) - (offset + 1)); in ext4_resize_fs()
2148 err = -ENOMEM; in ext4_resize_fs()