| /* |
| * 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/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/segment.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); |
| } |
| |
| 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, dev; |
| |
| 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); |
| 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 0x%04x.\n", |
| dev); |
| 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) 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); |
| return NULL; |
| } |
| |
| void xiafs_statfs(struct super_block *sb, struct statfs *buf) |
| { |
| long tmp; |
| |
| put_fs_long(_XIAFS_SUPER_MAGIC, &buf->f_type); |
| put_fs_long(XIAFS_ZSIZE(sb), &buf->f_bsize); |
| put_fs_long(sb->u.xiafs_sb.s_ndatazones, &buf->f_blocks); |
| tmp = xiafs_count_free_zones(sb); |
| put_fs_long(tmp, &buf->f_bfree); |
| put_fs_long(tmp, &buf->f_bavail); |
| put_fs_long(sb->u.xiafs_sb.s_ninodes, &buf->f_files); |
| put_fs_long(xiafs_count_free_inodes(sb), &buf->f_ffree); |
| put_fs_long(_XIAFS_NAME_LEN, &buf->f_namelen); |
| /* don't know what should be put in buf->f_fsid */ |
| } |
| |
| 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 (!bh->b_uptodate) { |
| ll_rw_block(READ, 1, &bh); |
| wait_on_buffer(bh); |
| if (!bh->b_uptodate) { |
| 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); |
| bh->b_dirt = 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 || bh->b_uptodate) |
| return bh; |
| ll_rw_block(READ, 1, &bh); |
| wait_on_buffer(bh); |
| if (bh->b_uptodate) |
| 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 = 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] = 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; |
| bh->b_dirt=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 && bh->b_dirt) |
| { |
| ll_rw_block(WRITE, 1, &bh); |
| wait_on_buffer(bh); |
| if (bh->b_req && !bh->b_uptodate) |
| { |
| printk ("IO error syncing xiafs inode [%04x:%08x]\n", |
| inode->i_dev, inode->i_ino); |
| err = -1; |
| } |
| } |
| else if (!bh) |
| err = -1; |
| brelse (bh); |
| return err; |
| } |