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 static ext2_ino_t       current_ino;
  29 static 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 static 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         ext2_ino_t      inode;
  70         int             ret;
  71         errcode_t       retval;
  72         char            *cp;
  73
  74         if (check_fs_open(argv[0]))
  75                 return;
  76
  77         if (argc == 1) {
  78                 if (current_ino)
  79                         printf("Current inode is %d\n", current_ino);
  80                 else
  81                         printf("No current inode\n");
  82                 return;
  83         }
  84
  85         if (common_inode_args_process(argc, argv, &inode, 0))
  86                 return;
  87
  88         current_ino = 0;
  89
  90         retval = ext2fs_extent_open(current_fs, inode, &current_handle);
  91         if (retval) {
  92                 com_err(argv[1], retval, "while opening extent handle");
  93                 return;
  94         }
  95
  96         current_ino = inode;
  97
  98         orig_prompt = ss_get_prompt(sci_idx);
  99         extent_prompt = malloc(strlen(orig_prompt) + 32);
 100         strcpy(extent_prompt, orig_prompt);
 101         cp = strchr(extent_prompt, ':');
 102         if (cp)
 103                 *cp = 0;
 104         sprintf(extent_prompt + strlen(extent_prompt), " (extent ino %d): ",
 105                 current_ino);
 106         ss_add_request_table(sci_idx, &extent_cmds, 1, &ret);
 107         ss_set_prompt(sci_idx, extent_prompt);
 108         return;
 109 }
 110
 111 void do_extent_close(int argc, char *argv[])
 112 {
 113         int ret;
 114
 115         if (common_args_process(argc, argv, 1, 1,
 116                                 "extent_close", "", 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 static void generic_goto_node(const char *my_name, int argc,
 134                               char **argv, int op)
 135 {
 136         struct ext2fs_extent    extent;
 137         errcode_t               retval;
 138
 139         if (my_name && common_args_process(argc, argv, 1, 1,
 140                                            my_name, "", 0))
 141                 return;
 142
 143         if (!current_handle) {
 144                 com_err(argv[0], 0, "Extent handle not open");
 145                 return;
 146         }
 147
 148         retval = ext2fs_extent_get(current_handle, op, &extent);
 149         if (retval) {
 150                 com_err(argv[0], retval, 0);
 151                 return;
 152         }
 153         dbg_print_extent(0, &extent);
 154 }
 155
 156 void do_current_node(int argc, char *argv[])
 157 {
 158         generic_goto_node("current_node", argc, argv, EXT2_EXTENT_CURRENT);
 159 }
 160
 161 void do_root_node(int argc, char *argv[])
 162 {
 163         generic_goto_node("root_node", argc, argv, EXT2_EXTENT_ROOT);
 164 }
 165
 166 void do_last_leaf(int argc, char *argv[])
 167 {
 168         generic_goto_node("last_leaf", argc, argv, EXT2_EXTENT_LAST_LEAF);
 169 }
 170
 171 void do_first_sib(int argc, char *argv[])
 172 {
 173         generic_goto_node("first_sib", argc, argv, EXT2_EXTENT_FIRST_SIB);
 174 }
 175
 176 void do_last_sib(int argc, char *argv[])
 177 {
 178         generic_goto_node("next_sib", argc, argv, EXT2_EXTENT_LAST_SIB);
 179 }
 180
 181 void do_next_sib(int argc, char *argv[])
 182 {
 183         generic_goto_node("next_sib", argc, argv, EXT2_EXTENT_NEXT_SIB);
 184 }
 185
 186 void do_prev_sib(int argc, char *argv[])
 187 {
 188         generic_goto_node("prev_sib", argc, argv, EXT2_EXTENT_PREV_SIB);
 189 }
 190
 191 void do_next_leaf(int argc, char *argv[])
 192 {
 193         generic_goto_node("next_leaf", argc, argv, EXT2_EXTENT_NEXT_LEAF);
 194 }
 195
 196 void do_prev_leaf(int argc, char *argv[])
 197 {
 198         generic_goto_node("prev_leaf", argc, argv, EXT2_EXTENT_PREV_LEAF);
 199 }
 200
 201 void do_next(int argc, char *argv[])
 202 {
 203         generic_goto_node("next", argc, argv, EXT2_EXTENT_NEXT);
 204 }
 205
 206 void do_prev(int argc, char *argv[])
 207 {
 208         generic_goto_node("prev", argc, argv, EXT2_EXTENT_PREV);
 209 }
 210
 211 void do_up(int argc, char *argv[])
 212 {
 213         generic_goto_node("up", argc, argv, EXT2_EXTENT_UP);
 214 }
 215
 216 void do_down(int argc, char *argv[])
 217 {
 218         generic_goto_node("down", argc, argv, EXT2_EXTENT_DOWN);
 219 }
 220
 221 void do_delete_node(int argc, char *argv[])
 222 {
 223         struct ext2fs_extent extent;
 224         errcode_t       retval;
 225
 226         if (common_extent_args_process(argc, argv, 1, 1, "delete_node",
 227                                        "", CHECK_FS_RW | CHECK_FS_BITMAPS))
 228                 return;
 229
 230         retval = ext2fs_extent_delete(current_handle, 0);
 231         if (retval) {
 232                 com_err(argv[0], retval, 0);
 233                 return;
 234         }
 235
 236         retval = ext2fs_extent_get(current_handle, EXT2_EXTENT_CURRENT,
 237                                    &extent);
 238         if (retval)
 239                 return;
 240         dbg_print_extent(0, &extent);
 241 }
 242
 243 void do_replace_node(int argc, char *argv[])
 244 {
 245         const char      *usage = "[--uninit] <lblk> <len> <pblk>";
 246         errcode_t       retval;
 247         struct ext2fs_extent extent;
 248         int err;
 249
 250         if (common_extent_args_process(argc, argv, 3, 5, "replace_node",
 251                                        usage, CHECK_FS_RW | CHECK_FS_BITMAPS))
 252                 return;
 253
 254         extent.e_flags = 0;
 255
 256         if (!strcmp(argv[1], "--uninit")) {
 257                 argc--;
 258                 argv++;
 259                 extent.e_flags |= EXT2_EXTENT_FLAGS_UNINIT;
 260         }
 261
 262         if (argc != 4) {
 263                 fprintf(stderr, "Usage: %s %s\n", argv[0], usage);
 264                 return;
 265         }
 266
 267         err = strtoblk(argv[0], argv[1], "logical block", &extent.e_lblk);
 268         if (err)
 269                 return;
 270
 271         extent.e_len = parse_ulong(argv[2], argv[0], "length", &err);
 272         if (err)
 273                 return;
 274
 275         err = strtoblk(argv[0], argv[3], "physical block", &extent.e_pblk);
 276         if (err)
 277                 return;
 278
 279         retval = ext2fs_extent_replace(current_handle, 0, &extent);
 280         if (retval) {
 281                 com_err(argv[0], retval, 0);
 282                 return;
 283         }
 284         generic_goto_node(NULL, argc, argv, EXT2_EXTENT_CURRENT);
 285 }
 286
 287 void do_split_node(int argc, char *argv[])
 288 {
 289         errcode_t       retval;
 290
 291         if (common_extent_args_process(argc, argv, 1, 1, "split_node",
 292                                        "", CHECK_FS_RW | CHECK_FS_BITMAPS))
 293                 return;
 294
 295         retval = ext2fs_extent_node_split(current_handle);
 296         if (retval) {
 297                 com_err(argv[0], retval, 0);
 298                 return;
 299         }
 300         generic_goto_node(NULL, argc, argv, EXT2_EXTENT_CURRENT);
 301 }
 302
 303 void do_insert_node(int argc, char *argv[])
 304 {
 305         const char      *usage = "[--after] [--uninit] <lblk> <len> <pblk>";
 306         errcode_t       retval;
 307         struct ext2fs_extent extent;
 308         char *cmd;
 309         int err;
 310         int flags = 0;
 311
 312         if (common_extent_args_process(argc, argv, 3, 6, "insert_node",
 313                                        usage, CHECK_FS_RW | CHECK_FS_BITMAPS))
 314                 return;
 315
 316         cmd = argv[0];
 317
 318         extent.e_flags = 0;
 319
 320         while (argc > 2) {
 321                 if (!strcmp(argv[1], "--after")) {
 322                         argc--;
 323                         argv++;
 324                         flags |= EXT2_EXTENT_INSERT_AFTER;
 325                         continue;
 326                 }
 327                 if (!strcmp(argv[1], "--uninit")) {
 328                         argc--;
 329                         argv++;
 330                         extent.e_flags |= EXT2_EXTENT_FLAGS_UNINIT;
 331                         continue;
 332                 }
 333                 break;
 334         }
 335
 336         if (argc != 4) {
 337                 fprintf(stderr, "usage: %s %s\n", cmd, usage);
 338                 return;
 339         }
 340
 341         err = strtoblk(cmd, argv[1], "logical block", &extent.e_lblk);
 342         if (err)
 343                 return;
 344
 345         extent.e_len = parse_ulong(argv[2], cmd, "length", &err);
 346         if (err)
 347                 return;
 348
 349         err = strtoblk(cmd, argv[3], "physical block", &extent.e_pblk);
 350         if (err)
 351                 return;
 352
 353         retval = ext2fs_extent_insert(current_handle, flags, &extent);
 354         if (retval) {
 355                 com_err(cmd, retval, 0);
 356                 return;
 357         }
 358         generic_goto_node(NULL, argc, argv, EXT2_EXTENT_CURRENT);
 359 }
 360
 361 void do_set_bmap(int argc, char **argv)
 362 {
 363         const char      *usage = "[--uninit] <lblk> <pblk>";
 364         struct ext2fs_extent extent;
 365         errcode_t       retval;
 366         blk64_t         logical;
 367         blk64_t         physical;
 368         char            *cmd = argv[0];
 369         int             flags = 0;
 370         int             err;
 371
 372         if (common_extent_args_process(argc, argv, 3, 5, "set_bmap",
 373                                        usage, CHECK_FS_RW | CHECK_FS_BITMAPS))
 374                 return;
 375
 376         if (argc > 2 && !strcmp(argv[1], "--uninit")) {
 377                 argc--;
 378                 argv++;
 379                 flags |= EXT2_EXTENT_SET_BMAP_UNINIT;
 380         }
 381
 382         if (argc != 3) {
 383                 fprintf(stderr, "Usage: %s %s\n", cmd, usage);
 384                 return;
 385         }
 386
 387         err = strtoblk(cmd, argv[1], "logical block", &logical);
 388         if (err)
 389                 return;
 390
 391         err = strtoblk(cmd, argv[2], "physical block", &physical);
 392         if (err)
 393                 return;
 394
 395         retval = ext2fs_extent_set_bmap(current_handle, logical,
 396                                         physical, flags);
 397         if (retval) {
 398                 com_err(cmd, retval, 0);
 399                 return;
 400         }
 401
 402         retval = ext2fs_extent_get(current_handle, EXT2_EXTENT_CURRENT,
 403                                    &extent);
 404         if (retval)
 405                 return;
 406         dbg_print_extent(0, &extent);
 407 }
 408
 409 void do_print_all(int argc, char **argv)
 410 {
 411         const char      *usage = "[--leaf-only|--reverse|--reverse-leaf]";
 412         struct ext2fs_extent    extent;
 413         errcode_t               retval;
 414         errcode_t               end_err = EXT2_ET_EXTENT_NO_NEXT;
 415         int                     op = EXT2_EXTENT_NEXT;
 416         int                     first_op = EXT2_EXTENT_ROOT;
 417
 418
 419         if (common_extent_args_process(argc, argv, 1, 2, "print_all",
 420                                        usage, 0))
 421                 return;
 422
 423         if (argc == 2) {
 424                 if (!strcmp(argv[1], "--leaf-only"))
 425                         op = EXT2_EXTENT_NEXT_LEAF;
 426                 else if (!strcmp(argv[1], "--reverse")) {
 427                         op = EXT2_EXTENT_PREV;
 428                         first_op = EXT2_EXTENT_LAST_LEAF;
 429                         end_err = EXT2_ET_EXTENT_NO_PREV;
 430                 } else if (!strcmp(argv[1], "--reverse-leaf")) {
 431                         op = EXT2_EXTENT_PREV_LEAF;
 432                         first_op = EXT2_EXTENT_LAST_LEAF;
 433                         end_err = EXT2_ET_EXTENT_NO_PREV;
 434                 } else {
 435                         fprintf(stderr, "Usage: %s %s\n", argv[0], usage);
 436                         return;
 437                 }
 438         }
 439
 440         retval = ext2fs_extent_get(current_handle, first_op, &extent);
 441         if (retval) {
 442                 com_err(argv[0], retval, 0);
 443                 return;
 444         }
 445         dbg_print_extent(0, &extent);
 446
 447         while (1) {
 448                 retval = ext2fs_extent_get(current_handle, op, &extent);
 449                 if (retval == end_err)
 450                         break;
 451
 452                 if (retval) {
 453                         com_err(argv[0], retval, 0);
 454                         return;
 455                 }
 456                 dbg_print_extent(0, &extent);
 457         }
 458 }
 459
 460 void do_fix_parents(int argc, char **argv)
 461 {
 462         errcode_t               retval;
 463
 464         if (common_extent_args_process(argc, argv, 1, 1, "fix_parents", "",
 465                                        CHECK_FS_RW))
 466                 return;
 467
 468         retval = ext2fs_extent_fix_parents(current_handle);
 469         if (retval) {
 470                 com_err(argv[0], retval, 0);
 471                 return;
 472         }
 473 }
 474
 475 void do_info(int argc, char **argv)
 476 {
 477         struct ext2fs_extent    extent;
 478         struct ext2_extent_info info;
 479         errcode_t               retval;
 480
 481         if (common_extent_args_process(argc, argv, 1, 1, "info", "", 0))
 482                 return;
 483
 484         retval = ext2fs_extent_get_info(current_handle, &info);
 485         if (retval) {
 486                 com_err(argv[0], retval, 0);
 487                 return;
 488         }
 489
 490         retval = ext2fs_extent_get(current_handle,
 491                                    EXT2_EXTENT_CURRENT, &extent);
 492         if (retval) {
 493                 com_err(argv[0], retval, 0);
 494                 return;
 495         }
 496
 497         dbg_print_extent(0, &extent);
 498
 499         printf("Current handle location: %d/%d (max: %d, bytes %d), level %d/%d\n",
 500                info.curr_entry, info.num_entries, info.max_entries,
 501                info.bytes_avail, info.curr_level, info.max_depth);
 502         printf("\tmax lblk: %llu, max pblk: %llu\n", info.max_lblk,
 503                info.max_pblk);
 504         printf("\tmax_len: %u, max_uninit_len: %u\n", info.max_len,
 505                info.max_uninit_len);
 506 }
 507
 508 void do_goto_block(int argc, char **argv)
 509 {
 510         errcode_t               retval;
 511         blk64_t                 blk;
 512         int                     level = 0, err;
 513
 514         if (common_extent_args_process(argc, argv, 2, 3, "goto_block",
 515                                        "block [level]", 0))
 516                 return;
 517
 518         if (strtoblk(argv[0], argv[1], NULL, &blk))
 519                 return;
 520
 521         if (argc == 3) {
 522                 level = parse_ulong(argv[2], argv[0], "level", &err);
 523                 if (err)
 524                         return;
 525         }
 526
 527         retval = ext2fs_extent_goto2(current_handle, level, (blk64_t) blk);
 528
 529         if (retval) {
 530                 com_err(argv[0], retval,
 531                         "while trying to go to block %llu, level %d",
 532                         (unsigned long long) blk, level);
 533                 return;
 534         }
 535
 536         generic_goto_node(NULL, argc, argv, EXT2_EXTENT_CURRENT);
 537 }