#include <ubixos/types.h>
#include <ufs/ufs.h>
#include <string.h>
#include <lib/kprintf.h>

static int dskread(void *, unsigned, unsigned);

static int
dskread(void *buf, unsigned lba, unsigned nblk)
{
    struct dos_partition *dp;
    struct disklabel *d;
    char *sec;
    unsigned sl, i;

    if (!dsk_meta) {
        sec = dmadat->secbuf;
        dsk.start = 0;
        if (drvread(sec, DOSBBSECTOR, 1))
            return -1;
        dp = (void *)(sec + DOSPARTOFF);
        sl = dsk.slice;
        if (sl < BASE_SLICE) {
            for (i = 0; i < NDOSPART; i++)
                if (dp[i].dp_typ == DOSPTYP_386BSD &&
                    (dp[i].dp_flag & 0x80 || sl < BASE_SLICE)) {
                    sl = BASE_SLICE + i;
                    if (dp[i].dp_flag & 0x80 ||
                        dsk.slice == COMPATIBILITY_SLICE)
                        break;
                }
            if (dsk.slice == WHOLE_DISK_SLICE)
                dsk.slice = sl;
        }
        if (sl != WHOLE_DISK_SLICE) {
            if (sl != COMPATIBILITY_SLICE)
                dp += sl - BASE_SLICE;
            if (dp->dp_typ != DOSPTYP_386BSD) {
                printf("Invalid %s\n", "slice");
                return -1;
            }
            dsk.start = dp->dp_start;
        }
        if (drvread(sec, dsk.start + LABELSECTOR, 1))
                return -1;
        d = (void *)(sec + LABELOFFSET);
        if (d->d_magic != DISKMAGIC || d->d_magic2 != DISKMAGIC) {
            if (dsk.part != RAW_PART) {
                printf("Invalid %s\n", "label");
                return -1;
            }
        } else {
            if (!dsk.init) {
                if (d->d_type == DTYPE_SCSI)
                    dsk.type = TYPE_DA;
                dsk.init++;
            }
            if (dsk.part >= d->d_npartitions ||
                !d->d_partitions[dsk.part].p_size) {
                printf("Invalid %s\n", "partition");
                return -1;
            }
            dsk.start += d->d_partitions[dsk.part].p_offset;
            dsk.start -= d->d_partitions[RAW_PART].p_offset;
        }
    }
    return drvread(buf, dsk.start + lba, nblk);
}

static ssize_t fsread(ino_t, void *, size_t);

struct dmadat {
        char blkbuf[VBLKSIZE];  /* filesystem blocks */
        char indbuf[VBLKSIZE];  /* indir blocks */
        char sbbuf[SBLOCKSIZE]; /* superblock */
        char secbuf[DEV_BSIZE]; /* for MBR/disklabel */
};
static struct dmadat *dmadat;

static int    ls,dsk_meta;
static uInt32 fs_off;

static int sblock_try[] = SBLOCKSEARCH;

static __inline__ int fsfind(const char *name, ino_t * ino) {
        char buf[DEV_BSIZE];
        struct dirent *d;
        char *s;
        ssize_t n;

        fs_off = 0;
        while ((n = fsread(*ino, buf, DEV_BSIZE)) > 0)
                for (s = buf; s < buf + DEV_BSIZE;) {
                        d = (void *)s;
                        if (ls)
                                kprintf("%s ", d->d_name);
                        else if (!strcmp(name, d->d_name)) {
                                *ino = d->d_fileno;
                                return d->d_type;
                        }
                        s += d->d_reclen;
                }
        if (n != -1 && ls)
                kprintf("\n");
        return 0;
  }

ino_t lookup(const char *path) {
        char name[MAXNAMLEN + 1];
        const char *s;
        ino_t ino;
        ssize_t n;
        int dt;

        ino = ROOTINO;
        dt = DT_DIR;
        name[0] = '/';
        name[1] = '\0';
        for (;;) {
                if (*path == '/')
                        path++;
                if (!*path)
                        break;
                for (s = path; *s && *s != '/'; s++);
                if ((n = s - path) > MAXNAMLEN)
                        return 0;
                ls = *path == '?' && n == 1 && !*s;
                memcpy(name, path, n);
                name[n] = 0;
                if (dt != DT_DIR) {
                        kprintf("%s: not a directory.\n", name);
                        return (0);
                }
                if ((dt = fsfind(name, &ino)) <= 0)
                        break;
                path = s;
        }
        return dt == DT_REG ? ino : 0;
  }

static ssize_t
fsread(ino_t inode, void *buf, size_t nbyte)
{
        static struct ufs1_dinode dp1;
        static struct ufs2_dinode dp2;
        static ino_t inomap;
        char *blkbuf;
        void *indbuf;
        struct fs *fs;
        char *s;
        size_t n, nb, size, off, vboff;
        ufs_lbn_t lbn;
        ufs2_daddr_t addr, vbaddr;
        static ufs2_daddr_t blkmap, indmap;
        u_int u;


        blkbuf = dmadat->blkbuf;
        indbuf = dmadat->indbuf;
        fs = (struct fs *)dmadat->sbbuf;
        if (!dsk_meta) {
                inomap = 0;
                for (n = 0; sblock_try[n] != -1; n++) {
                        if (dskread(fs, sblock_try[n] / DEV_BSIZE,
                            SBLOCKSIZE / DEV_BSIZE))
                                return -1;
                        if ((fs->fs_magic == FS_UFS1_MAGIC || (fs->fs_magic == FS_UFS2_MAGIC && fs->fs_sblockloc == sblock_try[n])) && fs->fs_bsize <= MAXBSIZE && fs->fs_bsize >= sizeof(struct fs))
                                break;
                }
                if (sblock_try[n] == -1) {
                        kprintf("Not ufs\n");
                        return -1;
                }
                dsk_meta++;
        }
        if (!inode)
                return 0;
        if (inomap != inode) {
                n = IPERVBLK(fs);
                if (dskread(blkbuf, INO_TO_VBA(fs, n, inode), DBPERVBLK))
                        return -1;
                n = INO_TO_VBO(n, inode);
#if defined(UFS1_ONLY)
                dp1 = ((struct ufs1_dinode *)blkbuf)[n];
#elif defined(UFS2_ONLY)
                dp2 = ((struct ufs2_dinode *)blkbuf)[n];
#else
                if (fs->fs_magic == FS_UFS1_MAGIC)
                        dp1 = ((struct ufs1_dinode *)blkbuf)[n];
                else
                        dp2 = ((struct ufs2_dinode *)blkbuf)[n];
#endif
                inomap = inode;
                fs_off = 0;
                blkmap = indmap = 0;
        }
        s = buf;
        size = DIP(di_size);
        n = size - fs_off;
        if (nbyte > n)
                nbyte = n;
        nb = nbyte;
        while (nb) {
                lbn = lblkno(fs, fs_off);
                off = blkoff(fs, fs_off);
                if (lbn < NDADDR) {
                        addr = DIP(di_db[lbn]);
                } else if (lbn < NDADDR + NINDIR(fs)) {
                        n = INDIRPERVBLK(fs);
                        addr = DIP(di_ib[0]);
                        u = (u_int)(lbn - NDADDR) / (n * DBPERVBLK);
                        vbaddr = fsbtodb(fs, addr) + u;
                        if (indmap != vbaddr) {
                                if (dskread(indbuf, vbaddr, DBPERVBLK))
                                        return -1;
                                indmap = vbaddr;
                        }
                        n = (lbn - NDADDR) & (n - 1);
#if defined(UFS1_ONLY)
                        addr = ((ufs1_daddr_t *)indbuf)[n];
#elif defined(UFS2_ONLY)
                        addr = ((ufs2_daddr_t *)indbuf)[n];
#else
                        if (fs->fs_magic == FS_UFS1_MAGIC)
                                addr = ((ufs1_daddr_t *)indbuf)[n];
                        else
                                addr = ((ufs2_daddr_t *)indbuf)[n];
#endif
                } else {
                        return -1;
                }
                vbaddr = fsbtodb(fs, addr) + (off >> VBLKSHIFT) * DBPERVBLK;
                vboff = off & VBLKMASK;
                n = sblksize(fs, size, lbn) - (off & ~VBLKMASK);
                if (n > VBLKSIZE)
                        n = VBLKSIZE;
                if (blkmap != vbaddr) {
                        if (dskread(blkbuf, vbaddr, n >> DEV_BSHIFT))
                                return -1;
                        blkmap = vbaddr;
                }
                n -= vboff;
                if (n > nb)
                        n = nb;
                memcpy(s, blkbuf + vboff, n);
                s += n;
                fs_off += n;
                nb -= n;
        }
        return nbyte;
}


/***
 $Log$
 Revision 1.1  2004/07/05 23:04:02  reddawg
 Added UFS Support

 END
 ***/
