~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~
bitmap.c

Version: ~ [ 2.4.0 ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~
  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 = le32_to_cpu(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 = le32_to_cpu(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                 offset++;
 80         }
 81 
 82         return total_free;
 83 }
 84 
 85 #ifdef CONFIG_QNX4FS_RW
 86 
 87 int qnx4_is_free(struct super_block *sb, long block)
 88 {
 89         int start = le32_to_cpu(sb->u.qnx4_sb.BitMap->di_first_xtnt.xtnt_blk) - 1;
 90         int size = le32_to_cpu(sb->u.qnx4_sb.BitMap->di_size);
 91         struct buffer_head *bh;
 92         const char *g;
 93         int ret = -EIO;
 94 
 95         start += block / (QNX4_BLOCK_SIZE * 8);
 96         QNX4DEBUG(("qnx4: is_free requesting block [%lu], bitmap in block [%lu]\n",
 97                    (unsigned long) block, (unsigned long) start));
 98         (void) size;            /* CHECKME */
 99         bh = bread(sb->s_dev, start, QNX4_BLOCK_SIZE);
100         if (bh == NULL) {
101                 return -EIO;
102         }
103         g = bh->b_data + (block % QNX4_BLOCK_SIZE);
104         if (((*g) & (1 << (block % 8))) == 0) {
105                 QNX4DEBUG(("qnx4: is_free -> block is free\n"));
106                 ret = 1;
107         } else {
108                 QNX4DEBUG(("qnx4: is_free -> block is busy\n"));
109                 ret = 0;
110         }
111         brelse(bh);
112 
113         return ret;
114 }
115 
116 int qnx4_set_bitmap(struct super_block *sb, long block, int busy)
117 {
118         int start = le32_to_cpu(sb->u.qnx4_sb.BitMap->di_first_xtnt.xtnt_blk) - 1;
119         int size = le32_to_cpu(sb->u.qnx4_sb.BitMap->di_size);
120         struct buffer_head *bh;
121         char *g;
122 
123         start += block / (QNX4_BLOCK_SIZE * 8);
124         QNX4DEBUG(("qnx4: set_bitmap requesting block [%lu], bitmap in block [%lu]\n",
125                    (unsigned long) block, (unsigned long) start));
126         (void) size;            /* CHECKME */
127         bh = bread(sb->s_dev, start, QNX4_BLOCK_SIZE);
128         if (bh == NULL) {
129                 return -EIO;
130         }
131         g = bh->b_data + (block % QNX4_BLOCK_SIZE);
132         if (busy == 0) {
133                 (*g) &= ~(1 << (block % 8));
134         } else {
135                 (*g) |= (1 << (block % 8));
136         }
137         mark_buffer_dirty(bh);
138         brelse(bh);
139 
140         return 0;
141 }
142 
143 static void qnx4_clear_inode(struct inode *inode)
144 {
145         struct qnx4_inode_info *qnx4_ino = &inode->u.qnx4_i;
146 
147         memset(qnx4_ino->i_reserved, 0, sizeof qnx4_ino->i_reserved);
148         qnx4_ino->i_size = 0;
149         qnx4_ino->i_num_xtnts = 0;
150         qnx4_ino->i_mode = 0;
151         qnx4_ino->i_status = 0;
152 }
153 
154 void qnx4_free_inode(struct inode *inode)
155 {
156         if (inode->i_ino < 1) {
157                 printk("free_inode: inode 0 or nonexistent inode\n");
158                 return;
159         }
160         qnx4_clear_inode(inode);
161         clear_inode(inode);
162 }
163 
164 #endif
165
~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~
This page was automatically generated by the LXR engine.
Visit the LXR main site for more information.
Linux Cross Reference Linux/fs/qnx4/bitmap.c

Linux Cross Reference
Linux/fs/qnx4/bitmap.c
