Annotation of /trunk/mkinitrd-magellan/busybox/util-linux/volume_id/fat.c
Parent Directory | Revision Log
Revision 816 -
(hide annotations)
(download)
Fri Apr 24 18:33:46 2009 UTC (15 years, 1 month ago) by niro
File MIME type: text/plain
File size: 9275 byte(s)
Fri Apr 24 18:33:46 2009 UTC (15 years, 1 month ago) by niro
File MIME type: text/plain
File size: 9275 byte(s)
-updated to busybox-1.13.4
1 | niro | 816 | /* |
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 | } __attribute__((__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 | } __attribute__((__packed__)) fat32; | ||
73 | } __attribute__((__packed__)) type; | ||
74 | } __attribute__((__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 | } __attribute__((__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 volume_id_probe_vfat(struct volume_id *id, uint64_t fat_partition_off) | ||
123 | { | ||
124 | struct vfat_super_block *vs; | ||
125 | struct vfat_dir_entry *dir; | ||
126 | uint16_t sector_size_bytes; | ||
127 | uint16_t dir_entries; | ||
128 | uint32_t sect_count; | ||
129 | uint16_t reserved_sct; | ||
130 | uint32_t fat_size_sct; | ||
131 | uint32_t root_cluster; | ||
132 | uint32_t dir_size_sct; | ||
133 | uint32_t cluster_count; | ||
134 | uint64_t root_start_off; | ||
135 | uint32_t start_data_sct; | ||
136 | uint8_t *buf; | ||
137 | uint32_t buf_size; | ||
138 | uint8_t *label = NULL; | ||
139 | uint32_t next_cluster; | ||
140 | int maxloop; | ||
141 | |||
142 | dbg("probing at offset 0x%llx", (unsigned long long) fat_partition_off); | ||
143 | |||
144 | vs = volume_id_get_buffer(id, fat_partition_off, 0x200); | ||
145 | if (vs == NULL) | ||
146 | return -1; | ||
147 | |||
148 | /* believe only that's fat, don't trust the version | ||
149 | * the cluster_count will tell us | ||
150 | */ | ||
151 | if (memcmp(vs->sysid, "NTFS", 4) == 0) | ||
152 | return -1; | ||
153 | |||
154 | if (memcmp(vs->type.fat32.magic, "MSWIN", 5) == 0) | ||
155 | goto valid; | ||
156 | |||
157 | if (memcmp(vs->type.fat32.magic, "FAT32 ", 8) == 0) | ||
158 | goto valid; | ||
159 | |||
160 | if (memcmp(vs->type.fat.magic, "FAT16 ", 8) == 0) | ||
161 | goto valid; | ||
162 | |||
163 | if (memcmp(vs->type.fat.magic, "MSDOS", 5) == 0) | ||
164 | goto valid; | ||
165 | |||
166 | if (memcmp(vs->type.fat.magic, "FAT12 ", 8) == 0) | ||
167 | goto valid; | ||
168 | |||
169 | /* | ||
170 | * There are old floppies out there without a magic, so we check | ||
171 | * for well known values and guess if it's a fat volume | ||
172 | */ | ||
173 | |||
174 | /* boot jump address check */ | ||
175 | if ((vs->boot_jump[0] != 0xeb || vs->boot_jump[2] != 0x90) && | ||
176 | vs->boot_jump[0] != 0xe9) | ||
177 | return -1; | ||
178 | |||
179 | /* heads check */ | ||
180 | if (vs->heads == 0) | ||
181 | return -1; | ||
182 | |||
183 | /* cluster size check */ | ||
184 | if (vs->sectors_per_cluster == 0 || | ||
185 | (vs->sectors_per_cluster & (vs->sectors_per_cluster-1))) | ||
186 | return -1; | ||
187 | |||
188 | /* media check */ | ||
189 | if (vs->media < 0xf8 && vs->media != 0xf0) | ||
190 | return -1; | ||
191 | |||
192 | /* fat count*/ | ||
193 | if (vs->fats != 2) | ||
194 | return -1; | ||
195 | |||
196 | valid: | ||
197 | /* sector size check */ | ||
198 | sector_size_bytes = le16_to_cpu(vs->sector_size_bytes); | ||
199 | if (sector_size_bytes != 0x200 && sector_size_bytes != 0x400 && | ||
200 | sector_size_bytes != 0x800 && sector_size_bytes != 0x1000) | ||
201 | return -1; | ||
202 | |||
203 | dbg("sector_size_bytes 0x%x", sector_size_bytes); | ||
204 | dbg("sectors_per_cluster 0x%x", vs->sectors_per_cluster); | ||
205 | |||
206 | reserved_sct = le16_to_cpu(vs->reserved_sct); | ||
207 | dbg("reserved_sct 0x%x", reserved_sct); | ||
208 | |||
209 | sect_count = le16_to_cpu(vs->sectors); | ||
210 | if (sect_count == 0) | ||
211 | sect_count = le32_to_cpu(vs->total_sect); | ||
212 | dbg("sect_count 0x%x", sect_count); | ||
213 | |||
214 | fat_size_sct = le16_to_cpu(vs->fat_length); | ||
215 | if (fat_size_sct == 0) | ||
216 | fat_size_sct = le32_to_cpu(vs->type.fat32.fat32_length); | ||
217 | fat_size_sct *= vs->fats; | ||
218 | dbg("fat_size_sct 0x%x", fat_size_sct); | ||
219 | |||
220 | dir_entries = le16_to_cpu(vs->dir_entries); | ||
221 | dir_size_sct = ((dir_entries * sizeof(struct vfat_dir_entry)) + | ||
222 | (sector_size_bytes-1)) / sector_size_bytes; | ||
223 | dbg("dir_size_sct 0x%x", dir_size_sct); | ||
224 | |||
225 | cluster_count = sect_count - (reserved_sct + fat_size_sct + dir_size_sct); | ||
226 | cluster_count /= vs->sectors_per_cluster; | ||
227 | dbg("cluster_count 0x%x", cluster_count); | ||
228 | |||
229 | // if (cluster_count < FAT12_MAX) { | ||
230 | // strcpy(id->type_version, "FAT12"); | ||
231 | // } else if (cluster_count < FAT16_MAX) { | ||
232 | // strcpy(id->type_version, "FAT16"); | ||
233 | // } else { | ||
234 | // strcpy(id->type_version, "FAT32"); | ||
235 | // goto fat32; | ||
236 | // } | ||
237 | if (cluster_count >= FAT16_MAX) | ||
238 | goto fat32; | ||
239 | |||
240 | /* the label may be an attribute in the root directory */ | ||
241 | root_start_off = (reserved_sct + fat_size_sct) * sector_size_bytes; | ||
242 | dbg("root dir start 0x%llx", (unsigned long long) root_start_off); | ||
243 | dbg("expected entries 0x%x", dir_entries); | ||
244 | |||
245 | buf_size = dir_entries * sizeof(struct vfat_dir_entry); | ||
246 | buf = volume_id_get_buffer(id, fat_partition_off + root_start_off, buf_size); | ||
247 | if (buf == NULL) | ||
248 | goto found; | ||
249 | |||
250 | label = get_attr_volume_id((struct vfat_dir_entry*) buf, dir_entries); | ||
251 | |||
252 | vs = volume_id_get_buffer(id, fat_partition_off, 0x200); | ||
253 | if (vs == NULL) | ||
254 | return -1; | ||
255 | |||
256 | if (label != NULL && memcmp(label, "NO NAME ", 11) != 0) { | ||
257 | // volume_id_set_label_raw(id, label, 11); | ||
258 | volume_id_set_label_string(id, label, 11); | ||
259 | } else if (memcmp(vs->type.fat.label, "NO NAME ", 11) != 0) { | ||
260 | // volume_id_set_label_raw(id, vs->type.fat.label, 11); | ||
261 | volume_id_set_label_string(id, vs->type.fat.label, 11); | ||
262 | } | ||
263 | volume_id_set_uuid(id, vs->type.fat.serno, UUID_DOS); | ||
264 | goto found; | ||
265 | |||
266 | fat32: | ||
267 | /* FAT32 root dir is a cluster chain like any other directory */ | ||
268 | buf_size = vs->sectors_per_cluster * sector_size_bytes; | ||
269 | root_cluster = le32_to_cpu(vs->type.fat32.root_cluster); | ||
270 | start_data_sct = reserved_sct + fat_size_sct; | ||
271 | |||
272 | next_cluster = root_cluster; | ||
273 | maxloop = 100; | ||
274 | while (--maxloop) { | ||
275 | uint32_t next_off_sct; | ||
276 | uint64_t next_off; | ||
277 | uint64_t fat_entry_off; | ||
278 | int count; | ||
279 | |||
280 | dbg("next_cluster 0x%x", (unsigned)next_cluster); | ||
281 | next_off_sct = (next_cluster - 2) * vs->sectors_per_cluster; | ||
282 | next_off = (start_data_sct + next_off_sct) * sector_size_bytes; | ||
283 | dbg("cluster offset 0x%llx", (unsigned long long) next_off); | ||
284 | |||
285 | /* get cluster */ | ||
286 | buf = volume_id_get_buffer(id, fat_partition_off + next_off, buf_size); | ||
287 | if (buf == NULL) | ||
288 | goto found; | ||
289 | |||
290 | dir = (struct vfat_dir_entry*) buf; | ||
291 | count = buf_size / sizeof(struct vfat_dir_entry); | ||
292 | dbg("expected entries 0x%x", count); | ||
293 | |||
294 | label = get_attr_volume_id(dir, count); | ||
295 | if (label) | ||
296 | break; | ||
297 | |||
298 | /* get FAT entry */ | ||
299 | fat_entry_off = (reserved_sct * sector_size_bytes) + (next_cluster * sizeof(uint32_t)); | ||
300 | dbg("fat_entry_off 0x%llx", (unsigned long long)fat_entry_off); | ||
301 | buf = volume_id_get_buffer(id, fat_partition_off + fat_entry_off, buf_size); | ||
302 | if (buf == NULL) | ||
303 | goto found; | ||
304 | |||
305 | /* set next cluster */ | ||
306 | next_cluster = le32_to_cpu(*(uint32_t*)buf) & 0x0fffffff; | ||
307 | if (next_cluster < 2 || next_cluster > FAT32_MAX) | ||
308 | break; | ||
309 | } | ||
310 | if (maxloop == 0) | ||
311 | dbg("reached maximum follow count of root cluster chain, give up"); | ||
312 | |||
313 | vs = volume_id_get_buffer(id, fat_partition_off, 0x200); | ||
314 | if (vs == NULL) | ||
315 | return -1; | ||
316 | |||
317 | if (label != NULL && memcmp(label, "NO NAME ", 11) != 0) { | ||
318 | // volume_id_set_label_raw(id, label, 11); | ||
319 | volume_id_set_label_string(id, label, 11); | ||
320 | } else if (memcmp(vs->type.fat32.label, "NO NAME ", 11) != 0) { | ||
321 | // volume_id_set_label_raw(id, vs->type.fat32.label, 11); | ||
322 | volume_id_set_label_string(id, vs->type.fat32.label, 11); | ||
323 | } | ||
324 | volume_id_set_uuid(id, vs->type.fat32.serno, UUID_DOS); | ||
325 | |||
326 | found: | ||
327 | // volume_id_set_usage(id, VOLUME_ID_FILESYSTEM); | ||
328 | // id->type = "vfat"; | ||
329 | |||
330 | return 0; | ||
331 | } |