Lines Matching defs:fs
28 static int ext2_add_group(struct ext2_fs *fs, blk_t groupsize)
36 if (fs->opt_verbose)
39 if (!ped_realloc ((void*) &fs->gd,
40 (fs->numgroups+1) * sizeof(struct ext2_group_desc)
41 + fs->blocksize))
44 if (fs->opt_debug)
46 if (EXT2_SUPER_BLOCKS_COUNT(fs->sb) !=
47 EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb)
48 + fs->numgroups * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb))
57 group = fs->numgroups;
58 sparse = ext2_is_group_sparse(fs, group);
59 groupstart = EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb)
60 + group * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
62 admin = fs->adminblocks;
64 admin -= fs->gdblocks + 1;
66 if (fs->opt_debug)
68 if (groupsize < fs->adminblocks ||
69 groupsize > EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb))
79 newgdblocks = ped_div_round_up((fs->numgroups + 1)
81 fs->blocksize);
82 if (newgdblocks != fs->gdblocks)
86 for (i=0;i<fs->numgroups;i++)
87 if (ext2_is_group_sparse(fs, i))
91 start = EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb)
92 + i * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
93 ext2_set_block_state(fs,
94 start + fs->gdblocks + 1, 1, 1);
97 fs->gdblocks++;
98 fs->adminblocks++;
103 fs->numgroups++;
105 fs->sb.s_inodes_count = PED_CPU_TO_LE32(
106 EXT2_SUPER_INODES_COUNT(fs->sb)
107 + EXT2_SUPER_INODES_PER_GROUP(fs->sb));
108 fs->sb.s_blocks_count = PED_CPU_TO_LE32(
109 EXT2_SUPER_BLOCKS_COUNT(fs->sb) + groupsize);
110 fs->sb.s_free_blocks_count = PED_CPU_TO_LE32(
111 EXT2_SUPER_FREE_BLOCKS_COUNT(fs->sb) + groupsize - admin);
112 fs->sb.s_free_inodes_count = PED_CPU_TO_LE32(
113 EXT2_SUPER_FREE_INODES_COUNT(fs->sb)
114 + EXT2_SUPER_INODES_PER_GROUP(fs->sb));
115 fs->metadirty |= EXT2_META_SB;
122 sparseoff = off + fs->itoffset - 2;
126 fs->gd[group].bg_block_bitmap
128 fs->gd[group].bg_inode_bitmap
133 fs->gd[group].bg_block_bitmap
135 fs->gd[group].bg_inode_bitmap
140 fs->gd[group].bg_inode_table = PED_CPU_TO_LE32(sparseoff + 2);
143 fs->gd[group].bg_free_blocks_count = PED_CPU_TO_LE16(groupsize - admin);
144 fs->gd[group].bg_free_inodes_count = PED_CPU_TO_LE16(
145 EXT2_SUPER_INODES_PER_GROUP(fs->sb));
146 fs->gd[group].bg_used_dirs_count = 0;
147 fs->metadirty |= EXT2_META_SB | EXT2_META_GD;
153 bh = ext2_bcreate(fs, EXT2_GROUP_BLOCK_BITMAP(fs->gd[group]));
160 for (i=1;i<=fs->gdblocks;i++)
164 i = EXT2_GROUP_BLOCK_BITMAP(fs->gd[group]) - groupstart;
167 i = EXT2_GROUP_INODE_BITMAP(fs->gd[group]) - groupstart;
170 for (i=0;i<fs->inodeblocks;i++)
174 j = EXT2_GROUP_INODE_TABLE(fs->gd[group])
179 for (i=groupsize;i<EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);i++)
185 if (!ext2_zero_blocks(fs, EXT2_GROUP_INODE_BITMAP(fs->gd[group]), 1))
187 if (!ext2_zero_blocks(fs, EXT2_GROUP_INODE_TABLE(fs->gd[group]),
188 fs->inodeblocks))
191 if (fs->opt_safe)
192 if (!ext2_sync(fs))
198 static int ext2_del_group(struct ext2_fs *fs)
206 if (fs->opt_verbose)
209 group = fs->numgroups - 1;
210 sparse = ext2_is_group_sparse(fs, group);
212 admin = fs->adminblocks;
214 admin -= fs->gdblocks + 1;
216 groupsize = EXT2_SUPER_BLOCKS_COUNT(fs->sb)
217 - EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb)
218 - group * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
220 if (EXT2_SUPER_FREE_BLOCKS_COUNT(fs->sb) < groupsize - admin)
228 if (EXT2_SUPER_FREE_INODES_COUNT(fs->sb)
229 < EXT2_SUPER_INODES_PER_GROUP(fs->sb))
237 if (fs->opt_debug)
239 if (EXT2_GROUP_FREE_INODES_COUNT(fs->gd[group]) !=
240 EXT2_SUPER_INODES_PER_GROUP(fs->sb))
249 newgdblocks = ped_div_round_up((fs->numgroups - 1) *
250 sizeof(struct ext2_group_desc), fs->blocksize);
252 if (newgdblocks != fs->gdblocks)
256 for (i=0;i<fs->numgroups;i++)
257 if (ext2_is_group_sparse(fs, i))
261 start = EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb) +
262 i * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
263 ext2_set_block_state(fs,
264 start + fs->gdblocks,
268 fs->gdblocks--;
269 fs->adminblocks--;
274 if (fs->opt_debug)
276 if (EXT2_GROUP_FREE_BLOCKS_COUNT(fs->gd[group])
283 offset = EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb) +
284 group * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
285 num = EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
288 if (ext2_is_data_block(fs, offset+i) &&
289 ext2_get_block_state(fs, offset+i))
302 fs->numgroups--;
304 fs->sb.s_inodes_count = PED_CPU_TO_LE32(
305 EXT2_SUPER_INODES_COUNT(fs->sb)
306 - EXT2_SUPER_INODES_PER_GROUP(fs->sb));
307 fs->sb.s_blocks_count = PED_CPU_TO_LE32(
308 EXT2_SUPER_BLOCKS_COUNT(fs->sb) - groupsize);
309 fs->sb.s_free_blocks_count = PED_CPU_TO_LE32(
310 EXT2_SUPER_FREE_BLOCKS_COUNT(fs->sb) - (groupsize - admin));
311 fs->sb.s_free_inodes_count = PED_CPU_TO_LE32(
312 EXT2_SUPER_FREE_INODES_COUNT(fs->sb)
313 - EXT2_SUPER_INODES_PER_GROUP(fs->sb));
314 fs->metadirty |= EXT2_META_SB;
316 if (fs->opt_safe)
317 ext2_sync(fs);
319 ped_realloc ((void*) &fs->gd,
320 fs->numgroups * sizeof(struct ext2_group_desc)
321 + fs->blocksize);
326 static int ext2_grow_group(struct ext2_fs *fs, blk_t newsize)
333 if (fs->opt_verbose)
336 group = fs->numgroups - 1;
337 groupoff = group * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb)
338 + EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb);
339 gblocks = EXT2_SUPER_BLOCKS_COUNT(fs->sb) - groupoff;
341 if (fs->opt_debug)
359 ext2_set_block_state(fs, groupoff + i, 0, 1);
361 fs->sb.s_blocks_count = PED_CPU_TO_LE32(
362 EXT2_SUPER_BLOCKS_COUNT(fs->sb) + newsize - gblocks);
363 fs->metadirty |= EXT2_META_SB;
365 if (fs->opt_safe)
366 ext2_sync(fs);
371 static int ext2_shrink_group(struct ext2_fs *fs, blk_t newsize)
379 if (fs->opt_verbose)
382 group = fs->numgroups - 1;
384 admin = fs->adminblocks;
385 if (!ext2_is_group_sparse(fs, group))
386 admin -= fs->gdblocks + 1;
388 groupoff = group * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb)
389 + EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb);
390 gblocks = EXT2_SUPER_BLOCKS_COUNT(fs->sb) - groupoff;
392 if (fs->opt_debug)
422 if (fs->opt_debug && ext2_get_block_state(fs, groupoff + i))
432 ext2_set_block_state(fs, groupoff + i, 1, 0);
436 fs->sb.s_blocks_count = PED_CPU_TO_LE32(
437 EXT2_SUPER_BLOCKS_COUNT(fs->sb) - i);
438 fs->sb.s_free_blocks_count = PED_CPU_TO_LE32(
439 EXT2_SUPER_FREE_BLOCKS_COUNT(fs->sb) - i);
440 fs->gd[group].bg_free_blocks_count = PED_CPU_TO_LE16(
441 EXT2_GROUP_FREE_BLOCKS_COUNT(fs->gd[group]) - i);
443 fs->metadirty |= EXT2_META_SB | EXT2_META_GD;
445 if (fs->opt_safe)
446 ext2_sync(fs);
456 static int ext2_grow_fs(struct ext2_fs *fs, blk_t newsize, PedTimer* timer)
460 blk_t origsize = EXT2_SUPER_BLOCKS_COUNT(fs->sb);
462 if (fs->opt_verbose)
465 if (!ext2_block_relocate(fs, newsize))
468 if (!ext2_metadata_push(fs, newsize))
471 diff = newsize - EXT2_SUPER_BLOCKS_COUNT(fs->sb);
472 sizelast = EXT2_SUPER_BLOCKS_COUNT(fs->sb)
473 - EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb)
474 - (fs->numgroups-1) * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
476 if (sizelast != EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb))
481 if (growto > EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb))
482 growto = EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
484 if (!ext2_grow_group(fs, growto))
498 sizelast = PED_MIN(diff, EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb));
499 if (!ext2_add_group(fs, sizelast))
510 static int ext2_shrink_fs(struct ext2_fs *fs, blk_t newsize,
513 blk_t origsize = EXT2_SUPER_BLOCKS_COUNT (fs->sb);
518 if (fs->opt_verbose)
522 - EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb),
523 EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb));
524 if (EXT2_SUPER_BLOCKS_COUNT(fs->sb)
525 - EXT2_SUPER_FREE_BLOCKS_COUNT(fs->sb) > newsize)
533 if (EXT2_SUPER_INODES_COUNT(fs->sb)
534 - EXT2_SUPER_FREE_INODES_COUNT(fs->sb)
535 > newgroups * EXT2_SUPER_INODES_PER_GROUP(fs->sb))
543 if (!ext2_inode_relocate(fs, newgroups))
546 if (!ext2_block_relocate(fs, newsize))
549 diff = EXT2_SUPER_BLOCKS_COUNT(fs->sb) - newsize;
559 sizelast = EXT2_SUPER_BLOCKS_COUNT(fs->sb)
560 - EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb) -
561 (fs->numgroups - 1)
562 * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
566 if (!ext2_shrink_group(fs, sizelast - diff))
573 if (!ext2_del_group(fs))
585 int ext2_determine_itoffset(struct ext2_fs *fs)
589 fs->itoffset = EXT2_GROUP_INODE_TABLE(fs->gd[0])
590 - EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb);
592 /*PED_DEBUG (0x20, "itoffset is %d", fs->itoffset);
594 PED_DEBUG (0x20, "walking %d groups", fs->numgroups);*/
596 for (i=0;i<fs->numgroups;i++)
603 start = EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb)
604 + (i * EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb));
605 it = start + fs->itoffset;
609 if (ext2_is_group_sparse(fs, i))
623 if (EXT2_GROUP_BLOCK_BITMAP(fs->gd[i]) != bb ||
624 EXT2_GROUP_INODE_BITMAP(fs->gd[i]) != ib ||
625 EXT2_GROUP_INODE_TABLE(fs->gd[i]) != it)
633 "but fs says %d.", bb,
634 EXT2_GROUP_BLOCK_BITMAP(fs->gd[i]));
636 "but fs says %d.", ib,
637 EXT2_GROUP_INODE_BITMAP(fs->gd[i]));
639 "but fs says %d.", it,
640 EXT2_GROUP_INODE_TABLE(fs->gd[i]));*/
649 int ext2_resize_fs(struct ext2_fs *fs, blk_t newsize, PedTimer* timer)
654 if (EXT2_SUPER_STATE(fs->sb) & EXT2_ERROR_FS)
662 if (!(EXT2_SUPER_STATE(fs->sb) & EXT2_VALID_FS))
671 if (EXT2_SUPER_FEATURE_COMPAT(fs->sb)
682 fs->sb.s_feature_compat
683 = PED_CPU_TO_LE32(EXT2_SUPER_FEATURE_COMPAT(fs->sb)
685 fs->metadirty |= EXT2_META_SB;
688 if (!ext2_determine_itoffset(fs) && ped_exception_throw (
702 if (fs->opt_verbose)
705 residue = (newsize - EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb))
706 % EXT2_SUPER_BLOCKS_PER_GROUP(fs->sb);
707 if (residue && residue <= fs->adminblocks)
710 if (newsize == EXT2_SUPER_BLOCKS_COUNT(fs->sb))
713 fs->relocator_pool
715 if (!fs->relocator_pool)
717 fs->relocator_pool_end
718 = fs->relocator_pool + (ext2_relocator_pool_size << 10);
720 if (newsize < EXT2_SUPER_BLOCKS_COUNT(fs->sb))
721 status = ext2_shrink_fs(fs, newsize, timer);
723 status = ext2_grow_fs(fs, newsize, timer);
725 free(fs->relocator_pool);
726 fs->relocator_pool = NULL;
727 fs->relocator_pool_end = NULL;