SCCS-vsn: sbin/fsck/pass4.c 5.6
SCCS-vsn: sbin/fsck/main.c 5.16
SCCS-vsn: sbin/fsck/utilities.c 5.19
SCCS-vsn: sbin/fsck/setup.c 5.24
SCCS-vsn: sbin/fsck/pass1.c 5.8
SCCS-vsn: sbin/fsck/dir.c 5.9
SCCS-vsn: sbin/fsck/inode.c 5.10
SCCS-vsn: sbin/fsck/fsck.h 5.9
SCCS-vsn: sbin/fsck/pass1b.c 5.5
SCCS-vsn: sbin/fsck/pass5.c 5.9
SCCS-vsn: sbin/fsck/pass3.c 5.5
SCCS-vsn: sbin/fsck/pass2.c 5.7
12 files changed:
-static char sccsid[] = "@(#)dir.c 5.8 (Berkeley) %G%";
+static char sccsid[] = "@(#)dir.c 5.9 (Berkeley) %G%";
#endif not lint
#include <sys/param.h>
#endif not lint
#include <sys/param.h>
struct dirtemplate emptydir = { 0, DIRBLKSIZ };
struct dirtemplate dirhead = { 0, 12, 1, ".", 0, DIRBLKSIZ - 12, 2, ".." };
struct dirtemplate emptydir = { 0, DIRBLKSIZ };
struct dirtemplate dirhead = { 0, 12, 1, ".", 0, DIRBLKSIZ - 12, 2, ".." };
-DIRECT *fsck_readdir();
-BUFAREA *getdirblk();
+struct direct *fsck_readdir();
+struct bufarea *getdirblk();
descend(parentino, inumber)
struct inodesc *parentino;
ino_t inumber;
{
descend(parentino, inumber)
struct inodesc *parentino;
ino_t inumber;
{
+ register struct dinode *dp;
struct inodesc curino;
bzero((char *)&curino, sizeof(struct inodesc));
struct inodesc curino;
bzero((char *)&curino, sizeof(struct inodesc));
statemap[inumber] = DFOUND;
dp = ginode(inumber);
if (dp->di_size == 0) {
statemap[inumber] = DFOUND;
dp = ginode(inumber);
if (dp->di_size == 0) {
- direrr(inumber, "ZERO LENGTH DIRECTORY");
+ direrror(inumber, "ZERO LENGTH DIRECTORY");
if (reply("REMOVE") == 1)
statemap[inumber] = DCLEAR;
return;
}
if (dp->di_size < MINDIRSIZE) {
if (reply("REMOVE") == 1)
statemap[inumber] = DCLEAR;
return;
}
if (dp->di_size < MINDIRSIZE) {
- direrr(inumber, "DIRECTORY TOO SHORT");
+ direrror(inumber, "DIRECTORY TOO SHORT");
dp->di_size = MINDIRSIZE;
if (reply("FIX") == 1)
inodirty();
dp->di_size = MINDIRSIZE;
if (reply("FIX") == 1)
inodirty();
curino.id_number = inumber;
(void)ckinode(dp, &curino);
if (curino.id_entryno < 2) {
curino.id_number = inumber;
(void)ckinode(dp, &curino);
if (curino.id_entryno < 2) {
- direrr(inumber, "NULL DIRECTORY");
+ direrror(inumber, "NULL DIRECTORY");
if (reply("REMOVE") == 1)
statemap[inumber] = DCLEAR;
}
if (reply("REMOVE") == 1)
statemap[inumber] = DCLEAR;
}
dirscan(idesc)
register struct inodesc *idesc;
{
dirscan(idesc)
register struct inodesc *idesc;
{
- register DIRECT *dp;
- register BUFAREA *bp;
+ register struct direct *dp;
+ register struct bufarea *bp;
int dsize, n;
long blksiz;
char dbuf[DIRBLKSIZ];
int dsize, n;
long blksiz;
char dbuf[DIRBLKSIZ];
(idesc->id_filesize & (DIRBLKSIZ - 1)) != 0)
idesc->id_filesize = roundup(idesc->id_filesize, DIRBLKSIZ);
blksiz = idesc->id_numfrags * sblock.fs_fsize;
(idesc->id_filesize & (DIRBLKSIZ - 1)) != 0)
idesc->id_filesize = roundup(idesc->id_filesize, DIRBLKSIZ);
blksiz = idesc->id_numfrags * sblock.fs_fsize;
- if (outrange(idesc->id_blkno, idesc->id_numfrags)) {
+ if (chkrange(idesc->id_blkno, idesc->id_numfrags)) {
idesc->id_filesize -= blksiz;
return (SKIP);
}
idesc->id_filesize -= blksiz;
return (SKIP);
}
for (dp = fsck_readdir(idesc); dp != NULL; dp = fsck_readdir(idesc)) {
dsize = dp->d_reclen;
bcopy((char *)dp, dbuf, dsize);
for (dp = fsck_readdir(idesc); dp != NULL; dp = fsck_readdir(idesc)) {
dsize = dp->d_reclen;
bcopy((char *)dp, dbuf, dsize);
- idesc->id_dirp = (DIRECT *)dbuf;
+ idesc->id_dirp = (struct direct *)dbuf;
if ((n = (*idesc->id_func)(idesc)) & ALTERED) {
bp = getdirblk(idesc->id_blkno, blksiz);
bcopy(dbuf, (char *)dp, dsize);
if ((n = (*idesc->id_func)(idesc)) & ALTERED) {
bp = getdirblk(idesc->id_blkno, blksiz);
bcopy(dbuf, (char *)dp, dsize);
/*
* get next entry in a directory.
*/
/*
* get next entry in a directory.
*/
fsck_readdir(idesc)
register struct inodesc *idesc;
{
fsck_readdir(idesc)
register struct inodesc *idesc;
{
- register DIRECT *dp, *ndp;
- register BUFAREA *bp;
+ register struct direct *dp, *ndp;
+ register struct bufarea *bp;
long size, blksiz;
blksiz = idesc->id_numfrags * sblock.fs_fsize;
bp = getdirblk(idesc->id_blkno, blksiz);
if (idesc->id_loc % DIRBLKSIZ == 0 && idesc->id_filesize > 0 &&
idesc->id_loc < blksiz) {
long size, blksiz;
blksiz = idesc->id_numfrags * sblock.fs_fsize;
bp = getdirblk(idesc->id_blkno, blksiz);
if (idesc->id_loc % DIRBLKSIZ == 0 && idesc->id_filesize > 0 &&
idesc->id_loc < blksiz) {
- dp = (DIRECT *)(bp->b_un.b_buf + idesc->id_loc);
+ dp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc);
if (dircheck(idesc, dp))
goto dpok;
idesc->id_loc += DIRBLKSIZ;
if (dircheck(idesc, dp))
goto dpok;
idesc->id_loc += DIRBLKSIZ;
dpok:
if (idesc->id_filesize <= 0 || idesc->id_loc >= blksiz)
return NULL;
dpok:
if (idesc->id_filesize <= 0 || idesc->id_loc >= blksiz)
return NULL;
- dp = (DIRECT *)(bp->b_un.b_buf + idesc->id_loc);
+ dp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc);
idesc->id_loc += dp->d_reclen;
idesc->id_filesize -= dp->d_reclen;
if ((idesc->id_loc % DIRBLKSIZ) == 0)
return (dp);
idesc->id_loc += dp->d_reclen;
idesc->id_filesize -= dp->d_reclen;
if ((idesc->id_loc % DIRBLKSIZ) == 0)
return (dp);
- ndp = (DIRECT *)(bp->b_un.b_buf + idesc->id_loc);
+ ndp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc);
if (idesc->id_loc < blksiz && idesc->id_filesize > 0 &&
dircheck(idesc, ndp) == 0) {
size = DIRBLKSIZ - (idesc->id_loc % DIRBLKSIZ);
if (idesc->id_loc < blksiz && idesc->id_filesize > 0 &&
dircheck(idesc, ndp) == 0) {
size = DIRBLKSIZ - (idesc->id_loc % DIRBLKSIZ);
*/
dircheck(idesc, dp)
struct inodesc *idesc;
*/
dircheck(idesc, dp)
struct inodesc *idesc;
+ register struct direct *dp;
{
register int size;
register char *cp;
{
register int size;
register char *cp;
size = DIRSIZ(dp);
spaceleft = DIRBLKSIZ - (idesc->id_loc % DIRBLKSIZ);
size = DIRSIZ(dp);
spaceleft = DIRBLKSIZ - (idesc->id_loc % DIRBLKSIZ);
- if (dp->d_ino < imax &&
+ if (dp->d_ino < maxino &&
dp->d_reclen != 0 &&
dp->d_reclen <= spaceleft &&
(dp->d_reclen & 0x3) == 0 &&
dp->d_reclen != 0 &&
dp->d_reclen <= spaceleft &&
(dp->d_reclen & 0x3) == 0 &&
+ register struct dinode *dp;
pinode(ino);
printf("\n");
pinode(ino);
printf("\n");
- if (ino < ROOTINO || ino > imax) {
+ if (ino < ROOTINO || ino > maxino) {
pfatal("NAME=%s\n", pathname);
return;
}
dp = ginode(ino);
if (ftypeok(dp))
pfatal("NAME=%s\n", pathname);
return;
}
dp = ginode(ino);
if (ftypeok(dp))
- pfatal("%s=%s\n", DIRCT(dp) ? "DIR" : "FILE", pathname);
+ pfatal("%s=%s\n",
+ (dp->di_mode & IFMT) == IFDIR ? "DIR" : "FILE", pathname);
else
pfatal("NAME=%s\n", pathname);
}
else
pfatal("NAME=%s\n", pathname);
}
register struct inodesc *idesc;
short lcnt;
{
register struct inodesc *idesc;
short lcnt;
{
+ register struct dinode *dp;
dp = ginode(idesc->id_number);
if (dp->di_nlink == lcnt) {
dp = ginode(idesc->id_number);
if (dp->di_nlink == lcnt) {
clri(idesc, "UNREF", 0);
} else {
pwarn("LINK COUNT %s", (lfdir == idesc->id_number) ? lfname :
clri(idesc, "UNREF", 0);
} else {
pwarn("LINK COUNT %s", (lfdir == idesc->id_number) ? lfname :
- (DIRCT(dp) ? "DIR" : "FILE"));
+ ((dp->di_mode & IFMT) == IFDIR ? "DIR" : "FILE"));
pinode(idesc->id_number);
printf(" COUNT %d SHOULD BE %d",
pinode(idesc->id_number);
printf(" COUNT %d SHOULD BE %d",
- dp->di_nlink, dp->di_nlink-lcnt);
+ dp->di_nlink, dp->di_nlink - lcnt);
if (preen) {
if (lcnt < 0) {
printf("\n");
if (preen) {
if (lcnt < 0) {
printf("\n");
mkentry(idesc)
struct inodesc *idesc;
{
mkentry(idesc)
struct inodesc *idesc;
{
- register DIRECT *dirp = idesc->id_dirp;
- DIRECT newent;
+ register struct direct *dirp = idesc->id_dirp;
+ struct direct newent;
int newlen, oldlen;
newent.d_namlen = 11;
int newlen, oldlen;
newent.d_namlen = 11;
dirp->d_ino = idesc->id_parent; /* ino to be entered is in id_parent */
dirp->d_reclen = newent.d_reclen;
dirp->d_namlen = strlen(idesc->id_name);
dirp->d_ino = idesc->id_parent; /* ino to be entered is in id_parent */
dirp->d_reclen = newent.d_reclen;
dirp->d_namlen = strlen(idesc->id_name);
- bcopy(idesc->id_name, dirp->d_name, dirp->d_namlen + 1);
+ bcopy(idesc->id_name, dirp->d_name, (int)dirp->d_namlen + 1);
return (ALTERED|STOP);
}
chgino(idesc)
struct inodesc *idesc;
{
return (ALTERED|STOP);
}
chgino(idesc)
struct inodesc *idesc;
{
- register DIRECT *dirp = idesc->id_dirp;
+ register struct direct *dirp = idesc->id_dirp;
- if (bcmp(dirp->d_name, idesc->id_name, dirp->d_namlen + 1))
+ if (bcmp(dirp->d_name, idesc->id_name, (int)dirp->d_namlen + 1))
- dirp->d_ino = idesc->id_parent;;
+ dirp->d_ino = idesc->id_parent;
+linkup(orphan, parentdir)
+ register struct dinode *dp;
int lostdir, len;
ino_t oldlfdir;
struct inodesc idesc;
int lostdir, len;
ino_t oldlfdir;
struct inodesc idesc;
bzero((char *)&idesc, sizeof(struct inodesc));
dp = ginode(orphan);
bzero((char *)&idesc, sizeof(struct inodesc));
dp = ginode(orphan);
+ lostdir = (dp->di_mode & IFMT) == IFDIR;
pwarn("UNREF %s ", lostdir ? "DIR" : "FILE");
pinode(orphan);
if (preen && dp->di_size == 0)
pwarn("UNREF %s ", lostdir ? "DIR" : "FILE");
pinode(orphan);
if (preen && dp->di_size == 0)
} else {
pwarn("NO lost+found DIRECTORY");
if (preen || reply("CREATE")) {
} else {
pwarn("NO lost+found DIRECTORY");
if (preen || reply("CREATE")) {
- lfdir = allocdir(ROOTINO, 0, lfmode);
+ lfdir = allocdir(ROOTINO, (ino_t)0, lfmode);
if (lfdir != 0) {
if (makeentry(ROOTINO, lfdir, lfname) != 0) {
if (preen)
if (lfdir != 0) {
if (makeentry(ROOTINO, lfdir, lfname) != 0) {
if (preen)
+ if ((dp->di_mode & IFMT) != IFDIR) {
pfatal("lost+found IS NOT A DIRECTORY");
if (reply("REALLOCATE") == 0)
return (0);
oldlfdir = lfdir;
pfatal("lost+found IS NOT A DIRECTORY");
if (reply("REALLOCATE") == 0)
return (0);
oldlfdir = lfdir;
- if ((lfdir = allocdir(ROOTINO, 0, lfmode)) == 0) {
+ if ((lfdir = allocdir(ROOTINO, (ino_t)0, lfmode)) == 0) {
pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n");
return (0);
}
pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n");
return (0);
}
inodirty();
lncntp[lfdir]++;
pwarn("DIR I=%u CONNECTED. ", orphan);
inodirty();
lncntp[lfdir]++;
pwarn("DIR I=%u CONNECTED. ", orphan);
- printf("PARENT WAS I=%u\n", pdir);
+ printf("PARENT WAS I=%u\n", parentdir);
if (preen == 0)
printf("\n");
}
if (preen == 0)
printf("\n");
}
ino_t parent, ino;
char *name;
{
ino_t parent, ino;
char *name;
{
- if (parent < ROOTINO || parent >= imax || ino < ROOTINO || ino >= imax)
+ if (parent < ROOTINO || parent >= maxino ||
+ ino < ROOTINO || ino >= maxino)
- bzero(&idesc, sizeof(struct inodesc));
+ bzero((char *)&idesc, sizeof(struct inodesc));
idesc.id_type = DATA;
idesc.id_func = mkentry;
idesc.id_number = parent;
idesc.id_type = DATA;
idesc.id_func = mkentry;
idesc.id_number = parent;
* Attempt to expand the size of a directory
*/
expanddir(dp)
* Attempt to expand the size of a directory
*/
expanddir(dp)
+ register struct dinode *dp;
{
daddr_t lastbn, newblk;
{
daddr_t lastbn, newblk;
+ register struct bufarea *bp;
char *cp, firstblk[DIRBLKSIZ];
lastbn = lblkno(&sblock, dp->di_size);
char *cp, firstblk[DIRBLKSIZ];
lastbn = lblkno(&sblock, dp->di_size);
- DINODE *dp;
- register BUFAREA *bp;
+ struct dinode *dp;
+ register struct bufarea *bp;
ino = allocino(request, IFDIR|mode);
dirhead.dot_ino = ino;
ino = allocino(request, IFDIR|mode);
dirhead.dot_ino = ino;
freedir(ino, parent)
ino_t ino, parent;
{
freedir(ino, parent)
ino_t ino, parent;
{
if (ino != parent) {
dp = ginode(parent);
if (ino != parent) {
dp = ginode(parent);
int namlen;
cp = bufp + 2;
int namlen;
cp = bufp + 2;
- for (in = imax; in > 0; in /= 10)
+ for (in = maxino; in > 0; in /= 10)
cp++;
*--cp = 0;
namlen = cp - bufp;
cp++;
*--cp = 0;
namlen = cp - bufp;
* Get a directory block.
* Insure that it is held until another is requested.
*/
* Get a directory block.
* Insure that it is held until another is requested.
*/
getdirblk(blkno, size)
daddr_t blkno;
long size;
{
getdirblk(blkno, size)
daddr_t blkno;
long size;
{
- static BUFAREA *pbp = 0;
+ static struct bufarea *pbp = 0;
if (pbp != 0)
pbp->b_flags &= ~B_INUSE;
if (pbp != 0)
pbp->b_flags &= ~B_INUSE;
* All rights reserved. The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
*
* All rights reserved. The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
*
- * @(#)fsck.h 5.8 (Berkeley) %G%
+ * @(#)fsck.h 5.9 (Berkeley) %G%
*/
#define MAXDUP 10 /* limit on dup blks (per inode) */
#define MAXBAD 10 /* limit on bad blks (per inode) */
#define MAXBUFSPACE 128*1024 /* maximum space to allocate to buffers */
*/
#define MAXDUP 10 /* limit on dup blks (per inode) */
#define MAXBAD 10 /* limit on bad blks (per inode) */
#define MAXBUFSPACE 128*1024 /* maximum space to allocate to buffers */
-typedef int (*SIG_TYP)();
-
#ifndef BUFSIZ
#define BUFSIZ 1024
#endif
#ifndef BUFSIZ
#define BUFSIZ 1024
#endif
#define DCLEAR 05 /* directory is to be cleared */
#define FCLEAR 06 /* file is to be cleared */
#define DCLEAR 05 /* directory is to be cleared */
#define FCLEAR 06 /* file is to be cleared */
-typedef struct dinode DINODE;
-typedef struct direct DIRECT;
-
-#define ALLOC(dip) (((dip)->di_mode & IFMT) != 0)
-#define DIRCT(dip) (((dip)->di_mode & IFMT) == IFDIR)
-#define SPECIAL(dip) \
- (((dip)->di_mode & IFMT) == IFBLK || ((dip)->di_mode & IFMT) == IFCHR)
-
/*
* buffer cache structure.
*/
/*
* buffer cache structure.
*/
daddr_t *b_indir; /* indirect block */
struct fs *b_fs; /* super block */
struct cg *b_cg; /* cylinder group */
daddr_t *b_indir; /* indirect block */
struct fs *b_fs; /* super block */
struct cg *b_cg; /* cylinder group */
- struct dinode *b_dinode; /* inode block */
+ struct dinode *b_dinode; /* inode block */
} b_un;
char b_dirty;
};
#define B_INUSE 1
} b_un;
char b_dirty;
};
#define B_INUSE 1
-typedef struct bufarea BUFAREA;
#define MINBUFS 5 /* minimum number of buffers required */
#define MINBUFS 5 /* minimum number of buffers required */
-BUFAREA bufhead; /* head of list of other blks in filesys */
-BUFAREA sblk; /* file system superblock */
-BUFAREA cgblk; /* cylinder group blocks */
-BUFAREA *getdatablk();
+struct bufarea bufhead; /* head of list of other blks in filesys */
+struct bufarea sblk; /* file system superblock */
+struct bufarea cgblk; /* cylinder group blocks */
+struct bufarea *getdatablk();
-#define dirty(x) (x)->b_dirty = 1
-#define initbarea(x) \
- (x)->b_dirty = 0; \
- (x)->b_bno = (daddr_t)-1; \
- (x)->b_flags = 0;
+#define dirty(bp) (bp)->b_dirty = 1
+#define initbarea(bp) \
+ (bp)->b_dirty = 0; \
+ (bp)->b_bno = (daddr_t)-1; \
+ (bp)->b_flags = 0;
#define sbdirty() sblk.b_dirty = 1
#define cgdirty() cgblk.b_dirty = 1
#define sblock (*sblk.b_un.b_fs)
#define cgrp (*cgblk.b_un.b_cg)
#define sbdirty() sblk.b_dirty = 1
#define cgdirty() cgblk.b_dirty = 1
#define sblock (*sblk.b_un.b_fs)
#define cgrp (*cgblk.b_un.b_cg)
-struct filecntl {
- int rfdes;
- int wfdes;
- int mod;
-} dfile; /* file descriptors for filesys */
-
enum fixstate {DONTKNOW, NOFIX, FIX};
struct inodesc {
enum fixstate {DONTKNOW, NOFIX, FIX};
struct inodesc {
long id_filesize; /* for DATA nodes, the size of the directory */
int id_loc; /* for DATA nodes, current location in dir */
int id_entryno; /* for DATA nodes, current entry number */
long id_filesize; /* for DATA nodes, the size of the directory */
int id_loc; /* for DATA nodes, current location in dir */
int id_entryno; /* for DATA nodes, current entry number */
- DIRECT *id_dirp; /* for DATA nodes, ptr to current entry */
+ struct direct *id_dirp; /* for DATA nodes, ptr to current entry */
char *id_name; /* for DATA nodes, name to find or enter */
char id_type; /* type of descriptor, DATA or ADDR */
};
char *id_name; /* for DATA nodes, name to find or enter */
char id_type; /* type of descriptor, DATA or ADDR */
};
};
struct zlncnt *zlnhead; /* head of zero link count list */
};
struct zlncnt *zlnhead; /* head of zero link count list */
-char rawflg;
-char *devname;
+char *devname; /* name of device being checked */
long dev_bsize; /* computed value of DEV_BSIZE */
long secsize; /* actual disk sector size */
char nflag; /* assume a no response */
long dev_bsize; /* computed value of DEV_BSIZE */
long secsize; /* actual disk sector size */
char nflag; /* assume a no response */
char preen; /* just fix normal inconsistencies */
char hotroot; /* checking root device */
char havesb; /* superblock has been read */
char preen; /* just fix normal inconsistencies */
char hotroot; /* checking root device */
char havesb; /* superblock has been read */
+int fsmodified; /* 1 => write done to file system */
+int fsreadfd; /* file descriptor for reading file system */
+int fswritefd; /* file descriptor for writing file system */
+daddr_t maxfsblock; /* number of blocks in the file system */
char *blockmap; /* ptr to primary blk allocation map */
char *blockmap; /* ptr to primary blk allocation map */
+ino_t maxino; /* number of inodes in file system */
+ino_t lastino; /* last inode in use */
char *statemap; /* ptr to inode state table */
short *lncntp; /* ptr to link count table */
char pathname[BUFSIZ]; /* current pathname */
char *statemap; /* ptr to inode state table */
short *lncntp; /* ptr to link count table */
char pathname[BUFSIZ]; /* current pathname */
-char *pathp; /* pointer to pathname position */
-char *endpathname;
+char *pathp; /* ptr to current position in pathname */
+char *endpathname; /* ptr to current end of pathname */
-daddr_t fmax; /* number of blocks in the volume */
-ino_t imax; /* number of inodes */
-ino_t lastino; /* hiwater mark of inodes */
ino_t lfdir; /* lost & found directory inode number */
char *lfname; /* lost & found directory name */
int lfmode; /* lost & found directory creation mode */
ino_t lfdir; /* lost & found directory inode number */
char *lfname; /* lost & found directory name */
int lfmode; /* lost & found directory creation mode */
-off_t maxblk; /* largest logical blk in file */
-off_t bmapsz; /* num chars in blockmap */
+daddr_t n_blks; /* number of blocks in use */
+daddr_t n_files; /* number of files in use */
-daddr_t n_blks; /* number of blocks used */
-daddr_t n_files; /* number of files seen */
-
-#define zapino(x) (*(x) = zino)
+#define clearinode(dp) (*(dp) = zino)
-#define setbmap(x) setbit(blockmap, x)
-#define getbmap(x) isset(blockmap, x)
-#define clrbmap(x) clrbit(blockmap, x)
-
-#define FOUND 020
-#define ALTERED 010
-#define KEEPON 04
-#define SKIP 02
-#define STOP 01
-
-time_t time();
-DINODE *ginode();
-BUFAREA *getblk();
-int findino();
+#define setbmap(blkno) setbit(blockmap, blkno)
+#define testbmap(blkno) isset(blockmap, blkno)
+#define clrbmap(blkno) clrbit(blockmap, blkno)
+
+#define STOP 0x01
+#define SKIP 0x02
+#define KEEPON 0x04
+#define ALTERED 0x08
+#define FOUND 0x10
+
+time_t time();
+struct dinode *ginode();
+struct bufarea *getblk();
+ino_t allocino();
+int findino();
-static char sccsid[] = "@(#)inode.c 5.9 (Berkeley) %G%";
+static char sccsid[] = "@(#)inode.c 5.10 (Berkeley) %G%";
#endif not lint
#include <sys/param.h>
#endif not lint
#include <sys/param.h>
#include <pwd.h>
#include "fsck.h"
#include <pwd.h>
#include "fsck.h"
+struct bufarea *pbp = 0;
register struct inodesc *idesc;
{
register daddr_t *ap;
register struct inodesc *idesc;
{
register daddr_t *ap;
- int ret, n, ndb, offset;
- DINODE dino;
+ long ret, n, ndb, offset;
+ struct dinode dino;
idesc->id_fix = DONTKNOW;
idesc->id_entryno = 0;
idesc->id_filesize = dp->di_size;
idesc->id_fix = DONTKNOW;
idesc->id_entryno = 0;
idesc->id_filesize = dp->di_size;
+ if ((dp->di_mode & IFMT) == IFBLK || (dp->di_mode & IFMT) == IFCHR)
return (KEEPON);
dino = *dp;
ndb = howmany(dino.di_size, sblock.fs_bsize);
return (KEEPON);
dino = *dp;
ndb = howmany(dino.di_size, sblock.fs_bsize);
iblock(idesc, ilevel, isize)
struct inodesc *idesc;
iblock(idesc, ilevel, isize)
struct inodesc *idesc;
long isize;
{
register daddr_t *ap;
register daddr_t *aplim;
int i, n, (*func)(), nif, sizepb;
long isize;
{
register daddr_t *ap;
register daddr_t *aplim;
int i, n, (*func)(), nif, sizepb;
+ register struct bufarea *bp;
char buf[BUFSIZ];
extern int dirscan(), pass1check();
char buf[BUFSIZ];
extern int dirscan(), pass1check();
return (n);
} else
func = dirscan;
return (n);
} else
func = dirscan;
- if (outrange(idesc->id_blkno, idesc->id_numfrags)) /* protect thyself */
+ if (chkrange(idesc->id_blkno, idesc->id_numfrags))
return (SKIP);
bp = getdatablk(idesc->id_blkno, sblock.fs_bsize);
ilevel--;
return (SKIP);
bp = getdatablk(idesc->id_blkno, sblock.fs_bsize);
ilevel--;
}
aplim = &bp->b_un.b_indir[nif];
for (ap = bp->b_un.b_indir, i = 1; ap < aplim; ap++, i++) {
}
aplim = &bp->b_un.b_indir[nif];
for (ap = bp->b_un.b_indir, i = 1; ap < aplim; ap++, i++) {
+/*
+ * Check that a block in a legal block number.
+ * Return 0 if in range, 1 if out of range.
+ */
+chkrange(blk, cnt)
daddr_t blk;
int cnt;
{
register int c;
daddr_t blk;
int cnt;
{
register int c;
- if ((unsigned)(blk+cnt) > fmax)
+ if ((unsigned)(blk + cnt) > maxfsblock)
return (1);
c = dtog(&sblock, blk);
if (blk < cgdmin(&sblock, c)) {
return (1);
c = dtog(&sblock, blk);
if (blk < cgdmin(&sblock, c)) {
- if ((blk+cnt) > cgsblock(&sblock, c)) {
+ if ((blk + cnt) > cgsblock(&sblock, c)) {
if (debug) {
printf("blk %d < cgdmin %d;",
blk, cgdmin(&sblock, c));
if (debug) {
printf("blk %d < cgdmin %d;",
blk, cgdmin(&sblock, c));
- printf(" blk+cnt %d > cgsbase %d\n",
- blk+cnt, cgsblock(&sblock, c));
+ printf(" blk + cnt %d > cgsbase %d\n",
+ blk + cnt, cgsblock(&sblock, c));
- if ((blk+cnt) > cgbase(&sblock, c+1)) {
+ if ((blk + cnt) > cgbase(&sblock, c+1)) {
if (debug) {
printf("blk %d >= cgdmin %d;",
blk, cgdmin(&sblock, c));
if (debug) {
printf("blk %d >= cgdmin %d;",
blk, cgdmin(&sblock, c));
- printf(" blk+cnt %d > sblock.fs_fpg %d\n",
+ printf(" blk + cnt %d > sblock.fs_fpg %d\n",
blk+cnt, sblock.fs_fpg);
}
return (1);
blk+cnt, sblock.fs_fpg);
}
return (1);
ginode(inumber)
ino_t inumber;
{
daddr_t iblk;
ginode(inumber)
ino_t inumber;
{
daddr_t iblk;
- static ino_t startinum = 0; /* blk num of first in raw area */
+ static ino_t startinum = 0;
- if (inumber < ROOTINO || inumber > imax)
+ if (inumber < ROOTINO || inumber > maxino)
errexit("bad inode number %d to ginode\n", inumber);
if (startinum == 0 ||
inumber < startinum || inumber >= startinum + INOPB(&sblock)) {
errexit("bad inode number %d to ginode\n", inumber);
if (startinum == 0 ||
inumber < startinum || inumber >= startinum + INOPB(&sblock)) {
register struct inodesc *idesc;
register struct inodesc *idesc;
+ char *type;
+ int flag;
+ register struct dinode *dp;
dp = ginode(idesc->id_number);
dp = ginode(idesc->id_number);
- if (flg == 1) {
- pwarn("%s %s", s, DIRCT(dp) ? "DIR" : "FILE");
+ if (flag == 1) {
+ pwarn("%s %s", type,
+ (dp->di_mode & IFMT) == IFDIR ? "DIR" : "FILE");
pinode(idesc->id_number);
}
if (preen || reply("CLEAR") == 1) {
pinode(idesc->id_number);
}
if (preen || reply("CLEAR") == 1) {
printf(" (CLEARED)\n");
n_files--;
(void)ckinode(dp, idesc);
printf(" (CLEARED)\n");
n_files--;
(void)ckinode(dp, idesc);
statemap[idesc->id_number] = USTATE;
inodirty();
}
statemap[idesc->id_number] = USTATE;
inodirty();
}
findname(idesc)
struct inodesc *idesc;
{
findname(idesc)
struct inodesc *idesc;
{
- register DIRECT *dirp = idesc->id_dirp;
+ register struct direct *dirp = idesc->id_dirp;
if (dirp->d_ino != idesc->id_parent)
return (KEEPON);
if (dirp->d_ino != idesc->id_parent)
return (KEEPON);
- bcopy(dirp->d_name, idesc->id_name, dirp->d_namlen + 1);
+ bcopy(dirp->d_name, idesc->id_name, (int)dirp->d_namlen + 1);
return (STOP|FOUND);
}
findino(idesc)
struct inodesc *idesc;
{
return (STOP|FOUND);
}
findino(idesc)
struct inodesc *idesc;
{
- register DIRECT *dirp = idesc->id_dirp;
+ register struct direct *dirp = idesc->id_dirp;
if (dirp->d_ino == 0)
return (KEEPON);
if (strcmp(dirp->d_name, idesc->id_name) == 0 &&
if (dirp->d_ino == 0)
return (KEEPON);
if (strcmp(dirp->d_name, idesc->id_name) == 0 &&
- dirp->d_ino >= ROOTINO && dirp->d_ino <= imax) {
+ dirp->d_ino >= ROOTINO && dirp->d_ino <= maxino) {
idesc->id_parent = dirp->d_ino;
return (STOP|FOUND);
}
idesc->id_parent = dirp->d_ino;
return (STOP|FOUND);
}
+ register struct dinode *dp;
register char *p;
struct passwd *pw;
char *ctime();
printf(" I=%u ", ino);
register char *p;
struct passwd *pw;
char *ctime();
printf(" I=%u ", ino);
- if (ino < ROOTINO || ino > imax)
+ if (ino < ROOTINO || ino > maxino)
return;
dp = ginode(ino);
printf(" OWNER=");
return;
dp = ginode(ino);
printf(" OWNER=");
printf("%s: ", devname);
printf("SIZE=%ld ", dp->di_size);
p = ctime(&dp->di_mtime);
printf("%s: ", devname);
printf("SIZE=%ld ", dp->di_size);
p = ctime(&dp->di_mtime);
- printf("MTIME=%12.12s %4.4s ", p+4, p+20);
+ printf("MTIME=%12.12s %4.4s ", p + 4, p + 20);
+blkerror(ino, type, blk)
- pfatal("%ld %s I=%u", blk, s, ino);
+ pfatal("%ld %s I=%u", blk, type, ino);
printf("\n");
switch (statemap[ino]) {
printf("\n");
switch (statemap[ino]) {
int type;
{
register ino_t ino;
int type;
{
register ino_t ino;
+ register struct dinode *dp;
if (request == 0)
request = ROOTINO;
else if (statemap[request] != USTATE)
return (0);
if (request == 0)
request = ROOTINO;
else if (statemap[request] != USTATE)
return (0);
- for (ino = request; ino < imax; ino++)
+ for (ino = request; ino < maxino; ino++)
if (statemap[ino] == USTATE)
break;
if (statemap[ino] == USTATE)
break;
return (0);
switch (type & IFMT) {
case IFDIR:
return (0);
switch (type & IFMT) {
case IFDIR:
return (0);
}
dp = ginode(ino);
return (0);
}
dp = ginode(ino);
- dp->di_db[0] = allocblk(1);
+ dp->di_db[0] = allocblk((long)1);
if (dp->di_db[0] == 0) {
statemap[ino] = USTATE;
return (0);
if (dp->di_db[0] == 0) {
statemap[ino] = USTATE;
return (0);
{
struct inodesc idesc;
extern int pass4check();
{
struct inodesc idesc;
extern int pass4check();
bzero((char *)&idesc, sizeof(struct inodesc));
idesc.id_type = ADDR;
bzero((char *)&idesc, sizeof(struct inodesc));
idesc.id_type = ADDR;
idesc.id_number = ino;
dp = ginode(ino);
(void)ckinode(dp, &idesc);
idesc.id_number = ino;
dp = ginode(ino);
(void)ckinode(dp, &idesc);
inodirty();
statemap[ino] = USTATE;
n_files--;
inodirty();
statemap[ino] = USTATE;
n_files--;
#endif not lint
#ifndef lint
#endif not lint
#ifndef lint
-static char sccsid[] = "@(#)main.c 5.15 (Berkeley) %G%";
+static char sccsid[] = "@(#)main.c 5.16 (Berkeley) %G%";
#endif not lint
#include <sys/param.h>
#endif not lint
#include <sys/param.h>
printf("** lost+found creation mode %o\n", lfmode);
break;
printf("** lost+found creation mode %o\n", lfmode);
break;
- case 'n': /* default no answer flag */
case 'N':
nflag++;
yflag = 0;
break;
case 'N':
nflag++;
yflag = 0;
break;
- case 'y': /* default yes answer flag */
case 'Y':
yflag++;
nflag = 0;
case 'Y':
yflag++;
nflag = 0;
if ((*dkp = (struct disk *)malloc(sizeof(struct disk))) == NULL)
errexit("out of memory");
dk = *dkp;
if ((*dkp = (struct disk *)malloc(sizeof(struct disk))) == NULL)
errexit("out of memory");
dk = *dkp;
- if ((dk->name = malloc(len + 1)) == NULL)
+ if ((dk->name = malloc((unsigned int)len + 1)) == NULL)
errexit("out of memory");
strncpy(dk->name, name, len);
dk->name[len] = '\0';
errexit("out of memory");
strncpy(dk->name, name, len);
dk->name[len] = '\0';
if ((*ppt = (struct part *)malloc(sizeof(struct part))) == NULL)
errexit("out of memory");
pt = *ppt;
if ((*ppt = (struct part *)malloc(sizeof(struct part))) == NULL)
errexit("out of memory");
pt = *ppt;
- if ((pt->name = malloc(strlen(name) + 1)) == NULL)
+ if ((pt->name = malloc((unsigned int)strlen(name) + 1)) == NULL)
errexit("out of memory");
strcpy(pt->name, name);
errexit("out of memory");
strcpy(pt->name, name);
- if ((pt->fsname = malloc(strlen(fsname) + 1)) == NULL)
+ if ((pt->fsname = malloc((unsigned int)strlen(fsname) + 1)) == NULL)
errexit("out of memory");
strcpy(pt->fsname, fsname);
pt->next = NULL;
errexit("out of memory");
strcpy(pt->fsname, fsname);
pt->next = NULL;
n_files, n_blks, n_ffree + sblock.fs_frag * n_bfree);
printf("(%d frags, %d blocks, %.1f%% fragmentation)\n",
n_ffree, n_bfree, (float)(n_ffree * 100) / sblock.fs_dsize);
n_files, n_blks, n_ffree + sblock.fs_frag * n_bfree);
printf("(%d frags, %d blocks, %.1f%% fragmentation)\n",
n_ffree, n_bfree, (float)(n_ffree * 100) / sblock.fs_dsize);
- if (debug && (n_files -= imax - ROOTINO - sblock.fs_cstotal.cs_nifree))
+ if (debug &&
+ (n_files -= maxino - ROOTINO - sblock.fs_cstotal.cs_nifree))
printf("%d files missing\n", n_files);
if (debug) {
n_blks += sblock.fs_ncg *
(cgdmin(&sblock, 0) - cgsblock(&sblock, 0));
n_blks += cgsblock(&sblock, 0) - cgbase(&sblock, 0);
n_blks += howmany(sblock.fs_cssize, sblock.fs_fsize);
printf("%d files missing\n", n_files);
if (debug) {
n_blks += sblock.fs_ncg *
(cgdmin(&sblock, 0) - cgsblock(&sblock, 0));
n_blks += cgsblock(&sblock, 0) - cgbase(&sblock, 0);
n_blks += howmany(sblock.fs_cssize, sblock.fs_fsize);
- if (n_blks -= fmax - (n_ffree + sblock.fs_frag * n_bfree))
+ if (n_blks -= maxfsblock - (n_ffree + sblock.fs_frag * n_bfree))
printf("%d blocks missing\n", n_blks);
if (duplist != NULL) {
printf("The following duplicate blocks remain:");
printf("%d blocks missing\n", n_blks);
if (duplist != NULL) {
printf("The following duplicate blocks remain:");
}
zlnhead = (struct zlncnt *)0;
duplist = (struct dups *)0;
}
zlnhead = (struct zlncnt *)0;
duplist = (struct dups *)0;
(void)time(&sblock.fs_time);
sbdirty();
}
(void)time(&sblock.fs_time);
sbdirty();
}
free(blockmap);
free(statemap);
free((char *)lncntp);
free(blockmap);
free(statemap);
free((char *)lncntp);
return;
if (!preen) {
printf("\n***** FILE SYSTEM WAS MODIFIED *****\n");
return;
if (!preen) {
printf("\n***** FILE SYSTEM WAS MODIFIED *****\n");
{
struct stat stslash, stblock, stchar;
char *raw;
{
struct stat stslash, stblock, stchar;
char *raw;
- if (stat("/", &stslash) < 0){
+ if (stat("/", &stslash) < 0) {
perror("/");
printf("Can't stat root\n");
return (0);
}
retry:
perror("/");
printf("Can't stat root\n");
return (0);
}
retry:
- if (stat(name, &stblock) < 0){
+ if (stat(name, &stblock) < 0) {
perror(name);
printf("Can't stat %s\n", name);
return (0);
perror(name);
printf("Can't stat %s\n", name);
return (0);
return (name);
}
raw = rawname(name);
return (name);
}
raw = rawname(name);
- if (stat(raw, &stchar) < 0){
+ if (stat(raw, &stchar) < 0) {
perror(raw);
printf("Can't stat %s\n", raw);
return (name);
}
perror(raw);
printf("Can't stat %s\n", raw);
return (name);
}
- if ((stchar.st_mode & S_IFMT) == S_IFCHR)
+ if ((stchar.st_mode & S_IFMT) == S_IFCHR) {
printf("%s is not a character device\n", raw);
return (name);
}
printf("%s is not a character device\n", raw);
return (name);
}
- } else if ((stblock.st_mode & S_IFMT) == S_IFCHR) {
- if (looped) {
- printf("Can't make sense out of name %s\n", name);
- return (0);
- }
+ } else if ((stblock.st_mode & S_IFMT) == S_IFCHR && !retried) {
goto retry;
}
printf("Can't make sense out of name %s\n", name);
goto retry;
}
printf("Can't make sense out of name %s\n", name);
-unrawname(cp)
- char *cp;
+unrawname(name)
+ char *name;
- char *dp = rindex(cp, '/');
- if (dp == 0)
- return (cp);
- if (stat(cp, &stb) < 0)
- return (cp);
- if ((stb.st_mode&S_IFMT) != S_IFCHR)
- return (cp);
- if (*(dp+1) != 'r')
- return (cp);
- (void)strcpy(dp+1, dp+2);
- return (cp);
+ if ((dp = rindex(name, '/')) == 0)
+ return (name);
+ if (stat(name, &stb) < 0)
+ return (name);
+ if ((stb.st_mode & S_IFMT) != S_IFCHR)
+ return (name);
+ if (*(dp + 1) != 'r')
+ return (name);
+ (void)strcpy(dp + 1, dp + 2);
+ return (name);
+rawname(name)
+ char *name;
{
static char rawbuf[32];
{
static char rawbuf[32];
- char *dp = rindex(cp, '/');
+ if ((dp = rindex(name, '/')) == 0)
- (void)strcpy(rawbuf, cp);
+ (void)strcpy(rawbuf, name);
*dp = '/';
(void)strcat(rawbuf, "/r");
*dp = '/';
(void)strcat(rawbuf, "/r");
- (void)strcat(rawbuf, dp+1);
+ (void)strcat(rawbuf, dp + 1);
-static char sccsid[] = "@(#)pass1.c 5.7 (Berkeley) %G%";
+static char sccsid[] = "@(#)pass1.c 5.8 (Berkeley) %G%";
#endif not lint
#include <sys/param.h>
#endif not lint
#include <sys/param.h>
pass1()
{
register int c, i, j;
pass1()
{
register int c, i, j;
+ register struct dinode *dp;
struct inodesc idesc;
ino_t inumber;
struct inodesc idesc;
ino_t inumber;
if (inumber < ROOTINO)
continue;
dp = ginode(inumber);
if (inumber < ROOTINO)
continue;
dp = ginode(inumber);
+ if ((dp->di_mode & IFMT) == 0) {
if (bcmp((char *)dp->di_db, (char *)zino.di_db,
NDADDR * sizeof(daddr_t)) ||
bcmp((char *)dp->di_ib, (char *)zino.di_ib,
if (bcmp((char *)dp->di_db, (char *)zino.di_db,
NDADDR * sizeof(daddr_t)) ||
bcmp((char *)dp->di_ib, (char *)zino.di_ib,
pfatal("PARTIALLY ALLOCATED INODE I=%u",
inumber);
if (reply("CLEAR") == 1) {
pfatal("PARTIALLY ALLOCATED INODE I=%u",
inumber);
if (reply("CLEAR") == 1) {
dp->di_size, ndb);
goto unknown;
}
dp->di_size, ndb);
goto unknown;
}
+ if ((dp->di_mode & IFMT) == IFBLK ||
+ (dp->di_mode & IFMT) == IFCHR)
ndb++;
for (j = ndb; j < NDADDR; j++)
if (dp->di_db[j] != 0) {
ndb++;
for (j = ndb; j < NDADDR; j++)
if (dp->di_db[j] != 0) {
- statemap[inumber] = DIRCT(dp) ? DSTATE : FSTATE;
- badblk = dupblk = 0; maxblk = 0;
+ statemap[inumber] =
+ (dp->di_mode & IFMT) == IFDIR ? DSTATE : FSTATE;
+ badblk = dupblk = 0;
idesc.id_number = inumber;
(void)ckinode(dp, &idesc);
idesc.id_entryno *= btodb(sblock.fs_fsize);
idesc.id_number = inumber;
(void)ckinode(dp, &idesc);
idesc.id_entryno *= btodb(sblock.fs_fsize);
statemap[inumber] = FCLEAR;
if (reply("CLEAR") == 1) {
statemap[inumber] = USTATE;
statemap[inumber] = FCLEAR;
if (reply("CLEAR") == 1) {
statemap[inumber] = USTATE;
register struct dups *dlp;
struct dups *new;
register struct dups *dlp;
struct dups *new;
- if ((anyout = outrange(blkno, idesc->id_numfrags)) != 0) {
- blkerr(idesc->id_number, "BAD", blkno);
+ if ((anyout = chkrange(blkno, idesc->id_numfrags)) != 0) {
+ blkerror(idesc->id_number, "BAD", blkno);
if (++badblk >= MAXBAD) {
pwarn("EXCESSIVE BAD BLKS I=%u",
idesc->id_number);
if (++badblk >= MAXBAD) {
pwarn("EXCESSIVE BAD BLKS I=%u",
idesc->id_number);
}
}
for (nfrags = idesc->id_numfrags; nfrags > 0; blkno++, nfrags--) {
}
}
for (nfrags = idesc->id_numfrags; nfrags > 0; blkno++, nfrags--) {
- if (anyout && outrange(blkno, 1)) {
+ if (anyout && chkrange(blkno, 1)) {
- } else if (!getbmap(blkno)) {
+ } else if (!testbmap(blkno)) {
n_blks++;
setbmap(blkno);
} else {
n_blks++;
setbmap(blkno);
} else {
- blkerr(idesc->id_number, "DUP", blkno);
+ blkerror(idesc->id_number, "DUP", blkno);
if (++dupblk >= MAXDUP) {
pwarn("EXCESSIVE DUP BLKS I=%u",
idesc->id_number);
if (++dupblk >= MAXDUP) {
pwarn("EXCESSIVE DUP BLKS I=%u",
idesc->id_number);
-static char sccsid[] = "@(#)pass1b.c 5.4 (Berkeley) %G%";
+static char sccsid[] = "@(#)pass1b.c 5.5 (Berkeley) %G%";
#endif not lint
#include <sys/param.h>
#endif not lint
#include <sys/param.h>
pass1b()
{
register int c, i;
pass1b()
{
register int c, i;
+ register struct dinode *dp;
struct inodesc idesc;
ino_t inumber;
struct inodesc idesc;
ino_t inumber;
idesc.id_number = inumber;
if (statemap[inumber] != USTATE &&
(ckinode(dp, &idesc) & STOP))
idesc.id_number = inumber;
if (statemap[inumber] != USTATE &&
(ckinode(dp, &idesc) & STOP))
daddr_t blkno = idesc->id_blkno;
for (nfrags = idesc->id_numfrags; nfrags > 0; blkno++, nfrags--) {
daddr_t blkno = idesc->id_blkno;
for (nfrags = idesc->id_numfrags; nfrags > 0; blkno++, nfrags--) {
- if (outrange(blkno, 1))
+ if (chkrange(blkno, 1))
res = SKIP;
for (dlp = duphead; dlp; dlp = dlp->next) {
if (dlp->dup == blkno) {
res = SKIP;
for (dlp = duphead; dlp; dlp = dlp->next) {
if (dlp->dup == blkno) {
- blkerr(idesc->id_number, "DUP", blkno);
+ blkerror(idesc->id_number, "DUP", blkno);
dlp->dup = duphead->dup;
duphead->dup = blkno;
duphead = duphead->next;
dlp->dup = duphead->dup;
duphead->dup = blkno;
duphead = duphead->next;
-static char sccsid[] = "@(#)pass2.c 5.6 (Berkeley) %G%";
+static char sccsid[] = "@(#)pass2.c 5.7 (Berkeley) %G%";
#endif not lint
#include <sys/param.h>
#endif not lint
#include <sys/param.h>
+ register struct dinode *dp;
struct inodesc rootdesc;
bzero((char *)&rootdesc, sizeof(struct inodesc));
struct inodesc rootdesc;
bzero((char *)&rootdesc, sizeof(struct inodesc));
pass2check(idesc)
struct inodesc *idesc;
{
pass2check(idesc)
struct inodesc *idesc;
{
- register DIRECT *dirp = idesc->id_dirp;
+ register struct direct *dirp = idesc->id_dirp;
char *curpathloc;
int n, entrysize, ret = 0;
char *curpathloc;
int n, entrysize, ret = 0;
- DINODE *dp;
- DIRECT proto;
+ struct dinode *dp;
+ struct direct proto;
goto chk1;
if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") == 0) {
if (dirp->d_ino != idesc->id_number) {
goto chk1;
if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") == 0) {
if (dirp->d_ino != idesc->id_number) {
- direrr(idesc->id_number, "BAD INODE NUMBER FOR '.'");
+ direrror(idesc->id_number, "BAD INODE NUMBER FOR '.'");
dirp->d_ino = idesc->id_number;
if (reply("FIX") == 1)
ret |= ALTERED;
}
goto chk1;
}
dirp->d_ino = idesc->id_number;
if (reply("FIX") == 1)
ret |= ALTERED;
}
goto chk1;
}
- direrr(idesc->id_number, "MISSING '.'");
+ direrror(idesc->id_number, "MISSING '.'");
proto.d_ino = idesc->id_number;
proto.d_namlen = 1;
(void)strcpy(proto.d_name, ".");
proto.d_ino = idesc->id_number;
proto.d_namlen = 1;
(void)strcpy(proto.d_name, ".");
bcopy((char *)&proto, (char *)dirp, entrysize);
idesc->id_entryno++;
lncntp[dirp->d_ino]--;
bcopy((char *)&proto, (char *)dirp, entrysize);
idesc->id_entryno++;
lncntp[dirp->d_ino]--;
- dirp = (DIRECT *)((char *)(dirp) + entrysize);
+ dirp = (struct direct *)((char *)(dirp) + entrysize);
bzero((char *)dirp, n);
dirp->d_reclen = n;
if (reply("FIX") == 1)
bzero((char *)dirp, n);
dirp->d_reclen = n;
if (reply("FIX") == 1)
dirp->d_reclen = n;
idesc->id_entryno++;
lncntp[dirp->d_ino]--;
dirp->d_reclen = n;
idesc->id_entryno++;
lncntp[dirp->d_ino]--;
- dirp = (DIRECT *)((char *)(dirp) + n);
+ dirp = (struct direct *)((char *)(dirp) + n);
bzero((char *)dirp, n);
dirp->d_reclen = n;
}
if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") == 0) {
if (dirp->d_ino != idesc->id_parent) {
bzero((char *)dirp, n);
dirp->d_reclen = n;
}
if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") == 0) {
if (dirp->d_ino != idesc->id_parent) {
- direrr(idesc->id_number, "BAD INODE NUMBER FOR '..'");
+ direrror(idesc->id_number, "BAD INODE NUMBER FOR '..'");
dirp->d_ino = idesc->id_parent;
if (reply("FIX") == 1)
ret |= ALTERED;
}
goto chk2;
}
dirp->d_ino = idesc->id_parent;
if (reply("FIX") == 1)
ret |= ALTERED;
}
goto chk2;
}
- direrr(idesc->id_number, "MISSING '..'");
+ direrror(idesc->id_number, "MISSING '..'");
if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") != 0) {
pfatal("CANNOT FIX, SECOND ENTRY IN DIRECTORY CONTAINS %s\n",
dirp->d_name);
if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") != 0) {
pfatal("CANNOT FIX, SECOND ENTRY IN DIRECTORY CONTAINS %s\n",
dirp->d_name);
dirp->d_name[0] == '.' &&
idesc->id_entryno >= 2) {
if (dirp->d_namlen == 1) {
dirp->d_name[0] == '.' &&
idesc->id_entryno >= 2) {
if (dirp->d_namlen == 1) {
- direrr(idesc->id_number, "EXTRA '.' ENTRY");
+ direrror(idesc->id_number, "EXTRA '.' ENTRY");
dirp->d_ino = 0;
if (reply("FIX") == 1)
ret |= ALTERED;
return (KEEPON | ret);
}
if (dirp->d_name[1] == '.') {
dirp->d_ino = 0;
if (reply("FIX") == 1)
ret |= ALTERED;
return (KEEPON | ret);
}
if (dirp->d_name[1] == '.') {
- direrr(idesc->id_number, "EXTRA '..' ENTRY");
+ direrror(idesc->id_number, "EXTRA '..' ENTRY");
dirp->d_ino = 0;
if (reply("FIX") == 1)
ret |= ALTERED;
dirp->d_ino = 0;
if (reply("FIX") == 1)
ret |= ALTERED;
*pathp = '\0';
errexit("NAME TOO LONG %s%s\n", pathname, dirp->d_name);
}
*pathp = '\0';
errexit("NAME TOO LONG %s%s\n", pathname, dirp->d_name);
}
- bcopy(dirp->d_name, pathp, dirp->d_namlen + 1);
+ bcopy(dirp->d_name, pathp, (int)dirp->d_namlen + 1);
pathp += dirp->d_namlen;
idesc->id_entryno++;
n = 0;
pathp += dirp->d_namlen;
idesc->id_entryno++;
n = 0;
- if (dirp->d_ino > imax || dirp->d_ino <= 0) {
- direrr(dirp->d_ino, "I OUT OF RANGE");
+ if (dirp->d_ino > maxino || dirp->d_ino <= 0) {
+ direrror(dirp->d_ino, "I OUT OF RANGE");
n = reply("REMOVE");
} else {
again:
switch (statemap[dirp->d_ino]) {
case USTATE:
n = reply("REMOVE");
} else {
again:
switch (statemap[dirp->d_ino]) {
case USTATE:
- direrr(dirp->d_ino, "UNALLOCATED");
+ direrror(dirp->d_ino, "UNALLOCATED");
n = reply("REMOVE");
break;
case DCLEAR:
case FCLEAR:
n = reply("REMOVE");
break;
case DCLEAR:
case FCLEAR:
- direrr(dirp->d_ino, "DUP/BAD");
+ direrror(dirp->d_ino, "DUP/BAD");
if ((n = reply("REMOVE")) == 1)
break;
dp = ginode(dirp->d_ino);
if ((n = reply("REMOVE")) == 1)
break;
dp = ginode(dirp->d_ino);
- statemap[dirp->d_ino] = DIRCT(dp) ? DSTATE : FSTATE;
+ statemap[dirp->d_ino] =
+ (dp->di_mode & IFMT) == IFDIR ? DSTATE : FSTATE;
lncntp[dirp->d_ino] = dp->di_nlink;
goto again;
lncntp[dirp->d_ino] = dp->di_nlink;
goto again;
-static char sccsid[] = "@(#)pass3.c 5.4 (Berkeley) %G%";
+static char sccsid[] = "@(#)pass3.c 5.5 (Berkeley) %G%";
#endif not lint
#include <sys/param.h>
#endif not lint
#include <sys/param.h>
+ register struct dinode *dp;
struct inodesc idesc;
ino_t inumber, orphan;
int loopcnt;
struct inodesc idesc;
ino_t inumber, orphan;
int loopcnt;
loopcnt = 0;
do {
orphan = idesc.id_parent;
loopcnt = 0;
do {
orphan = idesc.id_parent;
- if (orphan < ROOTINO || orphan > imax)
+ if (orphan < ROOTINO || orphan > maxino)
break;
dp = ginode(orphan);
idesc.id_parent = 0;
break;
dp = ginode(orphan);
idesc.id_parent = 0;
-static char sccsid[] = "@(#)pass4.c 5.5 (Berkeley) %G%";
+static char sccsid[] = "@(#)pass4.c 5.6 (Berkeley) %G%";
#endif not lint
#include <sys/param.h>
#endif not lint
#include <sys/param.h>
zlnp->zlncnt = zlnhead->zlncnt;
zlnp = zlnhead;
zlnhead = zlnhead->next;
zlnp->zlncnt = zlnhead->zlncnt;
zlnp = zlnhead;
zlnhead = zlnhead->next;
clri(&idesc, "UNREF", 1);
break;
}
clri(&idesc, "UNREF", 1);
break;
}
daddr_t blkno = idesc->id_blkno;
for (nfrags = idesc->id_numfrags; nfrags > 0; blkno++, nfrags--) {
daddr_t blkno = idesc->id_blkno;
for (nfrags = idesc->id_numfrags; nfrags > 0; blkno++, nfrags--) {
- if (outrange(blkno, 1)) {
+ if (chkrange(blkno, 1)) {
- } else if (getbmap(blkno)) {
+ } else if (testbmap(blkno)) {
for (dlp = duplist; dlp; dlp = dlp->next) {
if (dlp->dup != blkno)
continue;
dlp->dup = duplist->dup;
dlp = duplist;
duplist = duplist->next;
for (dlp = duplist; dlp; dlp = dlp->next) {
if (dlp->dup != blkno)
continue;
dlp->dup = duplist->dup;
dlp = duplist;
duplist = duplist->next;
-static char sccsid[] = "@(#)pass5.c 5.8 (Berkeley) %G%";
+static char sccsid[] = "@(#)pass5.c 5.9 (Berkeley) %G%";
#endif not lint
#include <sys/param.h>
#endif not lint
#include <sys/param.h>
register struct cg *newcg = (struct cg *)buf;
struct ocg *ocg = (struct ocg *)buf;
register struct cg *newcg = (struct cg *)buf;
struct ocg *ocg = (struct ocg *)buf;
- bzero((char *)newcg, fs->fs_cgsize);
+ bzero((char *)newcg, (int)fs->fs_cgsize);
newcg->cg_niblk = fs->fs_ipg;
newcg->cg_niblk = fs->fs_ipg;
- switch (fs->fs_postblformat) {
+ switch ((int)fs->fs_postblformat) {
case FS_42POSTBLFMT:
basesize = (char *)(&ocg->cg_btot[0]) - (char *)(&ocg->cg_link);
case FS_42POSTBLFMT:
basesize = (char *)(&ocg->cg_btot[0]) - (char *)(&ocg->cg_link);
d += fs->fs_frag, i += fs->fs_frag) {
frags = 0;
for (j = 0; j < fs->fs_frag; j++) {
d += fs->fs_frag, i += fs->fs_frag) {
frags = 0;
for (j = 0; j < fs->fs_frag; j++) {
continue;
setbit(cg_blksfree(newcg), i + j);
frags++;
continue;
setbit(cg_blksfree(newcg), i + j);
frags++;
sbdirty();
}
if (cvtflag) {
sbdirty();
}
if (cvtflag) {
- bcopy((char *)newcg, (char *)cg, fs->fs_cgsize);
+ bcopy((char *)newcg, (char *)cg, (int)fs->fs_cgsize);
-static char sccsid[] = "@(#)setup.c 5.23 (Berkeley) %G%";
+static char sccsid[] = "@(#)setup.c 5.24 (Berkeley) %G%";
#endif not lint
#define DKTYPENAMES
#endif not lint
#define DKTYPENAMES
#include <ctype.h>
#include "fsck.h"
#include <ctype.h>
#include "fsck.h"
#define altsblock (*asblk.b_un.b_fs)
#define POWEROF2(num) (((num) & ((num) - 1)) == 0)
#define altsblock (*asblk.b_un.b_fs)
#define POWEROF2(num) (((num) & ((num) - 1)) == 0)
char *dev;
{
dev_t rootdev;
char *dev;
{
dev_t rootdev;
- long cg, ncg, size, asked, i, j;
+ long cg, size, asked, i, j;
+ long bmapsize;
struct disklabel *lp;
struct stat statb;
struct fs proto;
struct disklabel *lp;
struct stat statb;
struct fs proto;
printf("Can't stat %s\n", dev);
return (0);
}
printf("Can't stat %s\n", dev);
return (0);
}
- rawflg = 0;
- if ((statb.st_mode & S_IFMT) == S_IFBLK)
- ;
- else if ((statb.st_mode & S_IFMT) == S_IFCHR)
- rawflg++;
- else {
- if (reply("file is not a block or character device; OK") == 0)
- return (0);
- }
+ if ((statb.st_mode & S_IFMT) != S_IFBLK &&
+ (statb.st_mode & S_IFMT) != S_IFCHR &&
+ reply("file is not a block or character device; OK") == 0)
+ return (0);
if (rootdev == statb.st_rdev)
hotroot++;
if (rootdev == statb.st_rdev)
hotroot++;
- if ((dfile.rfdes = open(dev, O_RDONLY)) < 0) {
+ if ((fsreadfd = open(dev, O_RDONLY)) < 0) {
perror(dev);
printf("Can't open %s\n", dev);
return (0);
}
if (preen == 0)
printf("** %s", dev);
perror(dev);
printf("Can't open %s\n", dev);
return (0);
}
if (preen == 0)
printf("** %s", dev);
- if (nflag || (dfile.wfdes = open(dev, O_WRONLY)) < 0) {
- dfile.wfdes = -1;
+ if (nflag || (fswritefd = open(dev, O_WRONLY)) < 0) {
+ fswritefd = -1;
if (preen)
pfatal("NO WRITE ACCESS");
printf(" (NO WRITE)");
}
if (preen == 0)
printf("\n");
if (preen)
pfatal("NO WRITE ACCESS");
printf(" (NO WRITE)");
}
if (preen == 0)
printf("\n");
lfdir = 0;
initbarea(&sblk);
initbarea(&asblk);
lfdir = 0;
initbarea(&sblk);
initbarea(&asblk);
asblk.b_un.b_buf = malloc(SBSIZE);
if (sblk.b_un.b_buf == NULL || asblk.b_un.b_buf == NULL)
errexit("cannot allocate space for superblock\n");
asblk.b_un.b_buf = malloc(SBSIZE);
if (sblk.b_un.b_buf == NULL || asblk.b_un.b_buf == NULL)
errexit("cannot allocate space for superblock\n");
- if (lp = getdisklabel((char *)NULL, dfile.rfdes))
+ if (lp = getdisklabel((char *)NULL, fsreadfd))
dev_bsize = secsize = lp->d_secsize;
else
dev_bsize = secsize = DEV_BSIZE;
dev_bsize = secsize = lp->d_secsize;
else
dev_bsize = secsize = DEV_BSIZE;
* Read in the superblock, looking for alternates if necessary
*/
if (readsb(1) == 0) {
* Read in the superblock, looking for alternates if necessary
*/
if (readsb(1) == 0) {
- if (bflag || preen || calcsb(dev, dfile.rfdes, &proto) == 0)
+ if (bflag || preen || calcsb(dev, fsreadfd, &proto) == 0)
return(0);
if (reply("LOOK FOR ALTERNATE SUPERBLOCKS") == 0)
return (0);
return(0);
if (reply("LOOK FOR ALTERNATE SUPERBLOCKS") == 0)
return (0);
}
pwarn("USING ALTERNATE SUPERBLOCK AT %d\n", bflag);
}
}
pwarn("USING ALTERNATE SUPERBLOCK AT %d\n", bflag);
}
- fmax = sblock.fs_size;
- imax = sblock.fs_ncg * sblock.fs_ipg;
+ maxfsblock = sblock.fs_size;
+ maxino = sblock.fs_ncg * sblock.fs_ipg;
/*
* Check and potentially fix certain fields in the super block.
*/
/*
* Check and potentially fix certain fields in the super block.
*/
- bcopy((char *)&sblock, (char *)&altsblock, sblock.fs_sbsize);
- flush(&dfile, &asblk);
+ bcopy((char *)&sblock, (char *)&altsblock,
+ (int)sblock.fs_sbsize);
+ flush(fswritefd, &asblk);
}
/*
* read in the summary info.
}
/*
* read in the summary info.
size = sblock.fs_cssize - i < sblock.fs_bsize ?
sblock.fs_cssize - i : sblock.fs_bsize;
sblock.fs_csp[j] = (struct csum *)calloc(1, (unsigned)size);
size = sblock.fs_cssize - i < sblock.fs_bsize ?
sblock.fs_cssize - i : sblock.fs_bsize;
sblock.fs_csp[j] = (struct csum *)calloc(1, (unsigned)size);
- if (bread(&dfile, (char *)sblock.fs_csp[j],
+ if (bread(fsreadfd, (char *)sblock.fs_csp[j],
fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
size) != 0 && !asked) {
pfatal("BAD SUMMARY INFORMATION");
fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
size) != 0 && !asked) {
pfatal("BAD SUMMARY INFORMATION");
/*
* allocate and initialize the necessary maps
*/
/*
* allocate and initialize the necessary maps
*/
- bmapsz = roundup(howmany(fmax, NBBY), sizeof(short));
- blockmap = calloc((unsigned)bmapsz, sizeof (char));
+ bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(short));
+ blockmap = calloc((unsigned)bmapsize, sizeof (char));
- printf("cannot alloc %d bytes for blockmap\n", bmapsz);
+ printf("cannot alloc %d bytes for blockmap\n", bmapsize);
- statemap = calloc((unsigned)(imax + 1), sizeof(char));
+ statemap = calloc((unsigned)(maxino + 1), sizeof(char));
- printf("cannot alloc %d bytes for statemap\n", imax + 1);
+ printf("cannot alloc %d bytes for statemap\n", maxino + 1);
- lncntp = (short *)calloc((unsigned)(imax + 1), sizeof(short));
+ lncntp = (short *)calloc((unsigned)(maxino + 1), sizeof(short));
if (lncntp == NULL) {
printf("cannot alloc %d bytes for lncntp\n",
if (lncntp == NULL) {
printf("cannot alloc %d bytes for lncntp\n",
- (imax + 1) * sizeof(short));
+ (maxino + 1) * sizeof(short));
readsb(listerr)
int listerr;
{
readsb(listerr)
int listerr;
{
daddr_t super = bflag ? bflag : SBOFF / dev_bsize;
daddr_t super = bflag ? bflag : SBOFF / dev_bsize;
- if (bread(&dfile, (char *)&sblock, super, (long)SBSIZE) != 0)
+ if (bread(fsreadfd, (char *)&sblock, super, (long)SBSIZE) != 0)
return (0);
sblk.b_bno = super;
sblk.b_size = SBSIZE;
return (0);
sblk.b_bno = super;
sblk.b_size = SBSIZE;
fstypenames[pp->p_fstype] : "unknown");
return (0);
}
fstypenames[pp->p_fstype] : "unknown");
return (0);
}
- bzero(fs, sizeof(struct fs));
+ bzero((char *)fs, sizeof(struct fs));
fs->fs_fsize = pp->p_fsize;
fs->fs_frag = pp->p_frag;
fs->fs_cpg = pp->p_cpg;
fs->fs_fsize = pp->p_fsize;
fs->fs_frag = pp->p_frag;
fs->fs_cpg = pp->p_cpg;
-static char sccsid[] = "@(#)utilities.c 5.18 (Berkeley) %G%";
+static char sccsid[] = "@(#)utilities.c 5.19 (Berkeley) %G%";
#endif not lint
#include <sys/param.h>
#endif not lint
#include <sys/param.h>
char *malloc();
ftypeok(dp)
char *malloc();
ftypeok(dp)
{
switch (dp->di_mode & IFMT) {
{
switch (dp->di_mode & IFMT) {
+reply(mesg)
+ char *mesg;
- int cont = (strcmp(s, "CONTINUE") == 0);
+ int cont = (strcmp(mesg, "CONTINUE") == 0);
if (preen)
pfatal("INTERNAL ERROR: GOT TO reply()");
if (preen)
pfatal("INTERNAL ERROR: GOT TO reply()");
- printf("\n%s? ", s);
- if (!cont && (nflag || dfile.wfdes < 0)) {
+ printf("\n%s? ", mesg);
+ if (!cont && (nflag || fswritefd < 0)) {
printf(" no\n\n");
return (0);
}
printf(" no\n\n");
return (0);
}
getline(fp, loc, maxlen)
FILE *fp;
char *loc;
getline(fp, loc, maxlen)
FILE *fp;
char *loc;
register char *p, *lastloc;
p = loc;
register char *p, *lastloc;
p = loc;
+ register struct bufarea *bp;
long bufcnt, i;
char *bufp;
long bufcnt, i;
char *bufp;
- bufp = malloc(sblock.fs_bsize);
+ bufp = malloc((unsigned int)sblock.fs_bsize);
if (bufp == 0)
errexit("cannot allocate buffer pool\n");
cgblk.b_un.b_buf = bufp;
if (bufp == 0)
errexit("cannot allocate buffer pool\n");
cgblk.b_un.b_buf = bufp;
if (bufcnt < MINBUFS)
bufcnt = MINBUFS;
for (i = 0; i < bufcnt; i++) {
if (bufcnt < MINBUFS)
bufcnt = MINBUFS;
for (i = 0; i < bufcnt; i++) {
- bp = (BUFAREA *)malloc(sizeof(BUFAREA));
- bufp = malloc(sblock.fs_bsize);
+ bp = (struct bufarea *)malloc(sizeof(struct bufarea));
+ bufp = malloc((unsigned int)sblock.fs_bsize);
if (bp == NULL || bufp == NULL) {
if (i >= MINBUFS)
break;
if (bp == NULL || bufp == NULL) {
if (i >= MINBUFS)
break;
/*
* Manage a cache of directory blocks.
*/
/*
* Manage a cache of directory blocks.
*/
getdatablk(blkno, size)
daddr_t blkno;
long size;
{
getdatablk(blkno, size)
daddr_t blkno;
long size;
{
+ register struct bufarea *bp;
for (bp = bufhead.b_next; bp != &bufhead; bp = bp->b_next)
if (bp->b_bno == fsbtodb(&sblock, blkno))
for (bp = bufhead.b_next; bp != &bufhead; bp = bp->b_next)
if (bp->b_bno == fsbtodb(&sblock, blkno))
+ register struct bufarea *bp;
daddr_t blk;
long size;
{
daddr_t blk;
long size;
{
- register struct filecntl *fcp;
dblk = fsbtodb(&sblock, blk);
if (bp->b_bno == dblk)
return (bp);
dblk = fsbtodb(&sblock, blk);
if (bp->b_bno == dblk)
return (bp);
- bp->b_errs = bread(fcp, bp->b_un.b_buf, dblk, size);
+ bp->b_errs = bread(fsreadfd, bp->b_un.b_buf, dblk, size);
bp->b_bno = dblk;
bp->b_size = size;
return (bp);
}
bp->b_bno = dblk;
bp->b_size = size;
return (bp);
}
-flush(fcp, bp)
- struct filecntl *fcp;
- register BUFAREA *bp;
+flush(fd, bp)
+ int fd;
+ register struct bufarea *bp;
bp->b_bno);
bp->b_dirty = 0;
bp->b_errs = 0;
bp->b_bno);
bp->b_dirty = 0;
bp->b_errs = 0;
- bwrite(fcp, bp->b_un.b_buf, bp->b_bno, (long)bp->b_size);
+ bwrite(fd, bp->b_un.b_buf, bp->b_bno, (long)bp->b_size);
if (bp != &sblk)
return;
for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
if (bp != &sblk)
return;
for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
- bwrite(&dfile, (char *)sblock.fs_csp[j],
+ bwrite(fswritefd, (char *)sblock.fs_csp[j],
fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
sblock.fs_cssize - i < sblock.fs_bsize ?
sblock.fs_cssize - i : sblock.fs_bsize);
}
}
fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
sblock.fs_cssize - i < sblock.fs_bsize ?
sblock.fs_cssize - i : sblock.fs_bsize);
}
}
-rwerr(s, blk)
- char *s;
+rwerror(mesg, blk)
+ char *mesg;
daddr_t blk;
{
if (preen == 0)
printf("\n");
daddr_t blk;
{
if (preen == 0)
printf("\n");
- pfatal("CANNOT %s: BLK %ld", s, blk);
+ pfatal("CANNOT %s: BLK %ld", mesg, blk);
if (reply("CONTINUE") == 0)
errexit("Program terminated\n");
}
ckfini()
{
if (reply("CONTINUE") == 0)
errexit("Program terminated\n");
}
ckfini()
{
- register BUFAREA *bp, *nbp;
+ register struct bufarea *bp, *nbp;
+ flush(fswritefd, &sblk);
if (havesb && sblk.b_bno != SBOFF / dev_bsize &&
!preen && reply("UPDATE STANDARD SUPERBLOCK")) {
sblk.b_bno = SBOFF / dev_bsize;
sbdirty();
if (havesb && sblk.b_bno != SBOFF / dev_bsize &&
!preen && reply("UPDATE STANDARD SUPERBLOCK")) {
sblk.b_bno = SBOFF / dev_bsize;
sbdirty();
+ flush(fswritefd, &sblk);
+ flush(fswritefd, &cgblk);
free(cgblk.b_un.b_buf);
for (bp = bufhead.b_prev; bp != &bufhead; bp = nbp) {
cnt++;
free(cgblk.b_un.b_buf);
for (bp = bufhead.b_prev; bp != &bufhead; bp = nbp) {
cnt++;
nbp = bp->b_prev;
free(bp->b_un.b_buf);
free((char *)bp);
nbp = bp->b_prev;
free(bp->b_un.b_buf);
free((char *)bp);
if (debug)
printf("cache missed %d of %d (%d%%)\n", diskreads,
totalreads, diskreads * 100 / totalreads);
if (debug)
printf("cache missed %d of %d (%d%%)\n", diskreads,
totalreads, diskreads * 100 / totalreads);
- (void)close(dfile.rfdes);
- (void)close(dfile.wfdes);
+ (void)close(fsreadfd);
+ (void)close(fswritefd);
-bread(fcp, buf, blk, size)
- register struct filecntl *fcp;
+bread(fd, buf, blk, size)
+ int fd;
char *buf;
daddr_t blk;
long size;
char *buf;
daddr_t blk;
long size;
- if (lseek(fcp->rfdes, blk * dev_bsize, 0) < 0)
- rwerr("SEEK", blk);
- else if (read(fcp->rfdes, buf, (int)size) == size)
+ if (lseek(fd, blk * dev_bsize, 0) < 0)
+ rwerror("SEEK", blk);
+ else if (read(fd, buf, (int)size) == size)
- rwerr("READ", blk);
- if (lseek(fcp->rfdes, blk * dev_bsize, 0) < 0)
- rwerr("SEEK", blk);
+ rwerror("READ", blk);
+ if (lseek(fd, blk * dev_bsize, 0) < 0)
+ rwerror("SEEK", blk);
printf("THE FOLLOWING DISK SECTORS COULD NOT BE READ:");
for (cp = buf, i = 0; i < size; i += secsize, cp += secsize) {
printf("THE FOLLOWING DISK SECTORS COULD NOT BE READ:");
for (cp = buf, i = 0; i < size; i += secsize, cp += secsize) {
- if (read(fcp->rfdes, cp, secsize) < 0) {
- lseek(fcp->rfdes, blk * dev_bsize + i + secsize, 0);
+ if (read(fd, cp, (int)secsize) < 0) {
+ lseek(fd, blk * dev_bsize + i + secsize, 0);
if (secsize != dev_bsize && dev_bsize != 1)
printf(" %d (%d),",
(blk * dev_bsize + i) / secsize,
if (secsize != dev_bsize && dev_bsize != 1)
printf(" %d (%d),",
(blk * dev_bsize + i) / secsize,
-bwrite(fcp, buf, blk, size)
- register struct filecntl *fcp;
+bwrite(fd, buf, blk, size)
+ int fd;
char *buf;
daddr_t blk;
long size;
char *buf;
daddr_t blk;
long size;
- if (lseek(fcp->wfdes, blk * dev_bsize, 0) < 0)
- rwerr("SEEK", blk);
- else if (write(fcp->wfdes, buf, (int)size) == size) {
- fcp->mod = 1;
+ if (lseek(fd, blk * dev_bsize, 0) < 0)
+ rwerror("SEEK", blk);
+ else if (write(fd, buf, (int)size) == size) {
+ fsmodified = 1;
- rwerr("WRITE", blk);
- if (lseek(fcp->wfdes, blk * dev_bsize, 0) < 0)
- rwerr("SEEK", blk);
+ rwerror("WRITE", blk);
+ if (lseek(fd, blk * dev_bsize, 0) < 0)
+ rwerror("SEEK", blk);
printf("THE FOLLOWING SECTORS COULD NOT BE WRITTEN:");
for (cp = buf, i = 0; i < size; i += dev_bsize, cp += dev_bsize)
printf("THE FOLLOWING SECTORS COULD NOT BE WRITTEN:");
for (cp = buf, i = 0; i < size; i += dev_bsize, cp += dev_bsize)
- if (write(fcp->wfdes, cp, dev_bsize) < 0) {
- lseek(fcp->rfdes, blk * dev_bsize + i + dev_bsize, 0);
+ if (write(fd, cp, (int)dev_bsize) < 0) {
+ lseek(fd, blk * dev_bsize + i + dev_bsize, 0);
printf(" %d,", blk + i / dev_bsize);
}
printf("\n");
printf(" %d,", blk + i / dev_bsize);
}
printf("\n");
* allocate a data block with the specified number of fragments
*/
allocblk(frags)
* allocate a data block with the specified number of fragments
*/
allocblk(frags)
{
register int i, j, k;
if (frags <= 0 || frags > sblock.fs_frag)
return (0);
{
register int i, j, k;
if (frags <= 0 || frags > sblock.fs_frag)
return (0);
- for (i = 0; i < fmax - sblock.fs_frag; i += sblock.fs_frag) {
+ for (i = 0; i < maxfsblock - sblock.fs_frag; i += sblock.fs_frag) {
for (j = 0; j <= sblock.fs_frag - frags; j++) {
for (j = 0; j <= sblock.fs_frag - frags; j++) {
continue;
for (k = 1; k < frags; k++)
continue;
for (k = 1; k < frags; k++)
- if (getbmap(i + j + k))
+ if (testbmap(i + j + k))
break;
if (k < frags) {
j += k;
break;
if (k < frags) {
j += k;
*/
freeblk(blkno, frags)
daddr_t blkno;
*/
freeblk(blkno, frags)
daddr_t blkno;
strcpy(namebuf, "?");
return;
}
strcpy(namebuf, "?");
return;
}
- bzero(&idesc, sizeof(struct inodesc));
+ bzero((char *)&idesc, sizeof(struct inodesc));
idesc.id_type = DATA;
cp = &namebuf[BUFSIZ - 1];
*cp = '\0';
idesc.id_type = DATA;
cp = &namebuf[BUFSIZ - 1];
*cp = '\0';
case DONTKNOW:
if (idesc->id_type == DATA)
case DONTKNOW:
if (idesc->id_type == DATA)
- direrr(idesc->id_number, msg);
+ direrror(idesc->id_number, msg);
else
pwarn(msg);
if (preen) {
else
pwarn(msg);
if (preen) {
- * An inconsistency occured which shouldn't during normal operations.
- * Die if preening, otherwise just printf.
+ * An unexpected inconsistency occured.
+ * Die if preening, otherwise just print message and continue.
*/
/* VARARGS1 */
pfatal(s, a1, a2, a3)
*/
/* VARARGS1 */
pfatal(s, a1, a2, a3)
- * Pwarn is like printf when not preening,
+ * Pwarn just prints a message when not preening,
* or a warning (preceded by filename) when preening.
*/
/* VARARGS1 */
* or a warning (preceded by filename) when preening.
*/
/* VARARGS1 */
projects / unix-history / commitdiff