1997-04-26 17:21:57 +04:00
|
|
|
/*
|
|
|
|
* alloc.c --- allocate new inodes, blocks for ext2fs
|
|
|
|
*
|
1997-04-29 20:15:03 +04:00
|
|
|
* Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
|
|
|
|
*
|
|
|
|
* %Begin-Header%
|
2010-05-18 05:31:56 +04:00
|
|
|
* This file may be redistributed under the terms of the GNU Library
|
|
|
|
* General Public License, version 2.
|
1997-04-29 20:15:03 +04:00
|
|
|
* %End-Header%
|
1997-04-26 17:21:57 +04:00
|
|
|
*/
|
|
|
|
|
2011-09-19 01:34:37 +04:00
|
|
|
#include "config.h"
|
1997-04-26 17:21:57 +04:00
|
|
|
#include <stdio.h>
|
1997-08-11 03:07:40 +04:00
|
|
|
#if HAVE_UNISTD_H
|
1997-04-26 17:21:57 +04:00
|
|
|
#include <unistd.h>
|
1997-08-11 03:07:40 +04:00
|
|
|
#endif
|
1997-04-26 17:21:57 +04:00
|
|
|
#include <time.h>
|
1997-10-26 02:37:42 +04:00
|
|
|
#include <string.h>
|
1997-10-20 03:00:21 +04:00
|
|
|
#if HAVE_SYS_STAT_H
|
1997-04-26 17:21:57 +04:00
|
|
|
#include <sys/stat.h>
|
1997-10-20 03:00:21 +04:00
|
|
|
#endif
|
|
|
|
#if HAVE_SYS_TYPES_H
|
1997-04-26 17:21:57 +04:00
|
|
|
#include <sys/types.h>
|
1997-10-20 03:00:21 +04:00
|
|
|
#endif
|
1997-04-26 17:21:57 +04:00
|
|
|
|
Many files:
inode.c (ext2fs_open_inode_scan): Initialize the group variables
so that we don't need to call get_next_blockgroup() the first
time around. Saves a bit of time, and prevents us from
needing to assign -1 to current_group (which is an unsigned
value).
icount.c (insert_icount_el): Cast the estimated number of inodes
from a float to an ino_t.
alloc.c, alloc_tables.c, badlbocks.c, bb_compat.c, bb_inode.c,
bitmaps.c, bitops.c, block.c, bmap.c, bmove.c, brel_ma.c,
check_desc.c, closefs.c, cmp_bitmaps.c, dblist.c,
dblist_dir.c, dir_iterate.c, dirblock.c, dupfs.c, expanddir.c,
ext2fs.h, fileio.c, freefs.c, get_pathname.c, getsize.c,
icount.c, initialize.c, inline.c, inode.c, irel_ma.c,
ismounted.c, link.c, lookup.c, mkdir.c, namei.c, native.c,
newdir.c, openfs.c, read_bb.c, read_bb_file.c, rs_bitmap.c,
rw_bitmaps.c, swapfs.c, test_io.c, tst_badblocks.c,
tst_getsize.c, tst_iscan.c, unix_io.c, unlink.c, valid_blk.c,
version.c: If EXT2_FLAT_INCLUDES is defined, then assume all
of the ext2-specific header files are in a flat directory.
block.c, bmove.c, dirblock.c, fileio.c: Explicitly cast
all assignments from void * to be compatible with C++.
closefs.c (ext2fs_flush): Add a call to io_channel_flush() to
make sure the contents of the disk are flushed to disk.
dblist.c (ext2fs_add_dir_block): Change new to be new_entry to
avoid C++ namespace clash.
bitmaps.c (ext2fs_copy_bitmap): Change new to be new_map to
avoid C++ namespace clash.
ext2fs.h, bb_inode.c, block.c, bmove.c, brel.h, brel_ma.c,
irel.h, irel_ma.c, dblist.c, dblist_dir.c, dir_iterate.c,
ext2fsP.h, expanddir.c, get_pathname.c, inode.c, link.c,
unlink.c: Change private to be priv_data (to avoid C++
namespace clash)
1998-01-19 17:47:53 +03:00
|
|
|
#include "ext2_fs.h"
|
1997-04-26 17:21:57 +04:00
|
|
|
#include "ext2fs.h"
|
|
|
|
|
2008-08-22 10:52:12 +04:00
|
|
|
/*
|
2014-01-19 10:24:30 +04:00
|
|
|
* Clear the uninit block bitmap flag if necessary
|
2008-08-22 10:52:12 +04:00
|
|
|
*/
|
2014-01-19 10:24:30 +04:00
|
|
|
static void clear_block_uninit(ext2_filsys fs, dgrp_t group)
|
2008-08-22 10:52:12 +04:00
|
|
|
{
|
|
|
|
if (!(EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
|
|
|
|
EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) ||
|
2009-10-26 04:42:12 +03:00
|
|
|
!(ext2fs_bg_flags_test(fs, group, EXT2_BG_BLOCK_UNINIT)))
|
2008-08-22 10:52:12 +04:00
|
|
|
return;
|
|
|
|
|
libext2fs: mark group data blocks when loading block bitmap
The kernel[1] and e2fsck[2] both react to a BLOCK_UNINIT group by
calculating the block bitmap that's needed to show all the group
blocks for that group (if any) and using that. However, when reading
bitmaps from disk, libext2fs simply imports a block of zeroes into the
bitmap, without bothering to check for group blocks. This erroneous
behavior results in the filesystem having a block bitmap that does not
accurately reflect disk contents, and worse yet makes it seem as
though superblocks, group descriptors, bitmaps, and inode tables are
"free" space on disk.
So, fix the block bitmap loading routines to calculate the correct
block bitmap for all groups and load it into the main fs block bitmap.
This also fixes bogus debugfs output such as:
Group 1: (Blocks 8193-16384) [INODE_UNINIT, BLOCK_UNINIT]
Checksum 0x1310, unused inodes 512
Backup superblock at 8193, Group descriptors at 8194-8217
Reserved GDT blocks at 8218-8473
Block bitmap at 283 (bg #0 + 282), Inode bitmap at 299 (bg #0 + 298)
Inode table at 442-569 (bg #0 + 441)
7911 free blocks, 512 free inodes, 0 directories, 512 unused inodes
Free blocks: 8193-16384
Free inodes: 513-1024
Notice how the "free blocks" range includes the backup sb & GDT area
and doesn't match the free block count.
Worse yet, debugfs' testb command will report those group descriptor
blocks as not being in use unless the user also instructs debugfs to
find a free block first. That is a rather surprising result:
debugfs: testb 8194
Block 8194 not in use
debugfs: ffb 1 16380
Free blocks found: 16380
debugfs: testb 8194
Block 8194 marked in use
Also, remove the part of check_block_uninit() that "fixes" the bitmap
since we're doing that at bitmap load time now.
[1] kernel git 717d50e4971b81b96c0199c91cdf0039a8cb181a
"Ext4: Uninitialized Block Groups"
[2] e2fsprogs git f5fa20078bfc05b554294fe9c5505375d7913e8c
"Add support for EXT2_FEATURE_COMPAT_LAZY_BG"
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
2014-01-11 23:04:48 +04:00
|
|
|
/* uninit block bitmaps are now initialized in read_bitmaps() */
|
2011-06-11 02:51:58 +04:00
|
|
|
|
libext2fs: clean up ext2fs_bg_flags_ interfaces
The ext2fs_bg_flag* functions were confusing.
Currently we have this:
void ext2fs_bg_flags_set(ext2_filsys fs, dgrp_t group, __u16 bg_flags);
void ext2fs_bg_flags_clear(ext2_filsys fs, dgrp_t group,__u16 bg_flags);
(_set (unused) sets exactly bg_flags; _clear clears all and ignores bg_flags)
and these, which can twiddle individual bits in bg_flags:
void ext2fs_bg_flag_set(ext2_filsys fs, dgrp_t group, __u16 bg_flag);
void ext2fs_bg_flag_clear(ext2_filsys fs, dgrp_t group, __u16 bg_flag);
A better interface, after the patch below, is just:
ext2fs_bg_flags_zap(fs, group) /* zeros bg_flags */
ext2fs_bg_flags_set(fs, group, flags) /* adds flags to bg_flags */
ext2fs_bg_flags_clear(fs, group, flags) /* clears flags in bg_flags */
and remove the original ext2fs_bg_flags_set / ext2fs_bg_flags_clear.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2009-10-26 04:41:32 +03:00
|
|
|
ext2fs_bg_flags_clear(fs, group, EXT2_BG_BLOCK_UNINIT);
|
2008-08-22 10:52:12 +04:00
|
|
|
ext2fs_group_desc_csum_set(fs, group);
|
2012-03-26 06:24:10 +04:00
|
|
|
ext2fs_mark_super_dirty(fs);
|
|
|
|
ext2fs_mark_bb_dirty(fs);
|
2008-08-22 10:52:12 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for uninit inode bitmaps and deal with them appropriately
|
|
|
|
*/
|
2008-11-16 18:03:00 +03:00
|
|
|
static void check_inode_uninit(ext2_filsys fs, ext2fs_inode_bitmap map,
|
2008-08-22 10:52:12 +04:00
|
|
|
dgrp_t group)
|
|
|
|
{
|
2008-11-16 18:03:00 +03:00
|
|
|
ext2_ino_t i, ino;
|
2008-08-22 10:52:12 +04:00
|
|
|
|
|
|
|
if (!(EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
|
|
|
|
EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) ||
|
2009-10-26 04:42:12 +03:00
|
|
|
!(ext2fs_bg_flags_test(fs, group, EXT2_BG_INODE_UNINIT)))
|
2008-08-22 10:52:12 +04:00
|
|
|
return;
|
|
|
|
|
|
|
|
ino = (group * fs->super->s_inodes_per_group) + 1;
|
|
|
|
for (i=0; i < fs->super->s_inodes_per_group; i++, ino++)
|
2009-08-05 08:27:10 +04:00
|
|
|
ext2fs_fast_unmark_inode_bitmap2(map, ino);
|
2008-08-22 10:52:12 +04:00
|
|
|
|
libext2fs: clean up ext2fs_bg_flags_ interfaces
The ext2fs_bg_flag* functions were confusing.
Currently we have this:
void ext2fs_bg_flags_set(ext2_filsys fs, dgrp_t group, __u16 bg_flags);
void ext2fs_bg_flags_clear(ext2_filsys fs, dgrp_t group,__u16 bg_flags);
(_set (unused) sets exactly bg_flags; _clear clears all and ignores bg_flags)
and these, which can twiddle individual bits in bg_flags:
void ext2fs_bg_flag_set(ext2_filsys fs, dgrp_t group, __u16 bg_flag);
void ext2fs_bg_flag_clear(ext2_filsys fs, dgrp_t group, __u16 bg_flag);
A better interface, after the patch below, is just:
ext2fs_bg_flags_zap(fs, group) /* zeros bg_flags */
ext2fs_bg_flags_set(fs, group, flags) /* adds flags to bg_flags */
ext2fs_bg_flags_clear(fs, group, flags) /* clears flags in bg_flags */
and remove the original ext2fs_bg_flags_set / ext2fs_bg_flags_clear.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2009-10-26 04:41:32 +03:00
|
|
|
ext2fs_bg_flags_clear(fs, group, EXT2_BG_INODE_UNINIT);
|
2014-01-19 10:24:30 +04:00
|
|
|
/* Mimics what the kernel does */
|
|
|
|
ext2fs_bg_flags_clear(fs, group, EXT2_BG_BLOCK_UNINIT);
|
2012-03-26 06:24:10 +04:00
|
|
|
ext2fs_group_desc_csum_set(fs, group);
|
|
|
|
ext2fs_mark_ib_dirty(fs);
|
|
|
|
ext2fs_mark_super_dirty(fs);
|
2008-08-22 10:52:12 +04:00
|
|
|
}
|
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
/*
|
|
|
|
* Right now, just search forward from the parent directory's block
|
|
|
|
* group to find the next free inode.
|
|
|
|
*
|
|
|
|
* Should have a special policy for directories.
|
|
|
|
*/
|
2008-08-28 07:07:54 +04:00
|
|
|
errcode_t ext2fs_new_inode(ext2_filsys fs, ext2_ino_t dir,
|
2003-12-07 09:28:50 +03:00
|
|
|
int mode EXT2FS_ATTR((unused)),
|
Many files:
alloc.c, bb_inode.c, bitmaps.c, bitops.h, block.c, bmap.c, bmove.c,
brel.h, cmp_bitmaps.c, dblist.c, dblist_dir.c, dir_iterate.c,
expanddir.c, ext2fs.h, ext2fsP.h, fileio.c, finddev.c, get_pathname.c,
icount.c, inode.c, irel.h, irel_ma.c, ismounted.c, link.c, lookup.c,
mkdir.c, mkjournal.c, namei.c, newdir.c, read_bb_file.c, test_io.c,
tst_iscan.c, unix_io.c, unlink.c: Change use of ino_t to ext2_ino_t,
to protect applications that attempt to compile
-D_FILE_OFFSET_BITS=64, since this inexplicably changes ino_t(!?). So
we use ext2_ino_t to avoid an unexpected ABI change.
2001-01-11 07:54:39 +03:00
|
|
|
ext2fs_inode_bitmap map, ext2_ino_t *ret)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
2012-03-11 00:36:12 +04:00
|
|
|
ext2_ino_t start_inode = 0;
|
|
|
|
ext2_ino_t i, ino_in_group, upto, first_zero;
|
|
|
|
errcode_t retval;
|
|
|
|
dgrp_t group;
|
1997-04-26 17:21:57 +04:00
|
|
|
|
1997-04-26 17:34:30 +04:00
|
|
|
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
|
2008-08-28 07:07:54 +04:00
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
if (!map)
|
|
|
|
map = fs->inode_map;
|
|
|
|
if (!map)
|
|
|
|
return EXT2_ET_NO_INODE_BITMAP;
|
2008-08-28 07:07:54 +04:00
|
|
|
|
2012-03-11 00:36:12 +04:00
|
|
|
if (dir > 0) {
|
|
|
|
group = (dir - 1) / EXT2_INODES_PER_GROUP(fs->super);
|
|
|
|
start_inode = (group * EXT2_INODES_PER_GROUP(fs->super)) + 1;
|
|
|
|
}
|
1997-04-26 18:48:50 +04:00
|
|
|
if (start_inode < EXT2_FIRST_INODE(fs->super))
|
|
|
|
start_inode = EXT2_FIRST_INODE(fs->super);
|
2009-01-22 23:55:49 +03:00
|
|
|
if (start_inode > fs->super->s_inodes_count)
|
|
|
|
return EXT2_ET_INODE_ALLOC_FAIL;
|
1997-04-26 17:21:57 +04:00
|
|
|
i = start_inode;
|
|
|
|
do {
|
2012-03-11 00:36:12 +04:00
|
|
|
ino_in_group = (i - 1) % EXT2_INODES_PER_GROUP(fs->super);
|
|
|
|
group = (i - 1) / EXT2_INODES_PER_GROUP(fs->super);
|
|
|
|
|
|
|
|
check_inode_uninit(fs, map, group);
|
|
|
|
upto = i + (EXT2_INODES_PER_GROUP(fs->super) - ino_in_group);
|
|
|
|
if (i < start_inode && upto >= start_inode)
|
|
|
|
upto = start_inode - 1;
|
|
|
|
if (upto > fs->super->s_inodes_count)
|
|
|
|
upto = fs->super->s_inodes_count;
|
|
|
|
|
|
|
|
retval = ext2fs_find_first_zero_inode_bitmap2(map, i, upto,
|
|
|
|
&first_zero);
|
|
|
|
if (retval == 0) {
|
|
|
|
i = first_zero;
|
1997-04-26 17:21:57 +04:00
|
|
|
break;
|
2012-03-23 03:42:38 +04:00
|
|
|
}
|
2012-03-11 00:36:12 +04:00
|
|
|
if (retval != ENOENT)
|
|
|
|
return EXT2_ET_INODE_ALLOC_FAIL;
|
|
|
|
i = upto + 1;
|
|
|
|
if (i > fs->super->s_inodes_count)
|
|
|
|
i = EXT2_FIRST_INODE(fs->super);
|
1997-04-26 17:21:57 +04:00
|
|
|
} while (i != start_inode);
|
2008-08-28 07:07:54 +04:00
|
|
|
|
2009-08-05 08:27:10 +04:00
|
|
|
if (ext2fs_test_inode_bitmap2(map, i))
|
1997-10-31 09:07:47 +03:00
|
|
|
return EXT2_ET_INODE_ALLOC_FAIL;
|
1997-04-26 17:21:57 +04:00
|
|
|
*ret = i;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Stupid algorithm --- we now just search forward starting from the
|
|
|
|
* goal. Should put in a smarter one someday....
|
|
|
|
*/
|
2009-06-02 00:15:40 +04:00
|
|
|
errcode_t ext2fs_new_block2(ext2_filsys fs, blk64_t goal,
|
|
|
|
ext2fs_block_bitmap map, blk64_t *ret)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
2014-01-20 04:35:33 +04:00
|
|
|
errcode_t retval;
|
2014-04-14 20:20:25 +04:00
|
|
|
blk64_t b = 0;
|
1997-04-26 17:21:57 +04:00
|
|
|
|
1997-04-26 17:34:30 +04:00
|
|
|
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
|
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
if (!map)
|
|
|
|
map = fs->block_map;
|
|
|
|
if (!map)
|
|
|
|
return EXT2_ET_NO_BLOCK_BITMAP;
|
2009-09-08 04:46:34 +04:00
|
|
|
if (!goal || (goal >= ext2fs_blocks_count(fs->super)))
|
1997-04-30 01:26:48 +04:00
|
|
|
goal = fs->super->s_first_data_block;
|
2014-01-20 04:35:33 +04:00
|
|
|
goal &= ~EXT2FS_CLUSTER_MASK(fs);
|
|
|
|
|
|
|
|
retval = ext2fs_find_first_zero_block_bitmap2(map,
|
|
|
|
goal, ext2fs_blocks_count(fs->super) - 1, &b);
|
|
|
|
if ((retval == ENOENT) && (goal != fs->super->s_first_data_block))
|
|
|
|
retval = ext2fs_find_first_zero_block_bitmap2(map,
|
|
|
|
fs->super->s_first_data_block, goal - 1, &b);
|
|
|
|
if (retval == ENOENT)
|
|
|
|
return EXT2_ET_BLOCK_ALLOC_FAIL;
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
clear_block_uninit(fs, ext2fs_group_of_blk2(fs, b));
|
|
|
|
*ret = b;
|
|
|
|
return 0;
|
1997-10-25 08:16:53 +04:00
|
|
|
}
|
|
|
|
|
2009-06-02 00:15:40 +04:00
|
|
|
errcode_t ext2fs_new_block(ext2_filsys fs, blk_t goal,
|
|
|
|
ext2fs_block_bitmap map, blk_t *ret)
|
|
|
|
{
|
|
|
|
errcode_t retval;
|
|
|
|
blk64_t val;
|
|
|
|
retval = ext2fs_new_block2(fs, goal, map, &val);
|
|
|
|
if (!retval)
|
|
|
|
*ret = (blk_t) val;
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
1997-10-25 08:16:53 +04:00
|
|
|
/*
|
1997-10-26 02:37:42 +04:00
|
|
|
* This function zeros out the allocated block, and updates all of the
|
|
|
|
* appropriate filesystem records.
|
1997-10-25 08:16:53 +04:00
|
|
|
*/
|
2009-06-02 00:15:40 +04:00
|
|
|
errcode_t ext2fs_alloc_block2(ext2_filsys fs, blk64_t goal,
|
|
|
|
char *block_buf, blk64_t *ret)
|
1997-10-25 08:16:53 +04:00
|
|
|
{
|
|
|
|
errcode_t retval;
|
2009-06-02 00:15:40 +04:00
|
|
|
blk64_t block;
|
1997-10-26 02:37:42 +04:00
|
|
|
char *buf = 0;
|
|
|
|
|
|
|
|
if (!block_buf) {
|
2003-08-01 17:41:07 +04:00
|
|
|
retval = ext2fs_get_mem(fs->blocksize, &buf);
|
1997-10-26 06:41:24 +03:00
|
|
|
if (retval)
|
|
|
|
return retval;
|
1997-10-26 02:37:42 +04:00
|
|
|
block_buf = buf;
|
|
|
|
}
|
|
|
|
memset(block_buf, 0, fs->blocksize);
|
|
|
|
|
2008-06-03 01:21:37 +04:00
|
|
|
if (fs->get_alloc_block) {
|
2009-06-02 00:15:40 +04:00
|
|
|
retval = (fs->get_alloc_block)(fs, goal, &block);
|
1997-10-26 02:37:42 +04:00
|
|
|
if (retval)
|
|
|
|
goto fail;
|
2008-06-03 01:21:37 +04:00
|
|
|
} else {
|
|
|
|
if (!fs->block_map) {
|
|
|
|
retval = ext2fs_read_block_bitmap(fs);
|
|
|
|
if (retval)
|
|
|
|
goto fail;
|
|
|
|
}
|
1997-10-26 02:37:42 +04:00
|
|
|
|
2009-06-02 00:15:40 +04:00
|
|
|
retval = ext2fs_new_block2(fs, goal, 0, &block);
|
2008-06-03 01:21:37 +04:00
|
|
|
if (retval)
|
|
|
|
goto fail;
|
|
|
|
}
|
1997-10-25 08:16:53 +04:00
|
|
|
|
2009-06-02 00:15:40 +04:00
|
|
|
retval = io_channel_write_blk64(fs->io, block, 1, block_buf);
|
1997-10-25 08:16:53 +04:00
|
|
|
if (retval)
|
1997-10-26 02:37:42 +04:00
|
|
|
goto fail;
|
2008-08-28 07:07:54 +04:00
|
|
|
|
2009-06-02 00:15:40 +04:00
|
|
|
ext2fs_block_alloc_stats2(fs, block, +1);
|
1997-10-26 02:37:42 +04:00
|
|
|
*ret = block;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
if (buf)
|
2003-08-01 17:41:07 +04:00
|
|
|
ext2fs_free_mem(&buf);
|
1997-10-26 02:37:42 +04:00
|
|
|
return retval;
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
|
|
|
|
2009-06-02 00:15:40 +04:00
|
|
|
errcode_t ext2fs_alloc_block(ext2_filsys fs, blk_t goal,
|
|
|
|
char *block_buf, blk_t *ret)
|
|
|
|
{
|
|
|
|
errcode_t retval;
|
|
|
|
blk64_t val;
|
|
|
|
retval = ext2fs_alloc_block2(fs, goal, block_buf, &val);
|
|
|
|
if (!retval)
|
|
|
|
*ret = (blk_t) val;
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
errcode_t ext2fs_get_free_blocks2(ext2_filsys fs, blk64_t start, blk64_t finish,
|
|
|
|
int num, ext2fs_block_bitmap map, blk64_t *ret)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
2011-06-16 06:17:38 +04:00
|
|
|
blk64_t b = start;
|
2011-06-11 02:51:58 +04:00
|
|
|
int c_ratio;
|
1997-04-26 17:21:57 +04:00
|
|
|
|
1997-04-26 17:34:30 +04:00
|
|
|
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
|
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
if (!map)
|
|
|
|
map = fs->block_map;
|
|
|
|
if (!map)
|
|
|
|
return EXT2_ET_NO_BLOCK_BITMAP;
|
|
|
|
if (!b)
|
|
|
|
b = fs->super->s_first_data_block;
|
|
|
|
if (!finish)
|
|
|
|
finish = start;
|
|
|
|
if (!num)
|
|
|
|
num = 1;
|
2011-06-11 02:51:58 +04:00
|
|
|
c_ratio = 1 << ext2fs_get_bitmap_granularity(map);
|
|
|
|
b &= ~(c_ratio - 1);
|
|
|
|
finish &= ~(c_ratio -1);
|
1997-04-26 17:21:57 +04:00
|
|
|
do {
|
2014-07-25 15:11:57 +04:00
|
|
|
if (b + num - 1 >= ext2fs_blocks_count(fs->super)) {
|
|
|
|
if (finish > start)
|
|
|
|
return EXT2_ET_BLOCK_ALLOC_FAIL;
|
1997-04-29 20:15:03 +04:00
|
|
|
b = fs->super->s_first_data_block;
|
2014-07-25 15:11:57 +04:00
|
|
|
}
|
2009-08-05 08:27:10 +04:00
|
|
|
if (ext2fs_fast_test_block_bitmap_range2(map, b, num)) {
|
1997-04-26 17:21:57 +04:00
|
|
|
*ret = b;
|
|
|
|
return 0;
|
|
|
|
}
|
2011-06-11 02:51:58 +04:00
|
|
|
b += c_ratio;
|
1997-04-26 17:21:57 +04:00
|
|
|
} while (b != finish);
|
1997-10-31 09:07:47 +03:00
|
|
|
return EXT2_ET_BLOCK_ALLOC_FAIL;
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
|
|
|
|
2009-06-02 00:15:40 +04:00
|
|
|
errcode_t ext2fs_get_free_blocks(ext2_filsys fs, blk_t start, blk_t finish,
|
|
|
|
int num, ext2fs_block_bitmap map, blk_t *ret)
|
|
|
|
{
|
|
|
|
errcode_t retval;
|
|
|
|
blk64_t val;
|
|
|
|
retval = ext2fs_get_free_blocks2(fs, start, finish, num, map, &val);
|
|
|
|
if(!retval)
|
|
|
|
*ret = (blk_t) val;
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2008-08-28 07:07:54 +04:00
|
|
|
void ext2fs_set_alloc_block_callback(ext2_filsys fs,
|
2008-06-03 01:21:37 +04:00
|
|
|
errcode_t (*func)(ext2_filsys fs,
|
|
|
|
blk64_t goal,
|
|
|
|
blk64_t *ret),
|
|
|
|
errcode_t (**old)(ext2_filsys fs,
|
|
|
|
blk64_t goal,
|
|
|
|
blk64_t *ret))
|
|
|
|
{
|
|
|
|
if (!fs || fs->magic != EXT2_ET_MAGIC_EXT2FS_FILSYS)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (old)
|
|
|
|
*old = fs->get_alloc_block;
|
|
|
|
|
|
|
|
fs->get_alloc_block = func;
|
|
|
|
}
|