* Copyright (C) 2007 Theodore Ts'o.
*
* %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
+ * This file may be redistributed under the terms of the GNU Library
+ * General Public License, version 2.
* %End-Header%
*/
+#include "config.h"
#include <stdio.h>
#include <string.h>
#if HAVE_UNISTD_H
ext2_filsys fs;
ext2_ino_t ino;
struct ext2_inode *inode;
+ struct ext2_inode inodebuf;
int type;
int level;
int max_depth;
{
if (desc)
printf("%s: ", desc);
- printf("extent: lblk %llu--%llu, len %lu, pblk %llu, flags: ",
+ printf("extent: lblk %llu--%llu, len %u, pblk %llu, flags: ",
extent->e_lblk, extent->e_lblk + extent->e_len - 1,
extent->e_len, extent->e_pblk);
if (extent->e_flags & EXT2_EXTENT_FLAGS_LEAF)
if (!handle)
return;
- if (handle->inode)
- ext2fs_free_mem(&handle->inode);
if (handle->path) {
- for (i=1; i < handle->max_depth; i++) {
+ for (i=1; i <= handle->max_depth; i++) {
if (handle->path[i].buf)
ext2fs_free_mem(&handle->path[i].buf);
}
extern 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,
+ struct ext2_inode *inode,
+ ext2_extent_handle_t *ret_handle)
+{
struct ext2_extent_handle *handle;
errcode_t retval;
- int isize = EXT2_INODE_SIZE(fs->super);
int i;
struct ext3_extent_header *eh;
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
- if ((ino == 0) || (ino > fs->super->s_inodes_count))
- return EXT2_ET_BAD_INODE_NUM;
+ if (!inode)
+ if ((ino == 0) || (ino > fs->super->s_inodes_count))
+ return EXT2_ET_BAD_INODE_NUM;
retval = ext2fs_get_mem(sizeof(struct ext2_extent_handle), &handle);
if (retval)
return retval;
memset(handle, 0, sizeof(struct ext2_extent_handle));
- retval = ext2fs_get_mem(isize, &handle->inode);
- if (retval)
- goto errout;
-
handle->ino = ino;
handle->fs = fs;
- retval = ext2fs_read_inode_full(fs, ino, handle->inode, isize);
- if (retval)
- goto errout;
+ if (inode) {
+ handle->inode = inode;
+ } else {
+ handle->inode = &handle->inodebuf;
+ retval = ext2fs_read_inode(fs, ino, handle->inode);
+ if (retval)
+ goto errout;
+ }
eh = (struct ext3_extent_header *) &handle->inode->i_block[0];
handle->path[0].max_entries = ext2fs_le16_to_cpu(eh->eh_max);
handle->path[0].curr = 0;
handle->path[0].end_blk =
- ((((__u64) handle->inode->i_size_high << 32) +
- handle->inode->i_size + (fs->blocksize - 1))
- >> EXT2_BLOCK_SIZE_BITS(fs->super));
+ (EXT2_I_SIZE(handle->inode) + fs->blocksize - 1) >>
+ EXT2_BLOCK_SIZE_BITS(fs->super);
handle->path[0].visit_num = 1;
handle->level = 0;
handle->magic = EXT2_ET_MAGIC_EXTENT_HANDLE;
struct ext3_extent_idx *ix = 0;
struct ext3_extent *ex;
errcode_t retval;
- blk_t blk;
+ blk64_t blk;
blk64_t end_blk;
int orig_op, op;
return EXT2_ET_EXTENT_NO_NEXT;
}
if (op != EXT2_EXTENT_NEXT_SIB) {
-#ifdef DEBUG
+#ifdef DEBUG_GET_EXTENT
printf("<<<< OP = %s\n",
(op == EXT2_EXTENT_DOWN) ? "down" :
((op == EXT2_EXTENT_UP) ? "up" : "unknown"));
return EXT2_ET_EXTENT_NO_PREV;
}
if (op != EXT2_EXTENT_PREV_SIB) {
-#ifdef DEBUG
+#ifdef DEBUG_GET_EXTENT
printf("<<<< OP = %s\n",
(op == EXT2_EXTENT_DOWN_AND_LAST) ? "down/last" :
((op == EXT2_EXTENT_UP) ? "up" : "unknown"));
op = EXT2_EXTENT_DOWN;
else
op = EXT2_EXTENT_LAST_SIB;
-#ifdef DEBUG
+#ifdef DEBUG_GET_EXTENT
printf("<<<< OP = %s\n",
(op == EXT2_EXTENT_DOWN) ? "down" : "last_sib");
#endif
case EXT2_EXTENT_ROOT:
handle->level = 0;
path = handle->path + handle->level;
+ /* fallthrough */
case EXT2_EXTENT_FIRST_SIB:
path->left = path->entries;
path->curr = 0;
+ /* fallthrough */
case EXT2_EXTENT_NEXT_SIB:
if (path->left <= 0)
return EXT2_ET_EXTENT_NO_NEXT;
(handle->fs->io != handle->fs->image_io))
memset(newpath->buf, 0, handle->fs->blocksize);
else {
- retval = io_channel_read_blk(handle->fs->io,
+ retval = io_channel_read_blk64(handle->fs->io,
blk, 1, newpath->buf);
if (retval)
return retval;
if (handle->level < handle->max_depth)
path->visit_num = 1;
}
-#ifdef DEBUG
+#ifdef DEBUG_GET_EXTENT
printf("Down to level %d/%d, end_blk=%llu\n",
handle->level, handle->max_depth,
path->end_blk);
return EXT2_ET_NO_CURRENT_NODE;
extent->e_flags = 0;
-#ifdef DEBUG
+#ifdef DEBUG_GET_EXTENT
printf("(Left %d)\n", path->left);
#endif
struct ext3_extent_idx *ix;
if (handle->level == 0) {
- retval = ext2fs_write_inode_full(handle->fs, handle->ino,
- handle->inode, EXT2_INODE_SIZE(handle->fs->super));
+ retval = ext2fs_write_inode(handle->fs, handle->ino,
+ handle->inode);
} else {
ix = handle->path[handle->level - 1].curr;
blk = ext2fs_le32_to_cpu(ix->ei_leaf) +
((__u64) ext2fs_le16_to_cpu(ix->ei_leaf_hi) << 32);
- retval = io_channel_write_blk(handle->fs->io,
+ retval = io_channel_write_blk64(handle->fs->io,
blk, 1, handle->path[handle->level].buf);
}
return retval;
* 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;
return EXT2_ET_OP_NOT_SUPPORTED;
}
+#ifdef DEBUG
+ printf("goto extent ino %u, level %d, %llu\n", handle->ino,
+ leaf_level, blk);
+#endif
+
+#ifdef DEBUG_GOTO_EXTENTS
dbg_print_extent("root", &extent);
+#endif
while (1) {
if (handle->max_depth - handle->level == leaf_level) {
/* block is in this &extent */
if (retval)
return retval;
+#ifdef DEBUG_GOTO_EXTENTS
dbg_print_extent("next", &extent);
+#endif
if (blk == extent.e_lblk)
goto go_down;
if (blk > extent.e_lblk)
if (retval)
return retval;
+#ifdef DEBUG_GOTO_EXTENTS
dbg_print_extent("prev", &extent);
+#endif
go_down:
retval = ext2fs_extent_get(handle, EXT2_EXTENT_DOWN,
if (retval)
return retval;
+#ifdef DEBUG_GOTO_EXTENTS
dbg_print_extent("down", &extent);
+#endif
}
}
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);
}
/*
* Safe to call for any position in node; if not at the first entry,
* will simply return.
*/
-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;
}
if (!path->curr)
return EXT2_ET_NO_CURRENT_NODE;
+#ifdef DEBUG
+ printf("extent replace: %u ", handle->ino);
+ dbg_print_extent(0, extent);
+#endif
+
if (handle->level == handle->max_depth) {
ex = path->curr;
*
* handle will be left pointing at original record.
*/
-static errcode_t extent_node_split(ext2_extent_handle_t handle)
+errcode_t ext2fs_extent_node_split(ext2_extent_handle_t handle)
{
errcode_t retval = 0;
- blk_t new_node_pblk;
+ blk64_t new_node_pblk;
blk64_t new_node_start;
blk64_t orig_lblk;
blk64_t goal_blk = 0;
goto done;
goal_blk = extent.e_pblk;
- retval = extent_node_split(handle);
+ retval = ext2fs_extent_node_split(handle);
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 (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;
+ goal_blk = ext2fs_group_first_block2(handle->fs, group);
}
- retval = ext2fs_alloc_block(handle->fs, (blk_t) goal_blk, block_buf,
+ retval = ext2fs_alloc_block2(handle->fs, goal_blk, block_buf,
&new_node_pblk);
if (retval)
goto done;
#ifdef DEBUG
- printf("will copy to new node at block %lu\n", new_node_pblk);
+ printf("will copy to new node at block %lu\n",
+ (unsigned long) new_node_pblk);
#endif
/* Copy data into new block buffer */
new_node_start = ext2fs_le32_to_cpu(EXT_FIRST_INDEX(neweh)->ei_block);
/* ...and write the new node block out to disk. */
- retval = io_channel_write_blk(handle->fs->io, new_node_pblk, 1, block_buf);
+ retval = io_channel_write_blk64(handle->fs->io, new_node_pblk, 1,
+ block_buf);
if (retval)
goto done;
}
/* 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;
- retval = ext2fs_write_inode_full(handle->fs, handle->ino,
- handle->inode, EXT2_INODE_SIZE(handle->fs->super));
+ handle->inode->i_blocks += (handle->fs->blocksize *
+ EXT2FS_CLUSTER_RATIO(handle->fs)) / 512;
+ retval = ext2fs_write_inode(handle->fs, handle->ino,
+ handle->inode);
if (retval)
goto done;
if (!handle->path)
return EXT2_ET_NO_CURRENT_NODE;
+#ifdef DEBUG
+ printf("extent insert: %u ", handle->ino);
+ dbg_print_extent(0, extent);
+#endif
+
path = handle->path + handle->level;
if (path->entries >= path->max_entries) {
printf("node full (level %d) - splitting\n",
handle->level);
#endif
- retval = extent_node_split(handle);
+ retval = ext2fs_extent_node_split(handle);
if (retval)
return retval;
path = handle->path + handle->level;
int mapped = 1; /* logical is mapped? */
int orig_height;
int extent_uninit = 0;
+ int prev_uninit = 0;
+ int next_uninit = 0;
int new_uninit = 0;
int max_len = EXT_INIT_MAX_LEN;
+ int has_prev, has_next;
blk64_t orig_lblk;
struct extent_path *path;
- struct ext2fs_extent extent;
+ struct ext2fs_extent extent, next_extent, prev_extent;
struct ext2fs_extent newextent;
struct ext2_extent_info info;
EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
+#ifdef DEBUG
+ printf("set_bmap ino %u log %lld phys %lld flags %d\n",
+ handle->ino, logical, physical, flags);
+#endif
+
if (!(handle->fs->flags & EXT2_FLAG_RW))
return EXT2_ET_RO_FILSYS;
orig_height = info.max_depth - info.curr_level;
orig_lblk = extent.e_lblk;
-again:
/* go to the logical spot we want to (re/un)map */
retval = ext2fs_extent_goto(handle, logical);
if (retval) {
/*
* This may be the extent *before* the requested logical,
* if it's currently unmapped.
+ *
+ * Get the previous and next leaf extents, if they are present.
*/
retval = ext2fs_extent_get(handle, EXT2_EXTENT_CURRENT, &extent);
if (retval)
goto done;
if (extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT)
extent_uninit = 1;
+ retval = ext2fs_extent_get(handle, EXT2_EXTENT_NEXT_LEAF, &next_extent);
+ if (retval) {
+ has_next = 0;
+ if (retval != EXT2_ET_EXTENT_NO_NEXT)
+ goto done;
+ } else {
+ dbg_print_extent("set_bmap: next_extent",
+ &next_extent);
+ has_next = 1;
+ if (next_extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT)
+ next_uninit = 1;
+ }
+ retval = ext2fs_extent_goto(handle, logical);
+ if (retval && retval != EXT2_ET_EXTENT_NOT_FOUND)
+ goto done;
+ retval = ext2fs_extent_get(handle, EXT2_EXTENT_PREV_LEAF, &prev_extent);
+ if (retval) {
+ has_prev = 0;
+ if (retval != EXT2_ET_EXTENT_NO_PREV)
+ goto done;
+ } else {
+ has_prev = 1;
+ dbg_print_extent("set_bmap: prev_extent",
+ &prev_extent);
+ if (prev_extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT)
+ prev_uninit = 1;
+ }
+ retval = ext2fs_extent_goto(handle, logical);
+ if (retval && retval != EXT2_ET_EXTENT_NOT_FOUND)
+ goto done;
/* check if already pointing to the requested physical */
if (mapped && (new_uninit == extent_uninit) &&
((int) extent.e_len < max_len-1)) {
extent.e_len++;
retval = ext2fs_extent_replace(handle, 0, &extent);
+ } else if ((logical == extent.e_lblk - 1) &&
+ (physical == extent.e_pblk - 1) &&
+ (new_uninit == extent_uninit) &&
+ ((int) extent.e_len < max_len - 1)) {
+ extent.e_len++;
+ extent.e_lblk--;
+ extent.e_pblk--;
+ retval = ext2fs_extent_replace(handle, 0, &extent);
+ } else if (has_next &&
+ (logical == next_extent.e_lblk - 1) &&
+ (physical == next_extent.e_pblk - 1) &&
+ (new_uninit == next_uninit) &&
+ ((int) next_extent.e_len < max_len - 1)) {
+ retval = ext2fs_extent_get(handle,
+ EXT2_EXTENT_NEXT_LEAF,
+ &next_extent);
+ if (retval)
+ goto done;
+ next_extent.e_len++;
+ next_extent.e_lblk--;
+ next_extent.e_pblk--;
+ retval = ext2fs_extent_replace(handle, 0, &next_extent);
} else if (logical < extent.e_lblk)
retval = ext2fs_extent_insert(handle, 0, &newextent);
else
#ifdef DEBUG
printf("(re/un)mapping last block in extent\n");
#endif
- /* Make sure insert works before replacing old extent */
if (physical) {
- retval = ext2fs_extent_insert(handle,
- EXT2_EXTENT_INSERT_AFTER, &newextent);
+ if (has_next &&
+ (logical == (next_extent.e_lblk - 1)) &&
+ (physical == (next_extent.e_pblk - 1)) &&
+ (new_uninit == next_uninit) &&
+ ((int) next_extent.e_len < max_len - 1)) {
+ retval = ext2fs_extent_get(handle,
+ EXT2_EXTENT_NEXT_LEAF, &next_extent);
+ if (retval)
+ goto done;
+ next_extent.e_len++;
+ next_extent.e_lblk--;
+ next_extent.e_pblk--;
+ retval = ext2fs_extent_replace(handle, 0,
+ &next_extent);
+ if (retval)
+ goto done;
+ retval = ext2fs_extent_fix_parents(handle);
+ if (retval)
+ goto done;
+ } else
+ retval = ext2fs_extent_insert(handle,
+ EXT2_EXTENT_INSERT_AFTER, &newextent);
+ if (retval)
+ goto done;
+ /* Now pointing at inserted extent; move back to prev */
+ retval = ext2fs_extent_get(handle,
+ EXT2_EXTENT_PREV_LEAF,
+ &extent);
if (retval)
goto done;
}
#ifdef DEBUG
printf("(re/un)mapping first block in extent\n");
#endif
+ if (physical) {
+ if (has_prev &&
+ (logical == (prev_extent.e_lblk +
+ prev_extent.e_len)) &&
+ (physical == (prev_extent.e_pblk +
+ prev_extent.e_len)) &&
+ (new_uninit == prev_uninit) &&
+ ((int) prev_extent.e_len < max_len-1)) {
+ retval = ext2fs_extent_get(handle,
+ EXT2_EXTENT_PREV_LEAF, &prev_extent);
+ if (retval)
+ goto done;
+ prev_extent.e_len++;
+ retval = ext2fs_extent_replace(handle, 0,
+ &prev_extent);
+ } else
+ retval = ext2fs_extent_insert(handle,
+ 0, &newextent);
+ if (retval)
+ goto done;
+ retval = ext2fs_extent_get(handle,
+ EXT2_EXTENT_NEXT_LEAF,
+ &extent);
+ if (retval)
+ goto done;
+ }
extent.e_pblk++;
extent.e_lblk++;
extent.e_len--;
retval = ext2fs_extent_replace(handle, 0, &extent);
if (retval)
goto done;
- if (physical) {
- /*
- * We've removed the old block, now rely on
- * the optimized hueristics for adding a new
- * mapping with appropriate merging if necessary.
- */
- goto again;
- } else {
- retval = ext2fs_extent_fix_parents(handle);
- if (retval)
- goto done;
- }
+ retval = ext2fs_extent_fix_parents(handle);
+ if (retval)
+ goto done;
} else {
__u32 orig_length;
/* 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;
}
if (!handle->path)
return EXT2_ET_NO_CURRENT_NODE;
+#ifdef DEBUG
+ {
+ struct ext2fs_extent extent;
+
+ retval = ext2fs_extent_get(handle, EXT2_EXTENT_CURRENT,
+ &extent);
+ if (retval == 0) {
+ printf("extent delete %u ", handle->ino);
+ dbg_print_extent(0, &extent);
+ }
+ }
+#endif
+
path = handle->path + handle->level;
if (!path->curr)
return EXT2_ET_NO_CURRENT_NODE;
return retval;
retval = ext2fs_extent_delete(handle, flags);
- handle->inode->i_blocks -= handle->fs->blocksize / 512;
- retval = ext2fs_write_inode_full(handle->fs,
- handle->ino, handle->inode,
- EXT2_INODE_SIZE(handle->fs->super));
- ext2fs_block_alloc_stats(handle->fs, extent.e_pblk, -1);
+ 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,
+ extent.e_pblk, -1);
}
} else {
eh = (struct ext3_extent_header *) path->buf;
}
#ifdef DEBUG
-
-#include "ss/ss.h"
-
-#include "debugfs.h"
-
/*
- * Hook in new commands into debugfs
+ * Override debugfs's prompt
*/
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)
-{
- if (common_args_process(argc, argv, min_argc, max_argc, cmd,
- usage, flags))
- return 1;
-
- if (!current_handle) {
- com_err(cmd, 0, "Extent handle not open");
- return 1;
- }
- return 0;
-}
-
-void do_inode(int argc, char *argv[])
-{
- 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;
-}
-
-void generic_goto_node(char *cmd_name, int op)
-{
- 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;
- }
- 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;
- }
- 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;
-
- 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);
-}
-
-void do_set_bmap(int argc, char **argv)
-{
- 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;
- }
-
- 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);
-}
-
-void do_print_all(int argc, char **argv)
-{
- const char *usage = "[--leaf-only|--reverse|--reverse-leaf]";
- 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;
- }
- dbg_print_extent(0, &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);
-
- 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);
-}
-
-void do_goto_block(int argc, char **argv)
-{
- struct ext2fs_extent extent;
- errcode_t retval;
- int op = EXT2_EXTENT_NEXT_LEAF;
- blk_t blk;
- int level = 0;
-
- 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)
- if (strtoblk(argv[0], argv[2], &level))
- return;
-
- retval = extent_goto(current_handle, level, (blk64_t) blk);
-
- if (retval) {
- com_err(argv[0], retval, "while trying to go to block %lu, level %d",
- blk, level);
- return;
- }
-
- generic_goto_node(argv[0], EXT2_EXTENT_CURRENT);
-}
#endif