1 #include <linux/kernel.h> 2 #include <linux/fs.h> 3 #include <linux/buffer_head.h> 4 #include <asm/div64.h> 5 #include "omfs.h" 6 7 unsigned long omfs_count_free(struct super_block *sb) 8 { 9 unsigned int i; 10 unsigned long sum = 0; 11 struct omfs_sb_info *sbi = OMFS_SB(sb); 12 int nbits = sb->s_blocksize * 8; 13 14 for (i = 0; i < sbi->s_imap_size; i++) 15 sum += nbits - bitmap_weight(sbi->s_imap[i], nbits); 16 17 return sum; 18 } 19 20 /* 21 * Counts the run of zero bits starting at bit up to max. 22 * It handles the case where a run might spill over a buffer. 23 * Called with bitmap lock. 24 */ 25 static int count_run(unsigned long **addr, int nbits, 26 int addrlen, int bit, int max) 27 { 28 int count = 0; 29 int x; 30 31 for (; addrlen > 0; addrlen--, addr++) { 32 x = find_next_bit(*addr, nbits, bit); 33 count += x - bit; 34 35 if (x < nbits || count > max) 36 return min(count, max); 37 38 bit = 0; 39 } 40 return min(count, max); 41 } 42 43 /* 44 * Sets or clears the run of count bits starting with bit. 45 * Called with bitmap lock. 46 */ 47 static int set_run(struct super_block *sb, int map, 48 int nbits, int bit, int count, int set) 49 { 50 int i; 51 int err; 52 struct buffer_head *bh; 53 struct omfs_sb_info *sbi = OMFS_SB(sb); 54 55 err = -ENOMEM; 56 bh = sb_bread(sb, clus_to_blk(sbi, sbi->s_bitmap_ino) + map); 57 if (!bh) 58 goto out; 59 60 for (i = 0; i < count; i++, bit++) { 61 if (bit >= nbits) { 62 bit = 0; 63 map++; 64 65 mark_buffer_dirty(bh); 66 brelse(bh); 67 bh = sb_bread(sb, 68 clus_to_blk(sbi, sbi->s_bitmap_ino) + map); 69 if (!bh) 70 goto out; 71 } 72 if (set) { 73 set_bit(bit, sbi->s_imap[map]); 74 set_bit(bit, (unsigned long *)bh->b_data); 75 } else { 76 clear_bit(bit, sbi->s_imap[map]); 77 clear_bit(bit, (unsigned long *)bh->b_data); 78 } 79 } 80 mark_buffer_dirty(bh); 81 brelse(bh); 82 err = 0; 83 out: 84 return err; 85 } 86 87 /* 88 * Tries to allocate exactly one block. Returns true if successful. 89 */ 90 int omfs_allocate_block(struct super_block *sb, u64 block) 91 { 92 struct buffer_head *bh; 93 struct omfs_sb_info *sbi = OMFS_SB(sb); 94 int bits_per_entry = 8 * sb->s_blocksize; 95 unsigned int map, bit; 96 int ret = 0; 97 u64 tmp; 98 99 tmp = block; 100 bit = do_div(tmp, bits_per_entry); 101 map = tmp; 102 103 mutex_lock(&sbi->s_bitmap_lock); 104 if (map >= sbi->s_imap_size || test_and_set_bit(bit, sbi->s_imap[map])) 105 goto out; 106 107 if (sbi->s_bitmap_ino > 0) { 108 bh = sb_bread(sb, clus_to_blk(sbi, sbi->s_bitmap_ino) + map); 109 if (!bh) 110 goto out; 111 112 set_bit(bit, (unsigned long *)bh->b_data); 113 mark_buffer_dirty(bh); 114 brelse(bh); 115 } 116 ret = 1; 117 out: 118 mutex_unlock(&sbi->s_bitmap_lock); 119 return ret; 120 } 121 122 123 /* 124 * Tries to allocate a set of blocks. The request size depends on the 125 * type: for inodes, we must allocate sbi->s_mirrors blocks, and for file 126 * blocks, we try to allocate sbi->s_clustersize, but can always get away 127 * with just one block. 128 */ 129 int omfs_allocate_range(struct super_block *sb, 130 int min_request, 131 int max_request, 132 u64 *return_block, 133 int *return_size) 134 { 135 struct omfs_sb_info *sbi = OMFS_SB(sb); 136 int bits_per_entry = 8 * sb->s_blocksize; 137 int ret = 0; 138 int i, run, bit; 139 140 mutex_lock(&sbi->s_bitmap_lock); 141 for (i = 0; i < sbi->s_imap_size; i++) { 142 bit = 0; 143 while (bit < bits_per_entry) { 144 bit = find_next_zero_bit(sbi->s_imap[i], bits_per_entry, 145 bit); 146 147 if (bit == bits_per_entry) 148 break; 149 150 run = count_run(&sbi->s_imap[i], bits_per_entry, 151 sbi->s_imap_size-i, bit, max_request); 152 153 if (run >= min_request) 154 goto found; 155 bit += run; 156 } 157 } 158 ret = -ENOSPC; 159 goto out; 160 161 found: 162 *return_block = i * bits_per_entry + bit; 163 *return_size = run; 164 ret = set_run(sb, i, bits_per_entry, bit, run, 1); 165 166 out: 167 mutex_unlock(&sbi->s_bitmap_lock); 168 return ret; 169 } 170 171 /* 172 * Clears count bits starting at a given block. 173 */ 174 int omfs_clear_range(struct super_block *sb, u64 block, int count) 175 { 176 struct omfs_sb_info *sbi = OMFS_SB(sb); 177 int bits_per_entry = 8 * sb->s_blocksize; 178 u64 tmp; 179 unsigned int map, bit; 180 int ret; 181 182 tmp = block; 183 bit = do_div(tmp, bits_per_entry); 184 map = tmp; 185 186 if (map >= sbi->s_imap_size) 187 return 0; 188 189 mutex_lock(&sbi->s_bitmap_lock); 190 ret = set_run(sb, map, bits_per_entry, bit, count, 0); 191 mutex_unlock(&sbi->s_bitmap_lock); 192 return ret; 193 } 194