1 /* 2 * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved. 3 */ 4 5 /* 6 * Copyright (c) 1988 Regents of the University of California. 7 * All rights reserved. 8 * 9 * This code is derived from software contributed to Berkeley by 10 * Computer Consoles Inc. 11 * 12 * Redistribution and use in source and binary forms are permitted 13 * provided that: (1) source distributions retain this entire copyright 14 * notice and comment, and (2) distributions including binaries display 15 * the following acknowledgement: ``This product includes software 16 * developed by the University of California, Berkeley and its contributors'' 17 * in the documentation or other materials provided with the distribution 18 * and in all advertising materials mentioning features or use of this 19 * software. Neither the name of the University nor the names of its 20 * contributors may be used to endorse or promote products derived 21 * from this software without specific prior written permission. 22 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED 24 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. 25 */ 26 27 #ifndef lint 28 char copyright[] = 29 "@(#) Copyright(c) 1988 Regents of the University of California.\n\ 30 All rights reserved.\n"; 31 #endif /* not lint */ 32 33 #ifndef lint 34 static char sccsid[] = "@(#)fsdb.c 5.8 (Berkeley) 6/1/90"; 35 #endif /* not lint */ 36 37 /* 38 * fsdb - file system debugger 39 * 40 * usage: fsdb [-o suboptions] special 41 * options/suboptions: 42 * -o 43 * ? display usage 44 * o override some error conditions 45 * p="string" set prompt to string 46 * w open for write 47 */ 48 49 #include <sys/param.h> 50 #include <sys/signal.h> 51 #include <sys/file.h> 52 #include <inttypes.h> 53 #include <sys/sysmacros.h> 54 55 #ifdef sun 56 #include <unistd.h> 57 #include <stdlib.h> 58 #include <string.h> 59 #include <fcntl.h> 60 #include <signal.h> 61 #include <sys/types.h> 62 #include <sys/vnode.h> 63 #include <sys/mntent.h> 64 #include <sys/wait.h> 65 #include <sys/fs/ufs_fsdir.h> 66 #include <sys/fs/ufs_fs.h> 67 #include <sys/fs/ufs_inode.h> 68 #include <sys/fs/ufs_acl.h> 69 #include <sys/fs/ufs_log.h> 70 #else 71 #include <sys/dir.h> 72 #include <ufs/fs.h> 73 #include <ufs/dinode.h> 74 #include <paths.h> 75 #endif /* sun */ 76 77 #include <stdio.h> 78 #include <setjmp.h> 79 80 #define OLD_FSDB_COMPATIBILITY /* To support the obsoleted "-z" option */ 81 82 #ifndef _PATH_BSHELL 83 #define _PATH_BSHELL "/bin/sh" 84 #endif /* _PATH_BSHELL */ 85 /* 86 * Defines from the 4.3-tahoe file system, for systems with the 4.2 or 4.3 87 * file system. 88 */ 89 #ifndef FS_42POSTBLFMT 90 #define cg_blktot(cgp) (((cgp))->cg_btot) 91 #define cg_blks(fs, cgp, cylno) (((cgp))->cg_b[cylno]) 92 #define cg_inosused(cgp) (((cgp))->cg_iused) 93 #define cg_blksfree(cgp) (((cgp))->cg_free) 94 #define cg_chkmagic(cgp) ((cgp)->cg_magic == CG_MAGIC) 95 #endif 96 97 /* 98 * Never changing defines. 99 */ 100 #define OCTAL 8 /* octal base */ 101 #define DECIMAL 10 /* decimal base */ 102 #define HEX 16 /* hexadecimal base */ 103 104 /* 105 * Adjustable defines. 106 */ 107 #define NBUF 10 /* number of cache buffers */ 108 #define PROMPTSIZE 80 /* size of user definable prompt */ 109 #define MAXFILES 40000 /* max number of files ls can handle */ 110 #define FIRST_DEPTH 10 /* default depth for find and ls */ 111 #define SECOND_DEPTH 100 /* second try at depth (maximum) */ 112 #define INPUTBUFFER 1040 /* size of input buffer */ 113 #define BYTESPERLINE 16 /* bytes per line of /dxo output */ 114 #define NREG 36 /* number of save registers */ 115 116 #define DEVPREFIX "/dev/" /* Uninteresting part of "special" */ 117 118 #if defined(OLD_FSDB_COMPATIBILITY) 119 #define FSDB_OPTIONS "o:wp:z:" 120 #else 121 #define FSDB_OPTIONS "o:wp:" 122 #endif /* OLD_FSDB_COMPATIBILITY */ 123 124 125 /* 126 * Values dependent on sizes of structs and such. 127 */ 128 #define NUMB 3 /* these three are arbitrary, */ 129 #define BLOCK 5 /* but must be different from */ 130 #define FRAGMENT 7 /* the rest (hence odd). */ 131 #define BITSPERCHAR 8 /* couldn't find it anywhere */ 132 #define CHAR (sizeof (char)) 133 #define SHORT (sizeof (short)) 134 #define LONG (sizeof (long)) 135 #define U_OFFSET_T (sizeof (u_offset_t)) /* essentially "long long" */ 136 #define INODE (sizeof (struct dinode)) 137 #define DIRECTORY (sizeof (struct direct)) 138 #define CGRP (sizeof (struct cg)) 139 #define SB (sizeof (struct fs)) 140 #define BLKSIZE (fs->fs_bsize) /* for clarity */ 141 #define FRGSIZE (fs->fs_fsize) 142 #define BLKSHIFT (fs->fs_bshift) 143 #define FRGSHIFT (fs->fs_fshift) 144 #define SHADOW_DATA (sizeof (struct ufs_fsd)) 145 146 /* 147 * Messy macros that would otherwise clutter up such glamorous code. 148 */ 149 #define itob(i) (((u_offset_t)itod(fs, (i)) << \ 150 (u_offset_t)FRGSHIFT) + (u_offset_t)itoo(fs, (i)) * (u_offset_t)INODE) 151 #define min(x, y) ((x) < (y) ? (x) : (y)) 152 #define STRINGSIZE(d) ((long)d->d_reclen - \ 153 ((long)&d->d_name[0] - (long)&d->d_ino)) 154 #define letter(c) ((((c) >= 'a')&&((c) <= 'z')) ||\ 155 (((c) >= 'A')&&((c) <= 'Z'))) 156 #define digit(c) (((c) >= '0') && ((c) <= '9')) 157 #define HEXLETTER(c) (((c) >= 'A') && ((c) <= 'F')) 158 #define hexletter(c) (((c) >= 'a') && ((c) <= 'f')) 159 #define octaldigit(c) (((c) >= '0') && ((c) <= '7')) 160 #define uppertolower(c) ((c) - 'A' + 'a') 161 #define hextodigit(c) ((c) - 'a' + 10) 162 #define numtodigit(c) ((c) - '0') 163 164 #if !defined(loword) 165 #define loword(X) (((ushort_t *)&X)[1]) 166 #endif /* loword */ 167 168 #if !defined(lobyte) 169 #define lobyte(X) (((unsigned char *)&X)[1]) 170 #endif /* lobyte */ 171 172 /* 173 * buffer cache structure. 174 */ 175 static struct lbuf { 176 struct lbuf *fwd; 177 struct lbuf *back; 178 char *blkaddr; 179 short valid; 180 u_offset_t blkno; 181 } lbuf[NBUF], bhdr; 182 183 /* 184 * used to hold save registers (see '<' and '>'). 185 */ 186 struct save_registers { 187 u_offset_t sv_addr; 188 u_offset_t sv_value; 189 long sv_objsz; 190 } regs[NREG]; 191 192 /* 193 * cd, find, and ls use this to hold filenames. Each filename is broken 194 * up by a slash. In other words, /usr/src/adm would have a len field 195 * of 2 (starting from 0), and filenames->fname[0-2] would hold usr, 196 * src, and adm components of the pathname. 197 */ 198 static struct filenames { 199 ino_t ino; /* inode */ 200 long len; /* number of components */ 201 char flag; /* flag if using SECOND_DEPTH allocator */ 202 char find; /* flag if found by find */ 203 char **fname; /* hold components of pathname */ 204 } *filenames, *top; 205 206 enum log_enum { LOG_NDELTAS, LOG_ALLDELTAS, LOG_CHECKSCAN }; 207 #ifdef sun 208 struct fs *fs; 209 static union { 210 struct fs un_filesystem; 211 char un_sbsize[SBSIZE]; 212 } fs_un; 213 #define filesystem fs_un.un_filesystem 214 #else 215 struct fs filesystem, *fs; /* super block */ 216 #endif /* sun */ 217 218 /* 219 * Global data. 220 */ 221 static char *input_path[MAXPATHLEN]; 222 static char *stack_path[MAXPATHLEN]; 223 static char *current_path[MAXPATHLEN]; 224 static char input_buffer[INPUTBUFFER]; 225 static char *prompt; 226 static char *buffers; 227 static char scratch[64]; 228 static char BASE[] = "o u x"; 229 static char PROMPT[PROMPTSIZE]; 230 static char laststyle = '/'; 231 static char lastpo = 'x'; 232 static short input_pointer; 233 static short current_pathp; 234 static short stack_pathp; 235 static short input_pathp; 236 static short cmp_level; 237 static int nfiles; 238 static short type = NUMB; 239 static short dirslot; 240 static short fd; 241 static short c_count; 242 static short error; 243 static short paren; 244 static short trapped; 245 static short doing_cd; 246 static short doing_find; 247 static short find_by_name; 248 static short find_by_inode; 249 static short long_list; 250 static short recursive; 251 static short objsz = SHORT; 252 static short override = 0; 253 static short wrtflag = O_RDONLY; 254 static short base = HEX; 255 static short acting_on_inode; 256 static short acting_on_directory; 257 static short should_print = 1; 258 static short clear; 259 static short star; 260 static u_offset_t addr; 261 static u_offset_t bod_addr; 262 static u_offset_t value; 263 static u_offset_t erraddr; 264 static long errcur_bytes; 265 static u_offset_t errino; 266 static long errinum; 267 static long cur_cgrp; 268 static u_offset_t cur_ino; 269 static long cur_inum; 270 static u_offset_t cur_dir; 271 static long cur_block; 272 static long cur_bytes; 273 static long find_ino; 274 static u_offset_t filesize; 275 static u_offset_t blocksize; 276 static long stringsize; 277 static long count = 1; 278 static long commands; 279 static long read_requests; 280 static long actual_disk_reads; 281 static jmp_buf env; 282 static long maxfiles; 283 static long cur_shad; 284 285 #ifndef sun 286 extern char *malloc(), *calloc(); 287 #endif 288 static char getachar(); 289 static char *getblk(), *fmtentry(); 290 291 static offset_t get(short); 292 static long bmap(); 293 static long expr(); 294 static long term(); 295 static long getnumb(); 296 static u_offset_t getdirslot(); 297 static unsigned long *print_check(unsigned long *, long *, short, int); 298 299 static void usage(char *); 300 static void ungetachar(char); 301 static void getnextinput(); 302 static void eat_spaces(); 303 static void restore_inode(ino_t); 304 static void find(); 305 static void ls(struct filenames *, struct filenames *, short); 306 static void formatf(struct filenames *, struct filenames *); 307 static void parse(); 308 static void follow_path(long, long); 309 static void getname(); 310 static void freemem(struct filenames *, int); 311 static void print_path(char **, int); 312 static void fill(); 313 static void put(u_offset_t, short); 314 static void insert(struct lbuf *); 315 static void puta(); 316 static void fprnt(char, char); 317 static void index(); 318 #ifdef _LARGEFILE64_SOURCE 319 static void printll 320 (u_offset_t value, int fieldsz, int digits, int lead); 321 #define print(value, fieldsz, digits, lead) \ 322 printll((u_offset_t)value, fieldsz, digits, lead) 323 #else /* !_LARGEFILE64_SOURCE */ 324 static void print(long value, int fieldsz, int digits, int lead); 325 #endif /* _LARGEFILE64_SOURCE */ 326 static void printsb(struct fs *); 327 static void printcg(struct cg *); 328 static void pbits(unsigned char *, int); 329 static void old_fsdb(int, char *); /* For old fsdb functionality */ 330 331 static int isnumber(char *); 332 static int icheck(u_offset_t); 333 static int cgrp_check(long); 334 static int valid_addr(); 335 static int match(char *, int); 336 static int devcheck(short); 337 static int bcomp(); 338 static int compare(char *, char *, short); 339 static int check_addr(short, short *, short *, short); 340 static int fcmp(); 341 static int ffcmp(); 342 343 static int getshadowslot(long); 344 static void getshadowdata(long *, int); 345 static void syncshadowscan(int); 346 static void log_display_header(void); 347 static void log_show(enum log_enum); 348 349 #ifdef sun 350 static void err(); 351 #else 352 static int err(); 353 #endif /* sun */ 354 355 /* Suboption vector */ 356 static char *subopt_v[] = { 357 #define OVERRIDE 0 358 "o", 359 #define NEW_PROMPT 1 360 "p", 361 #define WRITE_ENABLED 2 362 "w", 363 #define ALT_PROMPT 3 364 "prompt", 365 NULL 366 }; 367 368 /* 369 * main - lines are read up to the unprotected ('\') newline and 370 * held in an input buffer. Characters may be read from the 371 * input buffer using getachar() and unread using ungetachar(). 372 * Reading the whole line ahead allows the use of debuggers 373 * which would otherwise be impossible since the debugger 374 * and fsdb could not share stdin. 375 */ 376 377 int 378 main(int argc, char *argv[]) 379 { 380 381 char c, *cptr; 382 short i; 383 struct direct *dirp; 384 struct lbuf *bp; 385 char *progname; 386 short colon, mode; 387 long temp; 388 389 /* Options/Suboptions processing */ 390 int opt; 391 char *subopts; 392 char *optval; 393 394 /* 395 * The following are used to support the old fsdb functionality 396 * of clearing an inode. It's better to use 'clri'. 397 */ 398 int inum; /* Inode number to clear */ 399 char *special; 400 401 setbuf(stdin, NULL); 402 progname = argv[0]; 403 prompt = &PROMPT[0]; 404 /* 405 * Parse options. 406 */ 407 while ((opt = getopt(argc, argv, FSDB_OPTIONS)) != EOF) { 408 switch (opt) { 409 #if defined(OLD_FSDB_COMPATIBILITY) 410 case 'z': /* Hack - Better to use clri */ 411 (void) fprintf(stderr, "%s\n%s\n%s\n%s\n", 412 "Warning: The '-z' option of 'fsdb_ufs' has been declared obsolete", 413 "and may not be supported in a future version of Solaris.", 414 "While this functionality is currently still supported, the", 415 "recommended procedure to clear an inode is to use clri(1M)."); 416 if (isnumber(optarg)) { 417 inum = atoi(optarg); 418 special = argv[optind]; 419 /* Doesn't return */ 420 old_fsdb(inum, special); 421 } else { 422 usage(progname); 423 exit(31+1); 424 } 425 /* Should exit() before here */ 426 /*NOTREACHED*/ 427 #endif /* OLD_FSDB_COMPATIBILITY */ 428 case 'o': 429 /* UFS Specific Options */ 430 subopts = optarg; 431 while (*subopts != '\0') { 432 switch (getsubopt(&subopts, subopt_v, 433 &optval)) { 434 case OVERRIDE: 435 printf("error checking off\n"); 436 override = 1; 437 break; 438 439 /* 440 * Change the "-o prompt=foo" option to 441 * "-o p=foo" to match documentation. 442 * ALT_PROMPT continues support for the 443 * undocumented "-o prompt=foo" option so 444 * that we don't break anyone. 445 */ 446 case NEW_PROMPT: 447 case ALT_PROMPT: 448 if (optval == NULL) { 449 (void) fprintf(stderr, 450 "No prompt string\n"); 451 usage(progname); 452 } 453 (void) strncpy(PROMPT, optval, 454 PROMPTSIZE); 455 break; 456 457 case WRITE_ENABLED: 458 /* suitable for open */ 459 wrtflag = O_RDWR; 460 break; 461 462 default: 463 usage(progname); 464 /* Should exit here */ 465 } 466 } 467 break; 468 469 default: 470 usage(progname); 471 } 472 } 473 474 if ((argc - optind) != 1) { /* Should just have "special" left */ 475 usage(progname); 476 } 477 special = argv[optind]; 478 479 /* 480 * Unless it's already been set, the default prompt includes the 481 * name of the special device. 482 */ 483 if (*prompt == NULL) 484 (void) sprintf(prompt, "%s > ", special); 485 486 /* 487 * Attempt to open the special file. 488 */ 489 if ((fd = open(special, wrtflag)) < 0) { 490 perror(special); 491 exit(1); 492 } 493 /* 494 * Read in the super block and validate (not too picky). 495 */ 496 if (llseek(fd, (offset_t)(SBLOCK * DEV_BSIZE), 0) == -1) { 497 perror(special); 498 exit(1); 499 } 500 501 #ifdef sun 502 if (read(fd, &filesystem, SBSIZE) != SBSIZE) { 503 printf("%s: cannot read superblock\n", special); 504 exit(1); 505 } 506 #else 507 if (read(fd, &filesystem, sizeof (filesystem)) != sizeof (filesystem)) { 508 printf("%s: cannot read superblock\n", special); 509 exit(1); 510 } 511 #endif /* sun */ 512 513 fs = &filesystem; 514 if ((fs->fs_magic != FS_MAGIC) && (fs->fs_magic != MTB_UFS_MAGIC)) { 515 if (!override) { 516 printf("%s: Bad magic number in file system\n", 517 special); 518 exit(1); 519 } 520 521 printf("WARNING: Bad magic number in file system. "); 522 printf("Continue? (y/n): "); 523 (void) fflush(stdout); 524 if (gets(input_buffer) == NULL) { 525 exit(1); 526 } 527 528 if (*input_buffer != 'y' && *input_buffer != 'Y') { 529 exit(1); 530 } 531 } 532 533 if ((fs->fs_magic == FS_MAGIC && 534 (fs->fs_version != UFS_EFISTYLE4NONEFI_VERSION_2 && 535 fs->fs_version != UFS_VERSION_MIN)) || 536 (fs->fs_magic == MTB_UFS_MAGIC && 537 (fs->fs_version > MTB_UFS_VERSION_1 || 538 fs->fs_version < MTB_UFS_VERSION_MIN))) { 539 if (!override) { 540 printf("%s: Unrecognized UFS version number: %d\n", 541 special, fs->fs_version); 542 exit(1); 543 } 544 545 printf("WARNING: Unrecognized UFS version number. "); 546 printf("Continue? (y/n): "); 547 (void) fflush(stdout); 548 if (gets(input_buffer) == NULL) { 549 exit(1); 550 } 551 552 if (*input_buffer != 'y' && *input_buffer != 'Y') { 553 exit(1); 554 } 555 } 556 #ifdef FS_42POSTBLFMT 557 if (fs->fs_postblformat == FS_42POSTBLFMT) 558 fs->fs_nrpos = 8; 559 #endif 560 printf("fsdb of %s %s -- last mounted on %s\n", 561 special, 562 (wrtflag == O_RDWR) ? "(Opened for write)" : "(Read only)", 563 &fs->fs_fsmnt[0]); 564 #ifdef sun 565 printf("fs_clean is currently set to "); 566 switch (fs->fs_clean) { 567 568 case FSACTIVE: 569 printf("FSACTIVE\n"); 570 break; 571 case FSCLEAN: 572 printf("FSCLEAN\n"); 573 break; 574 case FSSTABLE: 575 printf("FSSTABLE\n"); 576 break; 577 case FSBAD: 578 printf("FSBAD\n"); 579 break; 580 case FSSUSPEND: 581 printf("FSSUSPEND\n"); 582 break; 583 case FSLOG: 584 printf("FSLOG\n"); 585 break; 586 case FSFIX: 587 printf("FSFIX\n"); 588 if (!override) { 589 printf("%s: fsck may be running on this file system\n", 590 special); 591 exit(1); 592 } 593 594 printf("WARNING: fsck may be running on this file system. "); 595 printf("Continue? (y/n): "); 596 (void) fflush(stdout); 597 if (gets(input_buffer) == NULL) { 598 exit(1); 599 } 600 601 if (*input_buffer != 'y' && *input_buffer != 'Y') { 602 exit(1); 603 } 604 break; 605 default: 606 printf("an unknown value (0x%x)\n", fs->fs_clean); 607 break; 608 } 609 610 if (fs->fs_state == (FSOKAY - fs->fs_time)) { 611 printf("fs_state consistent (fs_clean CAN be trusted)\n"); 612 } else { 613 printf("fs_state inconsistent (fs_clean CAN'T trusted)\n"); 614 } 615 #endif /* sun */ 616 /* 617 * Malloc buffers and set up cache. 618 */ 619 buffers = malloc(NBUF * BLKSIZE); 620 bhdr.fwd = bhdr.back = &bhdr; 621 for (i = 0; i < NBUF; i++) { 622 bp = &lbuf[i]; 623 bp->blkaddr = buffers + (i * BLKSIZE); 624 bp->valid = 0; 625 insert(bp); 626 } 627 /* 628 * Malloc filenames structure. The space for the actual filenames 629 * is allocated as it needs it. We estimate the size based on the 630 * number of inodes(objects) in the filesystem and the number of 631 * directories. The number of directories are padded by 3 because 632 * each directory traversed during a "find" or "ls -R" needs 3 633 * entries. 634 */ 635 maxfiles = (long)((((u_offset_t)fs->fs_ncg * (u_offset_t)fs->fs_ipg) - 636 (u_offset_t)fs->fs_cstotal.cs_nifree) + 637 ((u_offset_t)fs->fs_cstotal.cs_ndir * (u_offset_t)3)); 638 639 filenames = (struct filenames *)calloc(maxfiles, 640 sizeof (struct filenames)); 641 if (filenames == NULL) { 642 /* 643 * If we could not allocate memory for all of files 644 * in the filesystem then, back off to the old fixed 645 * value. 646 */ 647 maxfiles = MAXFILES; 648 filenames = (struct filenames *)calloc(maxfiles, 649 sizeof (struct filenames)); 650 if (filenames == NULL) { 651 printf("out of memory\n"); 652 exit(1); 653 } 654 } 655 656 restore_inode(2); 657 /* 658 * Malloc a few filenames (needed by pwd for example). 659 */ 660 for (i = 0; i < MAXPATHLEN; i++) { 661 input_path[i] = calloc(1, MAXNAMLEN); 662 stack_path[i] = calloc(1, MAXNAMLEN); 663 current_path[i] = calloc(1, MAXNAMLEN); 664 if (current_path[i] == NULL) { 665 printf("out of memory\n"); 666 exit(1); 667 } 668 } 669 current_pathp = -1; 670 671 (void) signal(2, err); 672 (void) setjmp(env); 673 674 getnextinput(); 675 /* 676 * Main loop and case statement. If an error condition occurs 677 * initialization and recovery is attempted. 678 */ 679 for (;;) { 680 if (error) { 681 freemem(filenames, nfiles); 682 nfiles = 0; 683 c_count = 0; 684 count = 1; 685 star = 0; 686 error = 0; 687 paren = 0; 688 acting_on_inode = 0; 689 acting_on_directory = 0; 690 should_print = 1; 691 addr = erraddr; 692 cur_ino = errino; 693 cur_inum = errinum; 694 cur_bytes = errcur_bytes; 695 printf("?\n"); 696 getnextinput(); 697 if (error) 698 continue; 699 } 700 c_count++; 701 702 switch (c = getachar()) { 703 704 case '\n': /* command end */ 705 freemem(filenames, nfiles); 706 nfiles = 0; 707 if (should_print && laststyle == '=') { 708 ungetachar(c); 709 goto calc; 710 } 711 if (c_count == 1) { 712 clear = 0; 713 should_print = 1; 714 erraddr = addr; 715 errino = cur_ino; 716 errinum = cur_inum; 717 errcur_bytes = cur_bytes; 718 switch (objsz) { 719 case DIRECTORY: 720 if ((addr = getdirslot( 721 (long)dirslot+1)) == 0) 722 should_print = 0; 723 if (error) { 724 ungetachar(c); 725 continue; 726 } 727 break; 728 case INODE: 729 cur_inum++; 730 addr = itob(cur_inum); 731 if (!icheck(addr)) { 732 cur_inum--; 733 should_print = 0; 734 } 735 break; 736 case CGRP: 737 case SB: 738 cur_cgrp++; 739 addr = cgrp_check(cur_cgrp); 740 if (addr == 0) { 741 cur_cgrp--; 742 continue; 743 } 744 break; 745 case SHADOW_DATA: 746 if ((addr = getshadowslot( 747 (long)cur_shad + 1)) == 0) 748 should_print = 0; 749 if (error) { 750 ungetachar(c); 751 continue; 752 } 753 break; 754 default: 755 addr += objsz; 756 cur_bytes += objsz; 757 if (valid_addr() == 0) 758 continue; 759 } 760 } 761 if (type == NUMB) 762 trapped = 0; 763 if (should_print) 764 switch (objsz) { 765 case DIRECTORY: 766 fprnt('?', 'd'); 767 break; 768 case INODE: 769 fprnt('?', 'i'); 770 if (!error) 771 cur_ino = addr; 772 break; 773 case CGRP: 774 fprnt('?', 'c'); 775 break; 776 case SB: 777 fprnt('?', 's'); 778 break; 779 case SHADOW_DATA: 780 fprnt('?', 'S'); 781 break; 782 case CHAR: 783 case SHORT: 784 case LONG: 785 fprnt(laststyle, lastpo); 786 } 787 if (error) { 788 ungetachar(c); 789 continue; 790 } 791 c_count = colon = acting_on_inode = 0; 792 acting_on_directory = 0; 793 should_print = 1; 794 getnextinput(); 795 if (error) 796 continue; 797 erraddr = addr; 798 errino = cur_ino; 799 errinum = cur_inum; 800 errcur_bytes = cur_bytes; 801 continue; 802 803 case '(': /* numeric expression or unknown command */ 804 default: 805 colon = 0; 806 if (digit(c) || c == '(') { 807 ungetachar(c); 808 addr = expr(); 809 type = NUMB; 810 value = addr; 811 continue; 812 } 813 printf("unknown command or bad syntax\n"); 814 error++; 815 continue; 816 817 case '?': /* general print facilities */ 818 case '/': 819 fprnt(c, getachar()); 820 continue; 821 822 case ';': /* command separator and . */ 823 case '\t': 824 case ' ': 825 case '.': 826 continue; 827 828 case ':': /* command indicator */ 829 colon++; 830 commands++; 831 should_print = 0; 832 stringsize = 0; 833 trapped = 0; 834 continue; 835 836 case ',': /* count indicator */ 837 colon = star = 0; 838 if ((c = getachar()) == '*') { 839 star = 1; 840 count = BLKSIZE; 841 } else { 842 ungetachar(c); 843 count = expr(); 844 if (error) 845 continue; 846 if (!count) 847 count = 1; 848 } 849 clear = 0; 850 continue; 851 852 case '+': /* address addition */ 853 colon = 0; 854 c = getachar(); 855 ungetachar(c); 856 if (c == '\n') 857 temp = 1; 858 else { 859 temp = expr(); 860 if (error) 861 continue; 862 } 863 erraddr = addr; 864 errcur_bytes = cur_bytes; 865 switch (objsz) { 866 case DIRECTORY: 867 addr = getdirslot((long)(dirslot + temp)); 868 if (error) 869 continue; 870 break; 871 case INODE: 872 cur_inum += temp; 873 addr = itob(cur_inum); 874 if (!icheck(addr)) { 875 cur_inum -= temp; 876 continue; 877 } 878 break; 879 case CGRP: 880 case SB: 881 cur_cgrp += temp; 882 if ((addr = cgrp_check(cur_cgrp)) == 0) { 883 cur_cgrp -= temp; 884 continue; 885 } 886 break; 887 case SHADOW_DATA: 888 addr = getshadowslot((long)(cur_shad + temp)); 889 if (error) 890 continue; 891 break; 892 893 default: 894 laststyle = '/'; 895 addr += temp * objsz; 896 cur_bytes += temp * objsz; 897 if (valid_addr() == 0) 898 continue; 899 } 900 value = get(objsz); 901 continue; 902 903 case '-': /* address subtraction */ 904 colon = 0; 905 c = getachar(); 906 ungetachar(c); 907 if (c == '\n') 908 temp = 1; 909 else { 910 temp = expr(); 911 if (error) 912 continue; 913 } 914 erraddr = addr; 915 errcur_bytes = cur_bytes; 916 switch (objsz) { 917 case DIRECTORY: 918 addr = getdirslot((long)(dirslot - temp)); 919 if (error) 920 continue; 921 break; 922 case INODE: 923 cur_inum -= temp; 924 addr = itob(cur_inum); 925 if (!icheck(addr)) { 926 cur_inum += temp; 927 continue; 928 } 929 break; 930 case CGRP: 931 case SB: 932 cur_cgrp -= temp; 933 if ((addr = cgrp_check(cur_cgrp)) == 0) { 934 cur_cgrp += temp; 935 continue; 936 } 937 break; 938 case SHADOW_DATA: 939 addr = getshadowslot((long)(cur_shad - temp)); 940 if (error) 941 continue; 942 break; 943 default: 944 laststyle = '/'; 945 addr -= temp * objsz; 946 cur_bytes -= temp * objsz; 947 if (valid_addr() == 0) 948 continue; 949 } 950 value = get(objsz); 951 continue; 952 953 case '*': /* address multiplication */ 954 colon = 0; 955 temp = expr(); 956 if (error) 957 continue; 958 if (objsz != INODE && objsz != DIRECTORY) 959 laststyle = '/'; 960 addr *= temp; 961 value = get(objsz); 962 continue; 963 964 case '%': /* address division */ 965 colon = 0; 966 temp = expr(); 967 if (error) 968 continue; 969 if (!temp) { 970 printf("divide by zero\n"); 971 error++; 972 continue; 973 } 974 if (objsz != INODE && objsz != DIRECTORY) 975 laststyle = '/'; 976 addr /= temp; 977 value = get(objsz); 978 continue; 979 980 case '=': { /* assignment operation */ 981 short tbase; 982 calc: 983 tbase = base; 984 985 c = getachar(); 986 if (c == '\n') { 987 ungetachar(c); 988 c = lastpo; 989 if (acting_on_inode == 1) { 990 if (c != 'o' && c != 'd' && c != 'x' && 991 c != 'O' && c != 'D' && c != 'X') { 992 switch (objsz) { 993 case LONG: 994 c = lastpo = 'X'; 995 break; 996 case SHORT: 997 c = lastpo = 'x'; 998 break; 999 case CHAR: 1000 c = lastpo = 'c'; 1001 } 1002 } 1003 } else { 1004 if (acting_on_inode == 2) 1005 c = lastpo = 't'; 1006 } 1007 } else if (acting_on_inode) 1008 lastpo = c; 1009 should_print = star = 0; 1010 count = 1; 1011 erraddr = addr; 1012 errcur_bytes = cur_bytes; 1013 switch (c) { 1014 case '"': /* character string */ 1015 if (type == NUMB) { 1016 blocksize = BLKSIZE; 1017 filesize = BLKSIZE * 2; 1018 cur_bytes = blkoff(fs, addr); 1019 if (objsz == DIRECTORY || 1020 objsz == INODE) 1021 lastpo = 'X'; 1022 } 1023 puta(); 1024 continue; 1025 case '+': /* =+ operator */ 1026 temp = expr(); 1027 value = get(objsz); 1028 if (!error) 1029 put(value+temp, objsz); 1030 continue; 1031 case '-': /* =- operator */ 1032 temp = expr(); 1033 value = get(objsz); 1034 if (!error) 1035 put(value-temp, objsz); 1036 continue; 1037 case 'b': 1038 case 'c': 1039 if (objsz == CGRP) 1040 fprnt('?', c); 1041 else 1042 fprnt('/', c); 1043 continue; 1044 case 'i': 1045 addr = cur_ino; 1046 fprnt('?', 'i'); 1047 continue; 1048 case 's': 1049 fprnt('?', 's'); 1050 continue; 1051 case 't': 1052 case 'T': 1053 laststyle = '='; 1054 printf("\t\t"); 1055 { 1056 /* 1057 * Truncation is intentional so 1058 * ctime is happy. 1059 */ 1060 time_t tvalue = (time_t)value; 1061 printf("%s", ctime(&tvalue)); 1062 } 1063 continue; 1064 case 'o': 1065 base = OCTAL; 1066 goto otx; 1067 case 'd': 1068 if (objsz == DIRECTORY) { 1069 addr = cur_dir; 1070 fprnt('?', 'd'); 1071 continue; 1072 } 1073 base = DECIMAL; 1074 goto otx; 1075 case 'x': 1076 base = HEX; 1077 otx: 1078 laststyle = '='; 1079 printf("\t\t"); 1080 if (acting_on_inode) 1081 print(value & 0177777L, 12, -8, 0); 1082 else 1083 print(addr & 0177777L, 12, -8, 0); 1084 printf("\n"); 1085 base = tbase; 1086 continue; 1087 case 'O': 1088 base = OCTAL; 1089 goto OTX; 1090 case 'D': 1091 base = DECIMAL; 1092 goto OTX; 1093 case 'X': 1094 base = HEX; 1095 OTX: 1096 laststyle = '='; 1097 printf("\t\t"); 1098 if (acting_on_inode) 1099 print(value, 12, -8, 0); 1100 else 1101 print(addr, 12, -8, 0); 1102 printf("\n"); 1103 base = tbase; 1104 continue; 1105 default: /* regular assignment */ 1106 ungetachar(c); 1107 value = expr(); 1108 if (error) 1109 printf("syntax error\n"); 1110 else 1111 put(value, objsz); 1112 continue; 1113 } 1114 } 1115 1116 case '>': /* save current address */ 1117 colon = 0; 1118 should_print = 0; 1119 c = getachar(); 1120 if (!letter(c) && !digit(c)) { 1121 printf("invalid register specification, "); 1122 printf("must be letter or digit\n"); 1123 error++; 1124 continue; 1125 } 1126 if (letter(c)) { 1127 if (c < 'a') 1128 c = uppertolower(c); 1129 c = hextodigit(c); 1130 } else 1131 c = numtodigit(c); 1132 regs[c].sv_addr = addr; 1133 regs[c].sv_value = value; 1134 regs[c].sv_objsz = objsz; 1135 continue; 1136 1137 case '<': /* restore saved address */ 1138 colon = 0; 1139 should_print = 0; 1140 c = getachar(); 1141 if (!letter(c) && !digit(c)) { 1142 printf("invalid register specification, "); 1143 printf("must be letter or digit\n"); 1144 error++; 1145 continue; 1146 } 1147 if (letter(c)) { 1148 if (c < 'a') 1149 c = uppertolower(c); 1150 c = hextodigit(c); 1151 } else 1152 c = numtodigit(c); 1153 addr = regs[c].sv_addr; 1154 value = regs[c].sv_value; 1155 objsz = regs[c].sv_objsz; 1156 continue; 1157 1158 case 'a': 1159 if (colon) 1160 colon = 0; 1161 else 1162 goto no_colon; 1163 if (match("at", 2)) { /* access time */ 1164 acting_on_inode = 2; 1165 should_print = 1; 1166 addr = (long)&((struct dinode *) 1167 (uintptr_t)cur_ino)->di_atime; 1168 value = get(LONG); 1169 type = NULL; 1170 continue; 1171 } 1172 goto bad_syntax; 1173 1174 case 'b': 1175 if (colon) 1176 colon = 0; 1177 else 1178 goto no_colon; 1179 if (match("block", 2)) { /* block conversion */ 1180 if (type == NUMB) { 1181 value = addr; 1182 cur_bytes = 0; 1183 blocksize = BLKSIZE; 1184 filesize = BLKSIZE * 2; 1185 } 1186 addr = value << FRGSHIFT; 1187 bod_addr = addr; 1188 value = get(LONG); 1189 type = BLOCK; 1190 dirslot = 0; 1191 trapped++; 1192 continue; 1193 } 1194 if (match("bs", 2)) { /* block size */ 1195 acting_on_inode = 1; 1196 should_print = 1; 1197 if (icheck(cur_ino) == 0) 1198 continue; 1199 addr = (long)&((struct dinode *) 1200 (uintptr_t)cur_ino)->di_blocks; 1201 value = get(LONG); 1202 type = NULL; 1203 continue; 1204 } 1205 if (match("base", 2)) { /* change/show base */ 1206 showbase: 1207 if ((c = getachar()) == '\n') { 1208 ungetachar(c); 1209 printf("base =\t\t"); 1210 switch (base) { 1211 case OCTAL: 1212 printf("OCTAL\n"); 1213 continue; 1214 case DECIMAL: 1215 printf("DECIMAL\n"); 1216 continue; 1217 case HEX: 1218 printf("HEX\n"); 1219 continue; 1220 } 1221 } 1222 if (c != '=') { 1223 printf("missing '='\n"); 1224 error++; 1225 continue; 1226 } 1227 value = expr(); 1228 switch (value) { 1229 default: 1230 printf("invalid base\n"); 1231 error++; 1232 break; 1233 case OCTAL: 1234 case DECIMAL: 1235 case HEX: 1236 base = (short)value; 1237 } 1238 goto showbase; 1239 } 1240 goto bad_syntax; 1241 1242 case 'c': 1243 if (colon) 1244 colon = 0; 1245 else 1246 goto no_colon; 1247 if (match("cd", 2)) { /* change directory */ 1248 top = filenames - 1; 1249 eat_spaces(); 1250 if ((c = getachar()) == '\n') { 1251 ungetachar(c); 1252 current_pathp = -1; 1253 restore_inode(2); 1254 continue; 1255 } 1256 ungetachar(c); 1257 temp = cur_inum; 1258 doing_cd = 1; 1259 parse(); 1260 doing_cd = 0; 1261 if (nfiles != 1) { 1262 restore_inode((ino_t)temp); 1263 if (!error) { 1264 print_path(input_path, 1265 (int)input_pathp); 1266 if (nfiles == 0) 1267 printf(" not found\n"); 1268 else 1269 printf(" ambiguous\n"); 1270 error++; 1271 } 1272 continue; 1273 } 1274 restore_inode(filenames->ino); 1275 if ((mode = icheck(addr)) == 0) 1276 continue; 1277 if ((mode & IFMT) != IFDIR) { 1278 restore_inode((ino_t)temp); 1279 print_path(input_path, 1280 (int)input_pathp); 1281 printf(" not a directory\n"); 1282 error++; 1283 continue; 1284 } 1285 for (i = 0; i <= top->len; i++) 1286 (void) strcpy(current_path[i], 1287 top->fname[i]); 1288 current_pathp = top->len; 1289 continue; 1290 } 1291 if (match("cg", 2)) { /* cylinder group */ 1292 if (type == NUMB) 1293 value = addr; 1294 if (value > fs->fs_ncg - 1) { 1295 printf("maximum cylinder group is "); 1296 print(fs->fs_ncg - 1, 8, -8, 0); 1297 printf("\n"); 1298 error++; 1299 continue; 1300 } 1301 type = objsz = CGRP; 1302 cur_cgrp = (long)value; 1303 addr = cgtod(fs, cur_cgrp) << FRGSHIFT; 1304 continue; 1305 } 1306 if (match("ct", 2)) { /* creation time */ 1307 acting_on_inode = 2; 1308 should_print = 1; 1309 addr = (long)&((struct dinode *) 1310 (uintptr_t)cur_ino)->di_ctime; 1311 value = get(LONG); 1312 type = NULL; 1313 continue; 1314 } 1315 goto bad_syntax; 1316 1317 case 'd': 1318 if (colon) 1319 colon = 0; 1320 else 1321 goto no_colon; 1322 if (match("directory", 2)) { /* directory offsets */ 1323 if (type == NUMB) 1324 value = addr; 1325 objsz = DIRECTORY; 1326 type = DIRECTORY; 1327 addr = (u_offset_t)getdirslot((long)value); 1328 continue; 1329 } 1330 if (match("db", 2)) { /* direct block */ 1331 acting_on_inode = 1; 1332 should_print = 1; 1333 if (type == NUMB) 1334 value = addr; 1335 if (value >= NDADDR) { 1336 printf("direct blocks are 0 to "); 1337 print(NDADDR - 1, 0, 0, 0); 1338 printf("\n"); 1339 error++; 1340 continue; 1341 } 1342 addr = cur_ino; 1343 if (!icheck(addr)) 1344 continue; 1345 addr = (long) 1346 &((struct dinode *)(uintptr_t)cur_ino)-> 1347 di_db[value]; 1348 bod_addr = addr; 1349 cur_bytes = (value) * BLKSIZE; 1350 cur_block = (long)value; 1351 type = BLOCK; 1352 dirslot = 0; 1353 value = get(LONG); 1354 if (!value && !override) { 1355 printf("non existent block\n"); 1356 error++; 1357 } 1358 continue; 1359 } 1360 goto bad_syntax; 1361 1362 case 'f': 1363 if (colon) 1364 colon = 0; 1365 else 1366 goto no_colon; 1367 if (match("find", 3)) { /* find command */ 1368 find(); 1369 continue; 1370 } 1371 if (match("fragment", 2)) { /* fragment conv. */ 1372 if (type == NUMB) { 1373 value = addr; 1374 cur_bytes = 0; 1375 blocksize = FRGSIZE; 1376 filesize = FRGSIZE * 2; 1377 } 1378 if (min(blocksize, filesize) - cur_bytes > 1379 FRGSIZE) { 1380 blocksize = cur_bytes + FRGSIZE; 1381 filesize = blocksize * 2; 1382 } 1383 addr = value << FRGSHIFT; 1384 bod_addr = addr; 1385 value = get(LONG); 1386 type = FRAGMENT; 1387 dirslot = 0; 1388 trapped++; 1389 continue; 1390 } 1391 if (match("file", 4)) { /* access as file */ 1392 acting_on_inode = 1; 1393 should_print = 1; 1394 if (type == NUMB) 1395 value = addr; 1396 addr = cur_ino; 1397 if ((mode = icheck(addr)) == 0) 1398 continue; 1399 if (!override) { 1400 switch (mode & IFMT) { 1401 case IFCHR: 1402 case IFBLK: 1403 printf("special device\n"); 1404 error++; 1405 continue; 1406 } 1407 } 1408 if ((addr = (u_offset_t) 1409 (bmap((long)value) << FRGSHIFT)) == 0) 1410 continue; 1411 cur_block = (long)value; 1412 bod_addr = addr; 1413 type = BLOCK; 1414 dirslot = 0; 1415 continue; 1416 } 1417 if (match("fill", 4)) { /* fill */ 1418 if (getachar() != '=') { 1419 printf("missing '='\n"); 1420 error++; 1421 continue; 1422 } 1423 if (objsz == INODE || objsz == DIRECTORY || 1424 objsz == SHADOW_DATA) { 1425 printf( 1426 "can't fill inode or directory\n"); 1427 error++; 1428 continue; 1429 } 1430 fill(); 1431 continue; 1432 } 1433 goto bad_syntax; 1434 1435 case 'g': 1436 if (colon) 1437 colon = 0; 1438 else 1439 goto no_colon; 1440 if (match("gid", 1)) { /* group id */ 1441 acting_on_inode = 1; 1442 should_print = 1; 1443 addr = (long)&((struct dinode *) 1444 (uintptr_t)cur_ino)->di_gid; 1445 value = get(SHORT); 1446 type = NULL; 1447 continue; 1448 } 1449 goto bad_syntax; 1450 1451 case 'i': 1452 if (colon) 1453 colon = 0; 1454 else 1455 goto no_colon; 1456 if (match("inode", 2)) { /* i# to inode conversion */ 1457 if (c_count == 2) { 1458 addr = cur_ino; 1459 value = get(INODE); 1460 type = NULL; 1461 laststyle = '='; 1462 lastpo = 'i'; 1463 should_print = 1; 1464 continue; 1465 } 1466 if (type == NUMB) 1467 value = addr; 1468 addr = itob(value); 1469 if (!icheck(addr)) 1470 continue; 1471 cur_ino = addr; 1472 cur_inum = (long)value; 1473 value = get(INODE); 1474 type = NULL; 1475 continue; 1476 } 1477 if (match("ib", 2)) { /* indirect block */ 1478 acting_on_inode = 1; 1479 should_print = 1; 1480 if (type == NUMB) 1481 value = addr; 1482 if (value >= NIADDR) { 1483 printf("indirect blocks are 0 to "); 1484 print(NIADDR - 1, 0, 0, 0); 1485 printf("\n"); 1486 error++; 1487 continue; 1488 } 1489 addr = (long)&((struct dinode *)(uintptr_t) 1490 cur_ino)->di_ib[value]; 1491 cur_bytes = (NDADDR - 1) * BLKSIZE; 1492 temp = 1; 1493 for (i = 0; i < value; i++) { 1494 temp *= NINDIR(fs) * BLKSIZE; 1495 cur_bytes += temp; 1496 } 1497 type = BLOCK; 1498 dirslot = 0; 1499 value = get(LONG); 1500 if (!value && !override) { 1501 printf("non existent block\n"); 1502 error++; 1503 } 1504 continue; 1505 } 1506 goto bad_syntax; 1507 1508 case 'l': 1509 if (colon) 1510 colon = 0; 1511 else 1512 goto no_colon; 1513 if (match("log_head", 8)) { 1514 log_display_header(); 1515 should_print = 0; 1516 continue; 1517 } 1518 if (match("log_delta", 9)) { 1519 log_show(LOG_NDELTAS); 1520 should_print = 0; 1521 continue; 1522 } 1523 if (match("log_show", 8)) { 1524 log_show(LOG_ALLDELTAS); 1525 should_print = 0; 1526 continue; 1527 } 1528 if (match("log_chk", 7)) { 1529 log_show(LOG_CHECKSCAN); 1530 should_print = 0; 1531 continue; 1532 } 1533 if (match("log_otodb", 9)) { 1534 if (log_lodb((u_offset_t)addr, &temp)) { 1535 addr = temp; 1536 should_print = 1; 1537 laststyle = '='; 1538 } else 1539 error++; 1540 continue; 1541 } 1542 if (match("ls", 2)) { /* ls command */ 1543 temp = cur_inum; 1544 recursive = long_list = 0; 1545 top = filenames - 1; 1546 for (;;) { 1547 eat_spaces(); 1548 if ((c = getachar()) == '-') { 1549 if ((c = getachar()) == 'R') { 1550 recursive = 1; 1551 continue; 1552 } else if (c == 'l') { 1553 long_list = 1; 1554 } else { 1555 printf( 1556 "unknown option "); 1557 printf("'%c'\n", c); 1558 error++; 1559 break; 1560 } 1561 } else 1562 ungetachar(c); 1563 if ((c = getachar()) == '\n') { 1564 if (c_count != 2) { 1565 ungetachar(c); 1566 break; 1567 } 1568 } 1569 c_count++; 1570 ungetachar(c); 1571 parse(); 1572 restore_inode((ino_t)temp); 1573 if (error) 1574 break; 1575 } 1576 recursive = 0; 1577 if (error || nfiles == 0) { 1578 if (!error) { 1579 print_path(input_path, 1580 (int)input_pathp); 1581 printf(" not found\n"); 1582 } 1583 continue; 1584 } 1585 if (nfiles) { 1586 cmp_level = 0; 1587 qsort((char *)filenames, nfiles, 1588 sizeof (struct filenames), ffcmp); 1589 ls(filenames, filenames + (nfiles - 1), 0); 1590 } else { 1591 printf("no match\n"); 1592 error++; 1593 } 1594 restore_inode((ino_t)temp); 1595 continue; 1596 } 1597 if (match("ln", 2)) { /* link count */ 1598 acting_on_inode = 1; 1599 should_print = 1; 1600 addr = (long)&((struct dinode *) 1601 (uintptr_t)cur_ino)->di_nlink; 1602 value = get(SHORT); 1603 type = NULL; 1604 continue; 1605 } 1606 goto bad_syntax; 1607 1608 case 'm': 1609 if (colon) 1610 colon = 0; 1611 else 1612 goto no_colon; 1613 addr = cur_ino; 1614 if ((mode = icheck(addr)) == 0) 1615 continue; 1616 if (match("mt", 2)) { /* modification time */ 1617 acting_on_inode = 2; 1618 should_print = 1; 1619 addr = (long)&((struct dinode *) 1620 (uintptr_t)cur_ino)->di_mtime; 1621 value = get(LONG); 1622 type = NULL; 1623 continue; 1624 } 1625 if (match("md", 2)) { /* mode */ 1626 acting_on_inode = 1; 1627 should_print = 1; 1628 addr = (long)&((struct dinode *) 1629 (uintptr_t)cur_ino)->di_mode; 1630 value = get(SHORT); 1631 type = NULL; 1632 continue; 1633 } 1634 if (match("maj", 2)) { /* major device number */ 1635 acting_on_inode = 1; 1636 should_print = 1; 1637 if (devcheck(mode)) 1638 continue; 1639 addr = (uintptr_t)&((struct dinode *)(uintptr_t) 1640 cur_ino)->di_ordev; 1641 { 1642 long dvalue; 1643 dvalue = get(LONG); 1644 value = major(dvalue); 1645 } 1646 type = NULL; 1647 continue; 1648 } 1649 if (match("min", 2)) { /* minor device number */ 1650 acting_on_inode = 1; 1651 should_print = 1; 1652 if (devcheck(mode)) 1653 continue; 1654 addr = (uintptr_t)&((struct dinode *)(uintptr_t) 1655 cur_ino)->di_ordev; 1656 { 1657 long dvalue; 1658 dvalue = (long)get(LONG); 1659 value = minor(dvalue); 1660 } 1661 type = NULL; 1662 continue; 1663 } 1664 goto bad_syntax; 1665 1666 case 'n': 1667 if (colon) 1668 colon = 0; 1669 else 1670 goto no_colon; 1671 if (match("nm", 1)) { /* directory name */ 1672 objsz = DIRECTORY; 1673 acting_on_directory = 1; 1674 cur_dir = addr; 1675 if ((cptr = getblk(addr)) == 0) 1676 continue; 1677 /*LINTED*/ 1678 dirp = (struct direct *)(cptr+blkoff(fs, addr)); 1679 stringsize = (long)dirp->d_reclen - 1680 ((long)&dirp->d_name[0] - 1681 (long)&dirp->d_ino); 1682 addr = (long)&((struct direct *) 1683 (uintptr_t)addr)->d_name[0]; 1684 type = NULL; 1685 continue; 1686 } 1687 goto bad_syntax; 1688 1689 case 'o': 1690 if (colon) 1691 colon = 0; 1692 else 1693 goto no_colon; 1694 if (match("override", 1)) { /* override flip flop */ 1695 override = !override; 1696 if (override) 1697 printf("error checking off\n"); 1698 else 1699 printf("error checking on\n"); 1700 continue; 1701 } 1702 goto bad_syntax; 1703 1704 case 'p': 1705 if (colon) 1706 colon = 0; 1707 else 1708 goto no_colon; 1709 if (match("pwd", 2)) { /* print working dir */ 1710 print_path(current_path, (int)current_pathp); 1711 printf("\n"); 1712 continue; 1713 } 1714 if (match("prompt", 2)) { /* change prompt */ 1715 if ((c = getachar()) != '=') { 1716 printf("missing '='\n"); 1717 error++; 1718 continue; 1719 } 1720 if ((c = getachar()) != '"') { 1721 printf("missing '\"'\n"); 1722 error++; 1723 continue; 1724 } 1725 i = 0; 1726 prompt = &prompt[0]; 1727 while ((c = getachar()) != '"' && c != '\n') { 1728 prompt[i++] = c; 1729 if (i >= PROMPTSIZE) { 1730 printf("string too long\n"); 1731 error++; 1732 break; 1733 } 1734 } 1735 prompt[i] = '\0'; 1736 continue; 1737 } 1738 goto bad_syntax; 1739 1740 case 'q': 1741 if (!colon) 1742 goto no_colon; 1743 if (match("quit", 1)) { /* quit */ 1744 if ((c = getachar()) != '\n') { 1745 error++; 1746 continue; 1747 } 1748 exit(0); 1749 } 1750 goto bad_syntax; 1751 1752 case 's': 1753 if (colon) 1754 colon = 0; 1755 else 1756 goto no_colon; 1757 if (match("sb", 2)) { /* super block */ 1758 if (c_count == 2) { 1759 cur_cgrp = -1; 1760 type = objsz = SB; 1761 laststyle = '='; 1762 lastpo = 's'; 1763 should_print = 1; 1764 continue; 1765 } 1766 if (type == NUMB) 1767 value = addr; 1768 if (value > fs->fs_ncg - 1) { 1769 printf("maximum super block is "); 1770 print(fs->fs_ncg - 1, 8, -8, 0); 1771 printf("\n"); 1772 error++; 1773 continue; 1774 } 1775 type = objsz = SB; 1776 cur_cgrp = (long)value; 1777 addr = cgsblock(fs, cur_cgrp) << FRGSHIFT; 1778 continue; 1779 } 1780 if (match("shadow", 2)) { /* shadow inode data */ 1781 if (type == NUMB) 1782 value = addr; 1783 objsz = SHADOW_DATA; 1784 type = SHADOW_DATA; 1785 addr = getshadowslot(value); 1786 continue; 1787 } 1788 if (match("si", 2)) { /* shadow inode field */ 1789 acting_on_inode = 1; 1790 should_print = 1; 1791 addr = (long)&((struct dinode *) 1792 (uintptr_t)cur_ino)->di_shadow; 1793 value = get(LONG); 1794 type = NULL; 1795 continue; 1796 } 1797 1798 if (match("sz", 2)) { /* file size */ 1799 acting_on_inode = 1; 1800 should_print = 1; 1801 addr = (long)&((struct dinode *) 1802 (uintptr_t)cur_ino)->di_size; 1803 value = get(U_OFFSET_T); 1804 type = NULL; 1805 objsz = U_OFFSET_T; 1806 laststyle = '='; 1807 lastpo = 'X'; 1808 continue; 1809 } 1810 goto bad_syntax; 1811 1812 case 'u': 1813 if (colon) 1814 colon = 0; 1815 else 1816 goto no_colon; 1817 if (match("uid", 1)) { /* user id */ 1818 acting_on_inode = 1; 1819 should_print = 1; 1820 addr = (long)&((struct dinode *) 1821 (uintptr_t)cur_ino)->di_uid; 1822 value = get(SHORT); 1823 type = NULL; 1824 continue; 1825 } 1826 goto bad_syntax; 1827 1828 case 'F': /* buffer status (internal use only) */ 1829 if (colon) 1830 colon = 0; 1831 else 1832 goto no_colon; 1833 for (bp = bhdr.fwd; bp != &bhdr; bp = bp->fwd) 1834 printf("%8" PRIx64 " %d\n", 1835 bp->blkno, bp->valid); 1836 printf("\n"); 1837 printf("# commands\t\t%ld\n", commands); 1838 printf("# read requests\t\t%ld\n", read_requests); 1839 printf("# actual disk reads\t%ld\n", actual_disk_reads); 1840 continue; 1841 no_colon: 1842 printf("a colon should precede a command\n"); 1843 error++; 1844 continue; 1845 bad_syntax: 1846 printf("more letters needed to distinguish command\n"); 1847 error++; 1848 continue; 1849 } 1850 } 1851 } 1852 1853 /* 1854 * usage - print usage and exit 1855 */ 1856 static void 1857 usage(char *progname) 1858 { 1859 printf("usage: %s [options] special\n", progname); 1860 printf("options:\n"); 1861 printf("\t-o Specify ufs filesystem sepcific options\n"); 1862 printf(" Available suboptions are:\n"); 1863 printf("\t\t? display usage\n"); 1864 printf("\t\to override some error conditions\n"); 1865 printf("\t\tp=\"string\" set prompt to string\n"); 1866 printf("\t\tw open for write\n"); 1867 exit(1); 1868 } 1869 1870 /* 1871 * getachar - get next character from input buffer. 1872 */ 1873 static char 1874 getachar() 1875 { 1876 return (input_buffer[input_pointer++]); 1877 } 1878 1879 /* 1880 * ungetachar - return character to input buffer. 1881 */ 1882 static void 1883 ungetachar(char c) 1884 { 1885 if (input_pointer == 0) { 1886 printf("internal problem maintaining input buffer\n"); 1887 error++; 1888 return; 1889 } 1890 input_buffer[--input_pointer] = c; 1891 } 1892 1893 /* 1894 * getnextinput - display the prompt and read an input line. 1895 * An input line is up to 128 characters terminated by the newline 1896 * character. Handle overflow, shell escape, and eof. 1897 */ 1898 static void 1899 getnextinput() 1900 { 1901 int i; 1902 char c; 1903 short pid, rpid; 1904 int retcode; 1905 1906 newline: 1907 i = 0; 1908 printf("%s", prompt); 1909 ignore_eol: 1910 while ((c = getc(stdin)) != '\n' && !(c == '!' && i == 0) && 1911 !feof(stdin) && i <= INPUTBUFFER - 2) 1912 input_buffer[i++] = c; 1913 if (i > 0 && input_buffer[i - 1] == '\\') { 1914 input_buffer[i++] = c; 1915 goto ignore_eol; 1916 } 1917 if (feof(stdin)) { 1918 printf("\n"); 1919 exit(0); 1920 } 1921 if (c == '!') { 1922 if ((pid = fork()) == 0) { 1923 (void) execl(_PATH_BSHELL, "sh", "-t", 0); 1924 error++; 1925 return; 1926 } 1927 while ((rpid = wait(&retcode)) != pid && rpid != -1) 1928 ; 1929 printf("!\n"); 1930 goto newline; 1931 } 1932 if (c != '\n') 1933 printf("input truncated to 128 characters\n"); 1934 input_buffer[i] = '\n'; 1935 input_pointer = 0; 1936 } 1937 1938 /* 1939 * eat_spaces - read extraneous spaces. 1940 */ 1941 static void 1942 eat_spaces() 1943 { 1944 char c; 1945 1946 while ((c = getachar()) == ' ') 1947 ; 1948 ungetachar(c); 1949 } 1950 1951 /* 1952 * restore_inode - set up all inode indicators so inum is now 1953 * the current inode. 1954 */ 1955 static void 1956 restore_inode(ino_t inum) 1957 { 1958 errinum = cur_inum = inum; 1959 addr = errino = cur_ino = itob(inum); 1960 } 1961 1962 /* 1963 * match - return false if the input does not match string up to 1964 * upto letters. Then proceed to chew up extraneous letters. 1965 */ 1966 static int 1967 match(char *string, int upto) 1968 { 1969 int i, length = strlen(string) - 1; 1970 char c; 1971 int save_upto = upto; 1972 1973 while (--upto) { 1974 string++; 1975 if ((c = getachar()) != *string) { 1976 for (i = save_upto - upto; i; i--) { 1977 ungetachar(c); 1978 c = *--string; 1979 } 1980 return (0); 1981 } 1982 length--; 1983 } 1984 while (length--) { 1985 string++; 1986 if ((c = getachar()) != *string) { 1987 ungetachar(c); 1988 return (1); 1989 } 1990 } 1991 return (1); 1992 } 1993 1994 /* 1995 * expr - expression evaluator. Will evaluate expressions from 1996 * left to right with no operator precedence. Parentheses may 1997 * be used. 1998 */ 1999 static long 2000 expr() 2001 { 2002 long numb = 0, temp; 2003 char c; 2004 2005 numb = term(); 2006 for (;;) { 2007 if (error) 2008 return (~0); /* error is set so value is ignored */ 2009 c = getachar(); 2010 switch (c) { 2011 2012 case '+': 2013 numb += term(); 2014 continue; 2015 2016 case '-': 2017 numb -= term(); 2018 continue; 2019 2020 case '*': 2021 numb *= term(); 2022 continue; 2023 2024 case '%': 2025 temp = term(); 2026 if (!temp) { 2027 printf("divide by zero\n"); 2028 error++; 2029 return (~0); 2030 } 2031 numb /= temp; 2032 continue; 2033 2034 case ')': 2035 paren--; 2036 return (numb); 2037 2038 default: 2039 ungetachar(c); 2040 if (paren && !error) { 2041 printf("missing ')'\n"); 2042 error++; 2043 } 2044 return (numb); 2045 } 2046 } 2047 } 2048 2049 /* 2050 * term - used by expression evaluator to get an operand. 2051 */ 2052 static long 2053 term() 2054 { 2055 char c; 2056 2057 switch (c = getachar()) { 2058 2059 default: 2060 ungetachar(c); 2061 /*FALLTHRU*/ 2062 case '+': 2063 return (getnumb()); 2064 2065 case '-': 2066 return (-getnumb()); 2067 2068 case '(': 2069 paren++; 2070 return (expr()); 2071 } 2072 } 2073 2074 /* 2075 * getnumb - read a number from the input stream. A leading 2076 * zero signifies octal interpretation, a leading '0x' 2077 * signifies hexadecimal, and a leading '0t' signifies 2078 * decimal. If the first character is a character, 2079 * return an error. 2080 */ 2081 static long 2082 getnumb() 2083 { 2084 2085 char c, savec; 2086 long number = 0, tbase, num; 2087 extern short error; 2088 2089 c = getachar(); 2090 if (!digit(c)) { 2091 error++; 2092 ungetachar(c); 2093 return (-1); 2094 } 2095 if (c == '0') { 2096 tbase = OCTAL; 2097 if ((c = getachar()) == 'x') 2098 tbase = HEX; 2099 else if (c == 't') 2100 tbase = DECIMAL; 2101 else ungetachar(c); 2102 } else { 2103 tbase = base; 2104 ungetachar(c); 2105 } 2106 for (;;) { 2107 num = tbase; 2108 c = savec = getachar(); 2109 if (HEXLETTER(c)) 2110 c = uppertolower(c); 2111 switch (tbase) { 2112 case HEX: 2113 if (hexletter(c)) { 2114 num = hextodigit(c); 2115 break; 2116 } 2117 /*FALLTHRU*/ 2118 case DECIMAL: 2119 if (digit(c)) 2120 num = numtodigit(c); 2121 break; 2122 case OCTAL: 2123 if (octaldigit(c)) 2124 num = numtodigit(c); 2125 } 2126 if (num == tbase) 2127 break; 2128 number = number * tbase + num; 2129 } 2130 ungetachar(savec); 2131 return (number); 2132 } 2133 2134 /* 2135 * find - the syntax is almost identical to the unix command. 2136 * find dir [-name pattern] [-inum number] 2137 * Note: only one of -name or -inum may be used at a time. 2138 * Also, the -print is not needed (implied). 2139 */ 2140 static void 2141 find() 2142 { 2143 struct filenames *fn; 2144 char c; 2145 long temp; 2146 short mode; 2147 2148 eat_spaces(); 2149 temp = cur_inum; 2150 top = filenames - 1; 2151 doing_cd = 1; 2152 parse(); 2153 doing_cd = 0; 2154 if (nfiles != 1) { 2155 restore_inode((ino_t)temp); 2156 if (!error) { 2157 print_path(input_path, (int)input_pathp); 2158 if (nfiles == 0) 2159 printf(" not found\n"); 2160 else 2161 printf(" ambiguous\n"); 2162 error++; 2163 return; 2164 } 2165 } 2166 restore_inode(filenames->ino); 2167 freemem(filenames, nfiles); 2168 nfiles = 0; 2169 top = filenames - 1; 2170 if ((mode = icheck(addr)) == 0) 2171 return; 2172 if ((mode & IFMT) != IFDIR) { 2173 print_path(input_path, (int)input_pathp); 2174 printf(" not a directory\n"); 2175 error++; 2176 return; 2177 } 2178 eat_spaces(); 2179 if ((c = getachar()) != '-') { 2180 restore_inode((ino_t)temp); 2181 printf("missing '-'\n"); 2182 error++; 2183 return; 2184 } 2185 find_by_name = find_by_inode = 0; 2186 c = getachar(); 2187 if (match("name", 4)) { 2188 eat_spaces(); 2189 find_by_name = 1; 2190 } else if (match("inum", 4)) { 2191 eat_spaces(); 2192 find_ino = expr(); 2193 if (error) { 2194 restore_inode((ino_t)temp); 2195 return; 2196 } 2197 while ((c = getachar()) != '\n') 2198 ; 2199 ungetachar(c); 2200 find_by_inode = 1; 2201 } else { 2202 restore_inode((ino_t)temp); 2203 printf("use -name or -inum with find\n"); 2204 error++; 2205 return; 2206 } 2207 doing_find = 1; 2208 parse(); 2209 doing_find = 0; 2210 if (error) { 2211 restore_inode((ino_t)temp); 2212 return; 2213 } 2214 for (fn = filenames; fn <= top; fn++) { 2215 if (fn->find == 0) 2216 continue; 2217 printf("i#: "); 2218 print(fn->ino, 12, -8, 0); 2219 print_path(fn->fname, (int)fn->len); 2220 printf("\n"); 2221 } 2222 restore_inode((ino_t)temp); 2223 } 2224 2225 /* 2226 * ls - do an ls. Should behave exactly as ls(1). 2227 * Only -R and -l is supported and -l gives different results. 2228 */ 2229 static void 2230 ls(struct filenames *fn0, struct filenames *fnlast, short level) 2231 { 2232 struct filenames *fn, *fnn; 2233 2234 fn = fn0; 2235 for (;;) { 2236 fn0 = fn; 2237 if (fn0->len) { 2238 cmp_level = level; 2239 qsort((char *)fn0, fnlast - fn0 + 1, 2240 sizeof (struct filenames), fcmp); 2241 } 2242 for (fnn = fn, fn++; fn <= fnlast; fnn = fn, fn++) { 2243 if (fnn->len != fn->len && level == fnn->len - 1) 2244 break; 2245 if (fnn->len == 0) 2246 continue; 2247 if (strcmp(fn->fname[level], fnn->fname[level])) 2248 break; 2249 } 2250 if (fn0->len && level != fn0->len - 1) 2251 ls(fn0, fnn, level + 1); 2252 else { 2253 if (fn0 != filenames) 2254 printf("\n"); 2255 print_path(fn0->fname, (int)(fn0->len - 1)); 2256 printf(":\n"); 2257 if (fn0->len == 0) 2258 cmp_level = level; 2259 else 2260 cmp_level = level + 1; 2261 qsort((char *)fn0, fnn - fn0 + 1, 2262 sizeof (struct filenames), fcmp); 2263 formatf(fn0, fnn); 2264 nfiles -= fnn - fn0 + 1; 2265 } 2266 if (fn > fnlast) 2267 return; 2268 } 2269 } 2270 2271 /* 2272 * formatf - code lifted from ls. 2273 */ 2274 static void 2275 formatf(struct filenames *fn0, struct filenames *fnlast) 2276 { 2277 struct filenames *fn; 2278 int width = 0, w, nentry = fnlast - fn0 + 1; 2279 int i, j, columns, lines; 2280 char *cp; 2281 2282 if (long_list) { 2283 columns = 1; 2284 } else { 2285 for (fn = fn0; fn <= fnlast; fn++) { 2286 int len = strlen(fn->fname[cmp_level]) + 2; 2287 2288 if (len > width) 2289 width = len; 2290 } 2291 width = (width + 8) &~ 7; 2292 columns = 80 / width; 2293 if (columns == 0) 2294 columns = 1; 2295 } 2296 lines = (nentry + columns - 1) / columns; 2297 for (i = 0; i < lines; i++) { 2298 for (j = 0; j < columns; j++) { 2299 fn = fn0 + j * lines + i; 2300 if (long_list) { 2301 printf("i#: "); 2302 print(fn->ino, 12, -8, 0); 2303 } 2304 if ((cp = fmtentry(fn)) == NULL) { 2305 printf("cannot read inode %ld\n", fn->ino); 2306 return; 2307 } 2308 printf("%s", cp); 2309 if (fn + lines > fnlast) { 2310 printf("\n"); 2311 break; 2312 } 2313 w = strlen(cp); 2314 while (w < width) { 2315 w = (w + 8) &~ 7; 2316 (void) putchar('\t'); 2317 } 2318 } 2319 } 2320 } 2321 2322 /* 2323 * fmtentry - code lifted from ls. 2324 */ 2325 static char * 2326 fmtentry(struct filenames *fn) 2327 { 2328 static char fmtres[BUFSIZ]; 2329 struct dinode *ip; 2330 char *cptr, *cp, *dp; 2331 2332 dp = &fmtres[0]; 2333 for (cp = fn->fname[cmp_level]; *cp; cp++) { 2334 if (*cp < ' ' || *cp >= 0177) 2335 *dp++ = '?'; 2336 else 2337 *dp++ = *cp; 2338 } 2339 addr = itob(fn->ino); 2340 if ((cptr = getblk(addr)) == 0) 2341 return (NULL); 2342 cptr += blkoff(fs, addr); 2343 /*LINTED*/ 2344 ip = (struct dinode *)cptr; 2345 switch (ip->di_mode & IFMT) { 2346 case IFDIR: 2347 *dp++ = '/'; 2348 break; 2349 case IFLNK: 2350 *dp++ = '@'; 2351 break; 2352 case IFSOCK: 2353 *dp++ = '='; 2354 break; 2355 #ifdef IFIFO 2356 case IFIFO: 2357 *dp++ = 'p'; 2358 break; 2359 #endif 2360 case IFCHR: 2361 case IFBLK: 2362 case IFREG: 2363 if (ip->di_mode & 0111) 2364 *dp++ = '*'; 2365 else 2366 *dp++ = ' '; 2367 break; 2368 default: 2369 *dp++ = '?'; 2370 2371 } 2372 *dp++ = 0; 2373 return (fmtres); 2374 } 2375 2376 /* 2377 * fcmp - routine used by qsort. Will sort first by name, then 2378 * then by pathname length if names are equal. Uses global 2379 * cmp_level to tell what component of the path name we are comparing. 2380 */ 2381 static int 2382 fcmp(struct filenames *f1, struct filenames *f2) 2383 { 2384 int value; 2385 2386 if ((value = strcmp(f1->fname[cmp_level], f2->fname[cmp_level]))) 2387 return (value); 2388 return (f1->len - f2->len); 2389 } 2390 2391 /* 2392 * ffcmp - routine used by qsort. Sort only by pathname length. 2393 */ 2394 static int 2395 ffcmp(struct filenames *f1, struct filenames *f2) 2396 { 2397 return (f1->len - f2->len); 2398 } 2399 2400 /* 2401 * parse - set up the call to follow_path. 2402 */ 2403 static void 2404 parse() 2405 { 2406 int i; 2407 char c; 2408 2409 stack_pathp = input_pathp = -1; 2410 if ((c = getachar()) == '/') { 2411 while ((c = getachar()) == '/') 2412 ; 2413 ungetachar(c); 2414 cur_inum = 2; 2415 c = getachar(); 2416 if ((c == '\n') || ((doing_cd) && (c == ' '))) { 2417 ungetachar(c); 2418 if (doing_cd) { 2419 top++; 2420 top->ino = 2; 2421 top->len = -1; 2422 nfiles = 1; 2423 return; 2424 } 2425 } else 2426 ungetachar(c); 2427 } else { 2428 ungetachar(c); 2429 stack_pathp = current_pathp; 2430 if (!doing_find) 2431 input_pathp = current_pathp; 2432 for (i = 0; i <= current_pathp; i++) { 2433 if (!doing_find) 2434 (void) strcpy(input_path[i], current_path[i]); 2435 (void) strcpy(stack_path[i], current_path[i]); 2436 } 2437 } 2438 getname(); 2439 follow_path((long)(stack_pathp + 1), cur_inum); 2440 } 2441 2442 /* 2443 * follow_path - called by cd, find, and ls. 2444 * input_path holds the name typed by the user. 2445 * stack_path holds the name at the current depth. 2446 */ 2447 static void 2448 follow_path(long level, long inum) 2449 { 2450 struct direct *dirp; 2451 char **ccptr, *cptr; 2452 int i; 2453 struct filenames *tos, *bos, *fn, *fnn, *fnnn; 2454 long block; 2455 short mode; 2456 2457 tos = top + 1; 2458 restore_inode((ino_t)inum); 2459 if ((mode = icheck(addr)) == 0) 2460 return; 2461 if ((mode & IFMT) != IFDIR) 2462 return; 2463 block = cur_bytes = 0; 2464 while (cur_bytes < filesize) { 2465 if (block == 0 || bcomp(addr)) { 2466 error = 0; 2467 if ((addr = ((u_offset_t)bmap(block++) << 2468 (u_offset_t)FRGSHIFT)) == 0) 2469 break; 2470 if ((cptr = getblk(addr)) == 0) 2471 break; 2472 cptr += blkoff(fs, addr); 2473 } 2474 /*LINTED*/ 2475 dirp = (struct direct *)cptr; 2476 if (dirp->d_ino) { 2477 if (level > input_pathp || doing_find || 2478 compare(input_path[level], &dirp->d_name[0], 1)) { 2479 if ((doing_find) && 2480 ((strcmp(dirp->d_name, ".") == 0 || 2481 strcmp(dirp->d_name, "..") == 0))) 2482 goto duplicate; 2483 if (++top - filenames >= maxfiles) { 2484 printf("too many files\n"); 2485 error++; 2486 return; 2487 } 2488 top->fname = (char **)calloc(FIRST_DEPTH, sizeof (char **)); 2489 top->flag = 0; 2490 if (top->fname == 0) { 2491 printf("out of memory\n"); 2492 error++; 2493 return; 2494 } 2495 nfiles++; 2496 top->ino = dirp->d_ino; 2497 top->len = stack_pathp; 2498 top->find = 0; 2499 if (doing_find) { 2500 if (find_by_name) { 2501 if (compare(input_path[0], &dirp->d_name[0], 1)) 2502 top->find = 1; 2503 } else if (find_by_inode) 2504 if (find_ino == dirp->d_ino) 2505 top->find = 1; 2506 } 2507 if (top->len + 1 >= FIRST_DEPTH && top->flag == 0) { 2508 ccptr = (char **)calloc(SECOND_DEPTH, sizeof (char **)); 2509 if (ccptr == 0) { 2510 printf("out of memory\n"); 2511 error++; 2512 return; 2513 } 2514 for (i = 0; i < FIRST_DEPTH; i++) 2515 ccptr[i] = top->fname[i]; 2516 free((char *)top->fname); 2517 top->fname = ccptr; 2518 top->flag = 1; 2519 } 2520 if (top->len >= SECOND_DEPTH) { 2521 printf("maximum depth exceeded, try to cd lower\n"); 2522 error++; 2523 return; 2524 } 2525 /* 2526 * Copy current depth. 2527 */ 2528 for (i = 0; i <= stack_pathp; i++) { 2529 top->fname[i] = calloc(1, strlen(stack_path[i])+1); 2530 if (top->fname[i] == 0) { 2531 printf("out of memory\n"); 2532 error++; 2533 return; 2534 } 2535 (void) strcpy(top->fname[i], stack_path[i]); 2536 } 2537 /* 2538 * Check for '.' or '..' typed. 2539 */ 2540 if ((level <= input_pathp) && 2541 (strcmp(input_path[level], ".") == 0 || 2542 strcmp(input_path[level], "..") == 0)) { 2543 if (strcmp(input_path[level], "..") == 0 && 2544 top->len >= 0) { 2545 free(top->fname[top->len]); 2546 top->len -= 1; 2547 } 2548 } else { 2549 /* 2550 * Check for duplicates. 2551 */ 2552 if (!doing_cd && !doing_find) { 2553 for (fn = filenames; fn < top; fn++) { 2554 if (fn->ino == dirp->d_ino && 2555 fn->len == stack_pathp + 1) { 2556 for (i = 0; i < fn->len; i++) 2557 if (strcmp(fn->fname[i], stack_path[i])) 2558 break; 2559 if (i != fn->len || 2560 strcmp(fn->fname[i], dirp->d_name)) 2561 continue; 2562 freemem(top, 1); 2563 if (top == filenames) 2564 top = NULL; 2565 else 2566 top--; 2567 nfiles--; 2568 goto duplicate; 2569 } 2570 } 2571 } 2572 top->len += 1; 2573 top->fname[top->len] = calloc(1, 2574 strlen(&dirp->d_name[0])+1); 2575 if (top->fname[top->len] == 0) { 2576 printf("out of memory\n"); 2577 error++; 2578 return; 2579 } 2580 (void) strcpy(top->fname[top->len], &dirp->d_name[0]); 2581 } 2582 } 2583 } 2584 duplicate: 2585 addr += dirp->d_reclen; 2586 cptr += dirp->d_reclen; 2587 cur_bytes += dirp->d_reclen; 2588 } 2589 if (top < filenames) 2590 return; 2591 if ((doing_cd && level == input_pathp) || 2592 (!recursive && !doing_find && level > input_pathp)) 2593 return; 2594 bos = top; 2595 /* 2596 * Check newly added entries to determine if further expansion 2597 * is required. 2598 */ 2599 for (fn = tos; fn <= bos; fn++) { 2600 /* 2601 * Avoid '.' and '..' if beyond input. 2602 */ 2603 if ((recursive || doing_find) && (level > input_pathp) && 2604 (strcmp(fn->fname[fn->len], ".") == 0 || 2605 strcmp(fn->fname[fn->len], "..") == 0)) 2606 continue; 2607 restore_inode(fn->ino); 2608 if ((mode = icheck(cur_ino)) == 0) 2609 return; 2610 if ((mode & IFMT) == IFDIR || level < input_pathp) { 2611 /* 2612 * Set up current depth, remove current entry and 2613 * continue recursion. 2614 */ 2615 for (i = 0; i <= fn->len; i++) 2616 (void) strcpy(stack_path[i], fn->fname[i]); 2617 stack_pathp = fn->len; 2618 if (!doing_find && 2619 (!recursive || (recursive && level <= input_pathp))) { 2620 /* 2621 * Remove current entry by moving others up. 2622 */ 2623 freemem(fn, 1); 2624 fnn = fn; 2625 for (fnnn = fnn, fnn++; fnn <= top; fnnn = fnn, fnn++) { 2626 fnnn->ino = fnn->ino; 2627 fnnn->len = fnn->len; 2628 if (fnnn->len + 1 < FIRST_DEPTH) { 2629 fnnn->fname = (char **)calloc(FIRST_DEPTH, 2630 sizeof (char **)); 2631 fnnn->flag = 0; 2632 } else if (fnnn->len < SECOND_DEPTH) { 2633 fnnn->fname = (char **)calloc(SECOND_DEPTH, 2634 sizeof (char **)); 2635 fnnn->flag = 1; 2636 } else { 2637 printf("maximum depth exceeded, "); 2638 printf("try to cd lower\n"); 2639 error++; 2640 return; 2641 } 2642 for (i = 0; i <= fnn->len; i++) 2643 fnnn->fname[i] = fnn->fname[i]; 2644 } 2645 if (fn == tos) 2646 fn--; 2647 top--; 2648 bos--; 2649 nfiles--; 2650 } 2651 follow_path(level + 1, cur_inum); 2652 if (error) 2653 return; 2654 } 2655 } 2656 } 2657 2658 /* 2659 * getname - break up the pathname entered by the user into components. 2660 */ 2661 static void 2662 getname() 2663 { 2664 int i; 2665 char c; 2666 2667 if ((c = getachar()) == '\n') { 2668 ungetachar(c); 2669 return; 2670 } 2671 ungetachar(c); 2672 input_pathp++; 2673 clear: 2674 for (i = 0; i < MAXNAMLEN; i++) 2675 input_path[input_pathp][i] = '\0'; 2676 for (;;) { 2677 c = getachar(); 2678 if (c == '\\') { 2679 if ((int)strlen(input_path[input_pathp]) + 1 >= MAXNAMLEN) { 2680 printf("maximum name length exceeded, "); 2681 printf("truncating\n"); 2682 return; 2683 } 2684 input_path[input_pathp][strlen(input_path[input_pathp])] = c; 2685 input_path[input_pathp][strlen(input_path[input_pathp])] = 2686 getachar(); 2687 continue; 2688 } 2689 if (c == ' ' || c == '\n') { 2690 ungetachar(c); 2691 return; 2692 } 2693 if (!doing_find && c == '/') { 2694 if (++input_pathp >= MAXPATHLEN) { 2695 printf("maximum path length exceeded, "); 2696 printf("truncating\n"); 2697 input_pathp--; 2698 return; 2699 } 2700 goto clear; 2701 } 2702 if ((int)strlen(input_path[input_pathp]) >= MAXNAMLEN) { 2703 printf("maximum name length exceeded, truncating\n"); 2704 return; 2705 } 2706 input_path[input_pathp][strlen(input_path[input_pathp])] = c; 2707 } 2708 } 2709 2710 /* 2711 * compare - check if a filename matches the pattern entered by the user. 2712 * Handles '*', '?', and '[]'. 2713 */ 2714 static int 2715 compare(char *s1, char *s2, short at_start) 2716 { 2717 char c, *s; 2718 2719 s = s2; 2720 while ((c = *s1) != NULL) { 2721 if (c == '*') { 2722 if (at_start && s == s2 && !letter(*s2) && !digit(*s2)) 2723 return (0); 2724 if (*++s1 == 0) 2725 return (1); 2726 while (*s2) { 2727 if (compare(s1, s2, 0)) 2728 return (1); 2729 if (error) 2730 return (0); 2731 s2++; 2732 } 2733 } 2734 if (*s2 == 0) 2735 return (0); 2736 if (c == '\\') { 2737 s1++; 2738 goto compare_chars; 2739 } 2740 if (c == '?') { 2741 if (at_start && s == s2 && !letter(*s2) && !digit(*s2)) 2742 return (0); 2743 s1++; 2744 s2++; 2745 continue; 2746 } 2747 if (c == '[') { 2748 s1++; 2749 if (*s2 >= *s1++) { 2750 if (*s1++ != '-') { 2751 printf("missing '-'\n"); 2752 error++; 2753 return (0); 2754 } 2755 if (*s2 <= *s1++) { 2756 if (*s1++ != ']') { 2757 printf("missing ']'"); 2758 error++; 2759 return (0); 2760 } 2761 s2++; 2762 continue; 2763 } 2764 } 2765 } 2766 compare_chars: 2767 if (*s1++ == *s2++) 2768 continue; 2769 else 2770 return (0); 2771 } 2772 if (*s1 == *s2) 2773 return (1); 2774 return (0); 2775 } 2776 2777 /* 2778 * freemem - free the memory allocated to the filenames structure. 2779 */ 2780 static void 2781 freemem(struct filenames *p, int numb) 2782 { 2783 int i, j; 2784 2785 if (numb == 0) 2786 return; 2787 for (i = 0; i < numb; i++, p++) { 2788 for (j = 0; j <= p->len; j++) 2789 free(p->fname[j]); 2790 free((char *)p->fname); 2791 } 2792 } 2793 2794 /* 2795 * print_path - print the pathname held in p. 2796 */ 2797 static void 2798 print_path(char *p[], int pntr) 2799 { 2800 int i; 2801 2802 printf("/"); 2803 if (pntr >= 0) { 2804 for (i = 0; i < pntr; i++) 2805 printf("%s/", p[i]); 2806 printf("%s", p[pntr]); 2807 } 2808 } 2809 2810 /* 2811 * fill - fill a section with a value or string. 2812 * addr,count:fill=[value, "string"]. 2813 */ 2814 static void 2815 fill() 2816 { 2817 char *cptr; 2818 int i; 2819 short eof_flag, end = 0, eof = 0; 2820 long temp, tcount; 2821 u_offset_t taddr; 2822 2823 if (wrtflag == O_RDONLY) { 2824 printf("not opened for write '-w'\n"); 2825 error++; 2826 return; 2827 } 2828 temp = expr(); 2829 if (error) 2830 return; 2831 if ((cptr = getblk(addr)) == 0) 2832 return; 2833 if (type == NUMB) 2834 eof_flag = 0; 2835 else 2836 eof_flag = 1; 2837 taddr = addr; 2838 switch (objsz) { 2839 case LONG: 2840 addr &= ~(LONG - 1); 2841 break; 2842 case SHORT: 2843 addr &= ~(SHORT - 1); 2844 temp &= 0177777L; 2845 break; 2846 case CHAR: 2847 temp &= 0377; 2848 } 2849 cur_bytes -= taddr - addr; 2850 cptr += blkoff(fs, addr); 2851 tcount = check_addr(eof_flag, &end, &eof, 0); 2852 for (i = 0; i < tcount; i++) { 2853 switch (objsz) { 2854 case LONG: 2855 /*LINTED*/ 2856 *(long *)cptr = temp; 2857 break; 2858 case SHORT: 2859 /*LINTED*/ 2860 *(short *)cptr = temp; 2861 break; 2862 case CHAR: 2863 *cptr = temp; 2864 } 2865 cptr += objsz; 2866 } 2867 addr += (tcount - 1) * objsz; 2868 cur_bytes += (tcount - 1) * objsz; 2869 put((u_offset_t)temp, objsz); 2870 if (eof) { 2871 printf("end of file\n"); 2872 error++; 2873 } else if (end) { 2874 printf("end of block\n"); 2875 error++; 2876 } 2877 } 2878 2879 /* 2880 * get - read a byte, short or long from the file system. 2881 * The entire block containing the desired item is read 2882 * and the appropriate data is extracted and returned. 2883 */ 2884 static offset_t 2885 get(short lngth) 2886 { 2887 2888 char *bptr; 2889 u_offset_t temp = addr; 2890 2891 objsz = lngth; 2892 if (objsz == INODE || objsz == SHORT) 2893 temp &= ~(SHORT - 1); 2894 else if (objsz == DIRECTORY || objsz == LONG || objsz == SHADOW_DATA) 2895 temp &= ~(LONG - 1); 2896 if ((bptr = getblk(temp)) == 0) 2897 return (-1); 2898 bptr += blkoff(fs, temp); 2899 switch (objsz) { 2900 case CHAR: 2901 return ((offset_t)*bptr); 2902 case SHORT: 2903 case INODE: 2904 /*LINTED*/ 2905 return ((offset_t)(*(short *)bptr)); 2906 case LONG: 2907 case DIRECTORY: 2908 case SHADOW_DATA: 2909 /*LINTED*/ 2910 return ((offset_t)(*(long *)bptr)); 2911 case U_OFFSET_T: 2912 /*LINTED*/ 2913 return (*(offset_t *)bptr); 2914 } 2915 return (0); 2916 } 2917 2918 /* 2919 * cgrp_check - make sure that we don't bump the cylinder group 2920 * beyond the total number of cylinder groups or before the start. 2921 */ 2922 static int 2923 cgrp_check(long cgrp) 2924 { 2925 if (cgrp < 0) { 2926 if (objsz == CGRP) 2927 printf("beginning of cylinder groups\n"); 2928 else 2929 printf("beginning of super blocks\n"); 2930 error++; 2931 return (0); 2932 } 2933 if (cgrp >= fs->fs_ncg) { 2934 if (objsz == CGRP) 2935 printf("end of cylinder groups\n"); 2936 else 2937 printf("end of super blocks\n"); 2938 error++; 2939 return (0); 2940 } 2941 if (objsz == CGRP) 2942 return (cgtod(fs, cgrp) << FRGSHIFT); 2943 else 2944 return (cgsblock(fs, cgrp) << FRGSHIFT); 2945 } 2946 2947 /* 2948 * icheck - make sure we can read the block containing the inode 2949 * and determine the filesize (0 if inode not allocated). Return 2950 * 0 if error otherwise return the mode. 2951 */ 2952 int 2953 icheck(u_offset_t address) 2954 { 2955 char *cptr; 2956 struct dinode *ip; 2957 2958 if ((cptr = getblk(address)) == 0) 2959 return (0); 2960 cptr += blkoff(fs, address); 2961 /*LINTED*/ 2962 ip = (struct dinode *)cptr; 2963 if ((ip->di_mode & IFMT) == 0) { 2964 if (!override) { 2965 printf("inode not allocated\n"); 2966 error++; 2967 return (0); 2968 } 2969 blocksize = filesize = 0; 2970 } else { 2971 trapped++; 2972 filesize = ip->di_size; 2973 blocksize = filesize * 2; 2974 } 2975 return (ip->di_mode); 2976 } 2977 2978 /* 2979 * getdirslot - get the address of the directory slot desired. 2980 */ 2981 static u_offset_t 2982 getdirslot(long slot) 2983 { 2984 char *cptr; 2985 struct direct *dirp; 2986 short i; 2987 char *string = &scratch[0]; 2988 short bod = 0, mode, temp; 2989 2990 if (slot < 0) { 2991 slot = 0; 2992 bod++; 2993 } 2994 if (type != DIRECTORY) { 2995 if (type == BLOCK) 2996 string = "block"; 2997 else 2998 string = "fragment"; 2999 addr = bod_addr; 3000 if ((cptr = getblk(addr)) == 0) 3001 return (0); 3002 cptr += blkoff(fs, addr); 3003 cur_bytes = 0; 3004 /*LINTED*/ 3005 dirp = (struct direct *)cptr; 3006 for (dirslot = 0; dirslot < slot; dirslot++) { 3007 /*LINTED*/ 3008 dirp = (struct direct *)cptr; 3009 if (blocksize > filesize) { 3010 if (cur_bytes + (long)dirp->d_reclen >= 3011 filesize) { 3012 printf("end of file\n"); 3013 erraddr = addr; 3014 errcur_bytes = cur_bytes; 3015 stringsize = STRINGSIZE(dirp); 3016 error++; 3017 return (addr); 3018 } 3019 } else { 3020 if (cur_bytes + (long)dirp->d_reclen >= 3021 blocksize) { 3022 printf("end of %s\n", string); 3023 erraddr = addr; 3024 errcur_bytes = cur_bytes; 3025 stringsize = STRINGSIZE(dirp); 3026 error++; 3027 return (addr); 3028 } 3029 } 3030 cptr += dirp->d_reclen; 3031 addr += dirp->d_reclen; 3032 cur_bytes += dirp->d_reclen; 3033 } 3034 if (bod) { 3035 if (blocksize > filesize) 3036 printf("beginning of file\n"); 3037 else 3038 printf("beginning of %s\n", string); 3039 erraddr = addr; 3040 errcur_bytes = cur_bytes; 3041 error++; 3042 } 3043 stringsize = STRINGSIZE(dirp); 3044 return (addr); 3045 } else { 3046 addr = cur_ino; 3047 if ((mode = icheck(addr)) == 0) 3048 return (0); 3049 if (!override && (mode & IFDIR) == 0) { 3050 printf("inode is not a directory\n"); 3051 error++; 3052 return (0); 3053 } 3054 temp = slot; 3055 i = cur_bytes = 0; 3056 for (;;) { 3057 if (i == 0 || bcomp(addr)) { 3058 error = 0; 3059 if ((addr = (bmap((long)i++) << FRGSHIFT)) == 0) 3060 break; 3061 if ((cptr = getblk(addr)) == 0) 3062 break; 3063 cptr += blkoff(fs, addr); 3064 } 3065 /*LINTED*/ 3066 dirp = (struct direct *)cptr; 3067 value = dirp->d_ino; 3068 if (!temp--) 3069 break; 3070 if (cur_bytes + (long)dirp->d_reclen >= filesize) { 3071 printf("end of file\n"); 3072 dirslot = slot - temp - 1; 3073 objsz = DIRECTORY; 3074 erraddr = addr; 3075 errcur_bytes = cur_bytes; 3076 stringsize = STRINGSIZE(dirp); 3077 error++; 3078 return (addr); 3079 } 3080 addr += dirp->d_reclen; 3081 cptr += dirp->d_reclen; 3082 cur_bytes += dirp->d_reclen; 3083 } 3084 dirslot = slot; 3085 objsz = DIRECTORY; 3086 if (bod) { 3087 printf("beginning of file\n"); 3088 erraddr = addr; 3089 errcur_bytes = cur_bytes; 3090 error++; 3091 } 3092 stringsize = STRINGSIZE(dirp); 3093 return (addr); 3094 } 3095 } 3096 3097 3098 /* 3099 * getshadowslot - get the address of the shadow data desired 3100 */ 3101 static int 3102 getshadowslot(long shadow) 3103 { 3104 struct ufs_fsd fsd; 3105 short bod = 0, mode; 3106 long taddr, tcurbytes; 3107 3108 if (shadow < 0) { 3109 shadow = 0; 3110 bod++; 3111 } 3112 if (type != SHADOW_DATA) { 3113 if (shadow < cur_shad) { 3114 printf("can't scan shadow data in reverse\n"); 3115 error++; 3116 return (0); 3117 } 3118 } else { 3119 addr = cur_ino; 3120 if ((mode = icheck(addr)) == 0) 3121 return (0); 3122 if (!override && (mode & IFMT) != IFSHAD) { 3123 printf("inode is not a shadow\n"); 3124 error++; 3125 return (0); 3126 } 3127 cur_bytes = 0; 3128 cur_shad = 0; 3129 syncshadowscan(1); /* force synchronization */ 3130 } 3131 3132 for (; cur_shad < shadow; cur_shad++) { 3133 taddr = addr; 3134 tcurbytes = cur_bytes; 3135 getshadowdata((long *)&fsd, LONG + LONG); 3136 addr = taddr; 3137 cur_bytes = tcurbytes; 3138 if (cur_bytes + (long)fsd.fsd_size > filesize) { 3139 syncshadowscan(0); 3140 printf("end of file\n"); 3141 erraddr = addr; 3142 errcur_bytes = cur_bytes; 3143 error++; 3144 return (addr); 3145 } 3146 addr += fsd.fsd_size; 3147 cur_bytes += fsd.fsd_size; 3148 syncshadowscan(0); 3149 } 3150 if (type == SHADOW_DATA) 3151 objsz = SHADOW_DATA; 3152 if (bod) { 3153 printf("beginning of file\n"); 3154 erraddr = addr; 3155 errcur_bytes = cur_bytes; 3156 error++; 3157 } 3158 return (addr); 3159 } 3160 3161 static void 3162 getshadowdata(long *buf, int len) 3163 { 3164 long tfsd; 3165 3166 len /= LONG; 3167 for (tfsd = 0; tfsd < len; tfsd++) { 3168 buf[tfsd] = get(SHADOW_DATA); 3169 addr += LONG; 3170 cur_bytes += LONG; 3171 syncshadowscan(0); 3172 } 3173 } 3174 3175 static void 3176 syncshadowscan(int force) 3177 { 3178 long curblkoff; 3179 if (type == SHADOW_DATA && (force || 3180 lblkno(fs, addr) != (bhdr.fwd)->blkno)) { 3181 curblkoff = blkoff(fs, cur_bytes); 3182 addr = bmap(lblkno(fs, cur_bytes)) << FRGSHIFT; 3183 addr += curblkoff; 3184 cur_bytes += curblkoff; 3185 (void) getblk(addr); 3186 objsz = SHADOW_DATA; 3187 } 3188 } 3189 3190 3191 3192 /* 3193 * putf - print a byte as an ascii character if possible. 3194 * The exceptions are tabs, newlines, backslashes 3195 * and nulls which are printed as the standard C 3196 * language escapes. Characters which are not 3197 * recognized are printed as \?. 3198 */ 3199 static void 3200 putf(char c) 3201 { 3202 3203 if (c <= 037 || c >= 0177 || c == '\\') { 3204 printf("\\"); 3205 switch (c) { 3206 case '\\': 3207 printf("\\"); 3208 break; 3209 case '\t': 3210 printf("t"); 3211 break; 3212 case '\n': 3213 printf("n"); 3214 break; 3215 case '\0': 3216 printf("0"); 3217 break; 3218 default: 3219 printf("?"); 3220 } 3221 } else { 3222 printf("%c", c); 3223 printf(" "); 3224 } 3225 } 3226 3227 /* 3228 * put - write an item into the buffer for the current address 3229 * block. The value is checked to make sure that it will 3230 * fit in the size given without truncation. If successful, 3231 * the entire block is written back to the file system. 3232 */ 3233 static void 3234 put(u_offset_t item, short lngth) 3235 { 3236 3237 char *bptr, *sbptr; 3238 long s_err, nbytes; 3239 long olditem; 3240 3241 if (wrtflag == O_RDONLY) { 3242 printf("not opened for write '-w'\n"); 3243 error++; 3244 return; 3245 } 3246 objsz = lngth; 3247 if ((sbptr = getblk(addr)) == 0) 3248 return; 3249 bptr = sbptr + blkoff(fs, addr); 3250 switch (objsz) { 3251 case LONG: 3252 case DIRECTORY: 3253 /*LINTED*/ 3254 olditem = *(long *)bptr; 3255 /*LINTED*/ 3256 *(long *)bptr = item; 3257 break; 3258 case SHORT: 3259 case INODE: 3260 /*LINTED*/ 3261 olditem = (long)*(short *)bptr; 3262 item &= 0177777L; 3263 /*LINTED*/ 3264 *(short *)bptr = item; 3265 break; 3266 case CHAR: 3267 olditem = (long)*bptr; 3268 item &= 0377; 3269 *bptr = lobyte(loword(item)); 3270 break; 3271 default: 3272 error++; 3273 return; 3274 } 3275 if ((s_err = llseek(fd, (offset_t)(addr & fs->fs_bmask), 0)) == -1) { 3276 error++; 3277 printf("seek error : %" PRIx64 "\n", addr); 3278 return; 3279 } 3280 if ((nbytes = write(fd, sbptr, BLKSIZE)) != BLKSIZE) { 3281 error++; 3282 printf("write error : addr = %" PRIx64 "\n", addr); 3283 printf(" : s_err = %lx\n", s_err); 3284 printf(" : nbytes = %lx\n", nbytes); 3285 return; 3286 } 3287 if (!acting_on_inode && objsz != INODE && objsz != DIRECTORY) { 3288 index(base); 3289 print(olditem, 8, -8, 0); 3290 printf("\t=\t"); 3291 print(item, 8, -8, 0); 3292 printf("\n"); 3293 } else { 3294 if (objsz == DIRECTORY) { 3295 addr = cur_dir; 3296 fprnt('?', 'd'); 3297 } else { 3298 addr = cur_ino; 3299 objsz = INODE; 3300 fprnt('?', 'i'); 3301 } 3302 } 3303 } 3304 3305 /* 3306 * getblk - check if the desired block is in the file system. 3307 * Search the incore buffers to see if the block is already 3308 * available. If successful, unlink the buffer control block 3309 * from its position in the buffer list and re-insert it at 3310 * the head of the list. If failure, use the last buffer 3311 * in the list for the desired block. Again, this control 3312 * block is placed at the head of the list. This process 3313 * will leave commonly requested blocks in the in-core buffers. 3314 * Finally, a pointer to the buffer is returned. 3315 */ 3316 static char * 3317 getblk(u_offset_t address) 3318 { 3319 3320 struct lbuf *bp; 3321 long s_err, nbytes; 3322 unsigned long block; 3323 3324 read_requests++; 3325 block = lblkno(fs, address); 3326 if (block >= fragstoblks(fs, fs->fs_size)) { 3327 printf("cannot read block %lu\n", block); 3328 error++; 3329 return (0); 3330 } 3331 for (bp = bhdr.fwd; bp != &bhdr; bp = bp->fwd) 3332 if (bp->valid && bp->blkno == block) 3333 goto xit; 3334 actual_disk_reads++; 3335 bp = bhdr.back; 3336 bp->blkno = block; 3337 bp->valid = 0; 3338 if ((s_err = llseek(fd, (offset_t)(address & fs->fs_bmask), 0)) == -1) { 3339 error++; 3340 printf("seek error : %" PRIx64 "\n", address); 3341 return (0); 3342 } 3343 if ((nbytes = read(fd, bp->blkaddr, BLKSIZE)) != BLKSIZE) { 3344 error++; 3345 printf("read error : addr = %" PRIx64 "\n", address); 3346 printf(" : s_err = %lx\n", s_err); 3347 printf(" : nbytes = %lx\n", nbytes); 3348 return (0); 3349 } 3350 bp->valid++; 3351 xit: bp->back->fwd = bp->fwd; 3352 bp->fwd->back = bp->back; 3353 insert(bp); 3354 return (bp->blkaddr); 3355 } 3356 3357 /* 3358 * insert - place the designated buffer control block 3359 * at the head of the linked list of buffers. 3360 */ 3361 static void 3362 insert(struct lbuf *bp) 3363 { 3364 3365 bp->back = &bhdr; 3366 bp->fwd = bhdr.fwd; 3367 bhdr.fwd->back = bp; 3368 bhdr.fwd = bp; 3369 } 3370 3371 /* 3372 * err - called on interrupts. Set the current address 3373 * back to the last address stored in erraddr. Reset all 3374 * appropriate flags. A reset call is made to return 3375 * to the main loop; 3376 */ 3377 #ifdef sun 3378 /*ARGSUSED*/ 3379 static void 3380 err(int sig) 3381 #else 3382 err() 3383 #endif /* sun */ 3384 { 3385 freemem(filenames, nfiles); 3386 nfiles = 0; 3387 (void) signal(2, err); 3388 addr = erraddr; 3389 cur_ino = errino; 3390 cur_inum = errinum; 3391 cur_bytes = errcur_bytes; 3392 error = 0; 3393 c_count = 0; 3394 printf("\n?\n"); 3395 (void) fseek(stdin, 0L, 2); 3396 longjmp(env, 0); 3397 } 3398 3399 /* 3400 * devcheck - check that the given mode represents a 3401 * special device. The IFCHR bit is on for both 3402 * character and block devices. 3403 */ 3404 static int 3405 devcheck(short md) 3406 { 3407 if (override) 3408 return (0); 3409 switch (md & IFMT) { 3410 case IFCHR: 3411 case IFBLK: 3412 return (0); 3413 } 3414 3415 printf("not character or block device\n"); 3416 error++; 3417 return (1); 3418 } 3419 3420 /* 3421 * nullblk - return error if address is zero. This is done 3422 * to prevent block 0 from being used as an indirect block 3423 * for a large file or as a data block for a small file. 3424 */ 3425 static int 3426 nullblk(long bn) 3427 { 3428 if (bn != 0) 3429 return (0); 3430 printf("non existent block\n"); 3431 error++; 3432 return (1); 3433 } 3434 3435 /* 3436 * puta - put ascii characters into a buffer. The string 3437 * terminates with a quote or newline. The leading quote, 3438 * which is optional for directory names, was stripped off 3439 * by the assignment case in the main loop. 3440 */ 3441 static void 3442 puta() 3443 { 3444 char *cptr, c; 3445 int i; 3446 char *sbptr; 3447 short terror = 0; 3448 long maxchars, s_err, nbytes, temp; 3449 u_offset_t taddr = addr; 3450 long tcount = 0, item, olditem = 0; 3451 3452 if (wrtflag == O_RDONLY) { 3453 printf("not opened for write '-w'\n"); 3454 error++; 3455 return; 3456 } 3457 if ((sbptr = getblk(addr)) == 0) 3458 return; 3459 cptr = sbptr + blkoff(fs, addr); 3460 if (objsz == DIRECTORY) { 3461 if (acting_on_directory) 3462 maxchars = stringsize - 1; 3463 else 3464 maxchars = LONG; 3465 } else if (objsz == INODE) 3466 maxchars = objsz - (addr - cur_ino); 3467 else 3468 maxchars = min(blocksize - cur_bytes, filesize - cur_bytes); 3469 while ((c = getachar()) != '"') { 3470 if (tcount >= maxchars) { 3471 printf("string too long\n"); 3472 if (objsz == DIRECTORY) 3473 addr = cur_dir; 3474 else if (acting_on_inode || objsz == INODE) 3475 addr = cur_ino; 3476 else 3477 addr = taddr; 3478 erraddr = addr; 3479 errcur_bytes = cur_bytes; 3480 terror++; 3481 break; 3482 } 3483 tcount++; 3484 if (c == '\n') { 3485 ungetachar(c); 3486 break; 3487 } 3488 temp = (long)*cptr; 3489 olditem <<= BITSPERCHAR; 3490 olditem += temp & 0xff; 3491 if (c == '\\') { 3492 switch (c = getachar()) { 3493 case 't': 3494 *cptr++ = '\t'; 3495 break; 3496 case 'n': 3497 *cptr++ = '\n'; 3498 break; 3499 case '0': 3500 *cptr++ = '\0'; 3501 break; 3502 default: 3503 *cptr++ = c; 3504 break; 3505 } 3506 } 3507 else 3508 *cptr++ = c; 3509 } 3510 if (objsz == DIRECTORY && acting_on_directory) 3511 for (i = tcount; i <= maxchars; i++) 3512 *cptr++ = '\0'; 3513 if ((s_err = llseek(fd, (offset_t)(addr & fs->fs_bmask), 0)) == -1) { 3514 error++; 3515 printf("seek error : %" PRIx64 "\n", addr); 3516 return; 3517 } 3518 if ((nbytes = write(fd, sbptr, BLKSIZE)) != BLKSIZE) { 3519 error++; 3520 printf("write error : addr = %" PRIx64 "\n", addr); 3521 printf(" : s_err = %lx\n", s_err); 3522 printf(" : nbytes = %lx\n", nbytes); 3523 return; 3524 } 3525 if (!acting_on_inode && objsz != INODE && objsz != DIRECTORY) { 3526 addr += tcount; 3527 cur_bytes += tcount; 3528 taddr = addr; 3529 if (objsz != CHAR) { 3530 addr &= ~(objsz - 1); 3531 cur_bytes -= taddr - addr; 3532 } 3533 if (addr == taddr) { 3534 addr -= objsz; 3535 taddr = addr; 3536 } 3537 tcount = LONG - (taddr - addr); 3538 index(base); 3539 if ((cptr = getblk(addr)) == 0) 3540 return; 3541 cptr += blkoff(fs, addr); 3542 switch (objsz) { 3543 case LONG: 3544 /*LINTED*/ 3545 item = *(long *)cptr; 3546 if (tcount < LONG) { 3547 olditem <<= tcount * BITSPERCHAR; 3548 temp = 1; 3549 for (i = 0; i < (tcount*BITSPERCHAR); i++) 3550 temp <<= 1; 3551 olditem += item & (temp - 1); 3552 } 3553 break; 3554 case SHORT: 3555 /*LINTED*/ 3556 item = (long)*(short *)cptr; 3557 if (tcount < SHORT) { 3558 olditem <<= tcount * BITSPERCHAR; 3559 temp = 1; 3560 for (i = 0; i < (tcount * BITSPERCHAR); i++) 3561 temp <<= 1; 3562 olditem += item & (temp - 1); 3563 } 3564 olditem &= 0177777L; 3565 break; 3566 case CHAR: 3567 item = (long)*cptr; 3568 olditem &= 0377; 3569 } 3570 print(olditem, 8, -8, 0); 3571 printf("\t=\t"); 3572 print(item, 8, -8, 0); 3573 printf("\n"); 3574 } else { 3575 if (objsz == DIRECTORY) { 3576 addr = cur_dir; 3577 fprnt('?', 'd'); 3578 } else { 3579 addr = cur_ino; 3580 objsz = INODE; 3581 fprnt('?', 'i'); 3582 } 3583 } 3584 if (terror) 3585 error++; 3586 } 3587 3588 /* 3589 * fprnt - print data. 'count' elements are printed where '*' will 3590 * print an entire blocks worth or up to the eof, whichever 3591 * occurs first. An error will occur if crossing a block boundary 3592 * is attempted since consecutive blocks don't usually have 3593 * meaning. Current print types: 3594 * / b - print as bytes (base sensitive) 3595 * c - print as characters 3596 * o O - print as octal shorts (longs) 3597 * d D - print as decimal shorts (longs) 3598 * x X - print as hexadecimal shorts (longs) 3599 * ? c - print as cylinder groups 3600 * d - print as directories 3601 * i - print as inodes 3602 * s - print as super blocks 3603 * S - print as shadow data 3604 */ 3605 static void 3606 fprnt(char style, char po) 3607 { 3608 int i; 3609 struct fs *sb; 3610 struct cg *cg; 3611 struct direct *dirp; 3612 struct dinode *ip; 3613 int tbase; 3614 char c, *cptr, *p; 3615 long tinode, tcount, temp; 3616 u_offset_t taddr; 3617 short offset, mode, end = 0, eof = 0, eof_flag; 3618 unsigned short *sptr; 3619 unsigned long *lptr; 3620 offset_t curoff, curioff; 3621 3622 laststyle = style; 3623 lastpo = po; 3624 should_print = 0; 3625 if (count != 1) { 3626 if (clear) { 3627 count = 1; 3628 star = 0; 3629 clear = 0; 3630 } else 3631 clear = 1; 3632 } 3633 tcount = count; 3634 offset = blkoff(fs, addr); 3635 3636 if (style == '/') { 3637 if (type == NUMB) 3638 eof_flag = 0; 3639 else 3640 eof_flag = 1; 3641 switch (po) { 3642 3643 case 'c': /* print as characters */ 3644 case 'b': /* or bytes */ 3645 if ((cptr = getblk(addr)) == 0) 3646 return; 3647 cptr += offset; 3648 objsz = CHAR; 3649 tcount = check_addr(eof_flag, &end, &eof, 0); 3650 if (tcount) { 3651 for (i = 0; tcount--; i++) { 3652 if (i % 16 == 0) { 3653 if (i) 3654 printf("\n"); 3655 index(base); 3656 } 3657 if (po == 'c') { 3658 putf(*cptr++); 3659 if ((i + 1) % 16) 3660 printf(" "); 3661 } else { 3662 if ((i + 1) % 16 == 0) 3663 print(*cptr++ & 0377L, 3664 2, -2, 0); 3665 else 3666 print(*cptr++ & 0377L, 3667 4, -2, 0); 3668 } 3669 addr += CHAR; 3670 cur_bytes += CHAR; 3671 } 3672 printf("\n"); 3673 } 3674 addr -= CHAR; 3675 erraddr = addr; 3676 cur_bytes -= CHAR; 3677 errcur_bytes = cur_bytes; 3678 if (eof) { 3679 printf("end of file\n"); 3680 error++; 3681 } else if (end) { 3682 if (type == BLOCK) 3683 printf("end of block\n"); 3684 else 3685 printf("end of fragment\n"); 3686 error++; 3687 } 3688 return; 3689 3690 case 'o': /* print as octal shorts */ 3691 tbase = OCTAL; 3692 goto otx; 3693 case 'd': /* print as decimal shorts */ 3694 tbase = DECIMAL; 3695 goto otx; 3696 case 'x': /* print as hex shorts */ 3697 tbase = HEX; 3698 otx: 3699 if ((cptr = getblk(addr)) == 0) 3700 return; 3701 taddr = addr; 3702 addr &= ~(SHORT - 1); 3703 cur_bytes -= taddr - addr; 3704 cptr += blkoff(fs, addr); 3705 /*LINTED*/ 3706 sptr = (unsigned short *)cptr; 3707 objsz = SHORT; 3708 tcount = check_addr(eof_flag, &end, &eof, 0); 3709 if (tcount) { 3710 for (i = 0; tcount--; i++) { 3711 sptr = (unsigned short *)print_check( 3712 /*LINTED*/ 3713 (unsigned long *)sptr, 3714 &tcount, tbase, i); 3715 switch (po) { 3716 case 'o': 3717 printf("%06o ", *sptr++); 3718 break; 3719 case 'd': 3720 printf("%05d ", *sptr++); 3721 break; 3722 case 'x': 3723 printf("%04x ", *sptr++); 3724 } 3725 addr += SHORT; 3726 cur_bytes += SHORT; 3727 } 3728 printf("\n"); 3729 } 3730 addr -= SHORT; 3731 erraddr = addr; 3732 cur_bytes -= SHORT; 3733 errcur_bytes = cur_bytes; 3734 if (eof) { 3735 printf("end of file\n"); 3736 error++; 3737 } else if (end) { 3738 if (type == BLOCK) 3739 printf("end of block\n"); 3740 else 3741 printf("end of fragment\n"); 3742 error++; 3743 } 3744 return; 3745 3746 case 'O': /* print as octal longs */ 3747 tbase = OCTAL; 3748 goto OTX; 3749 case 'D': /* print as decimal longs */ 3750 tbase = DECIMAL; 3751 goto OTX; 3752 case 'X': /* print as hex longs */ 3753 tbase = HEX; 3754 OTX: 3755 if ((cptr = getblk(addr)) == 0) 3756 return; 3757 taddr = addr; 3758 addr &= ~(LONG - 1); 3759 cur_bytes -= taddr - addr; 3760 cptr += blkoff(fs, addr); 3761 /*LINTED*/ 3762 lptr = (unsigned long *)cptr; 3763 objsz = LONG; 3764 tcount = check_addr(eof_flag, &end, &eof, 0); 3765 if (tcount) { 3766 for (i = 0; tcount--; i++) { 3767 lptr = print_check(lptr, &tcount, 3768 tbase, i); 3769 switch (po) { 3770 case 'O': 3771 printf("%011lo ", *lptr++); 3772 break; 3773 case 'D': 3774 printf("%010lu ", *lptr++); 3775 break; 3776 case 'X': 3777 printf("%08lx ", *lptr++); 3778 } 3779 addr += LONG; 3780 cur_bytes += LONG; 3781 } 3782 printf("\n"); 3783 } 3784 addr -= LONG; 3785 erraddr = addr; 3786 cur_bytes -= LONG; 3787 errcur_bytes = cur_bytes; 3788 if (eof) { 3789 printf("end of file\n"); 3790 error++; 3791 } else if (end) { 3792 if (type == BLOCK) 3793 printf("end of block\n"); 3794 else 3795 printf("end of fragment\n"); 3796 error++; 3797 } 3798 return; 3799 3800 default: 3801 error++; 3802 printf("no such print option\n"); 3803 return; 3804 } 3805 } else 3806 switch (po) { 3807 3808 case 'c': /* print as cylinder group */ 3809 if (type != NUMB) 3810 if (cur_cgrp + count > fs->fs_ncg) { 3811 tcount = fs->fs_ncg - cur_cgrp; 3812 if (!star) 3813 end++; 3814 } 3815 addr &= ~(LONG - 1); 3816 for (/* void */; tcount--; /* void */) { 3817 erraddr = addr; 3818 errcur_bytes = cur_bytes; 3819 if (type != NUMB) { 3820 addr = cgtod(fs, cur_cgrp) 3821 << FRGSHIFT; 3822 cur_cgrp++; 3823 } 3824 if ((cptr = getblk(addr)) == 0) { 3825 if (cur_cgrp) 3826 cur_cgrp--; 3827 return; 3828 } 3829 cptr += blkoff(fs, addr); 3830 /*LINTED*/ 3831 cg = (struct cg *)cptr; 3832 if (type == NUMB) { 3833 cur_cgrp = cg->cg_cgx + 1; 3834 type = objsz = CGRP; 3835 if (cur_cgrp + count - 1 > fs->fs_ncg) { 3836 tcount = fs->fs_ncg - cur_cgrp; 3837 if (!star) 3838 end++; 3839 } 3840 } 3841 if (! override && !cg_chkmagic(cg)) { 3842 printf("invalid cylinder group "); 3843 printf("magic word\n"); 3844 if (cur_cgrp) 3845 cur_cgrp--; 3846 error++; 3847 return; 3848 } 3849 printcg(cg); 3850 if (tcount) 3851 printf("\n"); 3852 } 3853 cur_cgrp--; 3854 if (end) { 3855 printf("end of cylinder groups\n"); 3856 error++; 3857 } 3858 return; 3859 3860 case 'd': /* print as directories */ 3861 if ((cptr = getblk(addr)) == 0) 3862 return; 3863 if (type == NUMB) { 3864 if (fragoff(fs, addr)) { 3865 printf("address must be at the "); 3866 printf("beginning of a fragment\n"); 3867 error++; 3868 return; 3869 } 3870 bod_addr = addr; 3871 type = FRAGMENT; 3872 dirslot = 0; 3873 cur_bytes = 0; 3874 blocksize = FRGSIZE; 3875 filesize = FRGSIZE * 2; 3876 } 3877 cptr += offset; 3878 objsz = DIRECTORY; 3879 while (tcount-- && cur_bytes < filesize && 3880 cur_bytes < blocksize && !bcomp(addr)) { 3881 /*LINTED*/ 3882 dirp = (struct direct *)cptr; 3883 tinode = dirp->d_ino; 3884 printf("i#: "); 3885 if (tinode == 0) 3886 printf("free\t"); 3887 else 3888 print(tinode, 12, -8, 0); 3889 printf("%s\n", &dirp->d_name[0]); 3890 erraddr = addr; 3891 errcur_bytes = cur_bytes; 3892 addr += dirp->d_reclen; 3893 cptr += dirp->d_reclen; 3894 cur_bytes += dirp->d_reclen; 3895 dirslot++; 3896 stringsize = STRINGSIZE(dirp); 3897 } 3898 addr = erraddr; 3899 cur_dir = addr; 3900 cur_bytes = errcur_bytes; 3901 dirslot--; 3902 if (tcount >= 0 && !star) { 3903 switch (type) { 3904 case FRAGMENT: 3905 printf("end of fragment\n"); 3906 break; 3907 case BLOCK: 3908 printf("end of block\n"); 3909 break; 3910 default: 3911 printf("end of directory\n"); 3912 } 3913 error++; 3914 } else 3915 error = 0; 3916 return; 3917 3918 case 'i': /* print as inodes */ 3919 /*LINTED*/ 3920 if ((ip = (struct dinode *)getblk(addr)) == 0) 3921 return; 3922 for (i = 1; i < fs->fs_ncg; i++) 3923 if (addr < (cgimin(fs, i) << FRGSHIFT)) 3924 break; 3925 i--; 3926 offset /= INODE; 3927 temp = (addr - (cgimin(fs, i) << FRGSHIFT)) >> FRGSHIFT; 3928 temp = (i * fs->fs_ipg) + fragstoblks(fs, temp) * 3929 INOPB(fs) + offset; 3930 if (count + offset > INOPB(fs)) { 3931 tcount = INOPB(fs) - offset; 3932 if (!star) 3933 end++; 3934 } 3935 objsz = INODE; 3936 ip += offset; 3937 for (i = 0; tcount--; ip++, temp++) { 3938 if ((mode = icheck(addr)) == 0) 3939 if (!override) 3940 continue; 3941 p = " ugtrwxrwxrwx"; 3942 3943 switch (mode & IFMT) { 3944 case IFDIR: 3945 c = 'd'; 3946 break; 3947 case IFCHR: 3948 c = 'c'; 3949 break; 3950 case IFBLK: 3951 c = 'b'; 3952 break; 3953 case IFREG: 3954 c = '-'; 3955 break; 3956 case IFLNK: 3957 c = 'l'; 3958 break; 3959 case IFSOCK: 3960 c = 's'; 3961 break; 3962 case IFSHAD: 3963 c = 'S'; 3964 break; 3965 case IFATTRDIR: 3966 c = 'A'; 3967 break; 3968 default: 3969 c = '?'; 3970 if (!override) 3971 goto empty; 3972 3973 } 3974 printf("i#: "); 3975 print(temp, 12, -8, 0); 3976 printf(" md: "); 3977 printf("%c", c); 3978 for (mode = mode << 4; *++p; mode = mode << 1) { 3979 if (mode & IFREG) 3980 printf("%c", *p); 3981 else 3982 printf("-"); 3983 } 3984 printf(" uid: "); 3985 print(ip->di_uid, 8, -4, 0); 3986 printf(" gid: "); 3987 print(ip->di_gid, 8, -4, 0); 3988 printf("\n"); 3989 printf("ln: "); 3990 print((long)ip->di_nlink, 8, -4, 0); 3991 printf(" bs: "); 3992 print(ip->di_blocks, 12, -8, 0); 3993 printf("c_flags : "); 3994 print(ip->di_cflags, 12, -8, 0); 3995 printf(" sz : "); 3996 #ifdef _LARGEFILE64_SOURCE 3997 printll(ip->di_size, 20, -16, 0); 3998 #else /* !_LARGEFILE64_SOURCE */ 3999 print(ip->di_size, 12, -8, 0); 4000 #endif /* _LARGEFILE64_SOURCE */ 4001 if (ip->di_shadow) { 4002 printf(" si: "); 4003 print(ip->di_shadow, 12, -8, 0); 4004 } 4005 printf("\n"); 4006 if (ip->di_oeftflag) { 4007 printf("ai: "); 4008 print(ip->di_oeftflag, 12, -8, 0); 4009 printf("\n"); 4010 } 4011 printf("\n"); 4012 switch (ip->di_mode & IFMT) { 4013 case IFBLK: 4014 case IFCHR: 4015 printf("maj: "); 4016 print(major(ip->di_ordev), 4, -2, 0); 4017 printf(" min: "); 4018 print(minor(ip->di_ordev), 4, -2, 0); 4019 printf("\n"); 4020 break; 4021 default: 4022 /* 4023 * only display blocks below the 4024 * current file size 4025 */ 4026 curoff = 0LL; 4027 for (i = 0; i < NDADDR; ) { 4028 if (ip->di_size <= curoff) 4029 break; 4030 printf("db#%x: ", i); 4031 print(ip->di_db[i], 11, -8, 0); 4032 4033 if (++i % 4 == 0) 4034 printf("\n"); 4035 else 4036 printf(" "); 4037 curoff += fs->fs_bsize; 4038 } 4039 if (i % 4) 4040 printf("\n"); 4041 4042 /* 4043 * curioff keeps track of the number 4044 * of bytes covered by each indirect 4045 * pointer in the inode, and is added 4046 * to curoff each time to get the 4047 * actual offset into the file. 4048 */ 4049 curioff = fs->fs_bsize * 4050 (fs->fs_bsize / sizeof (daddr_t)); 4051 for (i = 0; i < NIADDR; i++) { 4052 if (ip->di_size <= curoff) 4053 break; 4054 printf("ib#%x: ", i); 4055 print(ip->di_ib[i], 11, -8, 0); 4056 printf(" "); 4057 curoff += curioff; 4058 curioff *= (fs->fs_bsize / 4059 sizeof (daddr_t)); 4060 } 4061 if (i) 4062 printf("\n"); 4063 break; 4064 } 4065 if (count == 1) { 4066 time_t t; 4067 4068 t = ip->di_atime; 4069 printf("\taccessed: %s", ctime(&t)); 4070 t = ip->di_mtime; 4071 printf("\tmodified: %s", ctime(&t)); 4072 t = ip->di_ctime; 4073 printf("\tcreated : %s", ctime(&t)); 4074 } 4075 if (tcount) 4076 printf("\n"); 4077 empty: 4078 if (c == '?' && !override) { 4079 printf("i#: "); 4080 print(temp, 12, -8, 0); 4081 printf(" is unallocated\n"); 4082 if (count != 1) 4083 printf("\n"); 4084 } 4085 cur_ino = erraddr = addr; 4086 errcur_bytes = cur_bytes; 4087 cur_inum++; 4088 addr = addr + INODE; 4089 } 4090 addr = erraddr; 4091 cur_bytes = errcur_bytes; 4092 cur_inum--; 4093 if (end) { 4094 printf("end of block\n"); 4095 error++; 4096 } 4097 return; 4098 4099 case 's': /* print as super block */ 4100 if (cur_cgrp == -1) { 4101 addr = SBLOCK * DEV_BSIZE; 4102 type = NUMB; 4103 } 4104 addr &= ~(LONG - 1); 4105 if (type != NUMB) 4106 if (cur_cgrp + count > fs->fs_ncg) { 4107 tcount = fs->fs_ncg - cur_cgrp; 4108 if (!star) 4109 end++; 4110 } 4111 for (/* void */; tcount--; /* void */) { 4112 erraddr = addr; 4113 cur_bytes = errcur_bytes; 4114 if (type != NUMB) { 4115 addr = cgsblock(fs, cur_cgrp) 4116 << FRGSHIFT; 4117 cur_cgrp++; 4118 } 4119 if ((cptr = getblk(addr)) == 0) { 4120 if (cur_cgrp) 4121 cur_cgrp--; 4122 return; 4123 } 4124 cptr += blkoff(fs, addr); 4125 /*LINTED*/ 4126 sb = (struct fs *)cptr; 4127 if (type == NUMB) { 4128 for (i = 0; i < fs->fs_ncg; i++) 4129 if (addr == cgsblock(fs, i) << 4130 FRGSHIFT) 4131 break; 4132 if (i == fs->fs_ncg) 4133 cur_cgrp = 0; 4134 else 4135 cur_cgrp = i + 1; 4136 type = objsz = SB; 4137 if (cur_cgrp + count - 1 > fs->fs_ncg) { 4138 tcount = fs->fs_ncg - cur_cgrp; 4139 if (!star) 4140 end++; 4141 } 4142 } 4143 if ((sb->fs_magic != FS_MAGIC) && 4144 (sb->fs_magic != MTB_UFS_MAGIC)) { 4145 cur_cgrp = 0; 4146 if (!override) { 4147 printf("invalid super block "); 4148 printf("magic word\n"); 4149 cur_cgrp--; 4150 error++; 4151 return; 4152 } 4153 } 4154 if (sb->fs_magic == FS_MAGIC && 4155 (sb->fs_version != 4156 UFS_EFISTYLE4NONEFI_VERSION_2 && 4157 sb->fs_version != UFS_VERSION_MIN)) { 4158 cur_cgrp = 0; 4159 if (!override) { 4160 printf("invalid super block "); 4161 printf("version number\n"); 4162 cur_cgrp--; 4163 error++; 4164 return; 4165 } 4166 } 4167 if (sb->fs_magic == MTB_UFS_MAGIC && 4168 (sb->fs_version > MTB_UFS_VERSION_1 || 4169 sb->fs_version < MTB_UFS_VERSION_MIN)) { 4170 cur_cgrp = 0; 4171 if (!override) { 4172 printf("invalid super block "); 4173 printf("version number\n"); 4174 cur_cgrp--; 4175 error++; 4176 return; 4177 } 4178 } 4179 if (cur_cgrp == 0) 4180 printf("\tsuper block:\n"); 4181 else { 4182 printf("\tsuper block in cylinder "); 4183 printf("group "); 4184 print(cur_cgrp - 1, 0, 0, 0); 4185 printf(":\n"); 4186 } 4187 printsb(sb); 4188 if (tcount) 4189 printf("\n"); 4190 } 4191 cur_cgrp--; 4192 if (end) { 4193 printf("end of super blocks\n"); 4194 error++; 4195 } 4196 return; 4197 4198 case 'S': /* print as shadow data */ 4199 if (type == NUMB) { 4200 type = FRAGMENT; 4201 cur_shad = 0; 4202 cur_bytes = fragoff(fs, addr); 4203 bod_addr = addr - cur_bytes; 4204 /* no more than two fragments */ 4205 filesize = fragroundup(fs, 4206 bod_addr + FRGSIZE + 1); 4207 } 4208 objsz = SHADOW_DATA; 4209 while (tcount-- && 4210 (cur_bytes + SHADOW_DATA) <= filesize && 4211 (type != SHADOW_DATA || 4212 (cur_bytes + SHADOW_DATA)) <= blocksize) { 4213 /*LINTED*/ 4214 struct ufs_fsd fsd; 4215 long tcur_bytes; 4216 4217 taddr = addr; 4218 tcur_bytes = cur_bytes; 4219 index(base); 4220 getshadowdata((long *)&fsd, LONG + LONG); 4221 printf(" type: "); 4222 print((long)fsd.fsd_type, 8, -8, 0); 4223 printf(" size: "); 4224 print((long)fsd.fsd_size, 8, -8, 0); 4225 tbase = fsd.fsd_size - LONG - LONG; 4226 if (tbase > 256) 4227 tbase = 256; 4228 for (i = 0; i < tbase; i++) { 4229 if (i % LONG == 0) { 4230 if (i % 16 == 0) { 4231 printf("\n"); 4232 index(base); 4233 } else 4234 printf(" "); 4235 getshadowdata(&temp, LONG); 4236 p = (char *)&temp; 4237 } else 4238 printf(" "); 4239 printf("%02x", (int)(*p++ & 0377L)); 4240 } 4241 printf("\n"); 4242 addr = taddr; 4243 cur_bytes = tcur_bytes; 4244 erraddr = addr; 4245 errcur_bytes = cur_bytes; 4246 addr += FSD_RECSZ((&fsd), fsd.fsd_size); 4247 cur_bytes += FSD_RECSZ((&fsd), fsd.fsd_size); 4248 cur_shad++; 4249 syncshadowscan(0); 4250 } 4251 addr = erraddr; 4252 cur_bytes = errcur_bytes; 4253 cur_shad--; 4254 if (tcount >= 0 && !star) { 4255 switch (type) { 4256 case FRAGMENT: 4257 printf("end of fragment\n"); 4258 break; 4259 default: 4260 printf("end of shadow data\n"); 4261 } 4262 error++; 4263 } else 4264 error = 0; 4265 return; 4266 default: 4267 error++; 4268 printf("no such print option\n"); 4269 return; 4270 } 4271 } 4272 4273 /* 4274 * valid_addr - call check_addr to validate the current address. 4275 */ 4276 static int 4277 valid_addr() 4278 { 4279 short end = 0, eof = 0; 4280 long tcount = count; 4281 4282 if (!trapped) 4283 return (1); 4284 if (cur_bytes < 0) { 4285 cur_bytes = 0; 4286 if (blocksize > filesize) { 4287 printf("beginning of file\n"); 4288 } else { 4289 if (type == BLOCK) 4290 printf("beginning of block\n"); 4291 else 4292 printf("beginning of fragment\n"); 4293 } 4294 error++; 4295 return (0); 4296 } 4297 count = 1; 4298 (void) check_addr(1, &end, &eof, (filesize < blocksize)); 4299 count = tcount; 4300 if (eof) { 4301 printf("end of file\n"); 4302 error++; 4303 return (0); 4304 } 4305 if (end == 2) { 4306 if (erraddr > addr) { 4307 if (type == BLOCK) 4308 printf("beginning of block\n"); 4309 else 4310 printf("beginning of fragment\n"); 4311 error++; 4312 return (0); 4313 } 4314 } 4315 if (end) { 4316 if (type == BLOCK) 4317 printf("end of block\n"); 4318 else 4319 printf("end of fragment\n"); 4320 error++; 4321 return (0); 4322 } 4323 return (1); 4324 } 4325 4326 /* 4327 * check_addr - check if the address crosses the end of block or 4328 * end of file. Return the proper count. 4329 */ 4330 static int 4331 check_addr(short eof_flag, short *end, short *eof, short keep_on) 4332 { 4333 long temp, tcount = count, tcur_bytes = cur_bytes; 4334 u_offset_t taddr = addr; 4335 4336 if (bcomp(addr + count * objsz - 1) || 4337 (keep_on && taddr < (bmap(cur_block) << FRGSHIFT))) { 4338 error = 0; 4339 addr = taddr; 4340 cur_bytes = tcur_bytes; 4341 if (keep_on) { 4342 if (addr < erraddr) { 4343 if (cur_bytes < 0) { 4344 (*end) = 2; 4345 return (0); /* Value ignored */ 4346 } 4347 temp = cur_block - lblkno(fs, cur_bytes); 4348 cur_block -= temp; 4349 if ((addr = bmap(cur_block) << FRGSHIFT) == 0) { 4350 cur_block += temp; 4351 return (0); /* Value ignored */ 4352 } 4353 temp = tcur_bytes - cur_bytes; 4354 addr += temp; 4355 cur_bytes += temp; 4356 return (0); /* Value ignored */ 4357 } else { 4358 if (cur_bytes >= filesize) { 4359 (*eof)++; 4360 return (0); /* Value ignored */ 4361 } 4362 temp = lblkno(fs, cur_bytes) - cur_block; 4363 cur_block += temp; 4364 if ((addr = bmap(cur_block) << FRGSHIFT) == 0) { 4365 cur_block -= temp; 4366 return (0); /* Value ignored */ 4367 } 4368 temp = tcur_bytes - cur_bytes; 4369 addr += temp; 4370 cur_bytes += temp; 4371 return (0); /* Value ignored */ 4372 } 4373 } 4374 tcount = (blkroundup(fs, addr+1)-addr) / objsz; 4375 if (!star) 4376 (*end) = 2; 4377 } 4378 addr = taddr; 4379 cur_bytes = tcur_bytes; 4380 if (eof_flag) { 4381 if (blocksize > filesize) { 4382 if (cur_bytes >= filesize) { 4383 tcount = 0; 4384 (*eof)++; 4385 } else if (tcount > (filesize - cur_bytes) / objsz) { 4386 tcount = (filesize - cur_bytes) / objsz; 4387 if (!star || tcount == 0) 4388 (*eof)++; 4389 } 4390 } else { 4391 if (cur_bytes >= blocksize) { 4392 tcount = 0; 4393 (*end)++; 4394 } else if (tcount > (blocksize - cur_bytes) / objsz) { 4395 tcount = (blocksize - cur_bytes) / objsz; 4396 if (!star || tcount == 0) 4397 (*end)++; 4398 } 4399 } 4400 } 4401 return (tcount); 4402 } 4403 4404 /* 4405 * print_check - check if the index needs to be printed and delete 4406 * rows of zeros from the output. 4407 */ 4408 unsigned long * 4409 print_check(unsigned long *lptr, long *tcount, short tbase, int i) 4410 { 4411 int j, k, temp = BYTESPERLINE / objsz; 4412 short first_time = 0; 4413 unsigned long *tlptr; 4414 unsigned short *tsptr, *sptr; 4415 4416 sptr = (unsigned short *)lptr; 4417 if (i == 0) 4418 first_time = 1; 4419 if (i % temp == 0) { 4420 if (*tcount >= temp - 1) { 4421 if (objsz == SHORT) 4422 tsptr = sptr; 4423 else 4424 tlptr = lptr; 4425 k = *tcount - 1; 4426 for (j = i; k--; j++) 4427 if (objsz == SHORT) { 4428 if (*tsptr++ != 0) 4429 break; 4430 } else { 4431 if (*tlptr++ != 0) 4432 break; 4433 } 4434 if (j > (i + temp - 1)) { 4435 j = (j - i) / temp; 4436 while (j-- > 0) { 4437 if (objsz == SHORT) 4438 sptr += temp; 4439 else 4440 lptr += temp; 4441 *tcount -= temp; 4442 i += temp; 4443 addr += BYTESPERLINE; 4444 cur_bytes += BYTESPERLINE; 4445 } 4446 if (first_time) 4447 printf("*"); 4448 else 4449 printf("\n*"); 4450 } 4451 if (i) 4452 printf("\n"); 4453 index(tbase); 4454 } else { 4455 if (i) 4456 printf("\n"); 4457 index(tbase); 4458 } 4459 } 4460 if (objsz == SHORT) 4461 /*LINTED*/ 4462 return ((unsigned long *)sptr); 4463 else 4464 return (lptr); 4465 } 4466 4467 /* 4468 * index - print a byte index for the printout in base b 4469 * with leading zeros. 4470 */ 4471 static void 4472 index(int b) 4473 { 4474 int tbase = base; 4475 4476 base = b; 4477 print(addr, 8, 8, 1); 4478 printf(":\t"); 4479 base = tbase; 4480 } 4481 4482 /* 4483 * print - print out the value to digits places with/without 4484 * leading zeros and right/left justified in the current base. 4485 */ 4486 static void 4487 #ifdef _LARGEFILE64_SOURCE 4488 printll(u_offset_t value, int fieldsz, int digits, int lead) 4489 #else /* !_LARGEFILE64_SOURCE */ 4490 print(long value, int fieldsz, int digits, int lead) 4491 #endif /* _LARGEFILE64_SOURCE */ 4492 { 4493 int i, left = 0; 4494 char mode = BASE[base - OCTAL]; 4495 char *string = &scratch[0]; 4496 4497 if (digits < 0) { 4498 left = 1; 4499 digits *= -1; 4500 } 4501 if (base != HEX) 4502 if (digits) 4503 digits = digits + (digits - 1)/((base >> 1) - 1) + 1; 4504 else 4505 digits = 1; 4506 if (lead) { 4507 if (left) 4508 (void) sprintf(string, "%%%c%d%d.%d" 4509 #ifdef _LARGEFILE64_SOURCE 4510 "ll" 4511 #endif /* _LARGEFILE64_SOURCE */ 4512 "%c", '-', 0, digits, lead, mode); 4513 else 4514 (void) sprintf(string, "%%%d%d.%d" 4515 #ifdef _LARGEFILE64_SOURCE 4516 "ll" 4517 #endif /* _LARGEFILE64_SOURCE */ 4518 "%c", 0, digits, lead, mode); 4519 } else { 4520 if (left) 4521 (void) sprintf(string, "%%%c%d" 4522 #ifdef _LARGEFILE64_SOURCE 4523 "ll" 4524 #endif /* _LARGEFILE64_SOURCE */ 4525 "%c", '-', digits, mode); 4526 else 4527 (void) sprintf(string, "%%%d" 4528 #ifdef _LARGEFILE64_SOURCE 4529 "ll" 4530 #endif /* _LARGEFILE64_SOURCE */ 4531 "%c", digits, mode); 4532 } 4533 printf(string, value); 4534 for (i = 0; i < fieldsz - digits; i++) 4535 printf(" "); 4536 } 4537 4538 /* 4539 * Print out the contents of a superblock. 4540 */ 4541 static void 4542 printsb(struct fs *fs) 4543 { 4544 int c, i, j, k, size; 4545 caddr_t sip; 4546 time_t t; 4547 4548 t = fs->fs_time; 4549 #ifdef FS_42POSTBLFMT 4550 if (fs->fs_postblformat == FS_42POSTBLFMT) 4551 fs->fs_nrpos = 8; 4552 printf("magic\t%lx\tformat\t%s\ttime\t%s", fs->fs_magic, 4553 fs->fs_postblformat == FS_42POSTBLFMT ? "static" : "dynamic", 4554 ctime(&t)); 4555 #else 4556 printf("magic\t%x\ttime\t%s", 4557 fs->fs_magic, ctime(&t)); 4558 #endif 4559 printf("version\t%x\n", fs->fs_version); 4560 printf("nbfree\t%ld\tndir\t%ld\tnifree\t%ld\tnffree\t%ld\n", 4561 fs->fs_cstotal.cs_nbfree, fs->fs_cstotal.cs_ndir, 4562 fs->fs_cstotal.cs_nifree, fs->fs_cstotal.cs_nffree); 4563 printf("ncg\t%ld\tncyl\t%ld\tsize\t%ld\tblocks\t%ld\n", 4564 fs->fs_ncg, fs->fs_ncyl, fs->fs_size, fs->fs_dsize); 4565 printf("bsize\t%ld\tshift\t%ld\tmask\t0x%08lx\n", 4566 fs->fs_bsize, fs->fs_bshift, fs->fs_bmask); 4567 printf("fsize\t%ld\tshift\t%ld\tmask\t0x%08lx\n", 4568 fs->fs_fsize, fs->fs_fshift, fs->fs_fmask); 4569 printf("frag\t%ld\tshift\t%ld\tfsbtodb\t%ld\n", 4570 fs->fs_frag, fs->fs_fragshift, fs->fs_fsbtodb); 4571 printf("cpg\t%ld\tbpg\t%ld\tfpg\t%ld\tipg\t%ld\n", 4572 fs->fs_cpg, fs->fs_fpg / fs->fs_frag, fs->fs_fpg, fs->fs_ipg); 4573 printf("minfree\t%ld%%\toptim\t%s\tmaxcontig %ld\tmaxbpg\t%ld\n", 4574 fs->fs_minfree, fs->fs_optim == FS_OPTSPACE ? "space" : "time", 4575 fs->fs_maxcontig, fs->fs_maxbpg); 4576 #ifdef FS_42POSTBLFMT 4577 #ifdef sun 4578 printf("rotdelay %ldms\tfs_id[0] 0x%lx\tfs_id[1] 0x%lx\trps\t%ld\n", 4579 fs->fs_rotdelay, fs->fs_id[0], fs->fs_id[1], fs->fs_rps); 4580 #else 4581 printf("rotdelay %dms\theadswitch %dus\ttrackseek %dus\trps\t%d\n", 4582 fs->fs_rotdelay, fs->fs_headswitch, fs->fs_trkseek, fs->fs_rps); 4583 #endif /* sun */ 4584 printf("ntrak\t%ld\tnsect\t%ld\tnpsect\t%ld\tspc\t%ld\n", 4585 fs->fs_ntrak, fs->fs_nsect, fs->fs_npsect, fs->fs_spc); 4586 printf("trackskew %ld\n", fs->fs_trackskew); 4587 #else 4588 printf("rotdelay %ldms\trps\t%ld\n", 4589 fs->fs_rotdelay, fs->fs_rps); 4590 printf("ntrak\t%ld\tnsect\t%ld\tspc\t%ld\n", 4591 fs->fs_ntrak, fs->fs_nsect, fs->fs_spc); 4592 #endif 4593 printf("si %ld\n", fs->fs_si); 4594 printf("nindir\t%ld\tinopb\t%ld\tnspf\t%ld\n", 4595 fs->fs_nindir, fs->fs_inopb, fs->fs_nspf); 4596 printf("sblkno\t%ld\tcblkno\t%ld\tiblkno\t%ld\tdblkno\t%ld\n", 4597 fs->fs_sblkno, fs->fs_cblkno, fs->fs_iblkno, fs->fs_dblkno); 4598 printf("sbsize\t%ld\tcgsize\t%ld\tcgoffset %ld\tcgmask\t0x%08lx\n", 4599 fs->fs_sbsize, fs->fs_cgsize, fs->fs_cgoffset, fs->fs_cgmask); 4600 printf("csaddr\t%ld\tcssize\t%ld\tshift\t%ld\tmask\t0x%08lx\n", 4601 fs->fs_csaddr, fs->fs_cssize, fs->fs_csshift, fs->fs_csmask); 4602 printf("cgrotor\t%ld\tfmod\t%d\tronly\t%d\n", 4603 fs->fs_cgrotor, fs->fs_fmod, fs->fs_ronly); 4604 #ifdef FS_42POSTBLFMT 4605 if (fs->fs_cpc != 0) 4606 printf("blocks available in each of %ld rotational positions", 4607 fs->fs_nrpos); 4608 else 4609 printf("insufficient space to maintain rotational tables\n"); 4610 #endif 4611 for (c = 0; c < fs->fs_cpc; c++) { 4612 printf("\ncylinder number %d:", c); 4613 #ifdef FS_42POSTBLFMT 4614 for (i = 0; i < fs->fs_nrpos; i++) { 4615 /*LINTED*/ 4616 if (fs_postbl(fs, c)[i] == -1) 4617 continue; 4618 printf("\n position %d:\t", i); 4619 /*LINTED*/ 4620 for (j = fs_postbl(fs, c)[i], k = 1; /* void */; 4621 j += fs_rotbl(fs)[j], k++) { 4622 printf("%5d", j); 4623 if (k % 12 == 0) 4624 printf("\n\t\t"); 4625 if (fs_rotbl(fs)[j] == 0) 4626 break; 4627 } 4628 } 4629 #else 4630 for (i = 0; i < NRPOS; i++) { 4631 if (fs->fs_postbl[c][i] == -1) 4632 continue; 4633 printf("\n position %d:\t", i); 4634 for (j = fs->fs_postbl[c][i], k = 1; /* void */; 4635 j += fs->fs_rotbl[j], k++) { 4636 printf("%5d", j); 4637 if (k % 12 == 0) 4638 printf("\n\t\t"); 4639 if (fs->fs_rotbl[j] == 0) 4640 break; 4641 } 4642 } 4643 #endif 4644 } 4645 printf("\ncs[].cs_(nbfree, ndir, nifree, nffree):"); 4646 sip = calloc(1, fs->fs_cssize); 4647 fs->fs_u.fs_csp = (struct csum *)sip; 4648 for (i = 0, j = 0; i < fs->fs_cssize; i += fs->fs_bsize, j++) { 4649 size = fs->fs_cssize - i < fs->fs_bsize ? 4650 fs->fs_cssize - i : fs->fs_bsize; 4651 (void) llseek(fd, 4652 (offset_t)fsbtodb(fs, (fs->fs_csaddr + j * fs->fs_frag)) 4653 * fs->fs_fsize / fsbtodb(fs, 1), 0); 4654 if (read(fd, sip, size) != size) { 4655 free(fs->fs_u.fs_csp); 4656 return; 4657 } 4658 sip += size; 4659 } 4660 for (i = 0; i < fs->fs_ncg; i++) { 4661 struct csum *cs = &fs->fs_cs(fs, i); 4662 if (i % 4 == 0) 4663 printf("\n "); 4664 printf("%d:(%ld,%ld,%ld,%ld) ", i, cs->cs_nbfree, cs->cs_ndir, 4665 cs->cs_nifree, cs->cs_nffree); 4666 } 4667 free(fs->fs_u.fs_csp); 4668 printf("\n"); 4669 if (fs->fs_ncyl % fs->fs_cpg) { 4670 printf("cylinders in last group %d\n", 4671 i = fs->fs_ncyl % fs->fs_cpg); 4672 printf("blocks in last group %ld\n", 4673 i * fs->fs_spc / NSPB(fs)); 4674 } 4675 } 4676 4677 /* 4678 * Print out the contents of a cylinder group. 4679 */ 4680 static void 4681 printcg(struct cg *cg) 4682 { 4683 int i, j; 4684 time_t t; 4685 4686 printf("\ncg %ld:\n", cg->cg_cgx); 4687 t = cg->cg_time; 4688 #ifdef FS_42POSTBLFMT 4689 printf("magic\t%lx\ttell\t%llx\ttime\t%s", 4690 fs->fs_postblformat == FS_42POSTBLFMT ? 4691 ((struct ocg *)cg)->cg_magic : cg->cg_magic, 4692 fsbtodb(fs, cgtod(fs, cg->cg_cgx)) * fs->fs_fsize / fsbtodb(fs, 1), 4693 ctime(&t)); 4694 #else 4695 printf("magic\t%x\ttell\t%llx\ttime\t%s", 4696 cg->cg_magic, 4697 fsbtodb(fs, cgtod(fs, cg->cg_cgx)) * fs->fs_fsize / fsbtodb(fs, 1), 4698 ctime(&t)); 4699 #endif 4700 printf("cgx\t%ld\tncyl\t%d\tniblk\t%d\tndblk\t%ld\n", 4701 cg->cg_cgx, cg->cg_ncyl, cg->cg_niblk, cg->cg_ndblk); 4702 printf("nbfree\t%ld\tndir\t%ld\tnifree\t%ld\tnffree\t%ld\n", 4703 cg->cg_cs.cs_nbfree, cg->cg_cs.cs_ndir, 4704 cg->cg_cs.cs_nifree, cg->cg_cs.cs_nffree); 4705 printf("rotor\t%ld\tirotor\t%ld\tfrotor\t%ld\nfrsum", 4706 cg->cg_rotor, cg->cg_irotor, cg->cg_frotor); 4707 for (i = 1, j = 0; i < fs->fs_frag; i++) { 4708 printf("\t%ld", cg->cg_frsum[i]); 4709 j += i * cg->cg_frsum[i]; 4710 } 4711 printf("\nsum of frsum: %d\niused:\t", j); 4712 pbits((unsigned char *)cg_inosused(cg), fs->fs_ipg); 4713 printf("free:\t"); 4714 pbits(cg_blksfree(cg), fs->fs_fpg); 4715 printf("b:\n"); 4716 for (i = 0; i < fs->fs_cpg; i++) { 4717 /*LINTED*/ 4718 if (cg_blktot(cg)[i] == 0) 4719 continue; 4720 /*LINTED*/ 4721 printf(" c%d:\t(%ld)\t", i, cg_blktot(cg)[i]); 4722 #ifdef FS_42POSTBLFMT 4723 for (j = 0; j < fs->fs_nrpos; j++) { 4724 if (fs->fs_cpc == 0 || 4725 /*LINTED*/ 4726 fs_postbl(fs, i % fs->fs_cpc)[j] == -1) 4727 continue; 4728 /*LINTED*/ 4729 printf(" %d", cg_blks(fs, cg, i)[j]); 4730 } 4731 #else 4732 for (j = 0; j < NRPOS; j++) { 4733 if (fs->fs_cpc == 0 || 4734 fs->fs_postbl[i % fs->fs_cpc][j] == -1) 4735 continue; 4736 printf(" %d", cg->cg_b[i][j]); 4737 } 4738 #endif 4739 printf("\n"); 4740 } 4741 } 4742 4743 /* 4744 * Print out the contents of a bit array. 4745 */ 4746 static void 4747 pbits(unsigned char *cp, int max) 4748 { 4749 int i; 4750 int count = 0, j; 4751 4752 for (i = 0; i < max; i++) 4753 if (isset(cp, i)) { 4754 if (count) 4755 printf(",%s", count % 6 ? " " : "\n\t"); 4756 count++; 4757 printf("%d", i); 4758 j = i; 4759 while ((i+1) < max && isset(cp, i+1)) 4760 i++; 4761 if (i != j) 4762 printf("-%d", i); 4763 } 4764 printf("\n"); 4765 } 4766 4767 /* 4768 * bcomp - used to check for block over/under flows when stepping through 4769 * a file system. 4770 */ 4771 static int 4772 bcomp(addr) 4773 u_offset_t addr; 4774 { 4775 if (override) 4776 return (0); 4777 4778 if (lblkno(fs, addr) == (bhdr.fwd)->blkno) 4779 return (0); 4780 error++; 4781 return (1); 4782 } 4783 4784 /* 4785 * bmap - maps the logical block number of a file into 4786 * the corresponding physical block on the file 4787 * system. 4788 */ 4789 static long 4790 bmap(long bn) 4791 { 4792 int j; 4793 struct dinode *ip; 4794 int sh; 4795 long nb; 4796 char *cptr; 4797 4798 if ((cptr = getblk(cur_ino)) == 0) 4799 return (0); 4800 4801 cptr += blkoff(fs, cur_ino); 4802 4803 /*LINTED*/ 4804 ip = (struct dinode *)cptr; 4805 4806 if (bn < NDADDR) { 4807 nb = ip->di_db[bn]; 4808 return (nullblk(nb) ? 0L : nb); 4809 } 4810 4811 sh = 1; 4812 bn -= NDADDR; 4813 for (j = NIADDR; j > 0; j--) { 4814 sh *= NINDIR(fs); 4815 if (bn < sh) 4816 break; 4817 bn -= sh; 4818 } 4819 if (j == 0) { 4820 printf("file too big\n"); 4821 error++; 4822 return (0L); 4823 } 4824 addr = (uintptr_t)&ip->di_ib[NIADDR - j]; 4825 nb = get(LONG); 4826 if (nb == 0) 4827 return (0L); 4828 for (; j <= NIADDR; j++) { 4829 sh /= NINDIR(fs); 4830 addr = (nb << FRGSHIFT) + ((bn / sh) % NINDIR(fs)) * LONG; 4831 if (nullblk(nb = get(LONG))) 4832 return (0L); 4833 } 4834 return (nb); 4835 } 4836 4837 #if defined(OLD_FSDB_COMPATIBILITY) 4838 4839 /* 4840 * The following are "tacked on" to support the old fsdb functionality 4841 * of clearing an inode. (All together now...) "It's better to use clri". 4842 */ 4843 4844 #define ISIZE (sizeof (struct dinode)) 4845 #define NI (MAXBSIZE/ISIZE) 4846 4847 4848 static struct dinode di_buf[NI]; 4849 4850 static union { 4851 char dummy[SBSIZE]; 4852 struct fs sblk; 4853 } sb_un; 4854 4855 #define sblock sb_un.sblk 4856 4857 static void 4858 old_fsdb(int inum, char *special) 4859 { 4860 int f; /* File descriptor for "special" */ 4861 int j; 4862 int status = 0; 4863 u_offset_t off; 4864 long gen; 4865 time_t t; 4866 4867 f = open(special, 2); 4868 if (f < 0) { 4869 perror("open"); 4870 printf("cannot open %s\n", special); 4871 exit(31+4); 4872 } 4873 (void) llseek(f, (offset_t)SBLOCK * DEV_BSIZE, 0); 4874 if (read(f, &sblock, SBSIZE) != SBSIZE) { 4875 printf("cannot read %s\n", special); 4876 exit(31+4); 4877 } 4878 if (sblock.fs_magic != FS_MAGIC) { 4879 printf("bad super block magic number\n"); 4880 exit(31+4); 4881 } 4882 if (inum == 0) { 4883 printf("%d: is zero\n", inum); 4884 exit(31+1); 4885 } 4886 off = (u_offset_t)fsbtodb(&sblock, itod(&sblock, inum)) * DEV_BSIZE; 4887 (void) llseek(f, off, 0); 4888 if (read(f, (char *)di_buf, sblock.fs_bsize) != sblock.fs_bsize) { 4889 printf("%s: read error\n", special); 4890 status = 1; 4891 } 4892 if (status) 4893 exit(31+status); 4894 4895 /* 4896 * Update the time in superblock, so fsck will check this filesystem. 4897 */ 4898 (void) llseek(f, (offset_t)(SBLOCK * DEV_BSIZE), 0); 4899 (void) time(&t); 4900 sblock.fs_time = (time32_t)t; 4901 if (write(f, &sblock, SBSIZE) != SBSIZE) { 4902 printf("cannot update %s\n", special); 4903 exit(35); 4904 } 4905 4906 printf("clearing %u\n", inum); 4907 off = (u_offset_t)fsbtodb(&sblock, itod(&sblock, inum)) * DEV_BSIZE; 4908 (void) llseek(f, off, 0); 4909 read(f, (char *)di_buf, sblock.fs_bsize); 4910 j = itoo(&sblock, inum); 4911 gen = di_buf[j].di_gen; 4912 (void) memset((caddr_t)&di_buf[j], 0, ISIZE); 4913 di_buf[j].di_gen = gen + 1; 4914 (void) llseek(f, off, 0); 4915 write(f, (char *)di_buf, sblock.fs_bsize); 4916 exit(31+status); 4917 } 4918 4919 static int 4920 isnumber(char *s) 4921 { 4922 register int c; 4923 4924 if (s == NULL) 4925 return (0); 4926 while ((c = *s++) != NULL) 4927 if (c < '0' || c > '9') 4928 return (0); 4929 return (1); 4930 } 4931 #endif /* OLD_FSDB_COMPATIBILITY */ 4932 4933 enum boolean { True, False }; 4934 extent_block_t *log_eb; 4935 ml_odunit_t *log_odi; 4936 int lufs_tid; /* last valid TID seen */ 4937 4938 /* 4939 * no single value is safe to use to indicate 4940 * lufs_tid being invalid so we need a 4941 * seperate variable. 4942 */ 4943 enum boolean lufs_tid_valid; 4944 4945 /* 4946 * log_get_header_info - get the basic info of the logging filesystem 4947 */ 4948 int 4949 log_get_header_info(void) 4950 { 4951 char *b; 4952 int nb; 4953 4954 /* 4955 * Mark the global tid as invalid everytime we're called to 4956 * prevent any false positive responses. 4957 */ 4958 lufs_tid_valid = False; 4959 4960 /* 4961 * See if we've already set up the header areas. The only problem 4962 * with this approach is we don't reread the on disk data though 4963 * it shouldn't matter since we don't operate on a live disk. 4964 */ 4965 if ((log_eb != NULL) && (log_odi != NULL)) 4966 return (1); 4967 4968 /* 4969 * Either logging is disabled or we've not running 2.7. 4970 */ 4971 if (fs->fs_logbno == 0) { 4972 printf("Logging doesn't appear to be enabled on this disk\n"); 4973 return (0); 4974 } 4975 4976 /* 4977 * To find the log we need to first pick up the block allocation 4978 * data. The block number for that data is fs_logbno in the 4979 * super block. 4980 */ 4981 if ((b = getblk((u_offset_t)ldbtob(logbtodb(fs, fs->fs_logbno)))) 4982 == 0) { 4983 printf("getblk() indicates an error with logging block\n"); 4984 return (0); 4985 } 4986 4987 /* 4988 * Next we need to figure out how big the extent data structure 4989 * really is. It can't be more then fs_bsize and you could just 4990 * allocate that but, why get sloppy. 4991 * 1 is subtracted from nextents because extent_block_t contains 4992 * a single extent_t itself. 4993 */ 4994 log_eb = (extent_block_t *)b; 4995 if (log_eb->type != LUFS_EXTENTS) { 4996 printf("Extents block has invalid type (0x%x)\n", 4997 log_eb->type); 4998 return (0); 4999 } 5000 nb = sizeof (extent_block_t) + 5001 (sizeof (extent_t) * (log_eb->nextents - 1)); 5002 5003 log_eb = (extent_block_t *)malloc(nb); 5004 if (log_eb == NULL) { 5005 printf("Failed to allocate memory for extent block log\n"); 5006 return (0); 5007 } 5008 memcpy(log_eb, b, nb); 5009 5010 if (log_eb->nextbno != 0) 5011 /* 5012 * Currently, as of 11-Dec-1997 the field nextbno isn't 5013 * implemented. If someone starts using this sucker we'd 5014 * better warn somebody. 5015 */ 5016 printf("WARNING: extent block field nextbno is non-zero!\n"); 5017 5018 /* 5019 * Now read in the on disk log structure. This is always in the 5020 * first block of the first extent. 5021 */ 5022 b = getblk((u_offset_t)ldbtob(logbtodb(fs, log_eb->extents[0].pbno))); 5023 log_odi = (ml_odunit_t *)malloc(sizeof (ml_odunit_t)); 5024 if (log_odi == NULL) { 5025 free(log_eb); 5026 log_eb = NULL; 5027 printf("Failed to allocate memory for ondisk structure\n"); 5028 return (0); 5029 } 5030 memcpy(log_odi, b, sizeof (ml_odunit_t)); 5031 5032 /* 5033 * Consistency checks. 5034 */ 5035 if (log_odi->od_version != LUFS_VERSION_LATEST) { 5036 free(log_eb); 5037 log_eb = NULL; 5038 free(log_odi); 5039 log_odi = NULL; 5040 printf("Version mismatch in on-disk version of log data\n"); 5041 return (0); 5042 } else if (log_odi->od_badlog) { 5043 printf("WARNING: Log was marked as bad\n"); 5044 } 5045 5046 return (1); 5047 } 5048 5049 static void 5050 log_display_header(void) 5051 { 5052 int x; 5053 if (!log_get_header_info()) 5054 /* 5055 * No need to display anything here. The previous routine 5056 * has already done so. 5057 */ 5058 return; 5059 5060 if (fs->fs_magic == FS_MAGIC) 5061 printf("Log block number: 0x%x\n------------------\n", 5062 fs->fs_logbno); 5063 else 5064 printf("Log frag number: 0x%x\n------------------\n", 5065 fs->fs_logbno); 5066 printf("Extent Info\n\t# Extents : %d\n\t# Bytes : 0x%x\n", 5067 log_eb->nextents, log_eb->nbytes); 5068 printf("\tNext Block : 0x%x\n\tExtent List\n\t--------\n", 5069 log_eb->nextbno); 5070 for (x = 0; x < log_eb->nextents; x++) 5071 printf("\t [%d] lbno 0x%08x pbno 0x%08x nbno 0x%08x\n", 5072 x, log_eb->extents[x].lbno, log_eb->extents[x].pbno, 5073 log_eb->extents[x].nbno); 5074 printf("\nOn Disk Info\n\tbol_lof : 0x%08x\n\teol_lof : 0x%08x\n", 5075 log_odi->od_bol_lof, log_odi->od_eol_lof); 5076 printf("\tlog_size : 0x%08x\n", 5077 log_odi->od_logsize); 5078 printf("\thead_lof : 0x%08x\tident : 0x%x\n", 5079 log_odi->od_head_lof, log_odi->od_head_ident); 5080 printf("\ttail_lof : 0x%08x\tident : 0x%x\n\thead_tid : 0x%08x\n", 5081 log_odi->od_tail_lof, log_odi->od_tail_ident, log_odi->od_head_tid); 5082 printf("\tcheck sum : 0x%08x\n", log_odi->od_chksum); 5083 if (log_odi->od_chksum != 5084 (log_odi->od_head_ident + log_odi->od_tail_ident)) 5085 printf("bad checksum: found 0x%08x, should be 0x%08x\n", 5086 log_odi->od_chksum, 5087 log_odi->od_head_ident + log_odi->od_tail_ident); 5088 if (log_odi->od_head_lof == log_odi->od_tail_lof) 5089 printf("\t --- Log is empty ---\n"); 5090 } 5091 5092 /* 5093 * log_lodb -- logical log offset to disk block number 5094 */ 5095 int 5096 log_lodb(u_offset_t off, diskaddr_t *pblk) 5097 { 5098 uint32_t lblk = (uint32_t)btodb(off); 5099 int x; 5100 5101 if (!log_get_header_info()) 5102 /* 5103 * No need to display anything here. The previous routine 5104 * has already done so. 5105 */ 5106 return (0); 5107 5108 for (x = 0; x < log_eb->nextents; x++) 5109 if ((lblk >= log_eb->extents[x].lbno) && 5110 (lblk < (log_eb->extents[x].lbno + 5111 log_eb->extents[x].nbno))) { 5112 *pblk = (diskaddr_t)lblk - log_eb->extents[x].lbno + 5113 logbtodb(fs, log_eb->extents[x].pbno); 5114 return (1); 5115 } 5116 return (0); 5117 } 5118 5119 /* 5120 * String names for the enumerated types. These are only used 5121 * for display purposes. 5122 */ 5123 char *dt_str[] = { 5124 "DT_NONE", "DT_SB", "DT_CG", "DT_SI", "DT_AB", 5125 "DT_ABZERO", "DT_DIR", "DT_INODE", "DT_FBI", 5126 "DT_QR", "DT_COMMIT", "DT_CANCEL", "DT_BOT", 5127 "DT_EOT", "DT_UD", "DT_SUD", "DT_SHAD", "DT_MAX" 5128 }; 5129 5130 /* 5131 * log_read_log -- transfer information from the log and adjust offset 5132 */ 5133 int 5134 log_read_log(u_offset_t *addr, caddr_t va, int nb, uint32_t *chk) 5135 { 5136 int xfer; 5137 caddr_t bp; 5138 diskaddr_t pblk; 5139 sect_trailer_t *st; 5140 5141 while (nb) { 5142 if (!log_lodb(*addr, &pblk)) { 5143 printf("Invalid log offset\n"); 5144 return (0); 5145 } 5146 5147 /* 5148 * fsdb getblk() expects offsets not block number. 5149 */ 5150 if ((bp = getblk((u_offset_t)dbtob(pblk))) == NULL) 5151 return (0); 5152 5153 xfer = MIN(NB_LEFT_IN_SECTOR(*addr), nb); 5154 if (va != NULL) { 5155 memcpy(va, bp + blkoff(fs, *addr), xfer); 5156 va += xfer; 5157 } 5158 nb -= xfer; 5159 *addr += xfer; 5160 5161 /* 5162 * If the log offset is now at a sector trailer 5163 * run the checks if requested. 5164 */ 5165 if (NB_LEFT_IN_SECTOR(*addr) == 0) { 5166 if (chk != NULL) { 5167 st = (sect_trailer_t *) 5168 (bp + blkoff(fs, *addr)); 5169 if (*chk != st->st_ident) { 5170 printf( 5171 "Expected sector trailer id 0x%08x, but saw 0x%08x\n", 5172 *chk, st->st_ident); 5173 return (0); 5174 } else { 5175 *chk = st->st_ident + 1; 5176 /* 5177 * We update the on disk structure 5178 * transaction ID each time we see 5179 * one. By comparing this value 5180 * to the last valid DT_COMMIT record 5181 * we can determine if our log is 5182 * completely valid. 5183 */ 5184 log_odi->od_head_tid = st->st_tid; 5185 } 5186 } 5187 *addr += sizeof (sect_trailer_t); 5188 } 5189 if ((int32_t)*addr == log_odi->od_eol_lof) 5190 *addr = log_odi->od_bol_lof; 5191 } 5192 return (1); 5193 } 5194 5195 u_offset_t 5196 log_nbcommit(u_offset_t a) 5197 { 5198 /* 5199 * Comments are straight from ufs_log.c 5200 * 5201 * log is the offset following the commit header. However, 5202 * if the commit header fell on the end-of-sector, then lof 5203 * has already been advanced to the beginning of the next 5204 * sector. So do nothgin. Otherwise, return the remaining 5205 * bytes in the sector. 5206 */ 5207 if ((a & (DEV_BSIZE - 1)) == 0) 5208 return (0); 5209 else 5210 return (NB_LEFT_IN_SECTOR(a)); 5211 } 5212 5213 /* 5214 * log_show -- pretty print the deltas. The number of which is determined 5215 * by the log_enum arg. If LOG_ALLDELTAS the routine, as the 5216 * name implies dumps everything. If LOG_NDELTAS, the routine 5217 * will print out "count" deltas starting at "addr". If 5218 * LOG_CHECKSCAN then run through the log checking the st_ident 5219 * for valid data. 5220 */ 5221 static void 5222 log_show(enum log_enum l) 5223 { 5224 struct delta d; 5225 int32_t bol, eol; 5226 int x = 0; 5227 uint32_t chk; 5228 5229 if (!log_get_header_info()) 5230 /* 5231 * No need to display any error messages here. The previous 5232 * routine has already done so. 5233 */ 5234 return; 5235 5236 bol = log_odi->od_head_lof; 5237 eol = log_odi->od_tail_lof; 5238 chk = log_odi->od_head_ident; 5239 5240 if (bol == eol) { 5241 if ((l == LOG_ALLDELTAS) || (l == LOG_CHECKSCAN)) { 5242 printf("Empty log.\n"); 5243 return; 5244 } else 5245 printf("WARNING: empty log. addr may generate bogus" 5246 " information"); 5247 } 5248 5249 /* 5250 * Only reset the "addr" if we've been requested to show all 5251 * deltas in the log. 5252 */ 5253 if ((l == LOG_ALLDELTAS) || (l == LOG_CHECKSCAN)) 5254 addr = (u_offset_t)bol; 5255 5256 if (l != LOG_CHECKSCAN) { 5257 printf(" Log Offset Delta Count Type\n"); 5258 printf("-----------------------------------------" 5259 "-----------------\n"); 5260 } 5261 5262 while ((bol != eol) && ((l == LOG_ALLDELTAS) || 5263 (l == LOG_CHECKSCAN) || count--)) { 5264 if (!log_read_log(&addr, (caddr_t)&d, sizeof (d), 5265 ((l == LOG_ALLDELTAS) || (l == LOG_CHECKSCAN)) ? 5266 &chk : NULL)) 5267 /* 5268 * Two failures are possible. One from getblk() 5269 * which prints out a message or when we've hit 5270 * an invalid block which may or may not indicate 5271 * an error 5272 */ 5273 goto end_scan; 5274 5275 if ((uint32_t)d.d_nb > log_odi->od_logsize) { 5276 printf("Bad delta entry. size out of bounds\n"); 5277 return; 5278 } 5279 if (l != LOG_CHECKSCAN) 5280 printf("[%04d] %08x %08x.%08x %08x %s\n", x++, bol, 5281 d.d_mof, d.d_nb, 5282 dt_str[d.d_typ >= DT_MAX ? DT_MAX : d.d_typ]); 5283 5284 switch (d.d_typ) { 5285 case DT_CANCEL: 5286 case DT_ABZERO: 5287 /* 5288 * These two deltas don't have log space 5289 * associated with the entry even though 5290 * d_nb is non-zero. 5291 */ 5292 break; 5293 5294 case DT_COMMIT: 5295 /* 5296 * Commit records have zero size yet, the 5297 * rest of the current disk block is avoided. 5298 */ 5299 addr += log_nbcommit(addr); 5300 lufs_tid = log_odi->od_head_tid; 5301 lufs_tid_valid = True; 5302 break; 5303 5304 default: 5305 if (!log_read_log(&addr, NULL, d.d_nb, 5306 ((l == LOG_ALLDELTAS) || 5307 (l == LOG_CHECKSCAN)) ? &chk : NULL)) 5308 goto end_scan; 5309 break; 5310 } 5311 bol = (int32_t)addr; 5312 } 5313 5314 end_scan: 5315 if (lufs_tid_valid == True) { 5316 if (lufs_tid == log_odi->od_head_tid) 5317 printf("scan -- okay\n"); 5318 else 5319 printf("scan -- some transactions have been lost\n"); 5320 } else { 5321 printf("scan -- failed to find a single valid transaction\n"); 5322 printf(" (possibly due to an empty log)\n"); 5323 } 5324 } 5325