Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sbin/fsck_lfs/pass0.c

241 lines
7.3 KiB
C
Raw Normal View History

Various improvements to fsck_lfs, to wit: * Add lfs_balloc capability to the lfs library. * Extend the Ifile if we run out of free inodes when creating lost+found. * Don't roll forward if we have allocated a lost+found, to avoid conflicts when adding new files in roll-forward. * Make some messages slightly more verbose (e.g. include inode number, and use pwarn() instead of printf() so the messages include the device name when preening). * Change superblock detection/avoidance to use the offset table in the primary superblock, rather than looking at the contents. * Be more verbose about various operations when passed the -d flag, especially roll-forward. * Be more careful about dirops during roll forward, since the cleaner can sometimes write blocks from dirop vnodes. Detect and avoid this problem. * Always check the free list, even if given -i; if we're going to write it we have to check it first. * Mark inodes dirty when blocks are found during roll forward, so the inodes are written with the new block locations. * Update size of inodes if blocks beyond EOF are found during roll forward. * Fix segment accounting for blocks and inodes found during roll forward. * Report statistics on roll forward: how many new/deleted/moved files and how many updated blocks (or "nothing new"). * Don't care if the device being checked is really a device, if we have been passed the -f flag (to facilitate automated testing). * When writing to the disk, use the current time in the segment headers rathern than time 0. * When passed the -i flag, locate the partial segment containing the Ifile inode and use that to calculate lfs_offset, lfs_curseg, lfs_nextseg. (Again for automated testing.)
2006-07-19 03:37:13 +04:00
/* $NetBSD: pass0.c,v 1.28 2006/07/18 23:37:13 perseant Exp $ */
RCS Id police.
1999-07-03 23:55:03 +04:00
Add working writing ability to fsck_lfs, including roll-forward, based on a partial-segment writer ported from the kernel.
2003-03-28 11:09:52 +03:00
/*-
* Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Konrad E. Schroder <perseant@hhhh.org>.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the NetBSD
* Foundation, Inc. and its contributors.
* 4. Neither the name of The NetBSD Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*-
Initial checkin of fsck_lfs. This version cannot do any repair (-p flag does nothing, and one of -p or -n is required) but can be useful as a diagnostic tool.
1999-03-18 05:02:18 +03:00
* Copyright (c) 1980, 1986, 1993
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
Move UCB-licensed code from 4-clause to 3-clause licence. Patches provided by Joel Baker in PR 22308, verified by myself.
2003-08-07 14:04:22 +04:00
* 3. Neither the name of the University nor the names of its contributors
Initial checkin of fsck_lfs. This version cannot do any repair (-p flag does nothing, and one of -p or -n is required) but can be useful as a diagnostic tool.
1999-03-18 05:02:18 +03:00
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
Add working writing ability to fsck_lfs, including roll-forward, based on a partial-segment writer ported from the kernel.
2003-03-28 11:09:52 +03:00
#include <sys/types.h>
Initial checkin of fsck_lfs. This version cannot do any repair (-p flag does nothing, and one of -p or -n is required) but can be useful as a diagnostic tool.
1999-03-18 05:02:18 +03:00
#include <sys/param.h>
#include <sys/time.h>
Add working writing ability to fsck_lfs, including roll-forward, based on a partial-segment writer ported from the kernel.
2003-03-28 11:09:52 +03:00
#include <sys/buf.h>
Initial checkin of fsck_lfs. This version cannot do any repair (-p flag does nothing, and one of -p or -n is required) but can be useful as a diagnostic tool.
1999-03-18 05:02:18 +03:00
#include <sys/mount.h>
Add working writing ability to fsck_lfs, including roll-forward, based on a partial-segment writer ported from the kernel.
2003-03-28 11:09:52 +03:00
#include <ufs/ufs/inode.h>
#include <ufs/ufs/dir.h>
#define vnode uvnode
Initial checkin of fsck_lfs. This version cannot do any repair (-p flag does nothing, and one of -p or -n is required) but can be useful as a diagnostic tool.
1999-03-18 05:02:18 +03:00
#include <ufs/lfs/lfs.h>
Add working writing ability to fsck_lfs, including roll-forward, based on a partial-segment writer ported from the kernel.
2003-03-28 11:09:52 +03:00
#undef vnode
Initial checkin of fsck_lfs. This version cannot do any repair (-p flag does nothing, and one of -p or -n is required) but can be useful as a diagnostic tool.
1999-03-18 05:02:18 +03:00
Various improvements to fsck_lfs, to wit: * Add lfs_balloc capability to the lfs library. * Extend the Ifile if we run out of free inodes when creating lost+found. * Don't roll forward if we have allocated a lost+found, to avoid conflicts when adding new files in roll-forward. * Make some messages slightly more verbose (e.g. include inode number, and use pwarn() instead of printf() so the messages include the device name when preening). * Change superblock detection/avoidance to use the offset table in the primary superblock, rather than looking at the contents. * Be more verbose about various operations when passed the -d flag, especially roll-forward. * Be more careful about dirops during roll forward, since the cleaner can sometimes write blocks from dirop vnodes. Detect and avoid this problem. * Always check the free list, even if given -i; if we're going to write it we have to check it first. * Mark inodes dirty when blocks are found during roll forward, so the inodes are written with the new block locations. * Update size of inodes if blocks beyond EOF are found during roll forward. * Fix segment accounting for blocks and inodes found during roll forward. * Report statistics on roll forward: how many new/deleted/moved files and how many updated blocks (or "nothing new"). * Don't care if the device being checked is really a device, if we have been passed the -f flag (to facilitate automated testing). * When writing to the disk, use the current time in the segment headers rathern than time 0. * When passed the -i flag, locate the partial segment containing the Ifile inode and use that to calculate lfs_offset, lfs_curseg, lfs_nextseg. (Again for automated testing.)
2006-07-19 03:37:13 +04:00
#include <assert.h>
Make it compile again.
2006-03-17 22:24:08 +03:00
#include <err.h>
Initial checkin of fsck_lfs. This version cannot do any repair (-p flag does nothing, and one of -p or -n is required) but can be useful as a diagnostic tool.
1999-03-18 05:02:18 +03:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
Add working writing ability to fsck_lfs, including roll-forward, based on a partial-segment writer ported from the kernel.
2003-03-28 11:09:52 +03:00
#include "bufcache.h"
#include "vnode.h"
rename lfs.h to lfs_user.h so that it does not conflict.
2005-09-13 08:14:17 +04:00
#include "lfs_user.h"
Add working writing ability to fsck_lfs, including roll-forward, based on a partial-segment writer ported from the kernel.
2003-03-28 11:09:52 +03:00
Initial checkin of fsck_lfs. This version cannot do any repair (-p flag does nothing, and one of -p or -n is required) but can be useful as a diagnostic tool.
1999-03-18 05:02:18 +03:00
#include "fsck.h"
#include "extern.h"
#include "fsutil.h"
Add working writing ability to fsck_lfs, including roll-forward, based on a partial-segment writer ported from the kernel.
2003-03-28 11:09:52 +03:00
extern int fake_cleanseg;
Initial checkin of fsck_lfs. This version cannot do any repair (-p flag does nothing, and one of -p or -n is required) but can be useful as a diagnostic tool.
1999-03-18 05:02:18 +03:00
/*
* Pass 0. Check the LFS partial segments for valid checksums, correcting
* if necessary. Also check for valid offsets for inode and finfo blocks.
*/
Convert to NetBSD source code style
2000-05-23 05:48:52 +04:00
/*
* XXX more could be done here---consistency between inode-held blocks and
* finfo blocks, for one thing.
*/
Initial checkin of fsck_lfs. This version cannot do any repair (-p flag does nothing, and one of -p or -n is required) but can be useful as a diagnostic tool.
1999-03-18 05:02:18 +03:00
Add working writing ability to fsck_lfs, including roll-forward, based on a partial-segment writer ported from the kernel.
2003-03-28 11:09:52 +03:00
#define dbshift (fs->lfs_bshift - fs->lfs_blktodb)
Initial checkin of fsck_lfs. This version cannot do any repair (-p flag does nothing, and one of -p or -n is required) but can be useful as a diagnostic tool.
1999-03-18 05:02:18 +03:00
Check for cycles in the inode free list, and for free inodes not on the free list.
2000-05-30 08:33:14 +04:00
void
ANSIfy, WARNS=2
2005-01-19 22:41:59 +03:00
pass0(void)
Initial checkin of fsck_lfs. This version cannot do any repair (-p flag does nothing, and one of -p or -n is required) but can be useful as a diagnostic tool.
1999-03-18 05:02:18 +03:00
{
Add working writing ability to fsck_lfs, including roll-forward, based on a partial-segment writer ported from the kernel.
2003-03-28 11:09:52 +03:00
daddr_t daddr;
Check inode free list tail pointer as well as head pointer, and write both into the CLEANERINFO block of the Ifile as well as into the superblock. Make preen update both superblocks.
2003-03-31 23:56:59 +04:00
CLEANERINFO *cip;
Add working writing ability to fsck_lfs, including roll-forward, based on a partial-segment writer ported from the kernel.
2003-03-28 11:09:52 +03:00
IFILE *ifp;
Remove the free list ordering/disordering code, since the kernel now keeps the list in order (ordering it on mount). Regularize error messages: these are now all in ALL CAPS, with all hex numbers (not reported in caps) prefixed by 0x. (The non-fsck-specific messages are an exception to this all-caps rule.)
2006-04-17 23:05:16 +04:00
struct ubuf *bp, *cbp;
Various improvements to fsck_lfs, to wit: * Add lfs_balloc capability to the lfs library. * Extend the Ifile if we run out of free inodes when creating lost+found. * Don't roll forward if we have allocated a lost+found, to avoid conflicts when adding new files in roll-forward. * Make some messages slightly more verbose (e.g. include inode number, and use pwarn() instead of printf() so the messages include the device name when preening). * Change superblock detection/avoidance to use the offset table in the primary superblock, rather than looking at the contents. * Be more verbose about various operations when passed the -d flag, especially roll-forward. * Be more careful about dirops during roll forward, since the cleaner can sometimes write blocks from dirop vnodes. Detect and avoid this problem. * Always check the free list, even if given -i; if we're going to write it we have to check it first. * Mark inodes dirty when blocks are found during roll forward, so the inodes are written with the new block locations. * Update size of inodes if blocks beyond EOF are found during roll forward. * Fix segment accounting for blocks and inodes found during roll forward. * Report statistics on roll forward: how many new/deleted/moved files and how many updated blocks (or "nothing new"). * Don't care if the device being checked is really a device, if we have been passed the -f flag (to facilitate automated testing). * When writing to the disk, use the current time in the segment headers rathern than time 0. * When passed the -i flag, locate the partial segment containing the Ifile inode and use that to calculate lfs_offset, lfs_curseg, lfs_nextseg. (Again for automated testing.)
2006-07-19 03:37:13 +04:00
ino_t ino, plastino, nextino, lowfreeino, freehd;
char *visited;
Check inode free list tail pointer as well as head pointer, and write both into the CLEANERINFO block of the Ifile as well as into the superblock. Make preen update both superblocks.
2003-03-31 23:56:59 +04:00
int writeit = 0;
Initial checkin of fsck_lfs. This version cannot do any repair (-p flag does nothing, and one of -p or -n is required) but can be useful as a diagnostic tool.
1999-03-18 05:02:18 +03:00
Convert to NetBSD source code style
2000-05-23 05:48:52 +04:00
/*
Various improvements to fsck_lfs, to wit: * Add lfs_balloc capability to the lfs library. * Extend the Ifile if we run out of free inodes when creating lost+found. * Don't roll forward if we have allocated a lost+found, to avoid conflicts when adding new files in roll-forward. * Make some messages slightly more verbose (e.g. include inode number, and use pwarn() instead of printf() so the messages include the device name when preening). * Change superblock detection/avoidance to use the offset table in the primary superblock, rather than looking at the contents. * Be more verbose about various operations when passed the -d flag, especially roll-forward. * Be more careful about dirops during roll forward, since the cleaner can sometimes write blocks from dirop vnodes. Detect and avoid this problem. * Always check the free list, even if given -i; if we're going to write it we have to check it first. * Mark inodes dirty when blocks are found during roll forward, so the inodes are written with the new block locations. * Update size of inodes if blocks beyond EOF are found during roll forward. * Fix segment accounting for blocks and inodes found during roll forward. * Report statistics on roll forward: how many new/deleted/moved files and how many updated blocks (or "nothing new"). * Don't care if the device being checked is really a device, if we have been passed the -f flag (to facilitate automated testing). * When writing to the disk, use the current time in the segment headers rathern than time 0. * When passed the -i flag, locate the partial segment containing the Ifile inode and use that to calculate lfs_offset, lfs_curseg, lfs_nextseg. (Again for automated testing.)
2006-07-19 03:37:13 +04:00
* Check the inode free list for inuse inodes, and cycles.
Check for cycles in the inode free list, and for free inodes not on the free list.
2000-05-30 08:33:14 +04:00
* Make sure that all free inodes are in fact on the list.
Various improvements to fsck_lfs, to wit: * Add lfs_balloc capability to the lfs library. * Extend the Ifile if we run out of free inodes when creating lost+found. * Don't roll forward if we have allocated a lost+found, to avoid conflicts when adding new files in roll-forward. * Make some messages slightly more verbose (e.g. include inode number, and use pwarn() instead of printf() so the messages include the device name when preening). * Change superblock detection/avoidance to use the offset table in the primary superblock, rather than looking at the contents. * Be more verbose about various operations when passed the -d flag, especially roll-forward. * Be more careful about dirops during roll forward, since the cleaner can sometimes write blocks from dirop vnodes. Detect and avoid this problem. * Always check the free list, even if given -i; if we're going to write it we have to check it first. * Mark inodes dirty when blocks are found during roll forward, so the inodes are written with the new block locations. * Update size of inodes if blocks beyond EOF are found during roll forward. * Fix segment accounting for blocks and inodes found during roll forward. * Report statistics on roll forward: how many new/deleted/moved files and how many updated blocks (or "nothing new"). * Don't care if the device being checked is really a device, if we have been passed the -f flag (to facilitate automated testing). * When writing to the disk, use the current time in the segment headers rathern than time 0. * When passed the -i flag, locate the partial segment containing the Ifile inode and use that to calculate lfs_offset, lfs_curseg, lfs_nextseg. (Again for automated testing.)
2006-07-19 03:37:13 +04:00
*/
visited = (char *) malloc(maxino * sizeof(*visited));
Check for allocation failures in malloc, calloc, realloc, asprintf, and vasprintf and try to handle them.
2006-03-17 18:53:46 +03:00
if (visited == NULL)
err(1, NULL);
Various improvements to fsck_lfs, to wit: * Add lfs_balloc capability to the lfs library. * Extend the Ifile if we run out of free inodes when creating lost+found. * Don't roll forward if we have allocated a lost+found, to avoid conflicts when adding new files in roll-forward. * Make some messages slightly more verbose (e.g. include inode number, and use pwarn() instead of printf() so the messages include the device name when preening). * Change superblock detection/avoidance to use the offset table in the primary superblock, rather than looking at the contents. * Be more verbose about various operations when passed the -d flag, especially roll-forward. * Be more careful about dirops during roll forward, since the cleaner can sometimes write blocks from dirop vnodes. Detect and avoid this problem. * Always check the free list, even if given -i; if we're going to write it we have to check it first. * Mark inodes dirty when blocks are found during roll forward, so the inodes are written with the new block locations. * Update size of inodes if blocks beyond EOF are found during roll forward. * Fix segment accounting for blocks and inodes found during roll forward. * Report statistics on roll forward: how many new/deleted/moved files and how many updated blocks (or "nothing new"). * Don't care if the device being checked is really a device, if we have been passed the -f flag (to facilitate automated testing). * When writing to the disk, use the current time in the segment headers rathern than time 0. * When passed the -i flag, locate the partial segment containing the Ifile inode and use that to calculate lfs_offset, lfs_curseg, lfs_nextseg. (Again for automated testing.)
2006-07-19 03:37:13 +04:00
memset(visited, 0, maxino * sizeof(*visited));
Check for cycles in the inode free list, and for free inodes not on the free list.
2000-05-30 08:33:14 +04:00
fix -Wshadow warning
2001-11-02 08:33:21 +03:00
plastino = 0;
Make fsck_lfs optimize the inode free list, if it appears to have become too disordered. This should improve file creation speed on aged filesystems. Include code to disorder the list for debugging purposes, though this is of course not compiled in by default.
2005-03-25 23:14:43 +03:00
lowfreeino = maxino;
Remove the free list ordering/disordering code, since the kernel now keeps the list in order (ordering it on mount). Regularize error messages: these are now all in ALL CAPS, with all hex numbers (not reported in caps) prefixed by 0x. (The non-fsck-specific messages are an exception to this all-caps rule.)
2006-04-17 23:05:16 +04:00
LFS_CLEANERINFO(cip, fs, cbp);
Various improvements to fsck_lfs, to wit: * Add lfs_balloc capability to the lfs library. * Extend the Ifile if we run out of free inodes when creating lost+found. * Don't roll forward if we have allocated a lost+found, to avoid conflicts when adding new files in roll-forward. * Make some messages slightly more verbose (e.g. include inode number, and use pwarn() instead of printf() so the messages include the device name when preening). * Change superblock detection/avoidance to use the offset table in the primary superblock, rather than looking at the contents. * Be more verbose about various operations when passed the -d flag, especially roll-forward. * Be more careful about dirops during roll forward, since the cleaner can sometimes write blocks from dirop vnodes. Detect and avoid this problem. * Always check the free list, even if given -i; if we're going to write it we have to check it first. * Mark inodes dirty when blocks are found during roll forward, so the inodes are written with the new block locations. * Update size of inodes if blocks beyond EOF are found during roll forward. * Fix segment accounting for blocks and inodes found during roll forward. * Report statistics on roll forward: how many new/deleted/moved files and how many updated blocks (or "nothing new"). * Don't care if the device being checked is really a device, if we have been passed the -f flag (to facilitate automated testing). * When writing to the disk, use the current time in the segment headers rathern than time 0. * When passed the -i flag, locate the partial segment containing the Ifile inode and use that to calculate lfs_offset, lfs_curseg, lfs_nextseg. (Again for automated testing.)
2006-07-19 03:37:13 +04:00
freehd = ino = cip->free_head;
Remove the free list ordering/disordering code, since the kernel now keeps the list in order (ordering it on mount). Regularize error messages: these are now all in ALL CAPS, with all hex numbers (not reported in caps) prefixed by 0x. (The non-fsck-specific messages are an exception to this all-caps rule.)
2006-04-17 23:05:16 +04:00
brelse(cbp);
Convert to NetBSD source code style
2000-05-23 05:48:52 +04:00
while (ino) {
Make fsck_lfs optimize the inode free list, if it appears to have become too disordered. This should improve file creation speed on aged filesystems. Include code to disorder the list for debugging purposes, though this is of course not compiled in by default.
2005-03-25 23:14:43 +03:00
if (lowfreeino > ino)
lowfreeino = ino;
Add "-i" flag to specify the location of the index file inode, to examine alternate checkpoints. Regularize usage of maxino. Remove olf debugging cruft.
2000-06-14 22:43:57 +04:00
if (ino >= maxino) {
Various improvements to fsck_lfs, to wit: * Add lfs_balloc capability to the lfs library. * Extend the Ifile if we run out of free inodes when creating lost+found. * Don't roll forward if we have allocated a lost+found, to avoid conflicts when adding new files in roll-forward. * Make some messages slightly more verbose (e.g. include inode number, and use pwarn() instead of printf() so the messages include the device name when preening). * Change superblock detection/avoidance to use the offset table in the primary superblock, rather than looking at the contents. * Be more verbose about various operations when passed the -d flag, especially roll-forward. * Be more careful about dirops during roll forward, since the cleaner can sometimes write blocks from dirop vnodes. Detect and avoid this problem. * Always check the free list, even if given -i; if we're going to write it we have to check it first. * Mark inodes dirty when blocks are found during roll forward, so the inodes are written with the new block locations. * Update size of inodes if blocks beyond EOF are found during roll forward. * Fix segment accounting for blocks and inodes found during roll forward. * Report statistics on roll forward: how many new/deleted/moved files and how many updated blocks (or "nothing new"). * Don't care if the device being checked is really a device, if we have been passed the -f flag (to facilitate automated testing). * When writing to the disk, use the current time in the segment headers rathern than time 0. * When passed the -i flag, locate the partial segment containing the Ifile inode and use that to calculate lfs_offset, lfs_curseg, lfs_nextseg. (Again for automated testing.)
2006-07-19 03:37:13 +04:00
pwarn("OUT OF RANGE INO %llu ON FREE LIST\n",
Remove the free list ordering/disordering code, since the kernel now keeps the list in order (ordering it on mount). Regularize error messages: these are now all in ALL CAPS, with all hex numbers (not reported in caps) prefixed by 0x. (The non-fsck-specific messages are an exception to this all-caps rule.)
2006-04-17 23:05:16 +04:00
(unsigned long long)ino);
Add "-i" flag to specify the location of the index file inode, to examine alternate checkpoints. Regularize usage of maxino. Remove olf debugging cruft.
2000-06-14 22:43:57 +04:00
break;
}
Check for cycles in the inode free list, and for free inodes not on the free list.
2000-05-30 08:33:14 +04:00
if (visited[ino]) {
Remove the free list ordering/disordering code, since the kernel now keeps the list in order (ordering it on mount). Regularize error messages: these are now all in ALL CAPS, with all hex numbers (not reported in caps) prefixed by 0x. (The non-fsck-specific messages are an exception to this all-caps rule.)
2006-04-17 23:05:16 +04:00
pwarn("INO %llu ALREADY FOUND ON FREE LIST\n",
64 bit inode changes
2005-08-19 06:07:18 +04:00
(unsigned long long)ino);
Check for cycles in the inode free list, and for free inodes not on the free list.
2000-05-30 08:33:14 +04:00
if (preen || reply("FIX") == 1) {
fix -Wshadow warning
2001-11-02 08:33:21 +03:00
/* plastino can't be zero */
Add working writing ability to fsck_lfs, including roll-forward, based on a partial-segment writer ported from the kernel.
2003-03-28 11:09:52 +03:00
LFS_IENTRY(ifp, fs, plastino, bp);
Check for cycles in the inode free list, and for free inodes not on the free list.
2000-05-30 08:33:14 +04:00
ifp->if_nextfree = 0;
Add working writing ability to fsck_lfs, including roll-forward, based on a partial-segment writer ported from the kernel.
2003-03-28 11:09:52 +03:00
VOP_BWRITE(bp);
Check for cycles in the inode free list, and for free inodes not on the free list.
2000-05-30 08:33:14 +04:00
}
break;
}
Various improvements to fsck_lfs, to wit: * Add lfs_balloc capability to the lfs library. * Extend the Ifile if we run out of free inodes when creating lost+found. * Don't roll forward if we have allocated a lost+found, to avoid conflicts when adding new files in roll-forward. * Make some messages slightly more verbose (e.g. include inode number, and use pwarn() instead of printf() so the messages include the device name when preening). * Change superblock detection/avoidance to use the offset table in the primary superblock, rather than looking at the contents. * Be more verbose about various operations when passed the -d flag, especially roll-forward. * Be more careful about dirops during roll forward, since the cleaner can sometimes write blocks from dirop vnodes. Detect and avoid this problem. * Always check the free list, even if given -i; if we're going to write it we have to check it first. * Mark inodes dirty when blocks are found during roll forward, so the inodes are written with the new block locations. * Update size of inodes if blocks beyond EOF are found during roll forward. * Fix segment accounting for blocks and inodes found during roll forward. * Report statistics on roll forward: how many new/deleted/moved files and how many updated blocks (or "nothing new"). * Don't care if the device being checked is really a device, if we have been passed the -f flag (to facilitate automated testing). * When writing to the disk, use the current time in the segment headers rathern than time 0. * When passed the -i flag, locate the partial segment containing the Ifile inode and use that to calculate lfs_offset, lfs_curseg, lfs_nextseg. (Again for automated testing.)
2006-07-19 03:37:13 +04:00
visited[ino] = 1;
Add working writing ability to fsck_lfs, including roll-forward, based on a partial-segment writer ported from the kernel.
2003-03-28 11:09:52 +03:00
LFS_IENTRY(ifp, fs, ino, bp);
Convert to NetBSD source code style
2000-05-23 05:48:52 +04:00
nextino = ifp->if_nextfree;
daddr = ifp->if_daddr;
Add working writing ability to fsck_lfs, including roll-forward, based on a partial-segment writer ported from the kernel.
2003-03-28 11:09:52 +03:00
brelse(bp);
Convert to NetBSD source code style
2000-05-23 05:48:52 +04:00
if (daddr) {
Remove the free list ordering/disordering code, since the kernel now keeps the list in order (ordering it on mount). Regularize error messages: these are now all in ALL CAPS, with all hex numbers (not reported in caps) prefixed by 0x. (The non-fsck-specific messages are an exception to this all-caps rule.)
2006-04-17 23:05:16 +04:00
pwarn("INO %llu WITH DADDR 0x%llx ON FREE LIST\n",
64 bit inode changes
2005-08-19 06:07:18 +04:00
(unsigned long long)ino, (long long) daddr);
Convert to NetBSD source code style
2000-05-23 05:48:52 +04:00
if (preen || reply("FIX") == 1) {
fix -Wshadow warning
2001-11-02 08:33:21 +03:00
if (plastino == 0) {
Various improvements to fsck_lfs, to wit: * Add lfs_balloc capability to the lfs library. * Extend the Ifile if we run out of free inodes when creating lost+found. * Don't roll forward if we have allocated a lost+found, to avoid conflicts when adding new files in roll-forward. * Make some messages slightly more verbose (e.g. include inode number, and use pwarn() instead of printf() so the messages include the device name when preening). * Change superblock detection/avoidance to use the offset table in the primary superblock, rather than looking at the contents. * Be more verbose about various operations when passed the -d flag, especially roll-forward. * Be more careful about dirops during roll forward, since the cleaner can sometimes write blocks from dirop vnodes. Detect and avoid this problem. * Always check the free list, even if given -i; if we're going to write it we have to check it first. * Mark inodes dirty when blocks are found during roll forward, so the inodes are written with the new block locations. * Update size of inodes if blocks beyond EOF are found during roll forward. * Fix segment accounting for blocks and inodes found during roll forward. * Report statistics on roll forward: how many new/deleted/moved files and how many updated blocks (or "nothing new"). * Don't care if the device being checked is really a device, if we have been passed the -f flag (to facilitate automated testing). * When writing to the disk, use the current time in the segment headers rathern than time 0. * When passed the -i flag, locate the partial segment containing the Ifile inode and use that to calculate lfs_offset, lfs_curseg, lfs_nextseg. (Again for automated testing.)
2006-07-19 03:37:13 +04:00
freehd = nextino;
Convert to NetBSD source code style
2000-05-23 05:48:52 +04:00
sbdirty();
} else {
Add working writing ability to fsck_lfs, including roll-forward, based on a partial-segment writer ported from the kernel.
2003-03-28 11:09:52 +03:00
LFS_IENTRY(ifp, fs, plastino, bp);
Convert to NetBSD source code style
2000-05-23 05:48:52 +04:00
ifp->if_nextfree = nextino;
Add working writing ability to fsck_lfs, including roll-forward, based on a partial-segment writer ported from the kernel.
2003-03-28 11:09:52 +03:00
VOP_BWRITE(bp);
Convert to NetBSD source code style
2000-05-23 05:48:52 +04:00
}
ino = nextino;
continue;
}
}
fix -Wshadow warning
2001-11-02 08:33:21 +03:00
plastino = ino;
Convert to NetBSD source code style
2000-05-23 05:48:52 +04:00
ino = nextino;
}
Check inode free list tail pointer as well as head pointer, and write both into the CLEANERINFO block of the Ifile as well as into the superblock. Make preen update both superblocks.
2003-03-31 23:56:59 +04:00
Check for cycles in the inode free list, and for free inodes not on the free list.
2000-05-30 08:33:14 +04:00
/*
* Make sure all free inodes were found on the list
*/
Remove the free list ordering/disordering code, since the kernel now keeps the list in order (ordering it on mount). Regularize error messages: these are now all in ALL CAPS, with all hex numbers (not reported in caps) prefixed by 0x. (The non-fsck-specific messages are an exception to this all-caps rule.)
2006-04-17 23:05:16 +04:00
for (ino = maxino - 1; ino > ROOTINO; --ino) {
Check for cycles in the inode free list, and for free inodes not on the free list.
2000-05-30 08:33:14 +04:00
if (visited[ino])
continue;
Add working writing ability to fsck_lfs, including roll-forward, based on a partial-segment writer ported from the kernel.
2003-03-28 11:09:52 +03:00
LFS_IENTRY(ifp, fs, ino, bp);
Check for cycles in the inode free list, and for free inodes not on the free list.
2000-05-30 08:33:14 +04:00
if (ifp->if_daddr) {
Add working writing ability to fsck_lfs, including roll-forward, based on a partial-segment writer ported from the kernel.
2003-03-28 11:09:52 +03:00
brelse(bp);
Check for cycles in the inode free list, and for free inodes not on the free list.
2000-05-30 08:33:14 +04:00
continue;
}
Remove the free list ordering/disordering code, since the kernel now keeps the list in order (ordering it on mount). Regularize error messages: these are now all in ALL CAPS, with all hex numbers (not reported in caps) prefixed by 0x. (The non-fsck-specific messages are an exception to this all-caps rule.)
2006-04-17 23:05:16 +04:00
pwarn("INO %llu FREE BUT NOT ON FREE LIST\n",
64 bit inode changes
2005-08-19 06:07:18 +04:00
(unsigned long long)ino);
Check for cycles in the inode free list, and for free inodes not on the free list.
2000-05-30 08:33:14 +04:00
if (preen || reply("FIX") == 1) {
Various improvements to fsck_lfs, to wit: * Add lfs_balloc capability to the lfs library. * Extend the Ifile if we run out of free inodes when creating lost+found. * Don't roll forward if we have allocated a lost+found, to avoid conflicts when adding new files in roll-forward. * Make some messages slightly more verbose (e.g. include inode number, and use pwarn() instead of printf() so the messages include the device name when preening). * Change superblock detection/avoidance to use the offset table in the primary superblock, rather than looking at the contents. * Be more verbose about various operations when passed the -d flag, especially roll-forward. * Be more careful about dirops during roll forward, since the cleaner can sometimes write blocks from dirop vnodes. Detect and avoid this problem. * Always check the free list, even if given -i; if we're going to write it we have to check it first. * Mark inodes dirty when blocks are found during roll forward, so the inodes are written with the new block locations. * Update size of inodes if blocks beyond EOF are found during roll forward. * Fix segment accounting for blocks and inodes found during roll forward. * Report statistics on roll forward: how many new/deleted/moved files and how many updated blocks (or "nothing new"). * Don't care if the device being checked is really a device, if we have been passed the -f flag (to facilitate automated testing). * When writing to the disk, use the current time in the segment headers rathern than time 0. * When passed the -i flag, locate the partial segment containing the Ifile inode and use that to calculate lfs_offset, lfs_curseg, lfs_nextseg. (Again for automated testing.)
2006-07-19 03:37:13 +04:00
assert(ino != freehd);
ifp->if_nextfree = freehd;
Remove the free list ordering/disordering code, since the kernel now keeps the list in order (ordering it on mount). Regularize error messages: these are now all in ALL CAPS, with all hex numbers (not reported in caps) prefixed by 0x. (The non-fsck-specific messages are an exception to this all-caps rule.)
2006-04-17 23:05:16 +04:00
VOP_BWRITE(bp);
Various improvements to fsck_lfs, to wit: * Add lfs_balloc capability to the lfs library. * Extend the Ifile if we run out of free inodes when creating lost+found. * Don't roll forward if we have allocated a lost+found, to avoid conflicts when adding new files in roll-forward. * Make some messages slightly more verbose (e.g. include inode number, and use pwarn() instead of printf() so the messages include the device name when preening). * Change superblock detection/avoidance to use the offset table in the primary superblock, rather than looking at the contents. * Be more verbose about various operations when passed the -d flag, especially roll-forward. * Be more careful about dirops during roll forward, since the cleaner can sometimes write blocks from dirop vnodes. Detect and avoid this problem. * Always check the free list, even if given -i; if we're going to write it we have to check it first. * Mark inodes dirty when blocks are found during roll forward, so the inodes are written with the new block locations. * Update size of inodes if blocks beyond EOF are found during roll forward. * Fix segment accounting for blocks and inodes found during roll forward. * Report statistics on roll forward: how many new/deleted/moved files and how many updated blocks (or "nothing new"). * Don't care if the device being checked is really a device, if we have been passed the -f flag (to facilitate automated testing). * When writing to the disk, use the current time in the segment headers rathern than time 0. * When passed the -i flag, locate the partial segment containing the Ifile inode and use that to calculate lfs_offset, lfs_curseg, lfs_nextseg. (Again for automated testing.)
2006-07-19 03:37:13 +04:00
freehd = ino;
Check for cycles in the inode free list, and for free inodes not on the free list.
2000-05-30 08:33:14 +04:00
sbdirty();
Remove the free list ordering/disordering code, since the kernel now keeps the list in order (ordering it on mount). Regularize error messages: these are now all in ALL CAPS, with all hex numbers (not reported in caps) prefixed by 0x. (The non-fsck-specific messages are an exception to this all-caps rule.)
2006-04-17 23:05:16 +04:00
/* If freelist was empty, this is the tail */
if (plastino == 0)
plastino = ino;
Add working writing ability to fsck_lfs, including roll-forward, based on a partial-segment writer ported from the kernel.
2003-03-28 11:09:52 +03:00
} else
brelse(bp);
Convert to NetBSD source code style
2000-05-23 05:48:52 +04:00
}
Check inode free list tail pointer as well as head pointer, and write both into the CLEANERINFO block of the Ifile as well as into the superblock. Make preen update both superblocks.
2003-03-31 23:56:59 +04:00
Remove the free list ordering/disordering code, since the kernel now keeps the list in order (ordering it on mount). Regularize error messages: these are now all in ALL CAPS, with all hex numbers (not reported in caps) prefixed by 0x. (The non-fsck-specific messages are an exception to this all-caps rule.)
2006-04-17 23:05:16 +04:00
LFS_CLEANERINFO(cip, fs, cbp);
Various improvements to fsck_lfs, to wit: * Add lfs_balloc capability to the lfs library. * Extend the Ifile if we run out of free inodes when creating lost+found. * Don't roll forward if we have allocated a lost+found, to avoid conflicts when adding new files in roll-forward. * Make some messages slightly more verbose (e.g. include inode number, and use pwarn() instead of printf() so the messages include the device name when preening). * Change superblock detection/avoidance to use the offset table in the primary superblock, rather than looking at the contents. * Be more verbose about various operations when passed the -d flag, especially roll-forward. * Be more careful about dirops during roll forward, since the cleaner can sometimes write blocks from dirop vnodes. Detect and avoid this problem. * Always check the free list, even if given -i; if we're going to write it we have to check it first. * Mark inodes dirty when blocks are found during roll forward, so the inodes are written with the new block locations. * Update size of inodes if blocks beyond EOF are found during roll forward. * Fix segment accounting for blocks and inodes found during roll forward. * Report statistics on roll forward: how many new/deleted/moved files and how many updated blocks (or "nothing new"). * Don't care if the device being checked is really a device, if we have been passed the -f flag (to facilitate automated testing). * When writing to the disk, use the current time in the segment headers rathern than time 0. * When passed the -i flag, locate the partial segment containing the Ifile inode and use that to calculate lfs_offset, lfs_curseg, lfs_nextseg. (Again for automated testing.)
2006-07-19 03:37:13 +04:00
if (cip->free_head != freehd) {
/* They've already given us permission for this change */
cip->free_head = freehd;
writeit = 1;
}
if (freehd != fs->lfs_freehd) {
Remove the free list ordering/disordering code, since the kernel now keeps the list in order (ordering it on mount). Regularize error messages: these are now all in ALL CAPS, with all hex numbers (not reported in caps) prefixed by 0x. (The non-fsck-specific messages are an exception to this all-caps rule.)
2006-04-17 23:05:16 +04:00
pwarn("FREE LIST HEAD IN SUPERBLOCK SHOULD BE %d (WAS %d)\n",
Various improvements to fsck_lfs, to wit: * Add lfs_balloc capability to the lfs library. * Extend the Ifile if we run out of free inodes when creating lost+found. * Don't roll forward if we have allocated a lost+found, to avoid conflicts when adding new files in roll-forward. * Make some messages slightly more verbose (e.g. include inode number, and use pwarn() instead of printf() so the messages include the device name when preening). * Change superblock detection/avoidance to use the offset table in the primary superblock, rather than looking at the contents. * Be more verbose about various operations when passed the -d flag, especially roll-forward. * Be more careful about dirops during roll forward, since the cleaner can sometimes write blocks from dirop vnodes. Detect and avoid this problem. * Always check the free list, even if given -i; if we're going to write it we have to check it first. * Mark inodes dirty when blocks are found during roll forward, so the inodes are written with the new block locations. * Update size of inodes if blocks beyond EOF are found during roll forward. * Fix segment accounting for blocks and inodes found during roll forward. * Report statistics on roll forward: how many new/deleted/moved files and how many updated blocks (or "nothing new"). * Don't care if the device being checked is really a device, if we have been passed the -f flag (to facilitate automated testing). * When writing to the disk, use the current time in the segment headers rathern than time 0. * When passed the -i flag, locate the partial segment containing the Ifile inode and use that to calculate lfs_offset, lfs_curseg, lfs_nextseg. (Again for automated testing.)
2006-07-19 03:37:13 +04:00
(int)fs->lfs_freehd, (int)freehd);
Check inode free list tail pointer as well as head pointer, and write both into the CLEANERINFO block of the Ifile as well as into the superblock. Make preen update both superblocks.
2003-03-31 23:56:59 +04:00
if (preen || reply("FIX")) {
Various improvements to fsck_lfs, to wit: * Add lfs_balloc capability to the lfs library. * Extend the Ifile if we run out of free inodes when creating lost+found. * Don't roll forward if we have allocated a lost+found, to avoid conflicts when adding new files in roll-forward. * Make some messages slightly more verbose (e.g. include inode number, and use pwarn() instead of printf() so the messages include the device name when preening). * Change superblock detection/avoidance to use the offset table in the primary superblock, rather than looking at the contents. * Be more verbose about various operations when passed the -d flag, especially roll-forward. * Be more careful about dirops during roll forward, since the cleaner can sometimes write blocks from dirop vnodes. Detect and avoid this problem. * Always check the free list, even if given -i; if we're going to write it we have to check it first. * Mark inodes dirty when blocks are found during roll forward, so the inodes are written with the new block locations. * Update size of inodes if blocks beyond EOF are found during roll forward. * Fix segment accounting for blocks and inodes found during roll forward. * Report statistics on roll forward: how many new/deleted/moved files and how many updated blocks (or "nothing new"). * Don't care if the device being checked is really a device, if we have been passed the -f flag (to facilitate automated testing). * When writing to the disk, use the current time in the segment headers rathern than time 0. * When passed the -i flag, locate the partial segment containing the Ifile inode and use that to calculate lfs_offset, lfs_curseg, lfs_nextseg. (Again for automated testing.)
2006-07-19 03:37:13 +04:00
fs->lfs_freehd = freehd;
Remove the free list ordering/disordering code, since the kernel now keeps the list in order (ordering it on mount). Regularize error messages: these are now all in ALL CAPS, with all hex numbers (not reported in caps) prefixed by 0x. (The non-fsck-specific messages are an exception to this all-caps rule.)
2006-04-17 23:05:16 +04:00
sbdirty();
Check inode free list tail pointer as well as head pointer, and write both into the CLEANERINFO block of the Ifile as well as into the superblock. Make preen update both superblocks.
2003-03-31 23:56:59 +04:00
}
}
if (cip->free_tail != plastino) {
Remove the free list ordering/disordering code, since the kernel now keeps the list in order (ordering it on mount). Regularize error messages: these are now all in ALL CAPS, with all hex numbers (not reported in caps) prefixed by 0x. (The non-fsck-specific messages are an exception to this all-caps rule.)
2006-04-17 23:05:16 +04:00
pwarn("FREE LIST TAIL SHOULD BE %llu (WAS %llu)\n",
(unsigned long long)plastino,
(unsigned long long)cip->free_tail);
Check inode free list tail pointer as well as head pointer, and write both into the CLEANERINFO block of the Ifile as well as into the superblock. Make preen update both superblocks.
2003-03-31 23:56:59 +04:00
if (preen || reply("FIX")) {
cip->free_tail = plastino;
writeit = 1;
}
}
Various improvements to fsck_lfs, to wit: * Add lfs_balloc capability to the lfs library. * Extend the Ifile if we run out of free inodes when creating lost+found. * Don't roll forward if we have allocated a lost+found, to avoid conflicts when adding new files in roll-forward. * Make some messages slightly more verbose (e.g. include inode number, and use pwarn() instead of printf() so the messages include the device name when preening). * Change superblock detection/avoidance to use the offset table in the primary superblock, rather than looking at the contents. * Be more verbose about various operations when passed the -d flag, especially roll-forward. * Be more careful about dirops during roll forward, since the cleaner can sometimes write blocks from dirop vnodes. Detect and avoid this problem. * Always check the free list, even if given -i; if we're going to write it we have to check it first. * Mark inodes dirty when blocks are found during roll forward, so the inodes are written with the new block locations. * Update size of inodes if blocks beyond EOF are found during roll forward. * Fix segment accounting for blocks and inodes found during roll forward. * Report statistics on roll forward: how many new/deleted/moved files and how many updated blocks (or "nothing new"). * Don't care if the device being checked is really a device, if we have been passed the -f flag (to facilitate automated testing). * When writing to the disk, use the current time in the segment headers rathern than time 0. * When passed the -i flag, locate the partial segment containing the Ifile inode and use that to calculate lfs_offset, lfs_curseg, lfs_nextseg. (Again for automated testing.)
2006-07-19 03:37:13 +04:00
Various minor LFS improvements: * Extend the lfs library from fsck_lfs(8) so that it can be used with a not-yet-existent LFS. Make newfs_lfs(8) use this library, so it can create LFSs whose Ifile is larger than one segment. * Make newfs_lfs(8) use strsuftoi64() for its arguments, a la newfs(8). * Make fsck_lfs(8) respect the "file system is clean" flag. * Don't let fsck_lfs(8) think it has dirty blocks when invoked with the -n flag.
2005-02-26 08:45:54 +03:00
if (writeit)
Remove the free list ordering/disordering code, since the kernel now keeps the list in order (ordering it on mount). Regularize error messages: these are now all in ALL CAPS, with all hex numbers (not reported in caps) prefixed by 0x. (The non-fsck-specific messages are an exception to this all-caps rule.)
2006-04-17 23:05:16 +04:00
LFS_SYNC_CLEANERINFO(cip, fs, cbp, writeit);
Various minor LFS improvements: * Extend the lfs library from fsck_lfs(8) so that it can be used with a not-yet-existent LFS. Make newfs_lfs(8) use this library, so it can create LFSs whose Ifile is larger than one segment. * Make newfs_lfs(8) use strsuftoi64() for its arguments, a la newfs(8). * Make fsck_lfs(8) respect the "file system is clean" flag. * Don't let fsck_lfs(8) think it has dirty blocks when invoked with the -n flag.
2005-02-26 08:45:54 +03:00
else
Remove the free list ordering/disordering code, since the kernel now keeps the list in order (ordering it on mount). Regularize error messages: these are now all in ALL CAPS, with all hex numbers (not reported in caps) prefixed by 0x. (The non-fsck-specific messages are an exception to this all-caps rule.)
2006-04-17 23:05:16 +04:00
brelse(cbp);
Make fsck_lfs optimize the inode free list, if it appears to have become too disordered. This should improve file creation speed on aged filesystems. Include code to disorder the list for debugging purposes, though this is of course not compiled in by default.
2005-03-25 23:14:43 +03:00
Be more efficient with the hash tables for the buffer and vnode caches. Note that roll-forward can add more inodes to the filesystem; don't overflow the tables but reallocate them.
2005-04-12 03:19:24 +04:00
if (fs->lfs_freehd == 0) {
pwarn("%sree list head is 0x0\n", preen ? "f" : "F");
Various improvements to fsck_lfs, to wit: * Add lfs_balloc capability to the lfs library. * Extend the Ifile if we run out of free inodes when creating lost+found. * Don't roll forward if we have allocated a lost+found, to avoid conflicts when adding new files in roll-forward. * Make some messages slightly more verbose (e.g. include inode number, and use pwarn() instead of printf() so the messages include the device name when preening). * Change superblock detection/avoidance to use the offset table in the primary superblock, rather than looking at the contents. * Be more verbose about various operations when passed the -d flag, especially roll-forward. * Be more careful about dirops during roll forward, since the cleaner can sometimes write blocks from dirop vnodes. Detect and avoid this problem. * Always check the free list, even if given -i; if we're going to write it we have to check it first. * Mark inodes dirty when blocks are found during roll forward, so the inodes are written with the new block locations. * Update size of inodes if blocks beyond EOF are found during roll forward. * Fix segment accounting for blocks and inodes found during roll forward. * Report statistics on roll forward: how many new/deleted/moved files and how many updated blocks (or "nothing new"). * Don't care if the device being checked is really a device, if we have been passed the -f flag (to facilitate automated testing). * When writing to the disk, use the current time in the segment headers rathern than time 0. * When passed the -i flag, locate the partial segment containing the Ifile inode and use that to calculate lfs_offset, lfs_curseg, lfs_nextseg. (Again for automated testing.)
2006-07-19 03:37:13 +04:00
if (preen || reply("FIX"))
Use the correct method to create a new inode, when we allocate lost+found. Correct uninitialized variable issues in pass6.c and dir.c (PR#30411 and PR#30394, respectively).
2005-06-08 23:09:55 +04:00
extend_ifile(fs);
Be more efficient with the hash tables for the buffer and vnode caches. Note that roll-forward can add more inodes to the filesystem; don't overflow the tables but reallocate them.
2005-04-12 03:19:24 +04:00
}
Initial checkin of fsck_lfs. This version cannot do any repair (-p flag does nothing, and one of -p or -n is required) but can be useful as a diagnostic tool.
1999-03-18 05:02:18 +03:00
}