Subversion Repositories or1k

/*

 *  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

 *  Copyright (C) 1997, 1998  Krzysztof G. Baranowski

 *

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

 *  the superblock.

 */

#include <linux/fs.h>

#include <linux/sysv_fs.h>

#include <linux/locks.h>

#include <linux/smp_lock.h>

#include <linux/highuid.h>

#include <asm/byteorder.h>

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

static void sysv_write_super(struct super_block *sb)

{

        if (!(sb->s_flags & MS_RDONLY)) {

                /* 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 = fs32_to_cpu(sb, *sb->sv_sb_time);

                if (sb->sv_type == FSTYPE_SYSV4)

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

                                *sb->sv_sb_state = cpu_to_fs32(sb, 0x7c269d38 - time);

                *sb->sv_sb_time = cpu_to_fs32(sb, time);

                mark_buffer_dirty(sb->sv_bh2);

        }

        sb->s_dirt = 0;

}

static void sysv_put_super(struct super_block *sb)

{

        if (!(sb->s_flags & MS_RDONLY)) {

                /* XXX ext2 also updates the state here */

                mark_buffer_dirty(sb->sv_bh1);

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

                        mark_buffer_dirty(sb->sv_bh2);

        }

        brelse(sb->sv_bh1);

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

                brelse(sb->sv_bh2);

}

static int sysv_statfs(struct super_block *sb, struct statfs *buf)

{

        buf->f_type = sb->s_magic;

        buf->f_bsize = sb->s_blocksize;

        buf->f_blocks = sb->sv_ndatazones;

        buf->f_bavail = buf->f_bfree = sysv_count_free_blocks(sb);

        buf->f_files = sb->sv_ninodes;

        buf->f_ffree = sysv_count_free_inodes(sb);

        buf->f_namelen = SYSV_NAMELEN;

        return 0;

}

/*

 * NXI <-> N0XI for PDP, XIN <-> XIN0 for le32, NIX <-> 0NIX for be32

 */

static inline void read3byte(struct super_block *sb,

        unsigned char * from, unsigned char * to)

{

        if (sb->sv_bytesex == BYTESEX_PDP) {

                to[0] = from[0];

                to[1] = 0;

                to[2] = from[1];

                to[3] = from[2];

        } else if (sb->sv_bytesex == BYTESEX_LE) {

                to[0] = from[0];

                to[1] = from[1];

                to[2] = from[2];

                to[3] = 0;

        } else {

                to[0] = 0;

                to[1] = from[0];

                to[2] = from[1];

                to[3] = from[2];

        }

}

static inline void write3byte(struct super_block *sb,

        unsigned char * from, unsigned char * to)

{

        if (sb->sv_bytesex == BYTESEX_PDP) {

                to[0] = from[0];

                to[1] = from[2];

                to[2] = from[3];

        } else if (sb->sv_bytesex == BYTESEX_LE) {

                to[0] = from[0];

                to[1] = from[1];

                to[2] = from[2];

        } else {

                to[0] = from[1];

                to[1] = from[2];

                to[2] = from[3];

        }

}

static struct inode_operations sysv_symlink_inode_operations = {

        readlink:       page_readlink,

        follow_link:    page_follow_link,

};

void sysv_set_inode(struct inode *inode, dev_t rdev)

{

        if (S_ISREG(inode->i_mode)) {

                inode->i_op = &sysv_file_inode_operations;

                inode->i_fop = &sysv_file_operations;

                inode->i_mapping->a_ops = &sysv_aops;

        } else if (S_ISDIR(inode->i_mode)) {

                inode->i_op = &sysv_dir_inode_operations;

                inode->i_fop = &sysv_dir_operations;

                inode->i_mapping->a_ops = &sysv_aops;

        } else if (S_ISLNK(inode->i_mode)) {

                if (inode->i_blocks) {

                        inode->i_op = &sysv_symlink_inode_operations;

                        inode->i_mapping->a_ops = &sysv_aops;

                } else

                        inode->i_op = &sysv_fast_symlink_inode_operations;

        } else

                init_special_inode(inode, inode->i_mode, rdev);

}

static void sysv_read_inode(struct inode *inode)

{

        struct super_block * sb = inode->i_sb;

        struct buffer_head * bh;

        struct sysv_inode * raw_inode;

        unsigned int block, ino;

        dev_t rdev = 0;

        ino = inode->i_ino;

        if (!ino || ino > sb->sv_ninodes) {

                printk("Bad inode number on dev %s"

                       ": %d is out of range\n",

                       kdevname(inode->i_dev), ino);

                goto bad_inode;

        }

        raw_inode = sysv_raw_inode(sb, ino, &bh);

        if (!raw_inode) {

                printk("Major problem: unable to read inode from dev %s\n",

                       bdevname(inode->i_dev));

                goto bad_inode;

        }

        /* SystemV FS: kludge permissions if ino==SYSV_ROOT_INO ?? */

        inode->i_mode = fs16_to_cpu(sb, raw_inode->i_mode);

        inode->i_uid = (uid_t)fs16_to_cpu(sb, raw_inode->i_uid);

        inode->i_gid = (gid_t)fs16_to_cpu(sb, raw_inode->i_gid);

        inode->i_nlink = fs16_to_cpu(sb, raw_inode->i_nlink);

        inode->i_size = fs32_to_cpu(sb, raw_inode->i_size);

        inode->i_atime = fs32_to_cpu(sb, raw_inode->i_atime);

        inode->i_mtime = fs32_to_cpu(sb, raw_inode->i_mtime);

        inode->i_ctime = fs32_to_cpu(sb, raw_inode->i_ctime);

        inode->i_blocks = inode->i_blksize = 0;

        for (block = 0; block < 10+1+1+1; block++)

                read3byte(sb, &raw_inode->i_a.i_addb[3*block],

                        (unsigned char*)&inode->u.sysv_i.i_data[block]);

        brelse(bh);

        if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))

                rdev = (u16)fs32_to_cpu(sb, inode->u.sysv_i.i_data[0]);

        inode->u.sysv_i.i_dir_start_lookup = 0;

        sysv_set_inode(inode, rdev);

        return;

bad_inode:

        make_bad_inode(inode);

        return;

}

static struct buffer_head * sysv_update_inode(struct inode * inode)

{

        struct super_block * sb = inode->i_sb;

        struct buffer_head * bh;

        struct sysv_inode * raw_inode;

        unsigned int ino, block;

        ino = inode->i_ino;

        if (!ino || ino > sb->sv_ninodes) {

                printk("Bad inode number on dev %s: %d is out of range\n",

                       bdevname(inode->i_dev), ino);

                return 0;

        }

        raw_inode = sysv_raw_inode(sb, ino, &bh);

        if (!raw_inode) {

                printk("unable to read i-node block\n");

                return 0;

        }

        raw_inode->i_mode = cpu_to_fs16(sb, inode->i_mode);

        raw_inode->i_uid = cpu_to_fs16(sb, fs_high2lowuid(inode->i_uid));

        raw_inode->i_gid = cpu_to_fs16(sb, fs_high2lowgid(inode->i_gid));

        raw_inode->i_nlink = cpu_to_fs16(sb, inode->i_nlink);

        raw_inode->i_size = cpu_to_fs32(sb, inode->i_size);

        raw_inode->i_atime = cpu_to_fs32(sb, inode->i_atime);

        raw_inode->i_mtime = cpu_to_fs32(sb, inode->i_mtime);

        raw_inode->i_ctime = cpu_to_fs32(sb, inode->i_ctime);

        if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))

                inode->u.sysv_i.i_data[0] =

                        cpu_to_fs32(sb, kdev_t_to_nr(inode->i_rdev));

        for (block = 0; block < 10+1+1+1; block++)

                write3byte(sb, (unsigned char*)&inode->u.sysv_i.i_data[block],

                        &raw_inode->i_a.i_addb[3*block]);

        mark_buffer_dirty(bh);

        return bh;

}

void sysv_write_inode(struct inode * inode, int wait)

{

        struct buffer_head *bh;

        lock_kernel();

        bh = sysv_update_inode(inode);

        brelse(bh);

        unlock_kernel();

}

int sysv_sync_inode(struct inode * inode)

{

        int err = 0;

        struct buffer_head *bh;

        bh = sysv_update_inode(inode);

        if (bh && buffer_dirty(bh)) {

                ll_rw_block(WRITE, 1, &bh);

                wait_on_buffer(bh);

                if (buffer_req(bh) && !buffer_uptodate(bh)) {

                        printk ("IO error syncing sysv inode [%s:%08lx]\n",

                                bdevname(inode->i_dev), inode->i_ino);

                        err = -1;

                }

        }

        else if (!bh)

                err = -1;

        brelse (bh);

        return err;

}

static void sysv_delete_inode(struct inode *inode)

{

        lock_kernel();

        inode->i_size = 0;

        sysv_truncate(inode);

        sysv_free_inode(inode);

        unlock_kernel();

}

struct super_operations sysv_sops = {

        read_inode:     sysv_read_inode,

        write_inode:    sysv_write_inode,

        delete_inode:   sysv_delete_inode,

        put_super:      sysv_put_super,

        write_super:    sysv_write_super,

        statfs:         sysv_statfs,

};