lib/ext2fs/extent.c

   1 /*
   2  * extent.c --- routines to implement extents support
   3  *
   4  * Copyright (C) 2007 Theodore Ts'o.
   5  *
   6  * %Begin-Header%
   7  * This file may be redistributed under the terms of the GNU Public
   8  * License.
   9  * %End-Header%
  10  */
  11
  12 #include <stdio.h>
  13 #include <string.h>
  14 #if HAVE_UNISTD_H
  15 #include <unistd.h>
  16 #endif
  17 #if HAVE_ERRNO_H
  18 #include <errno.h>
  19 #endif
  20 #if HAVE_SYS_STAT_H
  21 #include <sys/stat.h>
  22 #endif
  23 #if HAVE_SYS_TYPES_H
  24 #include <sys/types.h>
  25 #endif
  26
  27 #include "ext2_fs.h"
  28 #include "ext2fsP.h"
  29 #include "e2image.h"
  30
  31 /*
  32  * Definitions to be dropped in lib/ext2fs/ext2fs.h
  33  */
  34
  35 /*
  36  * Private definitions
  37  */
  38
  39 struct extent_path {
  40         char            *buf;
  41         int             entries;
  42         int             max_entries;
  43         int             left;
  44         int             visit_num;
  45         int             flags;
  46         blk64_t         end_blk;
  47         void            *curr;
  48 };
  49
  50
  51 struct ext2_extent_handle {
  52         errcode_t               magic;
  53         ext2_filsys             fs;
  54         ext2_ino_t              ino;
  55         struct ext2_inode       *inode;
  56         int                     type;
  57         int                     level;
  58         int                     max_depth;
  59         struct extent_path      *path;
  60 };
  61
  62 struct ext2_extent_path {
  63         errcode_t               magic;
  64         int                     leaf_height;
  65         blk64_t                 lblk;
  66 };
  67
  68 /*
  69  *  Useful Debugging stuff
  70  */
  71
  72 #ifdef DEBUG
  73 static void dbg_show_header(struct ext3_extent_header *eh)
  74 {
  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));
  81 }
  82
  83 static void dbg_show_index(struct ext3_extent_idx *ix)
  84 {
  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));
  90 }
  91
  92 static void dbg_show_extent(struct ext3_extent *ex)
  93 {
  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));
 101 }
 102
 103 static void dbg_print_extent(char *desc, struct ext2fs_extent *extent)
 104 {
 105         if (desc)
 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);
 118         fputc('\n', stdout);
 119
 120 }
 121
 122 #else
 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)
 127 #endif
 128
 129 /*
 130  * Verify the extent header as being sane
 131  */
 132 errcode_t ext2fs_extent_header_verify(void *ptr, int size)
 133 {
 134         int eh_max, entry_size;
 135         struct ext3_extent_header *eh = ptr;
 136
 137         dbg_show_header(eh);
 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);
 144         else
 145                 entry_size = sizeof(struct ext3_extent_idx);
 146
 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;
 153
 154         return 0;
 155 }
 156
 157
 158 /*
 159  * Begin functions to handle an inode's extent information
 160  */
 161 extern void ext2fs_extent_free(ext2_extent_handle_t handle)
 162 {
 163         int                     i;
 164
 165         if (!handle)
 166                 return;
 167
 168         if (handle->inode)
 169                 ext2fs_free_mem(&handle->inode);
 170         if (handle->path) {
 171                 for (i=1; i <= handle->max_depth; i++) {
 172                         if (handle->path[i].buf)
 173                                 ext2fs_free_mem(&handle->path[i].buf);
 174                 }
 175                 ext2fs_free_mem(&handle->path);
 176         }
 177         ext2fs_free_mem(&handle);
 178 }
 179
 180 extern errcode_t ext2fs_extent_open(ext2_filsys fs, ext2_ino_t ino,
 181                                     ext2_extent_handle_t *ret_handle)
 182 {
 183         return ext2fs_extent_open2(fs, ino, NULL, ret_handle);
 184 }
 185
 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)
 189 {
 190         struct ext2_extent_handle       *handle;
 191         errcode_t                       retval;
 192         int                             i;
 193         struct ext3_extent_header       *eh;
 194
 195         EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 196
 197         if (!inode)
 198                 if ((ino == 0) || (ino > fs->super->s_inodes_count))
 199                         return EXT2_ET_BAD_INODE_NUM;
 200
 201         retval = ext2fs_get_mem(sizeof(struct ext2_extent_handle), &handle);
 202         if (retval)
 203                 return retval;
 204         memset(handle, 0, sizeof(struct ext2_extent_handle));
 205
 206         retval = ext2fs_get_mem(sizeof(struct ext2_inode), &handle->inode);
 207         if (retval)
 208                 goto errout;
 209
 210         handle->ino = ino;
 211         handle->fs = fs;
 212
 213         if (inode) {
 214                 memcpy(handle->inode, inode, sizeof(struct ext2_inode));
 215         }
 216         else {
 217                 retval = ext2fs_read_inode(fs, ino, handle->inode);
 218                 if (retval)
 219                         goto errout;
 220         }
 221
 222         eh = (struct ext3_extent_header *) &handle->inode->i_block[0];
 223
 224         for (i=0; i < EXT2_N_BLOCKS; i++)
 225                 if (handle->inode->i_block[i])
 226                         break;
 227         if (i >= EXT2_N_BLOCKS) {
 228                 eh->eh_magic = ext2fs_cpu_to_le16(EXT3_EXT_MAGIC);
 229                 eh->eh_depth = 0;
 230                 eh->eh_entries = 0;
 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;
 235         }
 236
 237         if (!(handle->inode->i_flags & EXT4_EXTENTS_FL)) {
 238                 retval = EXT2_ET_INODE_NOT_EXTENT;
 239                 goto errout;
 240         }
 241
 242         retval = ext2fs_extent_header_verify(eh, sizeof(handle->inode->i_block));
 243         if (retval)
 244                 goto errout;
 245
 246         handle->max_depth = ext2fs_le16_to_cpu(eh->eh_depth);
 247         handle->type = ext2fs_le16_to_cpu(eh->eh_magic);
 248
 249         retval = ext2fs_get_mem(((handle->max_depth+1) *
 250                                  sizeof(struct extent_path)),
 251                                 &handle->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;
 255
 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;
 265         handle->level = 0;
 266         handle->magic = EXT2_ET_MAGIC_EXTENT_HANDLE;
 267
 268         *ret_handle = handle;
 269         return 0;
 270
 271 errout:
 272         ext2fs_extent_free(handle);
 273         return retval;
 274 }
 275
 276 /*
 277  * This function is responsible for (optionally) moving through the
 278  * extent tree and then returning the current extent
 279  */
 280 errcode_t ext2fs_extent_get(ext2_extent_handle_t handle,
 281                             int flags, struct ext2fs_extent *extent)
 282 {
 283         struct extent_path      *path, *newpath;
 284         struct ext3_extent_header       *eh;
 285         struct ext3_extent_idx          *ix = 0;
 286         struct ext3_extent              *ex;
 287         errcode_t                       retval;
 288         blk_t                           blk;
 289         blk64_t                         end_blk;
 290         int                             orig_op, op;
 291
 292         EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
 293
 294         if (!handle->path)
 295                 return EXT2_ET_NO_CURRENT_NODE;
 296
 297         orig_op = op = flags & EXT2_EXTENT_MOVE_MASK;
 298
 299 retry:
 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) {
 304                         /* interior node */
 305                         if (path->visit_num == 0) {
 306                                 path->visit_num++;
 307                                 op = EXT2_EXTENT_DOWN;
 308                         } else if (path->left > 0)
 309                                 op = EXT2_EXTENT_NEXT_SIB;
 310                         else if (handle->level > 0)
 311                                 op = EXT2_EXTENT_UP;
 312                         else
 313                                 return EXT2_ET_EXTENT_NO_NEXT;
 314                 } else {
 315                         /* leaf node */
 316                         if (path->left > 0)
 317                                 op = EXT2_EXTENT_NEXT_SIB;
 318                         else if (handle->level > 0)
 319                                 op = EXT2_EXTENT_UP;
 320                         else
 321                                 return EXT2_ET_EXTENT_NO_NEXT;
 322                 }
 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"));
 328 #endif
 329                 }
 330         }
 331
 332         if ((orig_op == EXT2_EXTENT_PREV) ||
 333             (orig_op == EXT2_EXTENT_PREV_LEAF)) {
 334                 if (handle->level < handle->max_depth) {
 335                         /* interior node */
 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)
 342                                 op = EXT2_EXTENT_UP;
 343                         else
 344                                 return EXT2_ET_EXTENT_NO_PREV;
 345                 } else {
 346                         /* leaf node */
 347                         if (path->left < path->entries-1)
 348                                 op = EXT2_EXTENT_PREV_SIB;
 349                         else if (handle->level > 0)
 350                                 op = EXT2_EXTENT_UP;
 351                         else
 352                                 return EXT2_ET_EXTENT_NO_PREV;
 353                 }
 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"));
 359 #endif
 360                 }
 361         }
 362
 363         if (orig_op == EXT2_EXTENT_LAST_LEAF) {
 364                 if ((handle->level < handle->max_depth) &&
 365                     (path->left == 0))
 366                         op = EXT2_EXTENT_DOWN;
 367                 else
 368                         op = EXT2_EXTENT_LAST_SIB;
 369 #ifdef DEBUG_GET_EXTENT
 370                 printf("<<<< OP = %s\n",
 371                            (op == EXT2_EXTENT_DOWN) ? "down" : "last_sib");
 372 #endif
 373         }
 374
 375         switch (op) {
 376         case EXT2_EXTENT_CURRENT:
 377                 ix = path->curr;
 378                 break;
 379         case EXT2_EXTENT_ROOT:
 380                 handle->level = 0;
 381                 path = handle->path + handle->level;
 382         case EXT2_EXTENT_FIRST_SIB:
 383                 path->left = path->entries;
 384                 path->curr = 0;
 385         case EXT2_EXTENT_NEXT_SIB:
 386                 if (path->left <= 0)
 387                         return EXT2_ET_EXTENT_NO_NEXT;
 388                 if (path->curr) {
 389                         ix = path->curr;
 390                         ix++;
 391                 } else {
 392                         eh = (struct ext3_extent_header *) path->buf;
 393                         ix = EXT_FIRST_INDEX(eh);
 394                 }
 395                 path->left--;
 396                 path->curr = ix;
 397                 path->visit_num = 0;
 398                 break;
 399         case EXT2_EXTENT_PREV_SIB:
 400                 if (!path->curr ||
 401                     path->left+1 >= path->entries)
 402                         return EXT2_ET_EXTENT_NO_PREV;
 403                 ix = path->curr;
 404                 ix--;
 405                 path->curr = ix;
 406                 path->left++;
 407                 if (handle->level < handle->max_depth)
 408                         path->visit_num = 1;
 409                 break;
 410         case EXT2_EXTENT_LAST_SIB:
 411                 eh = (struct ext3_extent_header *) path->buf;
 412                 path->curr = EXT_LAST_EXTENT(eh);
 413                 ix = path->curr;
 414                 path->left = 0;
 415                 path->visit_num = 0;
 416                 break;
 417         case EXT2_EXTENT_UP:
 418                 if (handle->level <= 0)
 419                         return EXT2_ET_EXTENT_NO_UP;
 420                 handle->level--;
 421                 path--;
 422                 ix = path->curr;
 423                 if ((orig_op == EXT2_EXTENT_PREV) ||
 424                     (orig_op == EXT2_EXTENT_PREV_LEAF))
 425                         path->visit_num = 0;
 426                 break;
 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;
 431
 432                 ix = path->curr;
 433                 newpath = path + 1;
 434                 if (!newpath->buf) {
 435                         retval = ext2fs_get_mem(handle->fs->blocksize,
 436                                                 &newpath->buf);
 437                         if (retval)
 438                                 return retval;
 439                 }
 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);
 445                 else {
 446                         retval = io_channel_read_blk(handle->fs->io,
 447                                                      blk, 1, newpath->buf);
 448                         if (retval)
 449                                 return retval;
 450                 }
 451                 handle->level++;
 452
 453                 eh = (struct ext3_extent_header *) newpath->buf;
 454
 455                 retval = ext2fs_extent_header_verify(eh, handle->fs->blocksize);
 456                 if (retval) {
 457                         handle->level--;
 458                         return retval;
 459                 }
 460
 461                 newpath->left = newpath->entries =
 462                         ext2fs_le16_to_cpu(eh->eh_entries);
 463                 newpath->max_entries = ext2fs_le16_to_cpu(eh->eh_max);
 464
 465                 if (path->left > 0) {
 466                         ix++;
 467                         newpath->end_blk = ext2fs_le32_to_cpu(ix->ei_block);
 468                 } else
 469                         newpath->end_blk = path->end_blk;
 470
 471                 path = newpath;
 472                 if (op == EXT2_EXTENT_DOWN) {
 473                         ix = EXT_FIRST_INDEX((struct ext3_extent_header *) eh);
 474                         path->curr = ix;
 475                         path->left = path->entries - 1;
 476                         path->visit_num = 0;
 477                 } else {
 478                         ix = EXT_LAST_INDEX((struct ext3_extent_header *) eh);
 479                         path->curr = ix;
 480                         path->left = 0;
 481                         if (handle->level < handle->max_depth)
 482                                 path->visit_num = 1;
 483                 }
 484 #ifdef DEBUG_GET_EXTENT
 485                 printf("Down to level %d/%d, end_blk=%llu\n",
 486                            handle->level, handle->max_depth,
 487                            path->end_blk);
 488 #endif
 489                 break;
 490         default:
 491                 return EXT2_ET_OP_NOT_SUPPORTED;
 492         }
 493
 494         if (!ix)
 495                 return EXT2_ET_NO_CURRENT_NODE;
 496
 497         extent->e_flags = 0;
 498 #ifdef DEBUG_GET_EXTENT
 499         printf("(Left %d)\n", path->left);
 500 #endif
 501
 502         if (handle->level == handle->max_depth) {
 503                 ex = (struct ext3_extent *) ix;
 504
 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;
 513                 }
 514         } else {
 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) {
 519                         ix++;
 520                         end_blk = ext2fs_le32_to_cpu(ix->ei_block);
 521                 } else
 522                         end_blk = path->end_blk;
 523
 524                 extent->e_len = end_blk - extent->e_lblk;
 525         }
 526         if (path->visit_num)
 527                 extent->e_flags |= EXT2_EXTENT_FLAGS_SECOND_VISIT;
 528
 529         if (((orig_op == EXT2_EXTENT_NEXT_LEAF) ||
 530              (orig_op == EXT2_EXTENT_PREV_LEAF)) &&
 531             (handle->level != handle->max_depth))
 532                 goto retry;
 533
 534         if ((orig_op == EXT2_EXTENT_LAST_LEAF) &&
 535             ((handle->level != handle->max_depth) ||
 536              (path->left != 0)))
 537                 goto retry;
 538
 539         return 0;
 540 }
 541
 542 static errcode_t update_path(ext2_extent_handle_t handle)
 543 {
 544         blk64_t                         blk;
 545         errcode_t                       retval;
 546         struct ext3_extent_idx          *ix;
 547
 548         if (handle->level == 0) {
 549                 retval = ext2fs_write_inode(handle->fs, handle->ino,
 550                                             handle->inode);
 551         } else {
 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);
 555
 556                 retval = io_channel_write_blk(handle->fs->io,
 557                                       blk, 1, handle->path[handle->level].buf);
 558         }
 559         return retval;
 560 }
 561
 562 #if 0
 563 errcode_t ext2fs_extent_save_path(ext2_extent_handle_t handle,
 564                                   ext2_extent_path_t *ret_path)
 565 {
 566         ext2_extent_path_t      save_path;
 567         struct ext2fs_extent    extent;
 568         struct ext2_extent_info info;
 569         errcode_t               retval;
 570
 571         retval = ext2fs_extent_get(handle, EXT2_EXTENT_CURRENT, &extent);
 572         if (retval)
 573                 return retval;
 574
 575         retval = ext2fs_extent_get_info(handle, &info);
 576         if (retval)
 577                 return retval;
 578
 579         retval = ext2fs_get_mem(sizeof(struct ext2_extent_path), &save_path);
 580         if (retval)
 581                 return retval;
 582         memset(save_path, 0, sizeof(struct ext2_extent_path));
 583
 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;
 587
 588         *ret_path = save_path;
 589         return 0;
 590 }
 591
 592 errcode_t ext2fs_extent_free_path(ext2_extent_path_t path)
 593 {
 594         EXT2_CHECK_MAGIC(path, EXT2_ET_MAGIC_EXTENT_PATH);
 595
 596         ext2fs_free_mem(&path);
 597         return 0;
 598 }
 599 #endif
 600
 601 /*
 602  * Go to the node at leaf_level which contains logical block blk.
 603  *
 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.
 606  *
 607  * If "blk" has no mapping (hole) then handle is left at last
 608  * extent before blk.
 609  */
 610 static errcode_t extent_goto(ext2_extent_handle_t handle,
 611                              int leaf_level, blk64_t blk)
 612 {
 613         struct ext2fs_extent    extent;
 614         errcode_t               retval;
 615
 616         retval = ext2fs_extent_get(handle, EXT2_EXTENT_ROOT, &extent);
 617         if (retval) {
 618                 if (retval == EXT2_ET_EXTENT_NO_NEXT)
 619                         retval = EXT2_ET_EXTENT_NOT_FOUND;
 620                 return retval;
 621         }
 622
 623         if (leaf_level > handle->max_depth) {
 624 #ifdef DEBUG
 625                 printf("leaf level %d greater than tree depth %d\n",
 626                         leaf_level, handle->max_depth);
 627 #endif
 628                 return EXT2_ET_OP_NOT_SUPPORTED;
 629         }
 630
 631 #ifdef DEBUG
 632         printf("goto extent ino %u, level %d, %llu\n", handle->ino,
 633                leaf_level, blk);
 634 #endif
 635
 636 #ifdef DEBUG_GOTO_EXTENTS
 637         dbg_print_extent("root", &extent);
 638 #endif
 639         while (1) {
 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))
 644                                 return 0;
 645                         if (blk < extent.e_lblk) {
 646                                 retval = ext2fs_extent_get(handle,
 647                                                            EXT2_EXTENT_PREV_SIB,
 648                                                            &extent);
 649                                 return EXT2_ET_EXTENT_NOT_FOUND;
 650                         }
 651                         retval = ext2fs_extent_get(handle,
 652                                                    EXT2_EXTENT_NEXT_SIB,
 653                                                    &extent);
 654                         if (retval == EXT2_ET_EXTENT_NO_NEXT)
 655                                 return EXT2_ET_EXTENT_NOT_FOUND;
 656                         if (retval)
 657                                 return retval;
 658                         continue;
 659                 }
 660
 661                 retval = ext2fs_extent_get(handle, EXT2_EXTENT_NEXT_SIB,
 662                                            &extent);
 663                 if (retval == EXT2_ET_EXTENT_NO_NEXT)
 664                         goto go_down;
 665                 if (retval)
 666                         return retval;
 667
 668 #ifdef DEBUG_GOTO_EXTENTS
 669                 dbg_print_extent("next", &extent);
 670 #endif
 671                 if (blk == extent.e_lblk)
 672                         goto go_down;
 673                 if (blk > extent.e_lblk)
 674                         continue;
 675
 676                 retval = ext2fs_extent_get(handle, EXT2_EXTENT_PREV_SIB,
 677                                            &extent);
 678                 if (retval)
 679                         return retval;
 680
 681 #ifdef DEBUG_GOTO_EXTENTS
 682                 dbg_print_extent("prev", &extent);
 683 #endif
 684
 685         go_down:
 686                 retval = ext2fs_extent_get(handle, EXT2_EXTENT_DOWN,
 687                                            &extent);
 688                 if (retval)
 689                         return retval;
 690
 691 #ifdef DEBUG_GOTO_EXTENTS
 692                 dbg_print_extent("down", &extent);
 693 #endif
 694         }
 695 }
 696
 697 errcode_t ext2fs_extent_goto(ext2_extent_handle_t handle,
 698                              blk64_t blk)
 699 {
 700         return extent_goto(handle, 0, blk);
 701 }
 702
 703 /*
 704  * Traverse back up to root fixing parents of current node as needed.
 705  *
 706  * If we changed start of first entry in a node, fix parent index start
 707  * and so on.
 708  *
 709  * Safe to call for any position in node; if not at the first entry,
 710  * will  simply return.
 711  */
 712 static errcode_t ext2fs_extent_fix_parents(ext2_extent_handle_t handle)
 713 {
 714         int                             retval = 0;
 715         blk64_t                         start;
 716         struct extent_path              *path;
 717         struct ext2fs_extent            extent;
 718
 719         EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
 720
 721         if (!(handle->fs->flags & EXT2_FLAG_RW))
 722                 return EXT2_ET_RO_FILSYS;
 723
 724         if (!handle->path)
 725                 return EXT2_ET_NO_CURRENT_NODE;
 726
 727         path = handle->path + handle->level;
 728         if (!path->curr)
 729                 return EXT2_ET_NO_CURRENT_NODE;
 730
 731         retval = ext2fs_extent_get(handle, EXT2_EXTENT_CURRENT, &extent);
 732         if (retval)
 733                 goto done;
 734
 735         /* modified node's start block */
 736         start = extent.e_lblk;
 737
 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);
 742                 if (retval)
 743                         goto done;
 744                 if (extent.e_lblk == start)
 745                         break;
 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);
 750                 if (retval)
 751                         goto done;
 752                 update_path(handle);
 753         }
 754
 755         /* put handle back to where we started */
 756         retval = ext2fs_extent_goto(handle, start);
 757 done:
 758         return retval;
 759 }
 760
 761 errcode_t ext2fs_extent_replace(ext2_extent_handle_t handle,
 762                                 int flags EXT2FS_ATTR((unused)),
 763                                 struct ext2fs_extent *extent)
 764 {
 765         struct extent_path              *path;
 766         struct ext3_extent_idx          *ix;
 767         struct ext3_extent              *ex;
 768
 769         EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
 770
 771         if (!(handle->fs->flags & EXT2_FLAG_RW))
 772                 return EXT2_ET_RO_FILSYS;
 773
 774         if (!handle->path)
 775                 return EXT2_ET_NO_CURRENT_NODE;
 776
 777         path = handle->path + handle->level;
 778         if (!path->curr)
 779                 return EXT2_ET_NO_CURRENT_NODE;
 780
 781 #ifdef DEBUG
 782         printf("extent replace: %u ", handle->ino);
 783         dbg_print_extent(0, extent);
 784 #endif
 785
 786         if (handle->level == handle->max_depth) {
 787                 ex = path->curr;
 788
 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 +
 796                                                         EXT_INIT_MAX_LEN);
 797                 } else {
 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);
 801                 }
 802         } else {
 803                 ix = path->curr;
 804
 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);
 808                 ix->ei_unused = 0;
 809         }
 810         update_path(handle);
 811         return 0;
 812 }
 813
 814 /*
 815  * allocate a new block, move half the current node to it, and update parent
 816  *
 817  * handle will be left pointing at original record.
 818  */
 819 static errcode_t extent_node_split(ext2_extent_handle_t handle)
 820 {
 821         errcode_t                       retval = 0;
 822         blk_t                           new_node_pblk;
 823         blk64_t                         new_node_start;
 824         blk64_t                         orig_lblk;
 825         blk64_t                         goal_blk = 0;
 826         int                             orig_height;
 827         char                            *block_buf = NULL;
 828         struct ext2fs_extent            extent;
 829         struct extent_path              *path, *newpath = 0;
 830         struct ext3_extent_header       *eh, *neweh;
 831         int                             tocopy;
 832         int                             new_root = 0;
 833         struct ext2_extent_info         info;
 834
 835         /* basic sanity */
 836         EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
 837
 838         if (!(handle->fs->flags & EXT2_FLAG_RW))
 839                 return EXT2_ET_RO_FILSYS;
 840
 841         if (!handle->path)
 842                 return EXT2_ET_NO_CURRENT_NODE;
 843
 844 #ifdef DEBUG
 845         printf("splitting node at level %d\n", handle->level);
 846 #endif
 847         retval = ext2fs_extent_get(handle, EXT2_EXTENT_CURRENT, &extent);
 848         if (retval)
 849                 goto done;
 850
 851         retval = ext2fs_extent_get_info(handle, &info);
 852         if (retval)
 853                 goto done;
 854
 855         /* save the position we were originally splitting... */
 856         orig_height = info.max_depth - info.curr_level;
 857         orig_lblk = extent.e_lblk;
 858
 859         /* Is there room in the parent for a new entry? */
 860         if (handle->level &&
 861                         (handle->path[handle->level - 1].entries >=
 862                          handle->path[handle->level - 1].max_entries)) {
 863
 864 #ifdef DEBUG
 865                 printf("parent level %d full; splitting it too\n",
 866                                                         handle->level - 1);
 867 #endif
 868                 /* split the parent */
 869                 retval = ext2fs_extent_get(handle, EXT2_EXTENT_UP, &extent);
 870                 if (retval)
 871                         goto done;
 872                 goal_blk = extent.e_pblk;
 873
 874                 retval = extent_node_split(handle);
 875                 if (retval)
 876                         goto done;
 877
 878                 /* get handle back to our original split position */
 879                 retval = extent_goto(handle, orig_height, orig_lblk);
 880                 if (retval)
 881                         goto done;
 882         }
 883
 884         /* At this point, parent should have room for this split */
 885         path = handle->path + handle->level;
 886         if (!path->curr)
 887                 return EXT2_ET_NO_CURRENT_NODE;
 888
 889         /* extent header of the current node we'll split */
 890         eh = (struct ext3_extent_header *)path->buf;
 891
 892         /* splitting root level means moving them all out */
 893         if (handle->level == 0) {
 894                 new_root = 1;
 895                 tocopy = ext2fs_le16_to_cpu(eh->eh_entries);
 896                 retval = ext2fs_get_mem(((handle->max_depth+2) *
 897                                          sizeof(struct extent_path)),
 898                                         &newpath);
 899                 if (retval)
 900                         goto done;
 901                 memset(newpath, 0,
 902                        ((handle->max_depth+2) * sizeof(struct extent_path)));
 903         } else {
 904                 tocopy = ext2fs_le16_to_cpu(eh->eh_entries) / 2;
 905         }
 906
 907 #ifdef DEBUG
 908         printf("will copy out %d of %d entries at level %d\n",
 909                                 tocopy, ext2fs_le16_to_cpu(eh->eh_entries),
 910                                 handle->level);
 911 #endif
 912
 913         if (!tocopy) {
 914 #ifdef DEBUG
 915                 printf("Nothing to copy to new block!\n");
 916 #endif
 917                 retval = EXT2_ET_CANT_SPLIT_EXTENT;
 918                 goto done;
 919         }
 920
 921         /* first we need a new block, or can do nothing. */
 922         block_buf = malloc(handle->fs->blocksize);
 923         if (!block_buf) {
 924                 retval = ENOMEM;
 925                 goto done;
 926         }
 927
 928         if (!goal_blk) {
 929                 dgrp_t  group = ext2fs_group_of_ino(handle->fs, handle->ino);
 930                 __u8    log_flex = handle->fs->super->s_log_groups_per_flex;
 931
 932                 if (log_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;
 936         }
 937         retval = ext2fs_alloc_block(handle->fs, (blk_t) goal_blk, block_buf,
 938                                     &new_node_pblk);
 939         if (retval)
 940                 goto done;
 941
 942 #ifdef DEBUG
 943         printf("will copy to new node at block %lu\n",
 944                (unsigned long) new_node_pblk);
 945 #endif
 946
 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));
 955
 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);
 961
 962         new_node_start = ext2fs_le32_to_cpu(EXT_FIRST_INDEX(neweh)->ei_block);
 963
 964         /* ...and write the new node block out to disk. */
 965         retval = io_channel_write_blk(handle->fs->io, new_node_pblk, 1, block_buf);
 966
 967         if (retval)
 968                 goto done;
 969
 970         /* OK! we've created the new node; now adjust the tree */
 971
 972         /* current path now has fewer active entries, we copied some out */
 973         if (handle->level == 0) {
 974                 memcpy(newpath, path,
 975                        sizeof(struct extent_path) * (handle->max_depth+1));
 976                 handle->path = newpath;
 977                 newpath = path;
 978                 path = handle->path;
 979                 path->entries = 1;
 980                 path->left = path->max_entries - 1;
 981                 handle->max_depth++;
 982                 eh->eh_depth = ext2fs_cpu_to_le16(handle->max_depth);
 983         } else {
 984                 path->entries -= tocopy;
 985                 path->left -= tocopy;
 986         }
 987
 988         eh->eh_entries = ext2fs_cpu_to_le16(path->entries);
 989         /* this writes out the node, incl. the modified header */
 990         retval = update_path(handle);
 991         if (retval)
 992                 goto done;
 993
 994         /* now go up and insert/replace index for new node we created */
 995         if (new_root) {
 996                 retval = ext2fs_extent_get(handle, EXT2_EXTENT_FIRST_SIB, &extent);
 997                 if (retval)
 998                         goto done;
 999
1000                 extent.e_lblk = new_node_start;
1001                 extent.e_pblk = new_node_pblk;
1002                 extent.e_len = handle->path[0].end_blk - extent.e_lblk;
1003                 retval = ext2fs_extent_replace(handle, 0, &extent);
1004                 if (retval)
1005                         goto done;
1006         } else {
1007                 __u32 new_node_length;
1008
1009                 retval = ext2fs_extent_get(handle, EXT2_EXTENT_UP, &extent);
1010                 /* will insert after this one; it's length is shorter now */
1011                 new_node_length = new_node_start - extent.e_lblk;
1012                 extent.e_len -= new_node_length;
1013                 retval = ext2fs_extent_replace(handle, 0, &extent);
1014                 if (retval)
1015                         goto done;
1016
1017                 /* now set up the new extent and insert it */
1018                 extent.e_lblk = new_node_start;
1019                 extent.e_pblk = new_node_pblk;
1020                 extent.e_len = new_node_length;
1021                 retval = ext2fs_extent_insert(handle, EXT2_EXTENT_INSERT_AFTER, &extent);
1022                 if (retval)
1023                         goto done;
1024         }
1025
1026         /* get handle back to our original position */
1027         retval = extent_goto(handle, orig_height, orig_lblk);
1028         if (retval)
1029                 goto done;
1030
1031         /* new node hooked in, so update inode block count (do this here?) */
1032         handle->inode->i_blocks += handle->fs->blocksize / 512;
1033         retval = ext2fs_write_inode(handle->fs, handle->ino,
1034                                     handle->inode);
1035         if (retval)
1036                 goto done;
1037
1038 done:
1039         if (newpath)
1040                 ext2fs_free_mem(&newpath);
1041         free(block_buf);
1042
1043         return retval;
1044 }
1045
1046 errcode_t ext2fs_extent_insert(ext2_extent_handle_t handle, int flags,
1047                                       struct ext2fs_extent *extent)
1048 {
1049         struct extent_path              *path;
1050         struct ext3_extent_idx          *ix;
1051         struct ext3_extent_header       *eh;
1052         errcode_t                       retval;
1053
1054         EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
1055
1056         if (!(handle->fs->flags & EXT2_FLAG_RW))
1057                 return EXT2_ET_RO_FILSYS;
1058
1059         if (!handle->path)
1060                 return EXT2_ET_NO_CURRENT_NODE;
1061
1062 #ifdef DEBUG
1063         printf("extent insert: %u ", handle->ino);
1064         dbg_print_extent(0, extent);
1065 #endif
1066
1067         path = handle->path + handle->level;
1068
1069         if (path->entries >= path->max_entries) {
1070                 if (flags & EXT2_EXTENT_INSERT_NOSPLIT) {
1071                         return EXT2_ET_CANT_INSERT_EXTENT;
1072                 } else {
1073 #ifdef DEBUG
1074                         printf("node full (level %d) - splitting\n",
1075                                    handle->level);
1076 #endif
1077                         retval = extent_node_split(handle);
1078                         if (retval)
1079                                 return retval;
1080                         path = handle->path + handle->level;
1081                 }
1082         }
1083
1084         eh = (struct ext3_extent_header *) path->buf;
1085         if (path->curr) {
1086                 ix = path->curr;
1087                 if (flags & EXT2_EXTENT_INSERT_AFTER) {
1088                         ix++;
1089                         path->left--;
1090                 }
1091         } else
1092                 ix = EXT_FIRST_INDEX(eh);
1093
1094         path->curr = ix;
1095
1096         if (path->left >= 0)
1097                 memmove(ix + 1, ix,
1098                         (path->left+1) * sizeof(struct ext3_extent_idx));
1099         path->left++;
1100         path->entries++;
1101
1102         eh = (struct ext3_extent_header *) path->buf;
1103         eh->eh_entries = ext2fs_cpu_to_le16(path->entries);
1104
1105         retval = ext2fs_extent_replace(handle, 0, extent);
1106         if (retval)
1107                 goto errout;
1108
1109         retval = update_path(handle);
1110         if (retval)
1111                 goto errout;
1112
1113         return 0;
1114
1115 errout:
1116         ext2fs_extent_delete(handle, 0);
1117         return retval;
1118 }
1119
1120 /*
1121  * Sets the physical block for a logical file block in the extent tree.
1122  *
1123  * May: map unmapped, unmap mapped, or remap mapped blocks.
1124  *
1125  * Mapping an unmapped block adds a single-block extent.
1126  *
1127  * Unmapping first or last block modifies extent in-place
1128  *  - But may need to fix parent's starts too in first-block case
1129  *
1130  * Mapping any unmapped block requires adding a (single-block) extent
1131  * and inserting into proper point in tree.
1132  *
1133  * Modifying (unmapping or remapping) a block in the middle
1134  * of an extent requires splitting the extent.
1135  *  - Remapping case requires new single-block extent.
1136  *
1137  * Remapping first or last block adds an extent.
1138  *
1139  * We really need extent adding to be smart about merging.
1140  */
1141
1142 errcode_t ext2fs_extent_set_bmap(ext2_extent_handle_t handle,
1143                                  blk64_t logical, blk64_t physical, int flags)
1144 {
1145         errcode_t               ec, retval = 0;
1146         int                     mapped = 1; /* logical is mapped? */
1147         int                     orig_height;
1148         int                     extent_uninit = 0;
1149         int                     prev_uninit = 0;
1150         int                     next_uninit = 0;
1151         int                     new_uninit = 0;
1152         int                     max_len = EXT_INIT_MAX_LEN;
1153         int                     has_prev, has_next;
1154         blk64_t                 orig_lblk;
1155         struct extent_path      *path;
1156         struct ext2fs_extent    extent, next_extent, prev_extent;
1157         struct ext2fs_extent    newextent;
1158         struct ext2_extent_info info;
1159
1160         EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
1161
1162 #ifdef DEBUG
1163         printf("set_bmap ino %u log %lld phys %lld flags %d\n",
1164                handle->ino, logical, physical, flags);
1165 #endif
1166
1167         if (!(handle->fs->flags & EXT2_FLAG_RW))
1168                 return EXT2_ET_RO_FILSYS;
1169
1170         if (!handle->path)
1171                 return EXT2_ET_NO_CURRENT_NODE;
1172
1173         path = handle->path + handle->level;
1174
1175         if (flags & EXT2_EXTENT_SET_BMAP_UNINIT) {
1176                 new_uninit = 1;
1177                 max_len = EXT_UNINIT_MAX_LEN;
1178         }
1179
1180         /* if (re)mapping, set up new extent to insert */
1181         if (physical) {
1182                 newextent.e_len = 1;
1183                 newextent.e_pblk = physical;
1184                 newextent.e_lblk = logical;
1185                 newextent.e_flags = EXT2_EXTENT_FLAGS_LEAF;
1186                 if (new_uninit)
1187                         newextent.e_flags |= EXT2_EXTENT_FLAGS_UNINIT;
1188         }
1189
1190         /* special case if the extent tree is completely empty */
1191         if ((handle->max_depth == 0) && (path->entries == 0)) {
1192                 retval = ext2fs_extent_insert(handle, 0, &newextent);
1193                 return retval;
1194         }
1195
1196         /* save our original location in the extent tree */
1197         if ((retval = ext2fs_extent_get(handle, EXT2_EXTENT_CURRENT,
1198                                         &extent))) {
1199                 if (retval != EXT2_ET_NO_CURRENT_NODE)
1200                         return retval;
1201                 memset(&extent, 0, sizeof(extent));
1202         }
1203         if ((retval = ext2fs_extent_get_info(handle, &info)))
1204                 return retval;
1205         orig_height = info.max_depth - info.curr_level;
1206         orig_lblk = extent.e_lblk;
1207
1208         /* go to the logical spot we want to (re/un)map */
1209         retval = ext2fs_extent_goto(handle, logical);
1210         if (retval) {
1211                 if (retval == EXT2_ET_EXTENT_NOT_FOUND) {
1212                         retval = 0;
1213                         mapped = 0;
1214                         if (!physical) {
1215 #ifdef DEBUG
1216                                 printf("block %llu already unmapped\n",
1217                                         logical);
1218 #endif
1219                                 goto done;
1220                         }
1221                 } else
1222                         goto done;
1223         }
1224
1225         /*
1226          * This may be the extent *before* the requested logical,
1227          * if it's currently unmapped.
1228          *
1229          * Get the previous and next leaf extents, if they are present.
1230          */
1231         retval = ext2fs_extent_get(handle, EXT2_EXTENT_CURRENT, &extent);
1232         if (retval)
1233                 goto done;
1234         if (extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT)
1235                 extent_uninit = 1;
1236         retval = ext2fs_extent_get(handle, EXT2_EXTENT_NEXT_LEAF, &next_extent);
1237         if (retval) {
1238                 has_next = 0;
1239                 if (retval != EXT2_ET_EXTENT_NO_NEXT)
1240                         goto done;
1241         } else {
1242                 dbg_print_extent("set_bmap: next_extent",
1243                                  &next_extent);
1244                 has_next = 1;
1245                 if (next_extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT)
1246                         next_uninit = 1;
1247         }
1248         retval = ext2fs_extent_goto(handle, logical);
1249         if (retval && retval != EXT2_ET_EXTENT_NOT_FOUND)
1250                 goto done;
1251         retval = ext2fs_extent_get(handle, EXT2_EXTENT_PREV_LEAF, &prev_extent);
1252         if (retval) {
1253                 has_prev = 0;
1254                 if (retval != EXT2_ET_EXTENT_NO_PREV)
1255                         goto done;
1256         } else {
1257                 has_prev = 1;
1258                 dbg_print_extent("set_bmap: prev_extent",
1259                                  &prev_extent);
1260                 if (prev_extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT)
1261                         prev_uninit = 1;
1262         }
1263         retval = ext2fs_extent_goto(handle, logical);
1264         if (retval && retval != EXT2_ET_EXTENT_NOT_FOUND)
1265                 goto done;
1266
1267         /* check if already pointing to the requested physical */
1268         if (mapped && (new_uninit == extent_uninit) &&
1269             (extent.e_pblk + (logical - extent.e_lblk) == physical)) {
1270 #ifdef DEBUG
1271                 printf("physical block (at %llu) unchanged\n", logical);
1272 #endif
1273                 goto done;
1274         }
1275
1276         if (!mapped) {
1277 #ifdef DEBUG
1278                 printf("mapping unmapped logical block %llu\n", logical);
1279 #endif
1280                 if ((logical == extent.e_lblk + extent.e_len) &&
1281                     (physical == extent.e_pblk + extent.e_len) &&
1282                     (new_uninit == extent_uninit) &&
1283                     ((int) extent.e_len < max_len-1)) {
1284                         extent.e_len++;
1285                         retval = ext2fs_extent_replace(handle, 0, &extent);
1286                 } else if ((logical == extent.e_lblk - 1) &&
1287                            (physical == extent.e_pblk - 1) &&
1288                            (new_uninit == extent_uninit) &&
1289                            ((int) extent.e_len < max_len - 1)) {
1290                         extent.e_len++;
1291                         extent.e_lblk--;
1292                         extent.e_pblk--;
1293                         retval = ext2fs_extent_replace(handle, 0, &extent);
1294                 } else if (has_next &&
1295                            (logical == next_extent.e_lblk - 1) &&
1296                            (physical == next_extent.e_pblk - 1) &&
1297                            (new_uninit == next_uninit) &&
1298                            ((int) next_extent.e_len < max_len - 1)) {
1299                         retval = ext2fs_extent_get(handle,
1300                                                    EXT2_EXTENT_NEXT_LEAF,
1301                                                    &next_extent);
1302                         if (retval)
1303                                 goto done;
1304                         next_extent.e_len++;
1305                         next_extent.e_lblk--;
1306                         next_extent.e_pblk--;
1307                         retval = ext2fs_extent_replace(handle, 0, &next_extent);
1308                 } else if (logical < extent.e_lblk)
1309                         retval = ext2fs_extent_insert(handle, 0, &newextent);
1310                 else
1311                         retval = ext2fs_extent_insert(handle,
1312                                       EXT2_EXTENT_INSERT_AFTER, &newextent);
1313                 if (retval)
1314                         goto done;
1315                 retval = ext2fs_extent_fix_parents(handle);
1316                 if (retval)
1317                         goto done;
1318         } else if ((logical == extent.e_lblk) && (extent.e_len == 1))  {
1319 #ifdef DEBUG
1320                 printf("(re/un)mapping only block in extent\n");
1321 #endif
1322                 if (physical) {
1323                         retval = ext2fs_extent_replace(handle, 0, &newextent);
1324                 } else {
1325                         retval = ext2fs_extent_delete(handle, 0);
1326                         if (retval)
1327                                 goto done;
1328                         ec = ext2fs_extent_fix_parents(handle);
1329                         if (ec != EXT2_ET_NO_CURRENT_NODE)
1330                                 retval = ec;
1331                 }
1332
1333                 if (retval)
1334                         goto done;
1335         } else if (logical == extent.e_lblk + extent.e_len - 1)  {
1336 #ifdef DEBUG
1337                 printf("(re/un)mapping last block in extent\n");
1338 #endif
1339                 if (physical) {
1340                         if (has_next &&
1341                             (logical == (next_extent.e_lblk - 1)) &&
1342                             (physical == (next_extent.e_pblk - 1)) &&
1343                             (new_uninit == next_uninit) &&
1344                             ((int) next_extent.e_len < max_len - 1)) {
1345                                 retval = ext2fs_extent_get(handle,
1346                                         EXT2_EXTENT_NEXT_LEAF, &next_extent);
1347                                 if (retval)
1348                                         goto done;
1349                                 next_extent.e_len++;
1350                                 next_extent.e_lblk--;
1351                                 next_extent.e_pblk--;
1352                                 retval = ext2fs_extent_replace(handle, 0,
1353                                                                &next_extent);
1354                                 if (retval)
1355                                         goto done;
1356                         } else
1357                                 retval = ext2fs_extent_insert(handle,
1358                                       EXT2_EXTENT_INSERT_AFTER, &newextent);
1359                         if (retval)
1360                                 goto done;
1361                         /* Now pointing at inserted extent; move back to prev */
1362                         retval = ext2fs_extent_get(handle,
1363                                                    EXT2_EXTENT_PREV_LEAF,
1364                                                    &extent);
1365                         if (retval)
1366                                 goto done;
1367                 }
1368                 extent.e_len--;
1369                 retval = ext2fs_extent_replace(handle, 0, &extent);
1370                 if (retval)
1371                         goto done;
1372         } else if (logical == extent.e_lblk) {
1373 #ifdef DEBUG
1374                 printf("(re/un)mapping first block in extent\n");
1375 #endif
1376                 if (physical) {
1377                         if (has_prev &&
1378                             (logical == (prev_extent.e_lblk +
1379                                          prev_extent.e_len)) &&
1380                             (physical == (prev_extent.e_pblk +
1381                                           prev_extent.e_len)) &&
1382                             (new_uninit == prev_uninit) &&
1383                             ((int) prev_extent.e_len < max_len-1)) {
1384                                 retval = ext2fs_extent_get(handle,
1385                                         EXT2_EXTENT_PREV_LEAF, &prev_extent);
1386                                 if (retval)
1387                                         goto done;
1388                                 prev_extent.e_len++;
1389                                 retval = ext2fs_extent_replace(handle, 0,
1390                                                                &prev_extent);
1391                         } else
1392                                 retval = ext2fs_extent_insert(handle,
1393                                                               0, &newextent);
1394                         if (retval)
1395                                 goto done;
1396                         retval = ext2fs_extent_get(handle,
1397                                                    EXT2_EXTENT_NEXT_LEAF,
1398                                                    &extent);
1399                         if (retval)
1400                                 goto done;
1401                 }
1402                 extent.e_pblk++;
1403                 extent.e_lblk++;
1404                 extent.e_len--;
1405                 retval = ext2fs_extent_replace(handle, 0, &extent);
1406                 if (retval)
1407                         goto done;
1408         } else {
1409                 __u32   orig_length;
1410
1411 #ifdef DEBUG
1412                 printf("(re/un)mapping in middle of extent\n");
1413 #endif
1414                 /* need to split this extent; later */
1415
1416                 orig_length = extent.e_len;
1417
1418                 /* shorten pre-split extent */
1419                 extent.e_len = (logical - extent.e_lblk);
1420                 retval = ext2fs_extent_replace(handle, 0, &extent);
1421                 if (retval)
1422                         goto done;
1423                 /* insert our new extent, if any */
1424                 if (physical) {
1425                         /* insert new extent after current */
1426                         retval = ext2fs_extent_insert(handle,
1427                                         EXT2_EXTENT_INSERT_AFTER, &newextent);
1428                         if (retval)
1429                                 goto done;
1430                 }
1431                 /* add post-split extent */
1432                 extent.e_pblk += extent.e_len + 1;
1433                 extent.e_lblk += extent.e_len + 1;
1434                 extent.e_len = orig_length - extent.e_len - 1;
1435                 retval = ext2fs_extent_insert(handle,
1436                                 EXT2_EXTENT_INSERT_AFTER, &extent);
1437                 if (retval)
1438                         goto done;
1439         }
1440
1441 done:
1442         /* get handle back to its position */
1443         if (orig_height > handle->max_depth)
1444                 orig_height = handle->max_depth; /* In case we shortened the tree */
1445         extent_goto(handle, orig_height, orig_lblk);
1446         return retval;
1447 }
1448
1449 errcode_t ext2fs_extent_delete(ext2_extent_handle_t handle, int flags)
1450 {
1451         struct extent_path              *path;
1452         char                            *cp;
1453         struct ext3_extent_header       *eh;
1454         errcode_t                       retval = 0;
1455
1456         EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
1457
1458         if (!(handle->fs->flags & EXT2_FLAG_RW))
1459                 return EXT2_ET_RO_FILSYS;
1460
1461         if (!handle->path)
1462                 return EXT2_ET_NO_CURRENT_NODE;
1463
1464 #ifdef DEBUG
1465         {
1466                 struct ext2fs_extent    extent;
1467
1468                 retval = ext2fs_extent_get(handle, EXT2_EXTENT_CURRENT,
1469                                            &extent);
1470                 if (retval == 0) {
1471                         printf("extent delete %u ", handle->ino);
1472                         dbg_print_extent(0, &extent);
1473                 }
1474         }
1475 #endif
1476
1477         path = handle->path + handle->level;
1478         if (!path->curr)
1479                 return EXT2_ET_NO_CURRENT_NODE;
1480
1481         cp = path->curr;
1482
1483         if (path->left) {
1484                 memmove(cp, cp + sizeof(struct ext3_extent_idx),
1485                         path->left * sizeof(struct ext3_extent_idx));
1486                 path->left--;
1487         } else {
1488                 struct ext3_extent_idx  *ix = path->curr;
1489                 ix--;
1490                 path->curr = ix;
1491         }
1492         if (--path->entries == 0)
1493                 path->curr = 0;
1494
1495         /* if non-root node has no entries left, remove it & parent ptr to it */
1496         if (path->entries == 0 && handle->level) {
1497                 if (!(flags & EXT2_EXTENT_DELETE_KEEP_EMPTY)) {
1498                         struct ext2fs_extent    extent;
1499
1500                         retval = ext2fs_extent_get(handle, EXT2_EXTENT_UP,
1501                                                                 &extent);
1502                         if (retval)
1503                                 return retval;
1504
1505                         retval = ext2fs_extent_delete(handle, flags);
1506                         handle->inode->i_blocks -= handle->fs->blocksize / 512;
1507                         retval = ext2fs_write_inode(handle->fs, handle->ino,
1508                                                     handle->inode);
1509                         ext2fs_block_alloc_stats(handle->fs, extent.e_pblk, -1);
1510                 }
1511         } else {
1512                 eh = (struct ext3_extent_header *) path->buf;
1513                 eh->eh_entries = ext2fs_cpu_to_le16(path->entries);
1514                 if ((path->entries == 0) && (handle->level == 0))
1515                         eh->eh_depth = handle->max_depth = 0;
1516                 retval = update_path(handle);
1517         }
1518         return retval;
1519 }
1520
1521 errcode_t ext2fs_extent_get_info(ext2_extent_handle_t handle,
1522                                  struct ext2_extent_info *info)
1523 {
1524         struct extent_path              *path;
1525
1526         EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
1527
1528         memset(info, 0, sizeof(struct ext2_extent_info));
1529
1530         path = handle->path + handle->level;
1531         if (path) {
1532                 if (path->curr)
1533                         info->curr_entry = ((char *) path->curr - path->buf) /
1534                                 sizeof(struct ext3_extent_idx);
1535                 else
1536                         info->curr_entry = 0;
1537                 info->num_entries = path->entries;
1538                 info->max_entries = path->max_entries;
1539                 info->bytes_avail = (path->max_entries - path->entries) *
1540                         sizeof(struct ext3_extent);
1541         }
1542
1543         info->curr_level = handle->level;
1544         info->max_depth = handle->max_depth;
1545         info->max_lblk = ((__u64) 1 << 32) - 1;
1546         info->max_pblk = ((__u64) 1 << 48) - 1;
1547         info->max_len = (1UL << 15);
1548         info->max_uninit_len = (1UL << 15) - 1;
1549
1550         return 0;
1551 }
1552
1553 #ifdef DEBUG
1554
1555 #include "ss/ss.h"
1556
1557 #include "debugfs.h"
1558
1559 /*
1560  * Hook in new commands into debugfs
1561  */
1562 const char *debug_prog_name = "tst_extents";
1563 extern ss_request_table extent_cmds;
1564 ss_request_table *extra_cmds = &extent_cmds;
1565
1566 ext2_ino_t      current_ino = 0;
1567 ext2_extent_handle_t current_handle;
1568
1569 int common_extent_args_process(int argc, char *argv[], int min_argc,
1570                                int max_argc, const char *cmd,
1571                                const char *usage, int flags)
1572 {
1573         if (common_args_process(argc, argv, min_argc, max_argc, cmd,
1574                                 usage, flags))
1575                 return 1;
1576
1577         if (!current_handle) {
1578                 com_err(cmd, 0, "Extent handle not open");
1579                 return 1;
1580         }
1581         return 0;
1582 }
1583
1584 void do_inode(int argc, char *argv[])
1585 {
1586         ext2_ino_t      inode;
1587         int             i;
1588         struct ext3_extent_header *eh;
1589         errcode_t retval;
1590
1591         if (check_fs_open(argv[0]))
1592                 return;
1593
1594         if (argc == 1) {
1595                 if (current_ino)
1596                         printf("Current inode is %d\n", current_ino);
1597                 else
1598                         printf("No current inode\n");
1599                 return;
1600         }
1601
1602         if (common_inode_args_process(argc, argv, &inode, 0)) {
1603                 return;
1604         }
1605
1606         current_ino = 0;
1607
1608         retval = ext2fs_extent_open(current_fs, inode, &current_handle);
1609         if (retval) {
1610                 com_err(argv[1], retval, "while opening extent handle");
1611                 return;
1612         }
1613
1614         current_ino = inode;
1615
1616         printf("Loaded inode %d\n", current_ino);
1617
1618         return;
1619 }
1620
1621 void generic_goto_node(char *cmd_name, int op)
1622 {
1623         struct ext2fs_extent    extent;
1624         errcode_t               retval;
1625
1626         if (check_fs_open(cmd_name))
1627                 return;
1628
1629         if (!current_handle) {
1630                 com_err(cmd_name, 0, "Extent handle not open");
1631                 return;
1632         }
1633
1634         retval = ext2fs_extent_get(current_handle, op, &extent);
1635         if (retval) {
1636                 com_err(cmd_name, retval, 0);
1637                 return;
1638         }
1639         dbg_print_extent(0, &extent);
1640 }
1641
1642 void do_current_node(int argc, char *argv[])
1643 {
1644         generic_goto_node(argv[0], EXT2_EXTENT_CURRENT);
1645 }
1646
1647 void do_root_node(int argc, char *argv[])
1648 {
1649         generic_goto_node(argv[0], EXT2_EXTENT_ROOT);
1650 }
1651
1652 void do_last_leaf(int argc, char *argv[])
1653 {
1654         generic_goto_node(argv[0], EXT2_EXTENT_LAST_LEAF);
1655 }
1656
1657 void do_first_sib(int argc, char *argv[])
1658 {
1659         generic_goto_node(argv[0], EXT2_EXTENT_FIRST_SIB);
1660 }
1661
1662 void do_last_sib(int argc, char *argv[])
1663 {
1664         generic_goto_node(argv[0], EXT2_EXTENT_LAST_SIB);
1665 }
1666
1667 void do_next_sib(int argc, char *argv[])
1668 {
1669         generic_goto_node(argv[0], EXT2_EXTENT_NEXT_SIB);
1670 }
1671
1672 void do_prev_sib(int argc, char *argv[])
1673 {
1674         generic_goto_node(argv[0], EXT2_EXTENT_PREV_SIB);
1675 }
1676
1677 void do_next_leaf(int argc, char *argv[])
1678 {
1679         generic_goto_node(argv[0], EXT2_EXTENT_NEXT_LEAF);
1680 }
1681
1682 void do_prev_leaf(int argc, char *argv[])
1683 {
1684         generic_goto_node(argv[0], EXT2_EXTENT_PREV_LEAF);
1685 }
1686
1687 void do_next(int argc, char *argv[])
1688 {
1689         generic_goto_node(argv[0], EXT2_EXTENT_NEXT);
1690 }
1691
1692 void do_prev(int argc, char *argv[])
1693 {
1694         generic_goto_node(argv[0], EXT2_EXTENT_PREV);
1695 }
1696
1697 void do_up(int argc, char *argv[])
1698 {
1699         generic_goto_node(argv[0], EXT2_EXTENT_UP);
1700 }
1701
1702 void do_down(int argc, char *argv[])
1703 {
1704         generic_goto_node(argv[0], EXT2_EXTENT_DOWN);
1705 }
1706
1707 void do_delete_node(int argc, char *argv[])
1708 {
1709         errcode_t       retval;
1710         int             err;
1711
1712         if (common_extent_args_process(argc, argv, 1, 1, "delete_node",
1713                                        "", CHECK_FS_RW | CHECK_FS_BITMAPS))
1714                 return;
1715
1716         retval = ext2fs_extent_delete(current_handle, 0);
1717         if (retval) {
1718                 com_err(argv[0], retval, 0);
1719                 return;
1720         }
1721         if (current_handle->path && current_handle->path[0].curr)
1722                 do_current_node(argc, argv);
1723 }
1724
1725 void do_replace_node(int argc, char *argv[])
1726 {
1727         const char      *usage = "[--uninit] <lblk> <len> <pblk>";
1728         errcode_t       retval;
1729         struct ext2fs_extent extent;
1730         int err;
1731
1732         if (common_extent_args_process(argc, argv, 3, 5, "replace_node",
1733                                        usage, CHECK_FS_RW | CHECK_FS_BITMAPS))
1734                 return;
1735
1736         extent.e_flags = 0;
1737
1738         if (!strcmp(argv[1], "--uninit")) {
1739                 argc--;
1740                 argv++;
1741                 extent.e_flags |= EXT2_EXTENT_FLAGS_UNINIT;
1742         }
1743
1744         if (argc != 4) {
1745                 fprintf(stderr, "Usage: %s %s\n", argv[0], usage);
1746                 return;
1747         }
1748
1749         extent.e_lblk = parse_ulong(argv[1], argv[0], "logical block", &err);
1750         if (err)
1751                 return;
1752
1753         extent.e_len = parse_ulong(argv[2], argv[0], "logical block", &err);
1754         if (err)
1755                 return;
1756
1757         extent.e_pblk = parse_ulong(argv[3], argv[0], "logical block", &err);
1758         if (err)
1759                 return;
1760
1761         retval = ext2fs_extent_replace(current_handle, 0, &extent);
1762         if (retval) {
1763                 com_err(argv[0], retval, 0);
1764                 return;
1765         }
1766         do_current_node(argc, argv);
1767 }
1768
1769 void do_split_node(int argc, char *argv[])
1770 {
1771         errcode_t       retval;
1772         struct ext2fs_extent extent;
1773         int err;
1774
1775         if (common_extent_args_process(argc, argv, 1, 1, "split_node",
1776                                        "", CHECK_FS_RW | CHECK_FS_BITMAPS))
1777                 return;
1778
1779         retval = extent_node_split(current_handle);
1780         if (retval) {
1781                 com_err(argv[0], retval, 0);
1782                 return;
1783         }
1784         do_current_node(argc, argv);
1785 }
1786
1787 void do_insert_node(int argc, char *argv[])
1788 {
1789         const char      *usage = "[--after] [--uninit] <lblk> <len> <pblk>";
1790         errcode_t       retval;
1791         struct ext2fs_extent extent;
1792         char *cmd;
1793         int err;
1794         int flags = 0;
1795
1796         if (common_extent_args_process(argc, argv, 3, 6, "insert_node",
1797                                        usage, CHECK_FS_RW | CHECK_FS_BITMAPS))
1798                 return;
1799
1800         cmd = argv[0];
1801
1802         extent.e_flags = 0;
1803
1804         while (argc > 2) {
1805                 if (!strcmp(argv[1], "--after")) {
1806                         argc--;
1807                         argv++;
1808                         flags |= EXT2_EXTENT_INSERT_AFTER;
1809                         continue;
1810                 }
1811                 if (!strcmp(argv[1], "--uninit")) {
1812                         argc--;
1813                         argv++;
1814                         extent.e_flags |= EXT2_EXTENT_FLAGS_UNINIT;
1815                         continue;
1816                 }
1817                 break;
1818         }
1819
1820         if (argc != 4) {
1821                 fprintf(stderr, "usage: %s %s\n", cmd, usage);
1822                 return;
1823         }
1824
1825         extent.e_lblk = parse_ulong(argv[1], cmd,
1826                                     "logical block", &err);
1827         if (err)
1828                 return;
1829
1830         extent.e_len = parse_ulong(argv[2], cmd,
1831                                     "length", &err);
1832         if (err)
1833                 return;
1834
1835         extent.e_pblk = parse_ulong(argv[3], cmd,
1836                                     "pysical block", &err);
1837         if (err)
1838                 return;
1839
1840         retval = ext2fs_extent_insert(current_handle, flags, &extent);
1841         if (retval) {
1842                 com_err(cmd, retval, 0);
1843                 return;
1844         }
1845         do_current_node(argc, argv);
1846 }
1847
1848 void do_set_bmap(int argc, char **argv)
1849 {
1850         const char      *usage = "[--uninit] <lblk> <pblk>";
1851         errcode_t       retval;
1852         blk_t           logical;
1853         blk_t           physical;
1854         char            *cmd = argv[0];
1855         int             flags = 0;
1856         int             err;
1857
1858         if (common_extent_args_process(argc, argv, 3, 5, "set_bmap",
1859                                        usage, CHECK_FS_RW | CHECK_FS_BITMAPS))
1860                 return;
1861
1862         if (argc > 2 && !strcmp(argv[1], "--uninit")) {
1863                 argc--;
1864                 argv++;
1865                 flags |= EXT2_EXTENT_SET_BMAP_UNINIT;
1866         }
1867
1868         if (argc != 3) {
1869                 fprintf(stderr, "Usage: %s %s\n", cmd, usage);
1870                 return;
1871         }
1872
1873         logical = parse_ulong(argv[1], cmd,
1874                                     "logical block", &err);
1875         if (err)
1876                 return;
1877
1878         physical = parse_ulong(argv[2], cmd,
1879                                     "physical block", &err);
1880         if (err)
1881                 return;
1882
1883         retval = ext2fs_extent_set_bmap(current_handle, logical,
1884                                         (blk64_t) physical, flags);
1885         if (retval) {
1886                 com_err(cmd, retval, 0);
1887                 return;
1888         }
1889         if (current_handle->path && current_handle->path[0].curr)
1890                 do_current_node(argc, argv);
1891 }
1892
1893 void do_print_all(int argc, char **argv)
1894 {
1895         const char      *usage = "[--leaf-only|--reverse|--reverse-leaf]";
1896         struct ext2fs_extent    extent;
1897         errcode_t               retval;
1898         errcode_t               end_err = EXT2_ET_EXTENT_NO_NEXT;
1899         int                     op = EXT2_EXTENT_NEXT;
1900         int                     first_op = EXT2_EXTENT_ROOT;
1901
1902
1903         if (common_extent_args_process(argc, argv, 1, 2, "print_all",
1904                                        usage, 0))
1905                 return;
1906
1907         if (argc == 2) {
1908                 if (!strcmp(argv[1], "--leaf-only"))
1909                         op = EXT2_EXTENT_NEXT_LEAF;
1910                 else if (!strcmp(argv[1], "--reverse")) {
1911                         op = EXT2_EXTENT_PREV;
1912                         first_op = EXT2_EXTENT_LAST_LEAF;
1913                         end_err = EXT2_ET_EXTENT_NO_PREV;
1914                 } else if (!strcmp(argv[1], "--reverse-leaf")) {
1915                         op = EXT2_EXTENT_PREV_LEAF;
1916                         first_op = EXT2_EXTENT_LAST_LEAF;
1917                         end_err = EXT2_ET_EXTENT_NO_PREV;
1918                 } else {
1919                         fprintf(stderr, "Usage: %s %s\n", argv[0], usage);
1920                         return;
1921                 }
1922         }
1923
1924         retval = ext2fs_extent_get(current_handle, first_op, &extent);
1925         if (retval) {
1926                 com_err(argv[0], retval, 0);
1927                 return;
1928         }
1929         dbg_print_extent(0, &extent);
1930
1931         while (1) {
1932                 retval = ext2fs_extent_get(current_handle, op, &extent);
1933                 if (retval == end_err)
1934                         break;
1935
1936                 if (retval) {
1937                         com_err(argv[0], retval, 0);
1938                         return;
1939                 }
1940                 dbg_print_extent(0, &extent);
1941         }
1942 }
1943
1944 void do_info(int argc, char **argv)
1945 {
1946         struct ext2fs_extent    extent;
1947         struct ext2_extent_info info;
1948         errcode_t               retval;
1949
1950         if (common_extent_args_process(argc, argv, 1, 1, "info", "", 0))
1951                 return;
1952
1953         retval = ext2fs_extent_get_info(current_handle, &info);
1954         if (retval) {
1955                 com_err(argv[0], retval, 0);
1956                 return;
1957         }
1958
1959         retval = ext2fs_extent_get(current_handle,
1960                                    EXT2_EXTENT_CURRENT, &extent);
1961         if (retval) {
1962                 com_err(argv[0], retval, 0);
1963                 return;
1964         }
1965
1966         dbg_print_extent(0, &extent);
1967
1968         printf("Current handle location: %d/%d (max: %d, bytes %d), level %d/%d\n",
1969                info.curr_entry, info.num_entries, info.max_entries,
1970                info.bytes_avail, info.curr_level, info.max_depth);
1971         printf("\tmax lblk: %llu, max pblk: %llu\n", info.max_lblk,
1972                info.max_pblk);
1973         printf("\tmax_len: %u, max_uninit_len: %u\n", info.max_len,
1974                info.max_uninit_len);
1975 }
1976
1977 void do_goto_block(int argc, char **argv)
1978 {
1979         struct ext2fs_extent    extent;
1980         errcode_t               retval;
1981         int                     op = EXT2_EXTENT_NEXT_LEAF;
1982         blk_t                   blk;
1983         int                     level = 0;
1984
1985         if (common_extent_args_process(argc, argv, 2, 3, "goto_block",
1986                                        "block [level]", 0))
1987                 return;
1988
1989         if (strtoblk(argv[0], argv[1], &blk))
1990                 return;
1991
1992         if (argc == 3)
1993                 if (strtoblk(argv[0], argv[2], &level))
1994                         return;
1995
1996         retval = extent_goto(current_handle, level, (blk64_t) blk);
1997
1998         if (retval) {
1999                 com_err(argv[0], retval,
2000                         "while trying to go to block %u, level %d",
2001                         blk, level);
2002                 return;
2003         }
2004
2005         generic_goto_node(argv[0], EXT2_EXTENT_CURRENT);
2006 }
2007 #endif
2008