1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Copyright (C) 2012-2013 Samsung Electronics Co., Ltd. |
4 | */ |
5 | |
6 | #include <linux/blkdev.h> |
7 | #include <linux/slab.h> |
8 | #include <linux/bitmap.h> |
9 | #include <linux/buffer_head.h> |
10 | |
11 | #include "exfat_raw.h" |
12 | #include "exfat_fs.h" |
13 | |
14 | #if BITS_PER_LONG == 32 |
15 | #define __le_long __le32 |
16 | #define lel_to_cpu(A) le32_to_cpu(A) |
17 | #define cpu_to_lel(A) cpu_to_le32(A) |
18 | #elif BITS_PER_LONG == 64 |
19 | #define __le_long __le64 |
20 | #define lel_to_cpu(A) le64_to_cpu(A) |
21 | #define cpu_to_lel(A) cpu_to_le64(A) |
22 | #else |
23 | #error "BITS_PER_LONG not 32 or 64" |
24 | #endif |
25 | |
26 | /* |
27 | * Allocation Bitmap Management Functions |
28 | */ |
29 | static int exfat_allocate_bitmap(struct super_block *sb, |
30 | struct exfat_dentry *ep) |
31 | { |
32 | struct exfat_sb_info *sbi = EXFAT_SB(sb); |
33 | long long map_size; |
34 | unsigned int i, need_map_size; |
35 | sector_t sector; |
36 | |
37 | sbi->map_clu = le32_to_cpu(ep->dentry.bitmap.start_clu); |
38 | map_size = le64_to_cpu(ep->dentry.bitmap.size); |
39 | need_map_size = ((EXFAT_DATA_CLUSTER_COUNT(sbi) - 1) / BITS_PER_BYTE) |
40 | + 1; |
41 | if (need_map_size != map_size) { |
42 | exfat_err(sb, "bogus allocation bitmap size(need : %u, cur : %lld)" , |
43 | need_map_size, map_size); |
44 | /* |
45 | * Only allowed when bogus allocation |
46 | * bitmap size is large |
47 | */ |
48 | if (need_map_size > map_size) |
49 | return -EIO; |
50 | } |
51 | sbi->map_sectors = ((need_map_size - 1) >> |
52 | (sb->s_blocksize_bits)) + 1; |
53 | sbi->vol_amap = kvmalloc_array(n: sbi->map_sectors, |
54 | size: sizeof(struct buffer_head *), GFP_KERNEL); |
55 | if (!sbi->vol_amap) |
56 | return -ENOMEM; |
57 | |
58 | sector = exfat_cluster_to_sector(sbi, clus: sbi->map_clu); |
59 | for (i = 0; i < sbi->map_sectors; i++) { |
60 | sbi->vol_amap[i] = sb_bread(sb, block: sector + i); |
61 | if (!sbi->vol_amap[i]) { |
62 | /* release all buffers and free vol_amap */ |
63 | int j = 0; |
64 | |
65 | while (j < i) |
66 | brelse(bh: sbi->vol_amap[j++]); |
67 | |
68 | kvfree(addr: sbi->vol_amap); |
69 | sbi->vol_amap = NULL; |
70 | return -EIO; |
71 | } |
72 | } |
73 | |
74 | return 0; |
75 | } |
76 | |
77 | int exfat_load_bitmap(struct super_block *sb) |
78 | { |
79 | unsigned int i, type; |
80 | struct exfat_chain clu; |
81 | struct exfat_sb_info *sbi = EXFAT_SB(sb); |
82 | |
83 | exfat_chain_set(ec: &clu, dir: sbi->root_dir, size: 0, ALLOC_FAT_CHAIN); |
84 | while (clu.dir != EXFAT_EOF_CLUSTER) { |
85 | for (i = 0; i < sbi->dentries_per_clu; i++) { |
86 | struct exfat_dentry *ep; |
87 | struct buffer_head *bh; |
88 | |
89 | ep = exfat_get_dentry(sb, p_dir: &clu, entry: i, bh: &bh); |
90 | if (!ep) |
91 | return -EIO; |
92 | |
93 | type = exfat_get_entry_type(p_entry: ep); |
94 | if (type == TYPE_UNUSED) |
95 | break; |
96 | if (type != TYPE_BITMAP) |
97 | continue; |
98 | if (ep->dentry.bitmap.flags == 0x0) { |
99 | int err; |
100 | |
101 | err = exfat_allocate_bitmap(sb, ep); |
102 | brelse(bh); |
103 | return err; |
104 | } |
105 | brelse(bh); |
106 | } |
107 | |
108 | if (exfat_get_next_cluster(sb, &clu.dir)) |
109 | return -EIO; |
110 | } |
111 | |
112 | return -EINVAL; |
113 | } |
114 | |
115 | void exfat_free_bitmap(struct exfat_sb_info *sbi) |
116 | { |
117 | int i; |
118 | |
119 | for (i = 0; i < sbi->map_sectors; i++) |
120 | __brelse(sbi->vol_amap[i]); |
121 | |
122 | kvfree(addr: sbi->vol_amap); |
123 | } |
124 | |
125 | int exfat_set_bitmap(struct inode *inode, unsigned int clu, bool sync) |
126 | { |
127 | int i, b; |
128 | unsigned int ent_idx; |
129 | struct super_block *sb = inode->i_sb; |
130 | struct exfat_sb_info *sbi = EXFAT_SB(sb); |
131 | |
132 | if (!is_valid_cluster(sbi, clus: clu)) |
133 | return -EINVAL; |
134 | |
135 | ent_idx = CLUSTER_TO_BITMAP_ENT(clu); |
136 | i = BITMAP_OFFSET_SECTOR_INDEX(sb, ent_idx); |
137 | b = BITMAP_OFFSET_BIT_IN_SECTOR(sb, ent_idx); |
138 | |
139 | set_bit_le(nr: b, addr: sbi->vol_amap[i]->b_data); |
140 | exfat_update_bh(bh: sbi->vol_amap[i], sync); |
141 | return 0; |
142 | } |
143 | |
144 | void exfat_clear_bitmap(struct inode *inode, unsigned int clu, bool sync) |
145 | { |
146 | int i, b; |
147 | unsigned int ent_idx; |
148 | struct super_block *sb = inode->i_sb; |
149 | struct exfat_sb_info *sbi = EXFAT_SB(sb); |
150 | struct exfat_mount_options *opts = &sbi->options; |
151 | |
152 | if (!is_valid_cluster(sbi, clus: clu)) |
153 | return; |
154 | |
155 | ent_idx = CLUSTER_TO_BITMAP_ENT(clu); |
156 | i = BITMAP_OFFSET_SECTOR_INDEX(sb, ent_idx); |
157 | b = BITMAP_OFFSET_BIT_IN_SECTOR(sb, ent_idx); |
158 | |
159 | clear_bit_le(nr: b, addr: sbi->vol_amap[i]->b_data); |
160 | exfat_update_bh(bh: sbi->vol_amap[i], sync); |
161 | |
162 | if (opts->discard) { |
163 | int ret_discard; |
164 | |
165 | ret_discard = sb_issue_discard(sb, |
166 | block: exfat_cluster_to_sector(sbi, clus: clu), |
167 | nr_blocks: (1 << sbi->sect_per_clus_bits), GFP_NOFS, flags: 0); |
168 | |
169 | if (ret_discard == -EOPNOTSUPP) { |
170 | exfat_err(sb, "discard not supported by device, disabling" ); |
171 | opts->discard = 0; |
172 | } |
173 | } |
174 | } |
175 | |
176 | /* |
177 | * If the value of "clu" is 0, it means cluster 2 which is the first cluster of |
178 | * the cluster heap. |
179 | */ |
180 | unsigned int exfat_find_free_bitmap(struct super_block *sb, unsigned int clu) |
181 | { |
182 | unsigned int i, map_i, map_b, ent_idx; |
183 | unsigned int clu_base, clu_free; |
184 | unsigned long clu_bits, clu_mask; |
185 | struct exfat_sb_info *sbi = EXFAT_SB(sb); |
186 | __le_long bitval; |
187 | |
188 | WARN_ON(clu < EXFAT_FIRST_CLUSTER); |
189 | ent_idx = ALIGN_DOWN(CLUSTER_TO_BITMAP_ENT(clu), BITS_PER_LONG); |
190 | clu_base = BITMAP_ENT_TO_CLUSTER(ent_idx); |
191 | clu_mask = IGNORED_BITS_REMAINED(clu, clu_base); |
192 | |
193 | map_i = BITMAP_OFFSET_SECTOR_INDEX(sb, ent_idx); |
194 | map_b = BITMAP_OFFSET_BYTE_IN_SECTOR(sb, ent_idx); |
195 | |
196 | for (i = EXFAT_FIRST_CLUSTER; i < sbi->num_clusters; |
197 | i += BITS_PER_LONG) { |
198 | bitval = *(__le_long *)(sbi->vol_amap[map_i]->b_data + map_b); |
199 | if (clu_mask > 0) { |
200 | bitval |= cpu_to_lel(clu_mask); |
201 | clu_mask = 0; |
202 | } |
203 | if (lel_to_cpu(bitval) != ULONG_MAX) { |
204 | clu_bits = lel_to_cpu(bitval); |
205 | clu_free = clu_base + ffz(clu_bits); |
206 | if (clu_free < sbi->num_clusters) |
207 | return clu_free; |
208 | } |
209 | clu_base += BITS_PER_LONG; |
210 | map_b += sizeof(long); |
211 | |
212 | if (map_b >= sb->s_blocksize || |
213 | clu_base >= sbi->num_clusters) { |
214 | if (++map_i >= sbi->map_sectors) { |
215 | clu_base = EXFAT_FIRST_CLUSTER; |
216 | map_i = 0; |
217 | } |
218 | map_b = 0; |
219 | } |
220 | } |
221 | |
222 | return EXFAT_EOF_CLUSTER; |
223 | } |
224 | |
225 | int exfat_count_used_clusters(struct super_block *sb, unsigned int *ret_count) |
226 | { |
227 | struct exfat_sb_info *sbi = EXFAT_SB(sb); |
228 | unsigned int count = 0; |
229 | unsigned int i, map_i = 0, map_b = 0; |
230 | unsigned int total_clus = EXFAT_DATA_CLUSTER_COUNT(sbi); |
231 | unsigned int last_mask = total_clus & (BITS_PER_LONG - 1); |
232 | unsigned long *bitmap, clu_bits; |
233 | |
234 | total_clus &= ~last_mask; |
235 | for (i = 0; i < total_clus; i += BITS_PER_LONG) { |
236 | bitmap = (void *)(sbi->vol_amap[map_i]->b_data + map_b); |
237 | count += hweight_long(w: *bitmap); |
238 | map_b += sizeof(long); |
239 | if (map_b >= (unsigned int)sb->s_blocksize) { |
240 | map_i++; |
241 | map_b = 0; |
242 | } |
243 | } |
244 | |
245 | if (last_mask) { |
246 | bitmap = (void *)(sbi->vol_amap[map_i]->b_data + map_b); |
247 | clu_bits = lel_to_cpu(*(__le_long *)bitmap); |
248 | count += hweight_long(w: clu_bits & BITMAP_LAST_WORD_MASK(last_mask)); |
249 | } |
250 | |
251 | *ret_count = count; |
252 | return 0; |
253 | } |
254 | |
255 | int exfat_trim_fs(struct inode *inode, struct fstrim_range *range) |
256 | { |
257 | unsigned int trim_begin, trim_end, count, next_free_clu; |
258 | u64 clu_start, clu_end, trim_minlen, trimmed_total = 0; |
259 | struct super_block *sb = inode->i_sb; |
260 | struct exfat_sb_info *sbi = EXFAT_SB(sb); |
261 | int err = 0; |
262 | |
263 | clu_start = max_t(u64, range->start >> sbi->cluster_size_bits, |
264 | EXFAT_FIRST_CLUSTER); |
265 | clu_end = clu_start + (range->len >> sbi->cluster_size_bits) - 1; |
266 | trim_minlen = range->minlen >> sbi->cluster_size_bits; |
267 | |
268 | if (clu_start >= sbi->num_clusters || range->len < sbi->cluster_size) |
269 | return -EINVAL; |
270 | |
271 | if (clu_end >= sbi->num_clusters) |
272 | clu_end = sbi->num_clusters - 1; |
273 | |
274 | mutex_lock(&sbi->bitmap_lock); |
275 | |
276 | trim_begin = trim_end = exfat_find_free_bitmap(sb, clu: clu_start); |
277 | if (trim_begin == EXFAT_EOF_CLUSTER) |
278 | goto unlock; |
279 | |
280 | next_free_clu = exfat_find_free_bitmap(sb, clu: trim_end + 1); |
281 | if (next_free_clu == EXFAT_EOF_CLUSTER) |
282 | goto unlock; |
283 | |
284 | do { |
285 | if (next_free_clu == trim_end + 1) { |
286 | /* extend trim range for continuous free cluster */ |
287 | trim_end++; |
288 | } else { |
289 | /* trim current range if it's larger than trim_minlen */ |
290 | count = trim_end - trim_begin + 1; |
291 | if (count >= trim_minlen) { |
292 | err = sb_issue_discard(sb, |
293 | block: exfat_cluster_to_sector(sbi, clus: trim_begin), |
294 | nr_blocks: count * sbi->sect_per_clus, GFP_NOFS, flags: 0); |
295 | if (err) |
296 | goto unlock; |
297 | |
298 | trimmed_total += count; |
299 | } |
300 | |
301 | /* set next start point of the free hole */ |
302 | trim_begin = trim_end = next_free_clu; |
303 | } |
304 | |
305 | if (next_free_clu >= clu_end) |
306 | break; |
307 | |
308 | if (fatal_signal_pending(current)) { |
309 | err = -ERESTARTSYS; |
310 | goto unlock; |
311 | } |
312 | |
313 | next_free_clu = exfat_find_free_bitmap(sb, clu: next_free_clu + 1); |
314 | } while (next_free_clu != EXFAT_EOF_CLUSTER && |
315 | next_free_clu > trim_end); |
316 | |
317 | /* try to trim remainder */ |
318 | count = trim_end - trim_begin + 1; |
319 | if (count >= trim_minlen) { |
320 | err = sb_issue_discard(sb, block: exfat_cluster_to_sector(sbi, clus: trim_begin), |
321 | nr_blocks: count * sbi->sect_per_clus, GFP_NOFS, flags: 0); |
322 | if (err) |
323 | goto unlock; |
324 | |
325 | trimmed_total += count; |
326 | } |
327 | |
328 | unlock: |
329 | mutex_unlock(lock: &sbi->bitmap_lock); |
330 | range->len = trimmed_total << sbi->cluster_size_bits; |
331 | |
332 | return err; |
333 | } |
334 | |