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[] = "@(#)inode.c 8.5 (Berkeley) 2/8/95";
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 <pwd.h>
44#include <stdio.h>
45#include <stdlib.h>
46#include <string.h>
47#include "fsck.h"
48
49static ino_t startinum;
50
51static int iblock __P((struct inodesc *idesc, long ilevel, quad_t isize));
52
53int
54ckinode(dp, idesc)
55 struct dinode *dp;
56 register struct inodesc *idesc;
57{
58 register daddr_t *ap;
59 int ret;
60 long n, ndb, offset;
61 struct dinode dino;
62 quad_t remsize, sizepb;
63 mode_t mode;
64 char pathbuf[MAXPATHLEN + 1];
65
66 if (idesc->id_fix != IGNORE)
67 idesc->id_fix = DONTKNOW;
68 idesc->id_entryno = 0;

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

142}
143
144static int
145iblock(idesc, ilevel, isize)
146 struct inodesc *idesc;
147 long ilevel;
148 quad_t isize;
149{
150 register daddr_t *ap;
151 register daddr_t *aplim;
152 register struct bufarea *bp;
153 int i, n, (*func)(), nif;
154 quad_t sizepb;
155 char buf[BUFSIZ];
156 char pathbuf[MAXPATHLEN + 1];
157 struct dinode *dp;
158
159 if (idesc->id_type == ADDR) {
160 func = idesc->id_func;

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

224}
225
226/*
227 * Check that a block in a legal block number.
228 * Return 0 if in range, 1 if out of range.
229 */
230int
231chkrange(blk, cnt)
232 daddr_t blk;
233 int cnt;
234{
235 register int c;
236
237 if ((unsigned)(blk + cnt) > maxfsblock)
238 return (1);
239 c = dtog(&sblock, blk);
240 if (blk < cgdmin(&sblock, c)) {

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

263
264/*
265 * General purpose interface for reading inodes.
266 */
267struct dinode *
268ginode(inumber)
269 ino_t inumber;
270{
271 daddr_t iblk;
272
273 if (inumber < ROOTINO || inumber > maxino)
274 errexit("bad inode number %d to ginode\n", inumber);
275 if (startinum == 0 ||
276 inumber < startinum || inumber >= startinum + INOPB(&sblock)) {
277 iblk = ino_to_fsba(&sblock, inumber);
278 if (pbp != 0)
279 pbp->b_flags &= ~B_INUSE;
280 pbp = getdatablk(iblk, sblock.fs_bsize);
281 startinum = (inumber / INOPB(&sblock)) * INOPB(&sblock);
282 }

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

291long readcnt, readpercg, fullcnt, inobufsize, partialcnt, partialsize;
292struct dinode *inodebuf;
293
294struct dinode *
295getnextinode(inumber)
296 ino_t inumber;
297{
298 long size;
299 daddr_t dblk;
300 static struct dinode *dp;
301
302 if (inumber != nextino++ || inumber > maxino)
303 errexit("bad inode number %d to nextinode\n", inumber);
304 if (inumber >= lastinum) {
305 readcnt++;
306 dblk = fsbtodb(&sblock, ino_to_fsba(&sblock, lastinum));
307 if (readcnt % readpercg == 0) {
308 size = partialsize;
309 lastinum += partialcnt;
310 } else {
311 size = inobufsize;

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

333 if (partialcnt != 0) {
334 readpercg++;
335 } else {
336 partialcnt = fullcnt;
337 partialsize = inobufsize;
338 }
339 if (inodebuf == NULL &&
340 (inodebuf = (struct dinode *)malloc((unsigned)inobufsize)) == NULL)
341 errexit("Cannot allocate space for inode buffer\n");
342 while (nextino < ROOTINO)
343 (void)getnextinode(nextino);
344}
345
346void
347freeinodebuf()
348{
349

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

367 register struct inoinfo *inp;
368 struct inoinfo **inpp;
369 unsigned int blks;
370
371 blks = howmany(dp->di_size, sblock.fs_bsize);
372 if (blks > NDADDR)
373 blks = NDADDR + NIADDR;
374 inp = (struct inoinfo *)
375 malloc(sizeof(*inp) + (blks - 1) * sizeof(daddr_t));
376 if (inp == NULL)
377 return;
378 inpp = &inphead[inumber % numdirs];
379 inp->i_nexthash = *inpp;
380 *inpp = inp;
381 if (inumber == ROOTINO)
382 inp->i_parent = ROOTINO;
383 else
384 inp->i_parent = (ino_t)0;
385 inp->i_dotdot = (ino_t)0;
386 inp->i_number = inumber;
387 inp->i_isize = dp->di_size;
388 inp->i_numblks = blks * sizeof(daddr_t);
389 bcopy((char *)&dp->di_db[0], (char *)&inp->i_blks[0],
390 (size_t)inp->i_numblks);
391 if (inplast == listmax) {
392 listmax += 100;
393 inpsort = (struct inoinfo **)realloc((char *)inpsort,
394 (unsigned)listmax * sizeof(struct inoinfo *));
395 if (inpsort == NULL)
396 errexit("cannot increase directory list");
397 }
398 inpsort[inplast++] = inp;
399}
400
401/*
402 * Look up an inode cache structure.
403 */
404struct inoinfo *
405getinoinfo(inumber)
406 ino_t inumber;
407{
408 register struct inoinfo *inp;
409
410 for (inp = inphead[inumber % numdirs]; inp; inp = inp->i_nexthash) {
411 if (inp->i_number != inumber)
412 continue;
413 return (inp);
414 }
415 errexit("cannot find inode %d\n", inumber);
416 return ((struct inoinfo *)0);
417}
418
419/*
420 * Clean up all the inode cache structure.
421 */
422void
423inocleanup()

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

467int
468findname(idesc)
469 struct inodesc *idesc;
470{
471 register struct direct *dirp = idesc->id_dirp;
472
473 if (dirp->d_ino != idesc->id_parent)
474 return (KEEPON);
475 bcopy(dirp->d_name, idesc->id_name, (size_t)dirp->d_namlen + 1);
476 return (STOP|FOUND);
477}
478
479int
480findino(idesc)
481 struct inodesc *idesc;
482{
483 register struct direct *dirp = idesc->id_dirp;

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

509 if ((pw = getpwuid((int)dp->di_uid)) != 0)
510 printf("%s ", pw->pw_name);
511 else
512 printf("%u ", (unsigned)dp->di_uid);
513 printf("MODE=%o\n", dp->di_mode);
514 if (preen)
515 printf("%s: ", cdevname);
516 printf("SIZE=%qu ", dp->di_size);
517 p = ctime(&dp->di_mtime.tv_sec);
518 printf("MTIME=%12.12s %4.4s ", &p[4], &p[20]);
519}
520
521void
522blkerror(ino, type, blk)
523 ino_t ino;
524 char *type;
525 daddr_t blk;
526{
527
528 pfatal("%ld %s I=%lu", blk, type, ino);
529 printf("\n");
530 switch (statemap[ino]) {
531
532 case FSTATE:
533 statemap[ino] = FCLEAR;
534 return;
535
536 case DSTATE:
537 statemap[ino] = DCLEAR;
538 return;
539
540 case FCLEAR:
541 case DCLEAR:
542 return;
543
544 default:
545 errexit("BAD STATE %d TO BLKERR", statemap[ino]);
546 /* NOTREACHED */
547 }
548}
549
550/*
551 * allocate an unused inode
552 */
553ino_t

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

580 }
581 dp = ginode(ino);
582 dp->di_db[0] = allocblk((long)1);
583 if (dp->di_db[0] == 0) {
584 statemap[ino] = USTATE;
585 return (0);
586 }
587 dp->di_mode = type;
588 (void)time(&dp->di_atime.tv_sec);
589 dp->di_mtime = dp->di_ctime = dp->di_atime;
590 dp->di_size = sblock.fs_fsize;
591 dp->di_blocks = btodb(sblock.fs_fsize);
592 n_files++;
593 inodirty();
594 if (newinofmt)
595 typemap[ino] = IFTODT(type);
596 return (ino);

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

601 */
602void
603freeino(ino)
604 ino_t ino;
605{
606 struct inodesc idesc;
607 struct dinode *dp;
608
609 bzero((char *)&idesc, sizeof(struct inodesc));
610 idesc.id_type = ADDR;
611 idesc.id_func = pass4check;
612 idesc.id_number = ino;
613 dp = ginode(ino);
614 (void)ckinode(dp, &idesc);
615 clearinode(dp);
616 inodirty();
617 statemap[ino] = USTATE;
618 n_files--;
619}