1 /* 2 * linux/fs/sysv/balloc.c 3 * 4 * minix/bitmap.c 5 * Copyright (C) 1991, 1992 Linus Torvalds 6 * 7 * ext/freelists.c 8 * Copyright (C) 1992 Remy Card (card@masi.ibp.fr) 9 * 10 * xenix/alloc.c 11 * Copyright (C) 1992 Doug Evans 12 * 13 * coh/alloc.c 14 * Copyright (C) 1993 Pascal Haible, Bruno Haible 15 * 16 * sysv/balloc.c 17 * Copyright (C) 1993 Bruno Haible 18 * 19 * This file contains code for allocating/freeing blocks. 20 */ 21 22 #include <linux/buffer_head.h> 23 #include <linux/string.h> 24 #include "sysv.h" 25 26 /* We don't trust the value of 27 sb->sv_sbd2->s_tfree = *sb->sv_free_blocks 28 but we nevertheless keep it up to date. */ 29 30 static inline sysv_zone_t *get_chunk(struct super_block *sb, struct buffer_head *bh) 31 { 32 char *bh_data = bh->b_data; 33 34 if (SYSV_SB(sb)->s_type == FSTYPE_SYSV4) 35 return (sysv_zone_t*)(bh_data+4); 36 else 37 return (sysv_zone_t*)(bh_data+2); 38 } 39 40 /* NOTE NOTE NOTE: nr is a block number _as_ _stored_ _on_ _disk_ */ 41 42 void sysv_free_block(struct super_block * sb, sysv_zone_t nr) 43 { 44 struct sysv_sb_info * sbi = SYSV_SB(sb); 45 struct buffer_head * bh; 46 sysv_zone_t *blocks = sbi->s_bcache; 47 unsigned count; 48 unsigned block = fs32_to_cpu(sbi, nr); 49 50 /* 51 * This code does not work at all for AFS (it has a bitmap 52 * free list). As AFS is supposed to be read-only no one 53 * should call this for an AFS filesystem anyway... 54 */ 55 if (sbi->s_type == FSTYPE_AFS) 56 return; 57 58 if (block < sbi->s_firstdatazone || block >= sbi->s_nzones) { 59 printk("sysv_free_block: trying to free block not in datazone\n"); 60 return; 61 } 62 63 mutex_lock(&sbi->s_lock); 64 count = fs16_to_cpu(sbi, *sbi->s_bcache_count); 65 66 if (count > sbi->s_flc_size) { 67 printk("sysv_free_block: flc_count > flc_size\n"); 68 mutex_unlock(&sbi->s_lock); 69 return; 70 } 71 /* If the free list head in super-block is full, it is copied 72 * into this block being freed, ditto if it's completely empty 73 * (applies only on Coherent). 74 */ 75 if (count == sbi->s_flc_size || count == 0) { 76 block += sbi->s_block_base; 77 bh = sb_getblk(sb, block); 78 if (!bh) { 79 printk("sysv_free_block: getblk() failed\n"); 80 mutex_unlock(&sbi->s_lock); 81 return; 82 } 83 memset(bh->b_data, 0, sb->s_blocksize); 84 *(__fs16*)bh->b_data = cpu_to_fs16(sbi, count); 85 memcpy(get_chunk(sb,bh), blocks, count * sizeof(sysv_zone_t)); 86 mark_buffer_dirty(bh); 87 set_buffer_uptodate(bh); 88 brelse(bh); 89 count = 0; 90 } 91 sbi->s_bcache[count++] = nr; 92 93 *sbi->s_bcache_count = cpu_to_fs16(sbi, count); 94 fs32_add(sbi, sbi->s_free_blocks, 1); 95 dirty_sb(sb); 96 mutex_unlock(&sbi->s_lock); 97 } 98 99 sysv_zone_t sysv_new_block(struct super_block * sb) 100 { 101 struct sysv_sb_info *sbi = SYSV_SB(sb); 102 unsigned int block; 103 sysv_zone_t nr; 104 struct buffer_head * bh; 105 unsigned count; 106 107 mutex_lock(&sbi->s_lock); 108 count = fs16_to_cpu(sbi, *sbi->s_bcache_count); 109 110 if (count == 0) /* Applies only to Coherent FS */ 111 goto Enospc; 112 nr = sbi->s_bcache[--count]; 113 if (nr == 0) /* Applies only to Xenix FS, SystemV FS */ 114 goto Enospc; 115 116 block = fs32_to_cpu(sbi, nr); 117 118 *sbi->s_bcache_count = cpu_to_fs16(sbi, count); 119 120 if (block < sbi->s_firstdatazone || block >= sbi->s_nzones) { 121 printk("sysv_new_block: new block %d is not in data zone\n", 122 block); 123 goto Enospc; 124 } 125 126 if (count == 0) { /* the last block continues the free list */ 127 unsigned count; 128 129 block += sbi->s_block_base; 130 if (!(bh = sb_bread(sb, block))) { 131 printk("sysv_new_block: cannot read free-list block\n"); 132 /* retry this same block next time */ 133 *sbi->s_bcache_count = cpu_to_fs16(sbi, 1); 134 goto Enospc; 135 } 136 count = fs16_to_cpu(sbi, *(__fs16*)bh->b_data); 137 if (count > sbi->s_flc_size) { 138 printk("sysv_new_block: free-list block with >flc_size entries\n"); 139 brelse(bh); 140 goto Enospc; 141 } 142 *sbi->s_bcache_count = cpu_to_fs16(sbi, count); 143 memcpy(sbi->s_bcache, get_chunk(sb, bh), 144 count * sizeof(sysv_zone_t)); 145 brelse(bh); 146 } 147 /* Now the free list head in the superblock is valid again. */ 148 fs32_add(sbi, sbi->s_free_blocks, -1); 149 dirty_sb(sb); 150 mutex_unlock(&sbi->s_lock); 151 return nr; 152 153 Enospc: 154 mutex_unlock(&sbi->s_lock); 155 return 0; 156 } 157 158 unsigned long sysv_count_free_blocks(struct super_block * sb) 159 { 160 struct sysv_sb_info * sbi = SYSV_SB(sb); 161 int sb_count; 162 int count; 163 struct buffer_head * bh = NULL; 164 sysv_zone_t *blocks; 165 unsigned block; 166 int n; 167 168 /* 169 * This code does not work at all for AFS (it has a bitmap 170 * free list). As AFS is supposed to be read-only we just 171 * lie and say it has no free block at all. 172 */ 173 if (sbi->s_type == FSTYPE_AFS) 174 return 0; 175 176 mutex_lock(&sbi->s_lock); 177 sb_count = fs32_to_cpu(sbi, *sbi->s_free_blocks); 178 179 if (0) 180 goto trust_sb; 181 182 /* this causes a lot of disk traffic ... */ 183 count = 0; 184 n = fs16_to_cpu(sbi, *sbi->s_bcache_count); 185 blocks = sbi->s_bcache; 186 while (1) { 187 sysv_zone_t zone; 188 if (n > sbi->s_flc_size) 189 goto E2big; 190 zone = 0; 191 while (n && (zone = blocks[--n]) != 0) 192 count++; 193 if (zone == 0) 194 break; 195 196 block = fs32_to_cpu(sbi, zone); 197 if (bh) 198 brelse(bh); 199 200 if (block < sbi->s_firstdatazone || block >= sbi->s_nzones) 201 goto Einval; 202 block += sbi->s_block_base; 203 bh = sb_bread(sb, block); 204 if (!bh) 205 goto Eio; 206 n = fs16_to_cpu(sbi, *(__fs16*)bh->b_data); 207 blocks = get_chunk(sb, bh); 208 } 209 if (bh) 210 brelse(bh); 211 if (count != sb_count) 212 goto Ecount; 213 done: 214 mutex_unlock(&sbi->s_lock); 215 return count; 216 217 Einval: 218 printk("sysv_count_free_blocks: new block %d is not in data zone\n", 219 block); 220 goto trust_sb; 221 Eio: 222 printk("sysv_count_free_blocks: cannot read free-list block\n"); 223 goto trust_sb; 224 E2big: 225 printk("sysv_count_free_blocks: >flc_size entries in free-list block\n"); 226 if (bh) 227 brelse(bh); 228 trust_sb: 229 count = sb_count; 230 goto done; 231 Ecount: 232 printk("sysv_count_free_blocks: free block count was %d, " 233 "correcting to %d\n", sb_count, count); 234 if (!(sb->s_flags & MS_RDONLY)) { 235 *sbi->s_free_blocks = cpu_to_fs32(sbi, count); 236 dirty_sb(sb); 237 } 238 goto done; 239 } 240