1 /* 2 * test_rel.c 3 * 4 * Copyright (C) 1997 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 <stdlib.h> 14 #include <string.h> 15 #include <unistd.h> 16 #ifdef HAVE_GETOPT_H 17 #include <getopt.h> 18 #endif 19 #include <fcntl.h> 20 21 #include <et/com_err.h> 22 #include <ss/ss.h> 23 #include <ext2fs/ext2_fs.h> 24 #include <ext2fs/ext2fs.h> 25 #include <ext2fs/irel.h> 26 #include <ext2fs/brel.h> 27 28 #include "test_rel.h" 29 30 extern ss_request_table test_cmds; 31 32 ext2_irel irel = NULL; 33 ext2_brel brel = NULL; 34 35 /* 36 * Helper function which parses an inode number. 37 */ 38 static int parse_inode(const char *request, const char *desc, 39 const char *str, ext2_ino_t *ino) 40 { 41 char *tmp; 42 43 *ino = strtoul(str, &tmp, 0); 44 if (*tmp) { 45 com_err(request, 0, "Bad %s - %s", desc, str); 46 return 1; 47 } 48 return 0; 49 } 50 51 /* 52 * Helper function which parses a block number. 53 */ 54 static int parse_block(const char *request, const char *desc, 55 const char *str, blk_t *blk) 56 { 57 char *tmp; 58 59 *blk = strtoul(str, &tmp, 0); 60 if (*tmp) { 61 com_err(request, 0, "Bad %s - %s", desc, str); 62 return 1; 63 } 64 return 0; 65 } 66 67 /* 68 * Helper function which assures that a brel table is open 69 */ 70 static int check_brel(char *request) 71 { 72 if (brel) 73 return 0; 74 com_err(request, 0, "A block relocation table must be open."); 75 return 1; 76 } 77 78 /* 79 * Helper function which assures that an irel table is open 80 */ 81 static int check_irel(char *request) 82 { 83 if (irel) 84 return 0; 85 com_err(request, 0, "An inode relocation table must be open."); 86 return 1; 87 } 88 89 /* 90 * Helper function which displays a brel entry 91 */ 92 static void display_brel_entry(blk_t old, 93 struct ext2_block_relocate_entry *ent) 94 { 95 printf("Old= %u, New= %u, Owner= %u:%u\n", old, ent->new, 96 ent->owner.block_ref, ent->offset); 97 } 98 99 /* 100 * Helper function which displays an irel entry 101 */ 102 static void display_irel_entry(ext2_ino_t old, 103 struct ext2_inode_relocate_entry *ent, 104 int do_refs) 105 { 106 struct ext2_inode_reference ref; 107 errcode_t retval; 108 int first = 1; 109 110 printf("Old= %lu, New= %lu, Original=%lu, Max_refs=%u\n", old, 111 ent->new, ent->orig, ent->max_refs); 112 if (!do_refs) 113 return; 114 115 retval = ext2fs_irel_start_iter_ref(irel, old); 116 if (retval) { 117 printf("\tCouldn't get references: %s\n", 118 error_message(retval)); 119 return; 120 } 121 while (1) { 122 retval = ext2fs_irel_next_ref(irel, &ref); 123 if (retval) { 124 printf("(%s) ", error_message(retval)); 125 break; 126 } 127 if (ref.block == 0) 128 break; 129 if (first) { 130 fputc('\t', stdout); 131 first = 0; 132 } else 133 printf(", "); 134 printf("%u:%u", ref.block, ref.offset); 135 } 136 if (!first) 137 fputc('\n', stdout); 138 } 139 140 /* 141 * These are the actual command table procedures 142 */ 143 void do_brel_ma_create(int argc, char **argv) 144 { 145 const char *usage = "Usage: %s name max_blocks\n"; 146 errcode_t retval; 147 blk_t max_blk; 148 149 if (argc < 3) { 150 printf(usage, argv[0]); 151 return; 152 } 153 if (parse_block(argv[0], "max_blocks", argv[2], &max_blk)) 154 return; 155 retval = ext2fs_brel_memarray_create(argv[1], max_blk, &brel); 156 if (retval) { 157 com_err(argv[0], retval, "while opening memarray brel"); 158 return; 159 } 160 return; 161 } 162 163 void do_brel_free(int argc, char **argv) 164 { 165 if (check_brel(argv[0])) 166 return; 167 ext2fs_brel_free(brel); 168 brel = NULL; 169 return; 170 } 171 172 void do_brel_put(int argc, char **argv) 173 { 174 const char *usage = "usage: %s old_block new_block [owner] [offset]"; 175 errcode_t retval; 176 struct ext2_block_relocate_entry ent; 177 blk_t old, new, offset=0, owner=0; 178 179 if (check_brel(argv[0])) 180 return; 181 182 if (argc < 3) { 183 printf(usage, argv[0]); 184 return; 185 } 186 if (parse_block(argv[0], "old block", argv[1], &old)) 187 return; 188 if (parse_block(argv[0], "new block", argv[2], &new)) 189 return; 190 if (argc > 3 && 191 parse_block(argv[0], "owner block", argv[3], &owner)) 192 return; 193 if (argc > 4 && 194 parse_block(argv[0], "offset", argv[4], &offset)) 195 return; 196 if (offset > 65535) { 197 printf("Offset too large.\n"); 198 return; 199 } 200 ent.new = new; 201 ent.offset = (__u16) offset; 202 ent.flags = 0; 203 ent.owner.block_ref = owner; 204 205 retval = ext2fs_brel_put(brel, old, &ent); 206 if (retval) { 207 com_err(argv[0], retval, "while calling ext2fs_brel_put"); 208 return; 209 } 210 return; 211 } 212 213 void do_brel_get(int argc, char **argv) 214 { 215 const char *usage = "%s block"; 216 errcode_t retval; 217 struct ext2_block_relocate_entry ent; 218 blk_t blk; 219 220 if (check_brel(argv[0])) 221 return; 222 if (argc < 2) { 223 printf(usage, argv[0]); 224 return; 225 } 226 if (parse_block(argv[0], "block", argv[1], &blk)) 227 return; 228 retval = ext2fs_brel_get(brel, blk, &ent); 229 if (retval) { 230 com_err(argv[0], retval, "while calling ext2fs_brel_get"); 231 return; 232 } 233 display_brel_entry(blk, &ent); 234 return; 235 } 236 237 void do_brel_start_iter(int argc, char **argv) 238 { 239 errcode_t retval; 240 241 if (check_brel(argv[0])) 242 return; 243 244 retval = ext2fs_brel_start_iter(brel); 245 if (retval) { 246 com_err(argv[0], retval, "while calling ext2fs_brel_start_iter"); 247 return; 248 } 249 return; 250 } 251 252 void do_brel_next(int argc, char **argv) 253 { 254 errcode_t retval; 255 struct ext2_block_relocate_entry ent; 256 blk_t blk; 257 258 if (check_brel(argv[0])) 259 return; 260 261 retval = ext2fs_brel_next(brel, &blk, &ent); 262 if (retval) { 263 com_err(argv[0], retval, "while calling ext2fs_brel_next"); 264 return; 265 } 266 if (blk == 0) { 267 printf("No more entries!\n"); 268 return; 269 } 270 display_brel_entry(blk, &ent); 271 return; 272 } 273 274 void do_brel_dump(int argc, char **argv) 275 { 276 errcode_t retval; 277 struct ext2_block_relocate_entry ent; 278 blk_t blk; 279 280 if (check_brel(argv[0])) 281 return; 282 283 retval = ext2fs_brel_start_iter(brel); 284 if (retval) { 285 com_err(argv[0], retval, "while calling ext2fs_brel_start_iter"); 286 return; 287 } 288 289 while (1) { 290 retval = ext2fs_brel_next(brel, &blk, &ent); 291 if (retval) { 292 com_err(argv[0], retval, "while calling ext2fs_brel_next"); 293 return; 294 } 295 if (blk == 0) 296 break; 297 298 display_brel_entry(blk, &ent); 299 } 300 return; 301 } 302 303 void do_brel_move(int argc, char **argv) 304 { 305 const char *usage = "%s old_block new_block"; 306 errcode_t retval; 307 blk_t old, new; 308 309 if (check_brel(argv[0])) 310 return; 311 if (argc < 2) { 312 printf(usage, argv[0]); 313 return; 314 } 315 if (parse_block(argv[0], "old block", argv[1], &old)) 316 return; 317 if (parse_block(argv[0], "new block", argv[2], &new)) 318 return; 319 320 retval = ext2fs_brel_move(brel, old, new); 321 if (retval) { 322 com_err(argv[0], retval, "while calling ext2fs_brel_move"); 323 return; 324 } 325 return; 326 } 327 328 void do_brel_delete(int argc, char **argv) 329 { 330 const char *usage = "%s block"; 331 errcode_t retval; 332 blk_t blk; 333 334 if (check_brel(argv[0])) 335 return; 336 if (argc < 2) { 337 printf(usage, argv[0]); 338 return; 339 } 340 if (parse_block(argv[0], "block", argv[1], &blk)) 341 return; 342 343 retval = ext2fs_brel_delete(brel, blk); 344 if (retval) { 345 com_err(argv[0], retval, "while calling ext2fs_brel_delete"); 346 return; 347 } 348 } 349 350 void do_irel_ma_create(int argc, char **argv) 351 { 352 const char *usage = "Usage: %s name max_inode\n"; 353 errcode_t retval; 354 ext2_ino_t max_ino; 355 356 if (argc < 3) { 357 printf(usage, argv[0]); 358 return; 359 } 360 if (parse_inode(argv[0], "max_inodes", argv[2], &max_ino)) 361 return; 362 retval = ext2fs_irel_memarray_create(argv[1], max_ino, &irel); 363 if (retval) { 364 com_err(argv[0], retval, "while opening memarray irel"); 365 return; 366 } 367 return; 368 } 369 370 void do_irel_free(int argc, char **argv) 371 { 372 if (check_irel(argv[0])) 373 return; 374 375 ext2fs_irel_free(irel); 376 irel = NULL; 377 return; 378 } 379 380 void do_irel_put(int argc, char **argv) 381 { 382 const char *usage = "%s old new max_refs"; 383 errcode_t retval; 384 ext2_ino_t old, new, max_refs; 385 struct ext2_inode_relocate_entry ent; 386 387 if (check_irel(argv[0])) 388 return; 389 390 if (argc < 4) { 391 printf(usage, argv[0]); 392 return; 393 } 394 if (parse_inode(argv[0], "old inode", argv[1], &old)) 395 return; 396 if (parse_inode(argv[0], "new inode", argv[2], &new)) 397 return; 398 if (parse_inode(argv[0], "max_refs", argv[3], &max_refs)) 399 return; 400 if (max_refs > 65535) { 401 printf("max_refs too big\n"); 402 return; 403 } 404 ent.new = new; 405 ent.max_refs = (__u16) max_refs; 406 ent.flags = 0; 407 408 retval = ext2fs_irel_put(irel, old, &ent); 409 if (retval) { 410 com_err(argv[0], retval, "while calling ext2fs_irel_put"); 411 return; 412 } 413 return; 414 } 415 416 void do_irel_get(int argc, char **argv) 417 { 418 const char *usage = "%s inode"; 419 errcode_t retval; 420 ext2_ino_t old; 421 struct ext2_inode_relocate_entry ent; 422 423 if (check_irel(argv[0])) 424 return; 425 426 if (argc < 2) { 427 printf(usage, argv[0]); 428 return; 429 } 430 if (parse_inode(argv[0], "inode", argv[1], &old)) 431 return; 432 433 retval = ext2fs_irel_get(irel, old, &ent); 434 if (retval) { 435 com_err(argv[0], retval, "while calling ext2fs_irel_get"); 436 return; 437 } 438 display_irel_entry(old, &ent, 1); 439 return; 440 } 441 442 void do_irel_get_by_orig(int argc, char **argv) 443 { 444 const char *usage = "%s orig_inode"; 445 errcode_t retval; 446 ext2_ino_t orig, old; 447 struct ext2_inode_relocate_entry ent; 448 449 if (check_irel(argv[0])) 450 return; 451 452 if (argc < 2) { 453 printf(usage, argv[0]); 454 return; 455 } 456 if (parse_inode(argv[0], "original inode", argv[1], &orig)) 457 return; 458 459 retval = ext2fs_irel_get_by_orig(irel, orig, &old, &ent); 460 if (retval) { 461 com_err(argv[0], retval, "while calling ext2fs_irel_get_by_orig"); 462 return; 463 } 464 display_irel_entry(old, &ent, 1); 465 return; 466 } 467 468 void do_irel_start_iter(int argc, char **argv) 469 { 470 errcode_t retval; 471 472 if (check_irel(argv[0])) 473 return; 474 475 retval = ext2fs_irel_start_iter(irel); 476 if (retval) { 477 com_err(argv[0], retval, "while calling ext2fs_irel_start_iter"); 478 return; 479 } 480 return; 481 } 482 483 void do_irel_next(int argc, char **argv) 484 { 485 errcode_t retval; 486 ext2_ino_t old; 487 struct ext2_inode_relocate_entry ent; 488 489 if (check_irel(argv[0])) 490 return; 491 492 retval = ext2fs_irel_next(irel, &old, &ent); 493 if (retval) { 494 com_err(argv[0], retval, "while calling ext2fs_irel_next"); 495 return; 496 } 497 if (old == 0) { 498 printf("No more entries!\n"); 499 return; 500 } 501 display_irel_entry(old, &ent, 1); 502 return; 503 } 504 505 void do_irel_dump(int argc, char **argv) 506 { 507 errcode_t retval; 508 ext2_ino_t ino; 509 struct ext2_inode_relocate_entry ent; 510 511 if (check_irel(argv[0])) 512 return; 513 514 retval = ext2fs_irel_start_iter(irel); 515 if (retval) { 516 com_err(argv[0], retval, "while calling ext2fs_irel_start_iter"); 517 return; 518 } 519 520 while (1) { 521 retval = ext2fs_irel_next(irel, &ino, &ent); 522 if (retval) { 523 com_err(argv[0], retval, "while calling ext2fs_irel_next"); 524 return; 525 } 526 if (ino == 0) 527 break; 528 529 display_irel_entry(ino, &ent, 1); 530 } 531 return; 532 } 533 534 void do_irel_add_ref(int argc, char **argv) 535 { 536 const char *usage = "%s inode block offset"; 537 errcode_t retval; 538 blk_t block, offset; 539 ext2_ino_t ino; 540 struct ext2_inode_reference ref; 541 542 543 if (check_irel(argv[0])) 544 return; 545 546 if (argc < 4) { 547 printf(usage, argv[0]); 548 return; 549 } 550 if (parse_inode(argv[0], "inode", argv[1], &ino)) 551 return; 552 if (parse_block(argv[0], "block", argv[2], &block)) 553 return; 554 if (parse_block(argv[0], "offset", argv[3], &offset)) 555 return; 556 if (offset > 65535) { 557 printf("Offset too big.\n"); 558 return; 559 } 560 ref.block = block; 561 ref.offset = offset; 562 563 retval = ext2fs_irel_add_ref(irel, ino, &ref); 564 if (retval) { 565 com_err(argv[0], retval, "while calling ext2fs_irel_add_ref"); 566 return; 567 } 568 return; 569 } 570 571 void do_irel_start_iter_ref(int argc, char **argv) 572 { 573 const char *usage = "%s inode"; 574 errcode_t retval; 575 ext2_ino_t ino; 576 577 if (check_irel(argv[0])) 578 return; 579 580 if (argc < 2) { 581 printf(usage, argv[0]); 582 return; 583 } 584 585 if (parse_inode(argv[0], "inode", argv[1], &ino)) 586 return; 587 retval = ext2fs_irel_start_iter_ref(irel, ino); 588 if (retval) { 589 com_err(argv[0], retval, "while calling ext2fs_irel_start_iter_ref"); 590 return; 591 } 592 return; 593 } 594 595 void do_irel_next_ref(int argc, char **argv) 596 { 597 struct ext2_inode_reference ref; 598 errcode_t retval; 599 600 if (check_irel(argv[0])) 601 return; 602 603 retval = ext2fs_irel_next_ref(irel, &ref); 604 if (retval) { 605 com_err(argv[0], retval, "while calling ext2fs_irel_next_ref"); 606 return; 607 } 608 printf("Inode reference: %u:%u\n", ref.block, ref.offset); 609 return; 610 } 611 612 void do_irel_move(int argc, char **argv) 613 { 614 const char *usage = "%s old new"; 615 errcode_t retval; 616 ext2_ino_t old, new; 617 618 if (check_irel(argv[0])) 619 return; 620 621 if (argc < 3) { 622 printf(usage, argv[0]); 623 return; 624 } 625 if (parse_inode(argv[0], "old inode", argv[1], &old)) 626 return; 627 if (parse_inode(argv[0], "new inode", argv[2], &new)) 628 return; 629 630 retval = ext2fs_irel_move(irel, old, new); 631 if (retval) { 632 com_err(argv[0], retval, "while calling ext2fs_irel_move"); 633 return; 634 } 635 return; 636 } 637 638 void do_irel_delete(int argc, char **argv) 639 { 640 const char *usage = "%s inode"; 641 errcode_t retval; 642 ext2_ino_t ino; 643 644 if (check_irel(argv[0])) 645 return; 646 647 if (argc < 2) { 648 printf(usage, argv[0]); 649 return; 650 } 651 if (parse_inode(argv[0], "inode", argv[1], &ino)) 652 return; 653 654 retval = ext2fs_irel_delete(irel, ino); 655 if (retval) { 656 com_err(argv[0], retval, "while calling ext2fs_irel_delete"); 657 return; 658 } 659 return; 660 } 661 662 static int source_file(const char *cmd_file, int sci_idx) 663 { 664 FILE *f; 665 char buf[256]; 666 char *cp; 667 int exit_status = 0; 668 int retval; 669 int noecho; 670 671 if (strcmp(cmd_file, "-") == 0) 672 f = stdin; 673 else { 674 f = fopen(cmd_file, "r"); 675 if (!f) { 676 perror(cmd_file); 677 exit(1); 678 } 679 } 680 fflush(stdout); 681 fflush(stderr); 682 setbuf(stdout, NULL); 683 setbuf(stderr, NULL); 684 while (!feof(f)) { 685 if (fgets(buf, sizeof(buf), f) == NULL) 686 break; 687 if (buf[0] == '#') 688 continue; 689 noecho = 0; 690 if (buf[0] == '-') { 691 noecho = 1; 692 buf[0] = ' '; 693 } 694 cp = strchr(buf, '\n'); 695 if (cp) 696 *cp = 0; 697 cp = strchr(buf, '\r'); 698 if (cp) 699 *cp = 0; 700 if (!noecho) 701 printf("test_rel: %s\n", buf); 702 retval = ss_execute_line(sci_idx, buf); 703 if (retval) { 704 ss_perror(sci_idx, retval, buf); 705 exit_status++; 706 } 707 } 708 return exit_status; 709 } 710 711 void main(int argc, char **argv) 712 { 713 int retval; 714 int sci_idx; 715 const char *usage = "Usage: test_rel [-R request] [-f cmd_file]"; 716 char c; 717 char *request = 0; 718 int exit_status = 0; 719 char *cmd_file = 0; 720 721 initialize_ext2_error_table(); 722 723 while ((c = getopt (argc, argv, "wR:f:")) != EOF) { 724 switch (c) { 725 case 'R': 726 request = optarg; 727 break; 728 case 'f': 729 cmd_file = optarg; 730 break; 731 default: 732 com_err(argv[0], 0, usage); 733 return; 734 } 735 } 736 sci_idx = ss_create_invocation("test_rel", "0.0", (char *) NULL, 737 &test_cmds, &retval); 738 if (retval) { 739 ss_perror(sci_idx, retval, "creating invocation"); 740 exit(1); 741 } 742 743 (void) ss_add_request_table (sci_idx, &ss_std_requests, 1, &retval); 744 if (retval) { 745 ss_perror(sci_idx, retval, "adding standard requests"); 746 exit (1); 747 } 748 if (request) { 749 retval = 0; 750 retval = ss_execute_line(sci_idx, request); 751 if (retval) { 752 ss_perror(sci_idx, retval, request); 753 exit_status++; 754 } 755 } else if (cmd_file) { 756 exit_status = source_file(cmd_file, sci_idx); 757 } else { 758 ss_listen(sci_idx); 759 } 760 761 exit(exit_status); 762 } 763 764
