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 Public
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 %lu, 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 struct ext2_extent_handle *handle;
185 int isize = EXT2_INODE_SIZE(fs->super);
187 struct ext3_extent_header *eh;
189 EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
191 if ((ino == 0) || (ino > fs->super->s_inodes_count))
192 return EXT2_ET_BAD_INODE_NUM;
194 retval = ext2fs_get_mem(sizeof(struct ext2_extent_handle), &handle);
197 memset(handle, 0, sizeof(struct ext2_extent_handle));
199 retval = ext2fs_get_mem(isize, &handle->inode);
206 retval = ext2fs_read_inode_full(fs, ino, handle->inode, isize);
210 eh = (struct ext3_extent_header *) &handle->inode->i_block[0];
212 for (i=0; i < EXT2_N_BLOCKS; i++)
213 if (handle->inode->i_block[i])
215 if (i >= EXT2_N_BLOCKS) {
216 eh->eh_magic = ext2fs_cpu_to_le16(EXT3_EXT_MAGIC);
219 i = (sizeof(handle->inode->i_block) - sizeof(*eh)) /
220 sizeof(struct ext3_extent);
221 eh->eh_max = ext2fs_cpu_to_le16(i);
222 handle->inode->i_flags |= EXT4_EXTENTS_FL;
225 if (!(handle->inode->i_flags & EXT4_EXTENTS_FL)) {
226 retval = EXT2_ET_INODE_NOT_EXTENT;
230 retval = ext2fs_extent_header_verify(eh, sizeof(handle->inode->i_block));
234 handle->max_depth = ext2fs_le16_to_cpu(eh->eh_depth);
235 handle->type = ext2fs_le16_to_cpu(eh->eh_magic);
237 retval = ext2fs_get_mem(((handle->max_depth+1) *
238 sizeof(struct extent_path)),
240 memset(handle->path, 0,
241 (handle->max_depth+1) * sizeof(struct extent_path));
242 handle->path[0].buf = (char *) handle->inode->i_block;
244 handle->path[0].left = handle->path[0].entries =
245 ext2fs_le16_to_cpu(eh->eh_entries);
246 handle->path[0].max_entries = ext2fs_le16_to_cpu(eh->eh_max);
247 handle->path[0].curr = 0;
248 handle->path[0].end_blk =
249 ((((__u64) handle->inode->i_size_high << 32) +
250 handle->inode->i_size + (fs->blocksize - 1))
251 >> EXT2_BLOCK_SIZE_BITS(fs->super));
252 handle->path[0].visit_num = 1;
254 handle->magic = EXT2_ET_MAGIC_EXTENT_HANDLE;
256 *ret_handle = handle;
260 ext2fs_extent_free(handle);
265 * This function is responsible for (optionally) moving through the
266 * extent tree and then returning the current extent
268 errcode_t ext2fs_extent_get(ext2_extent_handle_t handle,
269 int flags, struct ext2fs_extent *extent)
271 struct extent_path *path, *newpath;
272 struct ext3_extent_header *eh;
273 struct ext3_extent_idx *ix = 0;
274 struct ext3_extent *ex;
280 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
283 return EXT2_ET_NO_CURRENT_NODE;
285 orig_op = op = flags & EXT2_EXTENT_MOVE_MASK;
288 path = handle->path + handle->level;
289 if ((orig_op == EXT2_EXTENT_NEXT) ||
290 (orig_op == EXT2_EXTENT_NEXT_LEAF)) {
291 if (handle->level < handle->max_depth) {
293 if (path->visit_num == 0) {
295 op = EXT2_EXTENT_DOWN;
296 } else if (path->left > 0)
297 op = EXT2_EXTENT_NEXT_SIB;
298 else if (handle->level > 0)
301 return EXT2_ET_EXTENT_NO_NEXT;
305 op = EXT2_EXTENT_NEXT_SIB;
306 else if (handle->level > 0)
309 return EXT2_ET_EXTENT_NO_NEXT;
311 if (op != EXT2_EXTENT_NEXT_SIB) {
313 printf("<<<< OP = %s\n",
314 (op == EXT2_EXTENT_DOWN) ? "down" :
315 ((op == EXT2_EXTENT_UP) ? "up" : "unknown"));
320 if ((orig_op == EXT2_EXTENT_PREV) ||
321 (orig_op == EXT2_EXTENT_PREV_LEAF)) {
322 if (handle->level < handle->max_depth) {
324 if (path->visit_num > 0 ) {
325 /* path->visit_num = 0; */
326 op = EXT2_EXTENT_DOWN_AND_LAST;
327 } else if (path->left < path->entries-1)
328 op = EXT2_EXTENT_PREV_SIB;
329 else if (handle->level > 0)
332 return EXT2_ET_EXTENT_NO_PREV;
335 if (path->left < path->entries-1)
336 op = EXT2_EXTENT_PREV_SIB;
337 else if (handle->level > 0)
340 return EXT2_ET_EXTENT_NO_PREV;
342 if (op != EXT2_EXTENT_PREV_SIB) {
344 printf("<<<< OP = %s\n",
345 (op == EXT2_EXTENT_DOWN_AND_LAST) ? "down/last" :
346 ((op == EXT2_EXTENT_UP) ? "up" : "unknown"));
351 if (orig_op == EXT2_EXTENT_LAST_LEAF) {
352 if ((handle->level < handle->max_depth) &&
354 op = EXT2_EXTENT_DOWN;
356 op = EXT2_EXTENT_LAST_SIB;
358 printf("<<<< OP = %s\n",
359 (op == EXT2_EXTENT_DOWN) ? "down" : "last_sib");
364 case EXT2_EXTENT_CURRENT:
367 case EXT2_EXTENT_ROOT:
369 path = handle->path + handle->level;
370 case EXT2_EXTENT_FIRST_SIB:
371 path->left = path->entries;
373 case EXT2_EXTENT_NEXT_SIB:
375 return EXT2_ET_EXTENT_NO_NEXT;
380 eh = (struct ext3_extent_header *) path->buf;
381 ix = EXT_FIRST_INDEX(eh);
387 case EXT2_EXTENT_PREV_SIB:
389 path->left+1 >= path->entries)
390 return EXT2_ET_EXTENT_NO_PREV;
395 if (handle->level < handle->max_depth)
398 case EXT2_EXTENT_LAST_SIB:
399 eh = (struct ext3_extent_header *) path->buf;
400 path->curr = EXT_LAST_EXTENT(eh);
406 if (handle->level <= 0)
407 return EXT2_ET_EXTENT_NO_UP;
411 if ((orig_op == EXT2_EXTENT_PREV) ||
412 (orig_op == EXT2_EXTENT_PREV_LEAF))
415 case EXT2_EXTENT_DOWN:
416 case EXT2_EXTENT_DOWN_AND_LAST:
417 if (!path->curr ||(handle->level >= handle->max_depth))
418 return EXT2_ET_EXTENT_NO_DOWN;
423 retval = ext2fs_get_mem(handle->fs->blocksize,
428 blk = ext2fs_le32_to_cpu(ix->ei_leaf) +
429 ((__u64) ext2fs_le16_to_cpu(ix->ei_leaf_hi) << 32);
430 if ((handle->fs->flags & EXT2_FLAG_IMAGE_FILE) &&
431 (handle->fs->io != handle->fs->image_io))
432 memset(newpath->buf, 0, handle->fs->blocksize);
434 retval = io_channel_read_blk(handle->fs->io,
435 blk, 1, newpath->buf);
441 eh = (struct ext3_extent_header *) newpath->buf;
443 retval = ext2fs_extent_header_verify(eh, handle->fs->blocksize);
447 newpath->left = newpath->entries =
448 ext2fs_le16_to_cpu(eh->eh_entries);
449 newpath->max_entries = ext2fs_le16_to_cpu(eh->eh_max);
451 if (path->left > 0) {
453 newpath->end_blk = ext2fs_le32_to_cpu(ix->ei_block);
455 newpath->end_blk = path->end_blk;
458 if (op == EXT2_EXTENT_DOWN) {
459 ix = EXT_FIRST_INDEX((struct ext3_extent_header *) eh);
461 path->left = path->entries - 1;
464 ix = EXT_LAST_INDEX((struct ext3_extent_header *) eh);
467 if (handle->level < handle->max_depth)
471 printf("Down to level %d/%d, end_blk=%llu\n",
472 handle->level, handle->max_depth,
477 return EXT2_ET_OP_NOT_SUPPORTED;
481 return EXT2_ET_NO_CURRENT_NODE;
485 printf("(Left %d)\n", path->left);
488 if (handle->level == handle->max_depth) {
489 ex = (struct ext3_extent *) ix;
491 extent->e_pblk = ext2fs_le32_to_cpu(ex->ee_start) +
492 ((__u64) ext2fs_le16_to_cpu(ex->ee_start_hi) << 32);
493 extent->e_lblk = ext2fs_le32_to_cpu(ex->ee_block);
494 extent->e_len = ext2fs_le16_to_cpu(ex->ee_len);
495 extent->e_flags |= EXT2_EXTENT_FLAGS_LEAF;
496 if (extent->e_len > EXT_INIT_MAX_LEN) {
497 extent->e_len -= EXT_INIT_MAX_LEN;
498 extent->e_flags |= EXT2_EXTENT_FLAGS_UNINIT;
501 extent->e_pblk = ext2fs_le32_to_cpu(ix->ei_leaf) +
502 ((__u64) ext2fs_le16_to_cpu(ix->ei_leaf_hi) << 32);
503 extent->e_lblk = ext2fs_le32_to_cpu(ix->ei_block);
504 if (path->left > 0) {
506 end_blk = ext2fs_le32_to_cpu(ix->ei_block);
508 end_blk = path->end_blk;
510 extent->e_len = end_blk - extent->e_lblk;
513 extent->e_flags |= EXT2_EXTENT_FLAGS_SECOND_VISIT;
515 if (((orig_op == EXT2_EXTENT_NEXT_LEAF) ||
516 (orig_op == EXT2_EXTENT_PREV_LEAF)) &&
517 (handle->level != handle->max_depth))
520 if ((orig_op == EXT2_EXTENT_LAST_LEAF) &&
521 ((handle->level != handle->max_depth) ||
528 static errcode_t update_path(ext2_extent_handle_t handle)
532 struct ext3_extent_idx *ix;
534 if (handle->level == 0) {
535 retval = ext2fs_write_inode_full(handle->fs, handle->ino,
536 handle->inode, EXT2_INODE_SIZE(handle->fs->super));
538 ix = handle->path[handle->level - 1].curr;
539 blk = ext2fs_le32_to_cpu(ix->ei_leaf) +
540 ((__u64) ext2fs_le16_to_cpu(ix->ei_leaf_hi) << 32);
542 retval = io_channel_write_blk(handle->fs->io,
543 blk, 1, handle->path[handle->level].buf);
549 errcode_t ext2fs_extent_save_path(ext2_extent_handle_t handle,
550 ext2_extent_path_t *ret_path)
552 ext2_extent_path_t save_path;
553 struct ext2fs_extent extent;
554 struct ext2_extent_info info;
557 retval = ext2fs_extent_get(handle, EXT2_EXTENT_CURRENT, &extent);
561 retval = ext2fs_extent_get_info(handle, &info);
565 retval = ext2fs_get_mem(sizeof(struct ext2_extent_path), &save_path);
568 memset(save_path, 0, sizeof(struct ext2_extent_path));
570 save_path->magic = EXT2_ET_MAGIC_EXTENT_PATH;
571 save_path->leaf_height = info.max_depth - info.curr_level - 1;
572 save_path->lblk = extent.e_lblk;
574 *ret_path = save_path;
578 errcode_t ext2fs_extent_free_path(ext2_extent_path_t path)
580 EXT2_CHECK_MAGIC(path, EXT2_ET_MAGIC_EXTENT_PATH);
582 ext2fs_free_mem(&path);
588 * Go to the node at leaf_level which contains logical block blk.
590 * leaf_level is height from the leaf node level, i.e.
591 * leaf_level 0 is at leaf node, leaf_level 1 is 1 above etc.
593 * If "blk" has no mapping (hole) then handle is left at last
596 static errcode_t extent_goto(ext2_extent_handle_t handle,
597 int leaf_level, blk64_t blk)
599 struct ext2fs_extent extent;
602 retval = ext2fs_extent_get(handle, EXT2_EXTENT_ROOT, &extent);
606 if (leaf_level > handle->max_depth) {
608 printf("leaf level %d greater than tree depth %d\n",
609 leaf_level, handle->max_depth);
611 return EXT2_ET_OP_NOT_SUPPORTED;
614 dbg_print_extent("root", &extent);
616 if (handle->max_depth - handle->level == leaf_level) {
617 /* block is in this &extent */
618 if ((blk >= extent.e_lblk) &&
619 (blk < extent.e_lblk + extent.e_len))
621 if (blk < extent.e_lblk) {
622 retval = ext2fs_extent_get(handle,
623 EXT2_EXTENT_PREV_SIB,
625 return EXT2_ET_EXTENT_NOT_FOUND;
627 retval = ext2fs_extent_get(handle,
628 EXT2_EXTENT_NEXT_SIB,
630 if (retval == EXT2_ET_EXTENT_NO_NEXT)
631 return EXT2_ET_EXTENT_NOT_FOUND;
637 retval = ext2fs_extent_get(handle, EXT2_EXTENT_NEXT_SIB,
639 if (retval == EXT2_ET_EXTENT_NO_NEXT)
644 dbg_print_extent("next", &extent);
645 if (blk == extent.e_lblk)
647 if (blk > extent.e_lblk)
650 retval = ext2fs_extent_get(handle, EXT2_EXTENT_PREV_SIB,
655 dbg_print_extent("prev", &extent);
658 retval = ext2fs_extent_get(handle, EXT2_EXTENT_DOWN,
663 dbg_print_extent("down", &extent);
667 errcode_t ext2fs_extent_goto(ext2_extent_handle_t handle,
670 return extent_goto(handle, 0, blk);
674 * Traverse back up to root fixing parents of current node as needed.
676 * If we changed start of first entry in a node, fix parent index start
679 * Safe to call for any position in node; if not at the first entry,
680 * will simply return.
682 static errcode_t ext2fs_extent_fix_parents(ext2_extent_handle_t handle)
686 struct extent_path *path;
687 struct ext2fs_extent extent;
689 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
691 if (!(handle->fs->flags & EXT2_FLAG_RW))
692 return EXT2_ET_RO_FILSYS;
695 return EXT2_ET_NO_CURRENT_NODE;
697 path = handle->path + handle->level;
699 return EXT2_ET_NO_CURRENT_NODE;
701 retval = ext2fs_extent_get(handle, EXT2_EXTENT_CURRENT, &extent);
705 /* modified node's start block */
706 start = extent.e_lblk;
708 /* traverse up until index not first, or startblk matches, or top */
709 while (handle->level > 0 &&
710 (path->left == path->entries - 1)) {
711 retval = ext2fs_extent_get(handle, EXT2_EXTENT_UP, &extent);
714 if (extent.e_lblk == start)
716 path = handle->path + handle->level;
717 extent.e_len += (extent.e_lblk - start);
718 extent.e_lblk = start;
719 retval = ext2fs_extent_replace(handle, 0, &extent);
725 /* put handle back to where we started */
726 retval = ext2fs_extent_goto(handle, start);
731 errcode_t ext2fs_extent_replace(ext2_extent_handle_t handle,
732 int flags EXT2FS_ATTR((unused)),
733 struct ext2fs_extent *extent)
735 struct extent_path *path;
736 struct ext3_extent_idx *ix;
737 struct ext3_extent *ex;
739 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
741 if (!(handle->fs->flags & EXT2_FLAG_RW))
742 return EXT2_ET_RO_FILSYS;
745 return EXT2_ET_NO_CURRENT_NODE;
747 path = handle->path + handle->level;
749 return EXT2_ET_NO_CURRENT_NODE;
751 if (handle->level == handle->max_depth) {
754 ex->ee_block = ext2fs_cpu_to_le32(extent->e_lblk);
755 ex->ee_start = ext2fs_cpu_to_le32(extent->e_pblk & 0xFFFFFFFF);
756 ex->ee_start_hi = ext2fs_cpu_to_le16(extent->e_pblk >> 32);
757 if (extent->e_flags & EXT2_EXTENT_FLAGS_UNINIT) {
758 if (extent->e_len > EXT_UNINIT_MAX_LEN)
759 return EXT2_ET_EXTENT_INVALID_LENGTH;
760 ex->ee_len = ext2fs_cpu_to_le16(extent->e_len +
763 if (extent->e_len > EXT_INIT_MAX_LEN)
764 return EXT2_ET_EXTENT_INVALID_LENGTH;
765 ex->ee_len = ext2fs_cpu_to_le16(extent->e_len);
770 ix->ei_leaf = ext2fs_cpu_to_le32(extent->e_pblk & 0xFFFFFFFF);
771 ix->ei_leaf_hi = ext2fs_cpu_to_le16(extent->e_pblk >> 32);
772 ix->ei_block = ext2fs_cpu_to_le32(extent->e_lblk);
780 * allocate a new block, move half the current node to it, and update parent
782 * handle will be left pointing at original record.
784 static errcode_t extent_node_split(ext2_extent_handle_t handle)
786 errcode_t retval = 0;
788 blk64_t new_node_start;
790 blk64_t goal_blk = 0;
792 char *block_buf = NULL;
793 struct ext2fs_extent extent;
794 struct extent_path *path, *newpath = 0;
795 struct ext3_extent_header *eh, *neweh;
798 struct ext2_extent_info info;
801 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
803 if (!(handle->fs->flags & EXT2_FLAG_RW))
804 return EXT2_ET_RO_FILSYS;
807 return EXT2_ET_NO_CURRENT_NODE;
810 printf("splitting node at level %d\n", handle->level);
812 retval = ext2fs_extent_get(handle, EXT2_EXTENT_CURRENT, &extent);
816 retval = ext2fs_extent_get_info(handle, &info);
820 /* save the position we were originally splitting... */
821 orig_height = info.max_depth - info.curr_level;
822 orig_lblk = extent.e_lblk;
824 /* Is there room in the parent for a new entry? */
826 (handle->path[handle->level - 1].entries >=
827 handle->path[handle->level - 1].max_entries)) {
830 printf("parent level %d full; splitting it too\n",
833 /* split the parent */
834 retval = ext2fs_extent_get(handle, EXT2_EXTENT_UP, &extent);
837 goal_blk = extent.e_pblk;
839 retval = extent_node_split(handle);
843 /* get handle back to our original split position */
844 retval = extent_goto(handle, orig_height, orig_lblk);
849 /* At this point, parent should have room for this split */
850 path = handle->path + handle->level;
852 return EXT2_ET_NO_CURRENT_NODE;
854 /* extent header of the current node we'll split */
855 eh = (struct ext3_extent_header *)path->buf;
857 /* splitting root level means moving them all out */
858 if (handle->level == 0) {
860 tocopy = ext2fs_le16_to_cpu(eh->eh_entries);
861 retval = ext2fs_get_mem(((handle->max_depth+2) *
862 sizeof(struct extent_path)),
867 ((handle->max_depth+2) * sizeof(struct extent_path)));
869 tocopy = ext2fs_le16_to_cpu(eh->eh_entries) / 2;
873 printf("will copy out %d of %d entries at level %d\n",
874 tocopy, ext2fs_le16_to_cpu(eh->eh_entries),
880 printf("Nothing to copy to new block!\n");
882 retval = EXT2_ET_CANT_SPLIT_EXTENT;
886 /* first we need a new block, or can do nothing. */
887 block_buf = malloc(handle->fs->blocksize);
894 dgrp_t group = ext2fs_group_of_ino(handle->fs, handle->ino);
895 __u8 log_flex = handle->fs->super->s_log_groups_per_flex;
898 group = group & ~((1 << (log_flex)) - 1);
899 goal_blk = (group * handle->fs->super->s_blocks_per_group) +
900 handle->fs->super->s_first_data_block;
902 retval = ext2fs_alloc_block(handle->fs, (blk_t) goal_blk, block_buf,
908 printf("will copy to new node at block %lu\n", new_node_pblk);
911 /* Copy data into new block buffer */
912 /* First the header for the new block... */
913 neweh = (struct ext3_extent_header *) block_buf;
914 memcpy(neweh, eh, sizeof(struct ext3_extent_header));
915 neweh->eh_entries = ext2fs_cpu_to_le16(tocopy);
916 neweh->eh_max = ext2fs_cpu_to_le16((handle->fs->blocksize -
917 sizeof(struct ext3_extent_header)) /
918 sizeof(struct ext3_extent));
920 /* then the entries for the new block... */
921 memcpy(EXT_FIRST_INDEX(neweh),
922 EXT_FIRST_INDEX(eh) +
923 (ext2fs_le16_to_cpu(eh->eh_entries) - tocopy),
924 sizeof(struct ext3_extent_idx) * tocopy);
926 new_node_start = ext2fs_le32_to_cpu(EXT_FIRST_INDEX(neweh)->ei_block);
928 /* ...and write the new node block out to disk. */
929 retval = io_channel_write_blk(handle->fs->io, new_node_pblk, 1, block_buf);
934 /* OK! we've created the new node; now adjust the tree */
936 /* current path now has fewer active entries, we copied some out */
937 if (handle->level == 0) {
938 memcpy(newpath, path,
939 sizeof(struct extent_path) * (handle->max_depth+1));
940 handle->path = newpath;
944 path->left = path->max_entries - 1;
946 eh->eh_depth = ext2fs_cpu_to_le16(handle->max_depth);
948 path->entries -= tocopy;
949 path->left -= tocopy;
952 eh->eh_entries = ext2fs_cpu_to_le16(path->entries);
953 /* this writes out the node, incl. the modified header */
954 retval = update_path(handle);
958 /* now go up and insert/replace index for new node we created */
960 retval = ext2fs_extent_get(handle, EXT2_EXTENT_FIRST_SIB, &extent);
964 extent.e_lblk = new_node_start;
965 extent.e_pblk = new_node_pblk;
966 extent.e_len = handle->path[0].end_blk - extent.e_lblk;
967 retval = ext2fs_extent_replace(handle, 0, &extent);
971 __u32 new_node_length;
973 retval = ext2fs_extent_get(handle, EXT2_EXTENT_UP, &extent);
974 /* will insert after this one; it's length is shorter now */
975 new_node_length = new_node_start - extent.e_lblk;
976 extent.e_len -= new_node_length;
977 retval = ext2fs_extent_replace(handle, 0, &extent);
981 /* now set up the new extent and insert it */
982 extent.e_lblk = new_node_start;
983 extent.e_pblk = new_node_pblk;
984 extent.e_len = new_node_length;
985 retval = ext2fs_extent_insert(handle, EXT2_EXTENT_INSERT_AFTER, &extent);
990 /* get handle back to our original position */
991 retval = extent_goto(handle, orig_height, orig_lblk);
995 /* new node hooked in, so update inode block count (do this here?) */
996 handle->inode->i_blocks += handle->fs->blocksize / 512;
997 retval = ext2fs_write_inode_full(handle->fs, handle->ino,
998 handle->inode, EXT2_INODE_SIZE(handle->fs->super));
1004 ext2fs_free_mem(&newpath);
1011 errcode_t ext2fs_extent_insert(ext2_extent_handle_t handle, int flags,
1012 struct ext2fs_extent *extent)
1014 struct extent_path *path;
1015 struct ext3_extent_idx *ix;
1016 struct ext3_extent_header *eh;
1019 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
1021 if (!(handle->fs->flags & EXT2_FLAG_RW))
1022 return EXT2_ET_RO_FILSYS;
1025 return EXT2_ET_NO_CURRENT_NODE;
1027 path = handle->path + handle->level;
1029 if (path->entries >= path->max_entries) {
1030 if (flags & EXT2_EXTENT_INSERT_NOSPLIT) {
1031 return EXT2_ET_CANT_INSERT_EXTENT;
1034 printf("node full (level %d) - splitting\n",
1037 retval = extent_node_split(handle);
1040 path = handle->path + handle->level;
1044 eh = (struct ext3_extent_header *) path->buf;
1047 if (flags & EXT2_EXTENT_INSERT_AFTER) {
1052 ix = EXT_FIRST_INDEX(eh);
1056 if (path->left >= 0)
1058 (path->left+1) * sizeof(struct ext3_extent_idx));
1062 eh = (struct ext3_extent_header *) path->buf;
1063 eh->eh_entries = ext2fs_cpu_to_le16(path->entries);
1065 retval = ext2fs_extent_replace(handle, 0, extent);
1069 retval = update_path(handle);
1076 ext2fs_extent_delete(handle, 0);
1081 * Sets the physical block for a logical file block in the extent tree.
1083 * May: map unmapped, unmap mapped, or remap mapped blocks.
1085 * Mapping an unmapped block adds a single-block extent.
1087 * Unmapping first or last block modifies extent in-place
1088 * - But may need to fix parent's starts too in first-block case
1090 * Mapping any unmapped block requires adding a (single-block) extent
1091 * and inserting into proper point in tree.
1093 * Modifying (unmapping or remapping) a block in the middle
1094 * of an extent requires splitting the extent.
1095 * - Remapping case requires new single-block extent.
1097 * Remapping first or last block adds an extent.
1099 * We really need extent adding to be smart about merging.
1102 errcode_t ext2fs_extent_set_bmap(ext2_extent_handle_t handle,
1103 blk64_t logical, blk64_t physical, int flags)
1105 errcode_t ec, retval = 0;
1106 int mapped = 1; /* logical is mapped? */
1108 int extent_uninit = 0;
1110 int max_len = EXT_INIT_MAX_LEN;
1112 struct extent_path *path;
1113 struct ext2fs_extent extent;
1114 struct ext2fs_extent newextent;
1115 struct ext2_extent_info info;
1117 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
1119 if (!(handle->fs->flags & EXT2_FLAG_RW))
1120 return EXT2_ET_RO_FILSYS;
1123 return EXT2_ET_NO_CURRENT_NODE;
1125 path = handle->path + handle->level;
1127 if (flags & EXT2_EXTENT_SET_BMAP_UNINIT) {
1129 max_len = EXT_UNINIT_MAX_LEN;
1132 /* if (re)mapping, set up new extent to insert */
1134 newextent.e_len = 1;
1135 newextent.e_pblk = physical;
1136 newextent.e_lblk = logical;
1137 newextent.e_flags = EXT2_EXTENT_FLAGS_LEAF;
1139 newextent.e_flags |= EXT2_EXTENT_FLAGS_UNINIT;
1142 /* special case if the extent tree is completely empty */
1143 if ((handle->max_depth == 0) && (path->entries == 0)) {
1144 retval = ext2fs_extent_insert(handle, 0, &newextent);
1148 /* save our original location in the extent tree */
1149 if ((retval = ext2fs_extent_get(handle, EXT2_EXTENT_CURRENT,
1151 if (retval != EXT2_ET_NO_CURRENT_NODE)
1153 memset(&extent, 0, sizeof(extent));
1155 if ((retval = ext2fs_extent_get_info(handle, &info)))
1157 orig_height = info.max_depth - info.curr_level;
1158 orig_lblk = extent.e_lblk;
1160 /* go to the logical spot we want to (re/un)map */
1161 retval = ext2fs_extent_goto(handle, logical);
1163 if (retval == EXT2_ET_EXTENT_NOT_FOUND) {
1168 printf("block %llu already unmapped\n",
1178 * This may be the extent *before* the requested logical,
1179 * if it's currently unmapped.
1181 retval = ext2fs_extent_get(handle, EXT2_EXTENT_CURRENT, &extent);
1184 if (extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT)
1187 /* check if already pointing to the requested physical */
1188 if (mapped && (new_uninit == extent_uninit) &&
1189 (extent.e_pblk + (logical - extent.e_lblk) == physical)) {
1191 printf("physical block (at %llu) unchanged\n", logical);
1198 printf("mapping unmapped logical block %llu\n", logical);
1200 if ((logical == extent.e_lblk + extent.e_len) &&
1201 (physical == extent.e_pblk + extent.e_len) &&
1202 (new_uninit == extent_uninit) &&
1203 ((int) extent.e_len < max_len-1)) {
1205 retval = ext2fs_extent_replace(handle, 0, &extent);
1206 } else if (logical < extent.e_lblk)
1207 retval = ext2fs_extent_insert(handle, 0, &newextent);
1209 retval = ext2fs_extent_insert(handle,
1210 EXT2_EXTENT_INSERT_AFTER, &newextent);
1213 retval = ext2fs_extent_fix_parents(handle);
1216 } else if ((logical == extent.e_lblk) && (extent.e_len == 1)) {
1218 printf("(re/un)mapping only block in extent\n");
1221 extent.e_pblk = physical;
1222 retval = ext2fs_extent_replace(handle, 0, &extent);
1224 retval = ext2fs_extent_delete(handle, 0);
1227 ec = ext2fs_extent_fix_parents(handle);
1228 if (ec != EXT2_ET_NO_CURRENT_NODE)
1234 } else if (logical == extent.e_lblk + extent.e_len - 1) {
1236 printf("(re/un)mapping last block in extent\n");
1239 retval = ext2fs_extent_replace(handle, 0, &extent);
1243 retval = ext2fs_extent_insert(handle,
1244 EXT2_EXTENT_INSERT_AFTER, &newextent);
1248 } else if (logical == extent.e_lblk) {
1250 printf("(re/un)mapping first block in extent\n");
1255 retval = ext2fs_extent_replace(handle, 0, &extent);
1259 /* insert new extent ahead of current */
1260 retval = ext2fs_extent_insert(handle,
1265 retval = ext2fs_extent_fix_parents(handle);
1273 printf("(re/un)mapping in middle of extent\n");
1275 /* need to split this extent; later */
1277 orig_length = extent.e_len;
1279 /* shorten pre-split extent */
1280 extent.e_len = (logical - extent.e_lblk);
1281 retval = ext2fs_extent_replace(handle, 0, &extent);
1284 /* insert our new extent, if any */
1286 /* insert new extent after current */
1287 retval = ext2fs_extent_insert(handle,
1288 EXT2_EXTENT_INSERT_AFTER, &newextent);
1292 /* add post-split extent */
1293 extent.e_pblk += extent.e_len + 1;
1294 extent.e_lblk += extent.e_len + 1;
1295 extent.e_len = orig_length - extent.e_len - 1;
1296 retval = ext2fs_extent_insert(handle,
1297 EXT2_EXTENT_INSERT_AFTER, &extent);
1303 /* get handle back to its position */
1304 if (orig_height > handle->max_depth)
1305 orig_height = handle->max_depth; /* In case we shortened the tree */
1306 extent_goto(handle, orig_height, orig_lblk);
1310 errcode_t ext2fs_extent_delete(ext2_extent_handle_t handle, int flags)
1312 struct extent_path *path;
1314 struct ext3_extent_header *eh;
1315 errcode_t retval = 0;
1317 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
1319 if (!(handle->fs->flags & EXT2_FLAG_RW))
1320 return EXT2_ET_RO_FILSYS;
1323 return EXT2_ET_NO_CURRENT_NODE;
1325 path = handle->path + handle->level;
1327 return EXT2_ET_NO_CURRENT_NODE;
1332 memmove(cp, cp + sizeof(struct ext3_extent_idx),
1333 path->left * sizeof(struct ext3_extent_idx));
1336 struct ext3_extent_idx *ix = path->curr;
1340 if (--path->entries == 0)
1343 /* if non-root node has no entries left, remove it & parent ptr to it */
1344 if (path->entries == 0 && handle->level) {
1345 if (!(flags & EXT2_EXTENT_DELETE_KEEP_EMPTY)) {
1346 struct ext2fs_extent extent;
1348 retval = ext2fs_extent_get(handle, EXT2_EXTENT_UP,
1353 retval = ext2fs_extent_delete(handle, flags);
1354 handle->inode->i_blocks -= handle->fs->blocksize / 512;
1355 retval = ext2fs_write_inode_full(handle->fs,
1356 handle->ino, handle->inode,
1357 EXT2_INODE_SIZE(handle->fs->super));
1358 ext2fs_block_alloc_stats(handle->fs, extent.e_pblk, -1);
1361 eh = (struct ext3_extent_header *) path->buf;
1362 eh->eh_entries = ext2fs_cpu_to_le16(path->entries);
1363 if ((path->entries == 0) && (handle->level == 0))
1364 eh->eh_depth = handle->max_depth = 0;
1365 retval = update_path(handle);
1370 errcode_t ext2fs_extent_get_info(ext2_extent_handle_t handle,
1371 struct ext2_extent_info *info)
1373 struct extent_path *path;
1375 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
1377 memset(info, 0, sizeof(struct ext2_extent_info));
1379 path = handle->path + handle->level;
1382 info->curr_entry = ((char *) path->curr - path->buf) /
1383 sizeof(struct ext3_extent_idx);
1385 info->curr_entry = 0;
1386 info->num_entries = path->entries;
1387 info->max_entries = path->max_entries;
1388 info->bytes_avail = (path->max_entries - path->entries) *
1389 sizeof(struct ext3_extent);
1392 info->curr_level = handle->level;
1393 info->max_depth = handle->max_depth;
1394 info->max_lblk = ((__u64) 1 << 32) - 1;
1395 info->max_pblk = ((__u64) 1 << 48) - 1;
1396 info->max_len = (1UL << 15);
1397 info->max_uninit_len = (1UL << 15) - 1;
1406 #include "debugfs.h"
1409 * Hook in new commands into debugfs
1411 const char *debug_prog_name = "tst_extents";
1412 extern ss_request_table extent_cmds;
1413 ss_request_table *extra_cmds = &extent_cmds;
1415 ext2_ino_t current_ino = 0;
1416 ext2_extent_handle_t current_handle;
1418 int common_extent_args_process(int argc, char *argv[], int min_argc,
1419 int max_argc, const char *cmd,
1420 const char *usage, int flags)
1422 if (common_args_process(argc, argv, min_argc, max_argc, cmd,
1426 if (!current_handle) {
1427 com_err(cmd, 0, "Extent handle not open");
1433 void do_inode(int argc, char *argv[])
1437 struct ext3_extent_header *eh;
1440 if (check_fs_open(argv[0]))
1445 printf("Current inode is %d\n", current_ino);
1447 printf("No current inode\n");
1451 if (common_inode_args_process(argc, argv, &inode, 0)) {
1457 retval = ext2fs_extent_open(current_fs, inode, ¤t_handle);
1459 com_err(argv[1], retval, "while opening extent handle");
1463 current_ino = inode;
1465 printf("Loaded inode %d\n", current_ino);
1470 void generic_goto_node(char *cmd_name, int op)
1472 struct ext2fs_extent extent;
1475 if (check_fs_open(cmd_name))
1478 if (!current_handle) {
1479 com_err(cmd_name, 0, "Extent handle not open");
1483 retval = ext2fs_extent_get(current_handle, op, &extent);
1485 com_err(cmd_name, retval, 0);
1488 dbg_print_extent(0, &extent);
1491 void do_current_node(int argc, char *argv[])
1493 generic_goto_node(argv[0], EXT2_EXTENT_CURRENT);
1496 void do_root_node(int argc, char *argv[])
1498 generic_goto_node(argv[0], EXT2_EXTENT_ROOT);
1501 void do_last_leaf(int argc, char *argv[])
1503 generic_goto_node(argv[0], EXT2_EXTENT_LAST_LEAF);
1506 void do_first_sib(int argc, char *argv[])
1508 generic_goto_node(argv[0], EXT2_EXTENT_FIRST_SIB);
1511 void do_last_sib(int argc, char *argv[])
1513 generic_goto_node(argv[0], EXT2_EXTENT_LAST_SIB);
1516 void do_next_sib(int argc, char *argv[])
1518 generic_goto_node(argv[0], EXT2_EXTENT_NEXT_SIB);
1521 void do_prev_sib(int argc, char *argv[])
1523 generic_goto_node(argv[0], EXT2_EXTENT_PREV_SIB);
1526 void do_next_leaf(int argc, char *argv[])
1528 generic_goto_node(argv[0], EXT2_EXTENT_NEXT_LEAF);
1531 void do_prev_leaf(int argc, char *argv[])
1533 generic_goto_node(argv[0], EXT2_EXTENT_PREV_LEAF);
1536 void do_next(int argc, char *argv[])
1538 generic_goto_node(argv[0], EXT2_EXTENT_NEXT);
1541 void do_prev(int argc, char *argv[])
1543 generic_goto_node(argv[0], EXT2_EXTENT_PREV);
1546 void do_up(int argc, char *argv[])
1548 generic_goto_node(argv[0], EXT2_EXTENT_UP);
1551 void do_down(int argc, char *argv[])
1553 generic_goto_node(argv[0], EXT2_EXTENT_DOWN);
1556 void do_delete_node(int argc, char *argv[])
1561 if (common_extent_args_process(argc, argv, 1, 1, "delete_node",
1562 "", CHECK_FS_RW | CHECK_FS_BITMAPS))
1565 retval = ext2fs_extent_delete(current_handle, 0);
1567 com_err(argv[0], retval, 0);
1570 if (current_handle->path && current_handle->path[0].curr)
1571 do_current_node(argc, argv);
1574 void do_replace_node(int argc, char *argv[])
1576 const char *usage = "[--uninit] <lblk> <len> <pblk>";
1578 struct ext2fs_extent extent;
1581 if (common_extent_args_process(argc, argv, 3, 5, "replace_node",
1582 usage, CHECK_FS_RW | CHECK_FS_BITMAPS))
1587 if (!strcmp(argv[1], "--uninit")) {
1590 extent.e_flags |= EXT2_EXTENT_FLAGS_UNINIT;
1594 fprintf(stderr, "Usage: %s %s\n", argv[0], usage);
1598 extent.e_lblk = parse_ulong(argv[1], argv[0], "logical block", &err);
1602 extent.e_len = parse_ulong(argv[2], argv[0], "logical block", &err);
1606 extent.e_pblk = parse_ulong(argv[3], argv[0], "logical block", &err);
1610 retval = ext2fs_extent_replace(current_handle, 0, &extent);
1612 com_err(argv[0], retval, 0);
1615 do_current_node(argc, argv);
1618 void do_split_node(int argc, char *argv[])
1621 struct ext2fs_extent extent;
1624 if (common_extent_args_process(argc, argv, 1, 1, "split_node",
1625 "", CHECK_FS_RW | CHECK_FS_BITMAPS))
1628 retval = extent_node_split(current_handle);
1630 com_err(argv[0], retval, 0);
1633 do_current_node(argc, argv);
1636 void do_insert_node(int argc, char *argv[])
1638 const char *usage = "[--after] [--uninit] <lblk> <len> <pblk>";
1640 struct ext2fs_extent extent;
1645 if (common_extent_args_process(argc, argv, 3, 6, "insert_node",
1646 usage, CHECK_FS_RW | CHECK_FS_BITMAPS))
1654 if (!strcmp(argv[1], "--after")) {
1657 flags |= EXT2_EXTENT_INSERT_AFTER;
1660 if (!strcmp(argv[1], "--uninit")) {
1663 extent.e_flags |= EXT2_EXTENT_FLAGS_UNINIT;
1670 fprintf(stderr, "usage: %s %s\n", cmd, usage);
1674 extent.e_lblk = parse_ulong(argv[1], cmd,
1675 "logical block", &err);
1679 extent.e_len = parse_ulong(argv[2], cmd,
1684 extent.e_pblk = parse_ulong(argv[3], cmd,
1685 "pysical block", &err);
1689 retval = ext2fs_extent_insert(current_handle, flags, &extent);
1691 com_err(cmd, retval, 0);
1694 do_current_node(argc, argv);
1697 void do_set_bmap(int argc, char **argv)
1699 const char *usage = "[--uninit] <lblk> <pblk>";
1703 char *cmd = argv[0];
1707 if (common_extent_args_process(argc, argv, 3, 5, "set_bmap",
1708 usage, CHECK_FS_RW | CHECK_FS_BITMAPS))
1711 if (argc > 2 && !strcmp(argv[1], "--uninit")) {
1714 flags |= EXT2_EXTENT_SET_BMAP_UNINIT;
1718 fprintf(stderr, "Usage: %s %s\n", cmd, usage);
1722 logical = parse_ulong(argv[1], cmd,
1723 "logical block", &err);
1727 physical = parse_ulong(argv[2], cmd,
1728 "physical block", &err);
1732 retval = ext2fs_extent_set_bmap(current_handle, logical,
1733 (blk64_t) physical, flags);
1735 com_err(cmd, retval, 0);
1738 if (current_handle->path && current_handle->path[0].curr)
1739 do_current_node(argc, argv);
1742 void do_print_all(int argc, char **argv)
1744 const char *usage = "[--leaf-only|--reverse|--reverse-leaf]";
1745 struct ext2fs_extent extent;
1747 errcode_t end_err = EXT2_ET_EXTENT_NO_NEXT;
1748 int op = EXT2_EXTENT_NEXT;
1749 int first_op = EXT2_EXTENT_ROOT;
1752 if (common_extent_args_process(argc, argv, 1, 2, "print_all",
1757 if (!strcmp(argv[1], "--leaf-only"))
1758 op = EXT2_EXTENT_NEXT_LEAF;
1759 else if (!strcmp(argv[1], "--reverse")) {
1760 op = EXT2_EXTENT_PREV;
1761 first_op = EXT2_EXTENT_LAST_LEAF;
1762 end_err = EXT2_ET_EXTENT_NO_PREV;
1763 } else if (!strcmp(argv[1], "--reverse-leaf")) {
1764 op = EXT2_EXTENT_PREV_LEAF;
1765 first_op = EXT2_EXTENT_LAST_LEAF;
1766 end_err = EXT2_ET_EXTENT_NO_PREV;
1768 fprintf(stderr, "Usage: %s %s\n", argv[0], usage);
1773 retval = ext2fs_extent_get(current_handle, first_op, &extent);
1775 com_err(argv[0], retval, 0);
1778 dbg_print_extent(0, &extent);
1781 retval = ext2fs_extent_get(current_handle, op, &extent);
1782 if (retval == end_err)
1786 com_err(argv[0], retval, 0);
1789 dbg_print_extent(0, &extent);
1793 void do_info(int argc, char **argv)
1795 struct ext2fs_extent extent;
1796 struct ext2_extent_info info;
1799 if (common_extent_args_process(argc, argv, 1, 1, "info", "", 0))
1802 retval = ext2fs_extent_get_info(current_handle, &info);
1804 com_err(argv[0], retval, 0);
1808 retval = ext2fs_extent_get(current_handle,
1809 EXT2_EXTENT_CURRENT, &extent);
1811 com_err(argv[0], retval, 0);
1815 dbg_print_extent(0, &extent);
1817 printf("Current handle location: %d/%d (max: %d, bytes %d), level %d/%d\n",
1818 info.curr_entry, info.num_entries, info.max_entries,
1819 info.bytes_avail, info.curr_level, info.max_depth);
1820 printf("\tmax lblk: %llu, max pblk: %llu\n", info.max_lblk,
1822 printf("\tmax_len: %u, max_uninit_len: %u\n", info.max_len,
1823 info.max_uninit_len);
1826 void do_goto_block(int argc, char **argv)
1828 struct ext2fs_extent extent;
1830 int op = EXT2_EXTENT_NEXT_LEAF;
1834 if (common_extent_args_process(argc, argv, 2, 3, "goto_block",
1835 "block [level]", 0))
1838 if (strtoblk(argv[0], argv[1], &blk))
1842 if (strtoblk(argv[0], argv[2], &level))
1845 retval = extent_goto(current_handle, level, (blk64_t) blk);
1848 com_err(argv[0], retval, "while trying to go to block %lu, level %d",
1853 generic_goto_node(argv[0], EXT2_EXTENT_CURRENT);