rawfs.c

Go to the documentation of this file.

/*      rawfs.c - Raw Minix file system support.        Author: Kees J. Bot
 *                                                              23 Dec 1991
 *                                           Based on readfs by Paul Polderman
 */
#define nil 0
#define _POSIX_SOURCE   1
#define _MINIX          1
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#include <errno.h>
#include <minix/config.h>
#include <minix/const.h>
#include <minix/type.h>
#include <servers/fs/const.h>
#include <servers/fs/type.h>
#include <servers/fs/buf.h>
#include <servers/fs/super.h>
#include <servers/fs/inode.h>
#include "rawfs.h"

void readblock(off_t blockno, char *buf, int);

/* The following code handles two file system types: Version 1 with small
 * inodes and 16-bit disk addresses and Version 2 with big inodes and 32-bit
 * disk addresses.
#ifdef FLEX
 * To make matters worse, Minix-vmd knows about the normal Unix Version 7
 * directories and directories with flexible entries.
#endif
 */

/* File system parameters. */
static unsigned nr_dzones;      /* Fill these in after reading superblock. */
static unsigned nr_indirects;
static unsigned inodes_per_block;
static int block_size;
#ifdef FLEX
#include <dirent.h>
#define direct _v7_direct
#else
#include <sys/dir.h>
#endif

#if __minix_vmd
static struct v12_super_block super;    /* Superblock of file system */
#define s_log_zone_size s_dummy         /* Zones are obsolete. */
#else
static struct super_block super;        /* Superblock of file system */
#define SUPER_V1 SUPER_MAGIC            /* V1 magic has a weird name. */
#endif

static struct inode curfil;             /* Inode of file under examination */
static char indir[_MAX_BLOCK_SIZE];     /* Single indirect block. */
static char dindir[_MAX_BLOCK_SIZE];    /* Double indirect block. */
static char dirbuf[_MAX_BLOCK_SIZE];    /* Scratch/Directory block. */
#define scratch dirbuf

static block_t a_indir, a_dindir;       /* Addresses of the indirects. */
static off_t dirpos;                    /* Reading pos in a dir. */

#define fsbuf(b)        (* (struct buf *) (b))

#define zone_shift      (super.s_log_zone_size) /* zone to block ratio */

off_t r_super(int *bs)
/* Initialize variables, return size of file system in blocks,
 * (zero on error).
 */
{
        /* Read superblock. (The superblock is always at 1kB offset,
         * that's why we lie to readblock and say the block size is 1024
         * and we want block number 1 (the 'second block', at offset 1kB).)
         */
        readblock(1, scratch, 1024);

        memcpy(&super, scratch, sizeof(super));

        /* Is it really a MINIX file system ? */
        if (super.s_magic == SUPER_V2 || super.s_magic == SUPER_V3) {
                if(super.s_magic == SUPER_V2)
                        super.s_block_size = 1024;
                *bs = block_size = super.s_block_size;
                if(block_size < _MIN_BLOCK_SIZE ||
                        block_size > _MAX_BLOCK_SIZE) {
                        return 0;
                }
                nr_dzones= V2_NR_DZONES;
                nr_indirects= V2_INDIRECTS(block_size);
                inodes_per_block= V2_INODES_PER_BLOCK(block_size);
                return (off_t) super.s_zones << zone_shift;
        } else
        if (super.s_magic == SUPER_V1) {
                *bs = block_size = 1024;
                nr_dzones= V1_NR_DZONES;
                nr_indirects= V1_INDIRECTS;
                inodes_per_block= V1_INODES_PER_BLOCK;
                return (off_t) super.s_nzones << zone_shift;
        } else {
                /* Filesystem not recognized as Minix. */
                return 0;
        }
}

void r_stat(Ino_t inum, struct stat *stp)
/* Return information about a file like stat(2) and remember it. */
{
        block_t block;
        block_t ino_block;
        ino_t ino_offset;

        /* Calculate start of i-list */
        block = START_BLOCK + super.s_imap_blocks + super.s_zmap_blocks;

        /* Calculate block with inode inum */
        ino_block = ((inum - 1) / inodes_per_block);
        ino_offset = ((inum - 1) % inodes_per_block);
        block += ino_block;

        /* Fetch the block */
        readblock(block, scratch, block_size);

        if (super.s_magic == SUPER_V2 || super.s_magic == SUPER_V3) {
                d2_inode *dip;
                int i;

                dip= &fsbuf(scratch).b_v2_ino[ino_offset];

                curfil.i_mode= dip->d2_mode;
                curfil.i_nlinks= dip->d2_nlinks;
                curfil.i_uid= dip->d2_uid;
                curfil.i_gid= dip->d2_gid;
                curfil.i_size= dip->d2_size;
                curfil.i_atime= dip->d2_atime;
                curfil.i_mtime= dip->d2_mtime;
                curfil.i_ctime= dip->d2_ctime;
                for (i= 0; i < V2_NR_TZONES; i++)
                        curfil.i_zone[i]= dip->d2_zone[i];
        } else {
                d1_inode *dip;
                int i;

                dip= &fsbuf(scratch).b_v1_ino[ino_offset];

                curfil.i_mode= dip->d1_mode;
                curfil.i_nlinks= dip->d1_nlinks;
                curfil.i_uid= dip->d1_uid;
                curfil.i_gid= dip->d1_gid;
                curfil.i_size= dip->d1_size;
                curfil.i_atime= dip->d1_mtime;
                curfil.i_mtime= dip->d1_mtime;
                curfil.i_ctime= dip->d1_mtime;
                for (i= 0; i < V1_NR_TZONES; i++)
                        curfil.i_zone[i]= dip->d1_zone[i];
        }
        curfil.i_dev= -1;       /* Can't fill this in alas. */
        curfil.i_num= inum;

        stp->st_dev= curfil.i_dev;
        stp->st_ino= curfil.i_num;
        stp->st_mode= curfil.i_mode;
        stp->st_nlink= curfil.i_nlinks;
        stp->st_uid= curfil.i_uid;
        stp->st_gid= curfil.i_gid;
        stp->st_rdev= (dev_t) curfil.i_zone[0];
        stp->st_size= curfil.i_size;
        stp->st_atime= curfil.i_atime;
        stp->st_mtime= curfil.i_mtime;
        stp->st_ctime= curfil.i_ctime;

        a_indir= a_dindir= 0;
        dirpos= 0;
}

ino_t r_readdir(char *name)
/* Read next directory entry at "dirpos" from file "curfil". */
{
        ino_t inum= 0;
        int blkpos;
        struct direct *dp;

        if (!S_ISDIR(curfil.i_mode)) { errno= ENOTDIR; return -1; }

        if(!block_size) { errno = 0; return -1; }

        while (inum == 0 && dirpos < curfil.i_size) {
                if ((blkpos= (int) (dirpos % block_size)) == 0) {
                        /* Need to fetch a new directory block. */

                        readblock(r_vir2abs(dirpos / block_size), dirbuf, block_size);
                }
#ifdef FLEX
                if (super.s_flags & S_FLEX) {
                        struct _fl_direct *dp;

                        dp= (struct _fl_direct *) (dirbuf + blkpos);
                        if ((inum= dp->d_ino) != 0) strcpy(name, dp->d_name);

                        dirpos+= (1 + dp->d_extent) * FL_DIR_ENTRY_SIZE;
                        continue;
                }
#endif
                /* Let dp point to the next entry. */
                dp= (struct direct *) (dirbuf + blkpos);

                if ((inum= dp->d_ino) != 0) {
                        /* This entry is occupied, return name. */
                        strncpy(name, dp->d_name, sizeof(dp->d_name));
                        name[sizeof(dp->d_name)]= 0;
                }
                dirpos+= DIR_ENTRY_SIZE;
        }
        return inum;
}

off_t r_vir2abs(off_t virblk)
/* Translate a block number in a file to an absolute disk block number.
 * Returns 0 for a hole and -1 if block is past end of file.
 */
{
        block_t b= virblk;
        zone_t zone, ind_zone;
        block_t z, zone_index;
        int i;

        if(!block_size) return -1;

        /* Check if virblk within file. */
        if (virblk * block_size >= curfil.i_size) return -1;

        /* Calculate zone in which the datablock number is contained */
        zone = (zone_t) (b >> zone_shift);

        /* Calculate index of the block number in the zone */
        zone_index = b - ((block_t) zone << zone_shift);

        /* Go get the zone */
        if (zone < (zone_t) nr_dzones) {        /* direct block */
                zone = curfil.i_zone[(int) zone];
                z = ((block_t) zone << zone_shift) + zone_index;
                return z;
        }

        /* The zone is not a direct one */
        zone -= (zone_t) nr_dzones;

        /* Is it single indirect ? */
        if (zone < (zone_t) nr_indirects) {     /* single indirect block */
                ind_zone = curfil.i_zone[nr_dzones];
        } else {                        /* double indirect block */
                /* Fetch the double indirect block */
                if ((ind_zone = curfil.i_zone[nr_dzones + 1]) == 0) return 0;

                z = (block_t) ind_zone << zone_shift;
                if (a_dindir != z) {
                        readblock(z, dindir, block_size);
                        a_dindir= z;
                }
                /* Extract the indirect zone number from it */
                zone -= (zone_t) nr_indirects;

                i = zone / (zone_t) nr_indirects;
                ind_zone = (super.s_magic == SUPER_V2 || super.s_magic == SUPER_V3)
                                ? fsbuf(dindir).b_v2_ind[i]
                                : fsbuf(dindir).b_v1_ind[i];
                zone %= (zone_t) nr_indirects;
        }
        if (ind_zone == 0) return 0;

        /* Extract the datablock number from the indirect zone */
        z = (block_t) ind_zone << zone_shift;
        if (a_indir != z) {
                readblock(z, indir, block_size);
                a_indir= z;
        }
        zone = (super.s_magic == SUPER_V2 || super.s_magic == SUPER_V3)
                ? fsbuf(indir).b_v2_ind[(int) zone]
                : fsbuf(indir).b_v1_ind[(int) zone];

        /* Calculate absolute datablock number */
        z = ((block_t) zone << zone_shift) + zone_index;
        return z;
}

ino_t r_lookup(Ino_t cwd, char *path)
/* Translates a pathname to an inode number.  This is just a nice utility
 * function, it only needs r_stat and r_readdir.
 */
{
        char name[NAME_MAX+1], r_name[NAME_MAX+1];
        char *n;
        struct stat st;
        ino_t ino;

        ino= path[0] == '/' ? ROOT_INO : cwd;

        for (;;) {
                if (ino == 0) {
                        errno= ENOENT;
                        return 0;
                }

                while (*path == '/') path++;

                if (*path == 0) return ino;

                r_stat(ino, &st);

                if (!S_ISDIR(st.st_mode)) {
                        errno= ENOTDIR;
                        return 0;
                }

                n= name;
                while (*path != 0 && *path != '/')
                        if (n < name + NAME_MAX) *n++ = *path++;
                *n= 0;

                while ((ino= r_readdir(r_name)) != 0
                                        && strcmp(name, r_name) != 0) {
                }
        }
}

/*
 * $PchId: rawfs.c,v 1.8 1999/11/05 23:14:15 philip Exp $
 */

---