mirror of
https://github.com/wiidev/usbloadergx.git
synced 2024-11-16 00:15:08 +01:00
0f17471b27
*Added sources of the custom libs to the branches *Fixed crash when switching from list layout to grid/carousel layout *Removed 1:1 copy option because its meaningless and almost the same as installing all partitions *Fixed install partition selection. This option needs a reset. Go to settings and reselect your option for this. *Fixed schinese and tchinese language modes (filename bugs. has to be schinese.lang and tchinese.lang like on SVN) *Fixed bug in sound buffer circle *Fixed incorrect behaviour of x-flip when selecting system like (thx Cyan for the patch) *Accept ios revision 65535 for Waninkokos IOSes (thx to PPSainity for pointing it out) *Merged the new theming style branch into trunk. Just as a reminder: ALL old themes will not work until the themers did port it to the new style! *Removed old theme style completely Theme example: The example file of the theme is the Default.them file. It can be found in the SVN trunk. Change in loading of themes: When selecting a theme now a list of all .them files in a folder is displayed. The image folder of that theme has to be in the same folder as the .them file. The image path is defined in the head of the .them file in the line with "Image-Folder: Example\n".
240 lines
6.8 KiB
C
240 lines
6.8 KiB
C
/*
|
|
* alloc_tables.c --- Allocate tables for a newly initialized
|
|
* filesystem. Used by mke2fs when initializing a filesystem
|
|
*
|
|
* Copyright (C) 1996 Theodore Ts'o.
|
|
*
|
|
* %Begin-Header%
|
|
* This file may be redistributed under the terms of the GNU Library
|
|
* General Public License, version 2.
|
|
* %End-Header%
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#if HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
#include <fcntl.h>
|
|
#include <time.h>
|
|
#if HAVE_SYS_STAT_H
|
|
#include <sys/stat.h>
|
|
#endif
|
|
#if HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
|
|
#include "ext2_fs.h"
|
|
#include "ext2fs.h"
|
|
#include "ext2fsP.h"
|
|
|
|
/*
|
|
* This routine searches for free blocks that can allocate a full
|
|
* group of bitmaps or inode tables for a flexbg group. Returns the
|
|
* block number with a correct offset were the bitmaps and inode
|
|
* tables can be allocated continously and in order.
|
|
*/
|
|
static blk64_t flexbg_offset(ext2_filsys fs, dgrp_t group, blk64_t start_blk,
|
|
ext2fs_block_bitmap bmap, int offset, int size,
|
|
int elem_size)
|
|
{
|
|
int flexbg, flexbg_size;
|
|
blk64_t last_blk, first_free = 0;
|
|
dgrp_t last_grp;
|
|
|
|
flexbg_size = 1 << fs->super->s_log_groups_per_flex;
|
|
flexbg = group / flexbg_size;
|
|
|
|
if (size > (int) (fs->super->s_blocks_per_group / 8))
|
|
size = (int) fs->super->s_blocks_per_group / 8;
|
|
|
|
if (offset)
|
|
offset -= 1;
|
|
|
|
/*
|
|
* Don't do a long search if the previous block
|
|
* search is still valid.
|
|
*/
|
|
if (start_blk && group % flexbg_size) {
|
|
if (ext2fs_test_block_bitmap_range2(bmap, start_blk + elem_size,
|
|
size))
|
|
return start_blk + elem_size;
|
|
}
|
|
|
|
start_blk = ext2fs_group_first_block2(fs, flexbg_size * flexbg);
|
|
last_grp = group | (flexbg_size - 1);
|
|
if (last_grp > fs->group_desc_count)
|
|
last_grp = fs->group_desc_count;
|
|
last_blk = ext2fs_group_last_block2(fs, last_grp);
|
|
|
|
/* Find the first available block */
|
|
if (ext2fs_get_free_blocks2(fs, start_blk, last_blk, 1, bmap,
|
|
&first_free))
|
|
return first_free;
|
|
|
|
if (ext2fs_get_free_blocks2(fs, first_free + offset, last_blk, size,
|
|
bmap, &first_free))
|
|
return first_free;
|
|
|
|
return first_free;
|
|
}
|
|
|
|
errcode_t ext2fs_allocate_group_table(ext2_filsys fs, dgrp_t group,
|
|
ext2fs_block_bitmap bmap)
|
|
{
|
|
errcode_t retval;
|
|
blk64_t group_blk, start_blk, last_blk, new_blk, blk;
|
|
dgrp_t last_grp = 0;
|
|
int j, rem_grps = 0, flexbg_size = 0;
|
|
|
|
group_blk = ext2fs_group_first_block2(fs, group);
|
|
last_blk = ext2fs_group_last_block2(fs, group);
|
|
|
|
if (!bmap)
|
|
bmap = fs->block_map;
|
|
|
|
if (EXT2_HAS_INCOMPAT_FEATURE(fs->super,
|
|
EXT4_FEATURE_INCOMPAT_FLEX_BG) &&
|
|
fs->super->s_log_groups_per_flex) {
|
|
flexbg_size = 1 << fs->super->s_log_groups_per_flex;
|
|
last_grp = group | (flexbg_size - 1);
|
|
rem_grps = last_grp - group;
|
|
if (last_grp > fs->group_desc_count)
|
|
last_grp = fs->group_desc_count;
|
|
}
|
|
|
|
/*
|
|
* Allocate the block and inode bitmaps, if necessary
|
|
*/
|
|
if (fs->stride) {
|
|
retval = ext2fs_get_free_blocks2(fs, group_blk, last_blk,
|
|
1, bmap, &start_blk);
|
|
if (retval)
|
|
return retval;
|
|
start_blk += fs->inode_blocks_per_group;
|
|
start_blk += ((fs->stride * group) %
|
|
(last_blk - start_blk + 1));
|
|
if (start_blk >= last_blk)
|
|
start_blk = group_blk;
|
|
} else
|
|
start_blk = group_blk;
|
|
|
|
if (flexbg_size) {
|
|
blk64_t prev_block = 0;
|
|
|
|
if (group && ext2fs_block_bitmap_loc(fs, group - 1))
|
|
prev_block = ext2fs_block_bitmap_loc(fs, group - 1);
|
|
start_blk = flexbg_offset(fs, group, prev_block, bmap,
|
|
0, rem_grps, 1);
|
|
last_blk = ext2fs_group_last_block2(fs, last_grp);
|
|
}
|
|
|
|
if (!ext2fs_block_bitmap_loc(fs, group)) {
|
|
retval = ext2fs_get_free_blocks2(fs, start_blk, last_blk,
|
|
1, bmap, &new_blk);
|
|
if (retval == EXT2_ET_BLOCK_ALLOC_FAIL)
|
|
retval = ext2fs_get_free_blocks2(fs, group_blk,
|
|
last_blk, 1, bmap, &new_blk);
|
|
if (retval)
|
|
return retval;
|
|
ext2fs_mark_block_bitmap2(bmap, new_blk);
|
|
ext2fs_block_bitmap_loc_set(fs, group, new_blk);
|
|
if (flexbg_size) {
|
|
dgrp_t gr = ext2fs_group_of_blk2(fs, new_blk);
|
|
ext2fs_bg_free_blocks_count_set(fs, gr, ext2fs_bg_free_blocks_count(fs, gr) - 1);
|
|
ext2fs_free_blocks_count_add(fs->super, -1);
|
|
ext2fs_bg_flags_clear(fs, gr, EXT2_BG_BLOCK_UNINIT);
|
|
ext2fs_group_desc_csum_set(fs, gr);
|
|
}
|
|
}
|
|
|
|
if (flexbg_size) {
|
|
blk64_t prev_block = 0;
|
|
if (group && ext2fs_inode_bitmap_loc(fs, group - 1))
|
|
prev_block = ext2fs_inode_bitmap_loc(fs, group - 1);
|
|
start_blk = flexbg_offset(fs, group, prev_block, bmap,
|
|
flexbg_size, rem_grps, 1);
|
|
last_blk = ext2fs_group_last_block2(fs, last_grp);
|
|
}
|
|
|
|
if (!ext2fs_inode_bitmap_loc(fs, group)) {
|
|
retval = ext2fs_get_free_blocks2(fs, start_blk, last_blk,
|
|
1, bmap, &new_blk);
|
|
if (retval == EXT2_ET_BLOCK_ALLOC_FAIL)
|
|
retval = ext2fs_get_free_blocks2(fs, group_blk,
|
|
last_blk, 1, bmap, &new_blk);
|
|
if (retval)
|
|
return retval;
|
|
ext2fs_mark_block_bitmap2(bmap, new_blk);
|
|
ext2fs_inode_bitmap_loc_set(fs, group, new_blk);
|
|
if (flexbg_size) {
|
|
dgrp_t gr = ext2fs_group_of_blk2(fs, new_blk);
|
|
ext2fs_bg_free_blocks_count_set(fs, gr, ext2fs_bg_free_blocks_count(fs, gr) - 1);
|
|
ext2fs_free_blocks_count_add(fs->super, -1);
|
|
ext2fs_bg_flags_clear(fs, gr, EXT2_BG_BLOCK_UNINIT);
|
|
ext2fs_group_desc_csum_set(fs, gr);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Allocate the inode table
|
|
*/
|
|
if (flexbg_size) {
|
|
blk64_t prev_block = 0;
|
|
if (group && ext2fs_inode_table_loc(fs, group - 1))
|
|
prev_block = ext2fs_inode_table_loc(fs, group - 1);
|
|
if (last_grp == fs->group_desc_count)
|
|
rem_grps = last_grp - group;
|
|
group_blk = flexbg_offset(fs, group, prev_block, bmap,
|
|
flexbg_size * 2,
|
|
fs->inode_blocks_per_group *
|
|
rem_grps,
|
|
fs->inode_blocks_per_group);
|
|
last_blk = ext2fs_group_last_block2(fs, last_grp);
|
|
}
|
|
|
|
if (!ext2fs_inode_table_loc(fs, group)) {
|
|
retval = ext2fs_get_free_blocks2(fs, group_blk, last_blk,
|
|
fs->inode_blocks_per_group,
|
|
bmap, &new_blk);
|
|
if (retval)
|
|
return retval;
|
|
for (j=0, blk = new_blk;
|
|
j < fs->inode_blocks_per_group;
|
|
j++, blk++) {
|
|
ext2fs_mark_block_bitmap2(bmap, blk);
|
|
if (flexbg_size) {
|
|
dgrp_t gr = ext2fs_group_of_blk2(fs, blk);
|
|
ext2fs_bg_free_blocks_count_set(fs, gr, ext2fs_bg_free_blocks_count(fs, gr) - 1);
|
|
ext2fs_free_blocks_count_add(fs->super, -1);
|
|
ext2fs_bg_flags_clear(fs, gr,
|
|
EXT2_BG_BLOCK_UNINIT);
|
|
ext2fs_group_desc_csum_set(fs, gr);
|
|
}
|
|
}
|
|
ext2fs_inode_table_loc_set(fs, group, new_blk);
|
|
}
|
|
ext2fs_group_desc_csum_set(fs, group);
|
|
return 0;
|
|
}
|
|
|
|
errcode_t ext2fs_allocate_tables(ext2_filsys fs)
|
|
{
|
|
errcode_t retval;
|
|
dgrp_t i;
|
|
struct ext2fs_numeric_progress_struct progress;
|
|
|
|
ext2fs_numeric_progress_init(fs, &progress, NULL,
|
|
fs->group_desc_count);
|
|
|
|
for (i = 0; i < fs->group_desc_count; i++) {
|
|
ext2fs_numeric_progress_update(fs, &progress, i);
|
|
retval = ext2fs_allocate_group_table(fs, i, fs->block_map);
|
|
if (retval)
|
|
return retval;
|
|
}
|
|
ext2fs_numeric_progress_close(fs, &progress, NULL);
|
|
return 0;
|
|
}
|
|
|