41
42#include <sys/param.h>
43#include <sys/time.h>
44#include <sys/sysctl.h>
45
46#include <ufs/ufs/dinode.h>
47#include <ufs/ufs/dir.h>
48#include <ufs/ffs/fs.h>
49
50#include <err.h>
51#include <string.h>
52
53#include "fsck.h"
54
55const char *lfname = "lost+found";
56int lfmode = 01777;
57struct dirtemplate emptydir = {
58 0, DIRBLKSIZ, DT_UNKNOWN, 0, "",
59 0, 0, DT_UNKNOWN, 0, ""
60};
61struct dirtemplate dirhead = {
62 0, 12, DT_DIR, 1, ".",
63 0, DIRBLKSIZ - 12, DT_DIR, 2, ".."
64};
65struct odirtemplate odirhead = {
66 0, 12, 1, ".",
67 0, DIRBLKSIZ - 12, 2, ".."
68};
69
70static int chgino(struct inodesc *);
71static int dircheck(struct inodesc *, struct direct *);
72static int expanddir(union dinode *dp, char *name);
73static void freedir(ino_t ino, ino_t parent);
74static struct direct *fsck_readdir(struct inodesc *);
75static struct bufarea *getdirblk(ufs2_daddr_t blkno, long size);
76static int lftempname(char *bufp, ino_t ino);
77static int mkentry(struct inodesc *);
78
79/*
80 * Propagate connected state through the tree.
81 */
82void
83propagate(void)
84{
85 struct inoinfo **inpp, *inp;
86 struct inoinfo **inpend;
87 long change;
88
89 inpend = &inpsort[inplast];
90 do {
91 change = 0;
92 for (inpp = inpsort; inpp < inpend; inpp++) {
93 inp = *inpp;
94 if (inp->i_parent == 0)
95 continue;
96 if (inoinfo(inp->i_parent)->ino_state == DFOUND &&
97 inoinfo(inp->i_number)->ino_state == DSTATE) {
98 inoinfo(inp->i_number)->ino_state = DFOUND;
99 change++;
100 }
101 }
102 } while (change > 0);
103}
104
105/*
106 * Scan each entry in a directory block.
107 */
108int
109dirscan(struct inodesc *idesc)
110{
111 struct direct *dp;
112 struct bufarea *bp;
113 u_int dsize, n;
114 long blksiz;
115 char dbuf[DIRBLKSIZ];
116
117 if (idesc->id_type != DATA)
118 errx(EEXIT, "wrong type to dirscan %d", idesc->id_type);
119 if (idesc->id_entryno == 0 &&
120 (idesc->id_filesize & (DIRBLKSIZ - 1)) != 0)
121 idesc->id_filesize = roundup(idesc->id_filesize, DIRBLKSIZ);
122 blksiz = idesc->id_numfrags * sblock.fs_fsize;
123 if (chkrange(idesc->id_blkno, idesc->id_numfrags)) {
124 idesc->id_filesize -= blksiz;
125 return (SKIP);
126 }
127 idesc->id_loc = 0;
128 for (dp = fsck_readdir(idesc); dp != NULL; dp = fsck_readdir(idesc)) {
129 dsize = dp->d_reclen;
130 if (dsize > sizeof(dbuf))
131 dsize = sizeof(dbuf);
132 memmove(dbuf, dp, (size_t)dsize);
133 idesc->id_dirp = (struct direct *)dbuf;
134 if ((n = (*idesc->id_func)(idesc)) & ALTERED) {
135 bp = getdirblk(idesc->id_blkno, blksiz);
136 memmove(bp->b_un.b_buf + idesc->id_loc - dsize, dbuf,
137 (size_t)dsize);
138 dirty(bp);
139 sbdirty();
140 }
141 if (n & STOP)
142 return (n);
143 }
144 return (idesc->id_filesize > 0 ? KEEPON : STOP);
145}
146
147/*
148 * get next entry in a directory.
149 */
150static struct direct *
151fsck_readdir(struct inodesc *idesc)
152{
153 struct direct *dp, *ndp;
154 struct bufarea *bp;
155 long size, blksiz, fix, dploc;
156
157 blksiz = idesc->id_numfrags * sblock.fs_fsize;
158 bp = getdirblk(idesc->id_blkno, blksiz);
159 if (idesc->id_loc % DIRBLKSIZ == 0 && idesc->id_filesize > 0 &&
160 idesc->id_loc < blksiz) {
161 dp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc);
162 if (dircheck(idesc, dp))
163 goto dpok;
164 if (idesc->id_fix == IGNORE)
165 return (0);
166 fix = dofix(idesc, "DIRECTORY CORRUPTED");
167 bp = getdirblk(idesc->id_blkno, blksiz);
168 dp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc);
169 dp->d_reclen = DIRBLKSIZ;
170 dp->d_ino = 0;
171 dp->d_type = 0;
172 dp->d_namlen = 0;
173 dp->d_name[0] = '\0';
174 if (fix)
175 dirty(bp);
176 idesc->id_loc += DIRBLKSIZ;
177 idesc->id_filesize -= DIRBLKSIZ;
178 return (dp);
179 }
180dpok:
181 if (idesc->id_filesize <= 0 || idesc->id_loc >= blksiz)
182 return NULL;
183 dploc = idesc->id_loc;
184 dp = (struct direct *)(bp->b_un.b_buf + dploc);
185 idesc->id_loc += dp->d_reclen;
186 idesc->id_filesize -= dp->d_reclen;
187 if ((idesc->id_loc % DIRBLKSIZ) == 0)
188 return (dp);
189 ndp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc);
190 if (idesc->id_loc < blksiz && idesc->id_filesize > 0 &&
191 dircheck(idesc, ndp) == 0) {
192 size = DIRBLKSIZ - (idesc->id_loc % DIRBLKSIZ);
193 idesc->id_loc += size;
194 idesc->id_filesize -= size;
195 if (idesc->id_fix == IGNORE)
196 return (0);
197 fix = dofix(idesc, "DIRECTORY CORRUPTED");
198 bp = getdirblk(idesc->id_blkno, blksiz);
199 dp = (struct direct *)(bp->b_un.b_buf + dploc);
200 dp->d_reclen += size;
201 if (fix)
202 dirty(bp);
203 }
204 return (dp);
205}
206
207/*
208 * Verify that a directory entry is valid.
209 * This is a superset of the checks made in the kernel.
210 */
211static int
212dircheck(struct inodesc *idesc, struct direct *dp)
213{
| 41
42#include <sys/param.h>
43#include <sys/time.h>
44#include <sys/sysctl.h>
45
46#include <ufs/ufs/dinode.h>
47#include <ufs/ufs/dir.h>
48#include <ufs/ffs/fs.h>
49
50#include <err.h>
51#include <string.h>
52
53#include "fsck.h"
54
55const char *lfname = "lost+found";
56int lfmode = 01777;
57struct dirtemplate emptydir = {
58 0, DIRBLKSIZ, DT_UNKNOWN, 0, "",
59 0, 0, DT_UNKNOWN, 0, ""
60};
61struct dirtemplate dirhead = {
62 0, 12, DT_DIR, 1, ".",
63 0, DIRBLKSIZ - 12, DT_DIR, 2, ".."
64};
65struct odirtemplate odirhead = {
66 0, 12, 1, ".",
67 0, DIRBLKSIZ - 12, 2, ".."
68};
69
70static int chgino(struct inodesc *);
71static int dircheck(struct inodesc *, struct direct *);
72static int expanddir(union dinode *dp, char *name);
73static void freedir(ino_t ino, ino_t parent);
74static struct direct *fsck_readdir(struct inodesc *);
75static struct bufarea *getdirblk(ufs2_daddr_t blkno, long size);
76static int lftempname(char *bufp, ino_t ino);
77static int mkentry(struct inodesc *);
78
79/*
80 * Propagate connected state through the tree.
81 */
82void
83propagate(void)
84{
85 struct inoinfo **inpp, *inp;
86 struct inoinfo **inpend;
87 long change;
88
89 inpend = &inpsort[inplast];
90 do {
91 change = 0;
92 for (inpp = inpsort; inpp < inpend; inpp++) {
93 inp = *inpp;
94 if (inp->i_parent == 0)
95 continue;
96 if (inoinfo(inp->i_parent)->ino_state == DFOUND &&
97 inoinfo(inp->i_number)->ino_state == DSTATE) {
98 inoinfo(inp->i_number)->ino_state = DFOUND;
99 change++;
100 }
101 }
102 } while (change > 0);
103}
104
105/*
106 * Scan each entry in a directory block.
107 */
108int
109dirscan(struct inodesc *idesc)
110{
111 struct direct *dp;
112 struct bufarea *bp;
113 u_int dsize, n;
114 long blksiz;
115 char dbuf[DIRBLKSIZ];
116
117 if (idesc->id_type != DATA)
118 errx(EEXIT, "wrong type to dirscan %d", idesc->id_type);
119 if (idesc->id_entryno == 0 &&
120 (idesc->id_filesize & (DIRBLKSIZ - 1)) != 0)
121 idesc->id_filesize = roundup(idesc->id_filesize, DIRBLKSIZ);
122 blksiz = idesc->id_numfrags * sblock.fs_fsize;
123 if (chkrange(idesc->id_blkno, idesc->id_numfrags)) {
124 idesc->id_filesize -= blksiz;
125 return (SKIP);
126 }
127 idesc->id_loc = 0;
128 for (dp = fsck_readdir(idesc); dp != NULL; dp = fsck_readdir(idesc)) {
129 dsize = dp->d_reclen;
130 if (dsize > sizeof(dbuf))
131 dsize = sizeof(dbuf);
132 memmove(dbuf, dp, (size_t)dsize);
133 idesc->id_dirp = (struct direct *)dbuf;
134 if ((n = (*idesc->id_func)(idesc)) & ALTERED) {
135 bp = getdirblk(idesc->id_blkno, blksiz);
136 memmove(bp->b_un.b_buf + idesc->id_loc - dsize, dbuf,
137 (size_t)dsize);
138 dirty(bp);
139 sbdirty();
140 }
141 if (n & STOP)
142 return (n);
143 }
144 return (idesc->id_filesize > 0 ? KEEPON : STOP);
145}
146
147/*
148 * get next entry in a directory.
149 */
150static struct direct *
151fsck_readdir(struct inodesc *idesc)
152{
153 struct direct *dp, *ndp;
154 struct bufarea *bp;
155 long size, blksiz, fix, dploc;
156
157 blksiz = idesc->id_numfrags * sblock.fs_fsize;
158 bp = getdirblk(idesc->id_blkno, blksiz);
159 if (idesc->id_loc % DIRBLKSIZ == 0 && idesc->id_filesize > 0 &&
160 idesc->id_loc < blksiz) {
161 dp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc);
162 if (dircheck(idesc, dp))
163 goto dpok;
164 if (idesc->id_fix == IGNORE)
165 return (0);
166 fix = dofix(idesc, "DIRECTORY CORRUPTED");
167 bp = getdirblk(idesc->id_blkno, blksiz);
168 dp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc);
169 dp->d_reclen = DIRBLKSIZ;
170 dp->d_ino = 0;
171 dp->d_type = 0;
172 dp->d_namlen = 0;
173 dp->d_name[0] = '\0';
174 if (fix)
175 dirty(bp);
176 idesc->id_loc += DIRBLKSIZ;
177 idesc->id_filesize -= DIRBLKSIZ;
178 return (dp);
179 }
180dpok:
181 if (idesc->id_filesize <= 0 || idesc->id_loc >= blksiz)
182 return NULL;
183 dploc = idesc->id_loc;
184 dp = (struct direct *)(bp->b_un.b_buf + dploc);
185 idesc->id_loc += dp->d_reclen;
186 idesc->id_filesize -= dp->d_reclen;
187 if ((idesc->id_loc % DIRBLKSIZ) == 0)
188 return (dp);
189 ndp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc);
190 if (idesc->id_loc < blksiz && idesc->id_filesize > 0 &&
191 dircheck(idesc, ndp) == 0) {
192 size = DIRBLKSIZ - (idesc->id_loc % DIRBLKSIZ);
193 idesc->id_loc += size;
194 idesc->id_filesize -= size;
195 if (idesc->id_fix == IGNORE)
196 return (0);
197 fix = dofix(idesc, "DIRECTORY CORRUPTED");
198 bp = getdirblk(idesc->id_blkno, blksiz);
199 dp = (struct direct *)(bp->b_un.b_buf + dploc);
200 dp->d_reclen += size;
201 if (fix)
202 dirty(bp);
203 }
204 return (dp);
205}
206
207/*
208 * Verify that a directory entry is valid.
209 * This is a superset of the checks made in the kernel.
210 */
211static int
212dircheck(struct inodesc *idesc, struct direct *dp)
213{
|
217 int spaceleft;
218
219 spaceleft = DIRBLKSIZ - (idesc->id_loc % DIRBLKSIZ);
220 if (dp->d_reclen == 0 ||
221 dp->d_reclen > spaceleft ||
222 (dp->d_reclen & 0x3) != 0)
223 goto bad;
224 if (dp->d_ino == 0)
225 return (1);
226 size = DIRSIZ(0, dp);
227 namlen = dp->d_namlen;
228 type = dp->d_type;
229 if (dp->d_reclen < size ||
230 idesc->id_filesize < size ||
231 namlen > MAXNAMLEN ||
232 type > 15)
233 goto bad;
234 for (cp = dp->d_name, size = 0; size < namlen; size++)
235 if (*cp == '\0' || (*cp++ == '/'))
236 goto bad;
237 if (*cp != '\0')
238 goto bad;
239 return (1);
240bad:
241 if (debug)
242 printf("Bad dir: ino %d reclen %d namlen %d type %d name %s\n",
243 dp->d_ino, dp->d_reclen, dp->d_namlen, dp->d_type,
244 dp->d_name);
245 return (0);
246}
247
248void
249direrror(ino_t ino, const char *errmesg)
250{
251
252 fileerror(ino, ino, errmesg);
253}
254
255void
256fileerror(ino_t cwd, ino_t ino, const char *errmesg)
257{
258 union dinode *dp;
259 char pathbuf[MAXPATHLEN + 1];
260
261 pwarn("%s ", errmesg);
262 pinode(ino);
263 printf("\n");
264 getpathname(pathbuf, cwd, ino);
265 if (ino < ROOTINO || ino > maxino) {
266 pfatal("NAME=%s\n", pathbuf);
267 return;
268 }
269 dp = ginode(ino);
270 if (ftypeok(dp))
271 pfatal("%s=%s\n",
272 (DIP(dp, di_mode) & IFMT) == IFDIR ? "DIR" : "FILE",
273 pathbuf);
274 else
275 pfatal("NAME=%s\n", pathbuf);
276}
277
278void
279adjust(struct inodesc *idesc, int lcnt)
280{
281 union dinode *dp;
282 int saveresolved;
283
284 dp = ginode(idesc->id_number);
285 if (DIP(dp, di_nlink) == lcnt) {
286 /*
287 * If we have not hit any unresolved problems, are running
288 * in preen mode, and are on a file system using soft updates,
289 * then just toss any partially allocated files.
290 */
291 if (resolved && (preen || bkgrdflag) && usedsoftdep) {
292 clri(idesc, "UNREF", 1);
293 return;
294 } else {
295 /*
296 * The file system can be marked clean even if
297 * a file is not linked up, but is cleared.
298 * Hence, resolved should not be cleared when
299 * linkup is answered no, but clri is answered yes.
300 */
301 saveresolved = resolved;
302 if (linkup(idesc->id_number, (ino_t)0, NULL) == 0) {
303 resolved = saveresolved;
304 clri(idesc, "UNREF", 0);
305 return;
306 }
307 /*
308 * Account for the new reference created by linkup().
309 */
310 dp = ginode(idesc->id_number);
311 lcnt--;
312 }
313 }
314 if (lcnt != 0) {
315 pwarn("LINK COUNT %s", (lfdir == idesc->id_number) ? lfname :
316 ((DIP(dp, di_mode) & IFMT) == IFDIR ? "DIR" : "FILE"));
317 pinode(idesc->id_number);
318 printf(" COUNT %d SHOULD BE %d",
319 DIP(dp, di_nlink), DIP(dp, di_nlink) - lcnt);
320 if (preen || usedsoftdep) {
321 if (lcnt < 0) {
322 printf("\n");
323 pfatal("LINK COUNT INCREASING");
324 }
325 if (preen)
326 printf(" (ADJUSTED)\n");
327 }
328 if (preen || reply("ADJUST") == 1) {
329 if (bkgrdflag == 0) {
330 DIP(dp, di_nlink) -= lcnt;
331 inodirty();
332 } else {
333 cmd.value = idesc->id_number;
334 cmd.size = -lcnt;
335 if (debug)
336 printf("adjrefcnt ino %ld amt %lld\n",
337 (long)cmd.value,
338 (long long)cmd.size);
339 if (sysctl(adjrefcnt, MIBSIZE, 0, 0,
340 &cmd, sizeof cmd) == -1)
341 rwerror("ADJUST INODE", cmd.value);
342 }
343 }
344 }
345}
346
347static int
348mkentry(struct inodesc *idesc)
349{
350 struct direct *dirp = idesc->id_dirp;
351 struct direct newent;
352 int newlen, oldlen;
353
354 newent.d_namlen = strlen(idesc->id_name);
355 newlen = DIRSIZ(0, &newent);
356 if (dirp->d_ino != 0)
357 oldlen = DIRSIZ(0, dirp);
358 else
359 oldlen = 0;
360 if (dirp->d_reclen - oldlen < newlen)
361 return (KEEPON);
362 newent.d_reclen = dirp->d_reclen - oldlen;
363 dirp->d_reclen = oldlen;
364 dirp = (struct direct *)(((char *)dirp) + oldlen);
365 dirp->d_ino = idesc->id_parent; /* ino to be entered is in id_parent */
366 dirp->d_reclen = newent.d_reclen;
367 dirp->d_type = inoinfo(idesc->id_parent)->ino_type;
368 dirp->d_namlen = newent.d_namlen;
369 memmove(dirp->d_name, idesc->id_name, (size_t)newent.d_namlen + 1);
370 return (ALTERED|STOP);
371}
372
373static int
374chgino(struct inodesc *idesc)
375{
376 struct direct *dirp = idesc->id_dirp;
377
378 if (memcmp(dirp->d_name, idesc->id_name, (int)dirp->d_namlen + 1))
379 return (KEEPON);
380 dirp->d_ino = idesc->id_parent;
381 dirp->d_type = inoinfo(idesc->id_parent)->ino_type;
382 return (ALTERED|STOP);
383}
384
385int
386linkup(ino_t orphan, ino_t parentdir, char *name)
387{
388 union dinode *dp;
389 int lostdir;
390 ino_t oldlfdir;
391 struct inodesc idesc;
392 char tempname[BUFSIZ];
393
394 memset(&idesc, 0, sizeof(struct inodesc));
395 dp = ginode(orphan);
396 lostdir = (DIP(dp, di_mode) & IFMT) == IFDIR;
397 pwarn("UNREF %s ", lostdir ? "DIR" : "FILE");
398 pinode(orphan);
399 if (preen && DIP(dp, di_size) == 0)
400 return (0);
401 if (cursnapshot != 0) {
402 pfatal("FILE LINKUP IN SNAPSHOT");
403 return (0);
404 }
405 if (preen)
406 printf(" (RECONNECTED)\n");
407 else
408 if (reply("RECONNECT") == 0)
409 return (0);
410 if (lfdir == 0) {
411 dp = ginode(ROOTINO);
412 idesc.id_name = strdup(lfname);
413 idesc.id_type = DATA;
414 idesc.id_func = findino;
415 idesc.id_number = ROOTINO;
416 if ((ckinode(dp, &idesc) & FOUND) != 0) {
417 lfdir = idesc.id_parent;
418 } else {
419 pwarn("NO lost+found DIRECTORY");
420 if (preen || reply("CREATE")) {
421 lfdir = allocdir(ROOTINO, (ino_t)0, lfmode);
422 if (lfdir != 0) {
423 if (makeentry(ROOTINO, lfdir, lfname) != 0) {
424 numdirs++;
425 if (preen)
426 printf(" (CREATED)\n");
427 } else {
428 freedir(lfdir, ROOTINO);
429 lfdir = 0;
430 if (preen)
431 printf("\n");
432 }
433 }
434 }
435 }
436 if (lfdir == 0) {
437 pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY");
438 printf("\n\n");
439 return (0);
440 }
441 }
442 dp = ginode(lfdir);
443 if ((DIP(dp, di_mode) & IFMT) != IFDIR) {
444 pfatal("lost+found IS NOT A DIRECTORY");
445 if (reply("REALLOCATE") == 0)
446 return (0);
447 oldlfdir = lfdir;
448 if ((lfdir = allocdir(ROOTINO, (ino_t)0, lfmode)) == 0) {
449 pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n");
450 return (0);
451 }
452 if ((changeino(ROOTINO, lfname, lfdir) & ALTERED) == 0) {
453 pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n");
454 return (0);
455 }
456 inodirty();
457 idesc.id_type = ADDR;
458 idesc.id_func = pass4check;
459 idesc.id_number = oldlfdir;
460 adjust(&idesc, inoinfo(oldlfdir)->ino_linkcnt + 1);
461 inoinfo(oldlfdir)->ino_linkcnt = 0;
462 dp = ginode(lfdir);
463 }
464 if (inoinfo(lfdir)->ino_state != DFOUND) {
465 pfatal("SORRY. NO lost+found DIRECTORY\n\n");
466 return (0);
467 }
468 (void)lftempname(tempname, orphan);
469 if (makeentry(lfdir, orphan, (name ? name : tempname)) == 0) {
470 pfatal("SORRY. NO SPACE IN lost+found DIRECTORY");
471 printf("\n\n");
472 return (0);
473 }
474 inoinfo(orphan)->ino_linkcnt--;
475 if (lostdir) {
476 if ((changeino(orphan, "..", lfdir) & ALTERED) == 0 &&
477 parentdir != (ino_t)-1)
478 (void)makeentry(orphan, lfdir, "..");
479 dp = ginode(lfdir);
480 DIP(dp, di_nlink)++;
481 inodirty();
482 inoinfo(lfdir)->ino_linkcnt++;
483 pwarn("DIR I=%lu CONNECTED. ", (u_long)orphan);
484 if (parentdir != (ino_t)-1) {
485 printf("PARENT WAS I=%lu\n", (u_long)parentdir);
486 /*
487 * The parent directory, because of the ordering
488 * guarantees, has had the link count incremented
489 * for the child, but no entry was made. This
490 * fixes the parent link count so that fsck does
491 * not need to be rerun.
492 */
493 inoinfo(parentdir)->ino_linkcnt++;
494 }
495 if (preen == 0)
496 printf("\n");
497 }
498 return (1);
499}
500
501/*
502 * fix an entry in a directory.
503 */
504int
505changeino(ino_t dir, const char *name, ino_t newnum)
506{
507 struct inodesc idesc;
508
509 memset(&idesc, 0, sizeof(struct inodesc));
510 idesc.id_type = DATA;
511 idesc.id_func = chgino;
512 idesc.id_number = dir;
513 idesc.id_fix = DONTKNOW;
514 idesc.id_name = strdup(name);
515 idesc.id_parent = newnum; /* new value for name */
516 return (ckinode(ginode(dir), &idesc));
517}
518
519/*
520 * make an entry in a directory
521 */
522int
523makeentry(ino_t parent, ino_t ino, const char *name)
524{
525 union dinode *dp;
526 struct inodesc idesc;
527 char pathbuf[MAXPATHLEN + 1];
528
529 if (parent < ROOTINO || parent >= maxino ||
530 ino < ROOTINO || ino >= maxino)
531 return (0);
532 memset(&idesc, 0, sizeof(struct inodesc));
533 idesc.id_type = DATA;
534 idesc.id_func = mkentry;
535 idesc.id_number = parent;
536 idesc.id_parent = ino; /* this is the inode to enter */
537 idesc.id_fix = DONTKNOW;
538 idesc.id_name = strdup(name);
539 dp = ginode(parent);
540 if (DIP(dp, di_size) % DIRBLKSIZ) {
541 DIP(dp, di_size) = roundup(DIP(dp, di_size), DIRBLKSIZ);
542 inodirty();
543 }
544 if ((ckinode(dp, &idesc) & ALTERED) != 0)
545 return (1);
546 getpathname(pathbuf, parent, parent);
547 dp = ginode(parent);
548 if (expanddir(dp, pathbuf) == 0)
549 return (0);
550 return (ckinode(dp, &idesc) & ALTERED);
551}
552
553/*
554 * Attempt to expand the size of a directory
555 */
556static int
557expanddir(union dinode *dp, char *name)
558{
559 ufs2_daddr_t lastbn, newblk;
560 struct bufarea *bp;
561 char *cp, firstblk[DIRBLKSIZ];
562
563 lastbn = lblkno(&sblock, DIP(dp, di_size));
564 if (lastbn >= NDADDR - 1 || DIP(dp, di_db[lastbn]) == 0 ||
565 DIP(dp, di_size) == 0)
566 return (0);
567 if ((newblk = allocblk(sblock.fs_frag)) == 0)
568 return (0);
569 DIP(dp, di_db[lastbn + 1]) = DIP(dp, di_db[lastbn]);
570 DIP(dp, di_db[lastbn]) = newblk;
571 DIP(dp, di_size) += sblock.fs_bsize;
572 DIP(dp, di_blocks) += btodb(sblock.fs_bsize);
573 bp = getdirblk(DIP(dp, di_db[lastbn + 1]),
574 sblksize(&sblock, DIP(dp, di_size), lastbn + 1));
575 if (bp->b_errs)
576 goto bad;
577 memmove(firstblk, bp->b_un.b_buf, DIRBLKSIZ);
578 bp = getdirblk(newblk, sblock.fs_bsize);
579 if (bp->b_errs)
580 goto bad;
581 memmove(bp->b_un.b_buf, firstblk, DIRBLKSIZ);
582 for (cp = &bp->b_un.b_buf[DIRBLKSIZ];
583 cp < &bp->b_un.b_buf[sblock.fs_bsize];
584 cp += DIRBLKSIZ)
585 memmove(cp, &emptydir, sizeof emptydir);
586 dirty(bp);
587 bp = getdirblk(DIP(dp, di_db[lastbn + 1]),
588 sblksize(&sblock, DIP(dp, di_size), lastbn + 1));
589 if (bp->b_errs)
590 goto bad;
591 memmove(bp->b_un.b_buf, &emptydir, sizeof emptydir);
592 pwarn("NO SPACE LEFT IN %s", name);
593 if (preen)
594 printf(" (EXPANDED)\n");
595 else if (reply("EXPAND") == 0)
596 goto bad;
597 dirty(bp);
598 inodirty();
599 return (1);
600bad:
601 DIP(dp, di_db[lastbn]) = DIP(dp, di_db[lastbn + 1]);
602 DIP(dp, di_db[lastbn + 1]) = 0;
603 DIP(dp, di_size) -= sblock.fs_bsize;
604 DIP(dp, di_blocks) -= btodb(sblock.fs_bsize);
605 freeblk(newblk, sblock.fs_frag);
606 return (0);
607}
608
609/*
610 * allocate a new directory
611 */
612ino_t
613allocdir(ino_t parent, ino_t request, int mode)
614{
615 ino_t ino;
616 char *cp;
617 union dinode *dp;
618 struct bufarea *bp;
619 struct inoinfo *inp;
620 struct dirtemplate *dirp;
621
622 ino = allocino(request, IFDIR|mode);
623 dirp = &dirhead;
624 dirp->dot_ino = ino;
625 dirp->dotdot_ino = parent;
626 dp = ginode(ino);
627 bp = getdirblk(DIP(dp, di_db[0]), sblock.fs_fsize);
628 if (bp->b_errs) {
629 freeino(ino);
630 return (0);
631 }
632 memmove(bp->b_un.b_buf, dirp, sizeof(struct dirtemplate));
633 for (cp = &bp->b_un.b_buf[DIRBLKSIZ];
634 cp < &bp->b_un.b_buf[sblock.fs_fsize];
635 cp += DIRBLKSIZ)
636 memmove(cp, &emptydir, sizeof emptydir);
637 dirty(bp);
638 DIP(dp, di_nlink) = 2;
639 inodirty();
640 if (ino == ROOTINO) {
641 inoinfo(ino)->ino_linkcnt = DIP(dp, di_nlink);
642 cacheino(dp, ino);
643 return(ino);
644 }
645 if (inoinfo(parent)->ino_state != DSTATE &&
646 inoinfo(parent)->ino_state != DFOUND) {
647 freeino(ino);
648 return (0);
649 }
650 cacheino(dp, ino);
651 inp = getinoinfo(ino);
652 inp->i_parent = parent;
653 inp->i_dotdot = parent;
654 inoinfo(ino)->ino_state = inoinfo(parent)->ino_state;
655 if (inoinfo(ino)->ino_state == DSTATE) {
656 inoinfo(ino)->ino_linkcnt = DIP(dp, di_nlink);
657 inoinfo(parent)->ino_linkcnt++;
658 }
659 dp = ginode(parent);
660 DIP(dp, di_nlink)++;
661 inodirty();
662 return (ino);
663}
664
665/*
666 * free a directory inode
667 */
668static void
669freedir(ino_t ino, ino_t parent)
670{
671 union dinode *dp;
672
673 if (ino != parent) {
674 dp = ginode(parent);
675 DIP(dp, di_nlink)--;
676 inodirty();
677 }
678 freeino(ino);
679}
680
681/*
682 * generate a temporary name for the lost+found directory.
683 */
684static int
685lftempname(char *bufp, ino_t ino)
686{
687 ino_t in;
688 char *cp;
689 int namlen;
690
691 cp = bufp + 2;
692 for (in = maxino; in > 0; in /= 10)
693 cp++;
694 *--cp = 0;
695 namlen = cp - bufp;
696 in = ino;
697 while (cp > bufp) {
698 *--cp = (in % 10) + '0';
699 in /= 10;
700 }
701 *cp = '#';
702 return (namlen);
703}
704
705/*
706 * Get a directory block.
707 * Insure that it is held until another is requested.
708 */
709static struct bufarea *
710getdirblk(ufs2_daddr_t blkno, long size)
711{
712
713 if (pdirbp != 0)
714 pdirbp->b_flags &= ~B_INUSE;
715 pdirbp = getdatablk(blkno, size);
716 return (pdirbp);
717}
| 218 int spaceleft;
219
220 spaceleft = DIRBLKSIZ - (idesc->id_loc % DIRBLKSIZ);
221 if (dp->d_reclen == 0 ||
222 dp->d_reclen > spaceleft ||
223 (dp->d_reclen & 0x3) != 0)
224 goto bad;
225 if (dp->d_ino == 0)
226 return (1);
227 size = DIRSIZ(0, dp);
228 namlen = dp->d_namlen;
229 type = dp->d_type;
230 if (dp->d_reclen < size ||
231 idesc->id_filesize < size ||
232 namlen > MAXNAMLEN ||
233 type > 15)
234 goto bad;
235 for (cp = dp->d_name, size = 0; size < namlen; size++)
236 if (*cp == '\0' || (*cp++ == '/'))
237 goto bad;
238 if (*cp != '\0')
239 goto bad;
240 return (1);
241bad:
242 if (debug)
243 printf("Bad dir: ino %d reclen %d namlen %d type %d name %s\n",
244 dp->d_ino, dp->d_reclen, dp->d_namlen, dp->d_type,
245 dp->d_name);
246 return (0);
247}
248
249void
250direrror(ino_t ino, const char *errmesg)
251{
252
253 fileerror(ino, ino, errmesg);
254}
255
256void
257fileerror(ino_t cwd, ino_t ino, const char *errmesg)
258{
259 union dinode *dp;
260 char pathbuf[MAXPATHLEN + 1];
261
262 pwarn("%s ", errmesg);
263 pinode(ino);
264 printf("\n");
265 getpathname(pathbuf, cwd, ino);
266 if (ino < ROOTINO || ino > maxino) {
267 pfatal("NAME=%s\n", pathbuf);
268 return;
269 }
270 dp = ginode(ino);
271 if (ftypeok(dp))
272 pfatal("%s=%s\n",
273 (DIP(dp, di_mode) & IFMT) == IFDIR ? "DIR" : "FILE",
274 pathbuf);
275 else
276 pfatal("NAME=%s\n", pathbuf);
277}
278
279void
280adjust(struct inodesc *idesc, int lcnt)
281{
282 union dinode *dp;
283 int saveresolved;
284
285 dp = ginode(idesc->id_number);
286 if (DIP(dp, di_nlink) == lcnt) {
287 /*
288 * If we have not hit any unresolved problems, are running
289 * in preen mode, and are on a file system using soft updates,
290 * then just toss any partially allocated files.
291 */
292 if (resolved && (preen || bkgrdflag) && usedsoftdep) {
293 clri(idesc, "UNREF", 1);
294 return;
295 } else {
296 /*
297 * The file system can be marked clean even if
298 * a file is not linked up, but is cleared.
299 * Hence, resolved should not be cleared when
300 * linkup is answered no, but clri is answered yes.
301 */
302 saveresolved = resolved;
303 if (linkup(idesc->id_number, (ino_t)0, NULL) == 0) {
304 resolved = saveresolved;
305 clri(idesc, "UNREF", 0);
306 return;
307 }
308 /*
309 * Account for the new reference created by linkup().
310 */
311 dp = ginode(idesc->id_number);
312 lcnt--;
313 }
314 }
315 if (lcnt != 0) {
316 pwarn("LINK COUNT %s", (lfdir == idesc->id_number) ? lfname :
317 ((DIP(dp, di_mode) & IFMT) == IFDIR ? "DIR" : "FILE"));
318 pinode(idesc->id_number);
319 printf(" COUNT %d SHOULD BE %d",
320 DIP(dp, di_nlink), DIP(dp, di_nlink) - lcnt);
321 if (preen || usedsoftdep) {
322 if (lcnt < 0) {
323 printf("\n");
324 pfatal("LINK COUNT INCREASING");
325 }
326 if (preen)
327 printf(" (ADJUSTED)\n");
328 }
329 if (preen || reply("ADJUST") == 1) {
330 if (bkgrdflag == 0) {
331 DIP(dp, di_nlink) -= lcnt;
332 inodirty();
333 } else {
334 cmd.value = idesc->id_number;
335 cmd.size = -lcnt;
336 if (debug)
337 printf("adjrefcnt ino %ld amt %lld\n",
338 (long)cmd.value,
339 (long long)cmd.size);
340 if (sysctl(adjrefcnt, MIBSIZE, 0, 0,
341 &cmd, sizeof cmd) == -1)
342 rwerror("ADJUST INODE", cmd.value);
343 }
344 }
345 }
346}
347
348static int
349mkentry(struct inodesc *idesc)
350{
351 struct direct *dirp = idesc->id_dirp;
352 struct direct newent;
353 int newlen, oldlen;
354
355 newent.d_namlen = strlen(idesc->id_name);
356 newlen = DIRSIZ(0, &newent);
357 if (dirp->d_ino != 0)
358 oldlen = DIRSIZ(0, dirp);
359 else
360 oldlen = 0;
361 if (dirp->d_reclen - oldlen < newlen)
362 return (KEEPON);
363 newent.d_reclen = dirp->d_reclen - oldlen;
364 dirp->d_reclen = oldlen;
365 dirp = (struct direct *)(((char *)dirp) + oldlen);
366 dirp->d_ino = idesc->id_parent; /* ino to be entered is in id_parent */
367 dirp->d_reclen = newent.d_reclen;
368 dirp->d_type = inoinfo(idesc->id_parent)->ino_type;
369 dirp->d_namlen = newent.d_namlen;
370 memmove(dirp->d_name, idesc->id_name, (size_t)newent.d_namlen + 1);
371 return (ALTERED|STOP);
372}
373
374static int
375chgino(struct inodesc *idesc)
376{
377 struct direct *dirp = idesc->id_dirp;
378
379 if (memcmp(dirp->d_name, idesc->id_name, (int)dirp->d_namlen + 1))
380 return (KEEPON);
381 dirp->d_ino = idesc->id_parent;
382 dirp->d_type = inoinfo(idesc->id_parent)->ino_type;
383 return (ALTERED|STOP);
384}
385
386int
387linkup(ino_t orphan, ino_t parentdir, char *name)
388{
389 union dinode *dp;
390 int lostdir;
391 ino_t oldlfdir;
392 struct inodesc idesc;
393 char tempname[BUFSIZ];
394
395 memset(&idesc, 0, sizeof(struct inodesc));
396 dp = ginode(orphan);
397 lostdir = (DIP(dp, di_mode) & IFMT) == IFDIR;
398 pwarn("UNREF %s ", lostdir ? "DIR" : "FILE");
399 pinode(orphan);
400 if (preen && DIP(dp, di_size) == 0)
401 return (0);
402 if (cursnapshot != 0) {
403 pfatal("FILE LINKUP IN SNAPSHOT");
404 return (0);
405 }
406 if (preen)
407 printf(" (RECONNECTED)\n");
408 else
409 if (reply("RECONNECT") == 0)
410 return (0);
411 if (lfdir == 0) {
412 dp = ginode(ROOTINO);
413 idesc.id_name = strdup(lfname);
414 idesc.id_type = DATA;
415 idesc.id_func = findino;
416 idesc.id_number = ROOTINO;
417 if ((ckinode(dp, &idesc) & FOUND) != 0) {
418 lfdir = idesc.id_parent;
419 } else {
420 pwarn("NO lost+found DIRECTORY");
421 if (preen || reply("CREATE")) {
422 lfdir = allocdir(ROOTINO, (ino_t)0, lfmode);
423 if (lfdir != 0) {
424 if (makeentry(ROOTINO, lfdir, lfname) != 0) {
425 numdirs++;
426 if (preen)
427 printf(" (CREATED)\n");
428 } else {
429 freedir(lfdir, ROOTINO);
430 lfdir = 0;
431 if (preen)
432 printf("\n");
433 }
434 }
435 }
436 }
437 if (lfdir == 0) {
438 pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY");
439 printf("\n\n");
440 return (0);
441 }
442 }
443 dp = ginode(lfdir);
444 if ((DIP(dp, di_mode) & IFMT) != IFDIR) {
445 pfatal("lost+found IS NOT A DIRECTORY");
446 if (reply("REALLOCATE") == 0)
447 return (0);
448 oldlfdir = lfdir;
449 if ((lfdir = allocdir(ROOTINO, (ino_t)0, lfmode)) == 0) {
450 pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n");
451 return (0);
452 }
453 if ((changeino(ROOTINO, lfname, lfdir) & ALTERED) == 0) {
454 pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n");
455 return (0);
456 }
457 inodirty();
458 idesc.id_type = ADDR;
459 idesc.id_func = pass4check;
460 idesc.id_number = oldlfdir;
461 adjust(&idesc, inoinfo(oldlfdir)->ino_linkcnt + 1);
462 inoinfo(oldlfdir)->ino_linkcnt = 0;
463 dp = ginode(lfdir);
464 }
465 if (inoinfo(lfdir)->ino_state != DFOUND) {
466 pfatal("SORRY. NO lost+found DIRECTORY\n\n");
467 return (0);
468 }
469 (void)lftempname(tempname, orphan);
470 if (makeentry(lfdir, orphan, (name ? name : tempname)) == 0) {
471 pfatal("SORRY. NO SPACE IN lost+found DIRECTORY");
472 printf("\n\n");
473 return (0);
474 }
475 inoinfo(orphan)->ino_linkcnt--;
476 if (lostdir) {
477 if ((changeino(orphan, "..", lfdir) & ALTERED) == 0 &&
478 parentdir != (ino_t)-1)
479 (void)makeentry(orphan, lfdir, "..");
480 dp = ginode(lfdir);
481 DIP(dp, di_nlink)++;
482 inodirty();
483 inoinfo(lfdir)->ino_linkcnt++;
484 pwarn("DIR I=%lu CONNECTED. ", (u_long)orphan);
485 if (parentdir != (ino_t)-1) {
486 printf("PARENT WAS I=%lu\n", (u_long)parentdir);
487 /*
488 * The parent directory, because of the ordering
489 * guarantees, has had the link count incremented
490 * for the child, but no entry was made. This
491 * fixes the parent link count so that fsck does
492 * not need to be rerun.
493 */
494 inoinfo(parentdir)->ino_linkcnt++;
495 }
496 if (preen == 0)
497 printf("\n");
498 }
499 return (1);
500}
501
502/*
503 * fix an entry in a directory.
504 */
505int
506changeino(ino_t dir, const char *name, ino_t newnum)
507{
508 struct inodesc idesc;
509
510 memset(&idesc, 0, sizeof(struct inodesc));
511 idesc.id_type = DATA;
512 idesc.id_func = chgino;
513 idesc.id_number = dir;
514 idesc.id_fix = DONTKNOW;
515 idesc.id_name = strdup(name);
516 idesc.id_parent = newnum; /* new value for name */
517 return (ckinode(ginode(dir), &idesc));
518}
519
520/*
521 * make an entry in a directory
522 */
523int
524makeentry(ino_t parent, ino_t ino, const char *name)
525{
526 union dinode *dp;
527 struct inodesc idesc;
528 char pathbuf[MAXPATHLEN + 1];
529
530 if (parent < ROOTINO || parent >= maxino ||
531 ino < ROOTINO || ino >= maxino)
532 return (0);
533 memset(&idesc, 0, sizeof(struct inodesc));
534 idesc.id_type = DATA;
535 idesc.id_func = mkentry;
536 idesc.id_number = parent;
537 idesc.id_parent = ino; /* this is the inode to enter */
538 idesc.id_fix = DONTKNOW;
539 idesc.id_name = strdup(name);
540 dp = ginode(parent);
541 if (DIP(dp, di_size) % DIRBLKSIZ) {
542 DIP(dp, di_size) = roundup(DIP(dp, di_size), DIRBLKSIZ);
543 inodirty();
544 }
545 if ((ckinode(dp, &idesc) & ALTERED) != 0)
546 return (1);
547 getpathname(pathbuf, parent, parent);
548 dp = ginode(parent);
549 if (expanddir(dp, pathbuf) == 0)
550 return (0);
551 return (ckinode(dp, &idesc) & ALTERED);
552}
553
554/*
555 * Attempt to expand the size of a directory
556 */
557static int
558expanddir(union dinode *dp, char *name)
559{
560 ufs2_daddr_t lastbn, newblk;
561 struct bufarea *bp;
562 char *cp, firstblk[DIRBLKSIZ];
563
564 lastbn = lblkno(&sblock, DIP(dp, di_size));
565 if (lastbn >= NDADDR - 1 || DIP(dp, di_db[lastbn]) == 0 ||
566 DIP(dp, di_size) == 0)
567 return (0);
568 if ((newblk = allocblk(sblock.fs_frag)) == 0)
569 return (0);
570 DIP(dp, di_db[lastbn + 1]) = DIP(dp, di_db[lastbn]);
571 DIP(dp, di_db[lastbn]) = newblk;
572 DIP(dp, di_size) += sblock.fs_bsize;
573 DIP(dp, di_blocks) += btodb(sblock.fs_bsize);
574 bp = getdirblk(DIP(dp, di_db[lastbn + 1]),
575 sblksize(&sblock, DIP(dp, di_size), lastbn + 1));
576 if (bp->b_errs)
577 goto bad;
578 memmove(firstblk, bp->b_un.b_buf, DIRBLKSIZ);
579 bp = getdirblk(newblk, sblock.fs_bsize);
580 if (bp->b_errs)
581 goto bad;
582 memmove(bp->b_un.b_buf, firstblk, DIRBLKSIZ);
583 for (cp = &bp->b_un.b_buf[DIRBLKSIZ];
584 cp < &bp->b_un.b_buf[sblock.fs_bsize];
585 cp += DIRBLKSIZ)
586 memmove(cp, &emptydir, sizeof emptydir);
587 dirty(bp);
588 bp = getdirblk(DIP(dp, di_db[lastbn + 1]),
589 sblksize(&sblock, DIP(dp, di_size), lastbn + 1));
590 if (bp->b_errs)
591 goto bad;
592 memmove(bp->b_un.b_buf, &emptydir, sizeof emptydir);
593 pwarn("NO SPACE LEFT IN %s", name);
594 if (preen)
595 printf(" (EXPANDED)\n");
596 else if (reply("EXPAND") == 0)
597 goto bad;
598 dirty(bp);
599 inodirty();
600 return (1);
601bad:
602 DIP(dp, di_db[lastbn]) = DIP(dp, di_db[lastbn + 1]);
603 DIP(dp, di_db[lastbn + 1]) = 0;
604 DIP(dp, di_size) -= sblock.fs_bsize;
605 DIP(dp, di_blocks) -= btodb(sblock.fs_bsize);
606 freeblk(newblk, sblock.fs_frag);
607 return (0);
608}
609
610/*
611 * allocate a new directory
612 */
613ino_t
614allocdir(ino_t parent, ino_t request, int mode)
615{
616 ino_t ino;
617 char *cp;
618 union dinode *dp;
619 struct bufarea *bp;
620 struct inoinfo *inp;
621 struct dirtemplate *dirp;
622
623 ino = allocino(request, IFDIR|mode);
624 dirp = &dirhead;
625 dirp->dot_ino = ino;
626 dirp->dotdot_ino = parent;
627 dp = ginode(ino);
628 bp = getdirblk(DIP(dp, di_db[0]), sblock.fs_fsize);
629 if (bp->b_errs) {
630 freeino(ino);
631 return (0);
632 }
633 memmove(bp->b_un.b_buf, dirp, sizeof(struct dirtemplate));
634 for (cp = &bp->b_un.b_buf[DIRBLKSIZ];
635 cp < &bp->b_un.b_buf[sblock.fs_fsize];
636 cp += DIRBLKSIZ)
637 memmove(cp, &emptydir, sizeof emptydir);
638 dirty(bp);
639 DIP(dp, di_nlink) = 2;
640 inodirty();
641 if (ino == ROOTINO) {
642 inoinfo(ino)->ino_linkcnt = DIP(dp, di_nlink);
643 cacheino(dp, ino);
644 return(ino);
645 }
646 if (inoinfo(parent)->ino_state != DSTATE &&
647 inoinfo(parent)->ino_state != DFOUND) {
648 freeino(ino);
649 return (0);
650 }
651 cacheino(dp, ino);
652 inp = getinoinfo(ino);
653 inp->i_parent = parent;
654 inp->i_dotdot = parent;
655 inoinfo(ino)->ino_state = inoinfo(parent)->ino_state;
656 if (inoinfo(ino)->ino_state == DSTATE) {
657 inoinfo(ino)->ino_linkcnt = DIP(dp, di_nlink);
658 inoinfo(parent)->ino_linkcnt++;
659 }
660 dp = ginode(parent);
661 DIP(dp, di_nlink)++;
662 inodirty();
663 return (ino);
664}
665
666/*
667 * free a directory inode
668 */
669static void
670freedir(ino_t ino, ino_t parent)
671{
672 union dinode *dp;
673
674 if (ino != parent) {
675 dp = ginode(parent);
676 DIP(dp, di_nlink)--;
677 inodirty();
678 }
679 freeino(ino);
680}
681
682/*
683 * generate a temporary name for the lost+found directory.
684 */
685static int
686lftempname(char *bufp, ino_t ino)
687{
688 ino_t in;
689 char *cp;
690 int namlen;
691
692 cp = bufp + 2;
693 for (in = maxino; in > 0; in /= 10)
694 cp++;
695 *--cp = 0;
696 namlen = cp - bufp;
697 in = ino;
698 while (cp > bufp) {
699 *--cp = (in % 10) + '0';
700 in /= 10;
701 }
702 *cp = '#';
703 return (namlen);
704}
705
706/*
707 * Get a directory block.
708 * Insure that it is held until another is requested.
709 */
710static struct bufarea *
711getdirblk(ufs2_daddr_t blkno, long size)
712{
713
714 if (pdirbp != 0)
715 pdirbp->b_flags &= ~B_INUSE;
716 pdirbp = getdatablk(blkno, size);
717 return (pdirbp);
718}
|