1/*
2 * Copyright (c) 1980, 1986, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 18 unchanged lines hidden (view full) ---

27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34#ifndef lint
35static const char sccsid[] = "@(#)pass1.c 8.1 (Berkeley) 6/5/93";
36#endif /* not lint */
37
38#include <sys/param.h>
39#include <sys/time.h>
40#include <ufs/ufs/dinode.h>
41#include <ufs/ufs/dir.h>
42#include <ufs/ffs/fs.h>
43#include <stdio.h>
44#include <stdlib.h>
45#include <string.h>
46#include "fsck.h"
47
48static daddr_t badblk;
49static daddr_t dupblk;
50
51static void checkinode __P((ino_t inumber, struct inodesc *idesc));
52
53void
54pass1()
55{
56 ino_t inumber;
57 int c, i, cgd;
58 struct inodesc idesc;
59

--- 8 unchanged lines hidden (view full) ---

68 } else
69 i = cgsblock(&sblock, c);
70 for (; i < cgd; i++)
71 setbmap(i);
72 }
73 /*
74 * Find all allocated blocks.
75 */
76 bzero((char *)&idesc, sizeof(struct inodesc));
77 idesc.id_type = ADDR;
78 idesc.id_func = pass1check;
79 inumber = 0;
80 n_files = n_blks = 0;
81 resetinodebuf();
82 for (c = 0; c < sblock.fs_ncg; c++) {
83 for (i = 0; i < sblock.fs_ipg; i++, inumber++) {
84 if (inumber < ROOTINO)
85 continue;
86 checkinode(inumber, &idesc);
87 }
88 }
89 freeinodebuf();
90}
91
92void
93checkinode(inumber, idesc)
94 ino_t inumber;
95 register struct inodesc *idesc;
96{
97 register struct dinode *dp;
98 struct zlncnt *zlnp;
99 int ndb, j;
100 mode_t mode;
101 char *symbuf;
102
103 dp = getnextinode(inumber);
104 mode = dp->di_mode & IFMT;
105 if (mode == 0) {
106 if (bcmp((char *)dp->di_db, (char *)zino.di_db,
107 NDADDR * sizeof(daddr_t)) ||
108 bcmp((char *)dp->di_ib, (char *)zino.di_ib,
109 NIADDR * sizeof(daddr_t)) ||
110 dp->di_mode || dp->di_size) {
111 pfatal("PARTIALLY ALLOCATED INODE I=%lu", inumber);
112 if (reply("CLEAR") == 1) {
113 dp = ginode(inumber);
114 clearinode(dp);
115 inodirty();
116 }
117 }
118 statemap[inumber] = USTATE;
119 return;
120 }
121 lastino = inumber;
122 if (/* dp->di_size < 0 || */
123 dp->di_size + sblock.fs_bsize - 1 < dp->di_size) {
124 if (debug)
125 printf("bad size %qu:", dp->di_size);
126 goto unknown;
127 }
128 if (!preen && mode == IFMT && reply("HOLD BAD BLOCK") == 1) {
129 dp = ginode(inumber);
130 dp->di_size = sblock.fs_fsize;
131 dp->di_mode = IFREG|0600;

--- 11 unchanged lines hidden (view full) ---

143 if (mode == IFLNK) {
144 if (doinglevel2 &&
145 dp->di_size > 0 && dp->di_size < MAXSYMLINKLEN &&
146 dp->di_blocks != 0) {
147 symbuf = alloca(secsize);
148 if (bread(fsreadfd, symbuf,
149 fsbtodb(&sblock, dp->di_db[0]),
150 (long)secsize) != 0)
151 errexit("cannot read symlink");
152 if (debug) {
153 symbuf[dp->di_size] = 0;
154 printf("convert symlink %ld(%s) of size %ld\n",
155 inumber, symbuf, (long)dp->di_size);
156 }
157 dp = ginode(inumber);
158 bcopy(symbuf, (caddr_t)dp->di_shortlink,
159 (long)dp->di_size);
160 dp->di_blocks = 0;
161 inodirty();
162 }
163 /*
164 * Fake ndb value so direct/indirect block checks below
165 * will detect any garbage after symlink string.
166 */
167 if ((dp->di_size < sblock.fs_maxsymlinklen) || dp->di_blocks == 0) {
168 ndb = howmany(dp->di_size, sizeof(daddr_t));
169 if (ndb > NDADDR) {
170 j = ndb - NDADDR;
171 for (ndb = 1; j > 1; j--)
172 ndb *= NINDIR(&sblock);
173 ndb += NDADDR;
174 }
175 }
176 }

--- 16 unchanged lines hidden (view full) ---

193 goto unknown;
194 n_files++;
195 lncntp[inumber] = dp->di_nlink;
196 if (dp->di_nlink <= 0) {
197 zlnp = (struct zlncnt *)malloc(sizeof *zlnp);
198 if (zlnp == NULL) {
199 pfatal("LINK COUNT TABLE OVERFLOW");
200 if (reply("CONTINUE") == 0)
201 errexit("");
202 } else {
203 zlnp->zlncnt = inumber;
204 zlnp->next = zlnhead;
205 zlnhead = zlnp;
206 }
207 }
208 if (mode == IFDIR) {
209 if (dp->di_size == 0)

--- 41 unchanged lines hidden (view full) ---

251}
252
253int
254pass1check(idesc)
255 register struct inodesc *idesc;
256{
257 int res = KEEPON;
258 int anyout, nfrags;
259 daddr_t blkno = idesc->id_blkno;
260 register struct dups *dlp;
261 struct dups *new;
262
263 if ((anyout = chkrange(blkno, idesc->id_numfrags)) != 0) {
264 blkerror(idesc->id_number, "BAD", blkno);
265 if (badblk++ >= MAXBAD) {
266 pwarn("EXCESSIVE BAD BLKS I=%lu",
267 idesc->id_number);
268 if (preen)
269 printf(" (SKIPPING)\n");
270 else if (reply("CONTINUE") == 0)
271 errexit("");
272 return (STOP);
273 }
274 }
275 for (nfrags = idesc->id_numfrags; nfrags > 0; blkno++, nfrags--) {
276 if (anyout && chkrange(blkno, 1)) {
277 res = SKIP;
278 } else if (!testbmap(blkno)) {
279 n_blks++;
280 setbmap(blkno);
281 } else {
282 blkerror(idesc->id_number, "DUP", blkno);
283 if (dupblk++ >= MAXDUP) {
284 pwarn("EXCESSIVE DUP BLKS I=%lu",
285 idesc->id_number);
286 if (preen)
287 printf(" (SKIPPING)\n");
288 else if (reply("CONTINUE") == 0)
289 errexit("");
290 return (STOP);
291 }
292 new = (struct dups *)malloc(sizeof(struct dups));
293 if (new == NULL) {
294 pfatal("DUP TABLE OVERFLOW.");
295 if (reply("CONTINUE") == 0)
296 errexit("");
297 return (STOP);
298 }
299 new->dup = blkno;
300 if (muldup == 0) {
301 duplist = muldup = new;
302 new->next = 0;
303 } else {
304 new->next = muldup->next;

--- 15 unchanged lines hidden ---