patch-2.1.21 linux/fs/xiafs/inode.c

• Lines: 539
• Date: Thu Jan 1 02:00:00 1970
• Orig file: v2.1.20/linux/fs/xiafs/inode.c
• Orig date: Mon Dec 30 15:39:14 1996

diff -u --recursive --new-file v2.1.20/linux/fs/xiafs/inode.c linux/fs/xiafs/inode.c
@@ -1,538 +0,0 @@
-/*
- *  linux/fs/xiafs/inode.c
- *
- *  Copyright (C) Q. Frank Xia, 1993.
- *
- *  Based on Linus' minix/inode.c
- *  Copyright (C) Linus Torvalds, 1991, 1992.
- *
- *  This software may be redistributed per Linux Copyright.
- */
-
-#include <linux/module.h>
-
-#include <linux/sched.h>
-#include <linux/xia_fs.h>
-#include <linux/kernel.h>
-#include <linux/mm.h>
-#include <linux/string.h>
-#include <linux/stat.h>
-#include <linux/locks.h>
-#include <asm/system.h>
-#include <asm/uaccess.h>
-
-#include "xiafs_mac.h"
-
-static u_long random_nr;
-
-void xiafs_put_inode(struct inode *inode)
-{
-    if (inode->i_nlink)
-        return;
-    inode->i_size = 0;
-    xiafs_truncate(inode);
-    xiafs_free_inode(inode);
-}
-
-void xiafs_put_super(struct super_block *sb)
-{
-    int i;
-
-    lock_super(sb);
-    sb->s_dev = 0;
-    for(i = 0 ; i < _XIAFS_IMAP_SLOTS ; i++)
-        brelse(sb->u.xiafs_sb.s_imap_buf[i]);
-    for(i = 0 ; i < _XIAFS_ZMAP_SLOTS ; i++)
-        brelse(sb->u.xiafs_sb.s_zmap_buf[i]);
-    unlock_super(sb);
-    MOD_DEC_USE_COUNT;
-}
-
-static struct super_operations xiafs_sops = {
-    xiafs_read_inode,
-    NULL,
-    xiafs_write_inode,
-    xiafs_put_inode,
-    xiafs_put_super,
-    NULL,
-    xiafs_statfs,
-    NULL
-};
-
-struct super_block *xiafs_read_super(struct super_block *s, void *data,
-				     int silent)
-{
-    struct buffer_head *bh;
-    struct xiafs_super_block *sp;
-    int i, z;
-    kdev_t dev;
-
-    MOD_INC_USE_COUNT;
-    dev = s->s_dev;
-    lock_super(s);
-
-    set_blocksize(dev, BLOCK_SIZE);
-
-    if (!(bh = bread(dev, 0, BLOCK_SIZE))) {
-        s->s_dev = 0;
-	unlock_super(s);
-	printk("XIA-FS: read super_block failed (%s %d)\n", WHERE_ERR);
-	MOD_DEC_USE_COUNT;
-	return NULL;
-    }
-    sp = (struct xiafs_super_block *) bh->b_data;
-    s->s_magic = sp->s_magic;
-    if (s->s_magic != _XIAFS_SUPER_MAGIC) {
-        s->s_dev = 0;
-	unlock_super(s);
-	brelse(bh);
-	if (!silent)
-		printk("VFS: Can't find a xiafs filesystem on dev "
-		       "%s.\n", kdevname(dev));
-	MOD_DEC_USE_COUNT;
-	return NULL;
-    }
-    s->s_blocksize = sp->s_zone_size;
-    s->s_blocksize_bits = 10 + sp->s_zone_shift;
-    if (s->s_blocksize != BLOCK_SIZE &&
-	(s->s_blocksize == 1024 || s->s_blocksize == 2048 ||
-	 s->s_blocksize == 4096)) {
-      brelse(bh);
-      set_blocksize(dev, s->s_blocksize);
-      bh = bread (dev, 0,  s->s_blocksize);
-      if(!bh) {
-	MOD_DEC_USE_COUNT;
-	return NULL;
-      }
-      sp = (struct xiafs_super_block *) (((char *)bh->b_data) + BLOCK_SIZE) ;
-    };
-    s->u.xiafs_sb.s_nzones = sp->s_nzones;
-    s->u.xiafs_sb.s_ninodes = sp->s_ninodes;
-    s->u.xiafs_sb.s_ndatazones = sp->s_ndatazones;
-    s->u.xiafs_sb.s_imap_zones = sp->s_imap_zones;
-    s->u.xiafs_sb.s_zmap_zones = sp->s_zmap_zones;
-    s->u.xiafs_sb.s_firstdatazone = sp->s_firstdatazone;
-    s->u.xiafs_sb.s_zone_shift = sp->s_zone_shift;
-    s->u.xiafs_sb.s_max_size = sp->s_max_size;
-    brelse(bh);
-    for (i=0;i < _XIAFS_IMAP_SLOTS;i++) {
-        s->u.xiafs_sb.s_imap_buf[i] = NULL;
-	s->u.xiafs_sb.s_imap_iznr[i] = -1;
-    }
-    for (i=0;i < _XIAFS_ZMAP_SLOTS;i++) {
-        s->u.xiafs_sb.s_zmap_buf[i] = NULL;
-	s->u.xiafs_sb.s_zmap_zznr[i] = -1;
-    }
-    z=1;
-    if ( s->u.xiafs_sb.s_imap_zones > _XIAFS_IMAP_SLOTS )
-        s->u.xiafs_sb.s_imap_cached=1;
-    else {
-        s->u.xiafs_sb.s_imap_cached=0;
-	for (i=0 ; i < s->u.xiafs_sb.s_imap_zones ; i++) {
-	    if (!(s->u.xiafs_sb.s_imap_buf[i]=bread(dev, z++, XIAFS_ZSIZE(s))))
-	        goto xiafs_read_super_fail;
-	    s->u.xiafs_sb.s_imap_iznr[i]=i;
-	}
-    }
-    if ( s->u.xiafs_sb.s_zmap_zones > _XIAFS_ZMAP_SLOTS )
-        s->u.xiafs_sb.s_zmap_cached=1;
-    else {
-        s->u.xiafs_sb.s_zmap_cached=0;
-	for (i=0 ; i < s->u.xiafs_sb.s_zmap_zones ; i++) {
-	    if (!(s->u.xiafs_sb.s_zmap_buf[i]=bread(dev, z++, XIAFS_ZSIZE(s))))
-	        goto xiafs_read_super_fail;
-	    s->u.xiafs_sb.s_zmap_zznr[i]=i;
-	}
-    }
-    /* set up enough so that it can read an inode */
-    s->s_dev = dev;
-    s->s_op = &xiafs_sops;
-    s->s_mounted = iget(s, _XIAFS_ROOT_INO);
-    if (!s->s_mounted)
-        goto xiafs_read_super_fail;
-    unlock_super(s);
-    random_nr=CURRENT_TIME;
-    return s;
-
-xiafs_read_super_fail:
-    for(i=0; i < _XIAFS_IMAP_SLOTS; i++)
-        brelse(s->u.xiafs_sb.s_imap_buf[i]);
-    for(i=0; i < _XIAFS_ZMAP_SLOTS; i++)
-        brelse(s->u.xiafs_sb.s_zmap_buf[i]);
-    s->s_dev = 0;
-    unlock_super(s);
-    printk("XIA-FS: read bitmaps failed (%s %d)\n", WHERE_ERR);
-    MOD_DEC_USE_COUNT;
-    return NULL;
-}
-
-void xiafs_statfs(struct super_block *sb, struct statfs *buf, int bufsiz)
-{
-	struct statfs tmp;
-
-	tmp.f_type = _XIAFS_SUPER_MAGIC;
-	tmp.f_bsize = XIAFS_ZSIZE(sb);
-	tmp.f_blocks = sb->u.xiafs_sb.s_ndatazones;
-	tmp.f_bfree = xiafs_count_free_zones(sb);
-	tmp.f_bavail = tmp.f_bfree;
-	tmp.f_files = sb->u.xiafs_sb.s_ninodes;
-	tmp.f_ffree = xiafs_count_free_inodes(sb);
-	tmp.f_namelen = _XIAFS_NAME_LEN;
-	copy_to_user(buf, &tmp, bufsiz);
-}
-
-static int zone_bmap(struct buffer_head * bh, int nr)
-{
-    int tmp;
-
-    if (!bh)
-        return 0;
-    tmp = ((u_long *) bh->b_data)[nr];
-    brelse(bh);
-    return tmp;
-}
-
-int xiafs_bmap(struct inode * inode,int zone)
-{
-    int i;
-
-    if (zone < 0) {
-        printk("XIA-FS: block < 0 (%s %d)\n", WHERE_ERR);
-	return 0;
-    }
-    if (zone >= 8+(1+XIAFS_ADDRS_PER_Z(inode->i_sb))*XIAFS_ADDRS_PER_Z(inode->i_sb)) {
-        printk("XIA-FS: zone > big (%s %d)\n", WHERE_ERR);
-	return 0;
-    }
-    if (!IS_RDONLY (inode)) {
-	inode->i_atime = CURRENT_TIME;
-	inode->i_dirt = 1;
-    }
-    if (zone < 8)
-        return inode->u.xiafs_i.i_zone[zone];
-    zone -= 8;
-    if (zone < XIAFS_ADDRS_PER_Z(inode->i_sb)) {
-        i = inode->u.xiafs_i.i_ind_zone;
-	if (i)
-	    i = zone_bmap(bread(inode->i_dev, i, XIAFS_ZSIZE(inode->i_sb)), zone);
-	return i;
-    }
-    zone -= XIAFS_ADDRS_PER_Z(inode->i_sb);
-    i = inode->u.xiafs_i.i_dind_zone;
-    if (i)
-      i = zone_bmap(bread(inode->i_dev, i, XIAFS_ZSIZE(inode->i_sb)),
-		    zone >> XIAFS_ADDRS_PER_Z_BITS(inode->i_sb));
-    if (i)
-      i= zone_bmap(bread(inode->i_dev,i, XIAFS_ZSIZE(inode->i_sb)),
-		   zone & (XIAFS_ADDRS_PER_Z(inode->i_sb)-1));
-    return i;
-}
-
-static u_long get_prev_addr(struct inode * inode, int zone)
-{
-    u_long tmp;
-
-    if (zone > 0)
-        while (--zone >= 0)		/* only files with holes suffer */
-	    if ((tmp=xiafs_bmap(inode, zone)))
-	        return tmp;
-    random_nr=(random_nr+23)%inode->i_sb->u.xiafs_sb.s_ndatazones;
-    return random_nr + inode->i_sb->u.xiafs_sb.s_firstdatazone;
-}
-
-static struct buffer_head *
-dt_getblk(struct inode * inode, u_long *lp, int create, u_long prev_addr)
-{
-    int tmp;
-    struct buffer_head * result;
-
-repeat:
-    if ((tmp=*lp)) {
-        result = getblk(inode->i_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
-	if (tmp == *lp)
-	    return result;
-	brelse(result);
-	goto repeat;
-    }
-    if (!create)
-        return NULL;
-    tmp = xiafs_new_zone(inode->i_sb, prev_addr);
-    if (!tmp)
-        return NULL;
-    result = getblk(inode->i_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
-    if (*lp) {
-        xiafs_free_zone(inode->i_sb, tmp);
-        brelse(result);
-        goto repeat;
-    }
-    *lp = tmp;
-    inode->i_blocks+=2 << XIAFS_ZSHIFT(inode->i_sb);
-    return result;
-}
-
-static struct buffer_head *
-indt_getblk(struct inode * inode, struct buffer_head * bh,
-	    int nr, int create, u_long prev_addr)
-{
-    int tmp;
-    u_long *lp;
-    struct buffer_head * result;
-
-    if (!bh)
-        return NULL;
-    if (!buffer_uptodate(bh)) {
-        ll_rw_block(READ, 1, &bh);
-	wait_on_buffer(bh);
-	if (!buffer_uptodate(bh)) {
-	    brelse(bh);
-	    return NULL;
-	}
-    }
-    lp = nr + (u_long *) bh->b_data;
-repeat:
-    if ((tmp=*lp)) {
-        result = getblk(bh->b_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
-	if (tmp == *lp) {
-	    brelse(bh);
-	    return result;
-	}
-	brelse(result);
-	goto repeat;
-    }
-    if (!create) {
-        brelse(bh);
-	return NULL;
-    }
-    tmp = xiafs_new_zone(inode->i_sb, prev_addr);
-    if (!tmp) {
-        brelse(bh);
-	return NULL;
-    }
-    result = getblk(bh->b_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
-    if (*lp) {
-        xiafs_free_zone(inode->i_sb, tmp);
-	brelse(result);
-	goto repeat;
-    }
-    *lp = tmp;
-    inode->i_blocks+=2 << XIAFS_ZSHIFT(inode->i_sb);
-    mark_buffer_dirty(bh, 1);
-    brelse(bh);
-    return result;
-}
-
-struct buffer_head * xiafs_getblk(struct inode * inode, int zone, int create)
-{
-    struct buffer_head * bh;
-    u_long prev_addr=0;
-
-    if (zone<0) {
-        printk("XIA-FS: zone < 0 (%s %d)\n", WHERE_ERR);
-	return NULL;
-    }
-    if (zone >= 8+(1+XIAFS_ADDRS_PER_Z(inode->i_sb))*XIAFS_ADDRS_PER_Z(inode->i_sb)) {
-	if (!create)
-            printk("XIA-FS: zone > big (%s %d)\n", WHERE_ERR);
-	return NULL;
-    }
-    if (create)
-        prev_addr=get_prev_addr(inode, zone);
-    if (zone < 8)
-        return dt_getblk(inode, zone+inode->u.xiafs_i.i_zone, create, prev_addr);
-    zone -= 8;
-    if (zone < XIAFS_ADDRS_PER_Z(inode->i_sb)) {
-        bh = dt_getblk(inode, &(inode->u.xiafs_i.i_ind_zone), create, prev_addr);
-	bh = indt_getblk(inode, bh, zone, create, prev_addr);
-	return bh;
-    }
-    zone -= XIAFS_ADDRS_PER_Z(inode->i_sb);
-    bh = dt_getblk(inode, &(inode->u.xiafs_i.i_dind_zone), create, prev_addr);
-    bh = indt_getblk(inode, bh, zone>>XIAFS_ADDRS_PER_Z_BITS(inode->i_sb),
-		     create, prev_addr);
-    bh = indt_getblk(inode, bh, zone&(XIAFS_ADDRS_PER_Z(inode->i_sb)-1),
-		     create, prev_addr);
-    return bh;
-}
-
-struct buffer_head * xiafs_bread(struct inode * inode, int zone, int create)
-{
-    struct buffer_head * bh;
-
-    bh = xiafs_getblk(inode, zone, create);
-    if (!bh || buffer_uptodate(bh))
-        return bh;
-    ll_rw_block(READ, 1, &bh);
-    wait_on_buffer(bh);
-    if (buffer_uptodate(bh))
-        return bh;
-    brelse(bh);
-    return NULL;
-}
-
-void xiafs_read_inode(struct inode * inode)
-{
-    struct buffer_head * bh;
-    struct xiafs_inode * raw_inode;
-    int zone;
-    ino_t ino;
-
-    ino = inode->i_ino;
-    inode->i_op = NULL;
-    inode->i_mode=0;
-    if (!ino || ino > inode->i_sb->u.xiafs_sb.s_ninodes) {
-    	printk("XIA-FS: bad inode number (%s %d)\n", WHERE_ERR);
-    	return;
-    }
-    zone = 1 + inode->i_sb->u.xiafs_sb.s_imap_zones +
-		inode->i_sb->u.xiafs_sb.s_zmap_zones +
-		(ino-1)/ XIAFS_INODES_PER_Z(inode->i_sb);
-    if (!(bh=bread(inode->i_dev, zone, XIAFS_ZSIZE(inode->i_sb)))) {
-    	printk("XIA-FS: read i-node zone failed (%s %d)\n", WHERE_ERR);
-    	return;
-    }
-    raw_inode = ((struct xiafs_inode *) bh->b_data) +
-                 ((ino-1) & (XIAFS_INODES_PER_Z(inode->i_sb) - 1));
-    inode->i_mode = raw_inode->i_mode;
-    inode->i_uid = raw_inode->i_uid;
-    inode->i_gid = raw_inode->i_gid;
-    inode->i_nlink = raw_inode->i_nlinks;
-    inode->i_size = raw_inode->i_size;
-    inode->i_mtime = raw_inode->i_mtime;
-    inode->i_atime = raw_inode->i_atime;
-    inode->i_ctime = raw_inode->i_ctime;
-    inode->i_blksize = XIAFS_ZSIZE(inode->i_sb);
-    if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
-        inode->i_blocks=0;
-        inode->i_rdev = to_kdev_t(raw_inode->i_zone[0]);
-    } else {
-        XIAFS_GET_BLOCKS(raw_inode, inode->i_blocks);
-        for (zone = 0; zone < 8; zone++)
-	    inode->u.xiafs_i.i_zone[zone] = raw_inode->i_zone[zone] & 0xffffff;
-	inode->u.xiafs_i.i_ind_zone       = raw_inode->i_ind_zone   & 0xffffff;
-	inode->u.xiafs_i.i_dind_zone      = raw_inode->i_dind_zone  & 0xffffff;
-    }
-    brelse(bh);
-    if (S_ISREG(inode->i_mode))
-        inode->i_op = &xiafs_file_inode_operations;
-    else if (S_ISDIR(inode->i_mode))
-        inode->i_op = &xiafs_dir_inode_operations;
-    else if (S_ISLNK(inode->i_mode))
-        inode->i_op = &xiafs_symlink_inode_operations;
-    else if (S_ISCHR(inode->i_mode))
-        inode->i_op = &chrdev_inode_operations;
-    else if (S_ISBLK(inode->i_mode))
-        inode->i_op = &blkdev_inode_operations;
-    else if (S_ISFIFO(inode->i_mode))
-    	init_fifo(inode);
-}
-
-static struct buffer_head *  xiafs_update_inode(struct inode * inode)
-{
-    struct buffer_head * bh;
-    struct xiafs_inode * raw_inode;
-    int zone;
-    ino_t ino;
-
-    if (IS_RDONLY (inode)) {
-	printk("XIA-FS: write_inode on a read-only filesystem (%s %d)\n", WHERE_ERR);
-	inode->i_dirt = 0;
-	return 0;
-    }
-
-    ino = inode->i_ino;
-    if (!ino || ino > inode->i_sb->u.xiafs_sb.s_ninodes) {
-    	printk("XIA-FS: bad inode number (%s %d)\n", WHERE_ERR);
-    	inode->i_dirt=0;
-    	return 0;
-    }
-    zone = 1 + inode->i_sb->u.xiafs_sb.s_imap_zones +
-                inode->i_sb->u.xiafs_sb.s_zmap_zones +
-		(ino-1) / XIAFS_INODES_PER_Z(inode->i_sb);
-    if (!(bh=bread(inode->i_dev, zone, XIAFS_ZSIZE(inode->i_sb)))) {
-        printk("XIA-FS: read i-node zone failed (%s %d)\n", WHERE_ERR);
-	inode->i_dirt=0;
-	return 0;
-    }
-    raw_inode = ((struct xiafs_inode *)bh->b_data) +
-                ((ino-1) & (XIAFS_INODES_PER_Z(inode->i_sb) -1));
-    raw_inode->i_mode = inode->i_mode;
-    raw_inode->i_uid = inode->i_uid;
-    raw_inode->i_gid = inode->i_gid;
-    raw_inode->i_nlinks = inode->i_nlink;
-    raw_inode->i_size = inode->i_size;
-    raw_inode->i_atime = inode->i_atime;
-    raw_inode->i_ctime = inode->i_ctime;
-    raw_inode->i_mtime = inode->i_mtime;
-    if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
-        raw_inode->i_zone[0] = kdev_t_to_nr(inode->i_rdev);
-    else {
-        XIAFS_PUT_BLOCKS(raw_inode, inode->i_blocks);
-        for (zone = 0; zone < 8; zone++)
-	    raw_inode->i_zone[zone] = (raw_inode->i_zone[zone] & 0xff000000)
-	                             | (inode->u.xiafs_i.i_zone[zone] & 0xffffff);
-	raw_inode->i_ind_zone = (raw_inode->i_ind_zone & 0xff000000)
-	                             | (inode->u.xiafs_i.i_ind_zone   & 0xffffff);
-	raw_inode->i_dind_zone = (raw_inode->i_dind_zone & 0xff000000)
-	                             | (inode->u.xiafs_i.i_dind_zone  & 0xffffff);
-    }
-    inode->i_dirt=0;
-    mark_buffer_dirty(bh, 1);
-    return bh;
-}
-
-
-void xiafs_write_inode(struct inode * inode)
-{
-    struct buffer_head * bh;
-    bh = xiafs_update_inode(inode);
-    brelse (bh);
-}
-
-int xiafs_sync_inode (struct inode *inode)
-{
-    int err = 0;
-    struct buffer_head *bh;
-
-    bh = xiafs_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 xiafs inode [%s:%lu]\n",
-		    kdevname(inode->i_dev), inode->i_ino);
-    	    err = -1;
-    	}
-    }
-    else if (!bh)
-    	err = -1;
-    brelse (bh);
-    return err;
-}
-
-/* Every kernel module contains stuff like this. */
-
-static struct file_system_type xiafs_fs_type = {
-	xiafs_read_super, "xiafs", 1, NULL
-};
-
-int init_xiafs_fs(void)
-{
-        return register_filesystem(&xiafs_fs_type);
-}
-
-#ifdef MODULE
-EXPORT_NO_SYMBOLS;
-
-int init_module(void)
-{
-	return init_xiafs_fs();
-}
-
-void cleanup_module(void)
-{
-	unregister_filesystem(&xiafs_fs_type);
-}
-
-#endif