| blob | 9214f9277e81537f2a30855b2d382efc0f1ee559 |
1 /*
2 * Copyright 2015 Gary Mills
3 * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
4 */
6 /*
7 * Copyright (c) 1988 Regents of the University of California.
8 * All rights reserved.
9 *
10 * This code is derived from software contributed to Berkeley by
11 * Computer Consoles Inc.
12 *
13 * Redistribution and use in source and binary forms are permitted
14 * provided that: (1) source distributions retain this entire copyright
15 * notice and comment, and (2) distributions including binaries display
16 * the following acknowledgement: ``This product includes software
17 * developed by the University of California, Berkeley and its contributors''
18 * in the documentation or other materials provided with the distribution
19 * and in all advertising materials mentioning features or use of this
20 * software. Neither the name of the University nor the names of its
21 * contributors may be used to endorse or promote products derived
22 * from this software without specific prior written permission.
23 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
24 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
25 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
26 */
32 /*
33 * fsdb - file system debugger
34 *
35 * usage: fsdb [-o suboptions] special
36 * options/suboptions:
37 * -o
38 * ? display usage
39 * o override some error conditions
40 * p="string" set prompt to string
41 * w open for write
42 */
44 #include <sys/param.h>
45 #include <sys/signal.h>
46 #include <sys/file.h>
47 #include <inttypes.h>
49 #include <sys/mkdev.h>
51 #ifdef sun
52 #include <unistd.h>
53 #include <stdlib.h>
54 #include <string.h>
55 #include <fcntl.h>
56 #include <signal.h>
57 #include <sys/types.h>
58 #include <sys/vnode.h>
59 #include <sys/mntent.h>
60 #include <sys/wait.h>
61 #include <sys/fs/ufs_fsdir.h>
62 #include <sys/fs/ufs_fs.h>
63 #include <sys/fs/ufs_inode.h>
64 #include <sys/fs/ufs_acl.h>
65 #include <sys/fs/ufs_log.h>
66 #else
67 #include <sys/dir.h>
68 #include <ufs/fs.h>
69 #include <ufs/dinode.h>
70 #include <paths.h>
73 #include <stdio.h>
74 #include <setjmp.h>
78 #ifndef _PATH_BSHELL
81 /*
82 * Defines from the 4.3-tahoe file system, for systems with the 4.2 or 4.3
83 * file system.
84 */
85 #ifndef FS_42POSTBLFMT
86 #define cg_blktot(cgp) (((cgp))->cg_btot)
87 #define cg_blks(fs, cgp, cylno) (((cgp))->cg_b[cylno])
88 #define cg_inosused(cgp) (((cgp))->cg_iused)
89 #define cg_blksfree(cgp) (((cgp))->cg_free)
90 #define cg_chkmagic(cgp) ((cgp)->cg_magic == CG_MAGIC)
91 #endif
93 /*
94 * Never changing defines.
95 */
100 /*
101 * Adjustable defines.
102 */
114 #if defined(OLD_FSDB_COMPATIBILITY)
116 #else
121 /*
122 * Values dependent on sizes of structs and such.
123 */
128 #define CHAR (sizeof (char))
129 #define SHORT (sizeof (short))
130 #define LONG (sizeof (long))
132 #define INODE (sizeof (struct dinode))
133 #define DIRECTORY (sizeof (struct direct))
134 #define CGRP (sizeof (struct cg))
135 #define SB (sizeof (struct fs))
137 #define FRGSIZE (fs->fs_fsize)
138 #define BLKSHIFT (fs->fs_bshift)
139 #define FRGSHIFT (fs->fs_fshift)
140 #define SHADOW_DATA (sizeof (struct ufs_fsd))
142 /*
143 * Messy macros that would otherwise clutter up such glamorous code.
144 */
145 #define itob(i) (((uoff_t)itod(fs, (i)) << \
146 (uoff_t)FRGSHIFT) + (uoff_t)itoo(fs, (i)) * (uoff_t)INODE)
147 #define min(x, y) ((x) < (y) ? (x) : (y))
148 #define STRINGSIZE(d) ((long)d->d_reclen - \
149 ((long)&d->d_name[0] - (long)&d->d_ino))
160 #if !defined(loword)
161 #define loword(X) (((ushort_t *)&X)[1])
164 #if !defined(lobyte)
165 #define lobyte(X) (((unsigned char *)&X)[1])
168 /*
169 * buffer cache structure.
170 */
176 uoff_t blkno;
179 /*
180 * used to hold save registers (see '<' and '>').
181 */
183 uoff_t sv_addr;
184 uoff_t sv_value;
188 /*
189 * cd, find, and ls use this to hold filenames. Each filename is broken
190 * up by a slash. In other words, /usr/src/adm would have a len field
191 * of 2 (starting from 0), and filenames->fname[0-2] would hold usr,
192 * src, and adm components of the pathname.
193 */
203 #ifdef sun
209 #define filesystem fs_un.un_filesystem
210 #else
214 /*
215 * Global data.
216 */
281 #ifndef sun
283 #endif
314 #ifdef _LARGEFILE64_SOURCE
315 static void printll
317 #define print(value, fieldsz, digits, lead) \
318 printll((uoff_t)value, fieldsz, digits, lead)
345 #ifdef sun
347 #else
351 /* Suboption vector */
353 #define OVERRIDE 0
355 #define NEW_PROMPT 1
357 #define WRITE_ENABLED 2
359 #define ALT_PROMPT 3
361 NULL
362 };
364 /*
365 * main - lines are read up to the unprotected ('\') newline and
366 * held in an input buffer. Characters may be read from the
367 * input buffer using getachar() and unread using ungetachar().
368 * Reading the whole line ahead allows the use of debuggers
369 * which would otherwise be impossible since the debugger
370 * and fsdb could not share stdin.
371 */
373 int
375 {
386 /* Options/Suboptions processing */
391 /*
392 * The following are used to support the old fsdb functionality
393 * of clearing an inode. It's better to use 'clri'.
394 */
401 /*
402 * Parse options.
403 */
406 #if defined(OLD_FSDB_COMPATIBILITY)
416 /* Doesn't return */
421 }
422 /* Should exit() before here */
423 /*NOTREACHED*/
426 /* UFS Specific Options */
436 /*
437 * Change the "-o prompt=foo" option to
438 * "-o p=foo" to match documentation.
439 * ALT_PROMPT continues support for the
440 * undocumented "-o prompt=foo" option so
441 * that we don't break anyone.
442 */
449 }
451 PROMPTSIZE);
455 /* suitable for open */
461 /* Should exit here */
462 }
463 }
468 }
469 }
473 }
476 /*
477 * Unless it's already been set, the default prompt includes the
478 * name of the special device.
479 */
483 /*
484 * Attempt to open the special file.
485 */
489 }
490 /*
491 * Read in the super block and validate (not too picky).
492 */
496 }
498 #ifdef sun
502 }
503 #else
507 }
514 special);
516 }
523 }
527 }
528 }
540 }
547 }
551 }
552 }
553 #ifdef FS_42POSTBLFMT
556 #endif
558 special,
561 #ifdef sun
587 special);
589 }
596 }
600 }
605 }
611 }
613 /*
614 * Malloc buffers and set up cache.
615 */
623 }
624 /*
625 * Malloc filenames structure. The space for the actual filenames
626 * is allocated as it needs it. We estimate the size based on the
627 * number of inodes(objects) in the filesystem and the number of
628 * directories. The number of directories are padded by 3 because
629 * each directory traversed during a "find" or "ls -R" needs 3
630 * entries.
631 */
639 /*
640 * If we could not allocate memory for all of files
641 * in the filesystem then, back off to the old fixed
642 * value.
643 */
650 }
651 }
654 /*
655 * Malloc a few filenames (needed by pwd for example).
656 */
664 }
665 }
672 /*
673 * Main loop and case statement. If an error condition occurs
674 * initialization and recovery is attempted.
675 */
696 }
697 c_count++;
707 }
723 }
726 cur_inum++;
729 cur_inum--;
731 }
735 cur_cgrp++;
738 cur_cgrp--;
740 }
749 }
756 }
757 }
783 }
787 }
809 }
811 error++;
826 colon++;
827 commands++;
845 }
859 }
874 }
882 }
896 }
910 }
925 }
933 }
946 }
968 error++;
970 }
979 calc:
998 }
999 }
1003 }
1019 }
1038 else
1052 {
1053 /*
1054 * Truncation is intentional so
1055 * ctime is happy.
1056 */
1059 }
1069 }
1074 otx:
1079 else
1092 OTX:
1097 else
1107 else
1110 }
1111 }
1120 error++;
1122 }
1141 error++;
1143 }
1158 else
1168 }
1174 else
1182 }
1188 trapped++;
1190 }
1201 }
1203 showbase:
1217 }
1218 }
1221 error++;
1223 }
1228 error++;
1234 }
1236 }
1242 else
1252 }
1265 else
1267 error++;
1268 }
1270 }
1279 error++;
1281 }
1287 }
1295 error++;
1297 }
1302 }
1311 }
1317 else
1326 }
1336 error++;
1338 }
1353 error++;
1354 }
1356 }
1362 else
1367 }
1374 }
1376 FRGSIZE) {
1379 }
1385 trapped++;
1387 }
1401 error++;
1403 }
1404 }
1413 }
1417 error++;
1419 }
1424 error++;
1426 }
1429 }
1435 else
1445 }
1451 else
1462 }
1473 }
1483 error++;
1485 }
1493 }
1499 error++;
1500 }
1502 }
1508 else
1514 }
1519 }
1524 }
1529 }
1536 error++;
1538 }
1555 error++;
1557 }
1564 }
1565 }
1566 c_count++;
1572 }
1579 }
1581 }
1589 error++;
1590 }
1593 }
1602 }
1608 else
1621 }
1630 }
1638 {
1642 }
1645 }
1653 {
1657 }
1660 }
1666 else
1674 /*LINTED*/
1683 }
1689 else
1695 else
1698 }
1704 else
1710 }
1714 error++;
1716 }
1719 error++;
1721 }
1728 error++;
1730 }
1731 }
1734 }
1742 error++;
1744 }
1746 }
1752 else
1762 }
1769 error++;
1771 }
1776 }
1784 }
1793 }
1806 }
1812 else
1822 }
1828 else
1838 no_colon:
1840 error++;
1842 bad_syntax:
1844 error++;
1846 }
1847 }
1848 }
1850 /*
1851 * usage - print usage and exit
1852 */
1853 static void
1855 {
1865 }
1867 /*
1868 * getachar - get next character from input buffer.
1869 */
1870 static char
1872 {
1874 }
1876 /*
1877 * ungetachar - return character to input buffer.
1878 */
1879 static void
1881 {
1884 error++;
1886 }
1888 }
1890 /*
1891 * getnextinput - display the prompt and read an input line.
1892 * An input line is up to 128 characters terminated by the newline
1893 * character. Handle overflow, shell escape, and eof.
1894 */
1895 static void
1897 {
1903 newline:
1906 ignore_eol:
1913 }
1917 }
1921 error++;
1923 }
1925 ;
1928 }
1933 }
1935 /*
1936 * eat_spaces - read extraneous spaces.
1937 */
1938 static void
1940 {
1944 ;
1946 }
1948 /*
1949 * restore_inode - set up all inode indicators so inum is now
1950 * the current inode.
1951 */
1952 static void
1954 {
1957 }
1959 /*
1960 * match - return false if the input does not match string up to
1961 * upto letters. Then proceed to chew up extraneous letters.
1962 */
1963 static int
1965 {
1971 string++;
1976 }
1978 }
1979 length--;
1980 }
1982 string++;
1986 }
1987 }
1989 }
1991 /*
1992 * expr - expression evaluator. Will evaluate expressions from
1993 * left to right with no operator precedence. Parentheses may
1994 * be used.
1995 */
1996 static long
1998 {
2025 error++;
2027 }
2032 paren--;
2039 error++;
2040 }
2042 }
2043 }
2044 }
2046 /*
2047 * term - used by expression evaluator to get an operand.
2048 */
2049 static long
2051 {
2058 /*FALLTHRU*/
2066 paren++;
2068 }
2069 }
2071 /*
2072 * getnumb - read a number from the input stream. A leading
2073 * zero signifies octal interpretation, a leading '0x'
2074 * signifies hexadecimal, and a leading '0t' signifies
2075 * decimal. If the first character is a character,
2076 * return an error.
2077 */
2078 static long
2080 {
2088 error++;
2091 }
2102 }
2113 }
2114 /*FALLTHRU*/
2122 }
2126 }
2129 }
2131 /*
2132 * find - the syntax is almost identical to the unix command.
2133 * find dir [-name pattern] [-inum number]
2134 * Note: only one of -name or -inum may be used at a time.
2135 * Also, the -print is not needed (implied).
2136 */
2137 static void
2139 {
2157 else
2159 error++;
2161 }
2162 }
2172 error++;
2174 }
2179 error++;
2181 }
2193 }
2195 ;
2201 error++;
2203 }
2210 }
2218 }
2220 }
2222 /*
2223 * ls - do an ls. Should behave exactly as ls(1).
2224 * Only -R and -l is supported and -l gives different results.
2225 */
2226 static void
2228 {
2238 }
2246 }
2256 else
2262 }
2265 }
2266 }
2268 /*
2269 * formatf - code lifted from ls.
2270 */
2271 static void
2273 {
2287 }
2292 }
2300 }
2304 }
2309 }
2314 }
2315 }
2316 }
2317 }
2319 /*
2320 * fmtentry - code lifted from ls.
2321 */
2324 {
2333 else
2335 }
2340 /*LINTED*/
2352 #ifdef IFIFO
2356 #endif
2362 else
2368 }
2371 }
2373 /*
2374 * fcmp - routine used by qsort. Will sort first by name, then
2375 * then by pathname length if names are equal. Uses global
2376 * cmp_level to tell what component of the path name we are comparing.
2377 */
2378 static int
2380 {
2386 }
2388 /*
2389 * ffcmp - routine used by qsort. Sort only by pathname length.
2390 */
2391 static int
2393 {
2395 }
2397 /*
2398 * parse - set up the call to follow_path.
2399 */
2400 static void
2402 {
2409 ;
2416 top++;
2421 }
2433 }
2434 }
2437 }
2439 /*
2440 * follow_path - called by cd, find, and ls.
2441 * input_path holds the name typed by the user.
2442 * stack_path holds the name at the current depth.
2443 */
2444 static void
2446 {
2470 }
2471 /*LINTED*/
2482 error++;
2484 }
2489 error++;
2491 }
2492 nfiles++;
2503 }
2508 error++;
2510 }
2516 }
2519 error++;
2521 }
2522 /*
2523 * Copy current depth.
2524 */
2529 error++;
2531 }
2533 }
2534 /*
2535 * Check for '.' or '..' typed.
2536 */
2544 }
2546 /*
2547 * Check for duplicates.
2548 */
2562 else
2563 top--;
2564 nfiles--;
2566 }
2567 }
2568 }
2574 error++;
2576 }
2578 }
2579 }
2580 }
2581 duplicate:
2585 }
2592 /*
2593 * Check newly added entries to determine if further expansion
2594 * is required.
2595 */
2597 /*
2598 * Avoid '.' and '..' if beyond input.
2599 */
2608 /*
2609 * Set up current depth, remove current entry and
2610 * continue recursion.
2611 */
2617 /*
2618 * Remove current entry by moving others up.
2619 */
2636 error++;
2638 }
2641 }
2643 fn--;
2644 top--;
2645 bos--;
2646 nfiles--;
2647 }
2651 }
2652 }
2653 }
2655 /*
2656 * getname - break up the pathname entered by the user into components.
2657 */
2658 static void
2660 {
2667 }
2669 input_pathp++;
2670 clear:
2680 }
2685 }
2689 }
2694 input_pathp--;
2696 }
2698 }
2702 }
2704 }
2705 }
2707 /*
2708 * compare - check if a filename matches the pattern entered by the user.
2709 * Handles '*', '?', and '[]'.
2710 */
2711 static int
2713 {
2728 s2++;
2729 }
2730 }
2734 s1++;
2736 }
2740 s1++;
2741 s2++;
2743 }
2745 s1++;
2749 error++;
2751 }
2755 error++;
2757 }
2758 s2++;
2760 }
2761 }
2762 }
2763 compare_chars:
2766 else
2768 }
2772 }
2774 /*
2775 * freemem - free the memory allocated to the filenames structure.
2776 */
2777 static void
2779 {
2788 }
2789 }
2791 /*
2792 * print_path - print the pathname held in p.
2793 */
2794 static void
2796 {
2804 }
2805 }
2807 /*
2808 * fill - fill a section with a value or string.
2809 * addr,count:fill=[value, "string"].
2810 */
2811 static void
2813 {
2818 uoff_t taddr;
2822 error++;
2824 }
2832 else
2845 }
2852 /*LINTED*/
2856 /*LINTED*/
2861 }
2863 }
2869 error++;
2872 error++;
2873 }
2874 }
2876 /*
2877 * get - read a byte, short or long from the file system.
2878 * The entire block containing the desired item is read
2879 * and the appropriate data is extracted and returned.
2880 */
2881 static offset_t
2883 {
2901 /*LINTED*/
2906 /*LINTED*/
2909 /*LINTED*/
2911 }
2913 }
2915 /*
2916 * cgrp_check - make sure that we don't bump the cylinder group
2917 * beyond the total number of cylinder groups or before the start.
2918 */
2919 static int
2921 {
2925 else
2927 error++;
2929 }
2933 else
2935 error++;
2937 }
2940 else
2942 }
2944 /*
2945 * icheck - make sure we can read the block containing the inode
2946 * and determine the filesize (0 if inode not allocated). Return
2947 * 0 if error otherwise return the mode.
2948 */
2949 int
2951 {
2958 /*LINTED*/
2963 error++;
2965 }
2968 trapped++;
2971 }
2973 }
2975 /*
2976 * getdirslot - get the address of the directory slot desired.
2977 */
2978 static uoff_t
2980 {
2989 bod++;
2990 }
2994 else
3001 /*LINTED*/
3004 /*LINTED*/
3008 filesize) {
3013 error++;
3015 }
3018 blocksize) {
3023 error++;
3025 }
3026 }
3030 }
3034 else
3038 error++;
3039 }
3048 error++;
3050 }
3061 }
3062 /*LINTED*/
3074 error++;
3076 }
3080 }
3087 error++;
3088 }
3091 }
3092 }
3095 /*
3096 * getshadowslot - get the address of the shadow data desired
3097 */
3098 static int
3100 {
3107 bod++;
3108 }
3112 error++;
3114 }
3121 error++;
3123 }
3127 }
3140 error++;
3142 }
3146 }
3153 error++;
3154 }
3156 }
3158 static void
3160 {
3169 }
3170 }
3172 static void
3174 {
3184 }
3185 }
3189 /*
3190 * putf - print a byte as an ascii character if possible.
3191 * The exceptions are tabs, newlines, backslashes
3192 * and nulls which are printed as the standard C
3193 * language escapes. Characters which are not
3194 * recognized are printed as \?.
3195 */
3196 static void
3198 {
3217 }
3221 }
3222 }
3224 /*
3225 * put - write an item into the buffer for the current address
3226 * block. The value is checked to make sure that it will
3227 * fit in the size given without truncation. If successful,
3228 * the entire block is written back to the file system.
3229 */
3230 static void
3232 {
3240 error++;
3242 }
3250 /*LINTED*/
3252 /*LINTED*/
3257 /*LINTED*/
3260 /*LINTED*/
3269 error++;
3271 }
3273 error++;
3276 }
3278 error++;
3283 }
3298 }
3299 }
3300 }
3302 /*
3303 * getblk - check if the desired block is in the file system.
3304 * Search the incore buffers to see if the block is already
3305 * available. If successful, unlink the buffer control block
3306 * from its position in the buffer list and re-insert it at
3307 * the head of the list. If failure, use the last buffer
3308 * in the list for the desired block. Again, this control
3309 * block is placed at the head of the list. This process
3310 * will leave commonly requested blocks in the in-core buffers.
3311 * Finally, a pointer to the buffer is returned.
3312 */
3315 {
3321 read_requests++;
3325 error++;
3327 }
3331 actual_disk_reads++;
3336 error++;
3339 }
3341 error++;
3346 }
3352 }
3354 /*
3355 * insert - place the designated buffer control block
3356 * at the head of the linked list of buffers.
3357 */
3358 static void
3360 {
3366 }
3368 /*
3369 * err - called on interrupts. Set the current address
3370 * back to the last address stored in erraddr. Reset all
3371 * appropriate flags. A reset call is made to return
3372 * to the main loop;
3373 */
3374 #ifdef sun
3375 /*ARGSUSED*/
3376 static void
3378 #else
3381 {
3394 }
3396 /*
3397 * devcheck - check that the given mode represents a
3398 * special device. The IFCHR bit is on for both
3399 * character and block devices.
3400 */
3401 static int
3403 {
3410 }
3413 error++;
3415 }
3417 /*
3418 * nullblk - return error if address is zero. This is done
3419 * to prevent block 0 from being used as an indirect block
3420 * for a large file or as a data block for a small file.
3421 */
3422 static int
3424 {
3428 error++;
3430 }
3432 /*
3433 * puta - put ascii characters into a buffer. The string
3434 * terminates with a quote or newline. The leading quote,
3435 * which is optional for directory names, was stripped off
3436 * by the assignment case in the main loop.
3437 */
3438 static void
3440 {
3451 error++;
3453 }
3460 else
3464 else
3473 else
3477 terror++;
3479 }
3480 tcount++;
3484 }
3502 }
3503 }
3504 else
3506 }
3511 error++;
3514 }
3516 error++;
3521 }
3529 }
3533 }
3541 /*LINTED*/
3549 }
3552 /*LINTED*/
3560 }
3566 }
3579 }
3580 }
3582 error++;
3583 }
3585 /*
3586 * fprnt - print data. 'count' elements are printed where '*' will
3587 * print an entire blocks worth or up to the eof, whichever
3588 * occurs first. An error will occur if crossing a block boundary
3589 * is attempted since consecutive blocks don't usually have
3590 * meaning. Current print types:
3591 * / b - print as bytes (base sensitive)
3592 * c - print as characters
3593 * o O - print as octal shorts (longs)
3594 * d D - print as decimal shorts (longs)
3595 * x X - print as hexadecimal shorts (longs)
3596 * ? c - print as cylinder groups
3597 * d - print as directories
3598 * i - print as inodes
3599 * s - print as super blocks
3600 * S - print as shadow data
3601 */
3602 static void
3604 {
3613 uoff_t taddr;
3629 }
3636 else
3653 }
3662 else
3665 }
3668 }
3670 }
3677 error++;
3681 else
3683 error++;
3684 }
3695 otx:
3702 /*LINTED*/
3709 /*LINTED*/
3721 }
3724 }
3726 }
3733 error++;
3737 else
3739 error++;
3740 }
3751 OTX:
3758 /*LINTED*/
3775 }
3778 }
3780 }
3787 error++;
3791 else
3793 error++;
3794 }
3798 error++;
3801 }
3810 end++;
3811 }
3819 cur_cgrp++;
3820 }
3823 cur_cgrp--;
3825 }
3827 /*LINTED*/
3835 end++;
3836 }
3837 }
3842 cur_cgrp--;
3843 error++;
3845 }
3849 }
3850 cur_cgrp--;
3853 error++;
3854 }
3864 error++;
3866 }
3873 }
3878 /*LINTED*/
3884 else
3892 dirslot++;
3894 }
3898 dirslot--;
3909 }
3910 error++;
3916 /*LINTED*/
3922 i--;
3930 end++;
3931 }
3970 }
3978 else
3980 }
3993 #ifdef _LARGEFILE64_SOURCE
4001 }
4007 }
4019 /*
4020 * only display blocks below the
4021 * current file size
4022 */
4032 else
4035 }
4039 /*
4040 * curioff keeps track of the number
4041 * of bytes covered by each indirect
4042 * pointer in the inode, and is added
4043 * to curoff each time to get the
4044 * actual offset into the file.
4045 */
4057 }
4061 }
4071 }
4074 empty:
4081 }
4084 cur_inum++;
4086 }
4089 cur_inum--;
4092 error++;
4093 }
4100 }
4106 end++;
4107 }
4114 cur_cgrp++;
4115 }
4118 cur_cgrp--;
4120 }
4122 /*LINTED*/
4127 FRGSHIFT)
4131 else
4137 end++;
4138 }
4139 }
4146 cur_cgrp--;
4147 error++;
4149 }
4150 }
4153 UFS_EFISTYLE4NONEFI_VERSION_2 &&
4159 cur_cgrp--;
4160 error++;
4162 }
4163 }
4171 cur_cgrp--;
4172 error++;
4174 }
4175 }
4183 }
4187 }
4188 cur_cgrp--;
4191 error++;
4192 }
4201 /* no more than two fragments */
4204 }
4210 /*LINTED*/
4237 }
4245 cur_shad++;
4247 }
4250 cur_shad--;
4258 }
4259 error++;
4264 error++;
4267 }
4268 }
4270 /*
4271 * valid_addr - call check_addr to validate the current address.
4272 */
4273 static int
4275 {
4288 else
4290 }
4291 error++;
4293 }
4299 error++;
4301 }
4306 else
4308 error++;
4310 }
4311 }
4315 else
4317 error++;
4319 }
4321 }
4323 /*
4324 * check_addr - check if the address crosses the end of block or
4325 * end of file. Return the proper count.
4326 */
4327 static int
4329 {
4343 }
4349 }
4358 }
4364 }
4369 }
4370 }
4374 }
4386 }
4395 }
4396 }
4397 }
4399 }
4401 /*
4402 * print_check - check if the index needs to be printed and delete
4403 * rows of zeros from the output.
4404 */
4407 {
4420 else
4430 }
4436 else
4442 }
4445 else
4447 }
4455 }
4456 }
4458 /*LINTED*/
4460 else
4462 }
4464 /*
4465 * index - print a byte index for the printout in base b
4466 * with leading zeros.
4467 */
4468 static void
4470 {
4477 }
4479 /*
4480 * print - print out the value to digits places with/without
4481 * leading zeros and right/left justified in the current base.
4482 */
4483 static void
4484 #ifdef _LARGEFILE64_SOURCE
4489 {
4497 }
4501 else
4506 #ifdef _LARGEFILE64_SOURCE
4507 "ll"
4510 else
4512 #ifdef _LARGEFILE64_SOURCE
4513 "ll"
4519 #ifdef _LARGEFILE64_SOURCE
4520 "ll"
4523 else
4525 #ifdef _LARGEFILE64_SOURCE
4526 "ll"
4529 }
4533 }
4535 /*
4536 * Print out the contents of a superblock.
4537 */
4538 static void
4540 {
4542 caddr_t sip;
4546 #ifdef FS_42POSTBLFMT
4552 #else
4555 #endif
4573 #ifdef FS_42POSTBLFMT
4574 #ifdef sun
4577 #else
4584 #else
4589 #endif
4601 #ifdef FS_42POSTBLFMT
4605 else
4607 #endif
4610 #ifdef FS_42POSTBLFMT
4612 /*LINTED*/
4616 /*LINTED*/
4624 }
4625 }
4626 #else
4638 }
4639 }
4640 #endif
4641 }
4654 }
4656 }
4663 }
4671 }
4672 }
4674 /*
4675 * Print out the contents of a cylinder group.
4676 */
4677 static void
4679 {
4685 #ifdef FS_42POSTBLFMT
4691 #else
4696 #endif
4707 }
4714 /*LINTED*/
4717 /*LINTED*/
4719 #ifdef FS_42POSTBLFMT
4722 /*LINTED*/
4725 /*LINTED*/
4727 }
4728 #else
4734 }
4735 #endif
4737 }
4738 }
4740 /*
4741 * Print out the contents of a bit array.
4742 */
4743 static void
4745 {
4753 count++;
4757 i++;
4760 }
4762 }
4764 /*
4765 * bcomp - used to check for block over/under flows when stepping through
4766 * a file system.
4767 */
4768 static int
4770 uoff_t addr;
4771 {
4777 error++;
4779 }
4781 /*
4782 * bmap - maps the logical block number of a file into
4783 * the corresponding physical block on the file
4784 * system.
4785 */
4786 static long
4788 {
4800 /*LINTED*/
4806 }
4815 }
4818 error++;
4820 }
4830 }
4832 }
4834 #if defined(OLD_FSDB_COMPATIBILITY)
4836 /*
4837 * The following are "tacked on" to support the old fsdb functionality
4838 * of clearing an inode. (All together now...) "It's better to use clri".
4839 */
4841 #define ISIZE (sizeof (struct dinode))
4842 #define NI (MAXBSIZE/ISIZE)
4852 #define sblock sb_un.sblk
4854 static void
4856 {
4860 uoff_t off;
4869 }
4874 }
4878 }
4882 }
4888 }
4892 /*
4893 * Update the time in superblock, so fsck will check this filesystem.
4894 */
4901 }
4914 }
4916 static int
4918 {
4927 }
4935 /*
4936 * no single value is safe to use to indicate
4937 * lufs_tid being invalid so we need a
4938 * seperate variable.
4939 */
4942 /*
4943 * log_get_header_info - get the basic info of the logging filesystem
4944 */
4945 int
4947 {
4951 /*
4952 * Mark the global tid as invalid everytime we're called to
4953 * prevent any false positive responses.
4954 */
4957 /*
4958 * See if we've already set up the header areas. The only problem
4959 * with this approach is we don't reread the on disk data though
4960 * it shouldn't matter since we don't operate on a live disk.
4961 */
4965 /*
4966 * Either logging is disabled or we've not running 2.7.
4967 */
4971 }
4973 /*
4974 * To find the log we need to first pick up the block allocation
4975 * data. The block number for that data is fs_logbno in the
4976 * super block.
4977 */
4982 }
4984 /*
4985 * Next we need to figure out how big the extent data structure
4986 * really is. It can't be more then fs_bsize and you could just
4987 * allocate that but, why get sloppy.
4988 * 1 is subtracted from nextents because extent_block_t contains
4989 * a single extent_t itself.
4990 */
4996 }
5004 }
5008 /*
5009 * Currently, as of 11-Dec-1997 the field nextbno isn't
5010 * implemented. If someone starts using this sucker we'd
5011 * better warn somebody.
5012 */
5015 /*
5016 * Now read in the on disk log structure. This is always in the
5017 * first block of the first extent.
5018 */
5026 }
5029 /*
5030 * Consistency checks.
5031 */
5041 }
5044 }
5046 static void
5048 {
5051 /*
5052 * No need to display anything here. The previous routine
5053 * has already done so.
5054 */
5060 else
5087 }
5089 /*
5090 * log_lodb -- logical log offset to disk block number
5091 */
5092 int
5094 {
5099 /*
5100 * No need to display anything here. The previous routine
5101 * has already done so.
5102 */
5112 }
5114 }
5116 /*
5117 * String names for the enumerated types. These are only used
5118 * for display purposes.
5119 */
5125 };
5127 /*
5128 * log_read_log -- transfer information from the log and adjust offset
5129 */
5130 int
5132 {
5134 caddr_t bp;
5135 diskaddr_t pblk;
5142 }
5144 /*
5145 * fsdb getblk() expects offsets not block number.
5146 */
5154 }
5158 /*
5159 * If the log offset is now at a sector trailer
5160 * run the checks if requested.
5161 */
5173 /*
5174 * We update the on disk structure
5175 * transaction ID each time we see
5176 * one. By comparing this value
5177 * to the last valid DT_COMMIT record
5178 * we can determine if our log is
5179 * completely valid.
5180 */
5182 }
5183 }
5185 }
5188 }
5190 }
5192 uoff_t
5194 {
5195 /*
5196 * Comments are straight from ufs_log.c
5197 *
5198 * log is the offset following the commit header. However,
5199 * if the commit header fell on the end-of-sector, then lof
5200 * has already been advanced to the beginning of the next
5201 * sector. So do nothgin. Otherwise, return the remaining
5202 * bytes in the sector.
5203 */
5206 else
5208 }
5210 /*
5211 * log_show -- pretty print the deltas. The number of which is determined
5212 * by the log_enum arg. If LOG_ALLDELTAS the routine, as the
5213 * name implies dumps everything. If LOG_NDELTAS, the routine
5214 * will print out "count" deltas starting at "addr". If
5215 * LOG_CHECKSCAN then run through the log checking the st_ident
5216 * for valid data.
5217 */
5218 static void
5220 {
5227 /*
5228 * No need to display any error messages here. The previous
5229 * routine has already done so.
5230 */
5244 }
5246 /*
5247 * Only reset the "addr" if we've been requested to show all
5248 * deltas in the log.
5249 */
5257 }
5264 /*
5265 * Two failures are possible. One from getblk()
5266 * which prints out a message or when we've hit
5267 * an invalid block which may or may not indicate
5268 * an error
5269 */
5275 }
5284 /*
5285 * These two deltas don't have log space
5286 * associated with the entry even though
5287 * d_nb is non-zero.
5288 */
5292 /*
5293 * Commit records have zero size yet, the
5294 * rest of the current disk block is avoided.
5295 */
5307 }
5309 }
5311 end_scan:
5315 else
5320 }
5321 }