i386/linux/linux-0.99/fs/xiafs/inode.c

   1 /*
   2  *  linux/fs/xiafs/inode.c
   3  *
   4  *  Copyright (C) Q. Frank Xia, 1993.
   5  *
   6  *  Based on Linus' minix/inode.c
   7  *  Copyright (C) Linus Torvalds, 1991, 1992.
   8  *
   9  *  This software may be redistributed per Linux Copyright.
  10  */
  11
  12 #include <linux/sched.h>
  13 #include <linux/xia_fs.h>
  14 #include <linux/kernel.h>
  15 #include <linux/mm.h>
  16 #include <linux/string.h>
  17 #include <linux/stat.h>
  18 #include <linux/locks.h>
  19 #include <asm/system.h>
  20 #include <asm/segment.h>
  21
  22 #include "xiafs_mac.h"
  23
  24 static u_long random_nr;
  25
  26 void xiafs_put_inode(struct inode *inode)
  27 {
  28     if (inode->i_nlink)
  29         return;
  30     inode->i_size = 0;
  31     xiafs_truncate(inode);
  32     xiafs_free_inode(inode);
  33 }
  34
  35 void xiafs_put_super(struct super_block *sb)
  36 {
  37     int i;
  38
  39     lock_super(sb);
  40     sb->s_dev = 0;
  41     for(i = 0 ; i < _XIAFS_IMAP_SLOTS ; i++)
  42         brelse(sb->u.xiafs_sb.s_imap_buf[i]);
  43     for(i = 0 ; i < _XIAFS_ZMAP_SLOTS ; i++)
  44         brelse(sb->u.xiafs_sb.s_zmap_buf[i]);
  45     unlock_super(sb);
  46 }
  47
  48 static struct super_operations xiafs_sops = {
  49     xiafs_read_inode,
  50     NULL,
  51     xiafs_write_inode,
  52     xiafs_put_inode,
  53     xiafs_put_super,
  54     NULL,
  55     xiafs_statfs,
  56     NULL
  57 };
  58
  59 struct super_block *xiafs_read_super(struct super_block *s, void *data,
  60                                      int silent)
  61 {
  62     struct buffer_head *bh;
  63     struct xiafs_super_block *sp;
  64     int i, z, dev;
  65
  66     dev=s->s_dev;
  67     lock_super(s);
  68
  69     set_blocksize(dev, BLOCK_SIZE);
  70
  71     if (!(bh = bread(dev, 0, BLOCK_SIZE))) {
  72         s->s_dev=0;
  73         unlock_super(s);
  74         printk("XIA-FS: read super_block failed (%s %d)\n", WHERE_ERR);
  75         return NULL;
  76     }
  77     sp = (struct xiafs_super_block *) bh->b_data;
  78     s->s_magic = sp->s_magic;
  79     if (s->s_magic != _XIAFS_SUPER_MAGIC) {
  80         s->s_dev = 0;
  81         unlock_super(s);
  82         brelse(bh);
  83         if (!silent)
  84                 printk("VFS: Can't find a xiafs filesystem on dev 0x%04x.\n",
  85                    dev);
  86         return NULL;
  87     }
  88     s->s_blocksize = sp->s_zone_size;
  89     s->s_blocksize_bits = 10 + sp->s_zone_shift;
  90     if (s->s_blocksize != BLOCK_SIZE &&
  91         (s->s_blocksize == 1024 || s->s_blocksize == 2048 ||
  92          s->s_blocksize == 4096)) {
  93       brelse(bh);
  94       set_blocksize(dev, s->s_blocksize);
  95       bh = bread (dev, 0,  s->s_blocksize);
  96       if(!bh) return NULL;
  97       sp = (struct xiafs_super_block *) (((char *)bh->b_data) + BLOCK_SIZE) ;
  98     };
  99     s->u.xiafs_sb.s_nzones = sp->s_nzones;
 100     s->u.xiafs_sb.s_ninodes = sp->s_ninodes;
 101     s->u.xiafs_sb.s_ndatazones = sp->s_ndatazones;
 102     s->u.xiafs_sb.s_imap_zones = sp->s_imap_zones;
 103     s->u.xiafs_sb.s_zmap_zones = sp->s_zmap_zones;
 104     s->u.xiafs_sb.s_firstdatazone = sp->s_firstdatazone;
 105     s->u.xiafs_sb.s_zone_shift = sp->s_zone_shift;
 106     s->u.xiafs_sb.s_max_size = sp->s_max_size;
 107     brelse(bh);
 108     for (i=0;i < _XIAFS_IMAP_SLOTS;i++) {
 109         s->u.xiafs_sb.s_imap_buf[i] = NULL;
 110         s->u.xiafs_sb.s_imap_iznr[i] = -1;
 111     }
 112     for (i=0;i < _XIAFS_ZMAP_SLOTS;i++) {
 113         s->u.xiafs_sb.s_zmap_buf[i] = NULL;
 114         s->u.xiafs_sb.s_zmap_zznr[i] = -1;
 115     }
 116     z=1;
 117     if ( s->u.xiafs_sb.s_imap_zones > _XIAFS_IMAP_SLOTS )
 118         s->u.xiafs_sb.s_imap_cached=1;
 119     else {
 120         s->u.xiafs_sb.s_imap_cached=0;
 121         for (i=0 ; i < s->u.xiafs_sb.s_imap_zones ; i++) {
 122             if (!(s->u.xiafs_sb.s_imap_buf[i]=bread(dev, z++, XIAFS_ZSIZE(s))))
 123                 goto xiafs_read_super_fail;
 124             s->u.xiafs_sb.s_imap_iznr[i]=i;
 125         }
 126     }
 127     if ( s->u.xiafs_sb.s_zmap_zones > _XIAFS_ZMAP_SLOTS )
 128         s->u.xiafs_sb.s_zmap_cached=1;
 129     else {
 130         s->u.xiafs_sb.s_zmap_cached=0;
 131         for (i=0 ; i < s->u.xiafs_sb.s_zmap_zones ; i++) {
 132             if (!(s->u.xiafs_sb.s_zmap_buf[i]=bread(dev, z++, XIAFS_ZSIZE(s))))
 133                 goto xiafs_read_super_fail;
 134             s->u.xiafs_sb.s_zmap_zznr[i]=i;
 135         }
 136     }
 137     /* set up enough so that it can read an inode */
 138     s->s_dev = dev;
 139     s->s_op = &xiafs_sops;
 140     s->s_mounted = iget(s, _XIAFS_ROOT_INO);
 141     if (!s->s_mounted)
 142         goto xiafs_read_super_fail;
 143     unlock_super(s);
 144     random_nr=CURRENT_TIME;
 145     return s;
 146
 147 xiafs_read_super_fail:
 148     for(i=0; i < _XIAFS_IMAP_SLOTS; i++)
 149         brelse(s->u.xiafs_sb.s_imap_buf[i]);
 150     for(i=0; i < _XIAFS_ZMAP_SLOTS; i++)
 151         brelse(s->u.xiafs_sb.s_zmap_buf[i]);
 152     s->s_dev=0;
 153     unlock_super(s);
 154     printk("XIA-FS: read bitmaps failed (%s %d)\n", WHERE_ERR);
 155     return NULL;
 156 }
 157
 158 void xiafs_statfs(struct super_block *sb, struct statfs *buf)
 159 {
 160     long tmp;
 161
 162     put_fs_long(_XIAFS_SUPER_MAGIC, &buf->f_type);
 163     put_fs_long(XIAFS_ZSIZE(sb), &buf->f_bsize);
 164     put_fs_long(sb->u.xiafs_sb.s_ndatazones, &buf->f_blocks);
 165     tmp = xiafs_count_free_zones(sb);
 166     put_fs_long(tmp, &buf->f_bfree);
 167     put_fs_long(tmp, &buf->f_bavail);
 168     put_fs_long(sb->u.xiafs_sb.s_ninodes, &buf->f_files);
 169     put_fs_long(xiafs_count_free_inodes(sb), &buf->f_ffree);
 170     put_fs_long(_XIAFS_NAME_LEN, &buf->f_namelen);
 171     /* don't know what should be put in buf->f_fsid */
 172 }
 173
 174 static int zone_bmap(struct buffer_head * bh, int nr)
 175 {
 176     int tmp;
 177
 178     if (!bh)
 179         return 0;
 180     tmp = ((u_long *) bh->b_data)[nr];
 181     brelse(bh);
 182     return tmp;
 183 }
 184
 185 int xiafs_bmap(struct inode * inode,int zone)
 186 {
 187     int i;
 188
 189     if (zone < 0) {
 190         printk("XIA-FS: block < 0 (%s %d)\n", WHERE_ERR);
 191         return 0;
 192     }
 193     if (zone >= 8+(1+XIAFS_ADDRS_PER_Z(inode->i_sb))*XIAFS_ADDRS_PER_Z(inode->i_sb)) {
 194         printk("XIA-FS: zone > big (%s %d)\n", WHERE_ERR);
 195         return 0;
 196     }
 197     if (!IS_RDONLY (inode)) {
 198         inode->i_atime = CURRENT_TIME;
 199         inode->i_dirt = 1;
 200     }
 201     if (zone < 8)
 202         return inode->u.xiafs_i.i_zone[zone];
 203     zone -= 8;
 204     if (zone < XIAFS_ADDRS_PER_Z(inode->i_sb)) {
 205         i = inode->u.xiafs_i.i_ind_zone;
 206         if (i)
 207             i = zone_bmap(bread(inode->i_dev, i, XIAFS_ZSIZE(inode->i_sb)), zone);
 208         return i;
 209     }
 210     zone -= XIAFS_ADDRS_PER_Z(inode->i_sb);
 211     i = inode->u.xiafs_i.i_dind_zone;
 212     if (i)
 213       i = zone_bmap(bread(inode->i_dev, i, XIAFS_ZSIZE(inode->i_sb)),
 214                     zone >> XIAFS_ADDRS_PER_Z_BITS(inode->i_sb));
 215     if (i)
 216       i= zone_bmap(bread(inode->i_dev,i, XIAFS_ZSIZE(inode->i_sb)),
 217                    zone & (XIAFS_ADDRS_PER_Z(inode->i_sb)-1));
 218     return i;
 219 }
 220
 221 static u_long get_prev_addr(struct inode * inode, int zone)
 222 {
 223     u_long tmp;
 224
 225     if (zone > 0)
 226         while (--zone >= 0)             /* only files with holes suffer */
 227             if ((tmp=xiafs_bmap(inode, zone)))
 228                 return tmp;
 229     random_nr=(random_nr+23)%inode->i_sb->u.xiafs_sb.s_ndatazones;
 230     return random_nr + inode->i_sb->u.xiafs_sb.s_firstdatazone;
 231 }
 232
 233 static struct buffer_head *
 234 dt_getblk(struct inode * inode, u_long *lp, int create, u_long prev_addr)
 235 {
 236     int tmp;
 237     struct buffer_head * result;
 238
 239 repeat:
 240     if ((tmp=*lp)) {
 241         result = getblk(inode->i_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
 242         if (tmp == *lp)
 243             return result;
 244         brelse(result);
 245         goto repeat;
 246     }
 247     if (!create)
 248         return NULL;
 249     tmp = xiafs_new_zone(inode->i_sb, prev_addr);
 250     if (!tmp)
 251         return NULL;
 252     result = getblk(inode->i_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
 253     if (*lp) {
 254         xiafs_free_zone(inode->i_sb, tmp);
 255         brelse(result);
 256         goto repeat;
 257     }
 258     *lp = tmp;
 259     inode->i_blocks+=2 << XIAFS_ZSHIFT(inode->i_sb);
 260     return result;
 261 }
 262
 263 static struct buffer_head *
 264 indt_getblk(struct inode * inode, struct buffer_head * bh,
 265             int nr, int create, u_long prev_addr)
 266 {
 267     int tmp;
 268     u_long *lp;
 269     struct buffer_head * result;
 270
 271     if (!bh)
 272         return NULL;
 273     if (!bh->b_uptodate) {
 274         ll_rw_block(READ, 1, &bh);
 275         wait_on_buffer(bh);
 276         if (!bh->b_uptodate) {
 277             brelse(bh);
 278             return NULL;
 279         }
 280     }
 281     lp = nr + (u_long *) bh->b_data;
 282 repeat:
 283     if ((tmp=*lp)) {
 284         result = getblk(bh->b_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
 285         if (tmp == *lp) {
 286             brelse(bh);
 287             return result;
 288         }
 289         brelse(result);
 290         goto repeat;
 291     }
 292     if (!create) {
 293         brelse(bh);
 294         return NULL;
 295     }
 296     tmp = xiafs_new_zone(inode->i_sb, prev_addr);
 297     if (!tmp) {
 298         brelse(bh);
 299         return NULL;
 300     }
 301     result = getblk(bh->b_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
 302     if (*lp) {
 303         xiafs_free_zone(inode->i_sb, tmp);
 304         brelse(result);
 305         goto repeat;
 306     }
 307     *lp = tmp;
 308     inode->i_blocks+=2 << XIAFS_ZSHIFT(inode->i_sb);
 309     bh->b_dirt = 1;
 310     brelse(bh);
 311     return result;
 312 }
 313
 314 struct buffer_head * xiafs_getblk(struct inode * inode, int zone, int create)
 315 {
 316     struct buffer_head * bh;
 317     u_long prev_addr=0;
 318
 319     if (zone<0) {
 320         printk("XIA-FS: zone < 0 (%s %d)\n", WHERE_ERR);
 321         return NULL;
 322     }
 323     if (zone >= 8+(1+XIAFS_ADDRS_PER_Z(inode->i_sb))*XIAFS_ADDRS_PER_Z(inode->i_sb)) {
 324         if (!create)
 325             printk("XIA-FS: zone > big (%s %d)\n", WHERE_ERR);
 326         return NULL;
 327     }
 328     if (create)
 329         prev_addr=get_prev_addr(inode, zone);
 330     if (zone < 8)
 331         return dt_getblk(inode, zone+inode->u.xiafs_i.i_zone, create, prev_addr);
 332     zone -= 8;
 333     if (zone < XIAFS_ADDRS_PER_Z(inode->i_sb)) {
 334         bh = dt_getblk(inode, &(inode->u.xiafs_i.i_ind_zone), create, prev_addr);
 335         bh = indt_getblk(inode, bh, zone, create, prev_addr);
 336         return bh;
 337     }
 338     zone -= XIAFS_ADDRS_PER_Z(inode->i_sb);
 339     bh = dt_getblk(inode, &(inode->u.xiafs_i.i_dind_zone), create, prev_addr);
 340     bh = indt_getblk(inode, bh, zone>>XIAFS_ADDRS_PER_Z_BITS(inode->i_sb),
 341                      create, prev_addr);
 342     bh = indt_getblk(inode, bh, zone&(XIAFS_ADDRS_PER_Z(inode->i_sb)-1),
 343                      create, prev_addr);
 344     return bh;
 345 }
 346
 347 struct buffer_head * xiafs_bread(struct inode * inode, int zone, int create)
 348 {
 349     struct buffer_head * bh;
 350
 351     bh = xiafs_getblk(inode, zone, create);
 352     if (!bh || bh->b_uptodate)
 353         return bh;
 354     ll_rw_block(READ, 1, &bh);
 355     wait_on_buffer(bh);
 356     if (bh->b_uptodate)
 357         return bh;
 358     brelse(bh);
 359     return NULL;
 360 }
 361
 362 void xiafs_read_inode(struct inode * inode)
 363 {
 364     struct buffer_head * bh;
 365     struct xiafs_inode * raw_inode;
 366     int zone;
 367     ino_t ino;
 368
 369     ino = inode->i_ino;
 370     inode->i_op = NULL;
 371     inode->i_mode=0;
 372     if (!ino || ino > inode->i_sb->u.xiafs_sb.s_ninodes) {
 373         printk("XIA-FS: bad inode number (%s %d)\n", WHERE_ERR);
 374         return;
 375     }
 376     zone = 1 + inode->i_sb->u.xiafs_sb.s_imap_zones +
 377                 inode->i_sb->u.xiafs_sb.s_zmap_zones +
 378                 (ino-1)/ XIAFS_INODES_PER_Z(inode->i_sb);
 379     if (!(bh=bread(inode->i_dev, zone, XIAFS_ZSIZE(inode->i_sb)))) {
 380         printk("XIA-FS: read i-node zone failed (%s %d)\n", WHERE_ERR);
 381         return;
 382     }
 383     raw_inode = ((struct xiafs_inode *) bh->b_data) +
 384                  ((ino-1) & (XIAFS_INODES_PER_Z(inode->i_sb) - 1));
 385     inode->i_mode = raw_inode->i_mode;
 386     inode->i_uid = raw_inode->i_uid;
 387     inode->i_gid = raw_inode->i_gid;
 388     inode->i_nlink = raw_inode->i_nlinks;
 389     inode->i_size = raw_inode->i_size;
 390     inode->i_mtime = raw_inode->i_mtime;
 391     inode->i_atime = raw_inode->i_atime;
 392     inode->i_ctime = raw_inode->i_ctime;
 393     inode->i_blksize = XIAFS_ZSIZE(inode->i_sb);
 394     if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
 395         inode->i_blocks=0;
 396         inode->i_rdev = raw_inode->i_zone[0];
 397     } else {
 398         XIAFS_GET_BLOCKS(raw_inode, inode->i_blocks);
 399         for (zone = 0; zone < 8; zone++)
 400             inode->u.xiafs_i.i_zone[zone] = raw_inode->i_zone[zone] & 0xffffff;
 401         inode->u.xiafs_i.i_ind_zone       = raw_inode->i_ind_zone   & 0xffffff;
 402         inode->u.xiafs_i.i_dind_zone      = raw_inode->i_dind_zone  & 0xffffff;
 403     }
 404     brelse(bh);
 405     if (S_ISREG(inode->i_mode))
 406         inode->i_op = &xiafs_file_inode_operations;
 407     else if (S_ISDIR(inode->i_mode))
 408         inode->i_op = &xiafs_dir_inode_operations;
 409     else if (S_ISLNK(inode->i_mode))
 410         inode->i_op = &xiafs_symlink_inode_operations;
 411     else if (S_ISCHR(inode->i_mode))
 412         inode->i_op = &chrdev_inode_operations;
 413     else if (S_ISBLK(inode->i_mode))
 414         inode->i_op = &blkdev_inode_operations;
 415     else if (S_ISFIFO(inode->i_mode))
 416         init_fifo(inode);
 417 }
 418
 419 static struct buffer_head *  xiafs_update_inode(struct inode * inode)
 420 {
 421     struct buffer_head * bh;
 422     struct xiafs_inode * raw_inode;
 423     int zone;
 424     ino_t ino;
 425
 426     if (IS_RDONLY (inode)) {
 427         printk("XIA-FS: write_inode on a read-only filesystem (%s %d)\n", WHERE_ERR);
 428         inode->i_dirt = 0;
 429         return 0;
 430     }
 431
 432     ino = inode->i_ino;
 433     if (!ino || ino > inode->i_sb->u.xiafs_sb.s_ninodes) {
 434         printk("XIA-FS: bad inode number (%s %d)\n", WHERE_ERR);
 435         inode->i_dirt=0;
 436         return 0;
 437     }
 438     zone = 1 + inode->i_sb->u.xiafs_sb.s_imap_zones +
 439                 inode->i_sb->u.xiafs_sb.s_zmap_zones +
 440                 (ino-1) / XIAFS_INODES_PER_Z(inode->i_sb);
 441     if (!(bh=bread(inode->i_dev, zone, XIAFS_ZSIZE(inode->i_sb)))) {
 442         printk("XIA-FS: read i-node zone failed (%s %d)\n", WHERE_ERR);
 443         inode->i_dirt=0;
 444         return 0;
 445     }
 446     raw_inode = ((struct xiafs_inode *)bh->b_data) +
 447                 ((ino-1) & (XIAFS_INODES_PER_Z(inode->i_sb) -1));
 448     raw_inode->i_mode = inode->i_mode;
 449     raw_inode->i_uid = inode->i_uid;
 450     raw_inode->i_gid = inode->i_gid;
 451     raw_inode->i_nlinks = inode->i_nlink;
 452     raw_inode->i_size = inode->i_size;
 453     raw_inode->i_atime = inode->i_atime;
 454     raw_inode->i_ctime = inode->i_ctime;
 455     raw_inode->i_mtime = inode->i_mtime;
 456     if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
 457         raw_inode->i_zone[0] = inode->i_rdev;
 458     else {
 459         XIAFS_PUT_BLOCKS(raw_inode, inode->i_blocks);
 460         for (zone = 0; zone < 8; zone++)
 461             raw_inode->i_zone[zone] = (raw_inode->i_zone[zone] & 0xff000000)
 462                                      | (inode->u.xiafs_i.i_zone[zone] & 0xffffff);
 463         raw_inode->i_ind_zone = (raw_inode->i_ind_zone & 0xff000000)
 464                                      | (inode->u.xiafs_i.i_ind_zone   & 0xffffff);
 465         raw_inode->i_dind_zone = (raw_inode->i_dind_zone & 0xff000000)
 466                                      | (inode->u.xiafs_i.i_dind_zone  & 0xffffff);
 467     }
 468     inode->i_dirt=0;
 469     bh->b_dirt=1;
 470     return bh;
 471 }
 472
 473
 474 void xiafs_write_inode(struct inode * inode)
 475 {
 476     struct buffer_head * bh;
 477     bh = xiafs_update_inode(inode);
 478     brelse (bh);
 479 }
 480
 481 int xiafs_sync_inode (struct inode *inode)
 482 {
 483     int err = 0;
 484     struct buffer_head *bh;
 485
 486     bh = xiafs_update_inode(inode);
 487     if (bh && bh->b_dirt)
 488     {
 489         ll_rw_block(WRITE, 1, &bh);
 490         wait_on_buffer(bh);
 491         if (bh->b_req && !bh->b_uptodate)
 492         {
 493             printk ("IO error syncing xiafs inode [%04X:%lu]\n",
 494                     inode->i_dev, inode->i_ino);
 495             err = -1;
 496         }
 497     }
 498     else if (!bh)
 499         err = -1;
 500     brelse (bh);
 501     return err;
 502 }