* %End-Header%
*/
+#include "config.h"
#include <stdio.h>
#include <string.h>
#if HAVE_UNISTD_H
#include "ext2fsP.h"
#include "e2image.h"
+#undef DEBUG
+
/*
* Definitions to be dropped in lib/ext2fs/ext2fs.h
*/
int type;
int level;
int max_depth;
+ int max_paths;
struct extent_path *path;
};
}
+static void dump_path(const char *tag, struct ext2_extent_handle *handle,
+ struct extent_path *path)
+{
+ struct extent_path *ppp = path;
+ printf("%s: level=%d\n", tag, handle->level);
+
+ do {
+ printf("%s: path=%ld buf=%p entries=%d max_entries=%d left=%d "
+ "visit_num=%d flags=0x%x end_blk=%llu curr=%p(%ld)\n",
+ tag, (ppp - handle->path), ppp->buf, ppp->entries,
+ ppp->max_entries, ppp->left, ppp->visit_num, ppp->flags,
+ ppp->end_blk, ppp->curr, ppp->curr - (void *)ppp->buf);
+ printf(" ");
+ dbg_show_header((struct ext3_extent_header *)ppp->buf);
+ if (ppp->curr) {
+ printf(" ");
+ dbg_show_index(ppp->curr);
+ printf(" ");
+ dbg_show_extent(ppp->curr);
+ }
+ ppp--;
+ } while (ppp >= handle->path);
+ fflush(stdout);
+
+ return;
+}
+
#else
#define dbg_show_header(eh) do { } while (0)
#define dbg_show_index(ix) do { } while (0)
#define dbg_show_extent(ex) do { } while (0)
#define dbg_print_extent(desc, ex) do { } while (0)
+#define dump_path(tag, handle, path) do { } while (0)
#endif
/*
/*
* Begin functions to handle an inode's extent information
*/
-extern void ext2fs_extent_free(ext2_extent_handle_t handle)
+void ext2fs_extent_free(ext2_extent_handle_t handle)
{
int i;
return;
if (handle->path) {
- for (i=1; i <= handle->max_depth; i++) {
+ for (i = 1; i < handle->max_paths; i++) {
if (handle->path[i].buf)
ext2fs_free_mem(&handle->path[i].buf);
}
ext2fs_free_mem(&handle);
}
-extern errcode_t ext2fs_extent_open(ext2_filsys fs, ext2_ino_t ino,
+errcode_t ext2fs_extent_open(ext2_filsys fs, ext2_ino_t ino,
ext2_extent_handle_t *ret_handle)
{
return ext2fs_extent_open2(fs, ino, NULL, ret_handle);
}
-extern errcode_t ext2fs_extent_open2(ext2_filsys fs, ext2_ino_t ino,
+errcode_t ext2fs_extent_open2(ext2_filsys fs, ext2_ino_t ino,
struct ext2_inode *inode,
ext2_extent_handle_t *ret_handle)
{
handle->max_depth = ext2fs_le16_to_cpu(eh->eh_depth);
handle->type = ext2fs_le16_to_cpu(eh->eh_magic);
- retval = ext2fs_get_mem(((handle->max_depth+1) *
- sizeof(struct extent_path)),
- &handle->path);
- memset(handle->path, 0,
- (handle->max_depth+1) * sizeof(struct extent_path));
+ handle->max_paths = handle->max_depth + 1;
+ retval = ext2fs_get_memzero(handle->max_paths *
+ sizeof(struct extent_path),
+ &handle->path);
handle->path[0].buf = (char *) handle->inode->i_block;
handle->path[0].left = handle->path[0].entries =
blk64_t blk;
blk64_t end_blk;
int orig_op, op;
+ int failed_csum = 0;
EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
return retval;
}
+ if (!(handle->fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) &&
+ !ext2fs_extent_block_csum_verify(handle->fs, handle->ino,
+ eh))
+ failed_csum = 1;
+
newpath->left = newpath->entries =
ext2fs_le16_to_cpu(eh->eh_entries);
newpath->max_entries = ext2fs_le16_to_cpu(eh->eh_max);
(path->left != 0)))
goto retry;
+ if (failed_csum)
+ return EXT2_ET_EXTENT_CSUM_INVALID;
+
return 0;
}
blk64_t blk;
errcode_t retval;
struct ext3_extent_idx *ix;
+ struct ext3_extent_header *eh;
if (handle->level == 0) {
retval = ext2fs_write_inode(handle->fs, handle->ino,
blk = ext2fs_le32_to_cpu(ix->ei_leaf) +
((__u64) ext2fs_le16_to_cpu(ix->ei_leaf_hi) << 32);
+ /* then update the checksum */
+ eh = (struct ext3_extent_header *)
+ handle->path[handle->level].buf;
+ retval = ext2fs_extent_block_csum_set(handle->fs, handle->ino,
+ eh);
+ if (retval)
+ return retval;
+
retval = io_channel_write_blk64(handle->fs->io,
blk, 1, handle->path[handle->level].buf);
}
* If "blk" has no mapping (hole) then handle is left at last
* extent before blk.
*/
-static errcode_t extent_goto(ext2_extent_handle_t handle,
- int leaf_level, blk64_t blk)
+errcode_t ext2fs_extent_goto2(ext2_extent_handle_t handle,
+ int leaf_level, blk64_t blk)
{
struct ext2fs_extent extent;
errcode_t retval;
errcode_t ext2fs_extent_goto(ext2_extent_handle_t handle,
blk64_t blk)
{
- return extent_goto(handle, 0, blk);
+ return ext2fs_extent_goto2(handle, 0, blk);
}
/*
* and so on.
*
* Safe to call for any position in node; if not at the first entry,
- * will simply return.
+ * it will simply return.
+ *
+ * Note a subtlety of this function -- if there happen to be two extents
+ * mapping the same lblk and someone calls fix_parents on the second of the two
+ * extents, the position of the extent handle after the call will be the second
+ * extent if nothing happened, or the first extent if something did. A caller
+ * in this situation must use ext2fs_extent_goto() after calling this function.
+ * Or simply don't map the same lblk with two extents, ever.
*/
-static errcode_t ext2fs_extent_fix_parents(ext2_extent_handle_t handle)
+errcode_t ext2fs_extent_fix_parents(ext2_extent_handle_t handle)
{
int retval = 0;
+ int orig_height;
blk64_t start;
struct extent_path *path;
struct ext2fs_extent extent;
+ struct ext2_extent_info info;
EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
/* modified node's start block */
start = extent.e_lblk;
+ if ((retval = ext2fs_extent_get_info(handle, &info)))
+ return retval;
+ orig_height = info.max_depth - info.curr_level;
+
/* traverse up until index not first, or startblk matches, or top */
while (handle->level > 0 &&
(path->left == path->entries - 1)) {
}
/* put handle back to where we started */
- retval = ext2fs_extent_goto(handle, start);
+ retval = ext2fs_extent_goto2(handle, orig_height, start);
done:
return retval;
}
return 0;
}
+static int splitting_at_eof(struct ext2_extent_handle *handle,
+ struct extent_path *path)
+{
+ struct extent_path *ppp = path;
+ dump_path(__func__, handle, path);
+
+ if (handle->level == 0)
+ return 0;
+
+ do {
+ if (ppp->left)
+ return 0;
+ ppp--;
+ } while (ppp >= handle->path);
+
+ return 1;
+}
+
/*
* allocate a new block, move half the current node to it, and update parent
*
* handle will be left pointing at original record.
*/
-static errcode_t extent_node_split(ext2_extent_handle_t handle)
+static errcode_t extent_node_split(ext2_extent_handle_t handle,
+ int expand_allowed)
{
errcode_t retval = 0;
blk64_t new_node_pblk;
int tocopy;
int new_root = 0;
struct ext2_extent_info info;
+ int no_balance;
/* basic sanity */
EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
orig_height = info.max_depth - info.curr_level;
orig_lblk = extent.e_lblk;
+ /* Try to put the index block before the first extent */
+ path = handle->path + handle->level;
+ eh = (struct ext3_extent_header *) path->buf;
+ if (handle->level == handle->max_depth) {
+ struct ext3_extent *ex;
+
+ ex = EXT_FIRST_EXTENT(eh);
+ goal_blk = ext2fs_le32_to_cpu(ex->ee_start) +
+ ((__u64) ext2fs_le16_to_cpu(ex->ee_start_hi) << 32);
+ } else {
+ struct ext3_extent_idx *ix;
+
+ ix = EXT_FIRST_INDEX(eh);
+ goal_blk = ext2fs_le32_to_cpu(ix->ei_leaf) +
+ ((__u64) ext2fs_le16_to_cpu(ix->ei_leaf_hi) << 32);
+ }
+ goal_blk -= EXT2FS_CLUSTER_RATIO(handle->fs);
+ goal_blk &= ~EXT2FS_CLUSTER_MASK(handle->fs);
+
/* Is there room in the parent for a new entry? */
if (handle->level &&
(handle->path[handle->level - 1].entries >=
retval = ext2fs_extent_get(handle, EXT2_EXTENT_UP, &extent);
if (retval)
goto done;
- goal_blk = extent.e_pblk;
- retval = extent_node_split(handle);
+ retval = extent_node_split(handle, expand_allowed);
if (retval)
goto done;
/* get handle back to our original split position */
- retval = extent_goto(handle, orig_height, orig_lblk);
+ retval = ext2fs_extent_goto2(handle, orig_height, orig_lblk);
if (retval)
goto done;
}
if (!path->curr)
return EXT2_ET_NO_CURRENT_NODE;
+ /*
+ * Normally, we try to split a full node in half. This doesn't turn
+ * out so well if we're tacking extents on the end of the file because
+ * then we're stuck with a tree of half-full extent blocks. This of
+ * course doesn't apply to the root level.
+ */
+ no_balance = expand_allowed ? splitting_at_eof(handle, path) : 0;
+
/* extent header of the current node we'll split */
eh = (struct ext3_extent_header *)path->buf;
if (handle->level == 0) {
new_root = 1;
tocopy = ext2fs_le16_to_cpu(eh->eh_entries);
- retval = ext2fs_get_mem(((handle->max_depth+2) *
- sizeof(struct extent_path)),
- &newpath);
+ retval = ext2fs_get_memzero((handle->max_paths + 1) *
+ sizeof(struct extent_path),
+ &newpath);
if (retval)
goto done;
- memset(newpath, 0,
- ((handle->max_depth+2) * sizeof(struct extent_path)));
} else {
- tocopy = ext2fs_le16_to_cpu(eh->eh_entries) / 2;
+ if (no_balance)
+ tocopy = 1;
+ else
+ tocopy = ext2fs_le16_to_cpu(eh->eh_entries) / 2;
}
#ifdef DEBUG
handle->level);
#endif
- if (!tocopy) {
+ if (!tocopy && !no_balance) {
#ifdef DEBUG
printf("Nothing to copy to new block!\n");
#endif
goto done;
}
- if (!goal_blk) {
- dgrp_t group = ext2fs_group_of_ino(handle->fs, handle->ino);
- __u8 log_flex = handle->fs->super->s_log_groups_per_flex;
-
- if (log_flex)
- group = group & ~((1 << (log_flex)) - 1);
- goal_blk = (group * handle->fs->super->s_blocks_per_group) +
- handle->fs->super->s_first_data_block;
- }
+ if (!goal_blk)
+ goal_blk = ext2fs_find_inode_goal(handle->fs, handle->ino,
+ handle->inode, 0);
retval = ext2fs_alloc_block2(handle->fs, goal_blk, block_buf,
&new_node_pblk);
if (retval)
new_node_start = ext2fs_le32_to_cpu(EXT_FIRST_INDEX(neweh)->ei_block);
+ /* then update the checksum */
+ retval = ext2fs_extent_block_csum_set(handle->fs, handle->ino, neweh);
+ if (retval)
+ goto done;
+
/* ...and write the new node block out to disk. */
retval = io_channel_write_blk64(handle->fs->io, new_node_pblk, 1,
block_buf);
/* current path now has fewer active entries, we copied some out */
if (handle->level == 0) {
memcpy(newpath, path,
- sizeof(struct extent_path) * (handle->max_depth+1));
+ sizeof(struct extent_path) * handle->max_paths);
handle->path = newpath;
newpath = path;
path = handle->path;
path->entries = 1;
path->left = path->max_entries - 1;
handle->max_depth++;
+ handle->max_paths++;
eh->eh_depth = ext2fs_cpu_to_le16(handle->max_depth);
} else {
path->entries -= tocopy;
}
/* get handle back to our original position */
- retval = extent_goto(handle, orig_height, orig_lblk);
+ retval = ext2fs_extent_goto2(handle, orig_height, orig_lblk);
if (retval)
goto done;
/* new node hooked in, so update inode block count (do this here?) */
- handle->inode->i_blocks += handle->fs->blocksize / 512;
+ ext2fs_iblk_add_blocks(handle->fs, handle->inode, 1);
retval = ext2fs_write_inode(handle->fs, handle->ino,
handle->inode);
if (retval)
return retval;
}
+errcode_t ext2fs_extent_node_split(ext2_extent_handle_t handle)
+{
+ return extent_node_split(handle, 0);
+}
+
errcode_t ext2fs_extent_insert(ext2_extent_handle_t handle, int flags,
struct ext2fs_extent *extent)
{
printf("node full (level %d) - splitting\n",
handle->level);
#endif
- retval = extent_node_split(handle);
+ retval = extent_node_split(handle, 1);
if (retval)
return retval;
path = handle->path + handle->level;
ix++;
path->left--;
}
- } else
+ } else {
ix = EXT_FIRST_INDEX(eh);
+ path->left = -1;
+ }
path->curr = ix;
EXT2_EXTENT_INSERT_AFTER, &newextent);
if (retval)
goto done;
- /* Now pointing at inserted extent; move back to prev */
+ retval = ext2fs_extent_fix_parents(handle);
+ if (retval)
+ goto done;
+ /*
+ * Now pointing at inserted extent; move back to prev.
+ *
+ * We cannot use EXT2_EXTENT_PREV to go back; note the
+ * subtlety in the comment for fix_parents().
+ */
+ retval = ext2fs_extent_goto(handle, logical);
+ if (retval)
+ goto done;
retval = ext2fs_extent_get(handle,
- EXT2_EXTENT_PREV_LEAF,
+ EXT2_EXTENT_CURRENT,
&extent);
if (retval)
goto done;
0, &newextent);
if (retval)
goto done;
+ retval = ext2fs_extent_fix_parents(handle);
+ if (retval)
+ goto done;
retval = ext2fs_extent_get(handle,
EXT2_EXTENT_NEXT_LEAF,
&extent);
retval = ext2fs_extent_replace(handle, 0, &extent);
if (retval)
goto done;
+ retval = ext2fs_extent_fix_parents(handle);
+ if (retval)
+ goto done;
} else {
- __u32 orig_length;
+ __u32 save_length;
+ blk64_t save_lblk;
+ struct ext2fs_extent save_extent;
+ errcode_t r2;
#ifdef DEBUG
printf("(re/un)mapping in middle of extent\n");
#endif
/* need to split this extent; later */
-
- orig_length = extent.e_len;
+ save_lblk = extent.e_lblk;
+ save_length = extent.e_len;
+ save_extent = extent;
/* shorten pre-split extent */
extent.e_len = (logical - extent.e_lblk);
/* insert new extent after current */
retval = ext2fs_extent_insert(handle,
EXT2_EXTENT_INSERT_AFTER, &newextent);
- if (retval)
+ if (retval) {
+ r2 = ext2fs_extent_goto(handle, save_lblk);
+ if (r2 == 0)
+ (void)ext2fs_extent_replace(handle, 0,
+ &save_extent);
goto done;
+ }
}
/* add post-split extent */
extent.e_pblk += extent.e_len + 1;
extent.e_lblk += extent.e_len + 1;
- extent.e_len = orig_length - extent.e_len - 1;
+ extent.e_len = save_length - extent.e_len - 1;
retval = ext2fs_extent_insert(handle,
EXT2_EXTENT_INSERT_AFTER, &extent);
- if (retval)
+ if (retval) {
+ if (physical) {
+ r2 = ext2fs_extent_goto(handle,
+ newextent.e_lblk);
+ if (r2 == 0)
+ (void)ext2fs_extent_delete(handle, 0);
+ }
+ r2 = ext2fs_extent_goto(handle, save_lblk);
+ if (r2 == 0)
+ (void)ext2fs_extent_replace(handle, 0,
+ &save_extent);
goto done;
+ }
}
done:
/* get handle back to its position */
if (orig_height > handle->max_depth)
orig_height = handle->max_depth; /* In case we shortened the tree */
- extent_goto(handle, orig_height, orig_lblk);
+ ext2fs_extent_goto2(handle, orig_height, orig_lblk);
return retval;
}
return retval;
retval = ext2fs_extent_delete(handle, flags);
- handle->inode->i_blocks -= handle->fs->blocksize / 512;
+ handle->inode->i_blocks -=
+ (handle->fs->blocksize *
+ EXT2FS_CLUSTER_RATIO(handle->fs)) / 512;
retval = ext2fs_write_inode(handle->fs, handle->ino,
handle->inode);
ext2fs_block_alloc_stats2(handle->fs,
} else {
eh = (struct ext3_extent_header *) path->buf;
eh->eh_entries = ext2fs_cpu_to_le16(path->entries);
- if ((path->entries == 0) && (handle->level == 0))
- eh->eh_depth = handle->max_depth = 0;
+ if ((path->entries == 0) && (handle->level == 0)) {
+ eh->eh_depth = 0;
+ handle->max_depth = 0;
+ }
retval = update_path(handle);
}
return retval;
info->curr_level = handle->level;
info->max_depth = handle->max_depth;
- info->max_lblk = ((__u64) 1 << 32) - 1;
- info->max_pblk = ((__u64) 1 << 48) - 1;
- info->max_len = (1UL << 15);
- info->max_uninit_len = (1UL << 15) - 1;
+ info->max_lblk = EXT_MAX_EXTENT_LBLK;
+ info->max_pblk = EXT_MAX_EXTENT_PBLK;
+ info->max_len = EXT_INIT_MAX_LEN;
+ info->max_uninit_len = EXT_UNINIT_MAX_LEN;
return 0;
}
-#ifdef DEBUG
-
-#include "ss/ss.h"
-
-#include "debugfs.h"
-
-/*
- * Hook in new commands into debugfs
- */
-const char *debug_prog_name = "tst_extents";
-extern ss_request_table extent_cmds;
-ss_request_table *extra_cmds = &extent_cmds;
-
-ext2_ino_t current_ino = 0;
-ext2_extent_handle_t current_handle;
-
-int common_extent_args_process(int argc, char *argv[], int min_argc,
- int max_argc, const char *cmd,
- const char *usage, int flags)
+static int ul_log2(unsigned long arg)
{
- if (common_args_process(argc, argv, min_argc, max_argc, cmd,
- usage, flags))
- return 1;
+ int l = 0;
- if (!current_handle) {
- com_err(cmd, 0, "Extent handle not open");
- return 1;
+ arg >>= 1;
+ while (arg) {
+ l++;
+ arg >>= 1;
}
- return 0;
+ return l;
}
-void do_inode(int argc, char *argv[])
+size_t ext2fs_max_extent_depth(ext2_extent_handle_t handle)
{
- ext2_ino_t inode;
- int i;
- struct ext3_extent_header *eh;
- errcode_t retval;
-
- if (check_fs_open(argv[0]))
- return;
-
- if (argc == 1) {
- if (current_ino)
- printf("Current inode is %d\n", current_ino);
- else
- printf("No current inode\n");
- return;
- }
-
- if (common_inode_args_process(argc, argv, &inode, 0)) {
- return;
- }
-
- current_ino = 0;
-
- retval = ext2fs_extent_open(current_fs, inode, ¤t_handle);
- if (retval) {
- com_err(argv[1], retval, "while opening extent handle");
- return;
- }
-
- current_ino = inode;
-
- printf("Loaded inode %d\n", current_ino);
-
- return;
+ size_t iblock_sz = sizeof(((struct ext2_inode *)NULL)->i_block);
+ size_t iblock_extents = (iblock_sz - sizeof(struct ext3_extent_header)) /
+ sizeof(struct ext3_extent);
+ size_t extents_per_block = (handle->fs->blocksize -
+ sizeof(struct ext3_extent_header)) /
+ sizeof(struct ext3_extent);
+ static unsigned int last_blocksize = 0;
+ static size_t last_result = 0;
+
+ if (last_blocksize && last_blocksize == handle->fs->blocksize)
+ return last_result;
+
+ last_result = 1 + ((ul_log2(EXT_MAX_EXTENT_LBLK) - ul_log2(iblock_extents)) /
+ ul_log2(extents_per_block));
+ last_blocksize = handle->fs->blocksize;
+ return last_result;
}
-void generic_goto_node(char *cmd_name, int op)
+errcode_t ext2fs_fix_extents_checksums(ext2_filsys fs, ext2_ino_t ino,
+ struct ext2_inode *inode)
{
+ ext2_extent_handle_t handle;
struct ext2fs_extent extent;
- errcode_t retval;
-
- if (check_fs_open(cmd_name))
- return;
-
- if (!current_handle) {
- com_err(cmd_name, 0, "Extent handle not open");
- return;
- }
-
- retval = ext2fs_extent_get(current_handle, op, &extent);
- if (retval) {
- com_err(cmd_name, retval, 0);
- return;
- }
- dbg_print_extent(0, &extent);
-}
-
-void do_current_node(int argc, char *argv[])
-{
- generic_goto_node(argv[0], EXT2_EXTENT_CURRENT);
-}
-
-void do_root_node(int argc, char *argv[])
-{
- generic_goto_node(argv[0], EXT2_EXTENT_ROOT);
-}
-
-void do_last_leaf(int argc, char *argv[])
-{
- generic_goto_node(argv[0], EXT2_EXTENT_LAST_LEAF);
-}
-
-void do_first_sib(int argc, char *argv[])
-{
- generic_goto_node(argv[0], EXT2_EXTENT_FIRST_SIB);
-}
-
-void do_last_sib(int argc, char *argv[])
-{
- generic_goto_node(argv[0], EXT2_EXTENT_LAST_SIB);
-}
-
-void do_next_sib(int argc, char *argv[])
-{
- generic_goto_node(argv[0], EXT2_EXTENT_NEXT_SIB);
-}
-
-void do_prev_sib(int argc, char *argv[])
-{
- generic_goto_node(argv[0], EXT2_EXTENT_PREV_SIB);
-}
-
-void do_next_leaf(int argc, char *argv[])
-{
- generic_goto_node(argv[0], EXT2_EXTENT_NEXT_LEAF);
-}
-
-void do_prev_leaf(int argc, char *argv[])
-{
- generic_goto_node(argv[0], EXT2_EXTENT_PREV_LEAF);
-}
-
-void do_next(int argc, char *argv[])
-{
- generic_goto_node(argv[0], EXT2_EXTENT_NEXT);
-}
-
-void do_prev(int argc, char *argv[])
-{
- generic_goto_node(argv[0], EXT2_EXTENT_PREV);
-}
-
-void do_up(int argc, char *argv[])
-{
- generic_goto_node(argv[0], EXT2_EXTENT_UP);
-}
-
-void do_down(int argc, char *argv[])
-{
- generic_goto_node(argv[0], EXT2_EXTENT_DOWN);
-}
-
-void do_delete_node(int argc, char *argv[])
-{
- errcode_t retval;
- int err;
-
- if (common_extent_args_process(argc, argv, 1, 1, "delete_node",
- "", CHECK_FS_RW | CHECK_FS_BITMAPS))
- return;
-
- retval = ext2fs_extent_delete(current_handle, 0);
- if (retval) {
- com_err(argv[0], retval, 0);
- return;
+ errcode_t errcode;
+ int save_flags = fs->flags;
+
+ if (!ext2fs_has_feature_metadata_csum(fs->super) ||
+ (inode && !(inode->i_flags & EXT4_EXTENTS_FL)))
+ return 0;
+
+ errcode = ext2fs_extent_open2(fs, ino, inode, &handle);
+ if (errcode) {
+ if (errcode == EXT2_ET_INODE_NOT_EXTENT)
+ errcode = 0;
+ return errcode;
}
- if (current_handle->path && current_handle->path[0].curr)
- do_current_node(argc, argv);
-}
-
-void do_replace_node(int argc, char *argv[])
-{
- const char *usage = "[--uninit] <lblk> <len> <pblk>";
- errcode_t retval;
- struct ext2fs_extent extent;
- int err;
- if (common_extent_args_process(argc, argv, 3, 5, "replace_node",
- usage, CHECK_FS_RW | CHECK_FS_BITMAPS))
- return;
-
- extent.e_flags = 0;
-
- if (!strcmp(argv[1], "--uninit")) {
- argc--;
- argv++;
- extent.e_flags |= EXT2_EXTENT_FLAGS_UNINIT;
- }
-
- if (argc != 4) {
- fprintf(stderr, "Usage: %s %s\n", argv[0], usage);
- return;
- }
-
- extent.e_lblk = parse_ulong(argv[1], argv[0], "logical block", &err);
- if (err)
- return;
-
- extent.e_len = parse_ulong(argv[2], argv[0], "logical block", &err);
- if (err)
- return;
-
- extent.e_pblk = parse_ulong(argv[3], argv[0], "logical block", &err);
- if (err)
- return;
-
- retval = ext2fs_extent_replace(current_handle, 0, &extent);
- if (retval) {
- com_err(argv[0], retval, 0);
- return;
- }
- do_current_node(argc, argv);
-}
-
-void do_split_node(int argc, char *argv[])
-{
- errcode_t retval;
- struct ext2fs_extent extent;
- int err;
-
- if (common_extent_args_process(argc, argv, 1, 1, "split_node",
- "", CHECK_FS_RW | CHECK_FS_BITMAPS))
- return;
-
- retval = extent_node_split(current_handle);
- if (retval) {
- com_err(argv[0], retval, 0);
- return;
- }
- do_current_node(argc, argv);
-}
-
-void do_insert_node(int argc, char *argv[])
-{
- const char *usage = "[--after] [--uninit] <lblk> <len> <pblk>";
- errcode_t retval;
- struct ext2fs_extent extent;
- char *cmd;
- int err;
- int flags = 0;
-
- if (common_extent_args_process(argc, argv, 3, 6, "insert_node",
- usage, CHECK_FS_RW | CHECK_FS_BITMAPS))
- return;
-
- cmd = argv[0];
-
- extent.e_flags = 0;
-
- while (argc > 2) {
- if (!strcmp(argv[1], "--after")) {
- argc--;
- argv++;
- flags |= EXT2_EXTENT_INSERT_AFTER;
- continue;
+ fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS;
+ errcode = ext2fs_extent_get(handle, EXT2_EXTENT_ROOT, &extent);
+ if (errcode)
+ goto out;
+
+ do {
+ /* Skip to the end of a block of leaf nodes */
+ if (extent.e_flags & EXT2_EXTENT_FLAGS_LEAF) {
+ errcode = ext2fs_extent_get(handle,
+ EXT2_EXTENT_LAST_SIB,
+ &extent);
+ if (errcode)
+ break;
}
- if (!strcmp(argv[1], "--uninit")) {
- argc--;
- argv++;
- extent.e_flags |= EXT2_EXTENT_FLAGS_UNINIT;
- continue;
- }
- break;
- }
- if (argc != 4) {
- fprintf(stderr, "usage: %s %s\n", cmd, usage);
- return;
- }
-
- extent.e_lblk = parse_ulong(argv[1], cmd,
- "logical block", &err);
- if (err)
- return;
+ errcode = ext2fs_extent_get(handle, EXT2_EXTENT_NEXT, &extent);
+ if (errcode == EXT2_ET_EXTENT_CSUM_INVALID)
+ errcode = update_path(handle);
+ } while (errcode == 0);
- extent.e_len = parse_ulong(argv[2], cmd,
- "length", &err);
- if (err)
- return;
-
- extent.e_pblk = parse_ulong(argv[3], cmd,
- "pysical block", &err);
- if (err)
- return;
-
- retval = ext2fs_extent_insert(current_handle, flags, &extent);
- if (retval) {
- com_err(cmd, retval, 0);
- return;
- }
- do_current_node(argc, argv);
+out:
+ /* Ok if we run off the end */
+ if (errcode == EXT2_ET_EXTENT_NO_NEXT)
+ errcode = 0;
+ ext2fs_extent_free(handle);
+ fs->flags = save_flags;
+ return errcode;
}
-void do_set_bmap(int argc, char **argv)
+errcode_t ext2fs_decode_extent(struct ext2fs_extent *to, void *addr, int len)
{
- const char *usage = "[--uninit] <lblk> <pblk>";
- errcode_t retval;
- blk_t logical;
- blk_t physical;
- char *cmd = argv[0];
- int flags = 0;
- int err;
-
- if (common_extent_args_process(argc, argv, 3, 5, "set_bmap",
- usage, CHECK_FS_RW | CHECK_FS_BITMAPS))
- return;
-
- if (argc > 2 && !strcmp(argv[1], "--uninit")) {
- argc--;
- argv++;
- flags |= EXT2_EXTENT_SET_BMAP_UNINIT;
+ struct ext3_extent *from = (struct ext3_extent *)addr;
+
+ if (len != sizeof(struct ext3_extent))
+ return EXT2_ET_INVALID_ARGUMENT;
+
+ to->e_pblk = ext2fs_le32_to_cpu(from->ee_start) +
+ ((__u64) ext2fs_le16_to_cpu(from->ee_start_hi)
+ << 32);
+ to->e_lblk = ext2fs_le32_to_cpu(from->ee_block);
+ to->e_len = ext2fs_le16_to_cpu(from->ee_len);
+ to->e_flags |= EXT2_EXTENT_FLAGS_LEAF;
+ if (to->e_len > EXT_INIT_MAX_LEN) {
+ to->e_len -= EXT_INIT_MAX_LEN;
+ to->e_flags |= EXT2_EXTENT_FLAGS_UNINIT;
}
- if (argc != 3) {
- fprintf(stderr, "Usage: %s %s\n", cmd, usage);
- return;
- }
-
- logical = parse_ulong(argv[1], cmd,
- "logical block", &err);
- if (err)
- return;
-
- physical = parse_ulong(argv[2], cmd,
- "physical block", &err);
- if (err)
- return;
-
- retval = ext2fs_extent_set_bmap(current_handle, logical,
- (blk64_t) physical, flags);
- if (retval) {
- com_err(cmd, retval, 0);
- return;
- }
- if (current_handle->path && current_handle->path[0].curr)
- do_current_node(argc, argv);
+ return 0;
}
-void do_print_all(int argc, char **argv)
+errcode_t ext2fs_count_blocks(ext2_filsys fs, ext2_ino_t ino,
+ struct ext2_inode *inode, blk64_t *ret_count)
{
- const char *usage = "[--leaf-only|--reverse|--reverse-leaf]";
+ ext2_extent_handle_t handle = NULL;
struct ext2fs_extent extent;
- errcode_t retval;
- errcode_t end_err = EXT2_ET_EXTENT_NO_NEXT;
- int op = EXT2_EXTENT_NEXT;
- int first_op = EXT2_EXTENT_ROOT;
-
-
- if (common_extent_args_process(argc, argv, 1, 2, "print_all",
- usage, 0))
- return;
-
- if (argc == 2) {
- if (!strcmp(argv[1], "--leaf-only"))
- op = EXT2_EXTENT_NEXT_LEAF;
- else if (!strcmp(argv[1], "--reverse")) {
- op = EXT2_EXTENT_PREV;
- first_op = EXT2_EXTENT_LAST_LEAF;
- end_err = EXT2_ET_EXTENT_NO_PREV;
- } else if (!strcmp(argv[1], "--reverse-leaf")) {
- op = EXT2_EXTENT_PREV_LEAF;
- first_op = EXT2_EXTENT_LAST_LEAF;
- end_err = EXT2_ET_EXTENT_NO_PREV;
- } else {
- fprintf(stderr, "Usage: %s %s\n", argv[0], usage);
- return;
- }
- }
-
- retval = ext2fs_extent_get(current_handle, first_op, &extent);
- if (retval) {
- com_err(argv[0], retval, 0);
- return;
- }
- dbg_print_extent(0, &extent);
-
- while (1) {
- retval = ext2fs_extent_get(current_handle, op, &extent);
- if (retval == end_err)
- break;
-
- if (retval) {
- com_err(argv[0], retval, 0);
- return;
+ errcode_t errcode;
+ int i;
+ blk64_t blkcount = 0;
+ blk64_t *intermediate_nodes;
+
+ errcode = ext2fs_extent_open2(fs, ino, inode, &handle);
+ if (errcode)
+ goto out;
+
+ errcode = ext2fs_extent_get(handle, EXT2_EXTENT_ROOT, &extent);
+ if (errcode)
+ goto out;
+
+ errcode = ext2fs_get_array(handle->max_depth, sizeof(blk64_t),
+ &intermediate_nodes);
+ if (errcode)
+ goto out;
+
+ blkcount = handle->level;
+ while (!errcode) {
+ if (extent.e_flags & EXT2_EXTENT_FLAGS_LEAF) {
+ blkcount += extent.e_len;
+ for (i = 0; i < handle->level; i++) {
+ if (intermediate_nodes[i] !=
+ handle->path[i].end_blk) {
+ blkcount++;
+ intermediate_nodes[i] =
+ handle->path[i].end_blk;
+ }
+ }
}
- dbg_print_extent(0, &extent);
+ errcode = ext2fs_extent_get(handle, EXT2_EXTENT_NEXT, &extent);
}
-}
-
-void do_info(int argc, char **argv)
-{
- struct ext2fs_extent extent;
- struct ext2_extent_info info;
- errcode_t retval;
-
- if (common_extent_args_process(argc, argv, 1, 1, "info", "", 0))
- return;
-
- retval = ext2fs_extent_get_info(current_handle, &info);
- if (retval) {
- com_err(argv[0], retval, 0);
- return;
- }
-
- retval = ext2fs_extent_get(current_handle,
- EXT2_EXTENT_CURRENT, &extent);
- if (retval) {
- com_err(argv[0], retval, 0);
- return;
- }
-
- dbg_print_extent(0, &extent);
+ ext2fs_free_mem(&intermediate_nodes);
+out:
+ *ret_count = blkcount;
+ ext2fs_extent_free(handle);
- printf("Current handle location: %d/%d (max: %d, bytes %d), level %d/%d\n",
- info.curr_entry, info.num_entries, info.max_entries,
- info.bytes_avail, info.curr_level, info.max_depth);
- printf("\tmax lblk: %llu, max pblk: %llu\n", info.max_lblk,
- info.max_pblk);
- printf("\tmax_len: %u, max_uninit_len: %u\n", info.max_len,
- info.max_uninit_len);
+ return 0;
}
-void do_goto_block(int argc, char **argv)
-{
- struct ext2fs_extent extent;
- errcode_t retval;
- int op = EXT2_EXTENT_NEXT_LEAF;
- blk64_t blk;
- int level = 0, err;
-
- if (common_extent_args_process(argc, argv, 2, 3, "goto_block",
- "block [level]", 0))
- return;
-
- if (strtoblk(argv[0], argv[1], &blk))
- return;
-
- if (argc == 3) {
- level = parse_ulong(argv[2], argv[0], "level", &err);
- if (err)
- return;
- }
-
- retval = extent_goto(current_handle, level, (blk64_t) blk);
-
- if (retval) {
- com_err(argv[0], retval,
- "while trying to go to block %llu, level %d",
- (unsigned long long) blk, level);
- return;
- }
+#ifdef DEBUG
+/*
+ * Override debugfs's prompt
+ */
+const char *debug_prog_name = "tst_extents";
- generic_goto_node(argv[0], EXT2_EXTENT_CURRENT);
-}
#endif
git://git.whamcloud.com / tools / e2fsprogs.git / blobdiff