Contents of /trunk/mkinitrd-magellan/busybox/util-linux/volume_id/fat.c
Parent Directory | Revision Log
Revision 984 -
(show annotations)
(download)
Sun May 30 11:32:42 2010 UTC (13 years, 11 months ago) by niro
File MIME type: text/plain
File size: 9224 byte(s)
Sun May 30 11:32:42 2010 UTC (13 years, 11 months ago) by niro
File MIME type: text/plain
File size: 9224 byte(s)
-updated to busybox-1.16.1 and enabled blkid/uuid support in default config
1 | /* |
2 | * volume_id - reads filesystem label and uuid |
3 | * |
4 | * Copyright (C) 2004 Kay Sievers <kay.sievers@vrfy.org> |
5 | * |
6 | * This library is free software; you can redistribute it and/or |
7 | * modify it under the terms of the GNU Lesser General Public |
8 | * License as published by the Free Software Foundation; either |
9 | * version 2.1 of the License, or (at your option) any later version. |
10 | * |
11 | * This library is distributed in the hope that it will be useful, |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
14 | * Lesser General Public License for more details. |
15 | * |
16 | * You should have received a copy of the GNU Lesser General Public |
17 | * License along with this library; if not, write to the Free Software |
18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
19 | */ |
20 | |
21 | #include "volume_id_internal.h" |
22 | |
23 | /* linux/msdos_fs.h says: */ |
24 | #define FAT12_MAX 0xff4 |
25 | #define FAT16_MAX 0xfff4 |
26 | #define FAT32_MAX 0x0ffffff6 |
27 | |
28 | #define FAT_ATTR_VOLUME_ID 0x08 |
29 | #define FAT_ATTR_DIR 0x10 |
30 | #define FAT_ATTR_LONG_NAME 0x0f |
31 | #define FAT_ATTR_MASK 0x3f |
32 | #define FAT_ENTRY_FREE 0xe5 |
33 | |
34 | struct vfat_super_block { |
35 | uint8_t boot_jump[3]; |
36 | uint8_t sysid[8]; |
37 | uint16_t sector_size_bytes; |
38 | uint8_t sectors_per_cluster; |
39 | uint16_t reserved_sct; |
40 | uint8_t fats; |
41 | uint16_t dir_entries; |
42 | uint16_t sectors; |
43 | uint8_t media; |
44 | uint16_t fat_length; |
45 | uint16_t secs_track; |
46 | uint16_t heads; |
47 | uint32_t hidden; |
48 | uint32_t total_sect; |
49 | union { |
50 | struct fat_super_block { |
51 | uint8_t unknown[3]; |
52 | uint8_t serno[4]; |
53 | uint8_t label[11]; |
54 | uint8_t magic[8]; |
55 | uint8_t dummy2[192]; |
56 | uint8_t pmagic[2]; |
57 | } PACKED fat; |
58 | struct fat32_super_block { |
59 | uint32_t fat32_length; |
60 | uint16_t flags; |
61 | uint8_t version[2]; |
62 | uint32_t root_cluster; |
63 | uint16_t insfo_sector; |
64 | uint16_t backup_boot; |
65 | uint16_t reserved2[6]; |
66 | uint8_t unknown[3]; |
67 | uint8_t serno[4]; |
68 | uint8_t label[11]; |
69 | uint8_t magic[8]; |
70 | uint8_t dummy2[164]; |
71 | uint8_t pmagic[2]; |
72 | } PACKED fat32; |
73 | } PACKED type; |
74 | } PACKED; |
75 | |
76 | struct vfat_dir_entry { |
77 | uint8_t name[11]; |
78 | uint8_t attr; |
79 | uint16_t time_creat; |
80 | uint16_t date_creat; |
81 | uint16_t time_acc; |
82 | uint16_t date_acc; |
83 | uint16_t cluster_high; |
84 | uint16_t time_write; |
85 | uint16_t date_write; |
86 | uint16_t cluster_low; |
87 | uint32_t size; |
88 | } PACKED; |
89 | |
90 | static uint8_t *get_attr_volume_id(struct vfat_dir_entry *dir, int count) |
91 | { |
92 | for (;--count >= 0; dir++) { |
93 | /* end marker */ |
94 | if (dir->name[0] == 0x00) { |
95 | dbg("end of dir"); |
96 | break; |
97 | } |
98 | |
99 | /* empty entry */ |
100 | if (dir->name[0] == FAT_ENTRY_FREE) |
101 | continue; |
102 | |
103 | /* long name */ |
104 | if ((dir->attr & FAT_ATTR_MASK) == FAT_ATTR_LONG_NAME) |
105 | continue; |
106 | |
107 | if ((dir->attr & (FAT_ATTR_VOLUME_ID | FAT_ATTR_DIR)) == FAT_ATTR_VOLUME_ID) { |
108 | /* labels do not have file data */ |
109 | if (dir->cluster_high != 0 || dir->cluster_low != 0) |
110 | continue; |
111 | |
112 | dbg("found ATTR_VOLUME_ID id in root dir"); |
113 | return dir->name; |
114 | } |
115 | |
116 | dbg("skip dir entry"); |
117 | } |
118 | |
119 | return NULL; |
120 | } |
121 | |
122 | int FAST_FUNC volume_id_probe_vfat(struct volume_id *id /*,uint64_t fat_partition_off*/) |
123 | { |
124 | #define fat_partition_off ((uint64_t)0) |
125 | struct vfat_super_block *vs; |
126 | struct vfat_dir_entry *dir; |
127 | uint16_t sector_size_bytes; |
128 | uint16_t dir_entries; |
129 | uint32_t sect_count; |
130 | uint16_t reserved_sct; |
131 | uint32_t fat_size_sct; |
132 | uint32_t root_cluster; |
133 | uint32_t dir_size_sct; |
134 | uint32_t cluster_count; |
135 | uint64_t root_start_off; |
136 | uint32_t start_data_sct; |
137 | uint8_t *buf; |
138 | uint32_t buf_size; |
139 | uint8_t *label = NULL; |
140 | uint32_t next_cluster; |
141 | int maxloop; |
142 | |
143 | dbg("probing at offset 0x%llx", (unsigned long long) fat_partition_off); |
144 | |
145 | vs = volume_id_get_buffer(id, fat_partition_off, 0x200); |
146 | if (vs == NULL) |
147 | return -1; |
148 | |
149 | /* believe only that's fat, don't trust the version |
150 | * the cluster_count will tell us |
151 | */ |
152 | if (memcmp(vs->sysid, "NTFS", 4) == 0) |
153 | return -1; |
154 | |
155 | if (memcmp(vs->type.fat32.magic, "MSWIN", 5) == 0) |
156 | goto valid; |
157 | |
158 | if (memcmp(vs->type.fat32.magic, "FAT32 ", 8) == 0) |
159 | goto valid; |
160 | |
161 | if (memcmp(vs->type.fat.magic, "FAT16 ", 8) == 0) |
162 | goto valid; |
163 | |
164 | if (memcmp(vs->type.fat.magic, "MSDOS", 5) == 0) |
165 | goto valid; |
166 | |
167 | if (memcmp(vs->type.fat.magic, "FAT12 ", 8) == 0) |
168 | goto valid; |
169 | |
170 | /* |
171 | * There are old floppies out there without a magic, so we check |
172 | * for well known values and guess if it's a fat volume |
173 | */ |
174 | |
175 | /* boot jump address check */ |
176 | if ((vs->boot_jump[0] != 0xeb || vs->boot_jump[2] != 0x90) && |
177 | vs->boot_jump[0] != 0xe9) |
178 | return -1; |
179 | |
180 | /* heads check */ |
181 | if (vs->heads == 0) |
182 | return -1; |
183 | |
184 | /* cluster size check */ |
185 | if (vs->sectors_per_cluster == 0 || |
186 | (vs->sectors_per_cluster & (vs->sectors_per_cluster-1))) |
187 | return -1; |
188 | |
189 | /* media check */ |
190 | if (vs->media < 0xf8 && vs->media != 0xf0) |
191 | return -1; |
192 | |
193 | /* fat count*/ |
194 | if (vs->fats != 2) |
195 | return -1; |
196 | |
197 | valid: |
198 | /* sector size check */ |
199 | sector_size_bytes = le16_to_cpu(vs->sector_size_bytes); |
200 | if (sector_size_bytes != 0x200 && sector_size_bytes != 0x400 && |
201 | sector_size_bytes != 0x800 && sector_size_bytes != 0x1000) |
202 | return -1; |
203 | |
204 | dbg("sector_size_bytes 0x%x", sector_size_bytes); |
205 | dbg("sectors_per_cluster 0x%x", vs->sectors_per_cluster); |
206 | |
207 | reserved_sct = le16_to_cpu(vs->reserved_sct); |
208 | dbg("reserved_sct 0x%x", reserved_sct); |
209 | |
210 | sect_count = le16_to_cpu(vs->sectors); |
211 | if (sect_count == 0) |
212 | sect_count = le32_to_cpu(vs->total_sect); |
213 | dbg("sect_count 0x%x", sect_count); |
214 | |
215 | fat_size_sct = le16_to_cpu(vs->fat_length); |
216 | if (fat_size_sct == 0) |
217 | fat_size_sct = le32_to_cpu(vs->type.fat32.fat32_length); |
218 | fat_size_sct *= vs->fats; |
219 | dbg("fat_size_sct 0x%x", fat_size_sct); |
220 | |
221 | dir_entries = le16_to_cpu(vs->dir_entries); |
222 | dir_size_sct = ((dir_entries * sizeof(struct vfat_dir_entry)) + |
223 | (sector_size_bytes-1)) / sector_size_bytes; |
224 | dbg("dir_size_sct 0x%x", dir_size_sct); |
225 | |
226 | cluster_count = sect_count - (reserved_sct + fat_size_sct + dir_size_sct); |
227 | cluster_count /= vs->sectors_per_cluster; |
228 | dbg("cluster_count 0x%x", cluster_count); |
229 | |
230 | // if (cluster_count < FAT12_MAX) { |
231 | // strcpy(id->type_version, "FAT12"); |
232 | // } else if (cluster_count < FAT16_MAX) { |
233 | // strcpy(id->type_version, "FAT16"); |
234 | // } else { |
235 | // strcpy(id->type_version, "FAT32"); |
236 | // goto fat32; |
237 | // } |
238 | if (cluster_count >= FAT16_MAX) |
239 | goto fat32; |
240 | |
241 | /* the label may be an attribute in the root directory */ |
242 | root_start_off = (reserved_sct + fat_size_sct) * sector_size_bytes; |
243 | dbg("root dir start 0x%llx", (unsigned long long) root_start_off); |
244 | dbg("expected entries 0x%x", dir_entries); |
245 | |
246 | buf_size = dir_entries * sizeof(struct vfat_dir_entry); |
247 | buf = volume_id_get_buffer(id, fat_partition_off + root_start_off, buf_size); |
248 | if (buf == NULL) |
249 | goto ret; |
250 | |
251 | label = get_attr_volume_id((struct vfat_dir_entry*) buf, dir_entries); |
252 | |
253 | vs = volume_id_get_buffer(id, fat_partition_off, 0x200); |
254 | if (vs == NULL) |
255 | return -1; |
256 | |
257 | if (label != NULL && memcmp(label, "NO NAME ", 11) != 0) { |
258 | // volume_id_set_label_raw(id, label, 11); |
259 | volume_id_set_label_string(id, label, 11); |
260 | } else if (memcmp(vs->type.fat.label, "NO NAME ", 11) != 0) { |
261 | // volume_id_set_label_raw(id, vs->type.fat.label, 11); |
262 | volume_id_set_label_string(id, vs->type.fat.label, 11); |
263 | } |
264 | volume_id_set_uuid(id, vs->type.fat.serno, UUID_DOS); |
265 | goto ret; |
266 | |
267 | fat32: |
268 | /* FAT32 root dir is a cluster chain like any other directory */ |
269 | buf_size = vs->sectors_per_cluster * sector_size_bytes; |
270 | root_cluster = le32_to_cpu(vs->type.fat32.root_cluster); |
271 | start_data_sct = reserved_sct + fat_size_sct; |
272 | |
273 | next_cluster = root_cluster; |
274 | maxloop = 100; |
275 | while (--maxloop) { |
276 | uint64_t next_off_sct; |
277 | uint64_t next_off; |
278 | uint64_t fat_entry_off; |
279 | int count; |
280 | |
281 | dbg("next_cluster 0x%x", (unsigned)next_cluster); |
282 | next_off_sct = (uint64_t)(next_cluster - 2) * vs->sectors_per_cluster; |
283 | next_off = (start_data_sct + next_off_sct) * sector_size_bytes; |
284 | dbg("cluster offset 0x%llx", (unsigned long long) next_off); |
285 | |
286 | /* get cluster */ |
287 | buf = volume_id_get_buffer(id, fat_partition_off + next_off, buf_size); |
288 | if (buf == NULL) |
289 | goto ret; |
290 | |
291 | dir = (struct vfat_dir_entry*) buf; |
292 | count = buf_size / sizeof(struct vfat_dir_entry); |
293 | dbg("expected entries 0x%x", count); |
294 | |
295 | label = get_attr_volume_id(dir, count); |
296 | if (label) |
297 | break; |
298 | |
299 | /* get FAT entry */ |
300 | fat_entry_off = (reserved_sct * sector_size_bytes) + (next_cluster * sizeof(uint32_t)); |
301 | dbg("fat_entry_off 0x%llx", (unsigned long long)fat_entry_off); |
302 | buf = volume_id_get_buffer(id, fat_partition_off + fat_entry_off, buf_size); |
303 | if (buf == NULL) |
304 | goto ret; |
305 | |
306 | /* set next cluster */ |
307 | next_cluster = le32_to_cpu(*(uint32_t*)buf) & 0x0fffffff; |
308 | if (next_cluster < 2 || next_cluster > FAT32_MAX) |
309 | break; |
310 | } |
311 | if (maxloop == 0) |
312 | dbg("reached maximum follow count of root cluster chain, give up"); |
313 | |
314 | vs = volume_id_get_buffer(id, fat_partition_off, 0x200); |
315 | if (vs == NULL) |
316 | return -1; |
317 | |
318 | if (label != NULL && memcmp(label, "NO NAME ", 11) != 0) { |
319 | // volume_id_set_label_raw(id, label, 11); |
320 | volume_id_set_label_string(id, label, 11); |
321 | } else if (memcmp(vs->type.fat32.label, "NO NAME ", 11) != 0) { |
322 | // volume_id_set_label_raw(id, vs->type.fat32.label, 11); |
323 | volume_id_set_label_string(id, vs->type.fat32.label, 11); |
324 | } |
325 | volume_id_set_uuid(id, vs->type.fat32.serno, UUID_DOS); |
326 | |
327 | ret: |
328 | // volume_id_set_usage(id, VOLUME_ID_FILESYSTEM); |
329 | // id->type = "vfat"; |
330 | |
331 | return 0; |
332 | } |