[thirdparty/e2fsprogs.git] / debugfs / extent_inode.c

/*
 * extent_inode.c --- direct extent tree manipulation
 *
 * Copyright (C) 2012 Theodore Ts'o.  This file may be redistributed
 * under the terms of the GNU Public License.
 */

#include "config.h"
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <time.h>
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
#include <sys/types.h>
#ifdef HAVE_GETOPT_H
#include <getopt.h>
#else
extern int optind;
extern char *optarg;
#endif

#include "debugfs.h"

static ext2_ino_t	current_ino;
static ext2_extent_handle_t current_handle;

static void dbg_print_extent(char *desc, struct ext2fs_extent *extent)
{
	if (desc)
		printf("%s: ", desc);
	printf("extent: lblk %llu--%llu, len %u, pblk %llu, flags: ",
	       (unsigned long long) extent->e_lblk,
	       (unsigned long long) extent->e_lblk + extent->e_len - 1,
	       extent->e_len, (unsigned long long) extent->e_pblk);
	if (extent->e_flags & EXT2_EXTENT_FLAGS_LEAF)
		fputs("LEAF ", stdout);
	if (extent->e_flags & EXT2_EXTENT_FLAGS_UNINIT)
		fputs("UNINIT ", stdout);
	if (extent->e_flags & EXT2_EXTENT_FLAGS_SECOND_VISIT)
		fputs("2ND_VISIT ", stdout);
	if (!extent->e_flags)
		fputs("(none)", stdout);
	fputc('\n', stdout);

}

static int common_extent_args_process(int argc, ss_argv_t 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;
}

static char *orig_prompt, *extent_prompt;

void do_extent_open(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
		    void *infop EXT2FS_ATTR((unused)))
{
	ext2_ino_t	inode;
	int		ret;
	errcode_t	retval;
	char		*cp;

	if (check_fs_open(argv[0]))
		return;

	if (argc == 1) {
		if (current_ino)
			printf("Current inode is %u\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, &current_handle);
	if (retval) {
		com_err(argv[1], retval, "while opening extent handle");
		return;
	}

	current_ino = inode;

	orig_prompt = ss_get_prompt(sci_idx);
	extent_prompt = malloc(strlen(orig_prompt) + 32);
	if (extent_prompt == NULL) {
		com_err(argv[1], retval, "out of memory");
		return;
	}

	strcpy(extent_prompt, orig_prompt);
	cp = strchr(extent_prompt, ':');
	if (cp)
		*cp = 0;
	sprintf(extent_prompt + strlen(extent_prompt), " (extent ino %u): ",
		current_ino);
	ss_add_request_table(sci_idx, &extent_cmds, 1, &ret);
	ss_set_prompt(sci_idx, extent_prompt);
	return;
}

void do_extent_close(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
		     void *infop EXT2FS_ATTR((unused)))
{
	int ret;

	if (common_args_process(argc, argv, 1, 1,
				"extent_close", "", 0))
		return;

	if (!current_handle) {
		com_err(argv[0], 0, "Extent handle not open");
		return;
	}

	ext2fs_extent_free(current_handle);
	current_handle = NULL;
	current_ino = 0;
	ss_delete_request_table(sci_idx, &extent_cmds, &ret);
	ss_set_prompt(sci_idx, orig_prompt);
	free(extent_prompt);
	extent_prompt = NULL;
}

static void generic_goto_node(const char *my_name, int argc,
			      ss_argv_t argv, int op)
{
	struct ext2fs_extent	extent;
	errcode_t		retval;

	if (my_name && common_args_process(argc, argv, 1, 1,
					   my_name, "", 0))
		return;

	if (!current_handle) {
		com_err(argv[0], 0, "Extent handle not open");
		return;
	}

	retval = ext2fs_extent_get(current_handle, op, &extent);
	if (retval) {
		com_err(argv[0], retval, 0);
		return;
	}
	dbg_print_extent(0, &extent);
}

void do_current_node(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
		     void *infop EXT2FS_ATTR((unused)))
{
	generic_goto_node("current_node", argc, argv, EXT2_EXTENT_CURRENT);
}

void do_root_node(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
		  void *infop EXT2FS_ATTR((unused)))
{
	generic_goto_node("root_node", argc, argv, EXT2_EXTENT_ROOT);
}

void do_last_leaf(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
		  void *infop EXT2FS_ATTR((unused)))
{
	generic_goto_node("last_leaf", argc, argv, EXT2_EXTENT_LAST_LEAF);
}

void do_first_sib(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
		  void *infop EXT2FS_ATTR((unused)))
{
	generic_goto_node("first_sib", argc, argv, EXT2_EXTENT_FIRST_SIB);
}

void do_last_sib(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
		 void *infop EXT2FS_ATTR((unused)))
{
	generic_goto_node("next_sib", argc, argv, EXT2_EXTENT_LAST_SIB);
}

void do_next_sib(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
		 void *infop EXT2FS_ATTR((unused)))
{
	generic_goto_node("next_sib", argc, argv, EXT2_EXTENT_NEXT_SIB);
}

void do_prev_sib(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
		 void *infop EXT2FS_ATTR((unused)))
{
	generic_goto_node("prev_sib", argc, argv, EXT2_EXTENT_PREV_SIB);
}

void do_next_leaf(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
		 void *infop EXT2FS_ATTR((unused)))
{
	generic_goto_node("next_leaf", argc, argv, EXT2_EXTENT_NEXT_LEAF);
}

void do_prev_leaf(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
		  void *infop EXT2FS_ATTR((unused)))
{
	generic_goto_node("prev_leaf", argc, argv, EXT2_EXTENT_PREV_LEAF);
}

void do_next(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
	     void *infop EXT2FS_ATTR((unused)))
{
	generic_goto_node("next", argc, argv, EXT2_EXTENT_NEXT);
}

void do_prev(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
	     void *infop EXT2FS_ATTR((unused)))
{
	generic_goto_node("prev", argc, argv, EXT2_EXTENT_PREV);
}

void do_up(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
	   void *infop EXT2FS_ATTR((unused)))
{
	generic_goto_node("up", argc, argv, EXT2_EXTENT_UP);
}

void do_down(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
	     void *infop EXT2FS_ATTR((unused)))
{
	generic_goto_node("down", argc, argv, EXT2_EXTENT_DOWN);
}

void do_delete_node(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
		    void *infop EXT2FS_ATTR((unused)))
{
	struct ext2fs_extent extent;
	errcode_t	retval;

	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;
	}

	retval = ext2fs_extent_get(current_handle, EXT2_EXTENT_CURRENT,
				   &extent);
	if (retval)
		return;
	dbg_print_extent(0, &extent);
}

void do_replace_node(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
		     void *infop EXT2FS_ATTR((unused)))
{
	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;
	}

	err = strtoblk(argv[0], argv[1], "logical block", &extent.e_lblk);
	if (err)
		return;

	extent.e_len = parse_ulong(argv[2], argv[0], "length", &err);
	if (err)
		return;

	err = strtoblk(argv[0], argv[3], "physical block", &extent.e_pblk);
	if (err)
		return;

	retval = ext2fs_extent_replace(current_handle, 0, &extent);
	if (retval) {
		com_err(argv[0], retval, 0);
		return;
	}
	generic_goto_node(NULL, argc, argv, EXT2_EXTENT_CURRENT);
}

void do_split_node(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
		   void *infop EXT2FS_ATTR((unused)))
{
	errcode_t	retval;

	if (common_extent_args_process(argc, argv, 1, 1, "split_node",
				       "", CHECK_FS_RW | CHECK_FS_BITMAPS))
		return;

	retval = ext2fs_extent_node_split(current_handle);
	if (retval) {
		com_err(argv[0], retval, 0);
		return;
	}
	generic_goto_node(NULL, argc, argv, EXT2_EXTENT_CURRENT);
}

void do_insert_node(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
		    void *infop EXT2FS_ATTR((unused)))
{
	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;
	}

	err = strtoblk(cmd, argv[1], "logical block", &extent.e_lblk);
	if (err)
		return;

	extent.e_len = parse_ulong(argv[2], cmd, "length", &err);
	if (err)
		return;

	err = strtoblk(cmd, argv[3], "physical block", &extent.e_pblk);
	if (err)
		return;

	retval = ext2fs_extent_insert(current_handle, flags, &extent);
	if (retval) {
		com_err(cmd, retval, 0);
		return;
	}
	generic_goto_node(NULL, argc, argv, EXT2_EXTENT_CURRENT);
}

void do_set_bmap(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
		 void *infop EXT2FS_ATTR((unused)))
{
	const char	*usage = "[--uninit] <lblk> <pblk>";
	struct ext2fs_extent extent;
	errcode_t	retval;
	blk64_t		logical;
	blk64_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;
	}

	err = strtoblk(cmd, argv[1], "logical block", &logical);
	if (err)
		return;

	err = strtoblk(cmd, argv[2], "physical block", &physical);
	if (err)
		return;

	retval = ext2fs_extent_set_bmap(current_handle, logical,
					physical, flags);
	if (retval) {
		com_err(cmd, retval, 0);
		return;
	}

	retval = ext2fs_extent_get(current_handle, EXT2_EXTENT_CURRENT,
				   &extent);
	if (retval)
		return;
	dbg_print_extent(0, &extent);
}

void do_print_all(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
		  void *infop EXT2FS_ATTR((unused)))
{
	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_fix_parents(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
		    void *infop EXT2FS_ATTR((unused)))
{
	errcode_t		retval;

	if (common_extent_args_process(argc, argv, 1, 1, "fix_parents", "",
				       CHECK_FS_RW))
		return;

	retval = ext2fs_extent_fix_parents(current_handle);
	if (retval) {
		com_err(argv[0], retval, 0);
		return;
	}
}

void do_info(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
	     void *infop EXT2FS_ATTR((unused)))
{
	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",
	       (unsigned long long) info.max_lblk,
	       (unsigned long long) 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, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
		   void *infop EXT2FS_ATTR((unused)))
{
	errcode_t		retval;
	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], NULL, &blk))
		return;

	if (argc == 3) {
		level = parse_ulong(argv[2], argv[0], "level", &err);
		if (err)
			return;
	}

	retval = ext2fs_extent_goto2(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;
	}

	generic_goto_node(NULL, argc, argv, EXT2_EXTENT_CURRENT);
}
Commit	Line	Data
bee7b67c TT	1	/*
	2	* extent_inode.c --- direct extent tree manipulation
	3	*
	4	* Copyright (C) 2012 Theodore Ts'o. This file may be redistributed
	5	* under the terms of the GNU Public License.
	6	*/
	7
	8	#include "config.h"
	9	#include <stdio.h>
	10	#include <unistd.h>
	11	#include <stdlib.h>
	12	#include <ctype.h>
	13	#include <string.h>
	14	#include <time.h>
	15	#ifdef HAVE_ERRNO_H
	16	#include <errno.h>
	17	#endif
	18	#include <sys/types.h>
	19	#ifdef HAVE_GETOPT_H
	20	#include <getopt.h>
	21	#else
	22	extern int optind;
	23	extern char *optarg;
	24	#endif
	25
	26	#include "debugfs.h"
	27
f404167d TT	28	static ext2_ino_t current_ino;
f404167d TT	29	static ext2_extent_handle_t current_handle;
bee7b67c TT	30
	31	static void dbg_print_extent(char desc, struct ext2fs_extent extent)
	32	{
	33	if (desc)
	34	printf("%s: ", desc);
	35	printf("extent: lblk %llu--%llu, len %u, pblk %llu, flags: ",
33b9a60c TT	36	(unsigned long long) extent->e_lblk,
	37	(unsigned long long) extent->e_lblk + extent->e_len - 1,
	38	extent->e_len, (unsigned long long) extent->e_pblk);
bee7b67c TT	39	if (extent->e_flags & EXT2_EXTENT_FLAGS_LEAF)
	40	fputs("LEAF ", stdout);
	41	if (extent->e_flags & EXT2_EXTENT_FLAGS_UNINIT)
	42	fputs("UNINIT ", stdout);
	43	if (extent->e_flags & EXT2_EXTENT_FLAGS_SECOND_VISIT)
	44	fputs("2ND_VISIT ", stdout);
	45	if (!extent->e_flags)
	46	fputs("(none)", stdout);
	47	fputc('\n', stdout);
	48
	49	}
	50
49125d40	51	static int common_extent_args_process(int argc, ss_argv_t argv, int min_argc,
9e85208e TT	52	int max_argc, const char *cmd,
9e85208e TT	53	const char *usage, int flags)
bee7b67c TT	54	{
	55	if (common_args_process(argc, argv, min_argc, max_argc, cmd,
	56	usage, flags))
	57	return 1;
	58
	59	if (!current_handle) {
	60	com_err(cmd, 0, "Extent handle not open");
	61	return 1;
	62	}
	63	return 0;
	64	}
	65
	66	static char orig_prompt, extent_prompt;
	67
49125d40	68	void do_extent_open(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	69	void *infop EXT2FS_ATTR((unused)))
bee7b67c	70	{
bee7b67c	71	ext2_ino_t inode;
e3507739	72	int ret;
bee7b67c TT	73	errcode_t retval;
	74	char *cp;
	75
	76	if (check_fs_open(argv[0]))
	77	return;
	78
	79	if (argc == 1) {
	80	if (current_ino)
c707fb6c	81	printf("Current inode is %u\n", current_ino);
bee7b67c TT	82	else
	83	printf("No current inode\n");
	84	return;
	85	}
	86
	87	if (common_inode_args_process(argc, argv, &inode, 0))
	88	return;
	89
	90	current_ino = 0;
	91
	92	retval = ext2fs_extent_open(current_fs, inode, &current_handle);
	93	if (retval) {
	94	com_err(argv[1], retval, "while opening extent handle");
	95	return;
	96	}
	97
	98	current_ino = inode;
	99
	100	orig_prompt = ss_get_prompt(sci_idx);
	101	extent_prompt = malloc(strlen(orig_prompt) + 32);
9f8d9a2c TS	102	if (extent_prompt == NULL) {
	103	com_err(argv[1], retval, "out of memory");
	104	return;
	105	}
	106
bee7b67c TT	107	strcpy(extent_prompt, orig_prompt);
	108	cp = strchr(extent_prompt, ':');
	109	if (cp)
	110	*cp = 0;
c707fb6c	111	sprintf(extent_prompt + strlen(extent_prompt), " (extent ino %u): ",
bee7b67c TT	112	current_ino);
	113	ss_add_request_table(sci_idx, &extent_cmds, 1, &ret);
	114	ss_set_prompt(sci_idx, extent_prompt);
	115	return;
	116	}
	117
49125d40	118	void do_extent_close(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	119	void *infop EXT2FS_ATTR((unused)))
bee7b67c TT	120	{
	121	int ret;
	122
9e85208e TT	123	if (common_args_process(argc, argv, 1, 1,
9e85208e TT	124	"extent_close", "", 0))
bee7b67c TT	125	return;
	126
	127	if (!current_handle) {
	128	com_err(argv[0], 0, "Extent handle not open");
	129	return;
	130	}
	131
	132	ext2fs_extent_free(current_handle);
	133	current_handle = NULL;
	134	current_ino = 0;
	135	ss_delete_request_table(sci_idx, &extent_cmds, &ret);
	136	ss_set_prompt(sci_idx, orig_prompt);
	137	free(extent_prompt);
	138	extent_prompt = NULL;
	139	}
	140
9e85208e	141	static void generic_goto_node(const char *my_name, int argc,
49125d40	142	ss_argv_t argv, int op)
bee7b67c TT	143	{
	144	struct ext2fs_extent extent;
	145	errcode_t retval;
	146
9e85208e TT	147	if (my_name && common_args_process(argc, argv, 1, 1,
9e85208e TT	148	my_name, "", 0))
bee7b67c TT	149	return;
	150
	151	if (!current_handle) {
9e85208e	152	com_err(argv[0], 0, "Extent handle not open");
bee7b67c TT	153	return;
	154	}
	155
	156	retval = ext2fs_extent_get(current_handle, op, &extent);
	157	if (retval) {
9e85208e	158	com_err(argv[0], retval, 0);
bee7b67c TT	159	return;
	160	}
	161	dbg_print_extent(0, &extent);
	162	}
	163
49125d40	164	void do_current_node(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	165	void *infop EXT2FS_ATTR((unused)))
bee7b67c	166	{
9e85208e	167	generic_goto_node("current_node", argc, argv, EXT2_EXTENT_CURRENT);
bee7b67c TT	168	}
bee7b67c TT	169
49125d40	170	void do_root_node(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	171	void *infop EXT2FS_ATTR((unused)))
bee7b67c	172	{
9e85208e	173	generic_goto_node("root_node", argc, argv, EXT2_EXTENT_ROOT);
bee7b67c TT	174	}
bee7b67c TT	175
49125d40	176	void do_last_leaf(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	177	void *infop EXT2FS_ATTR((unused)))
bee7b67c	178	{
9e85208e	179	generic_goto_node("last_leaf", argc, argv, EXT2_EXTENT_LAST_LEAF);
bee7b67c TT	180	}
bee7b67c TT	181
49125d40	182	void do_first_sib(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	183	void *infop EXT2FS_ATTR((unused)))
bee7b67c	184	{
9e85208e	185	generic_goto_node("first_sib", argc, argv, EXT2_EXTENT_FIRST_SIB);
bee7b67c TT	186	}
bee7b67c TT	187
49125d40	188	void do_last_sib(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	189	void *infop EXT2FS_ATTR((unused)))
bee7b67c	190	{
9e85208e	191	generic_goto_node("next_sib", argc, argv, EXT2_EXTENT_LAST_SIB);
bee7b67c TT	192	}
bee7b67c TT	193
49125d40	194	void do_next_sib(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	195	void *infop EXT2FS_ATTR((unused)))
bee7b67c	196	{
9e85208e	197	generic_goto_node("next_sib", argc, argv, EXT2_EXTENT_NEXT_SIB);
bee7b67c TT	198	}
bee7b67c TT	199
49125d40	200	void do_prev_sib(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	201	void *infop EXT2FS_ATTR((unused)))
bee7b67c	202	{
9e85208e	203	generic_goto_node("prev_sib", argc, argv, EXT2_EXTENT_PREV_SIB);
bee7b67c TT	204	}
bee7b67c TT	205
49125d40	206	void do_next_leaf(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	207	void *infop EXT2FS_ATTR((unused)))
bee7b67c	208	{
9e85208e	209	generic_goto_node("next_leaf", argc, argv, EXT2_EXTENT_NEXT_LEAF);
bee7b67c TT	210	}
bee7b67c TT	211
49125d40	212	void do_prev_leaf(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	213	void *infop EXT2FS_ATTR((unused)))
bee7b67c	214	{
9e85208e	215	generic_goto_node("prev_leaf", argc, argv, EXT2_EXTENT_PREV_LEAF);
bee7b67c TT	216	}
bee7b67c TT	217
49125d40	218	void do_next(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	219	void *infop EXT2FS_ATTR((unused)))
bee7b67c	220	{
9e85208e	221	generic_goto_node("next", argc, argv, EXT2_EXTENT_NEXT);
bee7b67c TT	222	}
bee7b67c TT	223
49125d40	224	void do_prev(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	225	void *infop EXT2FS_ATTR((unused)))
bee7b67c	226	{
9e85208e	227	generic_goto_node("prev", argc, argv, EXT2_EXTENT_PREV);
bee7b67c TT	228	}
bee7b67c TT	229
49125d40	230	void do_up(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	231	void *infop EXT2FS_ATTR((unused)))
bee7b67c	232	{
9e85208e	233	generic_goto_node("up", argc, argv, EXT2_EXTENT_UP);
bee7b67c TT	234	}
bee7b67c TT	235
49125d40	236	void do_down(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	237	void *infop EXT2FS_ATTR((unused)))
bee7b67c	238	{
9e85208e	239	generic_goto_node("down", argc, argv, EXT2_EXTENT_DOWN);
bee7b67c TT	240	}
bee7b67c TT	241
49125d40	242	void do_delete_node(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	243	void *infop EXT2FS_ATTR((unused)))
bee7b67c TT	244	{
	245	struct ext2fs_extent extent;
	246	errcode_t retval;
bee7b67c TT	247
	248	if (common_extent_args_process(argc, argv, 1, 1, "delete_node",
	249	"", CHECK_FS_RW \| CHECK_FS_BITMAPS))
	250	return;
	251
	252	retval = ext2fs_extent_delete(current_handle, 0);
	253	if (retval) {
	254	com_err(argv[0], retval, 0);
	255	return;
	256	}
	257
	258	retval = ext2fs_extent_get(current_handle, EXT2_EXTENT_CURRENT,
	259	&extent);
	260	if (retval)
	261	return;
	262	dbg_print_extent(0, &extent);
	263	}
	264
49125d40	265	void do_replace_node(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	266	void *infop EXT2FS_ATTR((unused)))
bee7b67c TT	267	{
	268	const char *usage = "[--uninit] <lblk> <len> <pblk>";
	269	errcode_t retval;
	270	struct ext2fs_extent extent;
	271	int err;
	272
	273	if (common_extent_args_process(argc, argv, 3, 5, "replace_node",
	274	usage, CHECK_FS_RW \| CHECK_FS_BITMAPS))
	275	return;
	276
	277	extent.e_flags = 0;
	278
	279	if (!strcmp(argv[1], "--uninit")) {
	280	argc--;
	281	argv++;
	282	extent.e_flags \|= EXT2_EXTENT_FLAGS_UNINIT;
	283	}
	284
	285	if (argc != 4) {
	286	fprintf(stderr, "Usage: %s %s\n", argv[0], usage);
	287	return;
	288	}
	289
a25fffae	290	err = strtoblk(argv[0], argv[1], "logical block", &extent.e_lblk);
bee7b67c TT	291	if (err)
	292	return;
	293
a25fffae	294	extent.e_len = parse_ulong(argv[2], argv[0], "length", &err);
bee7b67c TT	295	if (err)
	296	return;
	297
a25fffae	298	err = strtoblk(argv[0], argv[3], "physical block", &extent.e_pblk);
bee7b67c TT	299	if (err)
	300	return;
	301
	302	retval = ext2fs_extent_replace(current_handle, 0, &extent);
	303	if (retval) {
	304	com_err(argv[0], retval, 0);
	305	return;
	306	}
16b1fcf8	307	generic_goto_node(NULL, argc, argv, EXT2_EXTENT_CURRENT);
bee7b67c TT	308	}
bee7b67c TT	309
49125d40	310	void do_split_node(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	311	void *infop EXT2FS_ATTR((unused)))
bee7b67c TT	312	{
bee7b67c TT	313	errcode_t retval;
bee7b67c TT	314
	315	if (common_extent_args_process(argc, argv, 1, 1, "split_node",
	316	"", CHECK_FS_RW \| CHECK_FS_BITMAPS))
	317	return;
	318
	319	retval = ext2fs_extent_node_split(current_handle);
	320	if (retval) {
	321	com_err(argv[0], retval, 0);
	322	return;
	323	}
16b1fcf8	324	generic_goto_node(NULL, argc, argv, EXT2_EXTENT_CURRENT);
bee7b67c TT	325	}
bee7b67c TT	326
49125d40	327	void do_insert_node(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	328	void *infop EXT2FS_ATTR((unused)))
bee7b67c TT	329	{
	330	const char *usage = "[--after] [--uninit] <lblk> <len> <pblk>";
	331	errcode_t retval;
	332	struct ext2fs_extent extent;
	333	char *cmd;
	334	int err;
	335	int flags = 0;
	336
	337	if (common_extent_args_process(argc, argv, 3, 6, "insert_node",
	338	usage, CHECK_FS_RW \| CHECK_FS_BITMAPS))
	339	return;
	340
	341	cmd = argv[0];
	342
	343	extent.e_flags = 0;
	344
	345	while (argc > 2) {
	346	if (!strcmp(argv[1], "--after")) {
	347	argc--;
	348	argv++;
	349	flags \|= EXT2_EXTENT_INSERT_AFTER;
	350	continue;
	351	}
	352	if (!strcmp(argv[1], "--uninit")) {
	353	argc--;
	354	argv++;
	355	extent.e_flags \|= EXT2_EXTENT_FLAGS_UNINIT;
	356	continue;
	357	}
	358	break;
	359	}
	360
	361	if (argc != 4) {
	362	fprintf(stderr, "usage: %s %s\n", cmd, usage);
	363	return;
	364	}
	365
a25fffae	366	err = strtoblk(cmd, argv[1], "logical block", &extent.e_lblk);
bee7b67c TT	367	if (err)
	368	return;
	369
a25fffae	370	extent.e_len = parse_ulong(argv[2], cmd, "length", &err);
bee7b67c TT	371	if (err)
	372	return;
	373
a25fffae	374	err = strtoblk(cmd, argv[3], "physical block", &extent.e_pblk);
bee7b67c TT	375	if (err)
	376	return;
	377
	378	retval = ext2fs_extent_insert(current_handle, flags, &extent);
	379	if (retval) {
	380	com_err(cmd, retval, 0);
	381	return;
	382	}
16b1fcf8	383	generic_goto_node(NULL, argc, argv, EXT2_EXTENT_CURRENT);
bee7b67c TT	384	}
bee7b67c TT	385
49125d40	386	void do_set_bmap(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	387	void *infop EXT2FS_ATTR((unused)))
bee7b67c TT	388	{
	389	const char *usage = "[--uninit] <lblk> <pblk>";
	390	struct ext2fs_extent extent;
	391	errcode_t retval;
fe56188b DW	392	blk64_t logical;
fe56188b DW	393	blk64_t physical;
bee7b67c TT	394	char *cmd = argv[0];
	395	int flags = 0;
	396	int err;
	397
	398	if (common_extent_args_process(argc, argv, 3, 5, "set_bmap",
	399	usage, CHECK_FS_RW \| CHECK_FS_BITMAPS))
	400	return;
	401
	402	if (argc > 2 && !strcmp(argv[1], "--uninit")) {
	403	argc--;
	404	argv++;
	405	flags \|= EXT2_EXTENT_SET_BMAP_UNINIT;
	406	}
	407
	408	if (argc != 3) {
	409	fprintf(stderr, "Usage: %s %s\n", cmd, usage);
	410	return;
	411	}
	412
a25fffae	413	err = strtoblk(cmd, argv[1], "logical block", &logical);
bee7b67c TT	414	if (err)
	415	return;
	416
a25fffae	417	err = strtoblk(cmd, argv[2], "physical block", &physical);
bee7b67c TT	418	if (err)
	419	return;
	420
	421	retval = ext2fs_extent_set_bmap(current_handle, logical,
fe56188b	422	physical, flags);
bee7b67c TT	423	if (retval) {
	424	com_err(cmd, retval, 0);
	425	return;
	426	}
	427
	428	retval = ext2fs_extent_get(current_handle, EXT2_EXTENT_CURRENT,
	429	&extent);
	430	if (retval)
	431	return;
	432	dbg_print_extent(0, &extent);
	433	}
	434
49125d40	435	void do_print_all(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	436	void *infop EXT2FS_ATTR((unused)))
bee7b67c TT	437	{
	438	const char *usage = "[--leaf-only\|--reverse\|--reverse-leaf]";
	439	struct ext2fs_extent extent;
	440	errcode_t retval;
	441	errcode_t end_err = EXT2_ET_EXTENT_NO_NEXT;
	442	int op = EXT2_EXTENT_NEXT;
	443	int first_op = EXT2_EXTENT_ROOT;
	444
	445
	446	if (common_extent_args_process(argc, argv, 1, 2, "print_all",
	447	usage, 0))
	448	return;
	449
	450	if (argc == 2) {
	451	if (!strcmp(argv[1], "--leaf-only"))
	452	op = EXT2_EXTENT_NEXT_LEAF;
	453	else if (!strcmp(argv[1], "--reverse")) {
	454	op = EXT2_EXTENT_PREV;
	455	first_op = EXT2_EXTENT_LAST_LEAF;
	456	end_err = EXT2_ET_EXTENT_NO_PREV;
	457	} else if (!strcmp(argv[1], "--reverse-leaf")) {
	458	op = EXT2_EXTENT_PREV_LEAF;
	459	first_op = EXT2_EXTENT_LAST_LEAF;
	460	end_err = EXT2_ET_EXTENT_NO_PREV;
	461	} else {
	462	fprintf(stderr, "Usage: %s %s\n", argv[0], usage);
	463	return;
	464	}
	465	}
	466
	467	retval = ext2fs_extent_get(current_handle, first_op, &extent);
	468	if (retval) {
	469	com_err(argv[0], retval, 0);
	470	return;
	471	}
	472	dbg_print_extent(0, &extent);
	473
	474	while (1) {
	475	retval = ext2fs_extent_get(current_handle, op, &extent);
	476	if (retval == end_err)
	477	break;
	478
	479	if (retval) {
	480	com_err(argv[0], retval, 0);
	481	return;
	482	}
	483	dbg_print_extent(0, &extent);
	484	}
	485	}
	486
49125d40	487	void do_fix_parents(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	488	void *infop EXT2FS_ATTR((unused)))
bee7b67c	489	{
bee7b67c TT	490	errcode_t retval;
	491
	492	if (common_extent_args_process(argc, argv, 1, 1, "fix_parents", "",
	493	CHECK_FS_RW))
	494	return;
	495
	496	retval = ext2fs_extent_fix_parents(current_handle);
	497	if (retval) {
	498	com_err(argv[0], retval, 0);
	499	return;
	500	}
	501	}
	502
49125d40	503	void do_info(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	504	void *infop EXT2FS_ATTR((unused)))
bee7b67c TT	505	{
	506	struct ext2fs_extent extent;
	507	struct ext2_extent_info info;
	508	errcode_t retval;
	509
	510	if (common_extent_args_process(argc, argv, 1, 1, "info", "", 0))
	511	return;
	512
	513	retval = ext2fs_extent_get_info(current_handle, &info);
	514	if (retval) {
	515	com_err(argv[0], retval, 0);
	516	return;
	517	}
	518
	519	retval = ext2fs_extent_get(current_handle,
	520	EXT2_EXTENT_CURRENT, &extent);
	521	if (retval) {
	522	com_err(argv[0], retval, 0);
	523	return;
	524	}
	525
	526	dbg_print_extent(0, &extent);
	527
	528	printf("Current handle location: %d/%d (max: %d, bytes %d), level %d/%d\n",
	529	info.curr_entry, info.num_entries, info.max_entries,
	530	info.bytes_avail, info.curr_level, info.max_depth);
33b9a60c TT	531	printf("\tmax lblk: %llu, max pblk: %llu\n",
	532	(unsigned long long) info.max_lblk,
	533	(unsigned long long) info.max_pblk);
bee7b67c TT	534	printf("\tmax_len: %u, max_uninit_len: %u\n", info.max_len,
	535	info.max_uninit_len);
	536	}
	537
49125d40	538	void do_goto_block(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b	539	void *infop EXT2FS_ATTR((unused)))
bee7b67c	540	{
bee7b67c	541	errcode_t retval;
bee7b67c TT	542	blk64_t blk;
	543	int level = 0, err;
	544
	545	if (common_extent_args_process(argc, argv, 2, 3, "goto_block",
	546	"block [level]", 0))
	547	return;
	548
a25fffae	549	if (strtoblk(argv[0], argv[1], NULL, &blk))
bee7b67c TT	550	return;
	551
	552	if (argc == 3) {
	553	level = parse_ulong(argv[2], argv[0], "level", &err);
	554	if (err)
	555	return;
	556	}
	557
	558	retval = ext2fs_extent_goto2(current_handle, level, (blk64_t) blk);
	559
	560	if (retval) {
	561	com_err(argv[0], retval,
	562	"while trying to go to block %llu, level %d",
	563	(unsigned long long) blk, level);
	564	return;
	565	}
	566
9e85208e	567	generic_goto_node(NULL, argc, argv, EXT2_EXTENT_CURRENT);
bee7b67c	568	}