Subversion Repositories or1k_old

/*

 *  linux/fs/sysv/inode.c

 *

 *  minix/inode.c

 *  Copyright (C) 1991, 1992  Linus Torvalds

 *

 *  xenix/inode.c

 *  Copyright (C) 1992  Doug Evans

 *

 *  coh/inode.c

 *  Copyright (C) 1993  Pascal Haible, Bruno Haible

 *

 *  sysv/inode.c

 *  Copyright (C) 1993  Paul B. Monday

 *

 *  sysv/inode.c

 *  Copyright (C) 1993  Bruno Haible

 *

 *  This file contains code for allocating/freeing inodes and for read/writing

 *  the superblock.

 */

#include <linux/module.h>

#include <linux/sched.h>

#include <linux/kernel.h>

#include <linux/fs.h>

#include <linux/sysv_fs.h>

#include <linux/stat.h>

#include <linux/string.h>

#include <linux/locks.h>

#include <asm/segment.h>

void sysv_put_inode(struct inode *inode)

{

        if (inode->i_nlink)

                return;

        inode->i_size = 0;

        sysv_truncate(inode);

        sysv_free_inode(inode);

}

static struct super_operations sysv_sops = {

        sysv_read_inode,

        sysv_notify_change,

        sysv_write_inode,

        sysv_put_inode,

        sysv_put_super,

        sysv_write_super,

        sysv_statfs,

        NULL

};

/* The following functions try to recognize specific filesystems.

 * We recognize:

 * - Xenix FS by its magic number.

 * - SystemV FS by its magic number.

 * - Coherent FS by its funny fname/fpack field.

 * We discriminate among SystemV4 and SystemV2 FS by the assumption that

 * the time stamp is not < 01-01-1980.

 */

static void detected_bs512 (struct super_block *sb)

{

        sb->sv_block_size = 512;

        sb->sv_block_size_1 = 512-1;

        sb->sv_block_size_bits = 9;

        sb->sv_block_size_ratio = 2;

        sb->sv_block_size_ratio_bits = 1;

        sb->sv_inodes_per_block = 512/64;

        sb->sv_inodes_per_block_1 = 512/64-1;

        sb->sv_inodes_per_block_bits = 9-6;

        sb->sv_toobig_block = 10 +

          (sb->sv_ind_per_block = 512/4) +

          (sb->sv_ind_per_block_2 = (512/4)*(512/4)) +

          (sb->sv_ind_per_block_3 = (512/4)*(512/4)*(512/4));

        sb->sv_ind_per_block_1 = 512/4-1;

        sb->sv_ind_per_block_2_1 = (512/4)*(512/4)-1;

        sb->sv_ind_per_block_2_bits = 2 *

          (sb->sv_ind_per_block_bits = 9-2);

        sb->sv_ind_per_block_block_size_1 = (512/4)*512-1;

        sb->sv_ind_per_block_block_size_bits = (9-2)+9;

        sb->sv_ind_per_block_2_block_size_1 = (512/4)*(512/4)*512-1;

        sb->sv_ind_per_block_2_block_size_bits = (9-2)+(9-2)+9;

        sb->sv_ind0_size = 10 * 512;

        sb->sv_ind1_size = (10 + (512/4))* 512;

        sb->sv_ind2_size = (10 + (512/4) + (512/4)*(512/4)) * 512;

}

static void detected_bs1024 (struct super_block *sb)

{

        sb->sv_block_size = 1024;

        sb->sv_block_size_1 = 1024-1;

        sb->sv_block_size_bits = 10;

        sb->sv_block_size_ratio = 1;

        sb->sv_block_size_ratio_bits = 0;

        sb->sv_inodes_per_block = 1024/64;

        sb->sv_inodes_per_block_1 = 1024/64-1;

        sb->sv_inodes_per_block_bits = 10-6;

        sb->sv_toobig_block = 10 +

          (sb->sv_ind_per_block = 1024/4) +

          (sb->sv_ind_per_block_2 = (1024/4)*(1024/4)) +

          (sb->sv_ind_per_block_3 = (1024/4)*(1024/4)*(1024/4));

        sb->sv_ind_per_block_1 = 1024/4-1;

        sb->sv_ind_per_block_2_1 = (1024/4)*(1024/4)-1;

        sb->sv_ind_per_block_2_bits = 2 *

          (sb->sv_ind_per_block_bits = 10-2);

        sb->sv_ind_per_block_block_size_1 = (1024/4)*1024-1;

        sb->sv_ind_per_block_block_size_bits = (10-2)+10;

        sb->sv_ind_per_block_2_block_size_1 = (1024/4)*(1024/4)*1024-1;

        sb->sv_ind_per_block_2_block_size_bits = (10-2)+(10-2)+10;

        sb->sv_ind0_size = 10 * 1024;

        sb->sv_ind1_size = (10 + (1024/4))* 1024;

        sb->sv_ind2_size = (10 + (1024/4) + (1024/4)*(1024/4)) * 1024;

}

static const char* detect_xenix (struct super_block *sb, struct buffer_head *bh)

{

        struct xenix_super_block * sbd;

        sbd = (struct xenix_super_block *) bh->b_data;

        if (sbd->s_magic != 0x2b5544)

                return NULL;

        switch (sbd->s_type) {

                case 1: detected_bs512(sb); break;

                case 2: detected_bs1024(sb); break;

                default: return NULL;

        }

        sb->sv_type = FSTYPE_XENIX;

        return "Xenix";

}

static struct super_block * detected_xenix (struct super_block *sb, struct buffer_head *bh1, struct buffer_head *bh2)

{

        struct xenix_super_block * sbd1;

        struct xenix_super_block * sbd2;

        if (sb->sv_block_size == BLOCK_SIZE)

                /* block size = 1024, so bh1 = bh2 */

                sbd1 = sbd2 = (struct xenix_super_block *) bh1->b_data;

        else {

                /* block size = 512, so bh1 != bh2 */

                sbd1 = (struct xenix_super_block *) bh1->b_data;

                sbd2 = (struct xenix_super_block *) (bh2->b_data - BLOCK_SIZE/2);

                /* sanity check */

                if (sbd2->s_magic != 0x2b5544)

                        return NULL;

        }

        sb->sv_convert = 0;

        sb->sv_kludge_symlinks = 1;

        sb->sv_truncate = 1;

        sb->sv_link_max = XENIX_LINK_MAX;

        sb->sv_fic_size = XENIX_NICINOD;

        sb->sv_flc_size = XENIX_NICFREE;

        sb->sv_bh1 = bh1;

        sb->sv_bh2 = bh2;

        sb->sv_sbd1 = (char *) sbd1;

        sb->sv_sbd2 = (char *) sbd2;

        sb->sv_sb_fic_count = &sbd1->s_ninode;

        sb->sv_sb_fic_inodes = &sbd1->s_inode[0];

        sb->sv_sb_total_free_inodes = &sbd2->s_tinode;

        sb->sv_sb_flc_count = &sbd1->s_nfree;

        sb->sv_sb_flc_blocks = &sbd1->s_free[0];

        sb->sv_sb_total_free_blocks = &sbd2->s_tfree;

        sb->sv_sb_time = &sbd2->s_time;

        sb->sv_firstinodezone = 2;

        sb->sv_firstdatazone = sbd1->s_isize;

        sb->sv_nzones = sbd1->s_fsize;

        sb->sv_ndatazones = sb->sv_nzones - sb->sv_firstdatazone;

        return sb;

}

static const char* detect_sysv4 (struct super_block *sb, struct buffer_head *bh)

{

        struct sysv4_super_block * sbd;

        sbd = (struct sysv4_super_block *) (bh->b_data + BLOCK_SIZE/2);

        if (sbd->s_magic != 0xfd187e20)

                return NULL;

        if (sbd->s_time < 315532800) /* this is likely to happen on SystemV2 FS */

                return NULL;

        switch (sbd->s_type) {

                case 1: detected_bs512(sb); break;

                case 2: detected_bs1024(sb); break;

                default: return NULL;

        }

        sb->sv_type = FSTYPE_SYSV4;

        return "SystemV";

}

static struct super_block * detected_sysv4 (struct super_block *sb, struct buffer_head *bh)

{

        struct sysv4_super_block * sbd;

        if (sb->sv_block_size == BLOCK_SIZE)

                sbd = (struct sysv4_super_block *) (bh->b_data + BLOCK_SIZE/2);

        else {

                sbd = (struct sysv4_super_block *) bh->b_data;

                /* sanity check */

                if (sbd->s_magic != 0xfd187e20)

                        return NULL;

                if (sbd->s_time < 315532800)

                        return NULL;

        }

        sb->sv_convert = 0;

        sb->sv_kludge_symlinks = 0; /* ?? */

        sb->sv_truncate = 1;

        sb->sv_link_max = SYSV_LINK_MAX;

        sb->sv_fic_size = SYSV_NICINOD;

        sb->sv_flc_size = SYSV_NICFREE;

        sb->sv_bh1 = bh;

        sb->sv_bh2 = bh;

        sb->sv_sbd1 = (char *) sbd;

        sb->sv_sbd2 = (char *) sbd;

        sb->sv_sb_fic_count = &sbd->s_ninode;

        sb->sv_sb_fic_inodes = &sbd->s_inode[0];

        sb->sv_sb_total_free_inodes = &sbd->s_tinode;

        sb->sv_sb_flc_count = &sbd->s_nfree;

        sb->sv_sb_flc_blocks = &sbd->s_free[0];

        sb->sv_sb_total_free_blocks = &sbd->s_tfree;

        sb->sv_sb_time = &sbd->s_time;

        sb->sv_sb_state = &sbd->s_state;

        sb->sv_firstinodezone = 2;

        sb->sv_firstdatazone = sbd->s_isize;

        sb->sv_nzones = sbd->s_fsize;

        sb->sv_ndatazones = sb->sv_nzones - sb->sv_firstdatazone;

        return sb;

}

static const char* detect_sysv2 (struct super_block *sb, struct buffer_head *bh)

{

        struct sysv2_super_block * sbd;

        sbd = (struct sysv2_super_block *) (bh->b_data + BLOCK_SIZE/2);

        if (sbd->s_magic != 0xfd187e20)

                return NULL;

        if (sbd->s_time < 315532800) /* this is likely to happen on SystemV4 FS */

                return NULL;

        switch (sbd->s_type) {

                case 1: detected_bs512(sb); break;

                case 2: detected_bs1024(sb); break;

                default: return NULL;

        }

        sb->sv_type = FSTYPE_SYSV2;

        return "SystemV Release 2";

}

static struct super_block * detected_sysv2 (struct super_block *sb, struct buffer_head *bh)

{

        struct sysv2_super_block * sbd;

        if (sb->sv_block_size == BLOCK_SIZE)

                sbd = (struct sysv2_super_block *) (bh->b_data + BLOCK_SIZE/2);

        else {

                sbd = (struct sysv2_super_block *) bh->b_data;

                /* sanity check */

                if (sbd->s_magic != 0xfd187e20)

                        return NULL;

                if (sbd->s_time < 315532800)

                        return NULL;

        }

        sb->sv_convert = 0;

        sb->sv_kludge_symlinks = 0; /* ?? */

        sb->sv_truncate = 1;

        sb->sv_link_max = SYSV_LINK_MAX;

        sb->sv_fic_size = SYSV_NICINOD;

        sb->sv_flc_size = SYSV_NICFREE;

        sb->sv_bh1 = bh;

        sb->sv_bh2 = bh;

        sb->sv_sbd1 = (char *) sbd;

        sb->sv_sbd2 = (char *) sbd;

        sb->sv_sb_fic_count = &sbd->s_ninode;

        sb->sv_sb_fic_inodes = &sbd->s_inode[0];

        sb->sv_sb_total_free_inodes = &sbd->s_tinode;

        sb->sv_sb_flc_count = &sbd->s_nfree;

        sb->sv_sb_flc_blocks = &sbd->s_free[0];

        sb->sv_sb_total_free_blocks = &sbd->s_tfree;

        sb->sv_sb_time = &sbd->s_time;

        sb->sv_sb_state = &sbd->s_state;

        sb->sv_firstinodezone = 2;

        sb->sv_firstdatazone = sbd->s_isize;

        sb->sv_nzones = sbd->s_fsize;

        sb->sv_ndatazones = sb->sv_nzones - sb->sv_firstdatazone;

        return sb;

}

static const char* detect_coherent (struct super_block *sb, struct buffer_head *bh)

{

        struct coh_super_block * sbd;

        sbd = (struct coh_super_block *) (bh->b_data + BLOCK_SIZE/2);

        if ((memcmp(sbd->s_fname,"noname",6) && memcmp(sbd->s_fname,"xxxxx ",6))

            || (memcmp(sbd->s_fpack,"nopack",6) && memcmp(sbd->s_fpack,"xxxxx\n",6)))

                return NULL;

        detected_bs512(sb);

        sb->sv_type = FSTYPE_COH;

        return "Coherent";

}

static struct super_block * detected_coherent (struct super_block *sb, struct buffer_head *bh)

{

        struct coh_super_block * sbd;

        sbd = (struct coh_super_block *) bh->b_data;

        /* sanity check */

        if ((memcmp(sbd->s_fname,"noname",6) && memcmp(sbd->s_fname,"xxxxx ",6))

            || (memcmp(sbd->s_fpack,"nopack",6) && memcmp(sbd->s_fpack,"xxxxx\n",6)))

                return NULL;

        sb->sv_convert = 1;

        sb->sv_kludge_symlinks = 1;

        sb->sv_truncate = 1;

        sb->sv_link_max = COH_LINK_MAX;

        sb->sv_fic_size = COH_NICINOD;

        sb->sv_flc_size = COH_NICFREE;

        sb->sv_bh1 = bh;

        sb->sv_bh2 = bh;

        sb->sv_sbd1 = (char *) sbd;

        sb->sv_sbd2 = (char *) sbd;

        sb->sv_sb_fic_count = &sbd->s_ninode;

        sb->sv_sb_fic_inodes = &sbd->s_inode[0];

        sb->sv_sb_total_free_inodes = &sbd->s_tinode;

        sb->sv_sb_flc_count = &sbd->s_nfree;

        sb->sv_sb_flc_blocks = &sbd->s_free[0];

        sb->sv_sb_total_free_blocks = &sbd->s_tfree;

        sb->sv_sb_time = &sbd->s_time;

        sb->sv_firstinodezone = 2;

        sb->sv_firstdatazone = sbd->s_isize;

        sb->sv_nzones = from_coh_ulong(sbd->s_fsize);

        sb->sv_ndatazones = sb->sv_nzones - sb->sv_firstdatazone;

        return sb;

}

struct super_block *sysv_read_super(struct super_block *sb,void *data,

                                     int silent)

{

        struct buffer_head *bh;

        const char *found;

        kdev_t dev = sb->s_dev;

        if (1024 != sizeof (struct xenix_super_block))

                panic("Xenix FS: bad super-block size");

        if ((512 != sizeof (struct sysv4_super_block))

            || (512 != sizeof (struct sysv2_super_block)))

                panic("SystemV FS: bad super-block size");

        if (500 != sizeof (struct coh_super_block))

                panic("Coherent FS: bad super-block size");

        if (64 != sizeof (struct sysv_inode))

                panic("sysv fs: bad i-node size");

        MOD_INC_USE_COUNT;

        lock_super(sb);

        set_blocksize(dev,BLOCK_SIZE);

        sb->sv_block_base = 0;

        /* Try to read Xenix superblock */

        if ((bh = bread(dev, 1, BLOCK_SIZE)) != NULL) {

                if ((found = detect_xenix(sb,bh)) != NULL)

                        goto ok;

                brelse(bh);

        }

        if ((bh = bread(dev, 0, BLOCK_SIZE)) != NULL) {

                /* Try to recognize SystemV superblock */

                if ((found = detect_sysv4(sb,bh)) != NULL)

                        goto ok;

                if ((found = detect_sysv2(sb,bh)) != NULL)

                        goto ok;

                /* Try to recognize Coherent superblock */

                if ((found = detect_coherent(sb,bh)) != NULL)

                        goto ok;

                brelse(bh);

        }

        /* Try to recognize SystemV superblock */

        /* Offset by 1 track, i.e. most probably 9, 15, or 18 kilobytes. */

        {       static int offsets[] = { 9, 15, 18, };

                int i;

                for (i = 0; i < sizeof(offsets)/sizeof(offsets[0]); i++)

                        if ((bh = bread(dev, offsets[i], BLOCK_SIZE)) != NULL) {

                                /* Try to recognize SystemV superblock */

                                if ((found = detect_sysv4(sb,bh)) != NULL) {

                                        sb->sv_block_base = offsets[i] << sb->sv_block_size_ratio_bits;

                                        goto ok;

                                }

                                if ((found = detect_sysv2(sb,bh)) != NULL) {

                                        sb->sv_block_base = offsets[i] << sb->sv_block_size_ratio_bits;

                                        goto ok;

                                }

                                brelse(bh);

                        }

        }

        sb->s_dev = 0;

        unlock_super(sb);

        if (!silent)

                printk("VFS: unable to read Xenix/SystemV/Coherent superblock on device "

                       "%s\n", kdevname(dev));

        failed:

        MOD_DEC_USE_COUNT;

        return NULL;

        ok:

        if (sb->sv_block_size == BLOCK_SIZE) {

                switch (sb->sv_type) {

                        case FSTYPE_XENIX:

                                if (!detected_xenix(sb,bh,bh))

                                        goto bad_superblock;

                                break;

                        case FSTYPE_SYSV4:

                                if (!detected_sysv4(sb,bh))

                                        goto bad_superblock;

                                break;

                        case FSTYPE_SYSV2:

                                if (!detected_sysv2(sb,bh))

                                        goto bad_superblock;

                                break;

                        default:

                        bad_superblock:

                                brelse(bh);

                                sb->s_dev = 0;

                                unlock_super(sb);

                                printk("SysV FS: cannot read superblock in 1024 byte mode\n");

                                goto failed;

                }

        } else {

                /* Switch to another block size. Unfortunately, we have to

                   release the 1 KB block bh and read it in two parts again. */

                struct buffer_head *bh1, *bh2;

                unsigned long blocknr = bh->b_blocknr << sb->sv_block_size_ratio_bits;

                brelse(bh);

                set_blocksize(dev,sb->sv_block_size);

                bh1 = NULL; bh2 = NULL;

                switch (sb->sv_type) {

                        case FSTYPE_XENIX:

                                if ((bh1 = bread(dev, blocknr, sb->sv_block_size)) == NULL)

                                        goto bad_superblock2;

                                if ((bh2 = bread(dev, blocknr+1, sb->sv_block_size)) == NULL)

                                        goto bad_superblock2;

                                if (!detected_xenix(sb,bh1,bh2))

                                        goto bad_superblock2;

                                break;

                        case FSTYPE_SYSV4:

                                if ((bh2 = bread(dev, blocknr+1, sb->sv_block_size)) == NULL)

                                        goto bad_superblock2;

                                if (!detected_sysv4(sb,bh2))

                                        goto bad_superblock2;

                                break;

                        case FSTYPE_SYSV2:

                                if ((bh2 = bread(dev, blocknr+1, sb->sv_block_size)) == NULL)

                                        goto bad_superblock2;

                                if (!detected_sysv2(sb,bh2))

                                        goto bad_superblock2;

                                break;

                        case FSTYPE_COH:

                                if ((bh2 = bread(dev, blocknr+1, sb->sv_block_size)) == NULL)

                                        goto bad_superblock2;

                                if (!detected_coherent(sb,bh2))

                                        goto bad_superblock2;

                                break;

                        default:

                        bad_superblock2:

                                brelse(bh1);

                                brelse(bh2);

                                set_blocksize(sb->s_dev,BLOCK_SIZE);

                                sb->s_dev = 0;

                                unlock_super(sb);

                                printk("SysV FS: cannot read superblock in 512 byte mode\n");

                                goto failed;

                }

        }

        sb->sv_ninodes = (sb->sv_firstdatazone - sb->sv_firstinodezone) << sb->sv_inodes_per_block_bits;

        if (!silent)

                printk("VFS: Found a %s FS (block size = %d) on device %s\n",

                       found, sb->sv_block_size, kdevname(dev));

        sb->s_magic = SYSV_MAGIC_BASE + sb->sv_type;

        /* The buffer code now supports block size 512 as well as 1024. */

        sb->s_blocksize = sb->sv_block_size;

        sb->s_blocksize_bits = sb->sv_block_size_bits;

        /* set up enough so that it can read an inode */

        sb->s_dev = dev;

        sb->s_op = &sysv_sops;

        sb->s_mounted = iget(sb,SYSV_ROOT_INO);

        unlock_super(sb);

        if (!sb->s_mounted) {

                printk("SysV FS: get root inode failed\n");

                sysv_put_super(sb);

                return NULL;

        }

        sb->s_dirt = 1;

        /* brelse(bh);  resp.  brelse(bh1); brelse(bh2);

           occurs when the disk is unmounted. */

        return sb;

}

/* This is only called on sync() and umount(), when s_dirt=1. */

void sysv_write_super (struct super_block *sb)

{

        lock_super(sb);

        if (buffer_dirty(sb->sv_bh1) || buffer_dirty(sb->sv_bh2)) {

                /* If we are going to write out the super block,

                   then attach current time stamp.

                   But if the filesystem was marked clean, keep it clean. */

                unsigned long time = CURRENT_TIME;

                unsigned long old_time = *sb->sv_sb_time;

                if (sb->sv_convert)

                        old_time = from_coh_ulong(old_time);

                if (sb->sv_type == FSTYPE_SYSV4)

                        if (*sb->sv_sb_state == 0x7c269d38 - old_time)

                                *sb->sv_sb_state = 0x7c269d38 - time;

                if (sb->sv_convert)

                        time = to_coh_ulong(time);

                *sb->sv_sb_time = time;

                mark_buffer_dirty(sb->sv_bh2, 1);

        }

        sb->s_dirt = 0;

        unlock_super(sb);

}

void sysv_put_super(struct super_block *sb)

{

        /* we can assume sysv_write_super() has already been called */

        lock_super(sb);

        brelse(sb->sv_bh1);

        if (sb->sv_bh1 != sb->sv_bh2) brelse(sb->sv_bh2);

        /* switch back to default block size */

        if (sb->s_blocksize != BLOCK_SIZE)

                set_blocksize(sb->s_dev,BLOCK_SIZE);

        sb->s_dev = 0;

        unlock_super(sb);

        MOD_DEC_USE_COUNT;

}

void sysv_statfs(struct super_block *sb, struct statfs *buf, int bufsiz)

{

        struct statfs tmp;

        tmp.f_type = sb->s_magic;                       /* type of filesystem */

        tmp.f_bsize = sb->sv_block_size;                /* block size */

        tmp.f_blocks = sb->sv_ndatazones;               /* total data blocks in file system */

        tmp.f_bfree = sysv_count_free_blocks(sb);       /* free blocks in fs */

        tmp.f_bavail = tmp.f_bfree;                     /* free blocks available to non-superuser */

        tmp.f_files = sb->sv_ninodes;                   /* total file nodes in file system */

        tmp.f_ffree = sysv_count_free_inodes(sb);       /* free file nodes in fs */

        tmp.f_namelen = SYSV_NAMELEN;

        /* Don't know what value to put in tmp.f_fsid */ /* file system id */

        memcpy_tofs(buf, &tmp, bufsiz);

}

/* bmap support for running executables and shared libraries. */

static inline int inode_bmap(struct super_block * sb, struct inode * inode, int nr)

{

        int tmp = inode->u.sysv_i.i_data[nr];

        if (!tmp)

                return 0;

        return tmp + sb->sv_block_base;

}

static int block_bmap(struct super_block * sb, struct buffer_head * bh, int nr, int convert)

{

        int tmp;

        if (!bh)

                return 0;

        tmp = ((sysv_zone_t *) bh->b_data) [nr];

        if (convert)

                tmp = from_coh_ulong(tmp);

        brelse(bh);

        if (!tmp)

                return 0;

        return tmp + sb->sv_block_base;

}

int sysv_bmap(struct inode * inode,int block_nr)

{

        unsigned int block = block_nr;

        struct super_block * sb = inode->i_sb;

        int convert;

        int i;

        struct buffer_head * bh;

        if (block < 10)

                return inode_bmap(sb,inode,block);