fs/qnx4/bitmap.c

   1 /*
   2  * QNX4 file system, Linux implementation.
   3  *
   4  * Version : 0.2.1
   5  *
   6  * Using parts of the xiafs filesystem.
   7  *
   8  * History :
   9  *
  10  * 28-05-1998 by Richard Frowijn : first release.
  11  * 20-06-1998 by Frank Denis : basic optimisations.
  12  * 25-06-1998 by Frank Denis : qnx4_is_free, qnx4_set_bitmap, qnx4_bmap .
  13  * 28-06-1998 by Frank Denis : qnx4_free_inode (to be fixed) .
  14  */
  15
  16 #include <linux/config.h>
  17 #include <linux/sched.h>
  18 #include <linux/qnx4_fs.h>
  19 #include <linux/stat.h>
  20 #include <linux/kernel.h>
  21 #include <linux/string.h>
  22
  23 #include <asm/bitops.h>
  24
  25 int qnx4_new_block(struct super_block *sb)
  26 {
  27         return 0;
  28 }
  29
  30 void count_bits(const register char *bmPart, register int size,
  31                 int *const tf)
  32 {
  33         char b;
  34         int tot = *tf;
  35
  36         if (size > QNX4_BLOCK_SIZE) {
  37                 size = QNX4_BLOCK_SIZE;
  38         }
  39         do {
  40                 b = *bmPart++;
  41                 if ((b & 1) == 0)
  42                         tot++;
  43                 if ((b & 2) == 0)
  44                         tot++;
  45                 if ((b & 4) == 0)
  46                         tot++;
  47                 if ((b & 8) == 0)
  48                         tot++;
  49                 if ((b & 16) == 0)
  50                         tot++;
  51                 if ((b & 32) == 0)
  52                         tot++;
  53                 if ((b & 64) == 0)
  54                         tot++;
  55                 if ((b & 128) == 0)
  56                         tot++;
  57                 size--;
  58         } while (size != 0);
  59         *tf = tot;
  60 }
  61
  62 unsigned long qnx4_count_free_blocks(struct super_block *sb)
  63 {
  64         int start = sb->u.qnx4_sb.BitMap->di_first_xtnt.xtnt_blk - 1;
  65         int total = 0;
  66         int total_free = 0;
  67         int offset = 0;
  68         int size = sb->u.qnx4_sb.BitMap->di_size;
  69         struct buffer_head *bh;
  70
  71         while (total < size) {
  72                 if ((bh = bread(sb->s_dev, start + offset, QNX4_BLOCK_SIZE)) == NULL) {
  73                         printk("qnx4: I/O error in counting free blocks\n");
  74                         break;
  75                 }
  76                 count_bits(bh->b_data, size - total, &total_free);
  77                 brelse(bh);
  78                 total += QNX4_BLOCK_SIZE;
  79         }
  80
  81         return total_free;
  82 }
  83
  84 unsigned long qnx4_count_free_inodes(struct super_block *sb)
  85 {
  86         return qnx4_count_free_blocks(sb) * QNX4_INODES_PER_BLOCK;      /* FIXME */
  87 }
  88
  89 #ifdef CONFIG_QNX4FS_RW
  90
  91 int qnx4_is_free(struct super_block *sb, long block)
  92 {
  93         int start = sb->u.qnx4_sb.BitMap->di_first_xtnt.xtnt_blk - 1;
  94         int size = sb->u.qnx4_sb.BitMap->di_size;
  95         struct buffer_head *bh;
  96         const char *g;
  97         int ret = -EIO;
  98
  99         start += block / (QNX4_BLOCK_SIZE * 8);
 100         QNX4DEBUG(("qnx4: is_free requesting block [%lu], bitmap in block [%lu]\n",
 101                    (unsigned long) block, (unsigned long) start));
 102         (void) size;            /* CHECKME */
 103         bh = bread(sb->s_dev, start, QNX4_BLOCK_SIZE);
 104         if (bh == NULL) {
 105                 return -EIO;
 106         }
 107         g = bh->b_data + (block % QNX4_BLOCK_SIZE);
 108         if (((*g) & (1 << (block % 8))) == 0) {
 109                 QNX4DEBUG(("qnx4: is_free -> block is free\n"));
 110                 ret = 1;
 111         } else {
 112                 QNX4DEBUG(("qnx4: is_free -> block is busy\n"));
 113                 ret = 0;
 114         }
 115         brelse(bh);
 116
 117         return ret;
 118 }
 119
 120 int qnx4_set_bitmap(struct super_block *sb, long block, int busy)
 121 {
 122         int start = sb->u.qnx4_sb.BitMap->di_first_xtnt.xtnt_blk - 1;
 123         int size = sb->u.qnx4_sb.BitMap->di_size;
 124         struct buffer_head *bh;
 125         char *g;
 126
 127         start += block / (QNX4_BLOCK_SIZE * 8);
 128         QNX4DEBUG(("qnx4: set_bitmap requesting block [%lu], bitmap in block [%lu]\n",
 129                    (unsigned long) block, (unsigned long) start));
 130         (void) size;            /* CHECKME */
 131         bh = bread(sb->s_dev, start, QNX4_BLOCK_SIZE);
 132         if (bh == NULL) {
 133                 return -EIO;
 134         }
 135         g = bh->b_data + (block % QNX4_BLOCK_SIZE);
 136         if (busy == 0) {
 137                 (*g) &= ~(1 << (block % 8));
 138         } else {
 139                 (*g) |= (1 << (block % 8));
 140         }
 141         mark_buffer_dirty(bh, 1);
 142         brelse(bh);
 143
 144         return 0;
 145 }
 146
 147 static void qnx4_clear_inode(struct inode *inode)
 148 {
 149         struct qnx4_inode_info *qnx4_ino = &inode->u.qnx4_i;
 150
 151         memset(qnx4_ino->i_reserved, 0, sizeof qnx4_ino->i_reserved);
 152         qnx4_ino->i_size = 0;
 153         qnx4_ino->i_num_xtnts = 0;
 154         qnx4_ino->i_mode = 0;
 155         qnx4_ino->i_status = 0;
 156 }
 157
 158 void qnx4_free_inode(struct inode *inode)
 159 {
 160         if (!inode) {
 161                 return;
 162         }
 163         if (!inode->i_dev) {
 164                 printk("free_inode: inode has no device\n");
 165                 return;
 166         }
 167         if (inode->i_count > 1) {
 168                 printk("free_inode: inode has count=%d\n", inode->i_count);
 169                 return;
 170         }
 171         if (inode->i_nlink) {
 172                 printk("free_inode: inode has nlink=%d\n", inode->i_nlink);
 173                 return;
 174         }
 175         if (!inode->i_sb) {
 176                 printk("free_inode: inode on nonexistent device\n");
 177                 return;
 178         }
 179         if (inode->i_ino < 1) {
 180                 printk("free_inode: inode 0 or nonexistent inode\n");
 181                 return;
 182         }
 183         qnx4_clear_inode(inode);
 184         clear_inode(inode);
 185 }
 186
 187 #endif