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, n: 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, n: *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(lock: &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(lock: &sbi->s_lock); |
82 | return; |
83 | } |
84 | memset(bh->b_data, 0, sb->s_blocksize); |
85 | *(__fs16*)bh->b_data = cpu_to_fs16(sbi, n: 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, n: count); |
95 | fs32_add(sbi, n: sbi->s_free_blocks, d: 1); |
96 | dirty_sb(sb); |
97 | mutex_unlock(lock: &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, n: *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, n: nr); |
118 | |
119 | *sbi->s_bcache_count = cpu_to_fs16(sbi, n: 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, n: 1); |
135 | goto Enospc; |
136 | } |
137 | count = fs16_to_cpu(sbi, n: *(__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, n: 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, n: sbi->s_free_blocks, d: -1); |
150 | dirty_sb(sb); |
151 | mutex_unlock(lock: &sbi->s_lock); |
152 | return nr; |
153 | |
154 | Enospc: |
155 | mutex_unlock(lock: &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, n: *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, n: *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, n: 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, n: *(__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(lock: &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, n: count); |
237 | dirty_sb(sb); |
238 | } |
239 | goto done; |
240 | } |
241 | |