1 /* vim:set shiftwidth=4 ts=4: */
2 /*
3 * QEMU Block driver for virtual VFAT (shadows a local directory)
4 *
5 * Copyright (c) 2004,2005 Johannes E. Schindelin
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 * THE SOFTWARE.
24 */
25
26 #include "qemu/osdep.h"
27 #include <dirent.h>
28 #include <glib/gstdio.h>
29 #include "qapi/error.h"
30 #include "block/block-io.h"
31 #include "block/block_int.h"
32 #include "block/qdict.h"
33 #include "qemu/module.h"
34 #include "qemu/option.h"
35 #include "qemu/bswap.h"
36 #include "migration/blocker.h"
37 #include "qobject/qdict.h"
38 #include "qobject/qstring.h"
39 #include "qemu/ctype.h"
40 #include "qemu/cutils.h"
41 #include "qemu/error-report.h"
42
43 #ifndef S_IWGRP
44 #define S_IWGRP 0
45 #endif
46 #ifndef S_IWOTH
47 #define S_IWOTH 0
48 #endif
49
50 /* TODO: add ":bootsector=blabla.img:" */
51 /* LATER TODO: add automatic boot sector generation from
52 BOOTEASY.ASM and Ranish Partition Manager
53 Note that DOS assumes the system files to be the first files in the
54 file system (test if the boot sector still relies on that fact)! */
55 /* MAYBE TODO: write block-visofs.c */
56 /* TODO: call try_commit() only after a timeout */
57
58 /* #define DEBUG */
59
60 #ifdef DEBUG
61
62 #define DLOG(a) a
63
64 static void checkpoint(void);
65
66 #else
67
68 #define DLOG(a)
69
70 #endif
71
72 /* bootsector OEM name. see related compatibility problems at:
73 * https://jdebp.eu/FGA/volume-boot-block-oem-name-field.html
74 * http://seasip.info/Misc/oemid.html
75 */
76 #define BOOTSECTOR_OEM_NAME "MSWIN4.1"
77
78 #define DIR_DELETED 0xe5
79 #define DIR_KANJI DIR_DELETED
80 #define DIR_KANJI_FAKE 0x05
81 #define DIR_FREE 0x00
82
83 /* dynamic array functions */
84 typedef struct array_t {
85 char* pointer;
86 unsigned int size,next,item_size;
87 } array_t;
88
array_init(array_t * array,unsigned int item_size)89 static inline void array_init(array_t* array,unsigned int item_size)
90 {
91 array->pointer = NULL;
92 array->size=0;
93 array->next=0;
94 array->item_size=item_size;
95 }
96
array_free(array_t * array)97 static inline void array_free(array_t* array)
98 {
99 g_free(array->pointer);
100 array->size=array->next=0;
101 }
102
103 /* does not automatically grow */
array_get(array_t * array,unsigned int index)104 static inline void* array_get(array_t* array,unsigned int index) {
105 assert(index < array->next);
106 assert(array->pointer);
107 return array->pointer + index * array->item_size;
108 }
109
array_ensure_allocated(array_t * array,int index)110 static inline void array_ensure_allocated(array_t *array, int index)
111 {
112 if((index + 1) * array->item_size > array->size) {
113 int new_size = (index + 32) * array->item_size;
114 array->pointer = g_realloc(array->pointer, new_size);
115 assert(array->pointer);
116 memset(array->pointer + array->size, 0, new_size - array->size);
117 array->size = new_size;
118 array->next = index + 1;
119 }
120 }
121
array_get_next(array_t * array)122 static inline void* array_get_next(array_t* array) {
123 unsigned int next = array->next;
124
125 array_ensure_allocated(array, next);
126 array->next = next + 1;
127 return array_get(array, next);
128 }
129
array_insert(array_t * array,unsigned int index,unsigned int count)130 static inline void* array_insert(array_t* array,unsigned int index,unsigned int count) {
131 if((array->next+count)*array->item_size>array->size) {
132 int increment=count*array->item_size;
133 array->pointer=g_realloc(array->pointer,array->size+increment);
134 if(!array->pointer)
135 return NULL;
136 array->size+=increment;
137 }
138 memmove(array->pointer+(index+count)*array->item_size,
139 array->pointer+index*array->item_size,
140 (array->next-index)*array->item_size);
141 array->next+=count;
142 return array->pointer+index*array->item_size;
143 }
144
array_remove_slice(array_t * array,int index,int count)145 static inline int array_remove_slice(array_t* array,int index, int count)
146 {
147 assert(index >=0);
148 assert(count > 0);
149 assert(index + count <= array->next);
150
151 memmove(array->pointer + index * array->item_size,
152 array->pointer + (index + count) * array->item_size,
153 (array->next - index - count) * array->item_size);
154
155 array->next -= count;
156 return 0;
157 }
158
array_remove(array_t * array,int index)159 static int array_remove(array_t* array,int index)
160 {
161 return array_remove_slice(array, index, 1);
162 }
163
164 /* return the index for a given member */
array_index(array_t * array,void * pointer)165 static int array_index(array_t* array, void* pointer)
166 {
167 size_t offset = (char*)pointer - array->pointer;
168 assert((offset % array->item_size) == 0);
169 assert(offset/array->item_size < array->next);
170 return offset/array->item_size;
171 }
172
173 /* These structures are used to fake a disk and the VFAT filesystem.
174 * For this reason we need to use QEMU_PACKED. */
175
176 typedef struct bootsector_t {
177 uint8_t jump[3];
178 uint8_t name[8];
179 uint16_t sector_size;
180 uint8_t sectors_per_cluster;
181 uint16_t reserved_sectors;
182 uint8_t number_of_fats;
183 uint16_t root_entries;
184 uint16_t total_sectors16;
185 uint8_t media_type;
186 uint16_t sectors_per_fat;
187 uint16_t sectors_per_track;
188 uint16_t number_of_heads;
189 uint32_t hidden_sectors;
190 uint32_t total_sectors;
191 union {
192 struct {
193 uint8_t drive_number;
194 uint8_t reserved1;
195 uint8_t signature;
196 uint32_t id;
197 uint8_t volume_label[11];
198 uint8_t fat_type[8];
199 uint8_t ignored[0x1c0];
200 } QEMU_PACKED fat16;
201 struct {
202 uint32_t sectors_per_fat;
203 uint16_t flags;
204 uint8_t major,minor;
205 uint32_t first_cluster_of_root_dir;
206 uint16_t info_sector;
207 uint16_t backup_boot_sector;
208 uint8_t reserved[12];
209 uint8_t drive_number;
210 uint8_t reserved1;
211 uint8_t signature;
212 uint32_t id;
213 uint8_t volume_label[11];
214 uint8_t fat_type[8];
215 uint8_t ignored[0x1a4];
216 } QEMU_PACKED fat32;
217 } u;
218 uint8_t magic[2];
219 } QEMU_PACKED bootsector_t;
220
221 typedef struct {
222 uint8_t head;
223 uint8_t sector;
224 uint8_t cylinder;
225 } mbr_chs_t;
226
227 typedef struct partition_t {
228 uint8_t attributes; /* 0x80 = bootable */
229 mbr_chs_t start_CHS;
230 uint8_t fs_type; /* 0x1 = FAT12, 0x6 = FAT16, 0xe = FAT16_LBA, 0xb = FAT32, 0xc = FAT32_LBA */
231 mbr_chs_t end_CHS;
232 uint32_t start_sector_long;
233 uint32_t length_sector_long;
234 } QEMU_PACKED partition_t;
235
236 typedef struct mbr_t {
237 uint8_t ignored[0x1b8];
238 uint32_t nt_id;
239 uint8_t ignored2[2];
240 partition_t partition[4];
241 uint8_t magic[2];
242 } QEMU_PACKED mbr_t;
243
244 typedef struct direntry_t {
245 uint8_t name[8 + 3];
246 uint8_t attributes;
247 uint8_t reserved[2];
248 uint16_t ctime;
249 uint16_t cdate;
250 uint16_t adate;
251 uint16_t begin_hi;
252 uint16_t mtime;
253 uint16_t mdate;
254 uint16_t begin;
255 uint32_t size;
256 } QEMU_PACKED direntry_t;
257
258 /* this structure are used to transparently access the files */
259
260 typedef struct mapping_t {
261 /* begin is the first cluster, end is the last+1 */
262 uint32_t begin,end;
263 /* as s->directory is growable, no pointer may be used here */
264 unsigned int dir_index;
265 /* the clusters of a file may be in any order; this points to the first */
266 int first_mapping_index;
267 union {
268 /* offset is
269 * - the offset in the file (in clusters) for a file, or
270 * - the next cluster of the directory for a directory
271 */
272 struct {
273 uint32_t offset;
274 } file;
275 struct {
276 int parent_mapping_index;
277 int first_dir_index;
278 } dir;
279 } info;
280 /* path contains the full path, i.e. it always starts with s->path */
281 char* path;
282
283 enum {
284 MODE_UNDEFINED = 0,
285 MODE_NORMAL = 1,
286 MODE_MODIFIED = 2,
287 MODE_DIRECTORY = 4,
288 MODE_DELETED = 8,
289 } mode;
290 int read_only;
291 } mapping_t;
292
293 #ifdef DEBUG
294 static void print_direntry(const struct direntry_t*);
295 static void print_mapping(const struct mapping_t* mapping);
296 #endif
297
298 /* here begins the real VVFAT driver */
299
300 typedef struct BDRVVVFATState {
301 CoMutex lock;
302 BlockDriverState* bs; /* pointer to parent */
303 unsigned char first_sectors[0x40*0x200];
304
305 int fat_type; /* 16 or 32 */
306 array_t fat,directory,mapping;
307 char volume_label[11];
308
309 uint32_t offset_to_bootsector; /* 0 for floppy, 0x3f for disk */
310
311 unsigned int cluster_size;
312 unsigned int sectors_per_cluster;
313 unsigned int sectors_per_fat;
314 uint32_t last_cluster_of_root_directory;
315 /* how many entries are available in root directory (0 for FAT32) */
316 uint16_t root_entries;
317 uint32_t sector_count; /* total number of sectors of the partition */
318 uint32_t cluster_count; /* total number of clusters of this partition */
319 uint32_t max_fat_value;
320 uint32_t offset_to_fat;
321 uint32_t offset_to_root_dir;
322
323 int current_fd;
324 mapping_t* current_mapping;
325 unsigned char* cluster; /* points to current cluster */
326 unsigned char* cluster_buffer; /* points to a buffer to hold temp data */
327 unsigned int current_cluster;
328
329 /* write support */
330 char* qcow_filename;
331 BdrvChild* qcow;
332 void* fat2;
333 char* used_clusters;
334 array_t commits;
335 const char* path;
336 int downcase_short_names;
337
338 Error *migration_blocker;
339 } BDRVVVFATState;
340
341 /* take the sector position spos and convert it to Cylinder/Head/Sector position
342 * if the position is outside the specified geometry, fill maximum value for CHS
343 * and return 1 to signal overflow.
344 */
sector2CHS(mbr_chs_t * chs,int spos,int cyls,int heads,int secs)345 static int sector2CHS(mbr_chs_t *chs, int spos, int cyls, int heads, int secs)
346 {
347 int head,sector;
348 sector = spos % secs; spos /= secs;
349 head = spos % heads; spos /= heads;
350 if (spos >= cyls) {
351 /* Overflow,
352 it happens if 32bit sector positions are used, while CHS is only 24bit.
353 Windows/Dos is said to take 1023/255/63 as nonrepresentable CHS */
354 chs->head = 0xFF;
355 chs->sector = 0xFF;
356 chs->cylinder = 0xFF;
357 return 1;
358 }
359 chs->head = (uint8_t)head;
360 chs->sector = (uint8_t)( (sector+1) | ((spos>>8)<<6) );
361 chs->cylinder = (uint8_t)spos;
362 return 0;
363 }
364
init_mbr(BDRVVVFATState * s,int cyls,int heads,int secs)365 static void init_mbr(BDRVVVFATState *s, int cyls, int heads, int secs)
366 {
367 /* TODO: if the files mbr.img and bootsect.img exist, use them */
368 mbr_t* real_mbr=(mbr_t*)s->first_sectors;
369 partition_t* partition = &(real_mbr->partition[0]);
370 int lba;
371
372 memset(s->first_sectors,0,512);
373
374 /* Win NT Disk Signature */
375 real_mbr->nt_id= cpu_to_le32(0xbe1afdfa);
376
377 partition->attributes=0x80; /* bootable */
378
379 /* LBA is used when partition is outside the CHS geometry */
380 lba = sector2CHS(&partition->start_CHS, s->offset_to_bootsector,
381 cyls, heads, secs);
382 lba |= sector2CHS(&partition->end_CHS, s->bs->total_sectors - 1,
383 cyls, heads, secs);
384
385 /*LBA partitions are identified only by start/length_sector_long not by CHS*/
386 partition->start_sector_long = cpu_to_le32(s->offset_to_bootsector);
387 partition->length_sector_long = cpu_to_le32(s->bs->total_sectors
388 - s->offset_to_bootsector);
389
390 /* FAT12/FAT16/FAT32 */
391 /* DOS uses different types when partition is LBA,
392 probably to prevent older versions from using CHS on them */
393 partition->fs_type = s->fat_type == 12 ? 0x1 :
394 s->fat_type == 16 ? (lba ? 0xe : 0x06) :
395 /*s->fat_type == 32*/ (lba ? 0xc : 0x0b);
396
397 real_mbr->magic[0]=0x55; real_mbr->magic[1]=0xaa;
398 }
399
400 /* direntry functions */
401
create_long_filename(BDRVVVFATState * s,const char * filename)402 static direntry_t *create_long_filename(BDRVVVFATState *s, const char *filename)
403 {
404 int number_of_entries, i;
405 glong length;
406
407 gunichar2 *longname = g_utf8_to_utf16(filename, -1, NULL, &length, NULL);
408 if (!longname) {
409 fprintf(stderr, "vvfat: invalid UTF-8 name: %s\n", filename);
410 return NULL;
411 }
412
413 number_of_entries = DIV_ROUND_UP(length * 2, 26);
414
415 for(i=0;i<number_of_entries;i++) {
416 direntry_t *entry=array_get_next(&(s->directory));
417 entry->attributes=0xf;
418 entry->reserved[0]=0;
419 entry->begin=0;
420 entry->name[0]=(number_of_entries-i)|(i==0?0x40:0);
421 }
422 for(i=0;i<26*number_of_entries;i++) {
423 unsigned char *entry=array_get(&(s->directory),s->directory.next-1-(i/26));
424 int offset=(i%26);
425 if(offset<10) offset=1+offset;
426 else if(offset<22) offset=14+offset-10;
427 else offset=28+offset-22;
428 if (i >= 2 * length + 2) {
429 entry[offset] = 0xff;
430 } else if (i % 2 == 0) {
431 entry[offset] = longname[i / 2] & 0xff;
432 } else {
433 entry[offset] = longname[i / 2] >> 8;
434 }
435 }
436 g_free(longname);
437 return array_get(&(s->directory),s->directory.next-number_of_entries);
438 }
439
is_free(const direntry_t * direntry)440 static char is_free(const direntry_t* direntry)
441 {
442 return direntry->name[0] == DIR_DELETED || direntry->name[0] == DIR_FREE;
443 }
444
is_volume_label(const direntry_t * direntry)445 static char is_volume_label(const direntry_t* direntry)
446 {
447 return direntry->attributes == 0x28;
448 }
449
is_long_name(const direntry_t * direntry)450 static char is_long_name(const direntry_t* direntry)
451 {
452 return direntry->attributes == 0xf;
453 }
454
is_short_name(const direntry_t * direntry)455 static char is_short_name(const direntry_t* direntry)
456 {
457 return !is_volume_label(direntry) && !is_long_name(direntry)
458 && !is_free(direntry);
459 }
460
is_directory(const direntry_t * direntry)461 static char is_directory(const direntry_t* direntry)
462 {
463 return direntry->attributes & 0x10 && direntry->name[0] != DIR_DELETED;
464 }
465
is_dot(const direntry_t * direntry)466 static inline char is_dot(const direntry_t* direntry)
467 {
468 return is_short_name(direntry) && direntry->name[0] == '.';
469 }
470
is_file(const direntry_t * direntry)471 static char is_file(const direntry_t* direntry)
472 {
473 return is_short_name(direntry) && !is_directory(direntry);
474 }
475
begin_of_direntry(const direntry_t * direntry)476 static inline uint32_t begin_of_direntry(const direntry_t* direntry)
477 {
478 return le16_to_cpu(direntry->begin)|(le16_to_cpu(direntry->begin_hi)<<16);
479 }
480
filesize_of_direntry(const direntry_t * direntry)481 static inline uint32_t filesize_of_direntry(const direntry_t* direntry)
482 {
483 return le32_to_cpu(direntry->size);
484 }
485
set_begin_of_direntry(direntry_t * direntry,uint32_t begin)486 static void set_begin_of_direntry(direntry_t* direntry, uint32_t begin)
487 {
488 direntry->begin = cpu_to_le16(begin & 0xffff);
489 direntry->begin_hi = cpu_to_le16((begin >> 16) & 0xffff);
490 }
491
valid_filename(const unsigned char * name)492 static bool valid_filename(const unsigned char *name)
493 {
494 unsigned char c;
495 if (!strcmp((const char*)name, ".") || !strcmp((const char*)name, "..")) {
496 return false;
497 }
498 for (; (c = *name); name++) {
499 if (!((c >= '0' && c <= '9') ||
500 (c >= 'A' && c <= 'Z') ||
501 (c >= 'a' && c <= 'z') ||
502 c > 127 ||
503 strchr(" $%'-_@~`!(){}^#&.+,;=[]", c) != NULL))
504 {
505 return false;
506 }
507 }
508 return true;
509 }
510
to_valid_short_char(gunichar c)511 static uint8_t to_valid_short_char(gunichar c)
512 {
513 c = g_unichar_toupper(c);
514 if ((c >= '0' && c <= '9') ||
515 (c >= 'A' && c <= 'Z') ||
516 strchr("$%'-_@~`!(){}^#&", c) != NULL) {
517 return c;
518 } else {
519 return 0;
520 }
521 }
522
create_short_filename(BDRVVVFATState * s,const char * filename,unsigned int directory_start)523 static direntry_t *create_short_filename(BDRVVVFATState *s,
524 const char *filename,
525 unsigned int directory_start)
526 {
527 int i, j = 0;
528 direntry_t *entry = array_get_next(&(s->directory));
529 const gchar *p, *last_dot = NULL;
530 gunichar c;
531 bool lossy_conversion = false;
532 char tail[8];
533
534 if (!entry) {
535 return NULL;
536 }
537 memset(entry->name, 0x20, sizeof(entry->name));
538
539 /* copy filename and search last dot */
540 for (p = filename; ; p = g_utf8_next_char(p)) {
541 c = g_utf8_get_char(p);
542 if (c == '\0') {
543 break;
544 } else if (c == '.') {
545 if (j == 0) {
546 /* '.' at start of filename */
547 lossy_conversion = true;
548 } else {
549 if (last_dot) {
550 lossy_conversion = true;
551 }
552 last_dot = p;
553 }
554 } else if (!last_dot) {
555 /* first part of the name; copy it */
556 uint8_t v = to_valid_short_char(c);
557 if (j < 8 && v) {
558 entry->name[j++] = v;
559 } else {
560 lossy_conversion = true;
561 }
562 }
563 }
564
565 /* copy extension (if any) */
566 if (last_dot) {
567 j = 0;
568 for (p = g_utf8_next_char(last_dot); ; p = g_utf8_next_char(p)) {
569 c = g_utf8_get_char(p);
570 if (c == '\0') {
571 break;
572 } else {
573 /* extension; copy it */
574 uint8_t v = to_valid_short_char(c);
575 if (j < 3 && v) {
576 entry->name[8 + (j++)] = v;
577 } else {
578 lossy_conversion = true;
579 }
580 }
581 }
582 }
583
584 if (entry->name[0] == DIR_KANJI) {
585 entry->name[0] = DIR_KANJI_FAKE;
586 }
587
588 /* numeric-tail generation */
589 for (j = 0; j < 8; j++) {
590 if (entry->name[j] == ' ') {
591 break;
592 }
593 }
594 for (i = lossy_conversion ? 1 : 0; i < 999999; i++) {
595 direntry_t *entry1;
596 if (i > 0) {
597 int len = snprintf(tail, sizeof(tail), "~%u", (unsigned)i);
598 assert(len <= 7);
599 memcpy(entry->name + MIN(j, 8 - len), tail, len);
600 }
601 for (entry1 = array_get(&(s->directory), directory_start);
602 entry1 < entry; entry1++) {
603 if (!is_long_name(entry1) &&
604 !memcmp(entry1->name, entry->name, 11)) {
605 break; /* found dupe */
606 }
607 }
608 if (entry1 == entry) {
609 /* no dupe found */
610 return entry;
611 }
612 }
613 return NULL;
614 }
615
616 /* fat functions */
617
fat_chksum(const direntry_t * entry)618 static inline uint8_t fat_chksum(const direntry_t* entry)
619 {
620 uint8_t chksum=0;
621 int i;
622
623 for (i = 0; i < ARRAY_SIZE(entry->name); i++) {
624 chksum = (((chksum & 0xfe) >> 1) |
625 ((chksum & 0x01) ? 0x80 : 0)) + entry->name[i];
626 }
627
628 return chksum;
629 }
630
631 /* if return_time==0, this returns the fat_date, else the fat_time */
fat_datetime(time_t time,int return_time)632 static uint16_t fat_datetime(time_t time,int return_time) {
633 struct tm* t;
634 struct tm t1;
635 t = &t1;
636 localtime_r(&time,t);
637 if(return_time)
638 return cpu_to_le16((t->tm_sec/2)|(t->tm_min<<5)|(t->tm_hour<<11));
639 return cpu_to_le16((t->tm_mday)|((t->tm_mon+1)<<5)|((t->tm_year-80)<<9));
640 }
641
fat_set(BDRVVVFATState * s,unsigned int cluster,uint32_t value)642 static inline void fat_set(BDRVVVFATState* s,unsigned int cluster,uint32_t value)
643 {
644 if(s->fat_type==32) {
645 uint32_t* entry=array_get(&(s->fat),cluster);
646 *entry=cpu_to_le32(value);
647 } else if(s->fat_type==16) {
648 uint16_t* entry=array_get(&(s->fat),cluster);
649 *entry=cpu_to_le16(value&0xffff);
650 } else {
651 int offset = (cluster*3/2);
652 unsigned char* p = array_get(&(s->fat), offset);
653 switch (cluster&1) {
654 case 0:
655 p[0] = value&0xff;
656 p[1] = (p[1]&0xf0) | ((value>>8)&0xf);
657 break;
658 case 1:
659 p[0] = (p[0]&0xf) | ((value&0xf)<<4);
660 p[1] = (value>>4);
661 break;
662 }
663 }
664 }
665
fat_get(BDRVVVFATState * s,unsigned int cluster)666 static inline uint32_t fat_get(BDRVVVFATState* s,unsigned int cluster)
667 {
668 if(s->fat_type==32) {
669 uint32_t* entry=array_get(&(s->fat),cluster);
670 return le32_to_cpu(*entry);
671 } else if(s->fat_type==16) {
672 uint16_t* entry=array_get(&(s->fat),cluster);
673 return le16_to_cpu(*entry);
674 } else {
675 const uint8_t* x=(uint8_t*)(s->fat.pointer)+cluster*3/2;
676 return ((x[0]|(x[1]<<8))>>(cluster&1?4:0))&0x0fff;
677 }
678 }
679
fat_eof(BDRVVVFATState * s,uint32_t fat_entry)680 static inline int fat_eof(BDRVVVFATState* s,uint32_t fat_entry)
681 {
682 if(fat_entry>s->max_fat_value-8)
683 return -1;
684 return 0;
685 }
686
init_fat(BDRVVVFATState * s)687 static inline void init_fat(BDRVVVFATState* s)
688 {
689 if (s->fat_type == 12) {
690 array_init(&(s->fat),1);
691 array_ensure_allocated(&(s->fat),
692 s->sectors_per_fat * 0x200 * 3 / 2 - 1);
693 } else {
694 array_init(&(s->fat),(s->fat_type==32?4:2));
695 array_ensure_allocated(&(s->fat),
696 s->sectors_per_fat * 0x200 / s->fat.item_size - 1);
697 }
698 memset(s->fat.pointer,0,s->fat.size);
699
700 switch(s->fat_type) {
701 case 12: s->max_fat_value=0xfff; break;
702 case 16: s->max_fat_value=0xffff; break;
703 case 32: s->max_fat_value=0x0fffffff; break;
704 default: s->max_fat_value=0; /* error... */
705 }
706
707 }
708
create_short_and_long_name(BDRVVVFATState * s,unsigned int directory_start,const char * filename,int is_dot)709 static inline direntry_t* create_short_and_long_name(BDRVVVFATState* s,
710 unsigned int directory_start, const char* filename, int is_dot)
711 {
712 int long_index = s->directory.next;
713 direntry_t* entry = NULL;
714 direntry_t* entry_long = NULL;
715
716 if(is_dot) {
717 entry=array_get_next(&(s->directory));
718 memset(entry->name, 0x20, sizeof(entry->name));
719 memcpy(entry->name,filename,strlen(filename));
720 return entry;
721 }
722
723 entry_long=create_long_filename(s,filename);
724 entry = create_short_filename(s, filename, directory_start);
725
726 /* calculate checksum; propagate to long name */
727 if(entry_long) {
728 uint8_t chksum=fat_chksum(entry);
729
730 /* calculate anew, because realloc could have taken place */
731 entry_long=array_get(&(s->directory),long_index);
732 while(entry_long<entry && is_long_name(entry_long)) {
733 entry_long->reserved[1]=chksum;
734 entry_long++;
735 }
736 }
737
738 return entry;
739 }
740
741 /*
742 * Read a directory. (the index of the corresponding mapping must be passed).
743 */
read_directory(BDRVVVFATState * s,int mapping_index)744 static int read_directory(BDRVVVFATState* s, int mapping_index)
745 {
746 mapping_t* mapping = array_get(&(s->mapping), mapping_index);
747 direntry_t* direntry;
748 const char* dirname = mapping->path;
749 int first_cluster = mapping->begin;
750 int parent_index = mapping->info.dir.parent_mapping_index;
751 mapping_t* parent_mapping = (mapping_t*)
752 (parent_index >= 0 ? array_get(&(s->mapping), parent_index) : NULL);
753 int first_cluster_of_parent = parent_mapping ? parent_mapping->begin : -1;
754
755 DIR* dir=opendir(dirname);
756 struct dirent* entry;
757 int i;
758
759 assert(mapping->mode & MODE_DIRECTORY);
760
761 if(!dir) {
762 mapping->end = mapping->begin;
763 return -1;
764 }
765
766 i = mapping->info.dir.first_dir_index =
767 first_cluster == 0 ? 0 : s->directory.next;
768
769 if (first_cluster != 0) {
770 /* create the top entries of a subdirectory */
771 (void)create_short_and_long_name(s, i, ".", 1);
772 (void)create_short_and_long_name(s, i, "..", 1);
773 }
774
775 /* actually read the directory, and allocate the mappings */
776 while((entry=readdir(dir))) {
777 unsigned int length=strlen(dirname)+2+strlen(entry->d_name);
778 char* buffer;
779 struct stat st;
780 int is_dot=!strcmp(entry->d_name,".");
781 int is_dotdot=!strcmp(entry->d_name,"..");
782
783 if (first_cluster == 0 && s->directory.next >= s->root_entries - 1) {
784 fprintf(stderr, "Too many entries in root directory\n");
785 closedir(dir);
786 return -2;
787 }
788
789 if(first_cluster == 0 && (is_dotdot || is_dot))
790 continue;
791
792 buffer = g_malloc(length);
793 snprintf(buffer,length,"%s/%s",dirname,entry->d_name);
794
795 if(stat(buffer,&st)<0) {
796 g_free(buffer);
797 continue;
798 }
799
800 /* create directory entry for this file */
801 if (!is_dot && !is_dotdot) {
802 direntry = create_short_and_long_name(s, i, entry->d_name, 0);
803 } else {
804 direntry = array_get(&(s->directory), is_dot ? i : i + 1);
805 }
806 direntry->attributes=(S_ISDIR(st.st_mode)?0x10:0x20);
807 direntry->reserved[0]=direntry->reserved[1]=0;
808 direntry->ctime=fat_datetime(st.st_ctime,1);
809 direntry->cdate=fat_datetime(st.st_ctime,0);
810 direntry->adate=fat_datetime(st.st_atime,0);
811 direntry->begin_hi=0;
812 direntry->mtime=fat_datetime(st.st_mtime,1);
813 direntry->mdate=fat_datetime(st.st_mtime,0);
814 if(is_dotdot)
815 set_begin_of_direntry(direntry, first_cluster_of_parent);
816 else if(is_dot)
817 set_begin_of_direntry(direntry, first_cluster);
818 else
819 direntry->begin=0; /* do that later */
820 if (st.st_size > 0x7fffffff) {
821 fprintf(stderr, "File %s is larger than 2GB\n", buffer);
822 g_free(buffer);
823 closedir(dir);
824 return -2;
825 }
826 direntry->size=cpu_to_le32(S_ISDIR(st.st_mode)?0:st.st_size);
827
828 /* create mapping for this file */
829 if(!is_dot && !is_dotdot && (S_ISDIR(st.st_mode) || st.st_size)) {
830 s->current_mapping = array_get_next(&(s->mapping));
831 s->current_mapping->begin=0;
832 s->current_mapping->end=st.st_size;
833 /*
834 * we get the direntry of the most recent direntry, which
835 * contains the short name and all the relevant information.
836 */
837 s->current_mapping->dir_index=s->directory.next-1;
838 s->current_mapping->first_mapping_index = -1;
839 if (S_ISDIR(st.st_mode)) {
840 s->current_mapping->mode = MODE_DIRECTORY;
841 s->current_mapping->info.dir.parent_mapping_index =
842 mapping_index;
843 } else {
844 s->current_mapping->mode = MODE_UNDEFINED;
845 s->current_mapping->info.file.offset = 0;
846 }
847 s->current_mapping->path=buffer;
848 s->current_mapping->read_only =
849 (st.st_mode & (S_IWUSR | S_IWGRP | S_IWOTH)) == 0;
850 } else {
851 g_free(buffer);
852 }
853 }
854 closedir(dir);
855
856 /* fill with zeroes up to the end of the cluster */
857 while(s->directory.next%(0x10*s->sectors_per_cluster)) {
858 direntry = array_get_next(&(s->directory));
859 memset(direntry,0,sizeof(direntry_t));
860 }
861
862 if (s->fat_type != 32 &&
863 mapping_index == 0 &&
864 s->directory.next < s->root_entries) {
865 /* root directory */
866 int cur = s->directory.next;
867 array_ensure_allocated(&(s->directory), s->root_entries - 1);
868 s->directory.next = s->root_entries;
869 memset(array_get(&(s->directory), cur), 0,
870 (s->root_entries - cur) * sizeof(direntry_t));
871 }
872
873 /* re-get the mapping, since s->mapping was possibly realloc()ed */
874 mapping = array_get(&(s->mapping), mapping_index);
875 first_cluster += (s->directory.next - mapping->info.dir.first_dir_index)
876 * 0x20 / s->cluster_size;
877 mapping->end = first_cluster;
878
879 direntry = array_get(&(s->directory), mapping->dir_index);
880 set_begin_of_direntry(direntry, mapping->begin);
881
882 return 0;
883 }
884
sector2cluster(BDRVVVFATState * s,off_t sector_num)885 static inline int32_t sector2cluster(BDRVVVFATState* s,off_t sector_num)
886 {
887 return (sector_num - s->offset_to_root_dir) / s->sectors_per_cluster;
888 }
889
cluster2sector(BDRVVVFATState * s,uint32_t cluster_num)890 static inline off_t cluster2sector(BDRVVVFATState* s, uint32_t cluster_num)
891 {
892 return s->offset_to_root_dir + s->sectors_per_cluster * cluster_num;
893 }
894
init_directories(BDRVVVFATState * s,const char * dirname,int heads,int secs,Error ** errp)895 static int init_directories(BDRVVVFATState* s,
896 const char *dirname, int heads, int secs,
897 Error **errp)
898 {
899 bootsector_t* bootsector;
900 mapping_t* mapping;
901 unsigned int i;
902 unsigned int cluster;
903
904 memset(&(s->first_sectors[0]),0,0x40*0x200);
905
906 s->cluster_size=s->sectors_per_cluster*0x200;
907 s->cluster_buffer=g_malloc(s->cluster_size);
908
909 /*
910 * The formula: sc = spf+1+spf*spc*(512*8/fat_type),
911 * where sc is sector_count,
912 * spf is sectors_per_fat,
913 * spc is sectors_per_clusters, and
914 * fat_type = 12, 16 or 32.
915 */
916 i = 1+s->sectors_per_cluster*0x200*8/s->fat_type;
917 s->sectors_per_fat=(s->sector_count+i)/i; /* round up */
918
919 s->offset_to_fat = s->offset_to_bootsector + 1;
920 s->offset_to_root_dir = s->offset_to_fat + s->sectors_per_fat * 2;
921
922 array_init(&(s->mapping),sizeof(mapping_t));
923 array_init(&(s->directory),sizeof(direntry_t));
924
925 /* add volume label */
926 {
927 direntry_t* entry=array_get_next(&(s->directory));
928 entry->attributes=0x28; /* archive | volume label */
929 memcpy(entry->name, s->volume_label, sizeof(entry->name));
930 }
931
932 /* Now build FAT, and write back information into directory */
933 init_fat(s);
934
935 /* TODO: if there are more entries, bootsector has to be adjusted! */
936 s->root_entries = 0x02 * 0x10 * s->sectors_per_cluster;
937 s->cluster_count=sector2cluster(s, s->sector_count);
938
939 mapping = array_get_next(&(s->mapping));
940 mapping->begin = 0;
941 mapping->dir_index = 0;
942 mapping->info.dir.parent_mapping_index = -1;
943 mapping->first_mapping_index = -1;
944 mapping->path = g_strdup(dirname);
945 i = strlen(mapping->path);
946 if (i > 0 && mapping->path[i - 1] == '/')
947 mapping->path[i - 1] = '\0';
948 mapping->mode = MODE_DIRECTORY;
949 mapping->read_only = 0;
950 s->path = mapping->path;
951
952 for (i = 0, cluster = 0; i < s->mapping.next; i++) {
953 /* MS-DOS expects the FAT to be 0 for the root directory
954 * (except for the media byte). */
955 /* LATER TODO: still true for FAT32? */
956 int fix_fat = (i != 0);
957 mapping = array_get(&(s->mapping), i);
958
959 if (mapping->mode & MODE_DIRECTORY) {
960 char *path = mapping->path;
961 mapping->begin = cluster;
962 if(read_directory(s, i)) {
963 error_setg(errp, "Could not read directory %s", path);
964 return -1;
965 }
966 mapping = array_get(&(s->mapping), i);
967 } else {
968 assert(mapping->mode == MODE_UNDEFINED);
969 mapping->mode=MODE_NORMAL;
970 mapping->begin = cluster;
971 if (mapping->end > 0) {
972 direntry_t* direntry = array_get(&(s->directory),
973 mapping->dir_index);
974
975 mapping->end = cluster + 1 + (mapping->end-1)/s->cluster_size;
976 set_begin_of_direntry(direntry, mapping->begin);
977 } else {
978 mapping->end = cluster + 1;
979 fix_fat = 0;
980 }
981 }
982
983 assert(mapping->begin < mapping->end);
984
985 /* next free cluster */
986 cluster = mapping->end;
987
988 if(cluster > s->cluster_count) {
989 error_setg(errp,
990 "Directory does not fit in FAT%d (capacity %.2f MB)",
991 s->fat_type, s->sector_count / 2000.0);
992 return -1;
993 }
994
995 /* fix fat for entry */
996 if (fix_fat) {
997 int j;
998 for(j = mapping->begin; j < mapping->end - 1; j++)
999 fat_set(s, j, j+1);
1000 fat_set(s, mapping->end - 1, s->max_fat_value);
1001 }
1002 }
1003
1004 mapping = array_get(&(s->mapping), 0);
1005 s->last_cluster_of_root_directory = mapping->end;
1006
1007 /* the FAT signature */
1008 fat_set(s,0,s->max_fat_value);
1009 fat_set(s,1,s->max_fat_value);
1010
1011 s->current_mapping = NULL;
1012
1013 bootsector = (bootsector_t *)(s->first_sectors
1014 + s->offset_to_bootsector * 0x200);
1015 bootsector->jump[0]=0xeb;
1016 bootsector->jump[1]=0x3e;
1017 bootsector->jump[2]=0x90;
1018 memcpy(bootsector->name, BOOTSECTOR_OEM_NAME, 8);
1019 bootsector->sector_size=cpu_to_le16(0x200);
1020 bootsector->sectors_per_cluster=s->sectors_per_cluster;
1021 bootsector->reserved_sectors=cpu_to_le16(1);
1022 bootsector->number_of_fats=0x2; /* number of FATs */
1023 bootsector->root_entries = cpu_to_le16(s->root_entries);
1024 bootsector->total_sectors16=s->sector_count>0xffff?0:cpu_to_le16(s->sector_count);
1025 /* media descriptor: hard disk=0xf8, floppy=0xf0 */
1026 bootsector->media_type = (s->offset_to_bootsector > 0 ? 0xf8 : 0xf0);
1027 s->fat.pointer[0] = bootsector->media_type;
1028 bootsector->sectors_per_fat=cpu_to_le16(s->sectors_per_fat);
1029 bootsector->sectors_per_track = cpu_to_le16(secs);
1030 bootsector->number_of_heads = cpu_to_le16(heads);
1031 bootsector->hidden_sectors = cpu_to_le32(s->offset_to_bootsector);
1032 bootsector->total_sectors=cpu_to_le32(s->sector_count>0xffff?s->sector_count:0);
1033
1034 /* LATER TODO: if FAT32, this is wrong */
1035 /* drive_number: fda=0, hda=0x80 */
1036 bootsector->u.fat16.drive_number = s->offset_to_bootsector == 0 ? 0 : 0x80;
1037 bootsector->u.fat16.signature=0x29;
1038 bootsector->u.fat16.id=cpu_to_le32(0xfabe1afd);
1039
1040 memcpy(bootsector->u.fat16.volume_label, s->volume_label,
1041 sizeof(bootsector->u.fat16.volume_label));
1042 memcpy(bootsector->u.fat16.fat_type,
1043 s->fat_type == 12 ? "FAT12 " : "FAT16 ", 8);
1044 bootsector->magic[0]=0x55; bootsector->magic[1]=0xaa;
1045
1046 return 0;
1047 }
1048
1049 #ifdef DEBUG
1050 static BDRVVVFATState *vvv = NULL;
1051 #endif
1052
1053 static int enable_write_target(BlockDriverState *bs, Error **errp);
1054 static int coroutine_fn is_consistent(BDRVVVFATState *s);
1055
1056 static QemuOptsList runtime_opts = {
1057 .name = "vvfat",
1058 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
1059 .desc = {
1060 {
1061 .name = "dir",
1062 .type = QEMU_OPT_STRING,
1063 .help = "Host directory to map to the vvfat device",
1064 },
1065 {
1066 .name = "fat-type",
1067 .type = QEMU_OPT_NUMBER,
1068 .help = "FAT type (12, 16 or 32)",
1069 },
1070 {
1071 .name = "floppy",
1072 .type = QEMU_OPT_BOOL,
1073 .help = "Create a floppy rather than a hard disk image",
1074 },
1075 {
1076 .name = "label",
1077 .type = QEMU_OPT_STRING,
1078 .help = "Use a volume label other than QEMU VVFAT",
1079 },
1080 {
1081 .name = "rw",
1082 .type = QEMU_OPT_BOOL,
1083 .help = "Make the image writable",
1084 },
1085 { /* end of list */ }
1086 },
1087 };
1088
vvfat_parse_filename(const char * filename,QDict * options,Error ** errp)1089 static void vvfat_parse_filename(const char *filename, QDict *options,
1090 Error **errp)
1091 {
1092 int fat_type = 0;
1093 bool floppy = false;
1094 bool rw = false;
1095 int i;
1096
1097 if (!strstart(filename, "fat:", NULL)) {
1098 error_setg(errp, "File name string must start with 'fat:'");
1099 return;
1100 }
1101
1102 /* Parse options */
1103 if (strstr(filename, ":32:")) {
1104 fat_type = 32;
1105 } else if (strstr(filename, ":16:")) {
1106 fat_type = 16;
1107 } else if (strstr(filename, ":12:")) {
1108 fat_type = 12;
1109 }
1110
1111 if (strstr(filename, ":floppy:")) {
1112 floppy = true;
1113 }
1114
1115 if (strstr(filename, ":rw:")) {
1116 rw = true;
1117 }
1118
1119 /* Get the directory name without options */
1120 i = strrchr(filename, ':') - filename;
1121 assert(i >= 3);
1122 if (filename[i - 2] == ':' && qemu_isalpha(filename[i - 1])) {
1123 /* workaround for DOS drive names */
1124 filename += i - 1;
1125 } else {
1126 filename += i + 1;
1127 }
1128
1129 /* Fill in the options QDict */
1130 qdict_put_str(options, "dir", filename);
1131 qdict_put_int(options, "fat-type", fat_type);
1132 qdict_put_bool(options, "floppy", floppy);
1133 qdict_put_bool(options, "rw", rw);
1134 }
1135
vvfat_open(BlockDriverState * bs,QDict * options,int flags,Error ** errp)1136 static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
1137 Error **errp)
1138 {
1139 BDRVVVFATState *s = bs->opaque;
1140 int cyls, heads, secs;
1141 bool floppy;
1142 const char *dirname, *label;
1143 QemuOpts *opts;
1144 int ret;
1145
1146 GRAPH_RDLOCK_GUARD_MAINLOOP();
1147
1148 #ifdef DEBUG
1149 vvv = s;
1150 #endif
1151
1152 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
1153 if (!qemu_opts_absorb_qdict(opts, options, errp)) {
1154 ret = -EINVAL;
1155 goto fail;
1156 }
1157
1158 dirname = qemu_opt_get(opts, "dir");
1159 if (!dirname) {
1160 error_setg(errp, "vvfat block driver requires a 'dir' option");
1161 ret = -EINVAL;
1162 goto fail;
1163 }
1164
1165 s->fat_type = qemu_opt_get_number(opts, "fat-type", 0);
1166 floppy = qemu_opt_get_bool(opts, "floppy", false);
1167
1168 memset(s->volume_label, ' ', sizeof(s->volume_label));
1169 label = qemu_opt_get(opts, "label");
1170 if (label) {
1171 size_t label_length = strlen(label);
1172 if (label_length > 11) {
1173 error_setg(errp, "vvfat label cannot be longer than 11 bytes");
1174 ret = -EINVAL;
1175 goto fail;
1176 }
1177 memcpy(s->volume_label, label, label_length);
1178 } else {
1179 memcpy(s->volume_label, "QEMU VVFAT", 10);
1180 }
1181
1182 if (floppy) {
1183 /* 1.44MB or 2.88MB floppy. 2.88MB can be FAT12 (default) or FAT16. */
1184 if (!s->fat_type) {
1185 s->fat_type = 12;
1186 secs = 36;
1187 s->sectors_per_cluster = 2;
1188 } else {
1189 secs = s->fat_type == 12 ? 18 : 36;
1190 s->sectors_per_cluster = 1;
1191 }
1192 cyls = 80;
1193 heads = 2;
1194 } else {
1195 /* 32MB or 504MB disk*/
1196 if (!s->fat_type) {
1197 s->fat_type = 16;
1198 }
1199 s->offset_to_bootsector = 0x3f;
1200 cyls = s->fat_type == 12 ? 64 : 1024;
1201 heads = 16;
1202 secs = 63;
1203 }
1204
1205 switch (s->fat_type) {
1206 case 32:
1207 warn_report("FAT32 has not been tested. You are welcome to do so!");
1208 break;
1209 case 16:
1210 case 12:
1211 break;
1212 default:
1213 error_setg(errp, "Valid FAT types are only 12, 16 and 32");
1214 ret = -EINVAL;
1215 goto fail;
1216 }
1217
1218
1219 s->bs = bs;
1220
1221 /* LATER TODO: if FAT32, adjust */
1222 s->sectors_per_cluster=0x10;
1223
1224 s->current_cluster=0xffffffff;
1225
1226 s->qcow = NULL;
1227 s->qcow_filename = NULL;
1228 s->fat2 = NULL;
1229 s->downcase_short_names = 1;
1230
1231 DLOG(fprintf(stderr, "vvfat %s chs %d,%d,%d\n",
1232 dirname, cyls, heads, secs));
1233
1234 s->sector_count = cyls * heads * secs - s->offset_to_bootsector;
1235 bs->total_sectors = cyls * heads * secs;
1236
1237 if (qemu_opt_get_bool(opts, "rw", false)) {
1238 if (!bdrv_is_read_only(bs)) {
1239 ret = enable_write_target(bs, errp);
1240 if (ret < 0) {
1241 goto fail;
1242 }
1243 } else {
1244 ret = -EPERM;
1245 error_setg(errp,
1246 "Unable to set VVFAT to 'rw' when drive is read-only");
1247 goto fail;
1248 }
1249 } else {
1250 ret = bdrv_apply_auto_read_only(bs, NULL, errp);
1251 if (ret < 0) {
1252 goto fail;
1253 }
1254 }
1255
1256 if (init_directories(s, dirname, heads, secs, errp)) {
1257 ret = -EIO;
1258 goto fail;
1259 }
1260
1261 s->sector_count = s->offset_to_root_dir
1262 + s->sectors_per_cluster * s->cluster_count;
1263
1264 /* Disable migration when vvfat is used rw */
1265 if (s->qcow) {
1266 error_setg(&s->migration_blocker,
1267 "The vvfat (rw) format used by node '%s' "
1268 "does not support live migration",
1269 bdrv_get_device_or_node_name(bs));
1270 ret = migrate_add_blocker_normal(&s->migration_blocker, errp);
1271 if (ret < 0) {
1272 goto fail;
1273 }
1274 }
1275
1276 if (s->offset_to_bootsector > 0) {
1277 init_mbr(s, cyls, heads, secs);
1278 }
1279
1280 qemu_co_mutex_init(&s->lock);
1281
1282 qemu_opts_del(opts);
1283
1284 return 0;
1285
1286 fail:
1287 g_free(s->qcow_filename);
1288 s->qcow_filename = NULL;
1289 g_free(s->cluster_buffer);
1290 s->cluster_buffer = NULL;
1291 g_free(s->used_clusters);
1292 s->used_clusters = NULL;
1293
1294 qemu_opts_del(opts);
1295 return ret;
1296 }
1297
vvfat_refresh_limits(BlockDriverState * bs,Error ** errp)1298 static void vvfat_refresh_limits(BlockDriverState *bs, Error **errp)
1299 {
1300 bs->bl.request_alignment = BDRV_SECTOR_SIZE; /* No sub-sector I/O */
1301 }
1302
vvfat_close_current_file(BDRVVVFATState * s)1303 static inline void vvfat_close_current_file(BDRVVVFATState *s)
1304 {
1305 if(s->current_mapping) {
1306 s->current_mapping = NULL;
1307 if (s->current_fd) {
1308 qemu_close(s->current_fd);
1309 s->current_fd = 0;
1310 }
1311 }
1312 s->current_cluster = -1;
1313 }
1314
1315 /* mappings between index1 and index2-1 are supposed to be ordered
1316 * return value is the index of the last mapping for which end>cluster_num
1317 */
find_mapping_for_cluster_aux(BDRVVVFATState * s,int cluster_num,int index1,int index2)1318 static inline int find_mapping_for_cluster_aux(BDRVVVFATState* s,int cluster_num,int index1,int index2)
1319 {
1320 while(1) {
1321 int index3;
1322 mapping_t* mapping;
1323 index3=(index1+index2)/2;
1324 mapping=array_get(&(s->mapping),index3);
1325 assert(mapping->begin < mapping->end);
1326 if(mapping->begin>=cluster_num) {
1327 assert(index2!=index3 || index2==0);
1328 if(index2==index3)
1329 return index1;
1330 index2=index3;
1331 } else {
1332 if(index1==index3)
1333 return mapping->end<=cluster_num ? index2 : index1;
1334 index1=index3;
1335 }
1336 assert(index1<=index2);
1337 DLOG(mapping=array_get(&(s->mapping),index1);
1338 assert(mapping->begin<=cluster_num);
1339 assert(index2 >= s->mapping.next ||
1340 ((mapping = array_get(&(s->mapping),index2)) &&
1341 mapping->end>cluster_num)));
1342 }
1343 }
1344
find_mapping_for_cluster(BDRVVVFATState * s,int cluster_num)1345 static inline mapping_t* find_mapping_for_cluster(BDRVVVFATState* s,int cluster_num)
1346 {
1347 int index=find_mapping_for_cluster_aux(s,cluster_num,0,s->mapping.next);
1348 mapping_t* mapping;
1349 if(index>=s->mapping.next)
1350 return NULL;
1351 mapping=array_get(&(s->mapping),index);
1352 if(mapping->begin>cluster_num)
1353 return NULL;
1354 assert(mapping->begin<=cluster_num && mapping->end>cluster_num);
1355 return mapping;
1356 }
1357
open_file(BDRVVVFATState * s,mapping_t * mapping)1358 static int open_file(BDRVVVFATState* s,mapping_t* mapping)
1359 {
1360 if(!mapping)
1361 return -1;
1362 if(!s->current_mapping ||
1363 strcmp(s->current_mapping->path,mapping->path)) {
1364 /* open file */
1365 int fd = qemu_open_old(mapping->path,
1366 O_RDONLY | O_BINARY | O_LARGEFILE);
1367 if(fd<0)
1368 return -1;
1369 vvfat_close_current_file(s);
1370 s->current_fd = fd;
1371 }
1372
1373 s->current_mapping = mapping;
1374 return 0;
1375 }
1376
read_cluster(BDRVVVFATState * s,int cluster_num)1377 static inline int read_cluster(BDRVVVFATState *s,int cluster_num)
1378 {
1379 if(s->current_cluster != cluster_num) {
1380 int result=0;
1381 off_t offset;
1382 assert(!s->current_mapping || s->current_fd || (s->current_mapping->mode & MODE_DIRECTORY));
1383 if(!s->current_mapping
1384 || s->current_mapping->begin>cluster_num
1385 || s->current_mapping->end<=cluster_num) {
1386 /* binary search of mappings for file */
1387 mapping_t* mapping=find_mapping_for_cluster(s,cluster_num);
1388
1389 assert(!mapping || (cluster_num>=mapping->begin && cluster_num<mapping->end));
1390
1391 if (mapping && mapping->mode & MODE_DIRECTORY) {
1392 vvfat_close_current_file(s);
1393 s->current_mapping = mapping;
1394 read_cluster_directory:
1395 offset = s->cluster_size*(cluster_num-s->current_mapping->begin);
1396 s->cluster = (unsigned char*)s->directory.pointer+offset
1397 + 0x20*s->current_mapping->info.dir.first_dir_index;
1398 assert(((s->cluster-(unsigned char*)s->directory.pointer)%s->cluster_size)==0);
1399 assert((char*)s->cluster+s->cluster_size <= s->directory.pointer+s->directory.next*s->directory.item_size);
1400 s->current_cluster = cluster_num;
1401 return 0;
1402 }
1403
1404 if(open_file(s,mapping))
1405 return -2;
1406 } else if (s->current_mapping->mode & MODE_DIRECTORY)
1407 goto read_cluster_directory;
1408
1409 assert(s->current_fd);
1410
1411 offset = s->cluster_size *
1412 ((cluster_num - s->current_mapping->begin)
1413 + s->current_mapping->info.file.offset);
1414 if(lseek(s->current_fd, offset, SEEK_SET)!=offset)
1415 return -3;
1416 s->cluster=s->cluster_buffer;
1417 result=read(s->current_fd,s->cluster,s->cluster_size);
1418 if(result<0) {
1419 s->current_cluster = -1;
1420 return -1;
1421 }
1422 s->current_cluster = cluster_num;
1423 }
1424 return 0;
1425 }
1426
1427 #ifdef DEBUG
print_direntry(const direntry_t * direntry)1428 static void print_direntry(const direntry_t* direntry)
1429 {
1430 int j = 0;
1431 char buffer[1024];
1432
1433 fprintf(stderr, "direntry %p: ", direntry);
1434 if(!direntry)
1435 return;
1436 if(is_long_name(direntry)) {
1437 unsigned char* c=(unsigned char*)direntry;
1438 int i;
1439 for(i=1;i<11 && c[i] && c[i]!=0xff;i+=2)
1440 #define ADD_CHAR(c) {buffer[j] = (c); if (buffer[j] < ' ') buffer[j] = 0xb0; j++;}
1441 ADD_CHAR(c[i]);
1442 for(i=14;i<26 && c[i] && c[i]!=0xff;i+=2)
1443 ADD_CHAR(c[i]);
1444 for(i=28;i<32 && c[i] && c[i]!=0xff;i+=2)
1445 ADD_CHAR(c[i]);
1446 buffer[j] = 0;
1447 fprintf(stderr, "%s\n", buffer);
1448 } else {
1449 int i;
1450 for(i=0;i<11;i++)
1451 ADD_CHAR(direntry->name[i]);
1452 buffer[j] = 0;
1453 fprintf(stderr, "%s attributes=0x%02x begin=%u size=%u\n",
1454 buffer,
1455 direntry->attributes,
1456 begin_of_direntry(direntry),le32_to_cpu(direntry->size));
1457 }
1458 }
1459
print_mapping(const mapping_t * mapping)1460 static void print_mapping(const mapping_t* mapping)
1461 {
1462 fprintf(stderr, "mapping (%p): begin, end = %u, %u, dir_index = %u, "
1463 "first_mapping_index = %d, name = %s, mode = 0x%x, " ,
1464 mapping, mapping->begin, mapping->end, mapping->dir_index,
1465 mapping->first_mapping_index, mapping->path, mapping->mode);
1466
1467 if (mapping->mode & MODE_DIRECTORY)
1468 fprintf(stderr, "parent_mapping_index = %d, first_dir_index = %d\n", mapping->info.dir.parent_mapping_index, mapping->info.dir.first_dir_index);
1469 else
1470 fprintf(stderr, "offset = %u\n", mapping->info.file.offset);
1471 }
1472 #endif
1473
1474 static int coroutine_fn GRAPH_RDLOCK
vvfat_read(BlockDriverState * bs,int64_t sector_num,uint8_t * buf,int nb_sectors)1475 vvfat_read(BlockDriverState *bs, int64_t sector_num, uint8_t *buf, int nb_sectors)
1476 {
1477 BDRVVVFATState *s = bs->opaque;
1478 int i;
1479
1480 for(i=0;i<nb_sectors;i++,sector_num++) {
1481 if (sector_num >= bs->total_sectors)
1482 return -1;
1483 if (s->qcow) {
1484 int64_t n;
1485 int ret;
1486 ret = bdrv_co_is_allocated(s->qcow->bs, sector_num * BDRV_SECTOR_SIZE,
1487 (nb_sectors - i) * BDRV_SECTOR_SIZE, &n);
1488 if (ret < 0) {
1489 return ret;
1490 }
1491 if (ret) {
1492 DLOG(fprintf(stderr, "sectors %" PRId64 "+%" PRId64
1493 " allocated\n", sector_num,
1494 n >> BDRV_SECTOR_BITS));
1495 if (bdrv_co_pread(s->qcow, sector_num * BDRV_SECTOR_SIZE, n,
1496 buf + i * 0x200, 0) < 0) {
1497 return -1;
1498 }
1499 i += (n >> BDRV_SECTOR_BITS) - 1;
1500 sector_num += (n >> BDRV_SECTOR_BITS) - 1;
1501 continue;
1502 }
1503 DLOG(fprintf(stderr, "sector %" PRId64 " not allocated\n",
1504 sector_num));
1505 }
1506 if (sector_num < s->offset_to_root_dir) {
1507 if (sector_num < s->offset_to_fat) {
1508 memcpy(buf + i * 0x200,
1509 &(s->first_sectors[sector_num * 0x200]),
1510 0x200);
1511 } else if (sector_num < s->offset_to_fat + s->sectors_per_fat) {
1512 memcpy(buf + i * 0x200,
1513 &(s->fat.pointer[(sector_num
1514 - s->offset_to_fat) * 0x200]),
1515 0x200);
1516 } else if (sector_num < s->offset_to_root_dir) {
1517 memcpy(buf + i * 0x200,
1518 &(s->fat.pointer[(sector_num - s->offset_to_fat
1519 - s->sectors_per_fat) * 0x200]),
1520 0x200);
1521 }
1522 } else {
1523 uint32_t sector = sector_num - s->offset_to_root_dir,
1524 sector_offset_in_cluster=(sector%s->sectors_per_cluster),
1525 cluster_num=sector/s->sectors_per_cluster;
1526 if(cluster_num > s->cluster_count || read_cluster(s, cluster_num) != 0) {
1527 /* LATER TODO: strict: return -1; */
1528 memset(buf+i*0x200,0,0x200);
1529 continue;
1530 }
1531 memcpy(buf+i*0x200,s->cluster+sector_offset_in_cluster*0x200,0x200);
1532 }
1533 }
1534 return 0;
1535 }
1536
1537 static int coroutine_fn GRAPH_RDLOCK
vvfat_co_preadv(BlockDriverState * bs,int64_t offset,int64_t bytes,QEMUIOVector * qiov,BdrvRequestFlags flags)1538 vvfat_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
1539 QEMUIOVector *qiov, BdrvRequestFlags flags)
1540 {
1541 int ret;
1542 BDRVVVFATState *s = bs->opaque;
1543 uint64_t sector_num = offset >> BDRV_SECTOR_BITS;
1544 int nb_sectors = bytes >> BDRV_SECTOR_BITS;
1545 void *buf;
1546
1547 assert(QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE));
1548 assert(QEMU_IS_ALIGNED(bytes, BDRV_SECTOR_SIZE));
1549
1550 buf = g_try_malloc(bytes);
1551 if (bytes && buf == NULL) {
1552 return -ENOMEM;
1553 }
1554
1555 qemu_co_mutex_lock(&s->lock);
1556 ret = vvfat_read(bs, sector_num, buf, nb_sectors);
1557 qemu_co_mutex_unlock(&s->lock);
1558
1559 qemu_iovec_from_buf(qiov, 0, buf, bytes);
1560 g_free(buf);
1561
1562 return ret;
1563 }
1564
1565 /* LATER TODO: statify all functions */
1566
1567 /*
1568 * Idea of the write support (use snapshot):
1569 *
1570 * 1. check if all data is consistent, recording renames, modifications,
1571 * new files and directories (in s->commits).
1572 *
1573 * 2. if the data is not consistent, stop committing
1574 *
1575 * 3. handle renames, and create new files and directories (do not yet
1576 * write their contents)
1577 *
1578 * 4. walk the directories, fixing the mapping and direntries, and marking
1579 * the handled mappings as not deleted
1580 *
1581 * 5. commit the contents of the files
1582 *
1583 * 6. handle deleted files and directories
1584 *
1585 */
1586
1587 typedef struct commit_t {
1588 char* path;
1589 union {
1590 struct { uint32_t cluster; } rename;
1591 struct { int dir_index; uint32_t modified_offset; } writeout;
1592 struct { uint32_t first_cluster; } new_file;
1593 struct { uint32_t cluster; } mkdir;
1594 } param;
1595 /* DELETEs and RMDIRs are handled differently: see handle_deletes() */
1596 enum {
1597 ACTION_RENAME, ACTION_WRITEOUT, ACTION_NEW_FILE, ACTION_MKDIR
1598 } action;
1599 } commit_t;
1600
clear_commits(BDRVVVFATState * s)1601 static void clear_commits(BDRVVVFATState* s)
1602 {
1603 int i;
1604 DLOG(fprintf(stderr, "clear_commits (%u commits)\n", s->commits.next));
1605 for (i = 0; i < s->commits.next; i++) {
1606 commit_t* commit = array_get(&(s->commits), i);
1607 assert(commit->path || commit->action == ACTION_WRITEOUT);
1608 if (commit->action != ACTION_WRITEOUT) {
1609 assert(commit->path);
1610 g_free(commit->path);
1611 } else
1612 assert(commit->path == NULL);
1613 }
1614 s->commits.next = 0;
1615 }
1616
schedule_rename(BDRVVVFATState * s,uint32_t cluster,char * new_path)1617 static void schedule_rename(BDRVVVFATState* s,
1618 uint32_t cluster, char* new_path)
1619 {
1620 commit_t* commit = array_get_next(&(s->commits));
1621 commit->path = new_path;
1622 commit->param.rename.cluster = cluster;
1623 commit->action = ACTION_RENAME;
1624 }
1625
schedule_writeout(BDRVVVFATState * s,int dir_index,uint32_t modified_offset)1626 static void schedule_writeout(BDRVVVFATState* s,
1627 int dir_index, uint32_t modified_offset)
1628 {
1629 commit_t* commit = array_get_next(&(s->commits));
1630 commit->path = NULL;
1631 commit->param.writeout.dir_index = dir_index;
1632 commit->param.writeout.modified_offset = modified_offset;
1633 commit->action = ACTION_WRITEOUT;
1634 }
1635
schedule_new_file(BDRVVVFATState * s,char * path,uint32_t first_cluster)1636 static void schedule_new_file(BDRVVVFATState* s,
1637 char* path, uint32_t first_cluster)
1638 {
1639 commit_t* commit = array_get_next(&(s->commits));
1640 commit->path = path;
1641 commit->param.new_file.first_cluster = first_cluster;
1642 commit->action = ACTION_NEW_FILE;
1643 }
1644
schedule_mkdir(BDRVVVFATState * s,uint32_t cluster,char * path)1645 static void schedule_mkdir(BDRVVVFATState* s, uint32_t cluster, char* path)
1646 {
1647 commit_t* commit = array_get_next(&(s->commits));
1648 commit->path = path;
1649 commit->param.mkdir.cluster = cluster;
1650 commit->action = ACTION_MKDIR;
1651 }
1652
1653 typedef struct {
1654 /*
1655 * Since the sequence number is at most 0x3f, and the filename
1656 * length is at most 13 times the sequence number, the maximal
1657 * filename length is 0x3f * 13 bytes.
1658 */
1659 unsigned char name[0x3f * 13 + 1];
1660 gunichar2 name2[0x3f * 13 + 1];
1661 int checksum, len;
1662 int sequence_number;
1663 } long_file_name;
1664
lfn_init(long_file_name * lfn)1665 static void lfn_init(long_file_name* lfn)
1666 {
1667 lfn->sequence_number = lfn->len = 0;
1668 lfn->checksum = 0x100;
1669 }
1670
1671 /* return 0 if parsed successfully, > 0 if no long name, < 0 if error */
parse_long_name(long_file_name * lfn,const direntry_t * direntry)1672 static int parse_long_name(long_file_name* lfn,
1673 const direntry_t* direntry)
1674 {
1675 int i, j, offset;
1676 const unsigned char* pointer = (const unsigned char*)direntry;
1677
1678 if (!is_long_name(direntry))
1679 return 1;
1680
1681 if (pointer[0] & 0x40) {
1682 /* first entry; do some initialization */
1683 lfn->sequence_number = pointer[0] & 0x3f;
1684 lfn->checksum = pointer[13];
1685 lfn->name[0] = 0;
1686 lfn->name[lfn->sequence_number * 13] = 0;
1687 } else if ((pointer[0] & 0x3f) != --lfn->sequence_number) {
1688 /* not the expected sequence number */
1689 return -1;
1690 } else if (pointer[13] != lfn->checksum) {
1691 /* not the expected checksum */
1692 return -2;
1693 } else if (pointer[12] || pointer[26] || pointer[27]) {
1694 /* invalid zero fields */
1695 return -3;
1696 }
1697
1698 offset = 13 * (lfn->sequence_number - 1);
1699 for (i = 0, j = 1; i < 13; i++, j+=2) {
1700 if (j == 11)
1701 j = 14;
1702 else if (j == 26)
1703 j = 28;
1704
1705 if (pointer[j] == 0 && pointer[j + 1] == 0) {
1706 /* end of long file name */
1707 break;
1708 }
1709 gunichar2 c = (pointer[j + 1] << 8) + pointer[j];
1710 lfn->name2[offset + i] = c;
1711 }
1712
1713 if (pointer[0] & 0x40) {
1714 /* first entry; set len */
1715 lfn->len = offset + i;
1716 }
1717 if ((pointer[0] & 0x3f) == 0x01) {
1718 /* last entry; finalize entry */
1719 glong olen;
1720 gchar *utf8 = g_utf16_to_utf8(lfn->name2, lfn->len, NULL, &olen, NULL);
1721 if (!utf8) {
1722 return -4;
1723 }
1724 lfn->len = olen;
1725 memcpy(lfn->name, utf8, olen + 1);
1726 g_free(utf8);
1727 }
1728
1729 return 0;
1730 }
1731
1732 /* returns 0 if successful, >0 if no short_name, and <0 on error */
parse_short_name(BDRVVVFATState * s,long_file_name * lfn,direntry_t * direntry)1733 static int parse_short_name(BDRVVVFATState* s,
1734 long_file_name* lfn, direntry_t* direntry)
1735 {
1736 int i, j;
1737
1738 if (!is_short_name(direntry))
1739 return 1;
1740
1741 for (j = 7; j >= 0 && direntry->name[j] == ' '; j--);
1742 for (i = 0; i <= j; i++) {
1743 uint8_t c = direntry->name[i];
1744 if (c != to_valid_short_char(c)) {
1745 return -1;
1746 } else if (s->downcase_short_names) {
1747 lfn->name[i] = qemu_tolower(direntry->name[i]);
1748 } else {
1749 lfn->name[i] = direntry->name[i];
1750 }
1751 }
1752
1753 for (j = 2; j >= 0 && direntry->name[8 + j] == ' '; j--) {
1754 }
1755 if (j >= 0) {
1756 lfn->name[i++] = '.';
1757 lfn->name[i + j + 1] = '\0';
1758 for (;j >= 0; j--) {
1759 uint8_t c = direntry->name[8 + j];
1760 if (c != to_valid_short_char(c)) {
1761 return -2;
1762 } else if (s->downcase_short_names) {
1763 lfn->name[i + j] = qemu_tolower(c);
1764 } else {
1765 lfn->name[i + j] = c;
1766 }
1767 }
1768 } else
1769 lfn->name[i + j + 1] = '\0';
1770
1771 if (lfn->name[0] == DIR_KANJI_FAKE) {
1772 lfn->name[0] = DIR_KANJI;
1773 }
1774 lfn->len = strlen((char*)lfn->name);
1775
1776 return 0;
1777 }
1778
modified_fat_get(BDRVVVFATState * s,unsigned int cluster)1779 static inline uint32_t modified_fat_get(BDRVVVFATState* s,
1780 unsigned int cluster)
1781 {
1782 if (cluster < s->last_cluster_of_root_directory) {
1783 if (cluster + 1 == s->last_cluster_of_root_directory)
1784 return s->max_fat_value;
1785 else
1786 return cluster + 1;
1787 }
1788
1789 if (s->fat_type==32) {
1790 uint32_t* entry=((uint32_t*)s->fat2)+cluster;
1791 return le32_to_cpu(*entry);
1792 } else if (s->fat_type==16) {
1793 uint16_t* entry=((uint16_t*)s->fat2)+cluster;
1794 return le16_to_cpu(*entry);
1795 } else {
1796 const uint8_t* x=s->fat2+cluster*3/2;
1797 return ((x[0]|(x[1]<<8))>>(cluster&1?4:0))&0x0fff;
1798 }
1799 }
1800
1801 static inline bool coroutine_fn GRAPH_RDLOCK
cluster_was_modified(BDRVVVFATState * s,uint32_t cluster_num)1802 cluster_was_modified(BDRVVVFATState *s, uint32_t cluster_num)
1803 {
1804 int was_modified = 0;
1805 int i;
1806
1807 if (s->qcow == NULL) {
1808 return 0;
1809 }
1810
1811 for (i = 0; !was_modified && i < s->sectors_per_cluster; i++) {
1812 was_modified = bdrv_co_is_allocated(s->qcow->bs,
1813 (cluster2sector(s, cluster_num) +
1814 i) * BDRV_SECTOR_SIZE,
1815 BDRV_SECTOR_SIZE, NULL);
1816 }
1817
1818 /*
1819 * Note that this treats failures to learn allocation status the
1820 * same as if an allocation has occurred. It's as safe as
1821 * anything else, given that a failure to learn allocation status
1822 * will probably result in more failures.
1823 */
1824 return !!was_modified;
1825 }
1826
get_basename(const char * path)1827 static const char* get_basename(const char* path)
1828 {
1829 char* basename = strrchr(path, '/');
1830 if (basename == NULL)
1831 return path;
1832 else
1833 return basename + 1; /* strip '/' */
1834 }
1835
1836 /*
1837 * The array s->used_clusters holds the states of the clusters. If it is
1838 * part of a file, it has bit 2 set, in case of a directory, bit 1. If it
1839 * was modified, bit 3 is set.
1840 * If any cluster is allocated, but not part of a file or directory, this
1841 * driver refuses to commit.
1842 */
1843 typedef enum {
1844 USED_DIRECTORY = 1, USED_FILE = 2, USED_ANY = 3, USED_ALLOCATED = 4
1845 } used_t;
1846
1847 /*
1848 * get_cluster_count_for_direntry() not only determines how many clusters
1849 * are occupied by direntry, but also if it was renamed or modified.
1850 *
1851 * A file is thought to be renamed *only* if there already was a file with
1852 * exactly the same first cluster, but a different name.
1853 *
1854 * Further, the files/directories handled by this function are
1855 * assumed to be *not* deleted (and *only* those).
1856 */
1857 static uint32_t coroutine_fn GRAPH_RDLOCK
get_cluster_count_for_direntry(BDRVVVFATState * s,direntry_t * direntry,const char * path)1858 get_cluster_count_for_direntry(BDRVVVFATState* s, direntry_t* direntry, const char* path)
1859 {
1860 /*
1861 * This is a little bit tricky:
1862 * IF the guest OS just inserts a cluster into the file chain,
1863 * and leaves the rest alone, (i.e. the original file had clusters
1864 * 15 -> 16, but now has 15 -> 32 -> 16), then the following happens:
1865 *
1866 * - do_commit will write the cluster into the file at the given
1867 * offset, but
1868 *
1869 * - the cluster which is overwritten should be moved to a later
1870 * position in the file.
1871 *
1872 * I am not aware that any OS does something as braindead, but this
1873 * situation could happen anyway when not committing for a long time.
1874 * Just to be sure that this does not bite us, detect it, and copy the
1875 * contents of the clusters to-be-overwritten into the qcow.
1876 */
1877 int copy_it = 0;
1878 int was_modified = 0;
1879 int32_t ret = 0;
1880
1881 uint32_t cluster_num = begin_of_direntry(direntry);
1882 uint32_t offset = 0;
1883 mapping_t* mapping = NULL;
1884 const char* basename2 = NULL;
1885
1886 vvfat_close_current_file(s);
1887
1888 /* the root directory */
1889 if (cluster_num == 0)
1890 return 0;
1891
1892 /* write support */
1893 if (s->qcow) {
1894 basename2 = get_basename(path);
1895
1896 mapping = find_mapping_for_cluster(s, cluster_num);
1897
1898 if (mapping) {
1899 const char* basename;
1900
1901 assert(mapping->mode & MODE_DELETED);
1902 mapping->mode &= ~MODE_DELETED;
1903
1904 basename = get_basename(mapping->path);
1905
1906 assert(mapping->mode & MODE_NORMAL);
1907
1908 /* rename */
1909 if (strcmp(basename, basename2))
1910 schedule_rename(s, cluster_num, g_strdup(path));
1911 } else if (is_file(direntry))
1912 /* new file */
1913 schedule_new_file(s, g_strdup(path), cluster_num);
1914 else {
1915 abort();
1916 return 0;
1917 }
1918 }
1919
1920 while(1) {
1921 if (s->qcow) {
1922 if (!copy_it && cluster_was_modified(s, cluster_num)) {
1923 if (mapping == NULL ||
1924 mapping->begin > cluster_num ||
1925 mapping->end <= cluster_num)
1926 mapping = find_mapping_for_cluster(s, cluster_num);
1927
1928
1929 if (mapping &&
1930 (mapping->mode & MODE_DIRECTORY) == 0) {
1931
1932 /* was modified in qcow */
1933 if (offset != s->cluster_size
1934 * ((cluster_num - mapping->begin)
1935 + mapping->info.file.offset)) {
1936 /* offset of this cluster in file chain has changed */
1937 abort();
1938 copy_it = 1;
1939 } else if (offset == 0) {
1940 const char* basename = get_basename(mapping->path);
1941
1942 if (strcmp(basename, basename2))
1943 copy_it = 1;
1944 }
1945 assert(mapping->first_mapping_index == -1
1946 || mapping->info.file.offset > 0);
1947
1948 /* need to write out? */
1949 if (!was_modified && is_file(direntry)) {
1950 was_modified = 1;
1951 schedule_writeout(s, mapping->dir_index, offset);
1952 }
1953 }
1954 }
1955
1956 if (copy_it) {
1957 int i;
1958 /*
1959 * This is horribly inefficient, but that is okay, since
1960 * it is rarely executed, if at all.
1961 */
1962 int64_t offs = cluster2sector(s, cluster_num);
1963
1964 vvfat_close_current_file(s);
1965 for (i = 0; i < s->sectors_per_cluster; i++) {
1966 int res;
1967
1968 res = bdrv_co_is_allocated(s->qcow->bs,
1969 (offs + i) * BDRV_SECTOR_SIZE,
1970 BDRV_SECTOR_SIZE, NULL);
1971 if (res < 0) {
1972 return -1;
1973 }
1974 if (!res) {
1975 res = vvfat_read(s->bs, offs, s->cluster_buffer, 1);
1976 if (res) {
1977 return -1;
1978 }
1979 res = bdrv_co_pwrite(s->qcow, offs * BDRV_SECTOR_SIZE,
1980 BDRV_SECTOR_SIZE, s->cluster_buffer,
1981 0);
1982 if (res < 0) {
1983 return -2;
1984 }
1985 }
1986 }
1987 }
1988 }
1989
1990 ret++;
1991 if (s->used_clusters[cluster_num] & USED_ANY)
1992 return 0;
1993 s->used_clusters[cluster_num] = USED_FILE;
1994
1995 cluster_num = modified_fat_get(s, cluster_num);
1996
1997 if (fat_eof(s, cluster_num))
1998 return ret;
1999 else if (cluster_num < 2 || cluster_num > s->max_fat_value - 16)
2000 return -1;
2001
2002 offset += s->cluster_size;
2003 }
2004 }
2005
2006 /*
2007 * This function looks at the modified data (qcow).
2008 * It returns 0 upon inconsistency or error, and the number of clusters
2009 * used by the directory, its subdirectories and their files.
2010 */
2011 static int coroutine_fn GRAPH_RDLOCK
check_directory_consistency(BDRVVVFATState * s,int cluster_num,const char * path)2012 check_directory_consistency(BDRVVVFATState *s, int cluster_num, const char* path)
2013 {
2014 int ret = 0;
2015 unsigned char* cluster = g_malloc(s->cluster_size);
2016 direntry_t* direntries = (direntry_t*)cluster;
2017 mapping_t* mapping = find_mapping_for_cluster(s, cluster_num);
2018
2019 long_file_name lfn;
2020 int path_len = strlen(path);
2021 char path2[PATH_MAX + 1];
2022
2023 assert(path_len < PATH_MAX); /* len was tested before! */
2024 pstrcpy(path2, sizeof(path2), path);
2025 path2[path_len] = '/';
2026 path2[path_len + 1] = '\0';
2027
2028 if (mapping) {
2029 const char* basename = get_basename(mapping->path);
2030 const char* basename2 = get_basename(path);
2031
2032 assert(mapping->mode & MODE_DIRECTORY);
2033
2034 assert(mapping->mode & MODE_DELETED);
2035 mapping->mode &= ~MODE_DELETED;
2036
2037 if (strcmp(basename, basename2))
2038 schedule_rename(s, cluster_num, g_strdup(path));
2039 } else
2040 /* new directory */
2041 schedule_mkdir(s, cluster_num, g_strdup(path));
2042
2043 lfn_init(&lfn);
2044 do {
2045 int i;
2046 int subret = 0;
2047
2048 ret++;
2049
2050 if (s->used_clusters[cluster_num] & USED_ANY) {
2051 fprintf(stderr, "cluster %d used more than once\n", (int)cluster_num);
2052 goto fail;
2053 }
2054 s->used_clusters[cluster_num] = USED_DIRECTORY;
2055
2056 DLOG(fprintf(stderr, "read cluster %d (sector %d)\n", (int)cluster_num, (int)cluster2sector(s, cluster_num)));
2057 subret = vvfat_read(s->bs, cluster2sector(s, cluster_num), cluster,
2058 s->sectors_per_cluster);
2059 if (subret) {
2060 fprintf(stderr, "Error fetching direntries\n");
2061 fail:
2062 g_free(cluster);
2063 return 0;
2064 }
2065
2066 for (i = 0; i < 0x10 * s->sectors_per_cluster; i++) {
2067 int cluster_count = 0;
2068
2069 DLOG(fprintf(stderr, "check direntry %d:\n", i); print_direntry(direntries + i));
2070 if (is_volume_label(direntries + i) || is_dot(direntries + i) ||
2071 is_free(direntries + i))
2072 continue;
2073
2074 subret = parse_long_name(&lfn, direntries + i);
2075 if (subret < 0) {
2076 fprintf(stderr, "Error in long name\n");
2077 goto fail;
2078 }
2079 if (subret == 0 || is_free(direntries + i))
2080 continue;
2081
2082 if (fat_chksum(direntries+i) != lfn.checksum) {
2083 subret = parse_short_name(s, &lfn, direntries + i);
2084 if (subret < 0) {
2085 fprintf(stderr, "Error in short name (%d)\n", subret);
2086 goto fail;
2087 }
2088 if (subret > 0 || !strcmp((char*)lfn.name, ".")
2089 || !strcmp((char*)lfn.name, ".."))
2090 continue;
2091 }
2092 lfn.checksum = 0x100; /* cannot use long name twice */
2093
2094 if (!valid_filename(lfn.name)) {
2095 fprintf(stderr, "Invalid file name\n");
2096 goto fail;
2097 }
2098 if (path_len + 1 + lfn.len >= PATH_MAX) {
2099 fprintf(stderr, "Name too long: %s/%s\n", path, lfn.name);
2100 goto fail;
2101 }
2102 pstrcpy(path2 + path_len + 1, sizeof(path2) - path_len - 1,
2103 (char*)lfn.name);
2104
2105 if (is_directory(direntries + i)) {
2106 if (begin_of_direntry(direntries + i) == 0) {
2107 DLOG(fprintf(stderr, "invalid begin for directory: %s\n", path2); print_direntry(direntries + i));
2108 goto fail;
2109 }
2110 cluster_count = check_directory_consistency(s,
2111 begin_of_direntry(direntries + i), path2);
2112 if (cluster_count == 0) {
2113 DLOG(fprintf(stderr, "problem in directory %s:\n", path2); print_direntry(direntries + i));
2114 goto fail;
2115 }
2116 } else if (is_file(direntries + i)) {
2117 /* check file size with FAT */
2118 cluster_count = get_cluster_count_for_direntry(s, direntries + i, path2);
2119 if (cluster_count !=
2120 DIV_ROUND_UP(le32_to_cpu(direntries[i].size), s->cluster_size)) {
2121 DLOG(fprintf(stderr, "Cluster count mismatch\n"));
2122 goto fail;
2123 }
2124 } else
2125 abort(); /* cluster_count = 0; */
2126
2127 ret += cluster_count;
2128 }
2129
2130 cluster_num = modified_fat_get(s, cluster_num);
2131 } while(!fat_eof(s, cluster_num));
2132
2133 g_free(cluster);
2134 return ret;
2135 }
2136
2137 /* returns 1 on success */
2138 static int coroutine_fn GRAPH_RDLOCK
is_consistent(BDRVVVFATState * s)2139 is_consistent(BDRVVVFATState* s)
2140 {
2141 int i, check;
2142 int used_clusters_count = 0;
2143
2144 DLOG(checkpoint());
2145 /*
2146 * - get modified FAT
2147 * - compare the two FATs (TODO)
2148 * - get buffer for marking used clusters
2149 * - recurse direntries from root (using bs->bdrv_pread to make
2150 * sure to get the new data)
2151 * - check that the FAT agrees with the size
2152 * - count the number of clusters occupied by this directory and
2153 * its files
2154 * - check that the cumulative used cluster count agrees with the
2155 * FAT
2156 * - if all is fine, return number of used clusters
2157 */
2158 if (s->fat2 == NULL) {
2159 int size = 0x200 * s->sectors_per_fat;
2160 s->fat2 = g_malloc(size);
2161 memcpy(s->fat2, s->fat.pointer, size);
2162 }
2163 check = vvfat_read(s->bs,
2164 s->offset_to_fat, s->fat2, s->sectors_per_fat);
2165 if (check) {
2166 fprintf(stderr, "Could not copy fat\n");
2167 return 0;
2168 }
2169 assert (s->used_clusters);
2170 for (i = 0; i < sector2cluster(s, s->sector_count); i++)
2171 s->used_clusters[i] &= ~USED_ANY;
2172
2173 clear_commits(s);
2174
2175 /* mark every mapped file/directory as deleted.
2176 * (check_directory_consistency() will unmark those still present). */
2177 if (s->qcow)
2178 for (i = 0; i < s->mapping.next; i++) {
2179 mapping_t* mapping = array_get(&(s->mapping), i);
2180 if (mapping->first_mapping_index < 0)
2181 mapping->mode |= MODE_DELETED;
2182 }
2183
2184 used_clusters_count = check_directory_consistency(s, 0, s->path);
2185 if (used_clusters_count <= 0) {
2186 DLOG(fprintf(stderr, "problem in directory\n"));
2187 return 0;
2188 }
2189
2190 check = s->last_cluster_of_root_directory;
2191 for (i = check; i < sector2cluster(s, s->sector_count); i++) {
2192 if (modified_fat_get(s, i)) {
2193 if(!s->used_clusters[i]) {
2194 DLOG(fprintf(stderr, "FAT was modified (%d), but cluster is not used?\n", i));
2195 return 0;
2196 }
2197 check++;
2198 }
2199
2200 if (s->used_clusters[i] == USED_ALLOCATED) {
2201 /* allocated, but not used... */
2202 DLOG(fprintf(stderr, "unused, modified cluster: %d\n", i));
2203 return 0;
2204 }
2205 }
2206
2207 if (check != used_clusters_count)
2208 return 0;
2209
2210 return used_clusters_count;
2211 }
2212
adjust_mapping_indices(BDRVVVFATState * s,int offset,int adjust)2213 static inline void adjust_mapping_indices(BDRVVVFATState* s,
2214 int offset, int adjust)
2215 {
2216 int i;
2217
2218 for (i = 0; i < s->mapping.next; i++) {
2219 mapping_t* mapping = array_get(&(s->mapping), i);
2220
2221 #define ADJUST_MAPPING_INDEX(name) \
2222 if (mapping->name >= offset) \
2223 mapping->name += adjust
2224
2225 ADJUST_MAPPING_INDEX(first_mapping_index);
2226 if (mapping->mode & MODE_DIRECTORY)
2227 ADJUST_MAPPING_INDEX(info.dir.parent_mapping_index);
2228 }
2229 }
2230
2231 /* insert or update mapping */
insert_mapping(BDRVVVFATState * s,uint32_t begin,uint32_t end)2232 static mapping_t* insert_mapping(BDRVVVFATState* s,
2233 uint32_t begin, uint32_t end)
2234 {
2235 /*
2236 * - find mapping where mapping->begin >= begin,
2237 * - if mapping->begin > begin: insert
2238 * - adjust all references to mappings!
2239 * - else: adjust
2240 * - replace name
2241 */
2242 int index = find_mapping_for_cluster_aux(s, begin, 0, s->mapping.next);
2243 mapping_t* mapping = NULL;
2244 mapping_t* first_mapping = array_get(&(s->mapping), 0);
2245
2246 if (index < s->mapping.next && (mapping = array_get(&(s->mapping), index))
2247 && mapping->begin < begin) {
2248 mapping->end = begin;
2249 index++;
2250 mapping = array_get(&(s->mapping), index);
2251 }
2252 if (index >= s->mapping.next || mapping->begin > begin) {
2253 mapping = array_insert(&(s->mapping), index, 1);
2254 mapping->path = NULL;
2255 adjust_mapping_indices(s, index, +1);
2256 }
2257
2258 mapping->begin = begin;
2259 mapping->end = end;
2260
2261 DLOG(mapping_t* next_mapping;
2262 assert(index + 1 >= s->mapping.next ||
2263 ((next_mapping = array_get(&(s->mapping), index + 1)) &&
2264 next_mapping->begin >= end)));
2265
2266 if (s->current_mapping && first_mapping != (mapping_t*)s->mapping.pointer)
2267 s->current_mapping = array_get(&(s->mapping),
2268 s->current_mapping - first_mapping);
2269
2270 return mapping;
2271 }
2272
remove_mapping(BDRVVVFATState * s,int mapping_index)2273 static int remove_mapping(BDRVVVFATState* s, int mapping_index)
2274 {
2275 mapping_t* mapping = array_get(&(s->mapping), mapping_index);
2276 mapping_t* first_mapping = array_get(&(s->mapping), 0);
2277
2278 /* free mapping */
2279 if (mapping->first_mapping_index < 0) {
2280 g_free(mapping->path);
2281 }
2282
2283 /* remove from s->mapping */
2284 array_remove(&(s->mapping), mapping_index);
2285
2286 /* adjust all references to mappings */
2287 adjust_mapping_indices(s, mapping_index, -1);
2288
2289 if (s->current_mapping && first_mapping != (mapping_t*)s->mapping.pointer)
2290 s->current_mapping = array_get(&(s->mapping),
2291 s->current_mapping - first_mapping);
2292
2293 return 0;
2294 }
2295
adjust_dirindices(BDRVVVFATState * s,int offset,int adjust)2296 static void adjust_dirindices(BDRVVVFATState* s, int offset, int adjust)
2297 {
2298 int i;
2299 for (i = 0; i < s->mapping.next; i++) {
2300 mapping_t* mapping = array_get(&(s->mapping), i);
2301 if (mapping->dir_index >= offset)
2302 mapping->dir_index += adjust;
2303 if ((mapping->mode & MODE_DIRECTORY) &&
2304 mapping->info.dir.first_dir_index >= offset)
2305 mapping->info.dir.first_dir_index += adjust;
2306 }
2307 }
2308
insert_direntries(BDRVVVFATState * s,int dir_index,int count)2309 static direntry_t* insert_direntries(BDRVVVFATState* s,
2310 int dir_index, int count)
2311 {
2312 /*
2313 * make room in s->directory,
2314 * adjust_dirindices
2315 */
2316 direntry_t* result = array_insert(&(s->directory), dir_index, count);
2317 if (result == NULL)
2318 return NULL;
2319 adjust_dirindices(s, dir_index, count);
2320 return result;
2321 }
2322
remove_direntries(BDRVVVFATState * s,int dir_index,int count)2323 static int remove_direntries(BDRVVVFATState* s, int dir_index, int count)
2324 {
2325 int ret = array_remove_slice(&(s->directory), dir_index, count);
2326 if (ret)
2327 return ret;
2328 adjust_dirindices(s, dir_index, -count);
2329 return 0;
2330 }
2331
2332 /*
2333 * Adapt the mappings of the cluster chain starting at first cluster
2334 * (i.e. if a file starts at first_cluster, the chain is followed according
2335 * to the modified fat, and the corresponding entries in s->mapping are
2336 * adjusted)
2337 */
commit_mappings(BDRVVVFATState * s,uint32_t first_cluster,int dir_index)2338 static int commit_mappings(BDRVVVFATState* s,
2339 uint32_t first_cluster, int dir_index)
2340 {
2341 mapping_t* mapping = find_mapping_for_cluster(s, first_cluster);
2342 direntry_t* direntry = array_get(&(s->directory), dir_index);
2343 uint32_t cluster = first_cluster;
2344
2345 vvfat_close_current_file(s);
2346
2347 assert(mapping);
2348 assert(mapping->begin == first_cluster);
2349 mapping->first_mapping_index = -1;
2350 mapping->dir_index = dir_index;
2351 mapping->mode = (dir_index <= 0 || is_directory(direntry)) ?
2352 MODE_DIRECTORY : MODE_NORMAL;
2353
2354 while (!fat_eof(s, cluster)) {
2355 uint32_t c, c1;
2356
2357 for (c = cluster, c1 = modified_fat_get(s, c); c + 1 == c1;
2358 c = c1, c1 = modified_fat_get(s, c1));
2359
2360 c++;
2361 if (c > mapping->end) {
2362 int index = array_index(&(s->mapping), mapping);
2363 int i, max_i = s->mapping.next - index;
2364 for (i = 1; i < max_i && mapping[i].begin < c; i++);
2365 while (--i > 0)
2366 remove_mapping(s, index + 1);
2367 }
2368 assert(mapping == array_get(&(s->mapping), s->mapping.next - 1)
2369 || mapping[1].begin >= c);
2370 mapping->end = c;
2371
2372 if (!fat_eof(s, c1)) {
2373 int i = find_mapping_for_cluster_aux(s, c1, 0, s->mapping.next);
2374 mapping_t* next_mapping = i >= s->mapping.next ? NULL :
2375 array_get(&(s->mapping), i);
2376
2377 if (next_mapping == NULL || next_mapping->begin > c1) {
2378 int i1 = array_index(&(s->mapping), mapping);
2379
2380 next_mapping = insert_mapping(s, c1, c1+1);
2381
2382 if (c1 < c)
2383 i1++;
2384 mapping = array_get(&(s->mapping), i1);
2385 }
2386
2387 next_mapping->dir_index = mapping->dir_index;
2388 next_mapping->first_mapping_index =
2389 mapping->first_mapping_index < 0 ?
2390 array_index(&(s->mapping), mapping) :
2391 mapping->first_mapping_index;
2392 next_mapping->path = mapping->path;
2393 next_mapping->mode = mapping->mode;
2394 next_mapping->read_only = mapping->read_only;
2395 if (mapping->mode & MODE_DIRECTORY) {
2396 next_mapping->info.dir.parent_mapping_index =
2397 mapping->info.dir.parent_mapping_index;
2398 next_mapping->info.dir.first_dir_index =
2399 mapping->info.dir.first_dir_index +
2400 0x10 * s->sectors_per_cluster *
2401 (mapping->end - mapping->begin);
2402 } else
2403 next_mapping->info.file.offset = mapping->info.file.offset +
2404 (mapping->end - mapping->begin);
2405
2406 mapping = next_mapping;
2407 }
2408
2409 cluster = c1;
2410 }
2411
2412 return 0;
2413 }
2414
2415 static int coroutine_fn GRAPH_RDLOCK
commit_direntries(BDRVVVFATState * s,int dir_index,int parent_mapping_index)2416 commit_direntries(BDRVVVFATState* s, int dir_index, int parent_mapping_index)
2417 {
2418 direntry_t* direntry = array_get(&(s->directory), dir_index);
2419 uint32_t first_cluster = dir_index == 0 ? 0 : begin_of_direntry(direntry);
2420 mapping_t* mapping = find_mapping_for_cluster(s, first_cluster);
2421 int factor = 0x10 * s->sectors_per_cluster;
2422 int old_cluster_count, new_cluster_count;
2423 int current_dir_index;
2424 int first_dir_index;
2425 int ret, i;
2426 uint32_t c;
2427
2428 assert(direntry);
2429 assert(mapping);
2430 assert(mapping->begin == first_cluster);
2431 assert(mapping->info.dir.first_dir_index < s->directory.next);
2432 assert(mapping->mode & MODE_DIRECTORY);
2433 assert(dir_index == 0 || is_directory(direntry));
2434
2435 DLOG(fprintf(stderr, "commit_direntries for %s, parent_mapping_index %d\n",
2436 mapping->path, parent_mapping_index));
2437
2438 current_dir_index = mapping->info.dir.first_dir_index;
2439 first_dir_index = current_dir_index;
2440 mapping->info.dir.parent_mapping_index = parent_mapping_index;
2441
2442 if (first_cluster == 0) {
2443 old_cluster_count = new_cluster_count =
2444 s->last_cluster_of_root_directory;
2445 } else {
2446 for (old_cluster_count = 0, c = first_cluster; !fat_eof(s, c);
2447 c = fat_get(s, c))
2448 old_cluster_count++;
2449
2450 for (new_cluster_count = 0, c = first_cluster; !fat_eof(s, c);
2451 c = modified_fat_get(s, c))
2452 new_cluster_count++;
2453 }
2454
2455 if (new_cluster_count > old_cluster_count) {
2456 if (insert_direntries(s,
2457 current_dir_index + factor * old_cluster_count,
2458 factor * (new_cluster_count - old_cluster_count)) == NULL)
2459 return -1;
2460 } else if (new_cluster_count < old_cluster_count)
2461 remove_direntries(s,
2462 current_dir_index + factor * new_cluster_count,
2463 factor * (old_cluster_count - new_cluster_count));
2464
2465 for (c = first_cluster; !fat_eof(s, c); c = modified_fat_get(s, c)) {
2466 direntry_t *first_direntry;
2467
2468 direntry = array_get(&(s->directory), current_dir_index);
2469 ret = vvfat_read(s->bs, cluster2sector(s, c), (uint8_t *)direntry,
2470 s->sectors_per_cluster);
2471 if (ret)
2472 return ret;
2473
2474 /* The first directory entry on the filesystem is the volume name */
2475 first_direntry = (direntry_t*) s->directory.pointer;
2476 assert(!memcmp(first_direntry->name, s->volume_label, 11));
2477
2478 current_dir_index += factor;
2479 }
2480
2481 ret = commit_mappings(s, first_cluster, dir_index);
2482 if (ret)
2483 return ret;
2484
2485 /* recurse */
2486 for (i = 0; i < factor * new_cluster_count; i++) {
2487 direntry = array_get(&(s->directory), first_dir_index + i);
2488 if (is_directory(direntry) && !is_dot(direntry)) {
2489 mapping = find_mapping_for_cluster(s, first_cluster);
2490 if (mapping == NULL) {
2491 return -1;
2492 }
2493 assert(mapping->mode & MODE_DIRECTORY);
2494 ret = commit_direntries(s, first_dir_index + i,
2495 array_index(&(s->mapping), mapping));
2496 if (ret)
2497 return ret;
2498 }
2499 }
2500
2501 return 0;
2502 }
2503
2504 /* commit one file (adjust contents, adjust mapping),
2505 return first_mapping_index */
2506 static int coroutine_fn GRAPH_RDLOCK
commit_one_file(BDRVVVFATState * s,int dir_index,uint32_t offset)2507 commit_one_file(BDRVVVFATState* s, int dir_index, uint32_t offset)
2508 {
2509 direntry_t* direntry = array_get(&(s->directory), dir_index);
2510 uint32_t c = begin_of_direntry(direntry);
2511 uint32_t first_cluster = c;
2512 mapping_t* mapping = find_mapping_for_cluster(s, c);
2513 uint32_t size = filesize_of_direntry(direntry);
2514 char *cluster;
2515 uint32_t i;
2516 int fd = 0;
2517
2518 assert(offset < size);
2519 assert((offset % s->cluster_size) == 0);
2520
2521 if (mapping == NULL) {
2522 return -1;
2523 }
2524
2525 for (i = 0; i < offset; i += s->cluster_size) {
2526 c = modified_fat_get(s, c);
2527 }
2528
2529 fd = qemu_open_old(mapping->path, O_RDWR | O_CREAT | O_BINARY, 0666);
2530 if (fd < 0) {
2531 fprintf(stderr, "Could not open %s... (%s, %d)\n", mapping->path,
2532 strerror(errno), errno);
2533 return fd;
2534 }
2535 if (offset > 0) {
2536 if (lseek(fd, offset, SEEK_SET) != offset) {
2537 qemu_close(fd);
2538 return -3;
2539 }
2540 }
2541
2542 cluster = g_malloc(s->cluster_size);
2543
2544 while (offset < size) {
2545 uint32_t c1;
2546 int rest_size = (size - offset > s->cluster_size ?
2547 s->cluster_size : size - offset);
2548 int ret;
2549
2550 c1 = modified_fat_get(s, c);
2551
2552 assert((size - offset == 0 && fat_eof(s, c)) ||
2553 (size > offset && c >=2 && !fat_eof(s, c)));
2554
2555 ret = vvfat_read(s->bs, cluster2sector(s, c),
2556 (uint8_t*)cluster, DIV_ROUND_UP(rest_size, 0x200));
2557
2558 if (ret < 0) {
2559 qemu_close(fd);
2560 g_free(cluster);
2561 return ret;
2562 }
2563
2564 if (write(fd, cluster, rest_size) < 0) {
2565 qemu_close(fd);
2566 g_free(cluster);
2567 return -2;
2568 }
2569
2570 offset += rest_size;
2571 c = c1;
2572 }
2573
2574 if (ftruncate(fd, size)) {
2575 perror("ftruncate()");
2576 qemu_close(fd);
2577 g_free(cluster);
2578 return -4;
2579 }
2580 qemu_close(fd);
2581 g_free(cluster);
2582
2583 return commit_mappings(s, first_cluster, dir_index);
2584 }
2585
2586 #ifdef DEBUG
2587 /* test, if all mappings point to valid direntries */
check1(BDRVVVFATState * s)2588 static void check1(BDRVVVFATState* s)
2589 {
2590 int i;
2591 for (i = 0; i < s->mapping.next; i++) {
2592 mapping_t* mapping = array_get(&(s->mapping), i);
2593 if (mapping->mode & MODE_DELETED) {
2594 fprintf(stderr, "deleted\n");
2595 continue;
2596 }
2597 assert(mapping->dir_index < s->directory.next);
2598 direntry_t* direntry = array_get(&(s->directory), mapping->dir_index);
2599 assert(mapping->begin == begin_of_direntry(direntry) || mapping->first_mapping_index >= 0);
2600 if (mapping->mode & MODE_DIRECTORY) {
2601 assert(mapping->info.dir.first_dir_index + 0x10 * s->sectors_per_cluster * (mapping->end - mapping->begin) <= s->directory.next);
2602 assert((mapping->info.dir.first_dir_index % (0x10 * s->sectors_per_cluster)) == 0);
2603 }
2604 }
2605 }
2606
2607 /* test, if all direntries have mappings */
check2(BDRVVVFATState * s)2608 static void check2(BDRVVVFATState* s)
2609 {
2610 int i;
2611 int first_mapping = -1;
2612
2613 for (i = 0; i < s->directory.next; i++) {
2614 direntry_t* direntry = array_get(&(s->directory), i);
2615
2616 if (is_short_name(direntry) && begin_of_direntry(direntry)) {
2617 mapping_t* mapping = find_mapping_for_cluster(s, begin_of_direntry(direntry));
2618 assert(mapping);
2619 assert(mapping->dir_index == i || is_dot(direntry));
2620 assert(mapping->begin == begin_of_direntry(direntry) || is_dot(direntry));
2621 }
2622
2623 if ((i % (0x10 * s->sectors_per_cluster)) == 0) {
2624 /* cluster start */
2625 int j, count = 0;
2626
2627 for (j = 0; j < s->mapping.next; j++) {
2628 mapping_t* mapping = array_get(&(s->mapping), j);
2629 if (mapping->mode & MODE_DELETED)
2630 continue;
2631 if (mapping->mode & MODE_DIRECTORY) {
2632 if (mapping->info.dir.first_dir_index <= i && mapping->info.dir.first_dir_index + 0x10 * s->sectors_per_cluster > i) {
2633 assert(++count == 1);
2634 if (mapping->first_mapping_index == -1)
2635 first_mapping = array_index(&(s->mapping), mapping);
2636 else
2637 assert(first_mapping == mapping->first_mapping_index);
2638 if (mapping->info.dir.parent_mapping_index < 0)
2639 assert(j == 0);
2640 else {
2641 mapping_t* parent = array_get(&(s->mapping), mapping->info.dir.parent_mapping_index);
2642 assert(parent->mode & MODE_DIRECTORY);
2643 assert(parent->info.dir.first_dir_index < mapping->info.dir.first_dir_index);
2644 }
2645 }
2646 }
2647 }
2648 if (count == 0)
2649 first_mapping = -1;
2650 }
2651 }
2652 }
2653 #endif
2654
handle_renames_and_mkdirs(BDRVVVFATState * s)2655 static int handle_renames_and_mkdirs(BDRVVVFATState* s)
2656 {
2657 int i;
2658
2659 #ifdef DEBUG
2660 fprintf(stderr, "handle_renames\n");
2661 for (i = 0; i < s->commits.next; i++) {
2662 commit_t* commit = array_get(&(s->commits), i);
2663 fprintf(stderr, "%d, %s (%u, %d)\n", i,
2664 commit->path ? commit->path : "(null)",
2665 commit->param.rename.cluster, commit->action);
2666 }
2667 #endif
2668
2669 for (i = 0; i < s->commits.next;) {
2670 commit_t* commit = array_get(&(s->commits), i);
2671 if (commit->action == ACTION_RENAME) {
2672 mapping_t* mapping = find_mapping_for_cluster(s,
2673 commit->param.rename.cluster);
2674 char *old_path;
2675
2676 if (mapping == NULL) {
2677 return -1;
2678 }
2679 old_path = mapping->path;
2680 assert(commit->path);
2681 mapping->path = commit->path;
2682 if (rename(old_path, mapping->path))
2683 return -2;
2684
2685 if (mapping->mode & MODE_DIRECTORY) {
2686 int l1 = strlen(mapping->path);
2687 int l2 = strlen(old_path);
2688 int diff = l1 - l2;
2689 direntry_t* direntry = array_get(&(s->directory),
2690 mapping->info.dir.first_dir_index);
2691 uint32_t c = mapping->begin;
2692 int j = 0;
2693
2694 /* recurse */
2695 while (!fat_eof(s, c)) {
2696 do {
2697 direntry_t *d = direntry + j;
2698
2699 if (is_file(d) || (is_directory(d) && !is_dot(d))) {
2700 int l;
2701 char *new_path;
2702 mapping_t* m = find_mapping_for_cluster(s,
2703 begin_of_direntry(d));
2704 if (m == NULL) {
2705 return -1;
2706 }
2707 l = strlen(m->path);
2708 new_path = g_malloc(l + diff + 1);
2709
2710 assert(!strncmp(m->path, mapping->path, l2));
2711
2712 pstrcpy(new_path, l + diff + 1, mapping->path);
2713 pstrcpy(new_path + l1, l + diff + 1 - l1,
2714 m->path + l2);
2715
2716 schedule_rename(s, m->begin, new_path);
2717 }
2718 j++;
2719 } while (j % (0x10 * s->sectors_per_cluster) != 0);
2720 c = fat_get(s, c);
2721 }
2722 }
2723
2724 g_free(old_path);
2725 array_remove(&(s->commits), i);
2726 continue;
2727 } else if (commit->action == ACTION_MKDIR) {
2728 mapping_t* mapping;
2729 int j, parent_path_len;
2730
2731 if (g_mkdir(commit->path, 0755)) {
2732 return -5;
2733 }
2734
2735 mapping = insert_mapping(s, commit->param.mkdir.cluster,
2736 commit->param.mkdir.cluster + 1);
2737 if (mapping == NULL)
2738 return -6;
2739
2740 mapping->mode = MODE_DIRECTORY;
2741 mapping->read_only = 0;
2742 mapping->path = commit->path;
2743 j = s->directory.next;
2744 assert(j);
2745 insert_direntries(s, s->directory.next,
2746 0x10 * s->sectors_per_cluster);
2747 mapping->info.dir.first_dir_index = j;
2748
2749 parent_path_len = strlen(commit->path)
2750 - strlen(get_basename(commit->path)) - 1;
2751 for (j = 0; j < s->mapping.next; j++) {
2752 mapping_t* m = array_get(&(s->mapping), j);
2753 if (m->first_mapping_index < 0 && m != mapping &&
2754 !strncmp(m->path, mapping->path, parent_path_len) &&
2755 strlen(m->path) == parent_path_len)
2756 break;
2757 }
2758 assert(j < s->mapping.next);
2759 mapping->info.dir.parent_mapping_index = j;
2760
2761 array_remove(&(s->commits), i);
2762 continue;
2763 }
2764
2765 i++;
2766 }
2767 return 0;
2768 }
2769
2770 /*
2771 * TODO: make sure that the short name is not matching *another* file
2772 */
handle_commits(BDRVVVFATState * s)2773 static int coroutine_fn GRAPH_RDLOCK handle_commits(BDRVVVFATState* s)
2774 {
2775 int i, fail = 0;
2776
2777 vvfat_close_current_file(s);
2778
2779 for (i = 0; !fail && i < s->commits.next; i++) {
2780 commit_t* commit = array_get(&(s->commits), i);
2781 switch(commit->action) {
2782 case ACTION_RENAME: case ACTION_MKDIR:
2783 abort();
2784 fail = -2;
2785 break;
2786 case ACTION_WRITEOUT: {
2787 direntry_t* entry = array_get(&(s->directory),
2788 commit->param.writeout.dir_index);
2789 uint32_t begin = begin_of_direntry(entry);
2790 mapping_t* mapping = find_mapping_for_cluster(s, begin);
2791
2792 assert(mapping);
2793 assert(mapping->begin == begin);
2794 assert(commit->path == NULL);
2795
2796 if (commit_one_file(s, commit->param.writeout.dir_index,
2797 commit->param.writeout.modified_offset))
2798 fail = -3;
2799
2800 break;
2801 }
2802 case ACTION_NEW_FILE: {
2803 int begin = commit->param.new_file.first_cluster;
2804 mapping_t* mapping = find_mapping_for_cluster(s, begin);
2805 direntry_t* entry;
2806 int j;
2807
2808 /* find direntry */
2809 for (j = 0; j < s->directory.next; j++) {
2810 entry = array_get(&(s->directory), j);
2811 if (is_file(entry) && begin_of_direntry(entry) == begin)
2812 break;
2813 }
2814
2815 if (j >= s->directory.next) {
2816 fail = -6;
2817 continue;
2818 }
2819
2820 /* make sure there exists an initial mapping */
2821 if (mapping && mapping->begin != begin) {
2822 mapping->end = begin;
2823 mapping = NULL;
2824 }
2825 if (mapping == NULL) {
2826 mapping = insert_mapping(s, begin, begin+1);
2827 }
2828 /* most members will be fixed in commit_mappings() */
2829 assert(commit->path);
2830 mapping->path = commit->path;
2831 mapping->read_only = 0;
2832 mapping->mode = MODE_NORMAL;
2833 mapping->info.file.offset = 0;
2834
2835 if (commit_one_file(s, j, 0)) {
2836 fail = -7;
2837 }
2838
2839 break;
2840 }
2841 default:
2842 abort();
2843 }
2844 }
2845 if (i > 0 && array_remove_slice(&(s->commits), 0, i))
2846 return -1;
2847 return fail;
2848 }
2849
handle_deletes(BDRVVVFATState * s)2850 static int handle_deletes(BDRVVVFATState* s)
2851 {
2852 int i, deferred = 1, deleted = 1;
2853
2854 /* delete files corresponding to mappings marked as deleted */
2855 /* handle DELETEs and unused mappings (modified_fat_get(s, mapping->begin) == 0) */
2856 while (deferred && deleted) {
2857 deferred = 0;
2858 deleted = 0;
2859
2860 for (i = 1; i < s->mapping.next; i++) {
2861 mapping_t* mapping = array_get(&(s->mapping), i);
2862 if (mapping->mode & MODE_DELETED) {
2863 direntry_t* entry = array_get(&(s->directory),
2864 mapping->dir_index);
2865
2866 if (is_free(entry)) {
2867 /* remove file/directory */
2868 if (mapping->mode & MODE_DIRECTORY) {
2869 int j, next_dir_index = s->directory.next,
2870 first_dir_index = mapping->info.dir.first_dir_index;
2871
2872 if (rmdir(mapping->path) < 0) {
2873 if (errno == ENOTEMPTY) {
2874 deferred++;
2875 continue;
2876 } else
2877 return -5;
2878 }
2879
2880 for (j = 1; j < s->mapping.next; j++) {
2881 mapping_t* m = array_get(&(s->mapping), j);
2882 if (m->mode & MODE_DIRECTORY &&
2883 m->info.dir.first_dir_index >
2884 first_dir_index &&
2885 m->info.dir.first_dir_index <
2886 next_dir_index)
2887 next_dir_index =
2888 m->info.dir.first_dir_index;
2889 }
2890 remove_direntries(s, first_dir_index,
2891 next_dir_index - first_dir_index);
2892
2893 deleted++;
2894 }
2895 } else {
2896 if (unlink(mapping->path))
2897 return -4;
2898 deleted++;
2899 }
2900 DLOG(fprintf(stderr, "DELETE (%d)\n", i); print_mapping(mapping); print_direntry(entry));
2901 remove_mapping(s, i);
2902 }
2903 }
2904 }
2905
2906 return 0;
2907 }
2908
2909 /*
2910 * synchronize mapping with new state:
2911 *
2912 * - copy FAT (with bdrv_pread)
2913 * - mark all filenames corresponding to mappings as deleted
2914 * - recurse direntries from root (using bs->bdrv_pread)
2915 * - delete files corresponding to mappings marked as deleted
2916 */
do_commit(BDRVVVFATState * s)2917 static int coroutine_fn GRAPH_RDLOCK do_commit(BDRVVVFATState* s)
2918 {
2919 int ret = 0;
2920
2921 /* the real meat are the commits. Nothing to do? Move along! */
2922 if (s->commits.next == 0)
2923 return 0;
2924
2925 vvfat_close_current_file(s);
2926
2927 ret = handle_renames_and_mkdirs(s);
2928 if (ret) {
2929 fprintf(stderr, "Error handling renames (%d)\n", ret);
2930 abort();
2931 return ret;
2932 }
2933
2934 /* copy FAT (with bdrv_pread) */
2935 memcpy(s->fat.pointer, s->fat2, 0x200 * s->sectors_per_fat);
2936
2937 /* recurse direntries from root (using bs->bdrv_pread) */
2938 ret = commit_direntries(s, 0, -1);
2939 if (ret) {
2940 fprintf(stderr, "Fatal: error while committing (%d)\n", ret);
2941 abort();
2942 return ret;
2943 }
2944
2945 ret = handle_commits(s);
2946 if (ret) {
2947 fprintf(stderr, "Error handling commits (%d)\n", ret);
2948 abort();
2949 return ret;
2950 }
2951
2952 ret = handle_deletes(s);
2953 if (ret) {
2954 fprintf(stderr, "Error deleting\n");
2955 abort();
2956 return ret;
2957 }
2958
2959 bdrv_make_empty(s->qcow, NULL);
2960
2961 memset(s->used_clusters, 0, sector2cluster(s, s->sector_count));
2962
2963 DLOG(checkpoint());
2964 return 0;
2965 }
2966
try_commit(BDRVVVFATState * s)2967 static int coroutine_fn GRAPH_RDLOCK try_commit(BDRVVVFATState* s)
2968 {
2969 vvfat_close_current_file(s);
2970 DLOG(checkpoint());
2971 if(!is_consistent(s))
2972 return -1;
2973 return do_commit(s);
2974 }
2975
2976 static int coroutine_fn GRAPH_RDLOCK
vvfat_write(BlockDriverState * bs,int64_t sector_num,const uint8_t * buf,int nb_sectors)2977 vvfat_write(BlockDriverState *bs, int64_t sector_num,
2978 const uint8_t *buf, int nb_sectors)
2979 {
2980 BDRVVVFATState *s = bs->opaque;
2981 int i, ret;
2982 int first_cluster, last_cluster;
2983
2984 DLOG(checkpoint());
2985
2986 /* Check if we're operating in read-only mode */
2987 if (s->qcow == NULL) {
2988 return -EACCES;
2989 }
2990
2991 vvfat_close_current_file(s);
2992
2993 if (sector_num == s->offset_to_bootsector && nb_sectors == 1) {
2994 /*
2995 * Write on bootsector. Allow only changing the reserved1 field,
2996 * used to mark volume dirtiness
2997 */
2998 unsigned char *bootsector = s->first_sectors
2999 + s->offset_to_bootsector * 0x200;
3000 /*
3001 * LATER TODO: if FAT32, this is wrong (see init_directories(),
3002 * which always creates a FAT16 bootsector)
3003 */
3004 const int reserved1_offset = offsetof(bootsector_t, u.fat16.reserved1);
3005
3006 for (i = 0; i < 0x200; i++) {
3007 if (i != reserved1_offset && bootsector[i] != buf[i]) {
3008 fprintf(stderr, "Tried to write to protected bootsector\n");
3009 return -1;
3010 }
3011 }
3012
3013 /* Update bootsector with the only updatable byte, and return success */
3014 bootsector[reserved1_offset] = buf[reserved1_offset];
3015 return 0;
3016 }
3017
3018 /*
3019 * Some sanity checks:
3020 * - do not allow writing to the boot sector
3021 */
3022 if (sector_num < s->offset_to_fat)
3023 return -1;
3024
3025 /*
3026 * Values will be negative for writes to the FAT, which is located before
3027 * the root directory.
3028 */
3029 first_cluster = sector2cluster(s, sector_num);
3030 last_cluster = sector2cluster(s, sector_num + nb_sectors - 1);
3031
3032 for (i = first_cluster; i <= last_cluster;) {
3033 mapping_t *mapping = NULL;
3034
3035 if (i >= 0) {
3036 mapping = find_mapping_for_cluster(s, i);
3037 }
3038
3039 if (mapping) {
3040 if (mapping->read_only) {
3041 fprintf(stderr, "Tried to write to write-protected file %s\n",
3042 mapping->path);
3043 return -1;
3044 }
3045
3046 if (mapping->mode & MODE_DIRECTORY) {
3047 int begin = cluster2sector(s, i);
3048 int end = begin + s->sectors_per_cluster, k;
3049 int dir_index;
3050 const direntry_t* direntries;
3051 long_file_name lfn;
3052
3053 lfn_init(&lfn);
3054
3055 if (begin < sector_num)
3056 begin = sector_num;
3057 if (end > sector_num + nb_sectors)
3058 end = sector_num + nb_sectors;
3059 dir_index = mapping->dir_index +
3060 0x10 * (begin - mapping->begin * s->sectors_per_cluster);
3061 direntries = (direntry_t*)(buf + 0x200 * (begin - sector_num));
3062
3063 for (k = 0; k < (end - begin) * 0x10; k++) {
3064 /* no access to the direntry of a read-only file */
3065 if (is_short_name(direntries + k) &&
3066 (direntries[k].attributes & 1)) {
3067 if (memcmp(direntries + k,
3068 array_get(&(s->directory), dir_index + k),
3069 sizeof(direntry_t))) {
3070 warn_report("tried to write to write-protected "
3071 "file");
3072 return -1;
3073 }
3074 }
3075 }
3076 }
3077 i = mapping->end;
3078 } else {
3079 i++;
3080 }
3081 }
3082
3083 /*
3084 * Use qcow backend. Commit later.
3085 */
3086 DLOG(fprintf(stderr, "Write to qcow backend: %d + %d\n", (int)sector_num, nb_sectors));
3087 ret = bdrv_co_pwrite(s->qcow, sector_num * BDRV_SECTOR_SIZE,
3088 nb_sectors * BDRV_SECTOR_SIZE, buf, 0);
3089 if (ret < 0) {
3090 fprintf(stderr, "Error writing to qcow backend\n");
3091 return ret;
3092 }
3093
3094 for (i = first_cluster; i <= last_cluster; i++) {
3095 if (i >= 0) {
3096 s->used_clusters[i] |= USED_ALLOCATED;
3097 }
3098 }
3099
3100 DLOG(checkpoint());
3101 /* TODO: add timeout */
3102 try_commit(s);
3103
3104 DLOG(checkpoint());
3105 return 0;
3106 }
3107
3108 static int coroutine_fn GRAPH_RDLOCK
vvfat_co_pwritev(BlockDriverState * bs,int64_t offset,int64_t bytes,QEMUIOVector * qiov,BdrvRequestFlags flags)3109 vvfat_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
3110 QEMUIOVector *qiov, BdrvRequestFlags flags)
3111 {
3112 int ret;
3113 BDRVVVFATState *s = bs->opaque;
3114 uint64_t sector_num = offset >> BDRV_SECTOR_BITS;
3115 int nb_sectors = bytes >> BDRV_SECTOR_BITS;
3116 void *buf;
3117
3118 assert(QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE));
3119 assert(QEMU_IS_ALIGNED(bytes, BDRV_SECTOR_SIZE));
3120
3121 buf = g_try_malloc(bytes);
3122 if (bytes && buf == NULL) {
3123 return -ENOMEM;
3124 }
3125 qemu_iovec_to_buf(qiov, 0, buf, bytes);
3126
3127 qemu_co_mutex_lock(&s->lock);
3128 ret = vvfat_write(bs, sector_num, buf, nb_sectors);
3129 qemu_co_mutex_unlock(&s->lock);
3130
3131 g_free(buf);
3132
3133 return ret;
3134 }
3135
vvfat_co_block_status(BlockDriverState * bs,unsigned int mode,int64_t offset,int64_t bytes,int64_t * n,int64_t * map,BlockDriverState ** file)3136 static int coroutine_fn vvfat_co_block_status(BlockDriverState *bs,
3137 unsigned int mode,
3138 int64_t offset, int64_t bytes,
3139 int64_t *n, int64_t *map,
3140 BlockDriverState **file)
3141 {
3142 *n = bytes;
3143 return BDRV_BLOCK_DATA;
3144 }
3145
vvfat_qcow_options(BdrvChildRole role,bool parent_is_format,int * child_flags,QDict * child_options,int parent_flags,QDict * parent_options)3146 static void vvfat_qcow_options(BdrvChildRole role, bool parent_is_format,
3147 int *child_flags, QDict *child_options,
3148 int parent_flags, QDict *parent_options)
3149 {
3150 qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "off");
3151 qdict_set_default_str(child_options, BDRV_OPT_AUTO_READ_ONLY, "off");
3152 qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");
3153 }
3154
3155 static BdrvChildClass child_vvfat_qcow;
3156
enable_write_target(BlockDriverState * bs,Error ** errp)3157 static int enable_write_target(BlockDriverState *bs, Error **errp)
3158 {
3159 BDRVVVFATState *s = bs->opaque;
3160 BlockDriver *bdrv_qcow = NULL;
3161 QemuOpts *opts = NULL;
3162 int ret;
3163 int size = sector2cluster(s, s->sector_count);
3164 QDict *options;
3165
3166 s->used_clusters = g_malloc0(size);
3167
3168 array_init(&(s->commits), sizeof(commit_t));
3169
3170 s->qcow_filename = create_tmp_file(errp);
3171 if (!s->qcow_filename) {
3172 ret = -ENOENT;
3173 goto err;
3174 }
3175
3176 bdrv_qcow = bdrv_find_format("qcow");
3177 if (!bdrv_qcow) {
3178 error_setg(errp, "Failed to locate qcow driver");
3179 ret = -ENOENT;
3180 goto err;
3181 }
3182
3183 opts = qemu_opts_create(bdrv_qcow->create_opts, NULL, 0, &error_abort);
3184 qemu_opt_set_number(opts, BLOCK_OPT_SIZE,
3185 bs->total_sectors * BDRV_SECTOR_SIZE, &error_abort);
3186 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, "fat:", &error_abort);
3187
3188 ret = bdrv_create(bdrv_qcow, s->qcow_filename, opts, errp);
3189 qemu_opts_del(opts);
3190 if (ret < 0) {
3191 goto err;
3192 }
3193
3194 options = qdict_new();
3195 qdict_put_str(options, "write-target.driver", "qcow");
3196 s->qcow = bdrv_open_child(s->qcow_filename, options, "write-target", bs,
3197 &child_vvfat_qcow,
3198 BDRV_CHILD_DATA | BDRV_CHILD_METADATA,
3199 false, errp);
3200 qobject_unref(options);
3201 if (!s->qcow) {
3202 ret = -EINVAL;
3203 goto err;
3204 }
3205
3206 #ifndef _WIN32
3207 unlink(s->qcow_filename);
3208 #endif
3209
3210 return 0;
3211
3212 err:
3213 return ret;
3214 }
3215
vvfat_child_perm(BlockDriverState * bs,BdrvChild * c,BdrvChildRole role,BlockReopenQueue * reopen_queue,uint64_t perm,uint64_t shared,uint64_t * nperm,uint64_t * nshared)3216 static void vvfat_child_perm(BlockDriverState *bs, BdrvChild *c,
3217 BdrvChildRole role,
3218 BlockReopenQueue *reopen_queue,
3219 uint64_t perm, uint64_t shared,
3220 uint64_t *nperm, uint64_t *nshared)
3221 {
3222 assert(role & BDRV_CHILD_DATA);
3223 /* This is a private node, nobody should try to attach to it */
3224 *nperm = BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE;
3225 *nshared = BLK_PERM_WRITE_UNCHANGED;
3226 }
3227
vvfat_close(BlockDriverState * bs)3228 static void vvfat_close(BlockDriverState *bs)
3229 {
3230 BDRVVVFATState *s = bs->opaque;
3231
3232 vvfat_close_current_file(s);
3233 array_free(&(s->fat));
3234 array_free(&(s->directory));
3235 array_free(&(s->mapping));
3236 g_free(s->cluster_buffer);
3237
3238 if (s->qcow) {
3239 migrate_del_blocker(&s->migration_blocker);
3240 }
3241 }
3242
3243 static const char *const vvfat_strong_runtime_opts[] = {
3244 "dir",
3245 "fat-type",
3246 "floppy",
3247 "label",
3248 "rw",
3249
3250 NULL
3251 };
3252
3253 static BlockDriver bdrv_vvfat = {
3254 .format_name = "vvfat",
3255 .protocol_name = "fat",
3256 .instance_size = sizeof(BDRVVVFATState),
3257
3258 .bdrv_parse_filename = vvfat_parse_filename,
3259 .bdrv_open = vvfat_open,
3260 .bdrv_refresh_limits = vvfat_refresh_limits,
3261 .bdrv_close = vvfat_close,
3262 .bdrv_child_perm = vvfat_child_perm,
3263
3264 .bdrv_co_preadv = vvfat_co_preadv,
3265 .bdrv_co_pwritev = vvfat_co_pwritev,
3266 .bdrv_co_block_status = vvfat_co_block_status,
3267
3268 .strong_runtime_opts = vvfat_strong_runtime_opts,
3269 };
3270
bdrv_vvfat_init(void)3271 static void bdrv_vvfat_init(void)
3272 {
3273 child_vvfat_qcow = child_of_bds;
3274 child_vvfat_qcow.inherit_options = vvfat_qcow_options;
3275 bdrv_register(&bdrv_vvfat);
3276 }
3277
3278 block_init(bdrv_vvfat_init);
3279
3280 #ifdef DEBUG
checkpoint(void)3281 static void checkpoint(void)
3282 {
3283 assert(((mapping_t*)array_get(&(vvv->mapping), 0))->end == 2);
3284 check1(vvv);
3285 check2(vvv);
3286 assert(!vvv->current_mapping || vvv->current_fd || (vvv->current_mapping->mode & MODE_DIRECTORY));
3287 }
3288 #endif
3289