2 * extent.c --- routines to implement extents support
4 * Copyright (C) 2007 Theodore Ts'o.
7 * This file may be redistributed under the terms of the GNU Library
8 * General Public License, version 2.
24 #include <sys/types.h>
32 * Definitions to be dropped in lib/ext2fs/ext2fs.h
51 struct ext2_extent_handle {
55 struct ext2_inode *inode;
59 struct extent_path *path;
62 struct ext2_extent_path {
69 * Useful Debugging stuff
73 static void dbg_show_header(struct ext3_extent_header *eh)
75 printf("header: magic=%x entries=%u max=%u depth=%u generation=%u\n",
76 ext2fs_le16_to_cpu(eh->eh_magic),
77 ext2fs_le16_to_cpu(eh->eh_entries),
78 ext2fs_le16_to_cpu(eh->eh_max),
79 ext2fs_le16_to_cpu(eh->eh_depth),
80 ext2fs_le32_to_cpu(eh->eh_generation));
83 static void dbg_show_index(struct ext3_extent_idx *ix)
85 printf("index: block=%u leaf=%u leaf_hi=%u unused=%u\n",
86 ext2fs_le32_to_cpu(ix->ei_block),
87 ext2fs_le32_to_cpu(ix->ei_leaf),
88 ext2fs_le16_to_cpu(ix->ei_leaf_hi),
89 ext2fs_le16_to_cpu(ix->ei_unused));
92 static void dbg_show_extent(struct ext3_extent *ex)
94 printf("extent: block=%u-%u len=%u start=%u start_hi=%u\n",
95 ext2fs_le32_to_cpu(ex->ee_block),
96 ext2fs_le32_to_cpu(ex->ee_block) +
97 ext2fs_le16_to_cpu(ex->ee_len) - 1,
98 ext2fs_le16_to_cpu(ex->ee_len),
99 ext2fs_le32_to_cpu(ex->ee_start),
100 ext2fs_le16_to_cpu(ex->ee_start_hi));
103 static void dbg_print_extent(char *desc, struct ext2fs_extent *extent)
106 printf("%s: ", desc);
107 printf("extent: lblk %llu--%llu, len %u, pblk %llu, flags: ",
108 extent->e_lblk, extent->e_lblk + extent->e_len - 1,
109 extent->e_len, extent->e_pblk);
110 if (extent->e_flags & EXT2_EXTENT_FLAGS_LEAF)
111 fputs("LEAF ", stdout);
112 if (extent->e_flags & EXT2_EXTENT_FLAGS_UNINIT)
113 fputs("UNINIT ", stdout);
114 if (extent->e_flags & EXT2_EXTENT_FLAGS_SECOND_VISIT)
115 fputs("2ND_VISIT ", stdout);
116 if (!extent->e_flags)
117 fputs("(none)", stdout);
123 #define dbg_show_header(eh) do { } while (0)
124 #define dbg_show_index(ix) do { } while (0)
125 #define dbg_show_extent(ex) do { } while (0)
126 #define dbg_print_extent(desc, ex) do { } while (0)
130 * Verify the extent header as being sane
132 errcode_t ext2fs_extent_header_verify(void *ptr, int size)
134 int eh_max, entry_size;
135 struct ext3_extent_header *eh = ptr;
138 if (ext2fs_le16_to_cpu(eh->eh_magic) != EXT3_EXT_MAGIC)
139 return EXT2_ET_EXTENT_HEADER_BAD;
140 if (ext2fs_le16_to_cpu(eh->eh_entries) > ext2fs_le16_to_cpu(eh->eh_max))
141 return EXT2_ET_EXTENT_HEADER_BAD;
142 if (eh->eh_depth == 0)
143 entry_size = sizeof(struct ext3_extent);
145 entry_size = sizeof(struct ext3_extent_idx);
147 eh_max = (size - sizeof(*eh)) / entry_size;
148 /* Allow two extent-sized items at the end of the block, for
149 * ext4_extent_tail with checksum in the future. */
150 if ((ext2fs_le16_to_cpu(eh->eh_max) > eh_max) ||
151 (ext2fs_le16_to_cpu(eh->eh_max) < (eh_max - 2)))
152 return EXT2_ET_EXTENT_HEADER_BAD;
159 * Begin functions to handle an inode's extent information
161 extern void ext2fs_extent_free(ext2_extent_handle_t handle)
169 ext2fs_free_mem(&handle->inode);
171 for (i=1; i <= handle->max_depth; i++) {
172 if (handle->path[i].buf)
173 ext2fs_free_mem(&handle->path[i].buf);
175 ext2fs_free_mem(&handle->path);
177 ext2fs_free_mem(&handle);
180 extern errcode_t ext2fs_extent_open(ext2_filsys fs, ext2_ino_t ino,
181 ext2_extent_handle_t *ret_handle)
183 return ext2fs_extent_open2(fs, ino, NULL, ret_handle);
186 extern errcode_t ext2fs_extent_open2(ext2_filsys fs, ext2_ino_t ino,
187 struct ext2_inode *inode,
188 ext2_extent_handle_t *ret_handle)
190 struct ext2_extent_handle *handle;
193 struct ext3_extent_header *eh;
195 EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
198 if ((ino == 0) || (ino > fs->super->s_inodes_count))
199 return EXT2_ET_BAD_INODE_NUM;
201 retval = ext2fs_get_mem(sizeof(struct ext2_extent_handle), &handle);
204 memset(handle, 0, sizeof(struct ext2_extent_handle));
206 retval = ext2fs_get_mem(sizeof(struct ext2_inode), &handle->inode);
214 memcpy(handle->inode, inode, sizeof(struct ext2_inode));
217 retval = ext2fs_read_inode(fs, ino, handle->inode);
222 eh = (struct ext3_extent_header *) &handle->inode->i_block[0];
224 for (i=0; i < EXT2_N_BLOCKS; i++)
225 if (handle->inode->i_block[i])
227 if (i >= EXT2_N_BLOCKS) {
228 eh->eh_magic = ext2fs_cpu_to_le16(EXT3_EXT_MAGIC);
231 i = (sizeof(handle->inode->i_block) - sizeof(*eh)) /
232 sizeof(struct ext3_extent);
233 eh->eh_max = ext2fs_cpu_to_le16(i);
234 handle->inode->i_flags |= EXT4_EXTENTS_FL;
237 if (!(handle->inode->i_flags & EXT4_EXTENTS_FL)) {
238 retval = EXT2_ET_INODE_NOT_EXTENT;
242 retval = ext2fs_extent_header_verify(eh, sizeof(handle->inode->i_block));
246 handle->max_depth = ext2fs_le16_to_cpu(eh->eh_depth);
247 handle->type = ext2fs_le16_to_cpu(eh->eh_magic);
249 retval = ext2fs_get_mem(((handle->max_depth+1) *
250 sizeof(struct extent_path)),
252 memset(handle->path, 0,
253 (handle->max_depth+1) * sizeof(struct extent_path));
254 handle->path[0].buf = (char *) handle->inode->i_block;
256 handle->path[0].left = handle->path[0].entries =
257 ext2fs_le16_to_cpu(eh->eh_entries);
258 handle->path[0].max_entries = ext2fs_le16_to_cpu(eh->eh_max);
259 handle->path[0].curr = 0;
260 handle->path[0].end_blk =
261 ((((__u64) handle->inode->i_size_high << 32) +
262 handle->inode->i_size + (fs->blocksize - 1))
263 >> EXT2_BLOCK_SIZE_BITS(fs->super));
264 handle->path[0].visit_num = 1;
266 handle->magic = EXT2_ET_MAGIC_EXTENT_HANDLE;
268 *ret_handle = handle;
272 ext2fs_extent_free(handle);
277 * This function is responsible for (optionally) moving through the
278 * extent tree and then returning the current extent
280 errcode_t ext2fs_extent_get(ext2_extent_handle_t handle,
281 int flags, struct ext2fs_extent *extent)
283 struct extent_path *path, *newpath;
284 struct ext3_extent_header *eh;
285 struct ext3_extent_idx *ix = 0;
286 struct ext3_extent *ex;
292 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
295 return EXT2_ET_NO_CURRENT_NODE;
297 orig_op = op = flags & EXT2_EXTENT_MOVE_MASK;
300 path = handle->path + handle->level;
301 if ((orig_op == EXT2_EXTENT_NEXT) ||
302 (orig_op == EXT2_EXTENT_NEXT_LEAF)) {
303 if (handle->level < handle->max_depth) {
305 if (path->visit_num == 0) {
307 op = EXT2_EXTENT_DOWN;
308 } else if (path->left > 0)
309 op = EXT2_EXTENT_NEXT_SIB;
310 else if (handle->level > 0)
313 return EXT2_ET_EXTENT_NO_NEXT;
317 op = EXT2_EXTENT_NEXT_SIB;
318 else if (handle->level > 0)
321 return EXT2_ET_EXTENT_NO_NEXT;
323 if (op != EXT2_EXTENT_NEXT_SIB) {
324 #ifdef DEBUG_GET_EXTENT
325 printf("<<<< OP = %s\n",
326 (op == EXT2_EXTENT_DOWN) ? "down" :
327 ((op == EXT2_EXTENT_UP) ? "up" : "unknown"));
332 if ((orig_op == EXT2_EXTENT_PREV) ||
333 (orig_op == EXT2_EXTENT_PREV_LEAF)) {
334 if (handle->level < handle->max_depth) {
336 if (path->visit_num > 0 ) {
337 /* path->visit_num = 0; */
338 op = EXT2_EXTENT_DOWN_AND_LAST;
339 } else if (path->left < path->entries-1)
340 op = EXT2_EXTENT_PREV_SIB;
341 else if (handle->level > 0)
344 return EXT2_ET_EXTENT_NO_PREV;
347 if (path->left < path->entries-1)
348 op = EXT2_EXTENT_PREV_SIB;
349 else if (handle->level > 0)
352 return EXT2_ET_EXTENT_NO_PREV;
354 if (op != EXT2_EXTENT_PREV_SIB) {
355 #ifdef DEBUG_GET_EXTENT
356 printf("<<<< OP = %s\n",
357 (op == EXT2_EXTENT_DOWN_AND_LAST) ? "down/last" :
358 ((op == EXT2_EXTENT_UP) ? "up" : "unknown"));
363 if (orig_op == EXT2_EXTENT_LAST_LEAF) {
364 if ((handle->level < handle->max_depth) &&
366 op = EXT2_EXTENT_DOWN;
368 op = EXT2_EXTENT_LAST_SIB;
369 #ifdef DEBUG_GET_EXTENT
370 printf("<<<< OP = %s\n",
371 (op == EXT2_EXTENT_DOWN) ? "down" : "last_sib");
376 case EXT2_EXTENT_CURRENT:
379 case EXT2_EXTENT_ROOT:
381 path = handle->path + handle->level;
382 case EXT2_EXTENT_FIRST_SIB:
383 path->left = path->entries;
385 case EXT2_EXTENT_NEXT_SIB:
387 return EXT2_ET_EXTENT_NO_NEXT;
392 eh = (struct ext3_extent_header *) path->buf;
393 ix = EXT_FIRST_INDEX(eh);
399 case EXT2_EXTENT_PREV_SIB:
401 path->left+1 >= path->entries)
402 return EXT2_ET_EXTENT_NO_PREV;
407 if (handle->level < handle->max_depth)
410 case EXT2_EXTENT_LAST_SIB:
411 eh = (struct ext3_extent_header *) path->buf;
412 path->curr = EXT_LAST_EXTENT(eh);
418 if (handle->level <= 0)
419 return EXT2_ET_EXTENT_NO_UP;
423 if ((orig_op == EXT2_EXTENT_PREV) ||
424 (orig_op == EXT2_EXTENT_PREV_LEAF))
427 case EXT2_EXTENT_DOWN:
428 case EXT2_EXTENT_DOWN_AND_LAST:
429 if (!path->curr ||(handle->level >= handle->max_depth))
430 return EXT2_ET_EXTENT_NO_DOWN;
435 retval = ext2fs_get_mem(handle->fs->blocksize,
440 blk = ext2fs_le32_to_cpu(ix->ei_leaf) +
441 ((__u64) ext2fs_le16_to_cpu(ix->ei_leaf_hi) << 32);
442 if ((handle->fs->flags & EXT2_FLAG_IMAGE_FILE) &&
443 (handle->fs->io != handle->fs->image_io))
444 memset(newpath->buf, 0, handle->fs->blocksize);
446 retval = io_channel_read_blk64(handle->fs->io,
447 blk, 1, newpath->buf);
453 eh = (struct ext3_extent_header *) newpath->buf;
455 retval = ext2fs_extent_header_verify(eh, handle->fs->blocksize);
461 newpath->left = newpath->entries =
462 ext2fs_le16_to_cpu(eh->eh_entries);
463 newpath->max_entries = ext2fs_le16_to_cpu(eh->eh_max);
465 if (path->left > 0) {
467 newpath->end_blk = ext2fs_le32_to_cpu(ix->ei_block);
469 newpath->end_blk = path->end_blk;
472 if (op == EXT2_EXTENT_DOWN) {
473 ix = EXT_FIRST_INDEX((struct ext3_extent_header *) eh);
475 path->left = path->entries - 1;
478 ix = EXT_LAST_INDEX((struct ext3_extent_header *) eh);
481 if (handle->level < handle->max_depth)
484 #ifdef DEBUG_GET_EXTENT
485 printf("Down to level %d/%d, end_blk=%llu\n",
486 handle->level, handle->max_depth,
491 return EXT2_ET_OP_NOT_SUPPORTED;
495 return EXT2_ET_NO_CURRENT_NODE;
498 #ifdef DEBUG_GET_EXTENT
499 printf("(Left %d)\n", path->left);
502 if (handle->level == handle->max_depth) {
503 ex = (struct ext3_extent *) ix;
505 extent->e_pblk = ext2fs_le32_to_cpu(ex->ee_start) +
506 ((__u64) ext2fs_le16_to_cpu(ex->ee_start_hi) << 32);
507 extent->e_lblk = ext2fs_le32_to_cpu(ex->ee_block);
508 extent->e_len = ext2fs_le16_to_cpu(ex->ee_len);
509 extent->e_flags |= EXT2_EXTENT_FLAGS_LEAF;
510 if (extent->e_len > EXT_INIT_MAX_LEN) {
511 extent->e_len -= EXT_INIT_MAX_LEN;
512 extent->e_flags |= EXT2_EXTENT_FLAGS_UNINIT;
515 extent->e_pblk = ext2fs_le32_to_cpu(ix->ei_leaf) +
516 ((__u64) ext2fs_le16_to_cpu(ix->ei_leaf_hi) << 32);
517 extent->e_lblk = ext2fs_le32_to_cpu(ix->ei_block);
518 if (path->left > 0) {
520 end_blk = ext2fs_le32_to_cpu(ix->ei_block);
522 end_blk = path->end_blk;
524 extent->e_len = end_blk - extent->e_lblk;
527 extent->e_flags |= EXT2_EXTENT_FLAGS_SECOND_VISIT;
529 if (((orig_op == EXT2_EXTENT_NEXT_LEAF) ||
530 (orig_op == EXT2_EXTENT_PREV_LEAF)) &&
531 (handle->level != handle->max_depth))
534 if ((orig_op == EXT2_EXTENT_LAST_LEAF) &&
535 ((handle->level != handle->max_depth) ||
542 static errcode_t update_path(ext2_extent_handle_t handle)
546 struct ext3_extent_idx *ix;
548 if (handle->level == 0) {
549 retval = ext2fs_write_inode(handle->fs, handle->ino,
552 ix = handle->path[handle->level - 1].curr;
553 blk = ext2fs_le32_to_cpu(ix->ei_leaf) +
554 ((__u64) ext2fs_le16_to_cpu(ix->ei_leaf_hi) << 32);
556 retval = io_channel_write_blk64(handle->fs->io,
557 blk, 1, handle->path[handle->level].buf);
563 errcode_t ext2fs_extent_save_path(ext2_extent_handle_t handle,
564 ext2_extent_path_t *ret_path)
566 ext2_extent_path_t save_path;
567 struct ext2fs_extent extent;
568 struct ext2_extent_info info;
571 retval = ext2fs_extent_get(handle, EXT2_EXTENT_CURRENT, &extent);
575 retval = ext2fs_extent_get_info(handle, &info);
579 retval = ext2fs_get_mem(sizeof(struct ext2_extent_path), &save_path);
582 memset(save_path, 0, sizeof(struct ext2_extent_path));
584 save_path->magic = EXT2_ET_MAGIC_EXTENT_PATH;
585 save_path->leaf_height = info.max_depth - info.curr_level - 1;
586 save_path->lblk = extent.e_lblk;
588 *ret_path = save_path;
592 errcode_t ext2fs_extent_free_path(ext2_extent_path_t path)
594 EXT2_CHECK_MAGIC(path, EXT2_ET_MAGIC_EXTENT_PATH);
596 ext2fs_free_mem(&path);
602 * Go to the node at leaf_level which contains logical block blk.
604 * leaf_level is height from the leaf node level, i.e.
605 * leaf_level 0 is at leaf node, leaf_level 1 is 1 above etc.
607 * If "blk" has no mapping (hole) then handle is left at last
610 static errcode_t extent_goto(ext2_extent_handle_t handle,
611 int leaf_level, blk64_t blk)
613 struct ext2fs_extent extent;
616 retval = ext2fs_extent_get(handle, EXT2_EXTENT_ROOT, &extent);
618 if (retval == EXT2_ET_EXTENT_NO_NEXT)
619 retval = EXT2_ET_EXTENT_NOT_FOUND;
623 if (leaf_level > handle->max_depth) {
625 printf("leaf level %d greater than tree depth %d\n",
626 leaf_level, handle->max_depth);
628 return EXT2_ET_OP_NOT_SUPPORTED;
632 printf("goto extent ino %u, level %d, %llu\n", handle->ino,
636 #ifdef DEBUG_GOTO_EXTENTS
637 dbg_print_extent("root", &extent);
640 if (handle->max_depth - handle->level == leaf_level) {
641 /* block is in this &extent */
642 if ((blk >= extent.e_lblk) &&
643 (blk < extent.e_lblk + extent.e_len))
645 if (blk < extent.e_lblk) {
646 retval = ext2fs_extent_get(handle,
647 EXT2_EXTENT_PREV_SIB,
649 return EXT2_ET_EXTENT_NOT_FOUND;
651 retval = ext2fs_extent_get(handle,
652 EXT2_EXTENT_NEXT_SIB,
654 if (retval == EXT2_ET_EXTENT_NO_NEXT)
655 return EXT2_ET_EXTENT_NOT_FOUND;
661 retval = ext2fs_extent_get(handle, EXT2_EXTENT_NEXT_SIB,
663 if (retval == EXT2_ET_EXTENT_NO_NEXT)
668 #ifdef DEBUG_GOTO_EXTENTS
669 dbg_print_extent("next", &extent);
671 if (blk == extent.e_lblk)
673 if (blk > extent.e_lblk)
676 retval = ext2fs_extent_get(handle, EXT2_EXTENT_PREV_SIB,
681 #ifdef DEBUG_GOTO_EXTENTS
682 dbg_print_extent("prev", &extent);
686 retval = ext2fs_extent_get(handle, EXT2_EXTENT_DOWN,
691 #ifdef DEBUG_GOTO_EXTENTS
692 dbg_print_extent("down", &extent);
697 errcode_t ext2fs_extent_goto(ext2_extent_handle_t handle,
700 return extent_goto(handle, 0, blk);
704 * Traverse back up to root fixing parents of current node as needed.
706 * If we changed start of first entry in a node, fix parent index start
709 * Safe to call for any position in node; if not at the first entry,
710 * will simply return.
712 static errcode_t ext2fs_extent_fix_parents(ext2_extent_handle_t handle)
716 struct extent_path *path;
717 struct ext2fs_extent extent;
719 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
721 if (!(handle->fs->flags & EXT2_FLAG_RW))
722 return EXT2_ET_RO_FILSYS;
725 return EXT2_ET_NO_CURRENT_NODE;
727 path = handle->path + handle->level;
729 return EXT2_ET_NO_CURRENT_NODE;
731 retval = ext2fs_extent_get(handle, EXT2_EXTENT_CURRENT, &extent);
735 /* modified node's start block */
736 start = extent.e_lblk;
738 /* traverse up until index not first, or startblk matches, or top */
739 while (handle->level > 0 &&
740 (path->left == path->entries - 1)) {
741 retval = ext2fs_extent_get(handle, EXT2_EXTENT_UP, &extent);
744 if (extent.e_lblk == start)
746 path = handle->path + handle->level;
747 extent.e_len += (extent.e_lblk - start);
748 extent.e_lblk = start;
749 retval = ext2fs_extent_replace(handle, 0, &extent);
755 /* put handle back to where we started */
756 retval = ext2fs_extent_goto(handle, start);
761 errcode_t ext2fs_extent_replace(ext2_extent_handle_t handle,
762 int flags EXT2FS_ATTR((unused)),
763 struct ext2fs_extent *extent)
765 struct extent_path *path;
766 struct ext3_extent_idx *ix;
767 struct ext3_extent *ex;
769 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
771 if (!(handle->fs->flags & EXT2_FLAG_RW))
772 return EXT2_ET_RO_FILSYS;
775 return EXT2_ET_NO_CURRENT_NODE;
777 path = handle->path + handle->level;
779 return EXT2_ET_NO_CURRENT_NODE;
782 printf("extent replace: %u ", handle->ino);
783 dbg_print_extent(0, extent);
786 if (handle->level == handle->max_depth) {
789 ex->ee_block = ext2fs_cpu_to_le32(extent->e_lblk);
790 ex->ee_start = ext2fs_cpu_to_le32(extent->e_pblk & 0xFFFFFFFF);
791 ex->ee_start_hi = ext2fs_cpu_to_le16(extent->e_pblk >> 32);
792 if (extent->e_flags & EXT2_EXTENT_FLAGS_UNINIT) {
793 if (extent->e_len > EXT_UNINIT_MAX_LEN)
794 return EXT2_ET_EXTENT_INVALID_LENGTH;
795 ex->ee_len = ext2fs_cpu_to_le16(extent->e_len +
798 if (extent->e_len > EXT_INIT_MAX_LEN)
799 return EXT2_ET_EXTENT_INVALID_LENGTH;
800 ex->ee_len = ext2fs_cpu_to_le16(extent->e_len);
805 ix->ei_leaf = ext2fs_cpu_to_le32(extent->e_pblk & 0xFFFFFFFF);
806 ix->ei_leaf_hi = ext2fs_cpu_to_le16(extent->e_pblk >> 32);
807 ix->ei_block = ext2fs_cpu_to_le32(extent->e_lblk);
815 * allocate a new block, move half the current node to it, and update parent
817 * handle will be left pointing at original record.
819 static errcode_t extent_node_split(ext2_extent_handle_t handle)
821 errcode_t retval = 0;
822 blk64_t new_node_pblk;
823 blk64_t new_node_start;
825 blk64_t goal_blk = 0;
827 char *block_buf = NULL;
828 struct ext2fs_extent extent;
829 struct extent_path *path, *newpath = 0;
830 struct ext3_extent_header *eh, *neweh;
833 struct ext2_extent_info info;
836 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
838 if (!(handle->fs->flags & EXT2_FLAG_RW))
839 return EXT2_ET_RO_FILSYS;
842 return EXT2_ET_NO_CURRENT_NODE;
845 printf("splitting node at level %d\n", handle->level);
847 retval = ext2fs_extent_get(handle, EXT2_EXTENT_CURRENT, &extent);
851 retval = ext2fs_extent_get_info(handle, &info);
855 /* save the position we were originally splitting... */
856 orig_height = info.max_depth - info.curr_level;
857 orig_lblk = extent.e_lblk;
859 /* Is there room in the parent for a new entry? */
861 (handle->path[handle->level - 1].entries >=
862 handle->path[handle->level - 1].max_entries)) {
865 printf("parent level %d full; splitting it too\n",
868 /* split the parent */
869 retval = ext2fs_extent_get(handle, EXT2_EXTENT_UP, &extent);
872 goal_blk = extent.e_pblk;
874 retval = extent_node_split(handle);
878 /* get handle back to our original split position */
879 retval = extent_goto(handle, orig_height, orig_lblk);
884 /* At this point, parent should have room for this split */
885 path = handle->path + handle->level;
887 return EXT2_ET_NO_CURRENT_NODE;
889 /* extent header of the current node we'll split */
890 eh = (struct ext3_extent_header *)path->buf;
892 /* splitting root level means moving them all out */
893 if (handle->level == 0) {
895 tocopy = ext2fs_le16_to_cpu(eh->eh_entries);
896 retval = ext2fs_get_mem(((handle->max_depth+2) *
897 sizeof(struct extent_path)),
902 ((handle->max_depth+2) * sizeof(struct extent_path)));
904 tocopy = ext2fs_le16_to_cpu(eh->eh_entries) / 2;
908 printf("will copy out %d of %d entries at level %d\n",
909 tocopy, ext2fs_le16_to_cpu(eh->eh_entries),
915 printf("Nothing to copy to new block!\n");
917 retval = EXT2_ET_CANT_SPLIT_EXTENT;
921 /* first we need a new block, or can do nothing. */
922 block_buf = malloc(handle->fs->blocksize);
929 dgrp_t group = ext2fs_group_of_ino(handle->fs, handle->ino);
930 __u8 log_flex = handle->fs->super->s_log_groups_per_flex;
933 group = group & ~((1 << (log_flex)) - 1);
934 goal_blk = (group * handle->fs->super->s_blocks_per_group) +
935 handle->fs->super->s_first_data_block;
937 retval = ext2fs_alloc_block2(handle->fs, goal_blk, block_buf,
943 printf("will copy to new node at block %lu\n",
944 (unsigned long) new_node_pblk);
947 /* Copy data into new block buffer */
948 /* First the header for the new block... */
949 neweh = (struct ext3_extent_header *) block_buf;
950 memcpy(neweh, eh, sizeof(struct ext3_extent_header));
951 neweh->eh_entries = ext2fs_cpu_to_le16(tocopy);
952 neweh->eh_max = ext2fs_cpu_to_le16((handle->fs->blocksize -
953 sizeof(struct ext3_extent_header)) /
954 sizeof(struct ext3_extent));
956 /* then the entries for the new block... */
957 memcpy(EXT_FIRST_INDEX(neweh),
958 EXT_FIRST_INDEX(eh) +
959 (ext2fs_le16_to_cpu(eh->eh_entries) - tocopy),
960 sizeof(struct ext3_extent_idx) * tocopy);
962 new_node_start = ext2fs_le32_to_cpu(EXT_FIRST_INDEX(neweh)->ei_block);
964 /* ...and write the new node block out to disk. */
965 retval = io_channel_write_blk64(handle->fs->io, new_node_pblk, 1,
971 /* OK! we've created the new node; now adjust the tree */
973 /* current path now has fewer active entries, we copied some out */
974 if (handle->level == 0) {
975 memcpy(newpath, path,
976 sizeof(struct extent_path) * (handle->max_depth+1));
977 handle->path = newpath;
981 path->left = path->max_entries - 1;
983 eh->eh_depth = ext2fs_cpu_to_le16(handle->max_depth);
985 path->entries -= tocopy;
986 path->left -= tocopy;
989 eh->eh_entries = ext2fs_cpu_to_le16(path->entries);
990 /* this writes out the node, incl. the modified header */
991 retval = update_path(handle);
995 /* now go up and insert/replace index for new node we created */
997 retval = ext2fs_extent_get(handle, EXT2_EXTENT_FIRST_SIB, &extent);
1001 extent.e_lblk = new_node_start;
1002 extent.e_pblk = new_node_pblk;
1003 extent.e_len = handle->path[0].end_blk - extent.e_lblk;
1004 retval = ext2fs_extent_replace(handle, 0, &extent);
1008 __u32 new_node_length;
1010 retval = ext2fs_extent_get(handle, EXT2_EXTENT_UP, &extent);
1011 /* will insert after this one; it's length is shorter now */
1012 new_node_length = new_node_start - extent.e_lblk;
1013 extent.e_len -= new_node_length;
1014 retval = ext2fs_extent_replace(handle, 0, &extent);
1018 /* now set up the new extent and insert it */
1019 extent.e_lblk = new_node_start;
1020 extent.e_pblk = new_node_pblk;
1021 extent.e_len = new_node_length;
1022 retval = ext2fs_extent_insert(handle, EXT2_EXTENT_INSERT_AFTER, &extent);
1027 /* get handle back to our original position */
1028 retval = extent_goto(handle, orig_height, orig_lblk);
1032 /* new node hooked in, so update inode block count (do this here?) */
1033 handle->inode->i_blocks += handle->fs->blocksize / 512;
1034 retval = ext2fs_write_inode(handle->fs, handle->ino,
1041 ext2fs_free_mem(&newpath);
1047 errcode_t ext2fs_extent_insert(ext2_extent_handle_t handle, int flags,
1048 struct ext2fs_extent *extent)
1050 struct extent_path *path;
1051 struct ext3_extent_idx *ix;
1052 struct ext3_extent_header *eh;
1055 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
1057 if (!(handle->fs->flags & EXT2_FLAG_RW))
1058 return EXT2_ET_RO_FILSYS;
1061 return EXT2_ET_NO_CURRENT_NODE;
1064 printf("extent insert: %u ", handle->ino);
1065 dbg_print_extent(0, extent);
1068 path = handle->path + handle->level;
1070 if (path->entries >= path->max_entries) {
1071 if (flags & EXT2_EXTENT_INSERT_NOSPLIT) {
1072 return EXT2_ET_CANT_INSERT_EXTENT;
1075 printf("node full (level %d) - splitting\n",
1078 retval = extent_node_split(handle);
1081 path = handle->path + handle->level;
1085 eh = (struct ext3_extent_header *) path->buf;
1088 if (flags & EXT2_EXTENT_INSERT_AFTER) {
1093 ix = EXT_FIRST_INDEX(eh);
1097 if (path->left >= 0)
1099 (path->left+1) * sizeof(struct ext3_extent_idx));
1103 eh = (struct ext3_extent_header *) path->buf;
1104 eh->eh_entries = ext2fs_cpu_to_le16(path->entries);
1106 retval = ext2fs_extent_replace(handle, 0, extent);
1110 retval = update_path(handle);
1117 ext2fs_extent_delete(handle, 0);
1122 * Sets the physical block for a logical file block in the extent tree.
1124 * May: map unmapped, unmap mapped, or remap mapped blocks.
1126 * Mapping an unmapped block adds a single-block extent.
1128 * Unmapping first or last block modifies extent in-place
1129 * - But may need to fix parent's starts too in first-block case
1131 * Mapping any unmapped block requires adding a (single-block) extent
1132 * and inserting into proper point in tree.
1134 * Modifying (unmapping or remapping) a block in the middle
1135 * of an extent requires splitting the extent.
1136 * - Remapping case requires new single-block extent.
1138 * Remapping first or last block adds an extent.
1140 * We really need extent adding to be smart about merging.
1143 errcode_t ext2fs_extent_set_bmap(ext2_extent_handle_t handle,
1144 blk64_t logical, blk64_t physical, int flags)
1146 errcode_t ec, retval = 0;
1147 int mapped = 1; /* logical is mapped? */
1149 int extent_uninit = 0;
1150 int prev_uninit = 0;
1151 int next_uninit = 0;
1153 int max_len = EXT_INIT_MAX_LEN;
1154 int has_prev, has_next;
1156 struct extent_path *path;
1157 struct ext2fs_extent extent, next_extent, prev_extent;
1158 struct ext2fs_extent newextent;
1159 struct ext2_extent_info info;
1161 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
1164 printf("set_bmap ino %u log %lld phys %lld flags %d\n",
1165 handle->ino, logical, physical, flags);
1168 if (!(handle->fs->flags & EXT2_FLAG_RW))
1169 return EXT2_ET_RO_FILSYS;
1172 return EXT2_ET_NO_CURRENT_NODE;
1174 path = handle->path + handle->level;
1176 if (flags & EXT2_EXTENT_SET_BMAP_UNINIT) {
1178 max_len = EXT_UNINIT_MAX_LEN;
1181 /* if (re)mapping, set up new extent to insert */
1183 newextent.e_len = 1;
1184 newextent.e_pblk = physical;
1185 newextent.e_lblk = logical;
1186 newextent.e_flags = EXT2_EXTENT_FLAGS_LEAF;
1188 newextent.e_flags |= EXT2_EXTENT_FLAGS_UNINIT;
1191 /* special case if the extent tree is completely empty */
1192 if ((handle->max_depth == 0) && (path->entries == 0)) {
1193 retval = ext2fs_extent_insert(handle, 0, &newextent);
1197 /* save our original location in the extent tree */
1198 if ((retval = ext2fs_extent_get(handle, EXT2_EXTENT_CURRENT,
1200 if (retval != EXT2_ET_NO_CURRENT_NODE)
1202 memset(&extent, 0, sizeof(extent));
1204 if ((retval = ext2fs_extent_get_info(handle, &info)))
1206 orig_height = info.max_depth - info.curr_level;
1207 orig_lblk = extent.e_lblk;
1209 /* go to the logical spot we want to (re/un)map */
1210 retval = ext2fs_extent_goto(handle, logical);
1212 if (retval == EXT2_ET_EXTENT_NOT_FOUND) {
1217 printf("block %llu already unmapped\n",
1227 * This may be the extent *before* the requested logical,
1228 * if it's currently unmapped.
1230 * Get the previous and next leaf extents, if they are present.
1232 retval = ext2fs_extent_get(handle, EXT2_EXTENT_CURRENT, &extent);
1235 if (extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT)
1237 retval = ext2fs_extent_get(handle, EXT2_EXTENT_NEXT_LEAF, &next_extent);
1240 if (retval != EXT2_ET_EXTENT_NO_NEXT)
1243 dbg_print_extent("set_bmap: next_extent",
1246 if (next_extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT)
1249 retval = ext2fs_extent_goto(handle, logical);
1250 if (retval && retval != EXT2_ET_EXTENT_NOT_FOUND)
1252 retval = ext2fs_extent_get(handle, EXT2_EXTENT_PREV_LEAF, &prev_extent);
1255 if (retval != EXT2_ET_EXTENT_NO_PREV)
1259 dbg_print_extent("set_bmap: prev_extent",
1261 if (prev_extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT)
1264 retval = ext2fs_extent_goto(handle, logical);
1265 if (retval && retval != EXT2_ET_EXTENT_NOT_FOUND)
1268 /* check if already pointing to the requested physical */
1269 if (mapped && (new_uninit == extent_uninit) &&
1270 (extent.e_pblk + (logical - extent.e_lblk) == physical)) {
1272 printf("physical block (at %llu) unchanged\n", logical);
1279 printf("mapping unmapped logical block %llu\n", logical);
1281 if ((logical == extent.e_lblk + extent.e_len) &&
1282 (physical == extent.e_pblk + extent.e_len) &&
1283 (new_uninit == extent_uninit) &&
1284 ((int) extent.e_len < max_len-1)) {
1286 retval = ext2fs_extent_replace(handle, 0, &extent);
1287 } else if ((logical == extent.e_lblk - 1) &&
1288 (physical == extent.e_pblk - 1) &&
1289 (new_uninit == extent_uninit) &&
1290 ((int) extent.e_len < max_len - 1)) {
1294 retval = ext2fs_extent_replace(handle, 0, &extent);
1295 } else if (has_next &&
1296 (logical == next_extent.e_lblk - 1) &&
1297 (physical == next_extent.e_pblk - 1) &&
1298 (new_uninit == next_uninit) &&
1299 ((int) next_extent.e_len < max_len - 1)) {
1300 retval = ext2fs_extent_get(handle,
1301 EXT2_EXTENT_NEXT_LEAF,
1305 next_extent.e_len++;
1306 next_extent.e_lblk--;
1307 next_extent.e_pblk--;
1308 retval = ext2fs_extent_replace(handle, 0, &next_extent);
1309 } else if (logical < extent.e_lblk)
1310 retval = ext2fs_extent_insert(handle, 0, &newextent);
1312 retval = ext2fs_extent_insert(handle,
1313 EXT2_EXTENT_INSERT_AFTER, &newextent);
1316 retval = ext2fs_extent_fix_parents(handle);
1319 } else if ((logical == extent.e_lblk) && (extent.e_len == 1)) {
1321 printf("(re/un)mapping only block in extent\n");
1324 retval = ext2fs_extent_replace(handle, 0, &newextent);
1326 retval = ext2fs_extent_delete(handle, 0);
1329 ec = ext2fs_extent_fix_parents(handle);
1330 if (ec != EXT2_ET_NO_CURRENT_NODE)
1336 } else if (logical == extent.e_lblk + extent.e_len - 1) {
1338 printf("(re/un)mapping last block in extent\n");
1342 (logical == (next_extent.e_lblk - 1)) &&
1343 (physical == (next_extent.e_pblk - 1)) &&
1344 (new_uninit == next_uninit) &&
1345 ((int) next_extent.e_len < max_len - 1)) {
1346 retval = ext2fs_extent_get(handle,
1347 EXT2_EXTENT_NEXT_LEAF, &next_extent);
1350 next_extent.e_len++;
1351 next_extent.e_lblk--;
1352 next_extent.e_pblk--;
1353 retval = ext2fs_extent_replace(handle, 0,
1358 retval = ext2fs_extent_insert(handle,
1359 EXT2_EXTENT_INSERT_AFTER, &newextent);
1362 /* Now pointing at inserted extent; move back to prev */
1363 retval = ext2fs_extent_get(handle,
1364 EXT2_EXTENT_PREV_LEAF,
1370 retval = ext2fs_extent_replace(handle, 0, &extent);
1373 } else if (logical == extent.e_lblk) {
1375 printf("(re/un)mapping first block in extent\n");
1379 (logical == (prev_extent.e_lblk +
1380 prev_extent.e_len)) &&
1381 (physical == (prev_extent.e_pblk +
1382 prev_extent.e_len)) &&
1383 (new_uninit == prev_uninit) &&
1384 ((int) prev_extent.e_len < max_len-1)) {
1385 retval = ext2fs_extent_get(handle,
1386 EXT2_EXTENT_PREV_LEAF, &prev_extent);
1389 prev_extent.e_len++;
1390 retval = ext2fs_extent_replace(handle, 0,
1393 retval = ext2fs_extent_insert(handle,
1397 retval = ext2fs_extent_get(handle,
1398 EXT2_EXTENT_NEXT_LEAF,
1406 retval = ext2fs_extent_replace(handle, 0, &extent);
1413 printf("(re/un)mapping in middle of extent\n");
1415 /* need to split this extent; later */
1417 orig_length = extent.e_len;
1419 /* shorten pre-split extent */
1420 extent.e_len = (logical - extent.e_lblk);
1421 retval = ext2fs_extent_replace(handle, 0, &extent);
1424 /* insert our new extent, if any */
1426 /* insert new extent after current */
1427 retval = ext2fs_extent_insert(handle,
1428 EXT2_EXTENT_INSERT_AFTER, &newextent);
1432 /* add post-split extent */
1433 extent.e_pblk += extent.e_len + 1;
1434 extent.e_lblk += extent.e_len + 1;
1435 extent.e_len = orig_length - extent.e_len - 1;
1436 retval = ext2fs_extent_insert(handle,
1437 EXT2_EXTENT_INSERT_AFTER, &extent);
1443 /* get handle back to its position */
1444 if (orig_height > handle->max_depth)
1445 orig_height = handle->max_depth; /* In case we shortened the tree */
1446 extent_goto(handle, orig_height, orig_lblk);
1450 errcode_t ext2fs_extent_delete(ext2_extent_handle_t handle, int flags)
1452 struct extent_path *path;
1454 struct ext3_extent_header *eh;
1455 errcode_t retval = 0;
1457 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
1459 if (!(handle->fs->flags & EXT2_FLAG_RW))
1460 return EXT2_ET_RO_FILSYS;
1463 return EXT2_ET_NO_CURRENT_NODE;
1467 struct ext2fs_extent extent;
1469 retval = ext2fs_extent_get(handle, EXT2_EXTENT_CURRENT,
1472 printf("extent delete %u ", handle->ino);
1473 dbg_print_extent(0, &extent);
1478 path = handle->path + handle->level;
1480 return EXT2_ET_NO_CURRENT_NODE;
1485 memmove(cp, cp + sizeof(struct ext3_extent_idx),
1486 path->left * sizeof(struct ext3_extent_idx));
1489 struct ext3_extent_idx *ix = path->curr;
1493 if (--path->entries == 0)
1496 /* if non-root node has no entries left, remove it & parent ptr to it */
1497 if (path->entries == 0 && handle->level) {
1498 if (!(flags & EXT2_EXTENT_DELETE_KEEP_EMPTY)) {
1499 struct ext2fs_extent extent;
1501 retval = ext2fs_extent_get(handle, EXT2_EXTENT_UP,
1506 retval = ext2fs_extent_delete(handle, flags);
1507 handle->inode->i_blocks -= handle->fs->blocksize / 512;
1508 retval = ext2fs_write_inode(handle->fs, handle->ino,
1510 ext2fs_block_alloc_stats2(handle->fs,
1514 eh = (struct ext3_extent_header *) path->buf;
1515 eh->eh_entries = ext2fs_cpu_to_le16(path->entries);
1516 if ((path->entries == 0) && (handle->level == 0))
1517 eh->eh_depth = handle->max_depth = 0;
1518 retval = update_path(handle);
1523 errcode_t ext2fs_extent_get_info(ext2_extent_handle_t handle,
1524 struct ext2_extent_info *info)
1526 struct extent_path *path;
1528 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
1530 memset(info, 0, sizeof(struct ext2_extent_info));
1532 path = handle->path + handle->level;
1535 info->curr_entry = ((char *) path->curr - path->buf) /
1536 sizeof(struct ext3_extent_idx);
1538 info->curr_entry = 0;
1539 info->num_entries = path->entries;
1540 info->max_entries = path->max_entries;
1541 info->bytes_avail = (path->max_entries - path->entries) *
1542 sizeof(struct ext3_extent);
1545 info->curr_level = handle->level;
1546 info->max_depth = handle->max_depth;
1547 info->max_lblk = ((__u64) 1 << 32) - 1;
1548 info->max_pblk = ((__u64) 1 << 48) - 1;
1549 info->max_len = (1UL << 15);
1550 info->max_uninit_len = (1UL << 15) - 1;
1559 #include "debugfs.h"
1562 * Hook in new commands into debugfs
1564 const char *debug_prog_name = "tst_extents";
1565 extern ss_request_table extent_cmds;
1566 ss_request_table *extra_cmds = &extent_cmds;
1568 ext2_ino_t current_ino = 0;
1569 ext2_extent_handle_t current_handle;
1571 int common_extent_args_process(int argc, char *argv[], int min_argc,
1572 int max_argc, const char *cmd,
1573 const char *usage, int flags)
1575 if (common_args_process(argc, argv, min_argc, max_argc, cmd,
1579 if (!current_handle) {
1580 com_err(cmd, 0, "Extent handle not open");
1586 void do_inode(int argc, char *argv[])
1590 struct ext3_extent_header *eh;
1593 if (check_fs_open(argv[0]))
1598 printf("Current inode is %d\n", current_ino);
1600 printf("No current inode\n");
1604 if (common_inode_args_process(argc, argv, &inode, 0)) {
1610 retval = ext2fs_extent_open(current_fs, inode, ¤t_handle);
1612 com_err(argv[1], retval, "while opening extent handle");
1616 current_ino = inode;
1618 printf("Loaded inode %d\n", current_ino);
1623 void generic_goto_node(char *cmd_name, int op)
1625 struct ext2fs_extent extent;
1628 if (check_fs_open(cmd_name))
1631 if (!current_handle) {
1632 com_err(cmd_name, 0, "Extent handle not open");
1636 retval = ext2fs_extent_get(current_handle, op, &extent);
1638 com_err(cmd_name, retval, 0);
1641 dbg_print_extent(0, &extent);
1644 void do_current_node(int argc, char *argv[])
1646 generic_goto_node(argv[0], EXT2_EXTENT_CURRENT);
1649 void do_root_node(int argc, char *argv[])
1651 generic_goto_node(argv[0], EXT2_EXTENT_ROOT);
1654 void do_last_leaf(int argc, char *argv[])
1656 generic_goto_node(argv[0], EXT2_EXTENT_LAST_LEAF);
1659 void do_first_sib(int argc, char *argv[])
1661 generic_goto_node(argv[0], EXT2_EXTENT_FIRST_SIB);
1664 void do_last_sib(int argc, char *argv[])
1666 generic_goto_node(argv[0], EXT2_EXTENT_LAST_SIB);
1669 void do_next_sib(int argc, char *argv[])
1671 generic_goto_node(argv[0], EXT2_EXTENT_NEXT_SIB);
1674 void do_prev_sib(int argc, char *argv[])
1676 generic_goto_node(argv[0], EXT2_EXTENT_PREV_SIB);
1679 void do_next_leaf(int argc, char *argv[])
1681 generic_goto_node(argv[0], EXT2_EXTENT_NEXT_LEAF);
1684 void do_prev_leaf(int argc, char *argv[])
1686 generic_goto_node(argv[0], EXT2_EXTENT_PREV_LEAF);
1689 void do_next(int argc, char *argv[])
1691 generic_goto_node(argv[0], EXT2_EXTENT_NEXT);
1694 void do_prev(int argc, char *argv[])
1696 generic_goto_node(argv[0], EXT2_EXTENT_PREV);
1699 void do_up(int argc, char *argv[])
1701 generic_goto_node(argv[0], EXT2_EXTENT_UP);
1704 void do_down(int argc, char *argv[])
1706 generic_goto_node(argv[0], EXT2_EXTENT_DOWN);
1709 void do_delete_node(int argc, char *argv[])
1714 if (common_extent_args_process(argc, argv, 1, 1, "delete_node",
1715 "", CHECK_FS_RW | CHECK_FS_BITMAPS))
1718 retval = ext2fs_extent_delete(current_handle, 0);
1720 com_err(argv[0], retval, 0);
1723 if (current_handle->path && current_handle->path[0].curr)
1724 do_current_node(argc, argv);
1727 void do_replace_node(int argc, char *argv[])
1729 const char *usage = "[--uninit] <lblk> <len> <pblk>";
1731 struct ext2fs_extent extent;
1734 if (common_extent_args_process(argc, argv, 3, 5, "replace_node",
1735 usage, CHECK_FS_RW | CHECK_FS_BITMAPS))
1740 if (!strcmp(argv[1], "--uninit")) {
1743 extent.e_flags |= EXT2_EXTENT_FLAGS_UNINIT;
1747 fprintf(stderr, "Usage: %s %s\n", argv[0], usage);
1751 extent.e_lblk = parse_ulong(argv[1], argv[0], "logical block", &err);
1755 extent.e_len = parse_ulong(argv[2], argv[0], "logical block", &err);
1759 extent.e_pblk = parse_ulong(argv[3], argv[0], "logical block", &err);
1763 retval = ext2fs_extent_replace(current_handle, 0, &extent);
1765 com_err(argv[0], retval, 0);
1768 do_current_node(argc, argv);
1771 void do_split_node(int argc, char *argv[])
1774 struct ext2fs_extent extent;
1777 if (common_extent_args_process(argc, argv, 1, 1, "split_node",
1778 "", CHECK_FS_RW | CHECK_FS_BITMAPS))
1781 retval = extent_node_split(current_handle);
1783 com_err(argv[0], retval, 0);
1786 do_current_node(argc, argv);
1789 void do_insert_node(int argc, char *argv[])
1791 const char *usage = "[--after] [--uninit] <lblk> <len> <pblk>";
1793 struct ext2fs_extent extent;
1798 if (common_extent_args_process(argc, argv, 3, 6, "insert_node",
1799 usage, CHECK_FS_RW | CHECK_FS_BITMAPS))
1807 if (!strcmp(argv[1], "--after")) {
1810 flags |= EXT2_EXTENT_INSERT_AFTER;
1813 if (!strcmp(argv[1], "--uninit")) {
1816 extent.e_flags |= EXT2_EXTENT_FLAGS_UNINIT;
1823 fprintf(stderr, "usage: %s %s\n", cmd, usage);
1827 extent.e_lblk = parse_ulong(argv[1], cmd,
1828 "logical block", &err);
1832 extent.e_len = parse_ulong(argv[2], cmd,
1837 extent.e_pblk = parse_ulong(argv[3], cmd,
1838 "pysical block", &err);
1842 retval = ext2fs_extent_insert(current_handle, flags, &extent);
1844 com_err(cmd, retval, 0);
1847 do_current_node(argc, argv);
1850 void do_set_bmap(int argc, char **argv)
1852 const char *usage = "[--uninit] <lblk> <pblk>";
1856 char *cmd = argv[0];
1860 if (common_extent_args_process(argc, argv, 3, 5, "set_bmap",
1861 usage, CHECK_FS_RW | CHECK_FS_BITMAPS))
1864 if (argc > 2 && !strcmp(argv[1], "--uninit")) {
1867 flags |= EXT2_EXTENT_SET_BMAP_UNINIT;
1871 fprintf(stderr, "Usage: %s %s\n", cmd, usage);
1875 logical = parse_ulong(argv[1], cmd,
1876 "logical block", &err);
1880 physical = parse_ulong(argv[2], cmd,
1881 "physical block", &err);
1885 retval = ext2fs_extent_set_bmap(current_handle, logical,
1886 (blk64_t) physical, flags);
1888 com_err(cmd, retval, 0);
1891 if (current_handle->path && current_handle->path[0].curr)
1892 do_current_node(argc, argv);
1895 void do_print_all(int argc, char **argv)
1897 const char *usage = "[--leaf-only|--reverse|--reverse-leaf]";
1898 struct ext2fs_extent extent;
1900 errcode_t end_err = EXT2_ET_EXTENT_NO_NEXT;
1901 int op = EXT2_EXTENT_NEXT;
1902 int first_op = EXT2_EXTENT_ROOT;
1905 if (common_extent_args_process(argc, argv, 1, 2, "print_all",
1910 if (!strcmp(argv[1], "--leaf-only"))
1911 op = EXT2_EXTENT_NEXT_LEAF;
1912 else if (!strcmp(argv[1], "--reverse")) {
1913 op = EXT2_EXTENT_PREV;
1914 first_op = EXT2_EXTENT_LAST_LEAF;
1915 end_err = EXT2_ET_EXTENT_NO_PREV;
1916 } else if (!strcmp(argv[1], "--reverse-leaf")) {
1917 op = EXT2_EXTENT_PREV_LEAF;
1918 first_op = EXT2_EXTENT_LAST_LEAF;
1919 end_err = EXT2_ET_EXTENT_NO_PREV;
1921 fprintf(stderr, "Usage: %s %s\n", argv[0], usage);
1926 retval = ext2fs_extent_get(current_handle, first_op, &extent);
1928 com_err(argv[0], retval, 0);
1931 dbg_print_extent(0, &extent);
1934 retval = ext2fs_extent_get(current_handle, op, &extent);
1935 if (retval == end_err)
1939 com_err(argv[0], retval, 0);
1942 dbg_print_extent(0, &extent);
1946 void do_info(int argc, char **argv)
1948 struct ext2fs_extent extent;
1949 struct ext2_extent_info info;
1952 if (common_extent_args_process(argc, argv, 1, 1, "info", "", 0))
1955 retval = ext2fs_extent_get_info(current_handle, &info);
1957 com_err(argv[0], retval, 0);
1961 retval = ext2fs_extent_get(current_handle,
1962 EXT2_EXTENT_CURRENT, &extent);
1964 com_err(argv[0], retval, 0);
1968 dbg_print_extent(0, &extent);
1970 printf("Current handle location: %d/%d (max: %d, bytes %d), level %d/%d\n",
1971 info.curr_entry, info.num_entries, info.max_entries,
1972 info.bytes_avail, info.curr_level, info.max_depth);
1973 printf("\tmax lblk: %llu, max pblk: %llu\n", info.max_lblk,
1975 printf("\tmax_len: %u, max_uninit_len: %u\n", info.max_len,
1976 info.max_uninit_len);
1979 void do_goto_block(int argc, char **argv)
1981 struct ext2fs_extent extent;
1983 int op = EXT2_EXTENT_NEXT_LEAF;
1987 if (common_extent_args_process(argc, argv, 2, 3, "goto_block",
1988 "block [level]", 0))
1991 if (strtoblk(argv[0], argv[1], &blk))
1995 if (strtoblk(argv[0], argv[2], &level))
1998 retval = extent_goto(current_handle, level, (blk64_t) blk);
2001 com_err(argv[0], retval,
2002 "while trying to go to block %u, level %d",
2007 generic_goto_node(argv[0], EXT2_EXTENT_CURRENT);