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