Lines Matching +full:add +full:- +full:fs
2 * linux/fs/ext4/resize.c
24 return -EPERM; in ext4_resize_begin()
27 * We are not allowed to do online-resizing on a filesystem mounted in ext4_resize_begin()
30 if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) { in ext4_resize_begin()
33 return -EPERM; in ext4_resize_begin()
36 if (test_and_set_bit_lock(EXT4_RESIZING, &EXT4_SB(sb)->s_resize_flags)) in ext4_resize_begin()
37 ret = -EBUSY; in ext4_resize_begin()
44 clear_bit_unlock(EXT4_RESIZING, &EXT4_SB(sb)->s_resize_flags); in ext4_resize_end()
55 struct ext4_super_block *es = sbi->s_es; in verify_group_input()
57 ext4_fsblk_t end = start + input->blocks_count; in verify_group_input()
58 ext4_group_t group = input->group; in verify_group_input()
59 ext4_fsblk_t itend = input->inode_table + sbi->s_itb_per_group; in verify_group_input()
62 le16_to_cpu(es->s_reserved_gdt_blocks)) : 0; in verify_group_input()
66 int err = -EINVAL; in verify_group_input()
68 input->free_blocks_count = free_blocks_count = in verify_group_input()
69 input->blocks_count - 2 - overhead - sbi->s_itb_per_group; in verify_group_input()
72 printk(KERN_DEBUG "EXT4-fs: adding %s group %u: %u blocks " in verify_group_input()
74 ext4_bg_has_super(sb, input->group) ? "normal" : in verify_group_input()
75 "no-super", input->group, input->blocks_count, in verify_group_input()
76 free_blocks_count, input->reserved_blocks); in verify_group_input()
79 if (group != sbi->s_groups_count) in verify_group_input()
80 ext4_warning(sb, "Cannot add at group %u (only %u groups)", in verify_group_input()
81 input->group, sbi->s_groups_count); in verify_group_input()
84 else if (input->reserved_blocks > input->blocks_count / 5) in verify_group_input()
86 input->reserved_blocks); in verify_group_input()
89 input->blocks_count); in verify_group_input()
90 else if (!(bh = sb_bread(sb, end - 1))) in verify_group_input()
92 end - 1); in verify_group_input()
93 else if (outside(input->block_bitmap, start, end)) in verify_group_input()
95 (unsigned long long)input->block_bitmap); in verify_group_input()
96 else if (outside(input->inode_bitmap, start, end)) in verify_group_input()
98 (unsigned long long)input->inode_bitmap); in verify_group_input()
99 else if (outside(input->inode_table, start, end) || in verify_group_input()
100 outside(itend - 1, start, end)) in verify_group_input()
101 ext4_warning(sb, "Inode table not in group (blocks %llu-%llu)", in verify_group_input()
102 (unsigned long long)input->inode_table, itend - 1); in verify_group_input()
103 else if (input->inode_bitmap == input->block_bitmap) in verify_group_input()
105 (unsigned long long)input->block_bitmap); in verify_group_input()
106 else if (inside(input->block_bitmap, input->inode_table, itend)) in verify_group_input()
108 "(%llu-%llu)", in verify_group_input()
109 (unsigned long long)input->block_bitmap, in verify_group_input()
110 (unsigned long long)input->inode_table, itend - 1); in verify_group_input()
111 else if (inside(input->inode_bitmap, input->inode_table, itend)) in verify_group_input()
113 "(%llu-%llu)", in verify_group_input()
114 (unsigned long long)input->inode_bitmap, in verify_group_input()
115 (unsigned long long)input->inode_table, itend - 1); in verify_group_input()
116 else if (inside(input->block_bitmap, start, metaend)) in verify_group_input()
117 ext4_warning(sb, "Block bitmap (%llu) in GDT table (%llu-%llu)", in verify_group_input()
118 (unsigned long long)input->block_bitmap, in verify_group_input()
119 start, metaend - 1); in verify_group_input()
120 else if (inside(input->inode_bitmap, start, metaend)) in verify_group_input()
121 ext4_warning(sb, "Inode bitmap (%llu) in GDT table (%llu-%llu)", in verify_group_input()
122 (unsigned long long)input->inode_bitmap, in verify_group_input()
123 start, metaend - 1); in verify_group_input()
124 else if (inside(input->inode_table, start, metaend) || in verify_group_input()
125 inside(itend - 1, start, metaend)) in verify_group_input()
126 ext4_warning(sb, "Inode table (%llu-%llu) overlaps GDT table " in verify_group_input()
127 "(%llu-%llu)", in verify_group_input()
128 (unsigned long long)input->inode_table, in verify_group_input()
129 itend - 1, start, metaend - 1); in verify_group_input()
138 * ext4_new_flex_group_data is used by 64bit-resize interface to add a flex
164 flex_gd->count = flexbg_size; in alloc_flex_gd()
166 flex_gd->groups = kmalloc(sizeof(struct ext4_new_group_data) * in alloc_flex_gd()
168 if (flex_gd->groups == NULL) in alloc_flex_gd()
171 flex_gd->bg_flags = kmalloc(flexbg_size * sizeof(__u16), GFP_NOFS); in alloc_flex_gd()
172 if (flex_gd->bg_flags == NULL) in alloc_flex_gd()
178 kfree(flex_gd->groups); in alloc_flex_gd()
187 kfree(flex_gd->bg_flags); in free_flex_gd()
188 kfree(flex_gd->groups); in free_flex_gd()
196 * This function is used by 64bit-resize. Note that this function allocates
200 * @sb: super block of fs to which the groups belongs
206 struct ext4_new_group_data *group_data = flex_gd->groups; in ext4_alloc_group_tables()
207 struct ext4_super_block *es = EXT4_SB(sb)->s_es; in ext4_alloc_group_tables()
218 BUG_ON(flex_gd->count == 0 || group_data == NULL); in ext4_alloc_group_tables()
221 last_group = src_group + flex_gd->count - 1; in ext4_alloc_group_tables()
223 BUG_ON((flexbg_size > 1) && ((src_group & ~(flexbg_size - 1)) != in ext4_alloc_group_tables()
224 (last_group & ~(flexbg_size - 1)))); in ext4_alloc_group_tables()
228 last_blk = start_blk + group_data[src_group - group].blocks_count; in ext4_alloc_group_tables()
232 le16_to_cpu(es->s_reserved_gdt_blocks)) : 0; in ext4_alloc_group_tables()
236 BUG_ON(src_group >= group_data[0].group + flex_gd->count); in ext4_alloc_group_tables()
241 last_blk += group_data[src_group - group].blocks_count; in ext4_alloc_group_tables()
246 for (; bb_index < flex_gd->count; bb_index++) { in ext4_alloc_group_tables()
250 ext4_get_group_no_and_offset(sb, start_blk - 1, &group, NULL); in ext4_alloc_group_tables()
251 group -= group_data[0].group; in ext4_alloc_group_tables()
252 group_data[group].free_blocks_count--; in ext4_alloc_group_tables()
254 flex_gd->bg_flags[group] &= ~EXT4_BG_BLOCK_UNINIT; in ext4_alloc_group_tables()
258 for (; ib_index < flex_gd->count; ib_index++) { in ext4_alloc_group_tables()
262 ext4_get_group_no_and_offset(sb, start_blk - 1, &group, NULL); in ext4_alloc_group_tables()
263 group -= group_data[0].group; in ext4_alloc_group_tables()
264 group_data[group].free_blocks_count--; in ext4_alloc_group_tables()
266 flex_gd->bg_flags[group] &= ~EXT4_BG_BLOCK_UNINIT; in ext4_alloc_group_tables()
270 for (; it_index < flex_gd->count; it_index++) { in ext4_alloc_group_tables()
271 if (start_blk + EXT4_SB(sb)->s_itb_per_group > last_blk) in ext4_alloc_group_tables()
275 group -= group_data[0].group; in ext4_alloc_group_tables()
276 group_data[group].free_blocks_count -= in ext4_alloc_group_tables()
277 EXT4_SB(sb)->s_itb_per_group; in ext4_alloc_group_tables()
279 flex_gd->bg_flags[group] &= ~EXT4_BG_BLOCK_UNINIT; in ext4_alloc_group_tables()
281 start_blk += EXT4_SB(sb)->s_itb_per_group; in ext4_alloc_group_tables()
288 printk(KERN_DEBUG "EXT4-fs: adding a flex group with " in ext4_alloc_group_tables()
289 "%d groups, flexbg size is %d:\n", flex_gd->count, in ext4_alloc_group_tables()
292 for (i = 0; i < flex_gd->count; i++) { in ext4_alloc_group_tables()
296 "no-super", group + i, in ext4_alloc_group_tables()
311 return ERR_PTR(-EIO); in bclean()
316 memset(bh->b_data, 0, sb->s_blocksize); in bclean()
363 for (count2 = count; count > 0; count -= count2, block += count2) { in set_flexbg_block_bitmap()
371 group -= flex_gd->groups[0].group; in set_flexbg_block_bitmap()
373 count2 = sb->s_blocksize * 8 - (block - start); in set_flexbg_block_bitmap()
377 if (flex_gd->bg_flags[group] & EXT4_BG_BLOCK_UNINIT) { in set_flexbg_block_bitmap()
378 BUG_ON(flex_gd->count > 1); in set_flexbg_block_bitmap()
386 bh = sb_getblk(sb, flex_gd->groups[group].block_bitmap); in set_flexbg_block_bitmap()
388 return -EIO; in set_flexbg_block_bitmap()
394 block - start, count2); in set_flexbg_block_bitmap()
395 ext4_set_bits(bh->b_data, block - start, count2); in set_flexbg_block_bitmap()
423 int group_table_count[] = {1, 1, EXT4_SB(sb)->s_itb_per_group}; in setup_new_flex_group_blocks()
427 struct ext4_super_block *es = sbi->s_es; in setup_new_flex_group_blocks()
428 struct ext4_new_group_data *group_data = flex_gd->groups; in setup_new_flex_group_blocks()
429 __u16 *bg_flags = flex_gd->bg_flags; in setup_new_flex_group_blocks()
435 BUG_ON(!flex_gd->count || !group_data || in setup_new_flex_group_blocks()
436 group_data[0].group != sbi->s_groups_count); in setup_new_flex_group_blocks()
438 reserved_gdb = le16_to_cpu(es->s_reserved_gdt_blocks); in setup_new_flex_group_blocks()
446 for (i = 0; i < flex_gd->count; i++, group++) { in setup_new_flex_group_blocks()
463 err = -EIO; in setup_new_flex_group_blocks()
472 memcpy(gdb->b_data, sbi->s_group_desc[j]->b_data, in setup_new_flex_group_blocks()
473 gdb->b_size); in setup_new_flex_group_blocks()
500 ext4_debug("clear inode table blocks %#04llx -> %#04lx\n", in setup_new_flex_group_blocks()
501 block, sbi->s_itb_per_group); in setup_new_flex_group_blocks()
502 err = sb_issue_zeroout(sb, block, sbi->s_itb_per_group, in setup_new_flex_group_blocks()
525 ext4_set_bits(bh->b_data, 0, gdblocks + reserved_gdb + in setup_new_flex_group_blocks()
529 sb->s_blocksize * 8, bh->b_data); in setup_new_flex_group_blocks()
552 sb->s_blocksize * 8, bh->b_data); in setup_new_flex_group_blocks()
565 for (i = 1; i < flex_gd->count; i++) { in setup_new_flex_group_blocks()
602 * For a non-sparse filesystem it will be every group: 1, 2, 3, 4, ...
636 * groups in current filesystem that have BACKUPS, or -ve error code.
642 const ext4_fsblk_t blk = primary->b_blocknr; in verify_reserved_gdb()
647 __le32 *p = (__le32 *)primary->b_data; in verify_reserved_gdb()
659 return -EINVAL; in verify_reserved_gdb()
662 return -EFBIG; in verify_reserved_gdb()
684 struct super_block *sb = inode->i_sb; in add_new_gdb()
685 struct ext4_super_block *es = EXT4_SB(sb)->s_es; in add_new_gdb()
687 ext4_fsblk_t gdblock = EXT4_SB(sb)->s_sbh->b_blocknr + 1 + gdb_num; in add_new_gdb()
698 "EXT4-fs: ext4_add_new_gdb: adding group block %lu\n", in add_new_gdb()
706 if (EXT4_SB(sb)->s_sbh->b_blocknr != in add_new_gdb()
707 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block)) { in add_new_gdb()
709 (unsigned long long)EXT4_SB(sb)->s_sbh->b_blocknr); in add_new_gdb()
710 return -EPERM; in add_new_gdb()
715 return -EIO; in add_new_gdb()
723 data = EXT4_I(inode)->i_data + EXT4_DIND_BLOCK; in add_new_gdb()
726 err = -EIO; in add_new_gdb()
730 data = (__le32 *)dind->b_data; in add_new_gdb()
734 err = -EINVAL; in add_new_gdb()
738 err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh); in add_new_gdb()
759 err = -ENOMEM; in add_new_gdb()
768 * Remove new GDT block from inode double-indirect block and clear out in add_new_gdb()
771 * these blocks, because they are marked as in-use from being in the in add_new_gdb()
780 inode->i_blocks -= (gdbackups + 1) * sb->s_blocksize >> 9; in add_new_gdb()
782 memset(gdb_bh->b_data, 0, sb->s_blocksize); in add_new_gdb()
790 o_group_desc = EXT4_SB(sb)->s_group_desc; in add_new_gdb()
792 EXT4_SB(sb)->s_gdb_count * sizeof(struct buffer_head *)); in add_new_gdb()
794 EXT4_SB(sb)->s_group_desc = n_group_desc; in add_new_gdb()
795 EXT4_SB(sb)->s_gdb_count++; in add_new_gdb()
798 le16_add_cpu(&es->s_reserved_gdt_blocks, -1); in add_new_gdb()
799 err = ext4_handle_dirty_metadata(handle, NULL, EXT4_SB(sb)->s_sbh); in add_new_gdb()
812 /* ext4_handle_release_buffer(handle, EXT4_SB(sb)->s_sbh); */ in add_new_gdb()
825 * We need to add these reserved backup GDT blocks to the resize inode, so
831 * double-indirect block to verify it is pointing to the primary reserved
838 struct super_block *sb = inode->i_sb; in reserve_backup_gdb()
839 int reserved_gdb =le16_to_cpu(EXT4_SB(sb)->s_es->s_reserved_gdt_blocks); in reserve_backup_gdb()
851 return -ENOMEM; in reserve_backup_gdb()
853 data = EXT4_I(inode)->i_data + EXT4_DIND_BLOCK; in reserve_backup_gdb()
856 err = -EIO; in reserve_backup_gdb()
860 blk = EXT4_SB(sb)->s_sbh->b_blocknr + 1 + EXT4_SB(sb)->s_gdb_count; in reserve_backup_gdb()
861 data = (__le32 *)dind->b_data + (EXT4_SB(sb)->s_gdb_count % in reserve_backup_gdb()
863 end = (__le32 *)dind->b_data + EXT4_ADDR_PER_BLOCK(sb); in reserve_backup_gdb()
871 (long)(data - (__le32 *)dind->b_data)); in reserve_backup_gdb()
872 err = -EINVAL; in reserve_backup_gdb()
877 err = -EIO; in reserve_backup_gdb()
887 data = (__le32 *)dind->b_data; in reserve_backup_gdb()
905 * Finally we can add each of the reserved backup GDT blocks from in reserve_backup_gdb()
911 data = (__le32 *)primary[i]->b_data; in reserve_backup_gdb()
913 primary[i]->b_blocknr, gdbackups, in reserve_backup_gdb()
914 blk + primary[i]->b_blocknr); */ in reserve_backup_gdb()
915 data[gdbackups] = cpu_to_le32(blk + primary[i]->b_blocknr); in reserve_backup_gdb()
920 inode->i_blocks += reserved_gdb * sb->s_blocksize >> 9; in reserve_backup_gdb()
924 while (--res >= 0) in reserve_backup_gdb()
936 * of the main resize transaction, because e2fsck will re-write them if there
946 * sbi->s_groups_count, because the worst that can happen is that we
954 const ext4_group_t last = sbi->s_groups_count; in update_backups()
960 int rest = sb->s_blocksize - size; in update_backups()
974 /* Out of journal space, and can't get more - abort - so sad */ in update_backups()
976 handle->h_buffer_credits == 0 && in update_backups()
983 err = -EIO; in update_backups()
987 (unsigned long)bh->b_blocknr); in update_backups()
991 memcpy(bh->b_data, data, size); in update_backups()
993 memset(bh->b_data + size, 0, rest); in update_backups()
1012 * to disk, and if not - we will simply wait until next fsck. in update_backups()
1018 sbi->s_mount_state &= ~EXT4_VALID_FS; in update_backups()
1019 sbi->s_es->s_state &= cpu_to_le16(~EXT4_VALID_FS); in update_backups()
1020 mark_buffer_dirty(sbi->s_sbh); in update_backups()
1039 struct ext4_super_block *es = sbi->s_es; in ext4_add_new_descs()
1045 le16_to_cpu(es->s_reserved_gdt_blocks) : 0; in ext4_add_new_descs()
1051 * We will only either add reserved group blocks to a backup group in ext4_add_new_descs()
1054 * use non-sparse filesystems anymore. This is already checked above. in ext4_add_new_descs()
1057 gdb_bh = sbi->s_group_desc[gdb_num]; in ext4_add_new_descs()
1076 struct ext4_new_group_data *group_data = flex_gd->groups; in ext4_setup_new_descs()
1081 __u16 *bg_flags = flex_gd->bg_flags; in ext4_setup_new_descs()
1085 for (i = 0; i < flex_gd->count; i++, group_data++, bg_flags++) { in ext4_setup_new_descs()
1086 group = group_data->group; in ext4_setup_new_descs()
1094 gdb_bh = sbi->s_group_desc[gdb_num]; in ext4_setup_new_descs()
1096 gdp = (struct ext4_group_desc *)((char *)gdb_bh->b_data + in ext4_setup_new_descs()
1100 ext4_block_bitmap_set(sb, gdp, group_data->block_bitmap); in ext4_setup_new_descs()
1101 ext4_inode_bitmap_set(sb, gdp, group_data->inode_bitmap); in ext4_setup_new_descs()
1102 ext4_inode_table_set(sb, gdp, group_data->inode_table); in ext4_setup_new_descs()
1104 EXT4_B2C(sbi, group_data->free_blocks_count)); in ext4_setup_new_descs()
1106 gdp->bg_flags = cpu_to_le16(*bg_flags); in ext4_setup_new_descs()
1107 gdp->bg_checksum = ext4_group_desc_csum(sbi, group, gdp); in ext4_setup_new_descs()
1139 struct ext4_new_group_data *group_data = flex_gd->groups; in ext4_update_super()
1141 struct ext4_super_block *es = sbi->s_es; in ext4_update_super()
1144 BUG_ON(flex_gd->count == 0 || group_data == NULL); in ext4_update_super()
1150 * We always allocate group-by-group, then block-by-block or in ext4_update_super()
1151 * inode-by-inode within a group, so enabling these in ext4_update_super()
1155 for (i = 0; i < flex_gd->count; i++) { in ext4_update_super()
1166 le32_add_cpu(&es->s_inodes_count, EXT4_INODES_PER_GROUP(sb) * in ext4_update_super()
1167 flex_gd->count); in ext4_update_super()
1189 /* Update the global fs size fields */ in ext4_update_super()
1190 sbi->s_groups_count += flex_gd->count; in ext4_update_super()
1198 percpu_counter_add(&sbi->s_freeclusters_counter, in ext4_update_super()
1200 percpu_counter_add(&sbi->s_freeinodes_counter, in ext4_update_super()
1201 EXT4_INODES_PER_GROUP(sb) * flex_gd->count); in ext4_update_super()
1205 sbi->s_log_groups_per_flex) { in ext4_update_super()
1209 &sbi->s_flex_groups[flex_group].free_clusters); in ext4_update_super()
1210 atomic_add(EXT4_INODES_PER_GROUP(sb) * flex_gd->count, in ext4_update_super()
1211 &sbi->s_flex_groups[flex_group].free_inodes); in ext4_update_super()
1215 printk(KERN_DEBUG "EXT4-fs: added group %u:" in ext4_update_super()
1216 "%llu blocks(%llu free %llu reserved)\n", flex_gd->count, in ext4_update_super()
1220 /* Add a flex group to an fs. Ensure we handle all possible error conditions
1229 struct ext4_super_block *es = sbi->s_es; in ext4_flex_group_add()
1237 BUG_ON(!flex_gd->count || !flex_gd->groups || !flex_gd->bg_flags); in ext4_flex_group_add()
1239 reserved_gdb = le16_to_cpu(es->s_reserved_gdt_blocks); in ext4_flex_group_add()
1254 credit = flex_gd->count * 4 + reserved_gdb; in ext4_flex_group_add()
1261 err = ext4_journal_get_write_access(handle, sbi->s_sbh); in ext4_flex_group_add()
1265 group = flex_gd->groups[0].group; in ext4_flex_group_add()
1266 BUG_ON(group != EXT4_SB(sb)->s_groups_count); in ext4_flex_group_add()
1268 resize_inode, flex_gd->count); in ext4_flex_group_add()
1287 update_backups(sb, sbi->s_sbh->b_blocknr, (char *)es, in ext4_flex_group_add()
1289 for (i = 0; i < flex_gd->count; i++, group++) { in ext4_flex_group_add()
1293 gdb_bh = sbi->s_group_desc[gdb_num]; in ext4_flex_group_add()
1294 update_backups(sb, gdb_bh->b_blocknr, gdb_bh->b_data, in ext4_flex_group_add()
1295 gdb_bh->b_size); in ext4_flex_group_add()
1307 struct ext4_super_block *es = EXT4_SB(sb)->s_es; in ext4_setup_next_flex_gd()
1308 struct ext4_new_group_data *group_data = flex_gd->groups; in ext4_setup_next_flex_gd()
1326 ext4_get_group_no_and_offset(sb, n_blocks_count - 1, &n_group, &last); in ext4_setup_next_flex_gd()
1328 last_group = group | (flexbg_size - 1); in ext4_setup_next_flex_gd()
1332 flex_gd->count = last_group - group + 1; in ext4_setup_next_flex_gd()
1334 for (i = 0; i < flex_gd->count; i++) { in ext4_setup_next_flex_gd()
1341 le16_to_cpu(es->s_reserved_gdt_blocks)) : 0; in ext4_setup_next_flex_gd()
1342 group_data[i].free_blocks_count = blocks_per_group - overhead; in ext4_setup_next_flex_gd()
1345 flex_gd->bg_flags[i] = EXT4_BG_BLOCK_UNINIT | in ext4_setup_next_flex_gd()
1348 flex_gd->bg_flags[i] = EXT4_BG_INODE_ZEROED; in ext4_setup_next_flex_gd()
1355 flex_gd->bg_flags[i - 1] &= ~EXT4_BG_BLOCK_UNINIT; in ext4_setup_next_flex_gd()
1357 if ((last_group == n_group) && (last != blocks_per_group - 1)) { in ext4_setup_next_flex_gd()
1358 group_data[i - 1].blocks_count = last + 1; in ext4_setup_next_flex_gd()
1359 group_data[i - 1].free_blocks_count -= blocks_per_group- in ext4_setup_next_flex_gd()
1360 last - 1; in ext4_setup_next_flex_gd()
1366 /* Add group descriptor data to an existing or new group descriptor block.
1372 * Otherwise, we may need to add backup GDT blocks for a sparse group.
1376 * not really "added" the group at all. We re-check that we are still
1383 struct ext4_super_block *es = sbi->s_es; in ext4_group_add()
1384 int reserved_gdb = ext4_bg_has_super(sb, input->group) ? in ext4_group_add()
1385 le16_to_cpu(es->s_reserved_gdt_blocks) : 0; in ext4_group_add()
1391 gdb_num = input->group / EXT4_DESC_PER_BLOCK(sb); in ext4_group_add()
1392 gdb_off = input->group % EXT4_DESC_PER_BLOCK(sb); in ext4_group_add()
1396 ext4_warning(sb, "Can't resize non-sparse filesystem further"); in ext4_group_add()
1397 return -EPERM; in ext4_group_add()
1400 if (ext4_blocks_count(es) + input->blocks_count < in ext4_group_add()
1403 return -EINVAL; in ext4_group_add()
1406 if (le32_to_cpu(es->s_inodes_count) + EXT4_INODES_PER_GROUP(sb) < in ext4_group_add()
1407 le32_to_cpu(es->s_inodes_count)) { in ext4_group_add()
1409 return -EINVAL; in ext4_group_add()
1415 || !le16_to_cpu(es->s_reserved_gdt_blocks)) { in ext4_group_add()
1418 return -EPERM; in ext4_group_add()
1445 ext4_fsblk_t o_blocks_count, ext4_grpblk_t add) in ext4_group_extend_no_check() argument
1447 struct ext4_super_block *es = EXT4_SB(sb)->s_es; in ext4_group_extend_no_check()
1461 err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh); in ext4_group_extend_no_check()
1467 ext4_blocks_count_set(es, o_blocks_count + add); in ext4_group_extend_no_check()
1469 o_blocks_count + add); in ext4_group_extend_no_check()
1470 /* We add the blocks to the bitmap and set the group need init bit */ in ext4_group_extend_no_check()
1471 err = ext4_group_add_blocks(handle, sb, o_blocks_count, add); in ext4_group_extend_no_check()
1476 o_blocks_count + add); in ext4_group_extend_no_check()
1484 printk(KERN_DEBUG "EXT4-fs: extended group to %llu " in ext4_group_extend_no_check()
1486 update_backups(sb, EXT4_SB(sb)->s_sbh->b_blocknr, (char *)es, in ext4_group_extend_no_check()
1507 ext4_grpblk_t add; in ext4_group_extend() local
1515 printk(KERN_DEBUG "EXT4-fs: extending last group from %llu to %llu blocks\n", in ext4_group_extend()
1521 if (n_blocks_count > (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) { in ext4_group_extend()
1522 printk(KERN_ERR "EXT4-fs: filesystem on %s:" in ext4_group_extend()
1524 sb->s_id, n_blocks_count); in ext4_group_extend()
1527 return -EINVAL; in ext4_group_extend()
1531 ext4_warning(sb, "can't shrink FS - resize aborted"); in ext4_group_extend()
1532 return -EINVAL; in ext4_group_extend()
1540 return -EPERM; in ext4_group_extend()
1543 add = EXT4_BLOCKS_PER_GROUP(sb) - last; in ext4_group_extend()
1545 if (o_blocks_count + add < o_blocks_count) { in ext4_group_extend()
1547 return -EINVAL; in ext4_group_extend()
1550 if (o_blocks_count + add > n_blocks_count) in ext4_group_extend()
1551 add = n_blocks_count - o_blocks_count; in ext4_group_extend()
1553 if (o_blocks_count + add < n_blocks_count) in ext4_group_extend()
1555 o_blocks_count + add, add); in ext4_group_extend()
1558 bh = sb_bread(sb, o_blocks_count + add - 1); in ext4_group_extend()
1561 return -ENOSPC; in ext4_group_extend()
1565 err = ext4_group_extend_no_check(sb, o_blocks_count, add); in ext4_group_extend()
1570 * ext4_resize_fs() resizes a fs to new size specified by @n_blocks_count
1572 * @sb: super block of the fs to be resized
1573 * @n_blocks_count: the number of blocks resides in the resized fs
1579 struct ext4_super_block *es = sbi->s_es; in ext4_resize_fs()
1594 printk(KERN_DEBUG "EXT4-fs: resizing filesystem from %llu " in ext4_resize_fs()
1598 /* On-line shrinking not supported */ in ext4_resize_fs()
1599 ext4_warning(sb, "can't shrink FS - resize aborted"); in ext4_resize_fs()
1600 return -EINVAL; in ext4_resize_fs()
1607 ext4_get_group_no_and_offset(sb, n_blocks_count - 1, &n_group, &offset); in ext4_resize_fs()
1612 o_desc_blocks = (sbi->s_groups_count + EXT4_DESC_PER_BLOCK(sb) - 1) / in ext4_resize_fs()
1614 desc_blocks = n_desc_blocks - o_desc_blocks; in ext4_resize_fs()
1618 le16_to_cpu(es->s_reserved_gdt_blocks) < desc_blocks)) { in ext4_resize_fs()
1620 return -EPERM; in ext4_resize_fs()
1630 bh = sb_bread(sb, n_blocks_count - 1); in ext4_resize_fs()
1633 return -ENOSPC; in ext4_resize_fs()
1639 ext4_grpblk_t add; in ext4_resize_fs() local
1640 add = EXT4_BLOCKS_PER_GROUP(sb) - offset; in ext4_resize_fs()
1641 err = ext4_group_extend_no_check(sb, o_blocks_count, add); in ext4_resize_fs()
1647 es->s_log_groups_per_flex) in ext4_resize_fs()
1648 flexbg_size = 1 << es->s_log_groups_per_flex; in ext4_resize_fs()
1656 err = -ENOMEM; in ext4_resize_fs()
1660 /* Add flex groups. Note that a regular group is a in ext4_resize_fs()
1677 printk(KERN_DEBUG "EXT4-fs: resized filesystem from %llu " in ext4_resize_fs()