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         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 (check_fs_open(argv[0]))
 116                 return;
 117
 118         if (!current_handle) {
 119                 com_err(argv[0], 0, "Extent handle not open");
 120                 return;
 121         }
 122
 123         ext2fs_extent_free(current_handle);
 124         current_handle = NULL;
 125         current_ino = 0;
 126         ss_delete_request_table(sci_idx, &extent_cmds, &ret);
 127         ss_set_prompt(sci_idx, orig_prompt);
 128         free(extent_prompt);
 129         extent_prompt = NULL;
 130 }
 131
 132 void generic_goto_node(char *cmd_name, int op)
 133 {
 134         struct ext2fs_extent    extent;
 135         errcode_t               retval;
 136
 137         if (check_fs_open(cmd_name))
 138                 return;
 139
 140         if (!current_handle) {
 141                 com_err(cmd_name, 0, "Extent handle not open");
 142                 return;
 143         }
 144
 145         retval = ext2fs_extent_get(current_handle, op, &extent);
 146         if (retval) {
 147                 com_err(cmd_name, retval, 0);
 148                 return;
 149         }
 150         dbg_print_extent(0, &extent);
 151 }
 152
 153 void do_current_node(int argc, char *argv[])
 154 {
 155         generic_goto_node(argv[0], EXT2_EXTENT_CURRENT);
 156 }
 157
 158 void do_root_node(int argc, char *argv[])
 159 {
 160         generic_goto_node(argv[0], EXT2_EXTENT_ROOT);
 161 }
 162
 163 void do_last_leaf(int argc, char *argv[])
 164 {
 165         generic_goto_node(argv[0], EXT2_EXTENT_LAST_LEAF);
 166 }
 167
 168 void do_first_sib(int argc, char *argv[])
 169 {
 170         generic_goto_node(argv[0], EXT2_EXTENT_FIRST_SIB);
 171 }
 172
 173 void do_last_sib(int argc, char *argv[])
 174 {
 175         generic_goto_node(argv[0], EXT2_EXTENT_LAST_SIB);
 176 }
 177
 178 void do_next_sib(int argc, char *argv[])
 179 {
 180         generic_goto_node(argv[0], EXT2_EXTENT_NEXT_SIB);
 181 }
 182
 183 void do_prev_sib(int argc, char *argv[])
 184 {
 185         generic_goto_node(argv[0], EXT2_EXTENT_PREV_SIB);
 186 }
 187
 188 void do_next_leaf(int argc, char *argv[])
 189 {
 190         generic_goto_node(argv[0], EXT2_EXTENT_NEXT_LEAF);
 191 }
 192
 193 void do_prev_leaf(int argc, char *argv[])
 194 {
 195         generic_goto_node(argv[0], EXT2_EXTENT_PREV_LEAF);
 196 }
 197
 198 void do_next(int argc, char *argv[])
 199 {
 200         generic_goto_node(argv[0], EXT2_EXTENT_NEXT);
 201 }
 202
 203 void do_prev(int argc, char *argv[])
 204 {
 205         generic_goto_node(argv[0], EXT2_EXTENT_PREV);
 206 }
 207
 208 void do_up(int argc, char *argv[])
 209 {
 210         generic_goto_node(argv[0], EXT2_EXTENT_UP);
 211 }
 212
 213 void do_down(int argc, char *argv[])
 214 {
 215         generic_goto_node(argv[0], EXT2_EXTENT_DOWN);
 216 }
 217
 218 void do_delete_node(int argc, char *argv[])
 219 {
 220         struct ext2fs_extent extent;
 221         errcode_t       retval;
 222
 223         if (common_extent_args_process(argc, argv, 1, 1, "delete_node",
 224                                        "", CHECK_FS_RW | CHECK_FS_BITMAPS))
 225                 return;
 226
 227         retval = ext2fs_extent_delete(current_handle, 0);
 228         if (retval) {
 229                 com_err(argv[0], retval, 0);
 230                 return;
 231         }
 232
 233         retval = ext2fs_extent_get(current_handle, EXT2_EXTENT_CURRENT,
 234                                    &extent);
 235         if (retval)
 236                 return;
 237         dbg_print_extent(0, &extent);
 238 }
 239
 240 void do_replace_node(int argc, char *argv[])
 241 {
 242         const char      *usage = "[--uninit] <lblk> <len> <pblk>";
 243         errcode_t       retval;
 244         struct ext2fs_extent extent;
 245         int err;
 246
 247         if (common_extent_args_process(argc, argv, 3, 5, "replace_node",
 248                                        usage, CHECK_FS_RW | CHECK_FS_BITMAPS))
 249                 return;
 250
 251         extent.e_flags = 0;
 252
 253         if (!strcmp(argv[1], "--uninit")) {
 254                 argc--;
 255                 argv++;
 256                 extent.e_flags |= EXT2_EXTENT_FLAGS_UNINIT;
 257         }
 258
 259         if (argc != 4) {
 260                 fprintf(stderr, "Usage: %s %s\n", argv[0], usage);
 261                 return;
 262         }
 263
 264         extent.e_lblk = parse_ulong(argv[1], argv[0], "logical block", &err);
 265         if (err)
 266                 return;
 267
 268         extent.e_len = parse_ulong(argv[2], argv[0], "logical block", &err);
 269         if (err)
 270                 return;
 271
 272         extent.e_pblk = parse_ulong(argv[3], argv[0], "logical block", &err);
 273         if (err)
 274                 return;
 275
 276         retval = ext2fs_extent_replace(current_handle, 0, &extent);
 277         if (retval) {
 278                 com_err(argv[0], retval, 0);
 279                 return;
 280         }
 281         do_current_node(argc, argv);
 282 }
 283
 284 void do_split_node(int argc, char *argv[])
 285 {
 286         errcode_t       retval;
 287
 288         if (common_extent_args_process(argc, argv, 1, 1, "split_node",
 289                                        "", CHECK_FS_RW | CHECK_FS_BITMAPS))
 290                 return;
 291
 292         retval = ext2fs_extent_node_split(current_handle);
 293         if (retval) {
 294                 com_err(argv[0], retval, 0);
 295                 return;
 296         }
 297         do_current_node(argc, argv);
 298 }
 299
 300 void do_insert_node(int argc, char *argv[])
 301 {
 302         const char      *usage = "[--after] [--uninit] <lblk> <len> <pblk>";
 303         errcode_t       retval;
 304         struct ext2fs_extent extent;
 305         char *cmd;
 306         int err;
 307         int flags = 0;
 308
 309         if (common_extent_args_process(argc, argv, 3, 6, "insert_node",
 310                                        usage, CHECK_FS_RW | CHECK_FS_BITMAPS))
 311                 return;
 312
 313         cmd = argv[0];
 314
 315         extent.e_flags = 0;
 316
 317         while (argc > 2) {
 318                 if (!strcmp(argv[1], "--after")) {
 319                         argc--;
 320                         argv++;
 321                         flags |= EXT2_EXTENT_INSERT_AFTER;
 322                         continue;
 323                 }
 324                 if (!strcmp(argv[1], "--uninit")) {
 325                         argc--;
 326                         argv++;
 327                         extent.e_flags |= EXT2_EXTENT_FLAGS_UNINIT;
 328                         continue;
 329                 }
 330                 break;
 331         }
 332
 333         if (argc != 4) {
 334                 fprintf(stderr, "usage: %s %s\n", cmd, usage);
 335                 return;
 336         }
 337
 338         extent.e_lblk = parse_ulong(argv[1], cmd,
 339                                     "logical block", &err);
 340         if (err)
 341                 return;
 342
 343         extent.e_len = parse_ulong(argv[2], cmd,
 344                                     "length", &err);
 345         if (err)
 346                 return;
 347
 348         extent.e_pblk = parse_ulong(argv[3], cmd,
 349                                     "pysical block", &err);
 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         do_current_node(argc, argv);
 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         blk_t           logical;
 367         blk_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         logical = parse_ulong(argv[1], cmd,
 388                                     "logical block", &err);
 389         if (err)
 390                 return;
 391
 392         physical = parse_ulong(argv[2], cmd,
 393                                     "physical block", &err);
 394         if (err)
 395                 return;
 396
 397         retval = ext2fs_extent_set_bmap(current_handle, logical,
 398                                         (blk64_t) physical, flags);
 399         if (retval) {
 400                 com_err(cmd, retval, 0);
 401                 return;
 402         }
 403
 404         retval = ext2fs_extent_get(current_handle, EXT2_EXTENT_CURRENT,
 405                                    &extent);
 406         if (retval)
 407                 return;
 408         dbg_print_extent(0, &extent);
 409 }
 410
 411 void do_print_all(int argc, char **argv)
 412 {
 413         const char      *usage = "[--leaf-only|--reverse|--reverse-leaf]";
 414         struct ext2fs_extent    extent;
 415         errcode_t               retval;
 416         errcode_t               end_err = EXT2_ET_EXTENT_NO_NEXT;
 417         int                     op = EXT2_EXTENT_NEXT;
 418         int                     first_op = EXT2_EXTENT_ROOT;
 419
 420
 421         if (common_extent_args_process(argc, argv, 1, 2, "print_all",
 422                                        usage, 0))
 423                 return;
 424
 425         if (argc == 2) {
 426                 if (!strcmp(argv[1], "--leaf-only"))
 427                         op = EXT2_EXTENT_NEXT_LEAF;
 428                 else if (!strcmp(argv[1], "--reverse")) {
 429                         op = EXT2_EXTENT_PREV;
 430                         first_op = EXT2_EXTENT_LAST_LEAF;
 431                         end_err = EXT2_ET_EXTENT_NO_PREV;
 432                 } else if (!strcmp(argv[1], "--reverse-leaf")) {
 433                         op = EXT2_EXTENT_PREV_LEAF;
 434                         first_op = EXT2_EXTENT_LAST_LEAF;
 435                         end_err = EXT2_ET_EXTENT_NO_PREV;
 436                 } else {
 437                         fprintf(stderr, "Usage: %s %s\n", argv[0], usage);
 438                         return;
 439                 }
 440         }
 441
 442         retval = ext2fs_extent_get(current_handle, first_op, &extent);
 443         if (retval) {
 444                 com_err(argv[0], retval, 0);
 445                 return;
 446         }
 447         dbg_print_extent(0, &extent);
 448
 449         while (1) {
 450                 retval = ext2fs_extent_get(current_handle, op, &extent);
 451                 if (retval == end_err)
 452                         break;
 453
 454                 if (retval) {
 455                         com_err(argv[0], retval, 0);
 456                         return;
 457                 }
 458                 dbg_print_extent(0, &extent);
 459         }
 460 }
 461
 462 void do_fix_parents(int argc, char **argv)
 463 {
 464         errcode_t               retval;
 465
 466         if (common_extent_args_process(argc, argv, 1, 1, "fix_parents", "",
 467                                        CHECK_FS_RW))
 468                 return;
 469
 470         retval = ext2fs_extent_fix_parents(current_handle);
 471         if (retval) {
 472                 com_err(argv[0], retval, 0);
 473                 return;
 474         }
 475 }
 476
 477 void do_info(int argc, char **argv)
 478 {
 479         struct ext2fs_extent    extent;
 480         struct ext2_extent_info info;
 481         errcode_t               retval;
 482
 483         if (common_extent_args_process(argc, argv, 1, 1, "info", "", 0))
 484                 return;
 485
 486         retval = ext2fs_extent_get_info(current_handle, &info);
 487         if (retval) {
 488                 com_err(argv[0], retval, 0);
 489                 return;
 490         }
 491
 492         retval = ext2fs_extent_get(current_handle,
 493                                    EXT2_EXTENT_CURRENT, &extent);
 494         if (retval) {
 495                 com_err(argv[0], retval, 0);
 496                 return;
 497         }
 498
 499         dbg_print_extent(0, &extent);
 500
 501         printf("Current handle location: %d/%d (max: %d, bytes %d), level %d/%d\n",
 502                info.curr_entry, info.num_entries, info.max_entries,
 503                info.bytes_avail, info.curr_level, info.max_depth);
 504         printf("\tmax lblk: %llu, max pblk: %llu\n", info.max_lblk,
 505                info.max_pblk);
 506         printf("\tmax_len: %u, max_uninit_len: %u\n", info.max_len,
 507                info.max_uninit_len);
 508 }
 509
 510 void do_goto_block(int argc, char **argv)
 511 {
 512         errcode_t               retval;
 513         blk64_t                 blk;
 514         int                     level = 0, err;
 515
 516         if (common_extent_args_process(argc, argv, 2, 3, "goto_block",
 517                                        "block [level]", 0))
 518                 return;
 519
 520         if (strtoblk(argv[0], argv[1], &blk))
 521                 return;
 522
 523         if (argc == 3) {
 524                 level = parse_ulong(argv[2], argv[0], "level", &err);
 525                 if (err)
 526                         return;
 527         }
 528
 529         retval = ext2fs_extent_goto2(current_handle, level, (blk64_t) blk);
 530
 531         if (retval) {
 532                 com_err(argv[0], retval,
 533                         "while trying to go to block %llu, level %d",
 534                         (unsigned long long) blk, level);
 535                 return;
 536         }
 537
 538         generic_goto_node(argv[0], EXT2_EXTENT_CURRENT);
 539 }