/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*        All Rights Reserved   */

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#include "dump.h"
#include <sys/file.h>
#include <sys/mman.h>

static void lf_dmpindir(daddr32_t, int, u_offset_t *);
static void indir(daddr32_t, int, u_offset_t *);
static void lf_blksout(daddr32_t *, u_offset_t);
static void lf_dumpinode(struct dinode *);
static void dsrch(daddr32_t, ulong_t, u_offset_t);
void lf_dump(struct dinode *);

int     dadded;
int     nsubdir;
int     shortmeta;
static  char msgbuf[256];

void
pass(void (*fn)(struct dinode *), uchar_t *map)
{
        int bits;
        ino_t maxino;

        maxino = (unsigned)(sblock->fs_ipg * sblock->fs_ncg - 1);
        /*
         * Handle pass restarts.  We don't check for UFSROOTINO just in
         * case we need to restart on the root inode.
         */
        if (ino != 0) {
                bits = ~0;
                if (map != NULL) {
                        /* LINTED: lint seems to think map is signed */
                        map += (ino / NBBY);
                        bits = *map++;
                }
                bits >>= (ino % NBBY);
                resetino(ino);
                goto restart;
        }
        while (ino < maxino) {
                if ((ino % NBBY) == 0) {
                        bits = ~0;
                        if (map != NULL)
                                bits = *map++;
                }
restart:
                ino++;
                /*
                 * Ignore any inode less than UFSROOTINO and inodes that
                 * we have already done on a previous pass.
                 */
                if ((ino >= UFSROOTINO) && (bits & 1)) {
                        /*
                         * The following test is merely an optimization
                         * for common case where "add" will just return.
                         */
                        if (!(fn == add && BIT(ino, nodmap)))
                                (*fn)(getino(ino));
                }
                bits >>= 1;
        }
}

void
mark(struct dinode *ip)
{
        int f;

        f = ip->di_mode & IFMT;
        if (f == 0 || ip->di_nlink <= 0) {
                /* LINTED: 32-bit to 8-bit assignment ok */
                BIC(ino, clrmap);
                return;
        }
        /* LINTED: 32-bit to 8-bit assignment ok */
        BIS(ino, clrmap);
        if (f == IFDIR || f == IFATTRDIR) {
                /* LINTED: 32-bit to 8-bit assignment ok */
                BIS(ino, dirmap);
        }
        if (ip->di_ctime >= spcl.c_ddate) {
                if (f == IFSHAD)
                        return;
                /* LINTED: 32-bit to 8-bit assignment ok */
                BIS(ino, nodmap);
                /* attribute changes impact the root */
                if (f == IFATTRDIR)
                        BIS(UFSROOTINO, nodmap);
                if (f != IFREG && f != IFDIR && f != IFATTRDIR && f != IFLNK) {
                        o_esize += 1;
                        return;
                }
                est(ip);
        }
}

void
active_mark(struct dinode *ip)
{
        int f;

        f = ip->di_mode & IFMT;
        if (f == 0 || ip->di_nlink <= 0) {
                /* LINTED: 32-bit to 8-bit assignment ok */
                BIC(ino, clrmap);
                return;
        }
        /* LINTED: 32-bit to 8-bit assignment ok */
        BIS(ino, clrmap);
        if (f == IFDIR || f == IFATTRDIR) {
                /* LINTED: 32-bit to 8-bit assignment ok */
                BIS(ino, dirmap);
        }
        if (BIT(ino, activemap)) {
                /* LINTED: 32-bit to 8-bit assignment ok */
                BIS(ino, nodmap);
                /* attribute changes impact the root */
                if (f == IFATTRDIR)
                        BIS(UFSROOTINO, nodmap);
                if (f != IFREG && f != IFDIR && f != IFATTRDIR && f != IFLNK) {
                        o_esize += 1;
                        return;
                }
                est(ip);
        }
}

static struct shcount {
        struct shcount *higher, *lower;
        ino_t ino;
        unsigned long count;
} shcounts = {
        NULL, NULL,
        0,
        0
};
static struct shcount *shc = NULL;

void
markshad(struct dinode *ip)
{
        ino_t shadow;

        if (ip->di_shadow == 0)
                return;
        if (shc == NULL)
                shc = &shcounts;

        shadow = (ino_t)(unsigned)(ip->di_shadow);
        while ((shadow > shc->ino) && (shc->higher))
                shc = shc->higher;
        while ((shadow < shc->ino) && (shc->lower))
                shc = shc->lower;
        if (shadow != shc->ino) {
                struct shcount *new;

                new = (struct shcount *)xcalloc(1, sizeof (*new));
                new->higher = shc->higher;
                if (shc->higher != NULL)
                        shc->higher->lower = new;
                shc->higher = new;
                new->lower = shc;
                shc = new;
                shc->ino = shadow;
        }

        /* LINTED: 32-bit to 8-bit assignment ok */
        BIS(shadow, shamap);
        shc->count++;
}

void
estshad(struct dinode *ip)
{
        u_offset_t esizeprime;
        u_offset_t tmpesize;

        if (ip->di_size <= sizeof (union u_shadow))
                return;

        while ((ino > shc->ino) && (shc->higher))
                shc = shc->higher;
        while ((ino < shc->ino) && (shc->lower))
                shc = shc->lower;
        if (ino != shc->ino)
                return; /* xxx panic? complain? */

        tmpesize = (o_esize + f_esize);
        esizeprime = tmpesize;
        est(ip);
        esizeprime = tmpesize - esizeprime;
        esizeprime *= shc->count - 1;
        f_esize += esizeprime;
}

void
freeshad()
{
        if (shc == NULL)
                return;

        while (shc->higher)
                shc = shc->higher;
        while (shc->lower) {
                shc = shc->lower;
                if (shc->higher) /* else panic? */
                        (void) free(shc->higher);
        }
        /*
         * This should be unnecessary, but do it just to be safe.
         * Note that shc might be malloc'd or static, so can't free().
         */
        bzero(shc, sizeof (*shc));
}

void
add(struct dinode *ip)
{
        int i;
        u_offset_t filesize;

        if (BIT(ino, nodmap))
                return;
        if ((ip->di_mode & IFMT) != IFDIR &&
            (ip->di_mode & IFMT) != IFATTRDIR) {
                (void) snprintf(msgbuf, sizeof (msgbuf), gettext(
                    "Warning - directory at inode `%lu' vanished!\n"), ino);
                msg(msgbuf);
                /* LINTED: 32-bit to 8-bit assignment ok */
                BIC(ino, dirmap);
                return;
        }
        nsubdir = 0;
        dadded = 0;
        filesize = ip->di_size;
        for (i = 0; i < NDADDR; i++) {
                if (ip->di_db[i] != 0)
                        /* LINTED dblksize/blkoff does a safe cast here */
                        dsrch(ip->di_db[i], (ulong_t)dblksize(sblock, ip, i),
                            filesize);
                filesize -= (unsigned)(sblock->fs_bsize);
        }
        for (i = 0; i < NIADDR; i++) {
                if (ip->di_ib[i] != 0)
                        indir(ip->di_ib[i], i, &filesize);
        }
        if (dadded) {
                nadded++;
                if (!BIT(ino, nodmap)) {
                        /* LINTED: 32-bit to 8-bit assignment ok */
                        BIS(ino, nodmap);
                        if ((ip->di_mode & IFMT) == IFATTRDIR) {
                                /* attribute changes "auto-percolate" to root */
                                BIS(UFSROOTINO, nodmap);
                        }
                        est(ip);
                }
        }
        if (nsubdir == 0) {
                if (!BIT(ino, nodmap)) {
                        /* LINTED: 32-bit to 8-bit assignment ok */
                        BIC(ino, dirmap);
                }
        }
}

static void
indir(daddr32_t d, int n, u_offset_t *filesize)
{
        int i;
        daddr32_t idblk[MAXNINDIR];

        if ((unsigned)(sblock->fs_bsize) > sizeof (idblk)) {
                msg(gettext(
"Inconsistency detected: filesystem block size larger than valid maximum.\n"));
                dumpabort();
                /*NOTREACHED*/
        }

        if ((unsigned)NINDIR(sblock) > MAXNINDIR) {
                /*CSTYLED*/
                msg(gettext(
"Inconsistency detected: inode has more indirect \
blocks than valid maximum.\n"));
                dumpabort();
                /*NOTREACHED*/
        }

        if (dadded || *filesize == 0)
                return;

#ifdef  lint
        idblk[0] = '\0';
#endif  /* lint */

        /* xxx sanity check sblock contents before trusting them */
        bread(fsbtodb(sblock, d), (uchar_t *)idblk, (size_t)sblock->fs_bsize);
        if (n <= 0) {
                for (i = 0; i < NINDIR(sblock); i++) {
                        d = idblk[i];
                        if (d != 0)
                                dsrch(d, (ulong_t)(uint32_t)sblock->fs_bsize,
                                    *filesize);
                        *filesize -= (unsigned)(sblock->fs_bsize);
                }
        } else {
                n--;
                for (i = 0; i < NINDIR(sblock); i++) {
                        d = idblk[i];
                        if (d != 0)
                                indir(d, n, filesize);
                }
        }
}

void
dirdump(struct dinode *ip)
{
        /* watchout for dir inodes deleted and maybe reallocated */
        if (((ip->di_mode & IFMT) != IFDIR &&
            (ip->di_mode & IFMT) != IFATTRDIR) || ip->di_nlink < 2) {
                (void) snprintf(msgbuf, sizeof (msgbuf), gettext(
                    "Warning - directory at inode `%lu' vanished!\n"), ino);
                msg(msgbuf);
                return;
        }
        lf_dump(ip);
}

static u_offset_t loffset; /* current offset in file (ufsdump) */

static void
lf_dumpmeta(struct dinode *ip)
{
        if ((ip->di_shadow == 0) || shortmeta)
                return;

        lf_dumpinode(getino((ino_t)(unsigned)(ip->di_shadow)));
}

int
hasshortmeta(struct dinode **ip)
{
        ino_t savino;
        int rc;

        if ((*ip)->di_shadow == 0)
                return (0);
        savino = ino;
        *ip = getino((ino_t)(unsigned)((*ip)->di_shadow));
        rc = ((*ip)->di_size <= sizeof (union u_shadow));
        *ip = getino(ino = savino);
        return (rc);
}

void
lf_dumpinode(struct dinode *ip)
{
        int i;
        u_offset_t size;

        i = ip->di_mode & IFMT;

        if (i == 0 || ip->di_nlink <= 0)
                return;

        spcl.c_dinode = *ip;
        spcl.c_count = 0;

        if ((i != IFDIR && i != IFATTRDIR && i != IFREG && i != IFLNK &&
            i != IFSHAD) || ip->di_size == 0) {
                toslave(dospcl, ino);
                return;
        }

        size = NDADDR * (unsigned)(sblock->fs_bsize);
        if (size > ip->di_size)
                size = ip->di_size;

        lf_blksout(&ip->di_db[0], size);

        size = ip->di_size - size;
        if (size > 0) {
                for (i = 0; i < NIADDR; i++) {
                        lf_dmpindir(ip->di_ib[i], i, &size);
                        if (size == 0)
                                break;
                }
        }
}

void
lf_dump(struct dinode *ip)
{

        if ((!BIT(ino, nodmap)) && (!BIT(ino, shamap)))
                return;

        shortmeta = hasshortmeta(&ip);
        if (shortmeta) {
                ip = getino((ino_t)(unsigned)(ip->di_shadow));
                /* assume spcl.c_shadow is smaller than 1 block */
                bread(fsbtodb(sblock, ip->di_db[0]),
                    (uchar_t *)spcl.c_shadow.c_shadow, sizeof (spcl.c_shadow));
                spcl.c_flags |= DR_HASMETA;
        } else {
                spcl.c_flags &= ~DR_HASMETA;
        }
        ip = getino(ino);

        loffset = 0;

        if (newtape) {
                spcl.c_type = TS_TAPE;
        } else if (pos)
                spcl.c_type = TS_ADDR;
        else
                spcl.c_type = TS_INODE;

        newtape = 0;
        lf_dumpinode(ip);
        lf_dumpmeta(ip);
        pos = 0;
}

static void
lf_dmpindir(daddr32_t blk, int lvl, u_offset_t *size)
{
        int i;
        u_offset_t cnt;
        daddr32_t idblk[MAXNINDIR];

        if ((unsigned)(sblock->fs_bsize) > sizeof (idblk)) {
                msg(gettext(
"Inconsistency detected: filesystem block size larger than valid maximum.\n"));
                dumpabort();
                /*NOTREACHED*/
        }

        if ((unsigned)NINDIR(sblock) > MAXNINDIR) {
                msg(gettext(
"Inconsistency detected: inode has more indirect \
blocks than valid maximum.\n"));
                dumpabort();
                /*NOTREACHED*/
        }

        if (blk != 0)
                bread(fsbtodb(sblock, blk), (uchar_t *)idblk,
                    (size_t)sblock->fs_bsize);
        else
                bzero((char *)idblk, (size_t)sblock->fs_bsize);
        if (lvl <= 0) {
                cnt = (u_offset_t)(unsigned)NINDIR(sblock) *
                    (u_offset_t)(unsigned)(sblock->fs_bsize);
                if (cnt > *size)
                        cnt = *size;
                *size -= cnt;
                lf_blksout(&idblk[0], cnt);
                return;
        }
        lvl--;
        for (i = 0; i < NINDIR(sblock); i++) {
                lf_dmpindir(idblk[i], lvl, size);
                if (*size == 0)
                        return;
        }
}

static void
lf_blksout(daddr32_t *blkp, u_offset_t bytes)
{
        u_offset_t i;
        u_offset_t tbperfsb = (unsigned)(sblock->fs_bsize / tp_bsize);

        u_offset_t j, k, count;

        u_offset_t bytepos, diff;
        u_offset_t bytecnt = 0;
        off_t byteoff = 0;      /* bytes to skip within first f/s block */
        off_t fragoff = 0;      /* frags to skip within first f/s block */

        u_offset_t tpblkoff = 0; /* tape blocks to skip in first f/s block */
        u_offset_t tpblkskip = 0;       /* total tape blocks to skip  */
        u_offset_t skip;                /* tape blocks to skip this pass */

        if (pos) {
                /*
                 * We get here if a slave throws a signal to the
                 * master indicating a partially dumped file.
                 * Begin by figuring out what was undone.
                 */
                bytepos = (offset_t)pos * tp_bsize;

                if ((loffset + bytes) <= bytepos) {
                        /* This stuff was dumped already, forget it. */
                        loffset += (u_offset_t)tp_bsize *
                            /* LINTED: spurious complaint on sign-extending */
                            d_howmany(bytes, (u_offset_t)tp_bsize);
                        return;
                }

                if (loffset < bytepos) {
                        /*
                         * Some of this was dumped, some wasn't.
                         * Figure out what was done and skip it.
                         */
                        diff = bytepos - loffset;
                        /* LINTED: spurious complaint on sign-extending */
                        tpblkskip = d_howmany(diff, (u_offset_t)tp_bsize);
                        /* LINTED room after EOT is only a few MB */
                        blkp += (int)(diff / sblock->fs_bsize);

                        bytecnt = diff % (unsigned)(sblock->fs_bsize);
                        /* LINTED: result fits, due to modulus */
                        byteoff = bytecnt % (off_t)(sblock->fs_fsize);
                        /* LINTED: spurious complaint on sign-extending */
                        tpblkoff = d_howmany(bytecnt,
                            (u_offset_t)(unsigned)tp_bsize);
                        /* LINTED: result fits, due to modulus */
                        fragoff = bytecnt / (off_t)(sblock->fs_fsize);
                        bytecnt = (unsigned)(sblock->fs_bsize) - bytecnt;
                }
        }

        loffset += bytes;

        while (bytes > 0) {
                if (bytes < TP_NINDIR*tp_bsize)
                        /* LINTED: spurious complaint on sign-extending */
                        count = d_howmany(bytes, (u_offset_t)tp_bsize);
                else
                        count = TP_NINDIR;
                if (tpblkskip) {
                        if (tpblkskip < TP_NINDIR) {
                                bytes -= (tpblkskip * (u_offset_t)tp_bsize);
                                skip = tpblkskip;
                                tpblkskip = 0;
                        } else {
                                bytes -= (offset_t)TP_NINDIR*tp_bsize;
                                tpblkskip -= TP_NINDIR;
                                continue;
                        }
                } else
                        skip = 0;
                assert(tbperfsb >= tpblkoff);
                assert((count - skip) <= TP_NINDIR);
                for (j = 0, k = 0; j < count - skip; j++, k++) {
                        spcl.c_addr[j] = (blkp[k] != 0);
                        for (i = tbperfsb - tpblkoff; --i > 0; j++)
                                spcl.c_addr[j+1] = spcl.c_addr[j];
                        tpblkoff = 0;
                }
                /* LINTED (count - skip) will always fit into an int32_t */
                spcl.c_count = count - skip;
                toslave(dospcl, ino);
                bytecnt = MIN(bytes, bytecnt ?
                    bytecnt : (unsigned)(sblock->fs_bsize));
                j = 0;
                while (j < count - skip) {
                        if (*blkp != 0) {
                                /* LINTED: fragoff fits into 32 bits */
                                dmpblk(*blkp+(int32_t)fragoff,
                                    /* LINTED: bytecnt fits into 32 bits */
                                    (size_t)bytecnt, byteoff);
                        }
                        blkp++;
                        bytes -= bytecnt;
                        /* LINTED: spurious complaint on sign-extending */
                        j += d_howmany(bytecnt, (u_offset_t)tp_bsize);
                        bytecnt = MIN(bytes, (unsigned)(sblock->fs_bsize));
                        byteoff = 0;
                        fragoff = 0;
                }
                spcl.c_type = TS_ADDR;
                bytecnt = 0;
        }
        pos = 0;
}

void
bitmap(uchar_t *map, int typ)
{
        int i;
        u_offset_t count;
        uchar_t *cp;

        if (!newtape)
                spcl.c_type = typ;
        else
                newtape = 0;
        for (i = 0; i < TP_NINDIR; i++)
                spcl.c_addr[i] = 1;
        /* LINTED: spurious complaint on sign-extending */
        count = d_howmany(msiz * sizeof (map[0]), tp_bsize) - pos;
        for (cp = &map[pos * tp_bsize]; count > 0;
            count -= (u_offset_t)(unsigned)spcl.c_count) {
                if (leftover) {
                        spcl.c_count = leftover;
                        leftover = 0;
                } else {
                        /* LINTED value always less than INT32_MAX */
                        spcl.c_count = count > TP_NINDIR ? TP_NINDIR : count;
                }
                spclrec();
                for (i = 0; i < spcl.c_count; i++, cp += tp_bsize)
                        taprec(cp, 0, tp_bsize);
                spcl.c_type = TS_ADDR;
        }
}

static void
dsrch(daddr32_t d, ulong_t size, u_offset_t filesize)
{
        struct direct *dp;
        struct dinode *ip;
        ulong_t loc;
        char dblk[MAXBSIZE];

        if (dadded || filesize == 0)
                return;
        if (filesize > (u_offset_t)size)
                filesize = (u_offset_t)size;
        if (sizeof (dblk) < roundup(filesize, DEV_BSIZE)) {
                msg(gettext(
"Inconsistency detected: filesystem block size larger than valid maximum.\n"));
                dumpabort();
                /*NOTREACHED*/
        }

#ifdef  lint
        dblk[0] = '\0';
#endif  /* lint */

        /* LINTED ufs disk addresses always fit into 32 bits */
        bread(fsbtodb(sblock, d), (uchar_t *)dblk,
            /* LINTED from sizeof check above, roundup() <= max(size_t) */
            (size_t)(roundup(filesize, DEV_BSIZE)));
        loc = 0;
        while ((u_offset_t)loc < filesize) {
                /*LINTED [dblk is char[], loc (dp->d_reclen) % 4 == 0]*/
                dp = (struct direct *)(dblk + loc);
                if (dp->d_reclen == 0) {
                        (void) snprintf(msgbuf, sizeof (msgbuf), gettext(
                            "Warning - directory at inode `%lu' is "
                            "corrupted\n"), ino);
                        msg(msgbuf);
                        break;
                }
                loc += dp->d_reclen;
                if (dp->d_ino == 0)
                        continue;
                if (dp->d_name[0] == '.') {
                        if (dp->d_name[1] == '\0') {
                                if ((ino_t)(dp->d_ino) != ino) {
                                        (void) snprintf(msgbuf, sizeof (msgbuf),
                                            gettext(
                        "Warning - directory at inode `%lu' is corrupted:\n\
\t\".\" points to inode `%lu' - run fsck\n"),
                                            ino, dp->d_ino);
                                        msg(msgbuf);
                                }
                                continue;
                        }
                        if (dp->d_name[1] == '.' && dp->d_name[2] == '\0') {
                                if (!BIT(dp->d_ino, dirmap) &&
                                    ((ip = getino(ino)) == NULL ||
                                    (ip->di_mode & IFMT) != IFATTRDIR)) {
                                        (void) snprintf(msgbuf, sizeof (msgbuf),
                                            gettext(
                        "Warning - directory at inode `%lu' is corrupted:\n\
\t\"..\" points to non-directory inode `%lu' - run fsck\n"),
                                            ino, dp->d_ino);
                                        msg(msgbuf);
                                }
                                continue;
                        }
                }
                if (BIT(dp->d_ino, nodmap)) {
                        dadded++;
                        return;
                }
                if (BIT(dp->d_ino, dirmap))
                        nsubdir++;
        }
}

#define CACHESIZE 32

struct dinode *
getino(ino_t ino)
{
        static ino_t minino, maxino;
        static struct dinode itab[MAXINOPB];
        static struct dinode icache[CACHESIZE];
        static ino_t icacheval[CACHESIZE], lasti = 0;
        static int cacheoff = 0;
        int i;

        if (ino >= minino && ino < maxino) {
                lasti = ino;
                return (&itab[ino - minino]);
        }

        /* before we do major i/o, check for a secondary cache hit */
        for (i = 0; i < CACHESIZE; i++)
                if (icacheval[i] == ino)
                        return (icache + i);

        /* we need to do major i/o.  throw the last inode retrieved into */
        /* the cache.  note: this copies garbage the first time it is    */
        /* used, but no harm done.                                       */
        icacheval[cacheoff] = lasti;
        bcopy(itab + (lasti - minino), icache + cacheoff, sizeof (itab[0]));
        lasti = ino;
        if (++cacheoff >= CACHESIZE)
                cacheoff = 0;

#define INOPERDB (DEV_BSIZE / sizeof (struct dinode))
        minino = ino &~ (INOPERDB - 1);
        maxino = ((itog(sblock, ino) + 1) * (unsigned)(sblock->fs_ipg));
        if (maxino > minino + MAXINOPB)
                maxino = minino + MAXINOPB;
        bread(
            /* LINTED: can't make up for broken system macros here */
            (fsbtodb(sblock, itod(sblock, ino)) + itoo(sblock, ino) / INOPERDB),
            /* LINTED: (max - min) * size fits into a size_t */
            (uchar_t *)itab, (size_t)((maxino - minino) * sizeof (*itab)));
        return (&itab[ino - minino]);
}

#define BREADEMAX 32

#ifdef NO__LONGLONG__
#define DEV_LSEEK(fd, offset, whence) \
        lseek((fd), (((off_t)(offset))*DEV_BSIZE), (whence))
#else
#define DEV_LSEEK(fd, offset, whence) \
        llseek((fd), (((offset_t)((offset)))*DEV_BSIZE), (whence))
#endif

#define BREAD_FAIL(buf, size)   { \
                breaderrors += 1; \
                bzero(buf, (size_t)size); \
        }



void
bread(diskaddr_t da, uchar_t *ba, size_t cnt)
{
        caddr_t maddr;
        uchar_t *dest;
        int saverr;
        int n;
        size_t len;
        off64_t filoff;
        off64_t mapoff;
        off64_t displacement;

        static size_t pagesize = 0;
        static int breaderrors = 0;

        /* mechanics for caching small bread requests.  these are */
        /* often small ACLs that are used over and over.          */
        static uchar_t bcache[DEV_BSIZE * CACHESIZE];
        static diskaddr_t bcacheval[CACHESIZE];
        static int cacheoff = 0;
        int i;

        if ((cnt >= DEV_BSIZE) && (mapfd != -1)) {
                if (pagesize == 0)
                        pagesize = getpagesize();
                /*
                 * We depend on mmap(2)'s guarantee that mapping a
                 * partial page will cause the remainder of the page
                 * to be zero-filled.
                 */
                filoff = ((off64_t)da) * DEV_BSIZE;
                displacement = filoff & (pagesize - 1);
                mapoff = filoff - displacement;
                /* LINTED offset will fit into 32 bits */
                len = (size_t)roundup(cnt + (filoff - mapoff), pagesize);
                maddr = mmap64(NULL, len, PROT_READ, MAP_SHARED, mapfd, mapoff);
                if (maddr != MAP_FAILED) {
                        (void) memcpy(ba, maddr + displacement, cnt);
                        (void) munmap(maddr, len);
                        return;
                }
        }

        if (DEV_LSEEK(fi, da, L_SET) < 0) {
                saverr = errno;
                msg(gettext("bread: dev_seek error: %s\n"), strerror(saverr));
                /* Don't know where we are, return the least-harmful data */
                BREAD_FAIL(ba, cnt);
                return;
        }

        if (read(fi, ba, (size_t)cnt) == (size_t)cnt)
                return;

        while (cnt != 0) {

                if (da >= fsbtodb(sblock, sblock->fs_size)) {
                        msg(gettext(
                            "Warning - block %llu is beyond the end of `%s'\n"),
                            da, disk);
                        BREAD_FAIL(ba, cnt);
                        break;
                }

                if (DEV_LSEEK(fi, da, L_SET) < 0) {
                        msg(gettext("%s: %s error\n"), "bread", "DEV_LSEEK2");
                        BREAD_FAIL(ba, cnt);
                        break;
                }

                if (cnt < DEV_BSIZE) {
                        /* small read.  check for cache hit. */
                        for (i = 0; i < CACHESIZE; i++)
                                if (bcacheval[i] == da) {
                                        bcopy(bcache + (i * DEV_BSIZE),
                                            ba, cnt);
                                        return;
                                }

                        /* no cache hit; throw this one into the cache... */
                        len = cnt;
                        dest = bcache + (cacheoff * DEV_BSIZE);
                        bcacheval[cacheoff] = da;
                        if (++cacheoff >= CACHESIZE)
                                cacheoff = 0;
                } else {
                        len = DEV_BSIZE;
                        dest = ba;
                }

                n = read(fi, dest, DEV_BSIZE);
                if (n != DEV_BSIZE) {
                        n = MAX(n, 0);
                        bzero(dest+n, DEV_BSIZE-n);
                        breaderrors += 1;
                        msg(gettext(
                            "Warning - cannot read sector %llu of `%s'\n"),
                            da, disk);
                }
                if (dest != ba)
                        bcopy(dest, ba, len);

                da++;
                /* LINTED character pointers aren't signed */
                ba += len;
                cnt -= len;
        }

        if (breaderrors > BREADEMAX) {
                msg(gettext(
                    "More than %d block read errors from dump device `%s'\n"),
                    BREADEMAX, disk);
                dumpailing();
                breaderrors = 0;
        }
}