Commit | Line | Data |
---|---|---|
1e49a94c NJ |
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/buffer_head.h> | |
9 | ||
10 | #include "exfat_raw.h" | |
11 | #include "exfat_fs.h" | |
12 | ||
13 | static const unsigned char free_bit[] = { | |
14 | 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2,/* 0 ~ 19*/ | |
15 | 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3,/* 20 ~ 39*/ | |
16 | 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2,/* 40 ~ 59*/ | |
17 | 0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4,/* 60 ~ 79*/ | |
18 | 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2,/* 80 ~ 99*/ | |
19 | 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3,/*100 ~ 119*/ | |
20 | 0, 1, 0, 2, 0, 1, 0, 7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2,/*120 ~ 139*/ | |
21 | 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5,/*140 ~ 159*/ | |
22 | 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2,/*160 ~ 179*/ | |
23 | 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3,/*180 ~ 199*/ | |
24 | 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2,/*200 ~ 219*/ | |
25 | 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4,/*220 ~ 239*/ | |
26 | 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0 /*240 ~ 254*/ | |
27 | }; | |
28 | ||
29 | static const unsigned char used_bit[] = { | |
30 | 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3,/* 0 ~ 19*/ | |
31 | 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4,/* 20 ~ 39*/ | |
32 | 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5,/* 40 ~ 59*/ | |
33 | 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,/* 60 ~ 79*/ | |
34 | 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4,/* 80 ~ 99*/ | |
35 | 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6,/*100 ~ 119*/ | |
36 | 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4,/*120 ~ 139*/ | |
37 | 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,/*140 ~ 159*/ | |
38 | 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5,/*160 ~ 179*/ | |
39 | 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5,/*180 ~ 199*/ | |
40 | 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6,/*200 ~ 219*/ | |
41 | 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,/*220 ~ 239*/ | |
42 | 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8 /*240 ~ 255*/ | |
43 | }; | |
44 | ||
45 | /* | |
46 | * Allocation Bitmap Management Functions | |
47 | */ | |
48 | static int exfat_allocate_bitmap(struct super_block *sb, | |
49 | struct exfat_dentry *ep) | |
50 | { | |
51 | struct exfat_sb_info *sbi = EXFAT_SB(sb); | |
52 | long long map_size; | |
53 | unsigned int i, need_map_size; | |
54 | sector_t sector; | |
55 | ||
56 | sbi->map_clu = le32_to_cpu(ep->dentry.bitmap.start_clu); | |
57 | map_size = le64_to_cpu(ep->dentry.bitmap.size); | |
58 | need_map_size = ((EXFAT_DATA_CLUSTER_COUNT(sbi) - 1) / BITS_PER_BYTE) | |
59 | + 1; | |
60 | if (need_map_size != map_size) { | |
d1727d55 JP |
61 | exfat_err(sb, "bogus allocation bitmap size(need : %u, cur : %lld)", |
62 | need_map_size, map_size); | |
1e49a94c NJ |
63 | /* |
64 | * Only allowed when bogus allocation | |
65 | * bitmap size is large | |
66 | */ | |
67 | if (need_map_size > map_size) | |
68 | return -EIO; | |
69 | } | |
70 | sbi->map_sectors = ((need_map_size - 1) >> | |
71 | (sb->s_blocksize_bits)) + 1; | |
72 | sbi->vol_amap = kmalloc_array(sbi->map_sectors, | |
73 | sizeof(struct buffer_head *), GFP_KERNEL); | |
74 | if (!sbi->vol_amap) | |
75 | return -ENOMEM; | |
76 | ||
77 | sector = exfat_cluster_to_sector(sbi, sbi->map_clu); | |
78 | for (i = 0; i < sbi->map_sectors; i++) { | |
79 | sbi->vol_amap[i] = sb_bread(sb, sector + i); | |
80 | if (!sbi->vol_amap[i]) { | |
81 | /* release all buffers and free vol_amap */ | |
82 | int j = 0; | |
83 | ||
84 | while (j < i) | |
85 | brelse(sbi->vol_amap[j++]); | |
86 | ||
87 | kfree(sbi->vol_amap); | |
88 | sbi->vol_amap = NULL; | |
89 | return -EIO; | |
90 | } | |
91 | } | |
92 | ||
1e49a94c NJ |
93 | return 0; |
94 | } | |
95 | ||
96 | int exfat_load_bitmap(struct super_block *sb) | |
97 | { | |
98 | unsigned int i, type; | |
99 | struct exfat_chain clu; | |
100 | struct exfat_sb_info *sbi = EXFAT_SB(sb); | |
101 | ||
102 | exfat_chain_set(&clu, sbi->root_dir, 0, ALLOC_FAT_CHAIN); | |
103 | while (clu.dir != EXFAT_EOF_CLUSTER) { | |
104 | for (i = 0; i < sbi->dentries_per_clu; i++) { | |
105 | struct exfat_dentry *ep; | |
106 | struct buffer_head *bh; | |
107 | ||
108 | ep = exfat_get_dentry(sb, &clu, i, &bh, NULL); | |
109 | if (!ep) | |
110 | return -EIO; | |
111 | ||
112 | type = exfat_get_entry_type(ep); | |
113 | if (type == TYPE_UNUSED) | |
114 | break; | |
115 | if (type != TYPE_BITMAP) | |
116 | continue; | |
117 | if (ep->dentry.bitmap.flags == 0x0) { | |
118 | int err; | |
119 | ||
120 | err = exfat_allocate_bitmap(sb, ep); | |
121 | brelse(bh); | |
122 | return err; | |
123 | } | |
124 | brelse(bh); | |
125 | } | |
126 | ||
127 | if (exfat_get_next_cluster(sb, &clu.dir)) | |
128 | return -EIO; | |
129 | } | |
130 | ||
131 | return -EINVAL; | |
132 | } | |
133 | ||
134 | void exfat_free_bitmap(struct exfat_sb_info *sbi) | |
135 | { | |
136 | int i; | |
137 | ||
1e49a94c NJ |
138 | for (i = 0; i < sbi->map_sectors; i++) |
139 | __brelse(sbi->vol_amap[i]); | |
140 | ||
141 | kfree(sbi->vol_amap); | |
142 | } | |
143 | ||
144 | /* | |
145 | * If the value of "clu" is 0, it means cluster 2 which is the first cluster of | |
146 | * the cluster heap. | |
147 | */ | |
148 | int exfat_set_bitmap(struct inode *inode, unsigned int clu) | |
149 | { | |
150 | int i, b; | |
151 | unsigned int ent_idx; | |
152 | struct super_block *sb = inode->i_sb; | |
153 | struct exfat_sb_info *sbi = EXFAT_SB(sb); | |
154 | ||
155 | WARN_ON(clu < EXFAT_FIRST_CLUSTER); | |
156 | ent_idx = CLUSTER_TO_BITMAP_ENT(clu); | |
157 | i = BITMAP_OFFSET_SECTOR_INDEX(sb, ent_idx); | |
158 | b = BITMAP_OFFSET_BIT_IN_SECTOR(sb, ent_idx); | |
159 | ||
160 | set_bit_le(b, sbi->vol_amap[i]->b_data); | |
2c7f8937 | 161 | exfat_update_bh(sbi->vol_amap[i], IS_DIRSYNC(inode)); |
1e49a94c NJ |
162 | return 0; |
163 | } | |
164 | ||
165 | /* | |
166 | * If the value of "clu" is 0, it means cluster 2 which is the first cluster of | |
167 | * the cluster heap. | |
168 | */ | |
169 | void exfat_clear_bitmap(struct inode *inode, unsigned int clu) | |
170 | { | |
171 | int i, b; | |
172 | unsigned int ent_idx; | |
173 | struct super_block *sb = inode->i_sb; | |
174 | struct exfat_sb_info *sbi = EXFAT_SB(sb); | |
175 | struct exfat_mount_options *opts = &sbi->options; | |
176 | ||
177 | WARN_ON(clu < EXFAT_FIRST_CLUSTER); | |
178 | ent_idx = CLUSTER_TO_BITMAP_ENT(clu); | |
179 | i = BITMAP_OFFSET_SECTOR_INDEX(sb, ent_idx); | |
180 | b = BITMAP_OFFSET_BIT_IN_SECTOR(sb, ent_idx); | |
181 | ||
182 | clear_bit_le(b, sbi->vol_amap[i]->b_data); | |
2c7f8937 | 183 | exfat_update_bh(sbi->vol_amap[i], IS_DIRSYNC(inode)); |
1e49a94c NJ |
184 | |
185 | if (opts->discard) { | |
186 | int ret_discard; | |
187 | ||
188 | ret_discard = sb_issue_discard(sb, | |
189 | exfat_cluster_to_sector(sbi, clu + | |
190 | EXFAT_RESERVED_CLUSTERS), | |
191 | (1 << sbi->sect_per_clus_bits), GFP_NOFS, 0); | |
192 | ||
193 | if (ret_discard == -EOPNOTSUPP) { | |
d1727d55 | 194 | exfat_err(sb, "discard not supported by device, disabling"); |
1e49a94c NJ |
195 | opts->discard = 0; |
196 | } | |
197 | } | |
198 | } | |
199 | ||
200 | /* | |
201 | * If the value of "clu" is 0, it means cluster 2 which is the first cluster of | |
202 | * the cluster heap. | |
203 | */ | |
204 | unsigned int exfat_find_free_bitmap(struct super_block *sb, unsigned int clu) | |
205 | { | |
206 | unsigned int i, map_i, map_b, ent_idx; | |
207 | unsigned int clu_base, clu_free; | |
208 | unsigned char k, clu_mask; | |
209 | struct exfat_sb_info *sbi = EXFAT_SB(sb); | |
210 | ||
211 | WARN_ON(clu < EXFAT_FIRST_CLUSTER); | |
212 | ent_idx = CLUSTER_TO_BITMAP_ENT(clu); | |
213 | clu_base = BITMAP_ENT_TO_CLUSTER(ent_idx & ~(BITS_PER_BYTE_MASK)); | |
214 | clu_mask = IGNORED_BITS_REMAINED(clu, clu_base); | |
215 | ||
216 | map_i = BITMAP_OFFSET_SECTOR_INDEX(sb, ent_idx); | |
217 | map_b = BITMAP_OFFSET_BYTE_IN_SECTOR(sb, ent_idx); | |
218 | ||
219 | for (i = EXFAT_FIRST_CLUSTER; i < sbi->num_clusters; | |
220 | i += BITS_PER_BYTE) { | |
221 | k = *(sbi->vol_amap[map_i]->b_data + map_b); | |
222 | if (clu_mask > 0) { | |
223 | k |= clu_mask; | |
224 | clu_mask = 0; | |
225 | } | |
226 | if (k < 0xFF) { | |
227 | clu_free = clu_base + free_bit[k]; | |
228 | if (clu_free < sbi->num_clusters) | |
229 | return clu_free; | |
230 | } | |
231 | clu_base += BITS_PER_BYTE; | |
232 | ||
233 | if (++map_b >= sb->s_blocksize || | |
234 | clu_base >= sbi->num_clusters) { | |
235 | if (++map_i >= sbi->map_sectors) { | |
236 | clu_base = EXFAT_FIRST_CLUSTER; | |
237 | map_i = 0; | |
238 | } | |
239 | map_b = 0; | |
240 | } | |
241 | } | |
242 | ||
243 | return EXFAT_EOF_CLUSTER; | |
244 | } | |
245 | ||
246 | int exfat_count_used_clusters(struct super_block *sb, unsigned int *ret_count) | |
247 | { | |
248 | struct exfat_sb_info *sbi = EXFAT_SB(sb); | |
249 | unsigned int count = 0; | |
250 | unsigned int i, map_i = 0, map_b = 0; | |
251 | unsigned int total_clus = EXFAT_DATA_CLUSTER_COUNT(sbi); | |
252 | unsigned int last_mask = total_clus & BITS_PER_BYTE_MASK; | |
253 | unsigned char clu_bits; | |
254 | const unsigned char last_bit_mask[] = {0, 0b00000001, 0b00000011, | |
255 | 0b00000111, 0b00001111, 0b00011111, 0b00111111, 0b01111111}; | |
256 | ||
257 | total_clus &= ~last_mask; | |
258 | for (i = 0; i < total_clus; i += BITS_PER_BYTE) { | |
259 | clu_bits = *(sbi->vol_amap[map_i]->b_data + map_b); | |
260 | count += used_bit[clu_bits]; | |
261 | if (++map_b >= (unsigned int)sb->s_blocksize) { | |
262 | map_i++; | |
263 | map_b = 0; | |
264 | } | |
265 | } | |
266 | ||
267 | if (last_mask) { | |
268 | clu_bits = *(sbi->vol_amap[map_i]->b_data + map_b); | |
269 | clu_bits &= last_bit_mask[last_mask]; | |
270 | count += used_bit[clu_bits]; | |
271 | } | |
272 | ||
273 | *ret_count = count; | |
274 | return 0; | |
275 | } |