pcfs/fsck/clusters.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1999,2000 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * fsck_pcfs -- routines for manipulating clusters.
 */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <libintl.h>
#include <errno.h>
#include <sys/dktp/fdisk.h>
#include <sys/fs/pc_fs.h>
#include <sys/fs/pc_dir.h>
#include <sys/fs/pc_label.h>
#include "pcfs_common.h"
#include "fsck_pcfs.h"

extern  ClusterContents TheRootDir;
extern  off64_t     FirstClusterOffset;
extern  off64_t     PartitionOffset;
extern  int32_t     BytesPerCluster;
extern  int32_t     TotalClusters;
extern  int32_t     LastCluster;
extern  int32_t     RootDirSize;
extern  int32_t     FATSize;
extern  bpb_t       TheBIOSParameterBlock;
extern  short       FATEntrySize;
extern  int     RootDirModified;
extern  int     OkayToRelink;
extern  int     ReadOnly;
extern  int     IsFAT32;
extern  int     Verbose;

static  struct pcdir    BlankPCDIR;
static  CachedCluster   *ClusterCache;
static  ClusterInfo **InUse;
static  int32_t     ReservedClusterCount;
static  int32_t     AllocedClusterCount;
static  int32_t     FreeClusterCount;
static  int32_t     BadClusterCount;

/*
 * Internal statistics
 */
static  int32_t     CachedClusterCount;

int32_t HiddenClusterCount;
int32_t FileClusterCount;
int32_t DirClusterCount;
int32_t HiddenFileCount;
int32_t FileCount;
int32_t DirCount;

static int32_t orphanSizeLookup(int32_t clusterNum);

static void
freeNameInfo(int32_t clusterNum)
{
    /* silent failure for bogus clusters */
    if (clusterNum < FIRST_CLUSTER || clusterNum > LastCluster)
        return;
    if (InUse[clusterNum - FIRST_CLUSTER]->path != NULL) {
        if (InUse[clusterNum - FIRST_CLUSTER]->path->references > 1) {
            InUse[clusterNum - FIRST_CLUSTER]->path->references--;
        } else {
            free(InUse[clusterNum - FIRST_CLUSTER]->path->fullName);
            free(InUse[clusterNum - FIRST_CLUSTER]->path);
        }
        InUse[clusterNum - FIRST_CLUSTER]->path = NULL;
    }
}

static void
printOrphanPath(int32_t clusterNum)
{
    /* silent failure for bogus clusters */
    if (clusterNum < FIRST_CLUSTER || clusterNum > LastCluster)
        return;
    if (InUse[clusterNum - FIRST_CLUSTER]->path != NULL) {
        (void) printf(gettext("\nOrphaned allocation units originally "
            "allocated to:\n"));
        (void) printf("%s\n",
            InUse[clusterNum - FIRST_CLUSTER]->path->fullName);
        freeNameInfo(clusterNum);
    } else {
        (void) printf(gettext("\nOrphaned allocation units originally "
            "allocated to an unknown file or directory:\n"));
        (void) printf(gettext("Orphaned chain begins with allocation "
            "unit %d.\n"), clusterNum);
    }
}

static void
printOrphanSize(int32_t clusterNum)
{
    int32_t size = orphanSizeLookup(clusterNum);

    if (size > 0) {
        (void) printf(gettext("%d bytes in the orphaned chain of "
            "allocation units.\n"), size);
        if (Verbose) {
            (void) printf(gettext("[Starting at allocation "
                "unit %d]\n"), clusterNum);
        }
    }
}

static void
printOrphanInfo(int32_t clusterNum)
{
    printOrphanPath(clusterNum);
    printOrphanSize(clusterNum);
}

static int
askAboutFreeing(int32_t clusterNum)
{
    /*
     * If it is not OkayToRelink, we haven't already printed the size
     * of the orphaned chain.
     */
    if (!OkayToRelink)
        printOrphanInfo(clusterNum);
    /*
     *  If we are in preen mode, preenBail won't return.
     */
    preenBail("Need user confirmation to free orphaned chain.\n");

    (void) printf(
        gettext("Free the allocation units in the orphaned chain ? "
        "(y/n) "));
    return (yes());
}

static int
askAboutRelink(int32_t clusterNum)
{
    /*
     * Display the size of the chain for the user to consider.
     */
    printOrphanInfo(clusterNum);
    /*
     *  If we are in preen mode, preenBail won't return.
     */
    preenBail("Need user confirmation to re-link orphaned chain.\n");

    (void) printf(gettext("Re-link orphaned chain into file system ? "
        "(y/n) "));

    return (yes());
}

static int
isHidden(int32_t clusterNum)
{
    /* silent failure for bogus clusters */
    if (clusterNum < FIRST_CLUSTER || clusterNum > LastCluster)
        return (0);

    if (InUse[clusterNum - FIRST_CLUSTER] == NULL)
        return (0);

    return (InUse[clusterNum - FIRST_CLUSTER]->flags & CLINFO_HIDDEN);
}

static int
isInUse(int32_t clusterNum)
{
    /* silent failure for bogus clusters */
    if (clusterNum < FIRST_CLUSTER || clusterNum > LastCluster)
        return (0);

    return ((InUse[clusterNum - FIRST_CLUSTER] != NULL) &&
        (InUse[clusterNum - FIRST_CLUSTER]->dirent != NULL));
}

/*
 *  Caller's may request that we cache the data from a readCluster.
 *  The xxxClusterxxxCachexxx routines handle looking for cached data
 *  or initially caching the data.
 *
 *  XXX - facilitate releasing cached data for low memory situations.
 */
static CachedCluster *
findClusterCacheEntry(int32_t clusterNum)
{
    CachedCluster *loop = ClusterCache;

    while (loop != NULL) {
        if (loop->clusterNum == clusterNum)
            return (loop);
        loop = loop->next;
    }
    return (NULL);
}

static uchar_t *
findClusterDataInTheCache(int32_t clusterNum)
{
    CachedCluster *loop = ClusterCache;

    while (loop) {
        if (loop->clusterNum == clusterNum)
            return (loop->clusterData.bytes);
        loop = loop->next;
    }
    return (NULL);
}

static uchar_t *
addToCache(int32_t clusterNum, uchar_t *buf, int32_t *datasize)
{
    CachedCluster *new;
    uchar_t *cp;

    if ((new = (CachedCluster *)malloc(sizeof (CachedCluster))) == NULL) {
        perror(gettext("No memory for cached cluster info"));
        return (buf);
    }
    new->clusterNum = clusterNum;
    new->modified = 0;

    if ((cp = (uchar_t *)calloc(1, BytesPerCluster)) == NULL) {
        perror(gettext("No memory for cached copy of cluster"));
        free(new);
        return (buf);
    }
    (void) memcpy(cp, buf, *datasize);
    new->clusterData.bytes = cp;

    if (Verbose) {
        (void) fprintf(stderr,
            gettext("Allocation unit %d cached.\n"), clusterNum);
    }
    if (ClusterCache == NULL) {
        ClusterCache = new;
        new->next = NULL;
    } else if (new->clusterNum < ClusterCache->clusterNum) {
        new->next = ClusterCache;
        ClusterCache = new;
    } else {
        CachedCluster *loop = ClusterCache;
        CachedCluster *trailer = NULL;

        while (loop && new->clusterNum > loop->clusterNum) {
            trailer = loop;
            loop = loop->next;
        }
        trailer->next = new;
        if (loop) {
            new->next = loop;
        } else {
            new->next = NULL;
        }
    }
    CachedClusterCount++;
    return (new->clusterData.bytes);
}

static int
seekCluster(int fd, int32_t clusterNum)
{
    off64_t seekto;
    int saveError;

    seekto = FirstClusterOffset +
        ((off64_t)clusterNum - FIRST_CLUSTER) * BytesPerCluster;
    if (lseek64(fd, seekto, SEEK_SET) != seekto) {
        saveError = errno;
        (void) fprintf(stderr,
            gettext("Seek to Allocation unit #%d failed: "),
            clusterNum);
        (void) fprintf(stderr, strerror(saveError));
        (void) fprintf(stderr, "\n");
        return (0);
    }
    return (1);
}

/*
 *  getcluster
 *  Get cluster bytes off the disk.  We always read those bytes into
 *  the same static buffer.  If the caller wants his own copy of the
 *  data he'll have to make his own copy.  We'll return all the data
 *  read, even if it's short of a full cluster.  This is for future use
 *  when we might want to relocate any salvagable data from bad clusters.
 */
static int
getCluster(int fd, int32_t clusterNum, uchar_t **data, int32_t *datasize)
{
    static uchar_t *clusterBuffer = NULL;
    int saveError;
    int try;

    *datasize = 0;
    *data = NULL;

    if (clusterNum < FIRST_CLUSTER || clusterNum > LastCluster)
        return (RDCLUST_BADINPUT);

    if (clusterBuffer == NULL &&
        (clusterBuffer = (uchar_t *)malloc(BytesPerCluster)) == NULL) {
        perror(gettext("No memory for a cluster data buffer"));
        return (RDCLUST_MEMERR);
    }

    for (try = 0; try < RDCLUST_MAX_RETRY; try++) {
        if (!seekCluster(fd, clusterNum))
            return (RDCLUST_FAIL);
        if ((*datasize = read(fd, clusterBuffer, BytesPerCluster)) ==
            BytesPerCluster) {
            *data = clusterBuffer;
            return (RDCLUST_GOOD);
        }
    }
    if (*datasize >= 0) {
        *data = clusterBuffer;
        (void) fprintf(stderr,
            gettext("Short read of allocation unit #%d\n"), clusterNum);
    } else {
        saveError = errno;
        (void) fprintf(stderr, "Allocation unit %d:", clusterNum);
        (void) fprintf(stderr, strerror(saveError));
        (void) fprintf(stderr, "\n");
    }
    return (RDCLUST_FAIL);
}

static void
writeCachedCluster(int fd, CachedCluster *clustInfo)
{
    ssize_t bytesWritten;

    if (ReadOnly)
        return;

    if (Verbose)
        (void) fprintf(stderr,
            gettext("Allocation unit %d modified.\n"),
            clustInfo->clusterNum);

    if (seekCluster(fd, clustInfo->clusterNum) == NULL)
        return;

    if ((bytesWritten = write(fd, clustInfo->clusterData.bytes,
        BytesPerCluster)) != BytesPerCluster) {
        if (bytesWritten < 0) {
            perror(gettext("Failed to write modified "
                "allocation unit"));
        } else {
            (void) fprintf(stderr,
                gettext("Short write of allocation unit %d\n"),
                clustInfo->clusterNum);
        }
        (void) close(fd);
        exit(13);
    }
}

/*
 * It's cheaper to allocate a lot at a time; malloc overhead pushes
 * you over the brink much more quickly if you don't.
 * This numbers seems to be a fair trade-off between reduced malloc overhead
 * and additional overhead by over-allocating.
 */

#define CHUNKSIZE   1024

static ClusterInfo *pool;

static ClusterInfo *
newClusterInfo(void)
{

    ClusterInfo *ret;

    if (pool == NULL) {
        int i;

        pool = (ClusterInfo *)malloc(sizeof (ClusterInfo) * CHUNKSIZE);

        if (pool == NULL) {
            perror(
                gettext("Out of memory for cluster information"));
            exit(9);
        }

        for (i = 0; i < CHUNKSIZE - 1; i++)
            pool[i].nextfree = &pool[i+1];

        pool[CHUNKSIZE-1].nextfree = NULL;
    }
    ret = pool;
    pool = pool->nextfree;

    memset(ret, 0, sizeof (*ret));

    return (ret);
}

/* Should be called with verified arguments */

static ClusterInfo *
cloneClusterInfo(int32_t clusterNum)
{
    ClusterInfo *cl = InUse[clusterNum - FIRST_CLUSTER];

    if (cl->refcnt > 1) {
        ClusterInfo *newCl = newClusterInfo();
        cl->refcnt--;
        *newCl = *cl;
        newCl->refcnt = 1;
        if (newCl->path)
            newCl->path->references++;
        InUse[clusterNum - FIRST_CLUSTER] = newCl;
    }
    return (InUse[clusterNum - FIRST_CLUSTER]);
}

static void
updateFlags(int32_t clusterNum, int newflags)
{
    ClusterInfo *cl = InUse[clusterNum - FIRST_CLUSTER];

    if (cl->flags != newflags && cl->refcnt > 1)
        cl = cloneClusterInfo(clusterNum);

    cl->flags = newflags;
}

static void
freeClusterInfo(ClusterInfo *old)
{
    if (--old->refcnt <= 0) {
        if (old->path && --old->path->references <= 0) {
            free(old->path->fullName);
            free(old->path);
        }
        old->nextfree = pool;
        pool = old;
    }
}

/*
 * Allocate entries in our sparse array of cluster information.
 * Returns non-zero if the structure already has been allocated
 * (for those keeping score at home).
 *
 * The template parameter, if non-NULL, is used to facilitate sharing
 * the ClusterInfo nodes for the clusters belonging to the same file.
 * The first call to allocInUse for a new file should have *template
 * set to 0; on return, *template then points to the newly allocated
 * ClusterInfo.  Second and further calls keep the same value
 * in *template and that ClusterInfo ndoe is then used for all
 * entries in the file.  Code that modifies the ClusterInfo nodes
 * should take care proper sharing semantics are maintained (i.e.,
 * copy-on-write using cloneClusterInfo())
 *
 * The ClusterInfo used in the template is guaranted to be in use in
 * at least one other cluster as we never return a value if we didn't
 * set it first.  So we can overwrite it without the possibility of a leak.
 */
static int
allocInUse(int32_t clusterNum, ClusterInfo **template)
{
    ClusterInfo *newCl;

    if (InUse[clusterNum - FIRST_CLUSTER] != NULL)
        return (CLINFO_PREVIOUSLY_ALLOCED);

    if (template != NULL && *template != NULL)
        newCl = *template;
    else {
        newCl = newClusterInfo();
        if (template)
            *template = newCl;
    }

    InUse[clusterNum - FIRST_CLUSTER] = newCl;
    newCl->refcnt++;

    return (CLINFO_NEWLY_ALLOCED);
}

static void
markFree(int32_t clusterNum)
{
    /* silent failure for bogus clusters */
    if (clusterNum < FIRST_CLUSTER || clusterNum > LastCluster)
        return;

    if (InUse[clusterNum - FIRST_CLUSTER]) {
        if (InUse[clusterNum - FIRST_CLUSTER]->saved)
            free(InUse[clusterNum - FIRST_CLUSTER]->saved);
        freeClusterInfo(InUse[clusterNum - FIRST_CLUSTER]);
        InUse[clusterNum - FIRST_CLUSTER] = NULL;
    }
}

static void
markOrphan(int fd, int32_t clusterNum, struct pcdir *dp)
{
    /* silent failure for bogus clusters */
    if (clusterNum < FIRST_CLUSTER || clusterNum > LastCluster)
        return;

    (void) markInUse(fd, clusterNum, dp, NULL, 0, VISIBLE, NULL);
    if (InUse[clusterNum - FIRST_CLUSTER] != NULL)
        updateFlags(clusterNum,
            InUse[clusterNum - FIRST_CLUSTER]->flags | CLINFO_ORPHAN);
}

static void
markBad(int32_t clusterNum, uchar_t *recovered, int32_t recoveredLen)
{
    /* silent failure for bogus clusters */
    if (clusterNum < FIRST_CLUSTER || clusterNum > LastCluster)
        return;

    (void) allocInUse(clusterNum, NULL);

    if (recoveredLen) {
        (void) cloneClusterInfo(clusterNum);
        InUse[clusterNum - FIRST_CLUSTER]->saved = recovered;
    }
    updateFlags(clusterNum,
        InUse[clusterNum - FIRST_CLUSTER]->flags | CLINFO_BAD);

    BadClusterCount++;
    if (Verbose)
        (void) fprintf(stderr,
            gettext("Allocation unit %d marked bad.\n"), clusterNum);
}

static void
clearOrphan(int32_t c)
{
    /* silent failure for bogus clusters */
    if (c < FIRST_CLUSTER || c > LastCluster)
        return;
    if (InUse[c - FIRST_CLUSTER] != NULL)
        updateFlags(c,
            InUse[c - FIRST_CLUSTER]->flags & ~CLINFO_ORPHAN);
}

static void
clearInUse(int32_t c)
{
    ClusterInfo **clp;

    /* silent failure for bogus clusters */
    if (c < FIRST_CLUSTER || c > LastCluster)
        return;

    clp = &InUse[c - FIRST_CLUSTER];
    if (*clp != NULL) {
        freeClusterInfo(*clp);
        *clp = NULL;
    }
}

static void
clearAllClusters_InUse()
{
    int32_t cc;
    for (cc = FIRST_CLUSTER; cc < LastCluster; cc++) {
        clearInUse(cc);
    }
}

static void
makeUseTable(void)
{
    if (InUse != NULL) {
        clearAllClusters_InUse();
        return;
    }
    if ((InUse = (ClusterInfo **)
        calloc(TotalClusters, sizeof (ClusterInfo *))) == NULL) {
        perror(gettext("No memory for internal table"));
        exit(9);
    }
}

static void
countClusters(void)
{
    int32_t c;

    BadClusterCount = HiddenClusterCount =
        AllocedClusterCount = FreeClusterCount = 0;

    for (c = FIRST_CLUSTER; c < LastCluster; c++) {
        if (badInFAT(c)) {
            BadClusterCount++;
        } else if (isMarkedBad(c)) {
            /*
             * This catches the bad sectors found
             * during thorough verify that have never been
             * allocated to a file.  Without this check, we
             * count these guys as free.
             */
            BadClusterCount++;
            markBadInFAT(c);
        } else if (isHidden(c)) {
            HiddenClusterCount++;
        } else if (isInUse(c)) {
            AllocedClusterCount++;
        } else {
            FreeClusterCount++;
        }
    }
}

/*
 * summarizeFAT
 *  Mark orphans without directory entries as allocated.
 *  XXX - these chains should be reclaimed!
 *  XXX - merge this routine with countClusters (same loop, duh.)
 */
static void
summarizeFAT(int fd)
{
    int32_t c;
    ClusterInfo *tmpl = NULL;

    for (c = FIRST_CLUSTER; c < LastCluster; c++) {
        if (!freeInFAT(c) && !badInFAT(c) && !reservedInFAT(c) &&
            !isInUse(c)) {
            (void) markInUse(fd, c, &BlankPCDIR, NULL, 0, VISIBLE,
                &tmpl);
        }
    }
}

static void
getReadyToSearch(int fd)
{
    getFAT(fd);
    if (!IsFAT32)
        getRootDirectory(fd);
}


static char PathName[MAXPATHLEN];

static void
summarize(int fd, int includeFAT)
{
    struct pcdir *ignorep1, *ignorep2 = NULL;
    int32_t ignore32;
    char ignore;
    int pathlen;

    ReservedClusterCount = 0;
    AllocedClusterCount = 0;
    HiddenClusterCount = 0;
    FileClusterCount = 0;
    FreeClusterCount = 0;
    DirClusterCount = 0;
    BadClusterCount = 0;
    HiddenFileCount = 0;
    FileCount = 0;
    DirCount = 0;
    ignorep1 = ignorep2 = NULL;
    ignore = '\0';

    PathName[0] = '\0';
    pathlen = 0;

    getReadyToSearch(fd);
    /*
     *  Traverse the full meta-data tree to talley what clusters
     * are in use.  The root directory is an area outside of the
     * file space on FAT12 and FAT16 file systems.  On FAT32 file
     * systems, the root directory is in a file area cluster just
     * like any other directory.
     */
    if (!IsFAT32) {
        traverseFromRoot(fd, 0, PCFS_VISIT_SUBDIRS, PCFS_TRAVERSE_ALL,
            ignore, &ignorep1, &ignore32, &ignorep2, PathName,
            &pathlen);
    } else {
        DirCount++;
        traverseDir(fd, TheBIOSParameterBlock.bpb32.root_dir_clust,
            0, PCFS_VISIT_SUBDIRS, PCFS_TRAVERSE_ALL, ignore,
            &ignorep1, &ignore32, &ignorep2, PathName, &pathlen);
    }

    if (includeFAT)
        summarizeFAT(fd);
    countClusters();
}

int
isMarkedBad(int32_t clusterNum)
{
    /* silent failure for bogus clusters */
    if (clusterNum < FIRST_CLUSTER || clusterNum > LastCluster)
        return (0);

    if (InUse[clusterNum - FIRST_CLUSTER] == NULL)
        return (0);

    return (InUse[clusterNum - FIRST_CLUSTER]->flags & CLINFO_BAD);
}

static int
isMarkedOrphan(int32_t clusterNum)
{
    /* silent failure for bogus clusters */
    if (clusterNum < FIRST_CLUSTER || clusterNum > LastCluster)
        return (0);

    if (InUse[clusterNum - FIRST_CLUSTER] == NULL)
        return (0);

    return (InUse[clusterNum - FIRST_CLUSTER]->flags & CLINFO_ORPHAN);
}

static void
orphanChain(int fd, int32_t c, struct pcdir *ndp)
{
    ClusterInfo *tmpl = NULL;

    /* silent failure for bogus clusters */
    if (c < FIRST_CLUSTER || c > LastCluster)
        return;
    clearInUse(c);
    markOrphan(fd, c, ndp);
    c = nextInChain(c);
    while (c != 0) {
        clearInUse(c);
        clearOrphan(c);
        (void) markInUse(fd, c, ndp, NULL, 0, VISIBLE, &tmpl);
        c = nextInChain(c);
    }
}

static int32_t
findAFreeCluster(int32_t startAt)
{
    int32_t look = startAt;

    for (;;) {
        if (freeInFAT(look)) {
            break;
        }
        if (look == LastCluster)
            look = FIRST_CLUSTER;
        else
            look++;
        if (look == startAt)
            break;
    }
    if (look != startAt)
        return (look);
    else
        return (0);
}

static void
setEndOfDirectory(struct pcdir *dp)
{
    dp->pcd_filename[0] = PCD_UNUSED;
}

static void
emergencyEndOfDirectory(int fd, int32_t secondToLast)
{
    ClusterContents dirdata;
    int32_t dirdatasize = 0;

    if (readCluster(fd, secondToLast, &(dirdata.bytes), &dirdatasize,
        RDCLUST_DO_CACHE) != RDCLUST_GOOD) {
        (void) fprintf(stderr,
            gettext("Unable to read allocation unit %d.\n"),
            secondToLast);
        (void) fprintf(stderr,
            gettext("Cannot allocate a new allocation unit to hold an"
            " end-of-directory marker.\nCannot access allocation unit"
            " to overwrite existing directory entry with\nthe marker."
            "  Needed directory truncation has failed.  Giving up.\n"));
        (void) close(fd);
        exit(11);
    }
    setEndOfDirectory(dirdata.dirp);
    markClusterModified(secondToLast);
}

static void
makeNewEndOfDirectory(struct pcdir *entry, int32_t secondToLast,
    int32_t newCluster, ClusterContents *newData)
{
    setEndOfDirectory(newData->dirp);
    markClusterModified(newCluster);
    /*
     *  There are two scenarios.  One is that we truncated the
     *  directory in the very beginning.  The other is that we
     *  truncated it in the middle or at the end.  In the first
     *  scenario, the secondToLast argument is not a valid cluster
     *  (it's zero), and so we actually need to change the start
     *  cluster for the directory to this new start cluster.  In
     *  the second scenario, the secondToLast cluster we received
     *  as an argument needs to be pointed at the new end of
     *  directory.
     */
    if (secondToLast == 0) {
        updateDirEnt_Start(entry, newCluster);
    } else {
        writeFATEntry(secondToLast, newCluster);
    }
    markLastInFAT(newCluster);
}

static void
createNewEndOfDirectory(int fd, struct pcdir *entry, int32_t secondToLast)
{
    ClusterContents dirdata;
    int32_t dirdatasize = 0;
    int32_t freeCluster;

    if (((freeCluster = findAFreeCluster(secondToLast)) != 0)) {
        if (readCluster(fd, freeCluster, &(dirdata.bytes),
            &dirdatasize, RDCLUST_DO_CACHE) == RDCLUST_GOOD) {
            if (Verbose) {
                (void) fprintf(stderr,
                    gettext("Grabbed allocation unit #%d "
                    "for truncated\ndirectory's new end "
                    "of directory.\n"), freeCluster);
            }
            makeNewEndOfDirectory(entry, secondToLast,
                freeCluster, &dirdata);
            return;
        }
    }
    if (secondToLast == 0) {
        if (freeCluster == 0) {
            (void) fprintf(stderr, gettext("File system full.\n"));
        } else {
            (void) fprintf(stderr,
                gettext("Unable to read allocation unit %d.\n"),
                freeCluster);
        }
        (void) fprintf(stderr,
            gettext("Cannot allocate a new allocation unit to hold "
            "an end-of-directory marker.\nNo existing directory "
            "entries can be overwritten with the marker,\n"
            "the only unit allocated to the directory is "
            "inaccessible.\nNeeded directory truncation has failed.  "
            "Giving up.\n"));
        (void) close(fd);
        exit(11);
    }
    emergencyEndOfDirectory(fd, secondToLast);
}

/*
 * truncAtCluster
 *  Given a directory entry and a cluster number, search through
 *  the cluster chain for the entry and make the cluster previous
 *  to the given cluster in the chain the last cluster in the file.
 *  The number of orphaned bytes is returned.  For a chain that's
 *  a directory we need to do some special handling, since we'll be
 *  getting rid of the end of directory notice by truncating.
 */
static int64_t
truncAtCluster(int fd, struct pcdir *entry, int32_t cluster)
{
    uint32_t oldSize, newSize;
    int32_t prev, count, follow;
    int dir = (entry->pcd_attr & PCA_DIR);

    prev = 0; count = 0;
    follow = extractStartCluster(entry);
    while (follow != cluster && follow >= FIRST_CLUSTER &&
        follow <= LastCluster) {
        prev = follow;
        count++;
        follow = nextInChain(follow);
    }
    if (follow != cluster) {
        /*
         *  We didn't find the cluster they wanted to trunc at
         *  anywhere in the entry's chain.  So we'll leave the
         *  entry alone, and return a negative value so they
         *  can know something is wrong.
         */
        return (-1);
    }
    if (Verbose) {
        (void) fprintf(stderr,
            gettext("Chain truncation at unit #%d\n"), cluster);
    }
    if (!dir) {
        oldSize = extractSize(entry);
        newSize = count *
            TheBIOSParameterBlock.bpb.sectors_per_cluster *
            TheBIOSParameterBlock.bpb.bytes_per_sector;
        if (newSize == 0)
            updateDirEnt_Start(entry, 0);
    } else {
        newSize = 0;
    }
    updateDirEnt_Size(entry, newSize);
    if (dir) {
        createNewEndOfDirectory(fd, entry, prev);
    } else if (prev != 0) {
        markLastInFAT(prev);
    }
    if (dir) {
        /*
         * We don't really know what the size of a directory is
         * but it is important for us to know if this truncation
         * results in an orphan with any size.  The value we
         * return from this routine for a normal file is the
         * number of bytes left in the chain.  For a directory
         * we can't be exact, and the caller doesn't really
         * expect us to be.  For a directory the caller only
         * cares if there are zero bytes left or more than
         * zero bytes left.  We'll return 1 to indicate
         * more than zero.
         */
        if ((follow = nextInChain(follow)) != 0)
            return (1);
        else
            return (0);
    }
    /*
     * newSize should always be smaller than the old one, since
     * we are decreasing the number of clusters allocated to the file.
     */
    return ((int64_t)oldSize - (int64_t)newSize);
}

static struct pcdir *
updateOrphanedChainMetadata(int fd, struct pcdir *dp, int32_t endCluster,
    int isBad)
{
    struct pcdir *ndp = NULL;
    int64_t remainder;
    char *newName = NULL;
    int chosenName;
    int dir = (dp->pcd_attr & PCA_DIR);

    /*
     *  If the truncation fails, (which ought not to happen),
     *  there's no need to go any further, we just return
     *  a null value for the new directory entry pointer.
     */
    remainder = truncAtCluster(fd, dp, endCluster);
    if (remainder < 0)
        return (ndp);
    if (!dir && isBad) {
        /*
         *  Subtract out the bad cluster from the remaining size
         *  We always assume the cluster being deleted from the
         *  file is full size, but that might not be the case
         *  for the last cluster of the file, so that is why
         *  we check for negative remainder value.
         */
        remainder -= TheBIOSParameterBlock.bpb.sectors_per_cluster *
            TheBIOSParameterBlock.bpb.bytes_per_sector;
        if (remainder < 0)
            remainder = 0;
    }
    /*
     * Build a new directory entry for the rest of the chain.
     * Later, if the user okays it, we'll link this entry into the
     * root directory.  The new entry will start out as a
     * copy of the truncated entry.
     */
    if ((remainder != 0) &&
        ((newName = nextAvailableCHKName(&chosenName)) != NULL) &&
        ((ndp = newDirEnt(dp)) != NULL)) {
        if (Verbose) {
            if (dir)
                (void) fprintf(stderr,
                    gettext("Orphaned directory chain.\n"));
            else
                (void) fprintf(stderr,
                    gettext("Orphaned chain, %u bytes.\n"),
                    (uint32_t)remainder);
        }
        if (!dir)
            updateDirEnt_Size(ndp, (uint32_t)remainder);
        if (isBad)
            updateDirEnt_Start(ndp, nextInChain(endCluster));
        else
            updateDirEnt_Start(ndp, endCluster);
        updateDirEnt_Name(ndp, newName);
        addEntryToCHKList(chosenName);
    }
    return (ndp);
}

/*
 *  splitChain()
 *
 *  split a cluster allocation chain into two cluster chains
 *  around a given cluster (problemCluster).  This results in two
 *  separate directory entries; the original (dp), and one we hope
 *  to create and return a pointer to to the caller (*newdp).
 *  This second entry is the orphan chain, and it may end up in
 *  the root directory as a FILEnnnn.CHK file.  We also return the
 *  starting cluster of the orphan chain to the caller (*orphanStart).
 */
void
splitChain(int fd, struct pcdir *dp, int32_t problemCluster,
    struct pcdir **newdp, int32_t *orphanStart)
{
    struct pcdir *ndp = NULL;
    int isBad = isMarkedBad(problemCluster);

    ndp = updateOrphanedChainMetadata(fd, dp, problemCluster, isBad);
    *newdp = ndp;
    clearInUse(problemCluster);
    if (isBad) {
        clearOrphan(problemCluster);
        *orphanStart = nextInChain(problemCluster);
        orphanChain(fd, *orphanStart, ndp);
        markBadInFAT(problemCluster);
    } else {
        *orphanStart = problemCluster;
        orphanChain(fd, problemCluster, ndp);
    }
}

/*
 *  freeOrphan
 *
 *  User has requested that an orphaned cluster chain be freed back
 *  into the file area.
 */
static void
freeOrphan(int32_t c)
{
    int32_t n;

    /*
     * Free the directory entry we explicitly created for
     * the orphaned clusters.
     */
    if (InUse[c - FIRST_CLUSTER]->dirent != NULL)
        free(InUse[c - FIRST_CLUSTER]->dirent);
    /*
     * Then mark the clusters themselves as available.
     */
    do {
        n = nextInChain(c);
        markFreeInFAT(c);
        markFree(c);
        c = n;
    } while (c != 0);
}

/*
 *  Rewrite the InUse field for a cluster chain.  Can be used on a partial
 *  chain if provided with a stopAtCluster.
 */
static void
redoInUse(int fd, int32_t c, struct pcdir *ndp, int32_t stopAtCluster)
{
    while (c && c != stopAtCluster) {
        clearInUse(c);
        (void) markInUse(fd, c, ndp, NULL, 0, VISIBLE, NULL);
        c = nextInChain(c);
    }
}

static struct pcdir *
orphanDirEntLookup(int32_t clusterNum)
{
    if (clusterNum < FIRST_CLUSTER || clusterNum > LastCluster)
        return (NULL);

    if (isInUse(clusterNum)) {
        return (InUse[clusterNum - FIRST_CLUSTER]->dirent);
    } else {
        return (NULL);
    }
}

static int32_t
orphanSizeLookup(int32_t clusterNum)
{
    /* silent failure for bogus clusters */
    if (clusterNum < FIRST_CLUSTER || clusterNum > LastCluster)
        return (-1);

    if (isInUse(clusterNum)) {
        return (extractSize(InUse[clusterNum - FIRST_CLUSTER]->dirent));
    } else {
        return (-1);
    }
}

/*
 *  linkOrphan
 *
 *  User has requested that an orphaned cluster chain be brought back
 *  into the file system.  So we have to make a new directory entry
 *  in the root directory and point it at the cluster chain.
 */
static void
linkOrphan(int fd, int32_t start)
{
    struct pcdir *newEnt = NULL;
    struct pcdir *dp;

    if ((dp = orphanDirEntLookup(start)) != NULL) {
        newEnt = addRootDirEnt(fd, dp);
    } else {
        (void) printf(gettext("Re-link of orphaned chain failed."
            "  Allocation units will remain orphaned.\n"));
    }
    /*
     *  A cluster isn't really InUse() unless it is referenced,
     *  so if newEnt is NULL here, we are in effect using markInUse()
     *  to note that the cluster is NOT in use.
     */
    redoInUse(fd, start, newEnt, 0);
}

/*
 *  relinkCreatedOrphans
 *
 *  While marking clusters as bad, we can create orphan cluster
 *  chains.  Since we were the ones doing the marking, we were able to
 *  keep track of the orphans we created.  Now we want to go through
 *  all those chains and either get them back into the file system or
 *  free them depending on the user's input.
 */
static void
relinkCreatedOrphans(int fd)
{
    int32_t c;

    for (c = FIRST_CLUSTER; c < LastCluster; c++) {
        if (isMarkedOrphan(c)) {
            if (OkayToRelink && askAboutRelink(c)) {
                linkOrphan(fd, c);
            } else if (askAboutFreeing(c)) {
                freeOrphan(c);
            }
            clearOrphan(c);
        }
    }
}

/*
 *  relinkFATOrphans
 *
 *  We want to find orphans not represented in the meta-data.
 *  These are chains marked in the FAT as being in use but
 *  not referenced anywhere by any directory entries.
 *  We'll go through the whole FAT and mark the first cluster
 *  in any such chain as an orphan.  Then we can just use
 *  the relinkCreatedOrphans routine to get them back into the
 *  file system or free'ed depending on the user's input.
 */
static void
relinkFATOrphans(int fd)
{
    struct pcdir *ndp = NULL;
    int32_t cc, c, n;
    int32_t bpc, newSize;
    char *newName;
    int chosenName;

    for (c = FIRST_CLUSTER; c < LastCluster; c++) {
        if (freeInFAT(c) || badInFAT(c) ||
            reservedInFAT(c) || isInUse(c))
            continue;
        cc = 1;
        n = c;
        while (n = nextInChain(n))
            cc++;
        bpc = TheBIOSParameterBlock.bpb.sectors_per_cluster *
            TheBIOSParameterBlock.bpb.bytes_per_sector;
        newSize = cc * bpc;
        if (((newName = nextAvailableCHKName(&chosenName)) != NULL) &&
            ((ndp = newDirEnt(NULL)) != NULL)) {
            updateDirEnt_Size(ndp, newSize);
            updateDirEnt_Start(ndp, c);
            updateDirEnt_Name(ndp, newName);
            addEntryToCHKList(chosenName);
        }
        orphanChain(fd, c, ndp);
    }
    relinkCreatedOrphans(fd);
}

static void
relinkOrphans(int fd)
{
    relinkCreatedOrphans(fd);
    relinkFATOrphans(fd);
}

static void
checkForFATLoop(int32_t clusterNum)
{
    int32_t prev = clusterNum;
    int32_t follow;

    if (clusterNum < FIRST_CLUSTER || clusterNum > LastCluster)
        return;

    follow = nextInChain(clusterNum);
    while (follow != clusterNum && follow >= FIRST_CLUSTER &&
        follow <= LastCluster) {
        prev = follow;
        follow = nextInChain(follow);
    }
    if (follow == clusterNum) {
        /*
         * We found a loop.  Eradicate it by changing
         * the last cluster in the loop to be last
         * in the chain instead instead of pointing
         * back to the first cluster.
         */
        markLastInFAT(prev);
    }
}

static void
sharedChainError(int fd, int32_t clusterNum, struct pcdir *badEntry)
{
    /*
     * If we have shared clusters, it is either because the
     * cluster somehow got assigned to multiple files and/or
     * because of a loop in the cluster chain.  In either
     * case we want to truncate the offending file at the
     * cluster of contention.  Then, we will want to run
     * through the remainder of the chain. If we find ourselves
     * back at the top, we will know there is a loop in the
     * FAT we need to remove.
     */
    if (Verbose)
        (void) fprintf(stderr,
            gettext("Truncating chain due to duplicate allocation of "
            "unit %d.\n"), clusterNum);
    /*
     * Note that we don't orphan anything here, because the duplicate
     * part of the chain may be part of another valid chain.
     */
    (void) truncAtCluster(fd, badEntry, clusterNum);
    checkForFATLoop(clusterNum);
}

void
truncChainWithBadCluster(int fd, struct pcdir *dp, int32_t startCluster)
{
    struct pcdir *orphanEntry;
    int32_t orphanStartCluster;
    int32_t c = startCluster;

    while (c != 0) {
        if (isMarkedBad(c)) {
            /*
             *  splitChain() truncates the current guy and
             *  then makes an orphan chain out of the remaining
             *  clusters.  When we come back from the split
             *  we'll want to continue looking for bad clusters
             *  in the orphan chain.
             */
            splitChain(fd, dp, c,
                &orphanEntry, &orphanStartCluster);
            /*
             *  There is a chance that we weren't able or weren't
             *  required to make a directory entry for the
             *  remaining clusters.  In that case we won't go
             *  on, because we couldn't make any more splits
             *  anyway.
             */
            if (orphanEntry == NULL)
                break;
            c = orphanStartCluster;
            dp = orphanEntry;
            continue;
        }
        c = nextInChain(c);
    }
}

int32_t
nextInChain(int32_t currentCluster)
{
    int32_t nextCluster;

    /* silent failure for bogus clusters */
    if (currentCluster < FIRST_CLUSTER || currentCluster > LastCluster)
        return (0);

    /*
     * Look up FAT entry of next link in cluster chain,
     * if this one is the last one return 0 as the next link.
     */
    nextCluster = readFATEntry(currentCluster);
    if (nextCluster < FIRST_CLUSTER || nextCluster > LastCluster)
        return (0);

    return (nextCluster);
}

/*
 * findImpactedCluster
 *
 *  Called when someone modifies what they believe might be a cached
 *  cluster entry, but when they only have a directory entry pointer
 *  and not the cluster number.  We have to go dig up what cluster
 *  they are modifying.
 */
int32_t
findImpactedCluster(struct pcdir *modified)
{
    CachedCluster *loop;
    /*
     * Check to see if it's in the root directory first
     */
    if (!IsFAT32 && ((uchar_t *)modified >= TheRootDir.bytes) &&
        ((uchar_t *)modified < TheRootDir.bytes + RootDirSize))
        return (FAKE_ROOTDIR_CLUST);

    loop = ClusterCache;
    while (loop) {
        if (((uchar_t *)modified >= loop->clusterData.bytes) &&
            ((uchar_t *)modified <
            (loop->clusterData.bytes + BytesPerCluster))) {
            return (loop->clusterNum);
        }
        loop = loop->next;
    }
    /*
     *  Guess it wasn't cached after all...
     */
    return (0);
}

void
writeClusterMods(int fd)
{
    CachedCluster *loop = ClusterCache;

    while (loop) {
        if (loop->modified)
            writeCachedCluster(fd, loop);
        loop = loop->next;
    }
}

void
squirrelPath(struct nameinfo *pathInfo, int32_t clusterNum)
{
    /* silent failure for bogus clusters */
    if (clusterNum < FIRST_CLUSTER || clusterNum > LastCluster)
        return;
    if (InUse[clusterNum - FIRST_CLUSTER] == NULL)
        return;
    InUse[clusterNum - FIRST_CLUSTER]->path = pathInfo;
}

int
markInUse(int fd, int32_t clusterNum, struct pcdir *referencer, struct
    pcdir *longRef, int32_t longStartCluster, int isHiddenFile,
    ClusterInfo **template)
{
    int alreadyMarked;
    ClusterInfo *cl;

    /* silent failure for bogus clusters */
    if (clusterNum < FIRST_CLUSTER || clusterNum > LastCluster)
        return (CLINFO_NEWLY_ALLOCED);

    alreadyMarked = allocInUse(clusterNum, template);
    if ((alreadyMarked == CLINFO_PREVIOUSLY_ALLOCED) &&
        (isInUse(clusterNum))) {
        sharedChainError(fd, clusterNum, referencer);
        return (CLINFO_PREVIOUSLY_ALLOCED);
    }
    cl = InUse[clusterNum - FIRST_CLUSTER];
    /*
     * If Cl is newly allocated (refcnt <= 1) we must fill in the fields.
     * If Cl has different fields, we must clone it.
     */

    if (cl->refcnt <= 1 || cl->dirent != referencer ||
        cl->longent != longRef ||
        cl->longEntStartClust != longStartCluster) {
        if (cl->refcnt > 1)
            cl = cloneClusterInfo(clusterNum);
        cl->dirent = referencer;
        cl->longent = longRef;
        cl->longEntStartClust = longStartCluster;
        if (isHiddenFile)
            cl->flags |= CLINFO_HIDDEN;

        /*
         * Return cl as the template to use for other clusters in
         * this file
         */
        if (template)
            *template = cl;
    }
    return (CLINFO_NEWLY_ALLOCED);
}

void
markClusterModified(int32_t clusterNum)
{
    CachedCluster *c;

    if (clusterNum == FAKE_ROOTDIR_CLUST) {
        RootDirModified = 1;
        return;
    }

    /* silent failure for bogus clusters */
    if (clusterNum < FIRST_CLUSTER || clusterNum > LastCluster)
        return;

    if (c = findClusterCacheEntry(clusterNum)) {
        c->modified = 1;
    } else {
        (void) fprintf(stderr,
            gettext("Unexpected internal error: "
            "Missing cache entry [%d]\n"), clusterNum);
        exit(10);
    }
}

/*
 *  readCluster
 *  caller wants to read cluster clusterNum.  We should return
 *  a pointer to the read data in "data", and fill in the number
 *  of bytes read in "datasize".  If shouldCache is non-zero
 *  we should allocate cache space to the cluster, otherwise we
 *  just return a pointer to a buffer we re-use whenever cacheing
 *  is not requested.
 */
int
readCluster(int fd, int32_t clusterNum, uchar_t **data, int32_t *datasize,
    int shouldCache)
{
    uchar_t *newBuf;
    int rv;

    *data = NULL;
    if ((*data = findClusterDataInTheCache(clusterNum)) != NULL) {
        *datasize = BytesPerCluster;
        return (RDCLUST_GOOD);
    }

    rv = getCluster(fd, clusterNum, &newBuf, datasize);
    if (rv != RDCLUST_GOOD)
        return (rv);

    /*
     * Caller requested we NOT cache the data from this read.
     * So, we just return a pointer to the common data buffer.
     */
    if (shouldCache == 0) {
        *data = newBuf;
        return (rv);
    }

    /*
     * Caller requested we cache the data from this read.
     * So, if we have some data, add it to the cache by
     * copying it out of the common buffer into new storage.
     */
    if (*datasize > 0)
        *data = addToCache(clusterNum, newBuf, datasize);
    return (rv);
}

void
findBadClusters(int fd)
{
    int32_t clusterCount;
    int32_t datasize;
    uchar_t *data;

    BadClusterCount = 0;
    makeUseTable();
    (void) printf(gettext("** Scanning allocation units\n"));
    for (clusterCount = FIRST_CLUSTER;
        clusterCount < LastCluster; clusterCount++) {
        if (readCluster(fd, clusterCount,
            &data, &datasize, RDCLUST_DONT_CACHE) < 0) {
            if (Verbose)
                (void) fprintf(stderr,
                gettext("\nUnreadable allocation unit %d.\n"),
                clusterCount);
            markBad(clusterCount, data, datasize);
        }
        /*
         *  Progress meter, display a '.' for every 1000 clusters
         *  processed.  We don't want to display this when
         *  we are in verbose mode; verbose mode progress is
         *  shown by displaying each file name as it is found.
         */
        if (!Verbose && clusterCount % 1000 == 0)
            (void) printf(".");
    }
    (void) printf(gettext("..done\n"));
}

void
scanAndFixMetadata(int fd)
{
    /*
     * First we initialize a few things.
     */
    makeUseTable();
    getReadyToSearch(fd);
    createCHKNameList(fd);

    /*
     * Make initial scan, taking into account any effect that
     * the bad clusters we may have already discovered have
     * on meta-data.  We may break up some cluster chains
     * during this period.  The relinkCreatedOrphans() call
     * will then give the user the chance to recover stuff
     * we've created.
     */
    (void) printf(gettext("** Scanning file system meta-data\n"));
    summarize(fd, NO_FAT_IN_SUMMARY);
    if (Verbose)
        printSummary(stderr);
    (void) printf(gettext("** Correcting any meta-data discrepancies\n"));
    relinkCreatedOrphans(fd);

    /*
     * Clear our usage table and go back over everything, this
     * time including looking for clusters floating free in the FAT.
     * This may include clusters the user chose to free during the
     * relink phase.
     */
    makeUseTable();
    summarize(fd, INCLUDE_FAT_IN_SUMMARY);
    relinkOrphans(fd);
}

void
printSummary(FILE *outDest)
{
    (void) fprintf(outDest,
        gettext("%llu bytes.\n"),
        (uint64_t)
        TotalClusters * TheBIOSParameterBlock.bpb.sectors_per_cluster *
        TheBIOSParameterBlock.bpb.bytes_per_sector);
    (void) fprintf(outDest,
        gettext("%llu bytes in bad sectors.\n"),
        (uint64_t)
        BadClusterCount * TheBIOSParameterBlock.bpb.sectors_per_cluster *
        TheBIOSParameterBlock.bpb.bytes_per_sector);
    (void) fprintf(outDest,
        gettext("%llu bytes in %d directories.\n"),
        (uint64_t)
        DirClusterCount * TheBIOSParameterBlock.bpb.sectors_per_cluster *
        TheBIOSParameterBlock.bpb.bytes_per_sector, DirCount);
    if (HiddenClusterCount) {
        (void) fprintf(outDest,
            gettext("%llu bytes in %d hidden files.\n"),
            (uint64_t)HiddenClusterCount *
            TheBIOSParameterBlock.bpb.sectors_per_cluster *
            TheBIOSParameterBlock.bpb.bytes_per_sector,
            HiddenFileCount);
    }
    (void) fprintf(outDest,
        gettext("%llu bytes in %d files.\n"),
        (uint64_t)
        FileClusterCount * TheBIOSParameterBlock.bpb.sectors_per_cluster *
        TheBIOSParameterBlock.bpb.bytes_per_sector, FileCount);
    (void) fprintf(outDest,
        gettext("%llu bytes free.\n"), (uint64_t)FreeClusterCount *
        TheBIOSParameterBlock.bpb.sectors_per_cluster *
        TheBIOSParameterBlock.bpb.bytes_per_sector);
    (void) fprintf(outDest,
        gettext("%d bytes per allocation unit.\n"),
        TheBIOSParameterBlock.bpb.sectors_per_cluster *
        TheBIOSParameterBlock.bpb.bytes_per_sector);
    (void) fprintf(outDest,
        gettext("%d total allocation units.\n"), TotalClusters);
    if (ReservedClusterCount)
        (void) fprintf(outDest, gettext("%d reserved allocation units.\n"),
        ReservedClusterCount);
    (void) fprintf(outDest,
        gettext("%d available allocation units.\n"), FreeClusterCount);
}