MODIO_1 commit. This change (including documentation) implements a more

[thirdparty/squid.git] / src / fs / diskd / store_dir_diskd.cc

/*
 * $Id: store_dir_diskd.cc,v 1.1 2000/05/03 17:15:47 adrian Exp $
 *
 * DEBUG: section 47    Store Directory Routines
 * AUTHOR: Duane Wessels
 *
 * SQUID Internet Object Cache  http://squid.nlanr.net/Squid/
 * ----------------------------------------------------------
 *
 *  Squid is the result of efforts by numerous individuals from the
 *  Internet community.  Development is led by Duane Wessels of the
 *  National Laboratory for Applied Network Research and funded by the
 *  National Science Foundation.  Squid is Copyrighted (C) 1998 by
 *  Duane Wessels and the University of California San Diego.  Please
 *  see the COPYRIGHT file for full details.  Squid incorporates
 *  software developed and/or copyrighted by other sources.  Please see
 *  the CREDITS file for full details.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *  
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
 *
 */

#include "squid.h"
#if HAVE_STATVFS
#if HAVE_SYS_STATVFS_H
#include <sys/statvfs.h>
#endif
#endif

#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/shm.h>

#include "store_diskd.h"

#define DefaultLevelOneDirs     16
#define DefaultLevelTwoDirs     256
#define STORE_META_BDISKDZ 4096

#ifndef SQUID_PREFIX
#error "SQUID_PREFIX needs defining!"
#endif

diskd_stats_t diskd_stats;

typedef struct _RebuildState RebuildState;
struct _RebuildState {
    SwapDir *sd;
    int n_read;
    FILE *log;
    int speed;
    int curlvl1;
    int curlvl2;
    struct {
        unsigned int need_to_validate:1;
        unsigned int clean:1;
        unsigned int init:1;
    } flags;
    int done;
    int in_dir;
    int fn;
    struct dirent *entry;
    DIR *td;
    char fullpath[SQUID_MAXPATHLEN];
    char fullfilename[SQUID_MAXPATHLEN];
    struct _store_rebuild_data counts;
};

static int n_diskd_dirs = 0;
static int *diskd_dir_index = NULL;
MemPool * diskd_state_pool = NULL;
static int diskd_initialised = 0;

static char *storeDiskdDirSwapSubDir(SwapDir *, int subdirn);
static int storeDiskdDirCreateDirectory(const char *path, int);
static int storeDiskdDirVerifyCacheDirs(SwapDir *);
static int storeDiskdDirVerifyDirectory(const char *path);
static void storeDiskdDirCreateSwapSubDirs(SwapDir *);
static char *storeDiskdDirSwapLogFile(SwapDir *, const char *);
static EVH storeDiskdDirRebuildFromDirectory;
static EVH storeDiskdDirRebuildFromSwapLog;
static int storeDiskdDirGetNextFile(RebuildState *, int *sfileno, int *size);
static StoreEntry *storeDiskdDirAddDiskRestore(SwapDir *SD, const cache_key * key,
    int file_number,
    size_t swap_file_sz,
    time_t expires,
    time_t timestamp,
    time_t lastref,
    time_t lastmod,
    u_num32 refcount,
    u_short flags,
    int clean);
static void storeDiskdDirRebuild(SwapDir * sd);
static void storeDiskdDirCloseTmpSwapLog(SwapDir * sd);
static FILE *storeDiskdDirOpenTmpSwapLog(SwapDir *, int *, int *);
static STLOGOPEN storeDiskdDirOpenSwapLog;
static STINIT storeDiskdDirInit;
static STFREE storeDiskdDirFree;
static STLOGCLEANOPEN storeDiskdDirWriteCleanOpen;
static void storeDiskdDirWriteCleanClose(SwapDir * sd);
static STLOGCLEANWRITE storeDiskdDirWriteCleanEntry;
static STLOGCLOSE storeDiskdDirCloseSwapLog;
static STLOGWRITE storeDiskdDirSwapLog;
static STNEWFS storeDiskdDirNewfs;
static STDUMP storeDiskdDirDump;
static STMAINTAINFS storeDiskdDirMaintain;
static STCHECKOBJ storeDiskdDirCheckObj;
static STREFOBJ storeDiskdDirRefObj;
static STUNREFOBJ storeDiskdDirUnrefObj;
static QS rev_int_sort;
static int storeDiskdDirClean(int swap_index);
static EVH storeDiskdDirCleanEvent;
static int storeDiskdDirIs(SwapDir * sd);
static int storeDiskdFilenoBelongsHere(int fn, int F0, int F1, int F2);
static int storeDiskdCleanupDoubleCheck(SwapDir *, StoreEntry *);
static void storeDiskdDirStats(SwapDir *, StoreEntry *);
static void storeDiskdDirInitBitmap(SwapDir *);
static int storeDiskdDirValidFileno(SwapDir *, sfileno);
static int storeDiskdDirCheckExpired(SwapDir *, StoreEntry *);
#if !HEAP_REPLACEMENT
static time_t storeDiskdDirExpiredReferenceAge(SwapDir *);
#endif
static void storeDiskdStats(StoreEntry * sentry);
static void storeDiskdDirSync(SwapDir *);
static void storeDiskdDirCallback(SwapDir *);


/*
 * These functions were ripped straight out of the heart of store_dir.c.
 * They assume that the given filenum is on a diskd partiton, which may or
 * may not be true.. 
 * XXX this evilness should be tidied up at a later date!
 */

int
storeDiskdDirMapBitTest(SwapDir *SD, int fn)
{
    sfileno filn = fn;
    diskdinfo_t *diskdinfo;
    diskdinfo = (diskdinfo_t *)SD->fsdata;
    return file_map_bit_test(diskdinfo->map, filn);
}
 
void
storeDiskdDirMapBitSet(SwapDir *SD, int fn)
{  
    sfileno filn = fn;
    diskdinfo_t *diskdinfo;
    diskdinfo = (diskdinfo_t *)SD->fsdata;
    file_map_bit_set(diskdinfo->map, filn);
}
 
void
storeDiskdDirMapBitReset(SwapDir *SD, int fn)
{ 
    sfileno filn = fn;
    diskdinfo_t *diskdinfo;
    diskdinfo = (diskdinfo_t *)SD->fsdata;
    file_map_bit_reset(diskdinfo->map, filn);
}

int
storeDiskdDirMapBitAllocate(SwapDir *SD)
{
    diskdinfo_t *diskdinfo = (diskdinfo_t *)SD->fsdata;
    int fn;
    fn = file_map_allocate(diskdinfo->map, diskdinfo->suggest);
    file_map_bit_set(diskdinfo->map, fn);
    diskdinfo->suggest = fn + 1;
    return fn;
}
    
/*
 * Initialise the diskd bitmap
 *
 * If there already is a bitmap, and the numobjects is larger than currently
 * configured, we allocate a new bitmap and 'grow' the old one into it.
 */
static void
storeDiskdDirInitBitmap(SwapDir *sd)
{
    diskdinfo_t *diskdinfo = (diskdinfo_t *)sd->fsdata;

    if (diskdinfo->map == NULL) {
        /* First time */
        diskdinfo->map = file_map_create();
    } else if (diskdinfo->map->max_n_files) {
        /* it grew, need to expand */
        /* XXX We don't need it anymore .. */
    }
    /* else it shrunk, and we leave the old one in place */
}

static char *
storeDiskdDirSwapSubDir(SwapDir * sd, int subdirn)
{
    diskdinfo_t *diskdinfo = (diskdinfo_t *)sd->fsdata;

    LOCAL_ARRAY(char, fullfilename, SQUID_MAXPATHLEN);
    assert(0 <= subdirn && subdirn < diskdinfo->l1);
    snprintf(fullfilename, SQUID_MAXPATHLEN, "%s/%02X", sd->path, subdirn);
    return fullfilename;
}

static int
storeDiskdDirCreateDirectory(const char *path, int should_exist)
{
    int created = 0;
    struct stat st;
    getCurrentTime();
    if (0 == stat(path, &st)) {
        if (S_ISDIR(st.st_mode)) {
            debug(20, should_exist ? 3 : 1) ("%s exists\n", path);
        } else {
            fatalf("Swap directory %s is not a directory.", path);
        }
    } else if (0 == mkdir(path, 0755)) {
        debug(20, should_exist ? 1 : 3) ("%s created\n", path);
        created = 1;
    } else {
        fatalf("Failed to make swap directory %s: %s",
            path, xstrerror());
    }
    return created;
}

static int
storeDiskdDirVerifyDirectory(const char *path)
{
    struct stat sb;
    if (stat(path, &sb) < 0) {
        debug(20, 0) ("%s: %s\n", path, xstrerror());
        return -1;
    }
    if (S_ISDIR(sb.st_mode) == 0) {
        debug(20, 0) ("%s is not a directory\n", path);
        return -1;
    }
    return 0;
}

/*
 * This function is called by storeDiskdDirInit().  If this returns < 0,
 * then Squid exits, complains about swap directories not
 * existing, and instructs the admin to run 'squid -z'
 */
static int
storeDiskdDirVerifyCacheDirs(SwapDir * sd)
{
    diskdinfo_t *diskdinfo = (diskdinfo_t *)sd->fsdata;
    int j;
    const char *path = sd->path;

    if (storeDiskdDirVerifyDirectory(path) < 0)
        return -1;
    for (j = 0; j < diskdinfo->l1; j++) {
        path = storeDiskdDirSwapSubDir(sd, j);
        if (storeDiskdDirVerifyDirectory(path) < 0)
            return -1;
    }
    return 0;
}

static void
storeDiskdDirCreateSwapSubDirs(SwapDir * sd)
{
    diskdinfo_t *diskdinfo = (diskdinfo_t *)sd->fsdata;
    int i, k;
    int should_exist;
    LOCAL_ARRAY(char, name, MAXPATHLEN);
    for (i = 0; i < diskdinfo->l1; i++) {
        snprintf(name, MAXPATHLEN, "%s/%02X", sd->path, i);
        if (storeDiskdDirCreateDirectory(name, 0))
            should_exist = 0;
        else
            should_exist = 1;
        debug(47, 1) ("Making directories in %s\n", name);
        for (k = 0; k < diskdinfo->l2; k++) {
            snprintf(name, MAXPATHLEN, "%s/%02X/%02X", sd->path, i, k);
            storeDiskdDirCreateDirectory(name, should_exist);
        }
    }
}

static char *
storeDiskdDirSwapLogFile(SwapDir * sd, const char *ext)
{
    LOCAL_ARRAY(char, path, SQUID_MAXPATHLEN);
    LOCAL_ARRAY(char, pathtmp, SQUID_MAXPATHLEN);
    LOCAL_ARRAY(char, digit, 32);
    char *pathtmp2;
    if (Config.Log.swap) {
        xstrncpy(pathtmp, sd->path, SQUID_MAXPATHLEN - 64);
        while (index(pathtmp,'/'))
            *index(pathtmp,'/')='.';
        while (strlen(pathtmp) && pathtmp[strlen(pathtmp)-1]=='.')
            pathtmp[strlen(pathtmp)-1]= '\0';
        for(pathtmp2 = pathtmp; *pathtmp2 == '.'; pathtmp2++);
        snprintf(path, SQUID_MAXPATHLEN-64, Config.Log.swap, pathtmp2);
        if (strncmp(path, Config.Log.swap, SQUID_MAXPATHLEN - 64) == 0) {
            strcat(path, ".");
            snprintf(digit, 32, "%02d", sd->index);
            strncat(path, digit, 3);
        }
    } else {
        xstrncpy(path, sd->path, SQUID_MAXPATHLEN - 64);
        strcat(path, "/swap.state");
    }
    if (ext)
        strncat(path, ext, 16);
    return path;
}

static void
storeDiskdDirOpenSwapLog(SwapDir * sd)
{
    diskdinfo_t *diskdinfo = (diskdinfo_t *)sd->fsdata;
    char *path;
    int fd;
    path = storeDiskdDirSwapLogFile(sd, NULL);
    fd = file_open(path, O_WRONLY | O_CREAT);
    if (fd < 0) {
        debug(50, 1) ("%s: %s\n", path, xstrerror());
        fatal("storeDiskdDirOpenSwapLog: Failed to open swap log.");
    }
    debug(47, 3) ("Cache Dir #%d log opened on FD %d\n", sd->index, fd);
    diskdinfo->swaplog_fd = fd;
    if (0 == n_diskd_dirs)
        assert(NULL == diskd_dir_index);
    n_diskd_dirs++;
    assert(n_diskd_dirs <= Config.cacheSwap.n_configured);
}

static void
storeDiskdDirCloseSwapLog(SwapDir * sd)
{
    diskdinfo_t *diskdinfo = (diskdinfo_t *)sd->fsdata;
    if (diskdinfo->swaplog_fd < 0)      /* not open */
        return;
    file_close(diskdinfo->swaplog_fd);
    debug(47, 3) ("Cache Dir #%d log closed on FD %d\n",
        sd->index, diskdinfo->swaplog_fd);
    diskdinfo->swaplog_fd = -1;
    n_diskd_dirs--;
    assert(n_diskd_dirs >= 0);
    if (0 == n_diskd_dirs)
        safe_free(diskd_dir_index);
}

static void
storeDiskdDirInit(SwapDir * sd)
{
    static int started_clean_event = 0;
    int x;
    int i;
    int rfd;
    int ikey = (getpid() << 16) + (sd->index << 4);
    char *args[5];
    char skey1[32];
    char skey2[32];
    char skey3[32];
    diskdinfo_t *diskdinfo = (diskdinfo_t *) sd->fsdata;
    static const char *errmsg =
    "\tFailed to verify one of the swap directories, Check cache.log\n"
    "\tfor details.  Run 'squid -z' to create swap directories\n"
    "\tif needed, or if running Squid for the first time.";

    diskdinfo->smsgid = msgget((key_t) ikey, 0700 | IPC_CREAT);
    if (diskdinfo->smsgid < 0) {
        debug(50, 0) ("storeDiskdInit: msgget: %s\n", xstrerror());
        fatal("msgget failed");
    }
    diskdinfo->rmsgid = msgget((key_t) (ikey + 1), 0700 | IPC_CREAT);
    if (diskdinfo->rmsgid < 0) {
        debug(50, 0) ("storeDiskdInit: msgget: %s\n", xstrerror());
        fatal("msgget failed");
    }
    diskdinfo->shm.id = shmget((key_t) (ikey + 2),
        SHMBUFS * SHMBUF_BLKSZ, 0600 | IPC_CREAT);
    if (diskdinfo->shm.id < 0) {
        debug(50, 0) ("storeDiskdInit: shmget: %s\n", xstrerror());
        fatal("shmget failed");
    }
    diskdinfo->shm.buf = shmat(diskdinfo->shm.id, NULL, 0);
    if (diskdinfo->shm.buf == (void *) -1) {
        debug(50, 0) ("storeDiskdInit: shmat: %s\n", xstrerror());
        fatal("shmat failed");
    }
    diskd_stats.shmbuf_count += SHMBUFS;
    for (i = 0; i < SHMBUFS; i++)
        storeDiskdShmPut(sd, i * SHMBUF_BLKSZ);
    snprintf(skey1, 32, "%d", ikey);
    snprintf(skey2, 32, "%d", ikey + 1);
    snprintf(skey3, 32, "%d", ikey + 2);
    args[0] = "diskd";
    args[1] = skey1;
    args[2] = skey2;
    args[3] = skey3;
    args[4] = NULL;
#if HAVE_POLL && defined(_SQUID_OSF_)
    /* pipes and poll() don't get along on DUNIX -DW */
    x = ipcCreate(IPC_TCP_SOCKET,
#else
    x = ipcCreate(IPC_FIFO,
#endif
        SQUID_PREFIX "/bin/diskd",
        args,
        "diskd",
        &rfd,
        &diskdinfo->wfd);
    if (x < 0)
        fatal("execl " SQUID_PREFIX "/bin/diskd failed");
    if (rfd != diskdinfo->wfd)
        comm_close(rfd);
    fd_note(diskdinfo->wfd, "squid -> diskd");
    commSetTimeout(diskdinfo->wfd, -1, NULL, NULL);
    commSetNonBlocking(diskdinfo->wfd);
    storeDiskdDirInitBitmap(sd);
    if (storeDiskdDirVerifyCacheDirs(sd) < 0)
        fatal(errmsg);
    storeDiskdDirOpenSwapLog(sd);
    storeDiskdDirRebuild(sd);
    if (!started_clean_event) {
        eventAdd("storeDirClean", storeDiskdDirCleanEvent, NULL, 15.0, 1);
        started_clean_event = 1;
    }
}


static void
storeDiskdStats(StoreEntry * sentry)
{
    storeAppendPrintf(sentry, "sent_count: %d\n", diskd_stats.sent_count);
    storeAppendPrintf(sentry, "recv_count: %d\n", diskd_stats.recv_count);
    storeAppendPrintf(sentry, "max_away: %d\n", diskd_stats.max_away);
    storeAppendPrintf(sentry, "max_shmuse: %d\n", diskd_stats.max_shmuse);
    storeAppendPrintf(sentry, "open_fail_queue_len: %d\n", diskd_stats.open_fail_queue_len);
    storeAppendPrintf(sentry, "block_queue_len: %d\n", diskd_stats.block_queue_len);
    diskd_stats.max_away = diskd_stats.max_shmuse = 0;
}

/*
 * storeDiskdDirSync
 *
 * Sync any pending data. We just sit around and read the queue
 * until the data has finished writing.
 */
static void
storeDiskdDirSync(SwapDir *SD)
{
    /* XXX NOT DONE YET! */
#warning "storeDiskdSync() needs to be written"
}


/*
 * storeDiskdDirCallback
 *
 * Handle callbacks. If we have more than magic2 requests away, we block
 * until the queue is below magic2. Otherwise, we simply return when we
 * don't get a message.
 */
static void
storeDiskdDirCallback(SwapDir *SD)
{
    diomsg M;
    int x;
    diskdinfo_t *diskdinfo = (diskdinfo_t *)SD->fsdata;

    if (diskdinfo->away >= diskdinfo->magic2)
        diskd_stats.block_queue_len++;

    if (diskd_stats.sent_count - diskd_stats.recv_count >
      diskd_stats.max_away) {
        diskd_stats.max_away = diskd_stats.sent_count - diskd_stats.recv_count;
        diskd_stats.max_shmuse = diskd_stats.shmbuf_count;
    }

    /* if we are above magic2, we do not break under any reason */
    while (1) {
        memset(&M, '\0', sizeof(M));
        x = msgrcv(diskdinfo->rmsgid, &M, msg_snd_rcv_sz, 0, IPC_NOWAIT);
        if (x < 0) {
            if (diskdinfo->away >= diskdinfo->magic2)
                continue;
            else
                break;
        } else if (x != msg_snd_rcv_sz) {
            debug(81, 1) ("storeDiskdReadIndividualQueue: msgget returns %d\n",
              x);
            break;
        }
        diskd_stats.recv_count++;
        diskdinfo->away--;
        storeDiskdHandle(&M);
        if (M.shm_offset > -1)
            storeDiskdShmPut(SD, M.shm_offset);
    }
}



static void
storeDiskdDirRebuildFromDirectory(void *data)
{
    RebuildState *rb = data;
    SwapDir *SD = rb->sd;
    LOCAL_ARRAY(char, hdr_buf, SM_PAGE_SIZE);
    StoreEntry *e = NULL;
    StoreEntry tmpe;
    cache_key key[MD5_DIGEST_CHARS];
    int sfileno = 0;
    int count;
    int size;
    struct stat sb;
    int swap_hdr_len;
    int fd = -1;
    tlv *tlv_list;
    tlv *t;
    assert(rb != NULL);
    debug(20, 3) ("storeDiskdDirRebuildFromDirectory: DIR #%d\n", rb->sd->index);
    for (count = 0; count < rb->speed; count++) {
        assert(fd == -1);
        fd = storeDiskdDirGetNextFile(rb, &sfileno, &size);
        if (fd == -2) {
            debug(20, 1) ("Done scanning %s swaplog (%d entries)\n",
                rb->sd->path, rb->n_read);
            store_dirs_rebuilding--;
            storeDiskdDirCloseTmpSwapLog(rb->sd);
            storeRebuildComplete(&rb->counts);
            cbdataFree(rb);
            return;
        } else if (fd < 0) {
            continue;
        }
        assert(fd > -1);
        /* lets get file stats here */
        if (fstat(fd, &sb) < 0) {
            debug(20, 1) ("storeDiskdDirRebuildFromDirectory: fstat(FD %d): %s\n",
                fd, xstrerror());
            file_close(fd);
            store_open_disk_fd--;
            fd = -1;
            continue;
        }
        if ((++rb->counts.scancount & 0xFFFF) == 0)
            debug(20, 3) ("  %s %7d files opened so far.\n",
                rb->sd->path, rb->counts.scancount);
        debug(20, 9) ("file_in: fd=%d %08X\n", fd, sfileno);
        Counter.syscalls.disk.reads++;
        if (read(fd, hdr_buf, SM_PAGE_SIZE) < 0) {
            debug(20, 1) ("storeDiskdDirRebuildFromDirectory: read(FD %d): %s\n",
                fd, xstrerror());
            file_close(fd);
            store_open_disk_fd--;
            fd = -1;
            continue;
        }
        file_close(fd);
        store_open_disk_fd--;
        fd = -1;
        swap_hdr_len = 0;
#if USE_TRUNCATE
        if (sb.st_size == 0)
            continue;
#endif
        tlv_list = storeSwapMetaUnpack(hdr_buf, &swap_hdr_len);
        if (tlv_list == NULL) {
            debug(20, 1) ("storeDiskdDirRebuildFromDirectory: failed to get meta data\n");
            /* XXX shouldn't this be a call to storeDiskdUnlink ? */
            storeDiskdDirUnlinkFile(SD, sfileno);
            continue;
        }
        debug(20, 3) ("storeDiskdDirRebuildFromDirectory: successful swap meta unpacking\n");
        memset(key, '\0', MD5_DIGEST_CHARS);
        memset(&tmpe, '\0', sizeof(StoreEntry));
        for (t = tlv_list; t; t = t->next) {
            switch (t->type) {
            case STORE_META_KEY:
                assert(t->length == MD5_DIGEST_CHARS);
                xmemcpy(key, t->value, MD5_DIGEST_CHARS);
                break;
            case STORE_META_STD:
                assert(t->length == STORE_HDR_METASIZE);
                xmemcpy(&tmpe.timestamp, t->value, STORE_HDR_METASIZE);
                break;
            default:
                break;
            }
        }
        storeSwapTLVFree(tlv_list);
        tlv_list = NULL;
        if (storeKeyNull(key)) {
            debug(20, 1) ("storeDiskdDirRebuildFromDirectory: NULL key\n");
            storeDiskdDirUnlinkFile(SD, sfileno);
            continue;
        }
        tmpe.key = key;
        /* check sizes */
        if (tmpe.swap_file_sz == 0) {
            tmpe.swap_file_sz = sb.st_size;
        } else if (tmpe.swap_file_sz == sb.st_size - swap_hdr_len) {
            tmpe.swap_file_sz = sb.st_size;
        } else if (tmpe.swap_file_sz != sb.st_size) {
            debug(20, 1) ("storeDiskdDirRebuildFromDirectory: SIZE MISMATCH %d!=%d\n",
                tmpe.swap_file_sz, (int) sb.st_size);
            storeDiskdDirUnlinkFile(SD, sfileno);
            continue;
        }
        if (EBIT_TEST(tmpe.flags, KEY_PRIVATE)) {
            storeDiskdDirUnlinkFile(SD, sfileno);
            rb->counts.badflags++;
            continue;
        }
        e = storeGet(key);
        if (e && e->lastref >= tmpe.lastref) {
            /* key already exists, current entry is newer */
            /* keep old, ignore new */
            rb->counts.dupcount++;
            continue;
        } else if (NULL != e) {
            /* URL already exists, this swapfile not being used */
            /* junk old, load new */
            storeRelease(e);    /* release old entry */
            rb->counts.dupcount++;
        }
        rb->counts.objcount++;
        storeEntryDump(&tmpe, 5);
        e = storeDiskdDirAddDiskRestore(SD, key,
            sfileno,
            tmpe.swap_file_sz,
            tmpe.expires,
            tmpe.timestamp,
            tmpe.lastref,
            tmpe.lastmod,
            tmpe.refcount,      /* refcount */
            tmpe.flags,         /* flags */
            (int) rb->flags.clean);
        storeDirSwapLog(e, SWAP_LOG_ADD);
    }
    eventAdd("storeRebuild", storeDiskdDirRebuildFromDirectory, rb, 0.0, 1);
}

static void
storeDiskdDirRebuildFromSwapLog(void *data)
{
    RebuildState *rb = data;
    SwapDir *SD = rb->sd;
    StoreEntry *e = NULL;
    storeSwapLogData s;
    size_t ss = sizeof(storeSwapLogData);
    int count;
    int used;                   /* is swapfile already in use? */
    int disk_entry_newer;       /* is the log entry newer than current entry? */
    double x;
    assert(rb != NULL);
    /* load a number of objects per invocation */
    for (count = 0; count < rb->speed; count++) {
        if (fread(&s, ss, 1, rb->log) != 1) {
            debug(20, 1) ("Done reading %s swaplog (%d entries)\n",
                rb->sd->path, rb->n_read);
            fclose(rb->log);
            rb->log = NULL;
            store_dirs_rebuilding--;
            storeDiskdDirCloseTmpSwapLog(rb->sd);
            storeRebuildComplete(&rb->counts);
            cbdataFree(rb);
            return;
        }
        rb->n_read++;
        if (s.op <= SWAP_LOG_NOP)
            continue;
        if (s.op >= SWAP_LOG_MAX)
            continue;
        debug(20, 3) ("storeDiskdDirRebuildFromSwapLog: %s %s %08X\n",
            swap_log_op_str[(int) s.op],
            storeKeyText(s.key),
            s.swap_filen);
        if (s.op == SWAP_LOG_ADD) {
            (void) 0;
        } else if (s.op == SWAP_LOG_DEL) {
            if ((e = storeGet(s.key)) != NULL) {
                /*
                 * Make sure we don't unlink the file, it might be
                 * in use by a subsequent entry.  Also note that
                 * we don't have to subtract from store_swap_size
                 * because adding to store_swap_size happens in
                 * the cleanup procedure.
                 */
                storeExpireNow(e);
                storeReleaseRequest(e);
                storeDiskdDirReplRemove(e);
                if (e->swap_filen > -1) {
                    storeDiskdDirMapBitReset(SD, e->swap_filen);
                    e->swap_filen = -1;
                    e->swap_dirn = -1;
                }
                storeRelease(e);
                rb->counts.objcount--;
                rb->counts.cancelcount++;
            }
            continue;
        } else {
            x = log(++rb->counts.bad_log_op) / log(10.0);
            if (0.0 == x - (double) (int) x)
                debug(20, 1) ("WARNING: %d invalid swap log entries found\n",
                    rb->counts.bad_log_op);
            rb->counts.invalid++;
            continue;
        }
        if ((++rb->counts.scancount & 0xFFFF) == 0)
            debug(20, 3) ("  %7d %s Entries read so far.\n",
                rb->counts.scancount, rb->sd->path);
        if (!storeDiskdDirValidFileno(SD, s.swap_filen)) {
            rb->counts.invalid++;
            continue;
        }
        if (EBIT_TEST(s.flags, KEY_PRIVATE)) {
            rb->counts.badflags++;
            continue;
        }
        e = storeGet(s.key);
        used = storeDiskdDirMapBitTest(SD, s.swap_filen);
        /* If this URL already exists in the cache, does the swap log
         * appear to have a newer entry?  Compare 'lastref' from the
         * swap log to e->lastref. */
        disk_entry_newer = e ? (s.lastref > e->lastref ? 1 : 0) : 0;
        if (used && !disk_entry_newer) {
            /* log entry is old, ignore it */
            rb->counts.clashcount++;
            continue;
        } else if (used && e && e->swap_filen == s.swap_filen && e->swap_dirn == SD->index) {
            /* swapfile taken, same URL, newer, update meta */
            if (e->store_status == STORE_OK) {
                e->lastref = s.timestamp;
                e->timestamp = s.timestamp;
                e->expires = s.expires;
                e->lastmod = s.lastmod;
                e->flags = s.flags;
                e->refcount += s.refcount;
#if HEAP_REPLACEMENT
                storeHeapPositionUpdate(e, SD);
                storeDiskdDirUnrefObj(SD, e);
#endif
            } else {
                debug_trap("storeDiskdDirRebuildFromSwapLog: bad condition");
                debug(20, 1) ("\tSee %s:%d\n", __FILE__, __LINE__);
            }
            continue;
        } else if (used) {
            /* swapfile in use, not by this URL, log entry is newer */
            /* This is sorta bad: the log entry should NOT be newer at this
             * point.  If the log is dirty, the filesize check should have
             * caught this.  If the log is clean, there should never be a
             * newer entry. */
            debug(20, 1) ("WARNING: newer swaplog entry for dirno %d, fileno %08X\n",
                SD->index, s.swap_filen);
            /* I'm tempted to remove the swapfile here just to be safe,
             * but there is a bad race condition in the NOVM version if
             * the swapfile has recently been opened for writing, but
             * not yet opened for reading.  Because we can't map
             * swapfiles back to StoreEntrys, we don't know the state
             * of the entry using that file.  */
            /* We'll assume the existing entry is valid, probably because
             * were in a slow rebuild and the the swap file number got taken
             * and the validation procedure hasn't run. */
            assert(rb->flags.need_to_validate);
            rb->counts.clashcount++;
            continue;
        } else if (e && !disk_entry_newer) {
            /* key already exists, current entry is newer */
            /* keep old, ignore new */
            rb->counts.dupcount++;
            continue;
        } else if (e) {
            /* key already exists, this swapfile not being used */
            /* junk old, load new */
            storeExpireNow(e);
            storeReleaseRequest(e);
            storeDiskdDirReplRemove(e);
            if (e->swap_filen > -1) {
                /* Make sure we don't actually unlink the file */
                storeDiskdDirMapBitReset(SD, e->swap_filen);
                e->swap_filen = -1;
                e->swap_dirn = -1;
            }
            storeRelease(e);
            rb->counts.dupcount++;
        } else {
            /* URL doesnt exist, swapfile not in use */
            /* load new */
            (void) 0;
        }
        /* update store_swap_size */
        rb->counts.objcount++;
        e = storeDiskdDirAddDiskRestore(SD, s.key,
            s.swap_filen,
            s.swap_file_sz,
            s.expires,
            s.timestamp,
            s.lastref,
            s.lastmod,
            s.refcount,
            s.flags,
            (int) rb->flags.clean);
        storeDirSwapLog(e, SWAP_LOG_ADD);
    }
    eventAdd("storeRebuild", storeDiskdDirRebuildFromSwapLog, rb, 0.0, 1);
}

static int
storeDiskdDirGetNextFile(RebuildState * rb, int *sfileno, int *size)
{
    SwapDir *SD = rb->sd;
    diskdinfo_t *diskdinfo = (diskdinfo_t *)SD->fsdata;
    int fd = -1;
    int used = 0;
    int dirs_opened = 0;
    debug(20, 3) ("storeDiskdDirGetNextFile: flag=%d, %d: /%02X/%02X\n",
        rb->flags.init,
        rb->sd->index,
        rb->curlvl1,
        rb->curlvl2);
    if (rb->done)
        return -2;
    while (fd < 0 && rb->done == 0) {
        fd = -1;
        if (0 == rb->flags.init) {      /* initialize, open first file */
            rb->done = 0;
            rb->curlvl1 = 0;
            rb->curlvl2 = 0;
            rb->in_dir = 0;
            rb->flags.init = 1;
            assert(Config.cacheSwap.n_configured > 0);
        }
        if (0 == rb->in_dir) {  /* we need to read in a new directory */
            snprintf(rb->fullpath, SQUID_MAXPATHLEN, "%s/%02X/%02X",
                rb->sd->path,
                rb->curlvl1, rb->curlvl2);
            if (rb->flags.init && rb->td != NULL)
                closedir(rb->td);
            rb->td = NULL;
            if (dirs_opened)
                return -1;
            rb->td = opendir(rb->fullpath);
            dirs_opened++;
            if (rb->td == NULL) {
                debug(50, 1) ("storeDiskdDirGetNextFile: opendir: %s: %s\n",
                    rb->fullpath, xstrerror());
            } else {
                rb->entry = readdir(rb->td);    /* skip . and .. */
                rb->entry = readdir(rb->td);
                if (rb->entry == NULL && errno == ENOENT)
                    debug(20, 1) ("storeDiskdDirGetNextFile: directory does not exist!.\n");
                debug(20, 3) ("storeDiskdDirGetNextFile: Directory %s\n", rb->fullpath);
            }
        }
        if (rb->td != NULL && (rb->entry = readdir(rb->td)) != NULL) {
            rb->in_dir++;
            if (sscanf(rb->entry->d_name, "%x", &rb->fn) != 1) {
                debug(20, 3) ("storeDiskdDirGetNextFile: invalid %s\n",
                    rb->entry->d_name);
                continue;
            }
            if (!storeDiskdFilenoBelongsHere(rb->fn, rb->sd->index, rb->curlvl1, rb->curlvl2)) {
                debug(20, 3) ("storeDiskdDirGetNextFile: %08X does not belong in %d/%d/%d\n",
                    rb->fn, rb->sd->index, rb->curlvl1, rb->curlvl2);
                continue;
            }
            used = storeDiskdDirMapBitTest(SD, rb->fn);
            if (used) {
                debug(20, 3) ("storeDiskdDirGetNextFile: Locked, continuing with next.\n");
                continue;
            }
            snprintf(rb->fullfilename, SQUID_MAXPATHLEN, "%s/%s",
                rb->fullpath, rb->entry->d_name);
            debug(20, 3) ("storeDiskdDirGetNextFile: Opening %s\n", rb->fullfilename);
            fd = file_open(rb->fullfilename, O_RDONLY);
            if (fd < 0)
                debug(50, 1) ("storeDiskdDirGetNextFile: %s: %s\n", rb->fullfilename, xstrerror());
            else
                store_open_disk_fd++;
            continue;
        }
        rb->in_dir = 0;
        if (++rb->curlvl2 < diskdinfo->l2)
            continue;
        rb->curlvl2 = 0;
        if (++rb->curlvl1 < diskdinfo->l1)
            continue;
        rb->curlvl1 = 0;
        rb->done = 1;
    }
    *sfileno = rb->fn;
    return fd;
}

/* Add a new object to the cache with empty memory copy and pointer to disk
 * use to rebuild store from disk. */
static StoreEntry *
storeDiskdDirAddDiskRestore(SwapDir *SD, const cache_key * key,
    int file_number,
    size_t swap_file_sz,
    time_t expires,
    time_t timestamp,
    time_t lastref,
    time_t lastmod,
    u_num32 refcount,
    u_short flags,
    int clean)
{
    StoreEntry *e = NULL;
    debug(20, 5) ("storeDiskdAddDiskRestore: %s, fileno=%08X\n", storeKeyText(key), file_number);
    /* if you call this you'd better be sure file_number is not 
     * already in use! */
    e = new_StoreEntry(STORE_ENTRY_WITHOUT_MEMOBJ, NULL, NULL);
    e->store_status = STORE_OK;
    storeSetMemStatus(e, NOT_IN_MEMORY);
    e->swap_status = SWAPOUT_DONE;
    e->swap_filen = file_number;
    e->swap_dirn = SD->index;
    e->swap_file_sz = swap_file_sz;
    e->lock_count = 0;
#if !HEAP_REPLACEMENT
    e->refcount = 0;
#endif
    e->lastref = lastref;
    e->timestamp = timestamp;
    e->expires = expires;
    e->lastmod = lastmod;
    e->refcount = refcount;
    e->flags = flags;
    EBIT_SET(e->flags, ENTRY_CACHABLE);
    EBIT_CLR(e->flags, RELEASE_REQUEST);
    EBIT_CLR(e->flags, KEY_PRIVATE);
    e->ping_status = PING_NONE;
    EBIT_CLR(e->flags, ENTRY_VALIDATED);
    storeDiskdDirMapBitSet(SD, e->swap_filen);
    storeHashInsert(e, key);    /* do it after we clear KEY_PRIVATE */
    storeDiskdDirReplAdd(SD, e);
    return e;
}

static void
storeDiskdDirRebuild(SwapDir * sd)
{
    RebuildState *rb = xcalloc(1, sizeof(*rb));
    int clean = 0;
    int zero = 0;
    FILE *fp;
    EVH *func = NULL;
    rb->sd = sd;
    rb->speed = opt_foreground_rebuild ? 1 << 30 : 50;
    /*
     * If the swap.state file exists in the cache_dir, then
     * we'll use storeDiskdDirRebuildFromSwapLog(), otherwise we'll
     * use storeDiskdDirRebuildFromDirectory() to open up each file
     * and suck in the meta data.
     */
    fp = storeDiskdDirOpenTmpSwapLog(sd, &clean, &zero);
    if (fp == NULL || zero) {
        if (fp != NULL)
            fclose(fp);
        func = storeDiskdDirRebuildFromDirectory;
    } else {
        func = storeDiskdDirRebuildFromSwapLog;
        rb->log = fp;
        rb->flags.clean = (unsigned int) clean;
    }
    if (!clean)
        rb->flags.need_to_validate = 1;
    debug(20, 1) ("Rebuilding storage in %s (%s)\n",
        sd->path, clean ? "CLEAN" : "DIRTY");
    store_dirs_rebuilding++;
    cbdataAdd(rb, cbdataXfree, 0);
    eventAdd("storeRebuild", func, rb, 0.0, 1);
}

static void
storeDiskdDirCloseTmpSwapLog(SwapDir * sd)
{
    diskdinfo_t *diskdinfo = (diskdinfo_t *)sd->fsdata;
    char *swaplog_path = xstrdup(storeDiskdDirSwapLogFile(sd, NULL));
    char *new_path = xstrdup(storeDiskdDirSwapLogFile(sd, ".new"));
    int fd;
    file_close(diskdinfo->swaplog_fd);
#ifdef _SQUID_OS2_
    if (unlink(swaplog_path) < 0) {
        debug(50, 0) ("%s: %s\n", swaplog_path, xstrerror());
        fatal("storeDiskdDirCloseTmpSwapLog: unlink failed");
    }
#endif
    if (xrename(new_path, swaplog_path) < 0) {
        fatal("storeDiskdDirCloseTmpSwapLog: rename failed");
    }
    fd = file_open(swaplog_path, O_WRONLY | O_CREAT);
    if (fd < 0) {
        debug(50, 1) ("%s: %s\n", swaplog_path, xstrerror());
        fatal("storeDiskdDirCloseTmpSwapLog: Failed to open swap log.");
    }
    safe_free(swaplog_path);
    safe_free(new_path);
    diskdinfo->swaplog_fd = fd;
    debug(47, 3) ("Cache Dir #%d log opened on FD %d\n", sd->index, fd);
}

static FILE *
storeDiskdDirOpenTmpSwapLog(SwapDir * sd, int *clean_flag, int *zero_flag)
{
    diskdinfo_t *diskdinfo = (diskdinfo_t *)sd->fsdata;
    char *swaplog_path = xstrdup(storeDiskdDirSwapLogFile(sd, NULL));
    char *clean_path = xstrdup(storeDiskdDirSwapLogFile(sd, ".last-clean"));
    char *new_path = xstrdup(storeDiskdDirSwapLogFile(sd, ".new"));
    struct stat log_sb;
    struct stat clean_sb;
    FILE *fp;
    int fd;
    if (stat(swaplog_path, &log_sb) < 0) {
        debug(47, 1) ("Cache Dir #%d: No log file\n", sd->index);
        safe_free(swaplog_path);
        safe_free(clean_path);
        safe_free(new_path);
        return NULL;
    }
    *zero_flag = log_sb.st_size == 0 ? 1 : 0;
    /* close the existing write-only FD */
    if (diskdinfo->swaplog_fd >= 0)
        file_close(diskdinfo->swaplog_fd);
    /* open a write-only FD for the new log */
    fd = file_open(new_path, O_WRONLY | O_CREAT | O_TRUNC);
    if (fd < 0) {
        debug(50, 1) ("%s: %s\n", new_path, xstrerror());
        fatal("storeDirOpenTmpSwapLog: Failed to open swap log.");
    }
    diskdinfo->swaplog_fd = fd;
    /* open a read-only stream of the old log */
    fp = fopen(swaplog_path, "r");
    if (fp == NULL) {
        debug(50, 0) ("%s: %s\n", swaplog_path, xstrerror());
        fatal("Failed to open swap log for reading");
    }
    memset(&clean_sb, '\0', sizeof(struct stat));
    if (stat(clean_path, &clean_sb) < 0)
        *clean_flag = 0;
    else if (clean_sb.st_mtime < log_sb.st_mtime)
        *clean_flag = 0;
    else
        *clean_flag = 1;
    safeunlink(clean_path, 1);
    safe_free(swaplog_path);
    safe_free(clean_path);
    safe_free(new_path);
    return fp;
}

struct _clean_state {
    char *cur;
    char *new;
    char *cln;
    char *outbuf;
    off_t outbuf_offset;
    int fd;
};

#define CLEAN_BUF_SZ 16384
/*
 * Begin the process to write clean cache state.  For DISKD this means
 * opening some log files and allocating write buffers.  Return 0 if
 * we succeed, and assign the 'func' and 'data' return pointers.
 */
static int
storeDiskdDirWriteCleanOpen(SwapDir * sd)
{
    struct _clean_state *state = xcalloc(1, sizeof(*state));
    struct stat sb;
    sd->log.clean.write = NULL;
    sd->log.clean.state = NULL;
    state->cur = xstrdup(storeDiskdDirSwapLogFile(sd, NULL));
    state->new = xstrdup(storeDiskdDirSwapLogFile(sd, ".clean"));
    state->cln = xstrdup(storeDiskdDirSwapLogFile(sd, ".last-clean"));
    state->outbuf = xcalloc(CLEAN_BUF_SZ, 1);
    state->outbuf_offset = 0;
    unlink(state->new);
    unlink(state->cln);
    state->fd = file_open(state->new, O_WRONLY | O_CREAT | O_TRUNC);
    if (state->fd < 0)
        return -1;
    debug(20, 3) ("storeDirWriteCleanLogs: opened %s, FD %d\n",
        state->new, state->fd);
#if HAVE_FCHMOD
    if (stat(state->cur, &sb) == 0)
        fchmod(state->fd, sb.st_mode);
#endif
    sd->log.clean.write = storeDiskdDirWriteCleanEntry;
    sd->log.clean.state = state;
    return 0;
}

/*
 * "write" an entry to the clean log file.
 */
static void
storeDiskdDirWriteCleanEntry(const StoreEntry * e, SwapDir * sd)
{
    storeSwapLogData s;
    static size_t ss = sizeof(storeSwapLogData);
    struct _clean_state *state = sd->log.clean.state;
    if (NULL == e) {
        storeDiskdDirWriteCleanClose(sd);
        return;
    }
    memset(&s, '\0', ss);
    s.op = (char) SWAP_LOG_ADD;
    s.swap_filen = e->swap_filen;
    s.timestamp = e->timestamp;
    s.lastref = e->lastref;
    s.expires = e->expires;
    s.lastmod = e->lastmod;
    s.swap_file_sz = e->swap_file_sz;
    s.refcount = e->refcount;
    s.flags = e->flags;
    xmemcpy(&s.key, e->key, MD5_DIGEST_CHARS);
    xmemcpy(state->outbuf + state->outbuf_offset, &s, ss);
    state->outbuf_offset += ss;
    /* buffered write */
    if (state->outbuf_offset + ss > CLEAN_BUF_SZ) {
        if (write(state->fd, state->outbuf, state->outbuf_offset) < 0) {
            debug(50, 0) ("storeDirWriteCleanLogs: %s: write: %s\n",
                state->new, xstrerror());
            debug(20, 0) ("storeDirWriteCleanLogs: Current swap logfile not replaced.\n");
            file_close(state->fd);
            state->fd = -1;
            unlink(state->new);
            safe_free(state);
            sd->log.clean.state = NULL;
            sd->log.clean.write = NULL;
        }
        state->outbuf_offset = 0;
    }
}

static void
storeDiskdDirWriteCleanClose(SwapDir * sd)
{
    struct _clean_state *state = sd->log.clean.state;
    if (state->fd < 0)
        return;
    if (write(state->fd, state->outbuf, state->outbuf_offset) < 0) {
        debug(50, 0) ("storeDirWriteCleanLogs: %s: write: %s\n",
            state->new, xstrerror());
        debug(20, 0) ("storeDirWriteCleanLogs: Current swap logfile "
            "not replaced.\n");
        file_close(state->fd);
        state->fd = -1;
        unlink(state->new);
    }
    safe_free(state->outbuf);
    /*
     * You can't rename open files on Microsoft "operating systems"
     * so we have to close before renaming.
     */
    storeDiskdDirCloseSwapLog(sd);
    /* rename */
    if (state->fd >= 0) {
#ifdef _SQUID_OS2_
        file_close(state->fd);
        state->fd = -1;
        if (unlink(cur) < 0)
            debug(50, 0) ("storeDirWriteCleanLogs: unlinkd failed: %s, %s\n",
                xstrerror(), cur);
#endif
        xrename(state->new, state->cur);
    }
    /* touch a timestamp file if we're not still validating */
    if (store_dirs_rebuilding)
        (void) 0;
    else if (state->fd < 0)
        (void) 0;
    else
        file_close(file_open(state->cln, O_WRONLY | O_CREAT | O_TRUNC));
    /* close */
    safe_free(state->cur);
    safe_free(state->new);
    safe_free(state->cln);
    if (state->fd >= 0)
        file_close(state->fd);
    state->fd = -1;
    safe_free(state);
    sd->log.clean.state = NULL;
    sd->log.clean.write = NULL;
}

static void
storeDiskdDirSwapLog(const SwapDir * sd, const StoreEntry * e, int op)
{
    diskdinfo_t *diskdinfo = (diskdinfo_t *)sd->fsdata;
    storeSwapLogData *s = xcalloc(1, sizeof(storeSwapLogData));
    s->op = (char) op;
    s->swap_filen = e->swap_filen;
    s->timestamp = e->timestamp;
    s->lastref = e->lastref;
    s->expires = e->expires;
    s->lastmod = e->lastmod;
    s->swap_file_sz = e->swap_file_sz;
    s->refcount = e->refcount;
    s->flags = e->flags;
    xmemcpy(s->key, e->key, MD5_DIGEST_CHARS);
    file_write(diskdinfo->swaplog_fd,
        -1,
        s,
        sizeof(storeSwapLogData),
        NULL,
        NULL,
        xfree);
}

static void
storeDiskdDirNewfs(SwapDir * sd)
{
    debug(47, 3) ("Creating swap space in %s\n", sd->path);
    storeDiskdDirCreateDirectory(sd->path, 0);
    storeDiskdDirCreateSwapSubDirs(sd);
}

static int
rev_int_sort(const void *A, const void *B)
{
    const int *i1 = A;
    const int *i2 = B;
    return *i2 - *i1;
}

static int
storeDiskdDirClean(int swap_index)
{
    DIR *dp = NULL;
    struct dirent *de = NULL;
    LOCAL_ARRAY(char, p1, MAXPATHLEN + 1);
    LOCAL_ARRAY(char, p2, MAXPATHLEN + 1);
#if USE_TRUNCATE
    struct stat sb;
#endif
    int files[20];
    int swapfileno;
    int fn;                     /* same as swapfileno, but with dirn bits set */
    int n = 0;
    int k = 0;
    int N0, N1, N2;
    int D0, D1, D2;
    SwapDir *SD;
    diskdinfo_t *diskdinfo;
    N0 = n_diskd_dirs;
    D0 = diskd_dir_index[swap_index % N0];
    SD = &Config.cacheSwap.swapDirs[D0];
    diskdinfo = (diskdinfo_t *)SD->fsdata;
    N1 = diskdinfo->l1;
    D1 = (swap_index / N0) % N1;
    N2 = diskdinfo->l2;
    D2 = ((swap_index / N0) / N1) % N2;
    snprintf(p1, SQUID_MAXPATHLEN, "%s/%02X/%02X",
        Config.cacheSwap.swapDirs[D0].path, D1, D2);
    debug(36, 3) ("storeDirClean: Cleaning directory %s\n", p1);
    dp = opendir(p1);
    if (dp == NULL) {
        if (errno == ENOENT) {
            debug(36, 0) ("storeDirClean: WARNING: Creating %s\n", p1);
            if (mkdir(p1, 0777) == 0)
                return 0;
        }
        debug(50, 0) ("storeDirClean: %s: %s\n", p1, xstrerror());
        safeunlink(p1, 1);
        return 0;
    }
    while ((de = readdir(dp)) != NULL && k < 20) {
        if (sscanf(de->d_name, "%X", &swapfileno) != 1)
            continue;
        fn = swapfileno; /* XXX should remove this cruft ! */
        if (storeDiskdDirValidFileno(SD, fn))
            if (storeDiskdDirMapBitTest(SD, fn))
                if (storeDiskdFilenoBelongsHere(fn, D0, D1, D2))
                    continue;
#if USE_TRUNCATE
        if (!stat(de->d_name, &sb))
            if (sb.st_size == 0)
                continue;
#endif
        files[k++] = swapfileno;
    }
    closedir(dp);
    if (k == 0)
        return 0;
    qsort(files, k, sizeof(int), rev_int_sort);
    if (k > 10)
        k = 10;
    for (n = 0; n < k; n++) {
        debug(36, 3) ("storeDirClean: Cleaning file %08X\n", files[n]);
        snprintf(p2, MAXPATHLEN + 1, "%s/%08X", p1, files[n]);
#if USE_TRUNCATE
        truncate(p2, 0);
#else
        safeunlink(p2, 0);
#endif
        Counter.swap_files_cleaned++;
    }
    debug(36, 3) ("Cleaned %d unused files from %s\n", k, p1);
    return k;
}

static void
storeDiskdDirCleanEvent(void *unused)
{
    static int swap_index = 0;
    int i;
    int j = 0;
    int n = 0;
    /*
     * Assert that there are DISKD cache_dirs configured, otherwise
     * we should never be called.
     */
    assert(n_diskd_dirs);
    if (NULL == diskd_dir_index) {
        SwapDir *sd;
        diskdinfo_t *diskdinfo;
        /*
         * Initialize the little array that translates DISKD cache_dir
         * number into the Config.cacheSwap.swapDirs array index.
         */
        diskd_dir_index = xcalloc(n_diskd_dirs, sizeof(*diskd_dir_index));
        for (i = 0, n = 0; i < Config.cacheSwap.n_configured; i++) {
            sd = &Config.cacheSwap.swapDirs[i];
            if (!storeDiskdDirIs(sd))
                continue;
            diskd_dir_index[n++] = i;
            diskdinfo = (diskdinfo_t *)sd->fsdata;
            j += (diskdinfo->l1 * diskdinfo->l2);
        }
        assert(n == n_diskd_dirs);
        /*
         * Start the storeDiskdDirClean() swap_index with a random
         * value.  j equals the total number of DISKD level 2
         * swap directories
         */
        swap_index = (int) (squid_random() % j);
    }
    if (0 == store_dirs_rebuilding) {
        n = storeDiskdDirClean(swap_index);
        swap_index++;
    }
    eventAdd("storeDirClean", storeDiskdDirCleanEvent, NULL,
        15.0 * exp(-0.25 * n), 1);
}

static int
storeDiskdDirIs(SwapDir * sd)
{
    if (strncmp(sd->type, "diskd", 3) == 0)
        return 1;
    return 0;
}

/*
 * Does swapfile number 'fn' belong in cachedir #F0,
 * level1 dir #F1, level2 dir #F2?
 */
static int
storeDiskdFilenoBelongsHere(int fn, int F0, int F1, int F2)
{
    int D1, D2;
    int L1, L2;
    int filn = fn;
    diskdinfo_t *diskdinfo;
    assert(F0 < Config.cacheSwap.n_configured);
    diskdinfo = (diskdinfo_t *)Config.cacheSwap.swapDirs[F0].fsdata;
    L1 = diskdinfo->l1;
    L2 = diskdinfo->l2;
    D1 = ((filn / L2) / L2) % L1;
    if (F1 != D1)
        return 0;
    D2 = (filn / L2) % L2;
    if (F2 != D2)
        return 0;
    return 1;
}

int 
storeDiskdDirValidFileno(SwapDir *SD, sfileno filn)
{
    diskdinfo_t *diskdinfo = (diskdinfo_t *)SD->fsdata;
    if (filn < 0)
        return 0;
    if (filn > diskdinfo->map->max_n_files)  
        return 0;
    return 1;
}

void
storeDiskdDirMaintain(SwapDir *SD)
{
    StoreEntry *e = NULL;
    int scanned = 0;
    int locked = 0;
    int expired = 0;
    int max_scan;
    int max_remove;
    double f;
    static time_t last_warn_time = 0;
#if !HEAP_REPLACEMENT
    dlink_node *m;
    dlink_node *prev = NULL;
#else
    heap_key age;
    heap_key min_age = 0.0;
    link_list *locked_entries = NULL;
#if HEAP_REPLACEMENT_DEBUG
    if (!verify_heap_property(SD->repl.heap.heap)) {
        debug(20, 1) ("Heap property violated!\n");
    }
#endif
#endif
    /* We can't delete objects while rebuilding swap */
    if (store_dirs_rebuilding) {
        return;
    } else {
        f = (double) (store_swap_size - store_swap_low) / (store_swap_high - store_swap_low);
        f = f < 0.0 ? 0.0 : f > 1.0 ? 1.0 : f;
        max_scan = (int) (f * 400.0 + 100.0);
        max_remove = (int) (f * 70.0 + 10.0);
        /*
         * This is kinda cheap, but so we need this priority hack?
         */
#if 0
        eventAdd("MaintainSwapSpace", storeMaintainSwapSpace, NULL, 1.0 - f, 1);
#endif
    }
    debug(20, 3) ("storeMaintainSwapSpace: f=%f, max_scan=%d, max_remove=%d\n", f, max_scan, max_remove);
#if HEAP_REPLACEMENT
    while (heap_nodes(SD->repl.heap.heap) > 0) {
        if (store_swap_size < store_swap_low)
            break;
        if (expired >= max_remove)
            break;
        if (scanned >= max_scan)
            break;
        age = heap_peepminkey(SD->repl.heap.heap);
        e = heap_extractmin(SD->repl.heap.heap);
        e->repl.node = NULL;         /* no longer in the heap */
        scanned++;
        if (storeEntryLocked(e)) {
            /*
             * Entry is in use ... put it in a linked list to ignore it.
             */
            if (!EBIT_TEST(e->flags, ENTRY_SPECIAL)) {
                /*
                 * If this was a "SPECIAL" do not add it back into the heap.
                 * It will always be "SPECIAL" and therefore never removed.
                 */
                debug(20, 4) ("storeDiskdDirMaintain: locked url %s\n",
                    (e->mem_obj && e->mem_obj->url) ? e->mem_obj->url : storeKeyText(e->
key));
                linklistPush(&locked_entries, e);
            }
            locked++;
            continue;
        } else if (storeDiskdDirCheckExpired(SD, e)) {
            /*
             * Note: This will not check the reference age ifdef
             * HEAP_REPLACEMENT, but it does some other useful
             * checks...
             */
            expired++;
            debug(20, 3) ("Released store object age %f size %d refs %d key %s\n",
                age, e->swap_file_sz, e->refcount, storeKeyText(e->key));
            min_age = age;
            storeRelease(e);
        } else {
            /*
             * Did not expire the object so we need to add it back
             * into the heap!
             */
            debug(20, 5) ("storeMaintainSwapSpace: non-expired %s\n",
                storeKeyText(e->key));
            linklistPush(&locked_entries, e);
            continue;
        }
        if (store_swap_size < store_swap_low)
            break;
        else if (expired >= max_remove)
            break;
        else if (scanned >= max_scan)
            break;
    }
    /*
     * Bump the heap age factor.
     */
    if (min_age > 0.0)
        SD->repl.heap.heap->age = min_age;
    /*
     * Reinsert all bumped locked entries back into heap...
     */
    while ((e = linklistShift(&locked_entries)))
        e->repl.node = heap_insert(SD->repl.heap.heap, e);
#else
    for (m = SD->repl.lru.list.tail; m; m = prev) {
        prev = m->prev;
        e = m->data;
        scanned++;
        if (storeEntryLocked(e)) {
            /*
             * If there is a locked entry at the tail of the LRU list,
             * move it to the beginning to get it out of the way.
             * Theoretically, we might have all locked objects at the
             * tail, and then we'll never remove anything here and the
             * LRU age will go to zero.
             */
            if (memInUse(MEM_STOREENTRY) > max_scan) {
                dlinkDelete(&e->repl.lru, &SD->repl.lru.list);
                dlinkAdd(e, &e->repl.lru, &SD->repl.lru.list);
            }
            locked++;

        } else if (storeDiskdDirCheckExpired(SD, e)) {
            expired++;
            storeRelease(e);
        }
        if (expired >= max_remove)
            break;
        if (scanned >= max_scan)
            break;
    }
#endif
    debug(20, (expired ? 2 : 3)) ("storeMaintainSwapSpace: scanned %d/%d removed %d/%d l
ocked %d f=%.03f\n",
        scanned, max_scan, expired, max_remove, locked, f);
    debug(20, 3) ("storeMaintainSwapSpace stats:\n");
    debug(20, 3) ("  %6d objects\n", memInUse(MEM_STOREENTRY));
    debug(20, 3) ("  %6d were scanned\n", scanned);
    debug(20, 3) ("  %6d were locked\n", locked);
    debug(20, 3) ("  %6d were expired\n", expired);
    if (store_swap_size < Config.Swap.maxSize)
        return;
    if (squid_curtime - last_warn_time < 10)
        return;
    debug(20, 0) ("WARNING: Disk space over limit: %d KB > %d KB\n",
        store_swap_size, Config.Swap.maxSize);
    last_warn_time = squid_curtime;
}

/*
 * storeDiskdDirCheckObj
 *
 * This routine is called by storeDirSelectSwapDir to see if the given
 * object is able to be stored on this filesystem. DISKD filesystems will
 * happily store anything as long as the LRU time isn't too small.
 */
int
storeDiskdDirCheckObj(SwapDir *SD, const StoreEntry *e)
{
    int loadav;

    diskdinfo_t *diskdinfo = (diskdinfo_t *)SD->fsdata;
#if !HEAP_REPLACEMENT
    if (storeDiskdDirExpiredReferenceAge(SD) < 300) {
        debug(20, 3) ("storeDiskdDirCheckObj: NO: LRU Age = %d\n",
            storeDiskdDirExpiredReferenceAge(SD));
        /* store_check_cachable_hist.no.lru_age_too_low++; */
        return -1;
    }
#endif

    /* Check the queue length */
    if (diskdinfo->away >= diskdinfo->magic1)
        return -1;

    /* Calculate the storedir load relative to magic2 on a scale of 0 .. 1000 */
    if (diskdinfo->away == 0)
        loadav = 0;
    else
        loadav = diskdinfo->magic2 * 1000 / diskdinfo->away;
    return loadav;
}

/*
 * storeDiskdDirRefObj
 *
 * This routine is called whenever an object is referenced, so we can
 * maintain replacement information within the storage fs.
 */
void
storeDiskdDirRefObj(SwapDir *SD, StoreEntry *e)
{
    debug(1, 3) ("storeDiskdDirRefObj: referencing %p %d/%d\n", e, e->swap_dirn,
      e->swap_filen);
#if HEAP_REPLACEMENT
    /* Nothing to do here */
#else
    /* Reference the object */
    if (!EBIT_TEST(e->flags, RELEASE_REQUEST) &&
        !EBIT_TEST(e->flags, ENTRY_SPECIAL)) {
        dlinkDelete(&e->repl.lru, &SD->repl.lru.list);
        dlinkAdd(e, &e->repl.lru, &SD->repl.lru.list);
    }
#endif
}

/*
 * storeDiskdDirUnrefObj
 * This routine is called whenever the last reference to an object is
 * removed, to maintain replacement information within the storage fs.
 */
void
storeDiskdDirUnrefObj(SwapDir *SD, StoreEntry *e)
{
    debug(1, 3) ("storeDiskdDirUnrefObj: referencing %p %d/%d\n", e,
      e->swap_dirn, e->swap_filen);
#if HEAP_REPLACEMENT
    if (e->repl.node)
        heap_update(SD->repl.heap.heap, e->repl.node, e);
#endif
}

/*
 * storeDiskdDirUnlinkFile
 *
 * This is a *synchronous* unlink which is currently used in the rebuild
 * process. This is bad, but it'll have to stay until the dir rebuild
 * uses storeDiskdUnlink() ..
 */
void
storeDiskdDirUnlinkFile(SwapDir *SD, sfileno f)
{
    debug(79, 3) ("storeDiskdDirUnlinkFile: unlinking fileno %08X\n", f);
    storeDiskdDirMapBitReset(SD, f);
    unlinkdUnlink(storeDiskdDirFullPath(SD, f, NULL));
}

#if !HEAP_REPLACEMENT
/*
 * storeDiskdDirExpiredReferenceAge
 *
 * The LRU age is scaled exponentially between 1 minute and
 * Config.referenceAge , when store_swap_low < store_swap_size <
 * store_swap_high.  This keeps store_swap_size within the low and high
 * water marks.  If the cache is very busy then store_swap_size stays
 * closer to the low water mark, if it is not busy, then it will stay
 * near the high water mark.  The LRU age value can be examined on the
 * cachemgr 'info' page.
 */
static time_t
storeDiskdDirExpiredReferenceAge(SwapDir *SD)
{
    double x;
    double z;
    time_t age;
    long store_high, store_low;
 
    store_high = (long) (((float) SD->max_size *
            (float) Config.Swap.highWaterMark) / (float) 100);
    store_low = (long) (((float) SD->max_size *
            (float) Config.Swap.lowWaterMark) / (float) 100);
    debug(20, 20) ("RA: Dir %s, hi=%d, lo=%d, cur=%d\n", SD->path, store_high, store_low, SD->cur_size);
  
    x = (double) (store_high - SD->cur_size) /
        (store_high - store_low);
    x = x < 0.0 ? 0.0 : x > 1.0 ? 1.0 : x;
    z = pow((double) (Config.referenceAge / 60), x);
    age = (time_t) (z * 60.0);
    if (age < 60)
        age = 60;
    else if (age > Config.referenceAge)
        age = Config.referenceAge;
    return age;
}
#endif

/*
 * storeDiskdDirCheckExpired
 *
 * Check whether the given object is expired or not
 * It breaks layering a little by calling the upper layers to find
 * out whether the object is locked or not, but we can't help this
 * right now.
 */
static int
storeDiskdDirCheckExpired(SwapDir *SD, StoreEntry *e)
{
    if (storeEntryLocked(e))
       return 0;
    if (EBIT_TEST(e->flags, RELEASE_REQUEST))
       return 1;
    if (EBIT_TEST(e->flags, ENTRY_NEGCACHED) && squid_curtime >= e->expires)
       return 1;

#if HEAP_REPLACEMENT
    /*
     * with HEAP_REPLACEMENT we are not using the LRU reference age, the heap
     * controls the replacement of objects.
     */
    return 1;
#else
    if (squid_curtime - e->lastref > storeDiskdDirExpiredReferenceAge(SD))
       return 1;
    return 0;
#endif
}

/*
 * Add and remove the given StoreEntry from the replacement policy in
 * use.
 */

void
storeDiskdDirReplAdd(SwapDir *SD, StoreEntry *e)
{
    debug(20, 4) ("storeDiskdDirReplAdd: added node %p to dir %d\n", e,
      SD->index);
#if HEAP_REPLACEMENT
    if (EBIT_TEST(e->flags, ENTRY_SPECIAL)) {
        (void) 0;
    } else {
        e->repl.node = heap_insert(SD->repl.heap.heap, e);
        debug(20, 4) ("storeDiskdDirReplAdd: inserted node 0x%x\n", e->repl.node);
    }
#else
    /* Shouldn't we not throw special objects into the lru ? */
    dlinkAdd(e, &e->repl.lru, &SD->repl.lru.list);
#endif
}


void
storeDiskdDirReplRemove(StoreEntry *e)
{
    SwapDir *SD = INDEXSD(e->swap_dirn);
    debug(20, 4) ("storeDiskdDirReplRemove: remove node %p from dir %d\n", e,
      SD->index);
#if HEAP_REPLACEMENT
    /* And now, release the object from the replacement policy */
    if (e->repl.node) {
        debug(20, 4) ("storeDiskdDirReplRemove: deleting node 0x%x\n",
          e->repl.node);
        heap_delete(SD->repl.heap.heap, e->repl.node);
        e->repl.node = NULL;
    }
#else
    dlinkDelete(&e->repl.lru, &SD->repl.lru.list);
#endif
}



/*
 * SHM manipulation routines
 */

void *
storeDiskdShmGet(SwapDir * sd, int *shm_offset)
{
    char *buf;
    diskdinfo_t *diskdinfo = (diskdinfo_t *)sd->fsdata;
    buf = linklistShift(&diskdinfo->shm.stack);
    assert(buf);
    *shm_offset = buf - diskdinfo->shm.buf;
    assert(0 <= *shm_offset && *shm_offset < SHMBUFS * SHMBUF_BLKSZ);
    diskd_stats.shmbuf_count++;
    return buf;
}

void
storeDiskdShmPut(SwapDir * sd, int offset)
{
    char *buf;
    diskdinfo_t *diskdinfo = (diskdinfo_t *)sd->fsdata;
    assert(offset >= 0);
    assert(offset < SHMBUFS * SHMBUF_BLKSZ);
    buf = diskdinfo->shm.buf + offset;
    linklistPush(&diskdinfo->shm.stack, buf);
    diskd_stats.shmbuf_count--;
}




/* ========== LOCAL FUNCTIONS ABOVE, GLOBAL FUNCTIONS BELOW ========== */

void
storeDiskdDirStats(SwapDir *SD, StoreEntry * sentry)
{
    diskdinfo_t *diskdinfo;
#if HAVE_STATVFS
    struct statvfs sfs;
#endif
    diskdinfo = (diskdinfo_t *)SD->fsdata;
    storeAppendPrintf(sentry, "First level subdirectories: %d\n", diskdinfo->l1);
    storeAppendPrintf(sentry, "Second level subdirectories: %d\n", diskdinfo->l2);
    storeAppendPrintf(sentry, "Maximum Size: %d KB\n", SD->max_size);
    storeAppendPrintf(sentry, "Current Size: %d KB\n", SD->cur_size);
    storeAppendPrintf(sentry, "Percent Used: %0.2f%%\n",
        100.0 * SD->cur_size / SD->max_size);
    storeAppendPrintf(sentry, "Filemap bits in use: %d of %d (%d%%)\n",
    diskdinfo->map->n_files_in_map, diskdinfo->map->max_n_files,
    percent(diskdinfo->map->n_files_in_map, diskdinfo->map->max_n_files));
#if HAVE_STATVFS
#define fsbtoblk(num, fsbs, bs) \
    (((fsbs) != 0 && (fsbs) < (bs)) ? \
            (num) / ((bs) / (fsbs)) : (num) * ((fsbs) / (bs)))
        if (!statvfs(SD->path, &sfs)) {
            storeAppendPrintf(sentry, "Filesystem Space in use: %d/%d KB (%d%%)\n",
            fsbtoblk((sfs.f_blocks - sfs.f_bfree), sfs.f_frsize, 1024),
            fsbtoblk(sfs.f_blocks, sfs.f_frsize, 1024),
            percent(sfs.f_blocks - sfs.f_bfree, sfs.f_blocks));
            storeAppendPrintf(sentry, "Filesystem Inodes in use: %d/%d (%d%%)\n",
            sfs.f_files - sfs.f_ffree, sfs.f_files,
            percent(sfs.f_files - sfs.f_ffree, sfs.f_files));
    }
#endif
    storeAppendPrintf(sentry, "Flags:");
    if (SD->flags.selected)
        storeAppendPrintf(sentry, " SELECTED");
    if (SD->flags.read_only)
        storeAppendPrintf(sentry, " READ-ONLY");
    storeAppendPrintf(sentry, "\n");
#if !HEAP_REPLACEMENT
    storeAppendPrintf(sentry, "LRU Expiration Age: %6.2f days\n",
      (double) storeDiskdDirExpiredReferenceAge(SD) / 86400.0); 
#else
#if 0
    storeAppendPrintf(sentry, "Storage Replacement Threshold:\t%f\n",
        heap_peepminkey(sd.repl.heap.heap));
#endif
#endif
    storeAppendPrintf(sentry, "Pending operations: %d\n", diskdinfo->away);
}

/*
 * storeDiskdDirReconfigure
 *
 * This routine is called when the given swapdir needs reconfiguring 
 */
void
storeDiskdDirReconfigure(SwapDir *sd, int index, char *path)
{
    char *token;
    int i;
    int size;
    int l1;
    int l2;
    int magic1, magic2;
    unsigned int read_only = 0;
    diskdinfo_t *diskdinfo;

    i = GetInteger();
    size = i << 10;             /* Mbytes to kbytes */
    if (size <= 0)
        fatal("storeDiskdDirReconfigure: invalid size value");
    i = GetInteger();
    l1 = i;
    if (l1 <= 0)
        fatal("storeDiskdDirReconfigure: invalid level 1 directories value");
    i = GetInteger();
    l2 = i;
    if (l2 <= 0)
        fatal("storeDiskdDirReconfigure: invalid level 2 directories value");
    i = GetInteger();
    magic1 = i;
    if (magic1 <= 0)
        fatal("storeDiskdDirParse: invalid magic1 value");
    i = GetInteger();
    magic2 = i;
    if (magic2 <= 0)
        fatal("storeDiskdDirParse: invalid magic2 value");
    if ((token = strtok(NULL, w_space)))
        if (!strcasecmp(token, "read-only"))
            read_only = 1;

    /* just reconfigure it */
    if (size == sd->max_size)
        debug(3, 1) ("Cache dir '%s' size remains unchanged at %d KB\n",
            path, size);
    else
        debug(3, 1) ("Cache dir '%s' size changed to %d KB\n",
            path, size);
    sd->max_size = size;
    if (sd->flags.read_only != read_only)
        debug(3, 1) ("Cache dir '%s' now %s\n",
            path, read_only ? "Read-Only" : "Read-Write");
    diskdinfo = (diskdinfo_t *)sd->fsdata;
    diskdinfo->magic1 = magic1;
    diskdinfo->magic2 = magic2;
    sd->flags.read_only = read_only;
    return;
}

void
storeDiskdDirDump(StoreEntry * entry, const char *name, SwapDir * s)
{
    diskdinfo_t *diskdinfo = (diskdinfo_t *)s->fsdata;
    storeAppendPrintf(entry, "%s %s %s %d %d %d\n",
        name,
        "diskd",
        s->path,
        s->max_size >> 10,
        diskdinfo->l1,
        diskdinfo->l2);
}

/*
 * Only "free" the filesystem specific stuff here
 */
static void
storeDiskdDirFree(SwapDir * s)
{
    diskdinfo_t *diskdinfo = (diskdinfo_t *)s->fsdata;
    if (diskdinfo->swaplog_fd > -1) {
        file_close(diskdinfo->swaplog_fd);
        diskdinfo->swaplog_fd = -1;
    }
    filemapFreeMemory(diskdinfo->map);
    xfree(diskdinfo);
    s->fsdata = NULL; /* Will aid debugging... */

}

char *
storeDiskdDirFullPath(SwapDir *SD, sfileno filn, char *fullpath)
{
    LOCAL_ARRAY(char, fullfilename, SQUID_MAXPATHLEN);
    diskdinfo_t *diskdinfo = (diskdinfo_t *)SD->fsdata;
    int L1 = diskdinfo->l1;
    int L2 = diskdinfo->l2;
    if (!fullpath)
        fullpath = fullfilename;
    fullpath[0] = '\0';
    snprintf(fullpath, SQUID_MAXPATHLEN, "%s/%02X/%02X/%08X",
        SD->path,
        ((filn / L2) / L2) % L1,
        (filn / L2) % L2,
        filn);
    return fullpath;
}

/*
 * storeDiskdCleanupDoubleCheck
 *
 * This is called by storeCleanup() if -S was given on the command line.
 */
static int
storeDiskdCleanupDoubleCheck(SwapDir *sd, StoreEntry *e)
{
    struct stat sb;

    if (stat(storeDiskdDirFullPath(sd, e->swap_filen, NULL), &sb) < 0) {
        debug(20, 0) ("storeDiskdCleanupDoubleCheck: MISSING SWAP FILE\n");
        debug(20, 0) ("storeDiskdCleanupDoubleCheck: FILENO %08X\n", e->swap_filen);
        debug(20, 0) ("storeDiskdCleanupDoubleCheck: PATH %s\n",
            storeDiskdDirFullPath(sd, e->swap_filen, NULL));
        storeEntryDump(e, 0);
        return -1;
    }       
    if (e->swap_file_sz != sb.st_size) {
        debug(20, 0) ("storeDiskdCleanupDoubleCheck: SIZE MISMATCH\n");
        debug(20, 0) ("storeDiskdCleanupDoubleCheck: FILENO %08X\n", e->swap_filen);
        debug(20, 0) ("storeDiskdCleanupDoubleCheck: PATH %s\n",
            storeDiskdDirFullPath(sd, e->swap_filen, NULL));
        debug(20, 0) ("storeDiskdCleanupDoubleCheck: ENTRY SIZE: %d, FILE SIZE: %d\n",
            e->swap_file_sz, (int) sb.st_size); 
        storeEntryDump(e, 0); 
        return -1;
    }       
    return 0;
}

/*
 * storeDiskdDirParse
 *
 * Called when a *new* fs is being setup.
 */
void
storeDiskdDirParse(SwapDir *sd, int index, char *path)
{
    char *token;
    int i;
    int size;
    int l1;
    int l2;
    int magic1, magic2;
    unsigned int read_only = 0;
    diskdinfo_t *diskdinfo;

    i = GetInteger();
    size = i << 10;             /* Mbytes to kbytes */
    if (size <= 0)
        fatal("storeDiskdDirParse: invalid size value");
    i = GetInteger();
    l1 = i;
    if (l1 <= 0)
        fatal("storeDiskdDirParse: invalid level 1 directories value");
    i = GetInteger();
    l2 = i;
    if (l2 <= 0)
        fatal("storeDiskdDirParse: invalid level 2 directories value");
    i = GetInteger();
    magic1 = i;
    if (magic1 <= 0)
        fatal("storeDiskdDirParse: invalid magic1 value");
    i = GetInteger();
    magic2 = i;
    if (magic2 <= 0)
        fatal("storeDiskdDirParse: invalid magic2 value");


    if ((token = strtok(NULL, w_space)))
        if (!strcasecmp(token, "read-only"))
            read_only = 1;

    diskdinfo = xmalloc(sizeof(diskdinfo_t));
    if (diskdinfo == NULL)
        fatal("storeDiskdDirParse: couldn't xmalloc() diskdinfo_t!\n");

    sd->index = index;
    sd->path = xstrdup(path);
    sd->max_size = size;
    sd->fsdata = diskdinfo;
    diskdinfo->l1 = l1;
    diskdinfo->l2 = l2;
    diskdinfo->swaplog_fd = -1;
    diskdinfo->map = NULL; /* Debugging purposes */
    diskdinfo->suggest = 0;
    diskdinfo->magic1 = magic1;
    diskdinfo->magic2 = magic2;
    sd->flags.read_only = read_only;
    sd->init = storeDiskdDirInit;
    sd->newfs = storeDiskdDirNewfs;
    sd->dump = storeDiskdDirDump;
    sd->freefs = storeDiskdDirFree;
    sd->dblcheck = storeDiskdCleanupDoubleCheck;
    sd->statfs = storeDiskdDirStats;
    sd->maintainfs = storeDiskdDirMaintain;
    sd->checkobj = storeDiskdDirCheckObj;
    sd->refobj = storeDiskdDirRefObj;
    sd->unrefobj = storeDiskdDirUnrefObj;
    sd->callback = storeDiskdDirCallback;
    sd->sync = storeDiskdDirSync;
    sd->obj.create = storeDiskdCreate;
    sd->obj.open = storeDiskdOpen;
    sd->obj.close = storeDiskdClose;
    sd->obj.read = storeDiskdRead;
    sd->obj.write = storeDiskdWrite;
    sd->obj.unlink = storeDiskdUnlink;
    sd->log.open = storeDiskdDirOpenSwapLog;
    sd->log.close = storeDiskdDirCloseSwapLog;
    sd->log.write = storeDiskdDirSwapLog;
    sd->log.clean.open = storeDiskdDirWriteCleanOpen;

    /* Initialise replacement policy stuff */
#if HEAP_REPLACEMENT
    /*
     * Create new heaps with cache replacement policies attached to them.
     * The cache replacement policy is specified as either GDSF or LFUDA in
     * the squid.conf configuration file.  Note that the replacement policy
     * applies only to the disk replacement algorithm.  Memory replacement
     * always uses GDSF since we want to maximize object hit rate.
     */
    if (Config.replPolicy) {
        if (tolower(Config.replPolicy[0]) == 'g') {
            debug(20, 1) ("Using GDSF disk replacement policy\n");
            sd->repl.heap.heap = new_heap(10000, HeapKeyGen_StoreEntry_GDSF);
        } else if (tolower(Config.replPolicy[0]) == 'l') {
            if (tolower(Config.replPolicy[1]) == 'f') {
                debug(20, 1) ("Using LFUDA disk replacement policy\n");
                sd->repl.heap.heap = new_heap(10000, HeapKeyGen_StoreEntry_LFUDA);
            } else if (tolower(Config.replPolicy[1]) == 'r') {
                debug(20, 1) ("Using LRU heap disk replacement policy\n");
                sd->repl.heap.heap = new_heap(10000, HeapKeyGen_StoreEntry_LRU);
            }
        } else {
            debug(20, 1) ("Unrecognized replacement_policy; using GDSF\n");
            sd->repl.heap.heap = new_heap(10000, HeapKeyGen_StoreEntry_GDSF);
        }
    } else {
        debug(20, 1) ("Using default disk replacement policy (GDSF)\n");
        sd->repl.heap.heap = new_heap(10000, HeapKeyGen_StoreEntry_GDSF);
    }
#else
    sd->repl.lru.list.head = NULL;
    sd->repl.lru.list.tail = NULL;
#endif
}

/*
 * Initial setup / end destruction
 */
void
storeDiskdDirDone(void)
{
    memPoolDestroy(diskd_state_pool);
    diskd_initialised = 0;
}

void
storeFsSetup_diskd(storefs_entry_t *storefs)
{
    assert(!diskd_initialised);
    storefs->parsefunc = storeDiskdDirParse;
    storefs->reconfigurefunc = storeDiskdDirReconfigure;
    storefs->donefunc = storeDiskdDirDone;
    diskd_state_pool = memPoolCreate("DISKD IO State data", sizeof(diskdstate_t));
    memset(&diskd_stats, '\0', sizeof(diskd_stats));
    cachemgrRegister("diskd", "DISKD Stats", storeDiskdStats, 0, 1);
    debug(81, 1) ("diskd started\n");
    diskd_initialised = 1;
}