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