debugfs/extent_inode.c

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