xref: /illumos-gate/usr/src/cmd/fs.d/ufs/fsck/pass4.c (revision 77a343ab)
1 /*
2  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
3  * Use is subject to license terms.
4  */
5 
6 /*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
7 /*	  All Rights Reserved  	*/
8 
9 /*
10  * Copyright (c) 1980, 1986, 1990 The Regents of the University of California.
11  * All rights reserved.
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  */
27 
28 #pragma ident	"%Z%%M%	%I%	%E% SMI"
29 
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <unistd.h>
33 #include <sys/param.h>
34 #include <sys/types.h>
35 #include <sys/mntent.h>
36 #include <sys/fs/ufs_fs.h>
37 #include <sys/vnode.h>
38 #include <sys/fs/ufs_inode.h>
39 #include "fsck.h"
40 
41 void
pass4(void)42 pass4(void)
43 {
44 	fsck_ino_t inumber;
45 	struct dinode *dp;
46 	struct inodesc idesc;
47 	int n, was_dir;
48 	int need_rescan;
49 	int scan_pass = 0;
50 
51 	/*
52 	 * If we clear a directory, it may have produced orphans which
53 	 * we need to go pick up.  So, do this until done.  It can be
54 	 * proven that the loop terminates because at most there can
55 	 * be lastino directories, and we only rescan if we clear a
56 	 * directory.
57 	 */
58 	do {
59 		if (debug)
60 			(void) printf("pass4 scan %d\n", scan_pass++);
61 
62 		need_rescan = 0;
63 		for (inumber = UFSROOTINO; inumber <= lastino; inumber++) {
64 			init_inodesc(&idesc);
65 			idesc.id_type = ADDR;
66 			idesc.id_func = pass4check;
67 			idesc.id_number = inumber;
68 
69 			was_dir = (statemap[inumber] & DSTATE) == DSTATE;
70 
71 			switch (statemap[inumber] & ~(INORPHAN | INDELAYD
72 			    | INZLINK)) {
73 
74 			case FZLINK:
75 			case DZLINK:
76 				/*
77 				 * INZLINK gets set if the inode claimed zero
78 				 * links when we first looked at it in pass 1.
79 				 * If lncntp[] also claims it has zero links,
80 				 * it really is unreferenced.  However, we
81 				 * could have found a link to it during one of
82 				 * the other passes, so we have to check the
83 				 * final count in lncntp[].
84 				 */
85 				if (lncntp[inumber] == 0) {
86 					clri(&idesc, "UNREF", CLRI_VERBOSE,
87 					    CLRI_NOP_OK);
88 					if (was_dir &&
89 					    (statemap[inumber] == USTATE))
90 						need_rescan = 1;
91 					break;
92 				}
93 				/* FALLTHROUGH */
94 
95 			case FSTATE:
96 			case DFOUND:
97 			case SSTATE:
98 				n = lncntp[inumber];
99 				if (n || (statemap[inumber] &
100 				    (INDELAYD | INZLINK))) {
101 					/*
102 					 * adjust() will clear the inode if
103 					 * the link count goes to zero.  If
104 					 * it isn't cleared, we need to note
105 					 * that we've adjusted the count
106 					 * already, so we don't do it again
107 					 * on a rescan.
108 					 */
109 					adjust(&idesc, n);
110 					if (was_dir &&
111 					    (statemap[inumber] == USTATE)) {
112 						need_rescan = 1;
113 					} else {
114 						TRACK_LNCNTP(inumber,
115 						    lncntp[inumber] = 0);
116 					}
117 				}
118 				break;
119 
120 			case DSTATE:
121 				clri(&idesc, "UNREF", CLRI_VERBOSE,
122 				    CLRI_NOP_OK);
123 				if (was_dir && (statemap[inumber] == USTATE))
124 					need_rescan = 1;
125 				break;
126 
127 			case DCLEAR:
128 				dp = ginode(inumber);
129 				if (dp->di_size == 0) {
130 					clri(&idesc, "ZERO LENGTH",
131 					    CLRI_VERBOSE, CLRI_NOP_CORRUPT);
132 					break;
133 				}
134 				/* FALLTHROUGH */
135 
136 			case FCLEAR:
137 				clri(&idesc, "BAD/DUP", CLRI_VERBOSE,
138 				    CLRI_NOP_CORRUPT);
139 				break;
140 
141 			case SCLEAR:
142 				clri(&idesc, "BAD", CLRI_VERBOSE,
143 				    CLRI_NOP_CORRUPT);
144 				break;
145 
146 			case USTATE:
147 				break;
148 
149 			default:
150 				errexit("BAD STATE 0x%x FOR INODE I=%d",
151 					(int)statemap[inumber], inumber);
152 			}
153 		}
154 	} while (need_rescan);
155 }
156 
157 int
pass4check(struct inodesc * idesc)158 pass4check(struct inodesc *idesc)
159 {
160 	int fragnum, cg_frag;
161 	int res = KEEPON;
162 	daddr32_t blkno = idesc->id_blkno;
163 	int cylno;
164 	struct cg *cgp = &cgrp;
165 	caddr_t err;
166 
167 	if ((idesc->id_truncto >= 0) && (idesc->id_lbn < idesc->id_truncto)) {
168 		if (debug)
169 			(void) printf(
170 		    "pass4check: skipping inode %d lbn %d with truncto %d\n",
171 			    idesc->id_number, idesc->id_lbn,
172 			    idesc->id_truncto);
173 		return (KEEPON);
174 	}
175 
176 	for (fragnum = 0; fragnum < idesc->id_numfrags; fragnum++) {
177 		if (chkrange(blkno + fragnum, 1)) {
178 			res = SKIP;
179 		} else if (testbmap(blkno + fragnum)) {
180 			/*
181 			 * The block's in use.  Remove our reference
182 			 * from it.
183 			 *
184 			 * If it wasn't a dup, or everybody's done with
185 			 * it, then this is the last reference and it's
186 			 * safe to actually deallocate the on-disk block.
187 			 *
188 			 * We depend on pass 5 resolving the on-disk bitmap
189 			 * effects.
190 			 */
191 			cg_frag = blkno + fragnum;
192 			if (!find_dup_ref(cg_frag, idesc->id_number,
193 			    idesc->id_lbn * sblock.fs_frag + fragnum,
194 			    DB_DECR)) {
195 
196 				if (debug)
197 					(void) printf("p4c marking %d avail\n",
198 					    cg_frag);
199 				clrbmap(cg_frag);
200 				n_blks--;
201 
202 				/*
203 				 * Do the same for the on-disk bitmap, so
204 				 * that we don't need another pass to figure
205 				 * out what's really being used.  We'll let
206 				 * pass5() work out the fragment/block
207 				 * accounting.
208 				 */
209 				cylno = dtog(&sblock, cg_frag);
210 				(void) getblk(&cgblk, cgtod(&sblock, cylno),
211 				    (size_t)sblock.fs_cgsize);
212 				err = cg_sanity(cgp, cylno);
213 				if (err != NULL) {
214 					pfatal("CG %d: %s\n", cylno, err);
215 					free((void *)err);
216 					if (reply("REPAIR") == 0)
217 						errexit("Program terminated.");
218 					fix_cg(cgp, cylno);
219 				}
220 				clrbit(cg_blksfree(cgp),
221 				    dtogd(&sblock, cg_frag));
222 				cgdirty();
223 
224 				res |= ALTERED;
225 			}
226 		}
227 	}
228 	return (res);
229 }
230