1 /* vim:set shiftwidth=4 ts=4: */
3 * QEMU Block driver for virtual VFAT (shadows a local directory)
5 * Copyright (c) 2004,2005 Johannes E. Schindelin
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:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
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
25 #include "qemu/osdep.h"
27 #include "qapi/error.h"
28 #include "block/block_int.h"
29 #include "qemu/module.h"
30 #include "migration/migration.h"
31 #include "qapi/qmp/qint.h"
32 #include "qapi/qmp/qbool.h"
33 #include "qapi/qmp/qstring.h"
34 #include "qemu/cutils.h"
43 /* TODO: add ":bootsector=blabla.img:" */
44 /* LATER TODO: add automatic boot sector generation from
45 BOOTEASY.ASM and Ranish Partition Manager
46 Note that DOS assumes the system files to be the first files in the
47 file system (test if the boot sector still relies on that fact)! */
48 /* MAYBE TODO: write block-visofs.c */
49 /* TODO: call try_commit() only after a timeout */
57 static void checkpoint(void);
60 void nonono(const char* file
, int line
, const char* msg
) {
61 fprintf(stderr
, "Nonono! %s:%d %s\n", file
, line
, msg
);
65 #define assert(a) do {if (!(a)) nonono(__FILE__, __LINE__, #a);}while(0)
74 /* dynamic array functions */
75 typedef struct array_t
{
77 unsigned int size
,next
,item_size
;
80 static inline void array_init(array_t
* array
,unsigned int item_size
)
82 array
->pointer
= NULL
;
85 array
->item_size
=item_size
;
88 static inline void array_free(array_t
* array
)
90 g_free(array
->pointer
);
91 array
->size
=array
->next
=0;
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
;
100 static inline int array_ensure_allocated(array_t
* array
, int index
)
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
);
107 array
->size
= new_size
;
108 array
->next
= index
+ 1;
114 static inline void* array_get_next(array_t
* array
) {
115 unsigned int next
= array
->next
;
118 if (array_ensure_allocated(array
, next
) < 0)
121 array
->next
= next
+ 1;
122 result
= array_get(array
, next
);
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
);
133 array
->size
+=increment
;
135 memmove(array
->pointer
+(index
+count
)*array
->item_size
,
136 array
->pointer
+index
*array
->item_size
,
137 (array
->next
-index
)*array
->item_size
);
139 return array
->pointer
+index
*array
->item_size
;
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
)
152 index_to
<0 || index_to
>=array
->next
||
153 index_from
<0 || index_from
>=array
->next
)
156 if(index_to
==index_from
)
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
);
165 if(index_to
<index_from
)
166 memmove(to
+is
*count
,to
,from
-to
);
168 memmove(from
,from
+is
*count
,to
-from
);
170 memcpy(to
,buf
,is
*count
);
177 static inline int array_remove_slice(array_t
* array
,int index
, int count
)
181 assert(index
+ count
<= array
->next
);
182 if(array_roll(array
,array
->next
-1,index
,count
))
184 array
->next
-= count
;
188 static int array_remove(array_t
* array
,int index
)
190 return array_remove_slice(array
, index
, 1);
193 /* return the index for a given member */
194 static int array_index(array_t
* array
, void* pointer
)
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
;
202 /* These structures are used to fake a disk and the VFAT filesystem.
203 * For this reason we need to use QEMU_PACKED. */
205 typedef struct bootsector_t
{
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
;
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
;
222 uint8_t drive_number
;
223 uint8_t current_head
;
226 uint8_t volume_label
[11];
229 uint32_t sectors_per_fat
;
232 uint32_t first_cluster_of_root_directory
;
233 uint16_t info_sector
;
234 uint16_t backup_boot_sector
;
239 uint8_t ignored
[0x1c0];
241 } QEMU_PACKED bootsector_t
;
249 typedef struct partition_t
{
250 uint8_t attributes
; /* 0x80 = bootable */
252 uint8_t fs_type
; /* 0x1 = FAT12, 0x6 = FAT16, 0xe = FAT16_LBA, 0xb = FAT32, 0xc = FAT32_LBA */
254 uint32_t start_sector_long
;
255 uint32_t length_sector_long
;
256 } QEMU_PACKED partition_t
;
258 typedef struct mbr_t
{
259 uint8_t ignored
[0x1b8];
262 partition_t partition
[4];
266 typedef struct direntry_t
{
278 } QEMU_PACKED direntry_t
;
280 /* this structure are used to transparently access the files */
282 typedef struct mapping_t
{
283 /* begin is the first cluster, end is the last+1 */
285 /* as s->directory is growable, no pointer may be used here */
286 unsigned int dir_index
;
287 /* the clusters of a file may be in any order; this points to the first */
288 int first_mapping_index
;
291 * - the offset in the file (in clusters) for a file, or
292 * - the next cluster of the directory for a directory, and
293 * - the address of the buffer for a faked entry
299 int parent_mapping_index
;
303 /* path contains the full path, i.e. it always starts with s->path */
306 enum { MODE_UNDEFINED
= 0, MODE_NORMAL
= 1, MODE_MODIFIED
= 2,
307 MODE_DIRECTORY
= 4, MODE_FAKED
= 8,
308 MODE_DELETED
= 16, MODE_RENAMED
= 32 } mode
;
313 static void print_direntry(const struct direntry_t
*);
314 static void print_mapping(const struct mapping_t
* mapping
);
317 /* here begins the real VVFAT driver */
319 typedef struct BDRVVVFATState
{
321 BlockDriverState
* bs
; /* pointer to parent */
322 unsigned int first_sectors_number
; /* 1 for a single partition, 0x40 for a disk with partition table */
323 unsigned char first_sectors
[0x40*0x200];
325 int fat_type
; /* 16 or 32 */
326 array_t fat
,directory
,mapping
;
327 char volume_label
[11];
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
;
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
;
346 BlockDriverState
* write_target
;
348 BlockDriverState
* qcow
;
353 int downcase_short_names
;
355 Error
*migration_blocker
;
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.
362 static int sector2CHS(mbr_chs_t
*chs
, int spos
, int cyls
, int heads
, int secs
)
365 sector
= spos
% secs
; spos
/= secs
;
366 head
= spos
% heads
; spos
/= heads
;
369 it happens if 32bit sector positions are used, while CHS is only 24bit.
370 Windows/Dos is said to take 1023/255/63 as nonrepresentable CHS */
373 chs
->cylinder
= 0xFF;
376 chs
->head
= (uint8_t)head
;
377 chs
->sector
= (uint8_t)( (sector
+1) | ((spos
>>8)<<6) );
378 chs
->cylinder
= (uint8_t)spos
;
382 static void init_mbr(BDRVVVFATState
*s
, int cyls
, int heads
, int secs
)
384 /* TODO: if the files mbr.img and bootsect.img exist, use them */
385 mbr_t
* real_mbr
=(mbr_t
*)s
->first_sectors
;
386 partition_t
* partition
= &(real_mbr
->partition
[0]);
389 memset(s
->first_sectors
,0,512);
391 /* Win NT Disk Signature */
392 real_mbr
->nt_id
= cpu_to_le32(0xbe1afdfa);
394 partition
->attributes
=0x80; /* bootable */
396 /* LBA is used when partition is outside the CHS geometry */
397 lba
= sector2CHS(&partition
->start_CHS
, s
->first_sectors_number
- 1,
399 lba
|= sector2CHS(&partition
->end_CHS
, s
->bs
->total_sectors
- 1,
402 /*LBA partitions are identified only by start/length_sector_long not by CHS*/
403 partition
->start_sector_long
= cpu_to_le32(s
->first_sectors_number
- 1);
404 partition
->length_sector_long
= cpu_to_le32(s
->bs
->total_sectors
405 - s
->first_sectors_number
+ 1);
407 /* FAT12/FAT16/FAT32 */
408 /* DOS uses different types when partition is LBA,
409 probably to prevent older versions from using CHS on them */
410 partition
->fs_type
= s
->fat_type
==12 ? 0x1:
411 s
->fat_type
==16 ? (lba
?0xe:0x06):
412 /*fat_tyoe==32*/ (lba
?0xc:0x0b);
414 real_mbr
->magic
[0]=0x55; real_mbr
->magic
[1]=0xaa;
417 /* direntry functions */
419 /* dest is assumed to hold 258 bytes, and pads with 0xffff up to next multiple of 26 */
420 static inline int short2long_name(char* dest
,const char* src
)
424 for(i
=0;i
<129 && src
[i
];i
++) {
429 dest
[2*i
]=dest
[2*i
+1]=0;
430 for(i
=2*i
+2;(i
%26);i
++)
435 static inline direntry_t
* create_long_filename(BDRVVVFATState
* s
,const char* filename
)
438 int length
=short2long_name(buffer
,filename
),
439 number_of_entries
=(length
+25)/26,i
;
442 for(i
=0;i
<number_of_entries
;i
++) {
443 entry
=array_get_next(&(s
->directory
));
444 entry
->attributes
=0xf;
445 entry
->reserved
[0]=0;
447 entry
->name
[0]=(number_of_entries
-i
)|(i
==0?0x40:0);
449 for(i
=0;i
<26*number_of_entries
;i
++) {
451 if(offset
<10) offset
=1+offset
;
452 else if(offset
<22) offset
=14+offset
-10;
453 else offset
=28+offset
-22;
454 entry
=array_get(&(s
->directory
),s
->directory
.next
-1-(i
/26));
455 entry
->name
[offset
]=buffer
[i
];
457 return array_get(&(s
->directory
),s
->directory
.next
-number_of_entries
);
460 static char is_free(const direntry_t
* direntry
)
462 return direntry
->name
[0]==0xe5 || direntry
->name
[0]==0x00;
465 static char is_volume_label(const direntry_t
* direntry
)
467 return direntry
->attributes
== 0x28;
470 static char is_long_name(const direntry_t
* direntry
)
472 return direntry
->attributes
== 0xf;
475 static char is_short_name(const direntry_t
* direntry
)
477 return !is_volume_label(direntry
) && !is_long_name(direntry
)
478 && !is_free(direntry
);
481 static char is_directory(const direntry_t
* direntry
)
483 return direntry
->attributes
& 0x10 && direntry
->name
[0] != 0xe5;
486 static inline char is_dot(const direntry_t
* direntry
)
488 return is_short_name(direntry
) && direntry
->name
[0] == '.';
491 static char is_file(const direntry_t
* direntry
)
493 return is_short_name(direntry
) && !is_directory(direntry
);
496 static inline uint32_t begin_of_direntry(const direntry_t
* direntry
)
498 return le16_to_cpu(direntry
->begin
)|(le16_to_cpu(direntry
->begin_hi
)<<16);
501 static inline uint32_t filesize_of_direntry(const direntry_t
* direntry
)
503 return le32_to_cpu(direntry
->size
);
506 static void set_begin_of_direntry(direntry_t
* direntry
, uint32_t begin
)
508 direntry
->begin
= cpu_to_le16(begin
& 0xffff);
509 direntry
->begin_hi
= cpu_to_le16((begin
>> 16) & 0xffff);
514 static inline uint8_t fat_chksum(const direntry_t
* entry
)
519 for (i
= 0; i
< ARRAY_SIZE(entry
->name
); i
++) {
520 chksum
= (((chksum
& 0xfe) >> 1) |
521 ((chksum
& 0x01) ? 0x80 : 0)) + entry
->name
[i
];
527 /* if return_time==0, this returns the fat_date, else the fat_time */
528 static uint16_t fat_datetime(time_t time
,int return_time
) {
532 localtime_r(&time
,t
);
534 return cpu_to_le16((t
->tm_sec
/2)|(t
->tm_min
<<5)|(t
->tm_hour
<<11));
535 return cpu_to_le16((t
->tm_mday
)|((t
->tm_mon
+1)<<5)|((t
->tm_year
-80)<<9));
538 static inline void fat_set(BDRVVVFATState
* s
,unsigned int cluster
,uint32_t value
)
540 if(s
->fat_type
==32) {
541 uint32_t* entry
=array_get(&(s
->fat
),cluster
);
542 *entry
=cpu_to_le32(value
);
543 } else if(s
->fat_type
==16) {
544 uint16_t* entry
=array_get(&(s
->fat
),cluster
);
545 *entry
=cpu_to_le16(value
&0xffff);
547 int offset
= (cluster
*3/2);
548 unsigned char* p
= array_get(&(s
->fat
), offset
);
552 p
[1] = (p
[1]&0xf0) | ((value
>>8)&0xf);
555 p
[0] = (p
[0]&0xf) | ((value
&0xf)<<4);
562 static inline uint32_t fat_get(BDRVVVFATState
* s
,unsigned int cluster
)
564 if(s
->fat_type
==32) {
565 uint32_t* entry
=array_get(&(s
->fat
),cluster
);
566 return le32_to_cpu(*entry
);
567 } else if(s
->fat_type
==16) {
568 uint16_t* entry
=array_get(&(s
->fat
),cluster
);
569 return le16_to_cpu(*entry
);
571 const uint8_t* x
=(uint8_t*)(s
->fat
.pointer
)+cluster
*3/2;
572 return ((x
[0]|(x
[1]<<8))>>(cluster
&1?4:0))&0x0fff;
576 static inline int fat_eof(BDRVVVFATState
* s
,uint32_t fat_entry
)
578 if(fat_entry
>s
->max_fat_value
-8)
583 static inline void init_fat(BDRVVVFATState
* s
)
585 if (s
->fat_type
== 12) {
586 array_init(&(s
->fat
),1);
587 array_ensure_allocated(&(s
->fat
),
588 s
->sectors_per_fat
* 0x200 * 3 / 2 - 1);
590 array_init(&(s
->fat
),(s
->fat_type
==32?4:2));
591 array_ensure_allocated(&(s
->fat
),
592 s
->sectors_per_fat
* 0x200 / s
->fat
.item_size
- 1);
594 memset(s
->fat
.pointer
,0,s
->fat
.size
);
596 switch(s
->fat_type
) {
597 case 12: s
->max_fat_value
=0xfff; break;
598 case 16: s
->max_fat_value
=0xffff; break;
599 case 32: s
->max_fat_value
=0x0fffffff; break;
600 default: s
->max_fat_value
=0; /* error... */
605 /* TODO: in create_short_filename, 0xe5->0x05 is not yet handled! */
606 /* TODO: in parse_short_filename, 0x05->0xe5 is not yet handled! */
607 static inline direntry_t
* create_short_and_long_name(BDRVVVFATState
* s
,
608 unsigned int directory_start
, const char* filename
, int is_dot
)
610 int i
,j
,long_index
=s
->directory
.next
;
611 direntry_t
* entry
= NULL
;
612 direntry_t
* entry_long
= NULL
;
615 entry
=array_get_next(&(s
->directory
));
616 memset(entry
->name
, 0x20, sizeof(entry
->name
));
617 memcpy(entry
->name
,filename
,strlen(filename
));
621 entry_long
=create_long_filename(s
,filename
);
623 i
= strlen(filename
);
624 for(j
= i
- 1; j
>0 && filename
[j
]!='.';j
--);
630 entry
=array_get_next(&(s
->directory
));
631 memset(entry
->name
, 0x20, sizeof(entry
->name
));
632 memcpy(entry
->name
, filename
, i
);
635 for (i
= 0; i
< 3 && filename
[j
+ 1 + i
]; i
++) {
636 entry
->name
[8 + i
] = filename
[j
+ 1 + i
];
640 /* upcase & remove unwanted characters */
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
]))
646 else if(entry
->name
[i
]>='a' && entry
->name
[i
]<='z')
647 entry
->name
[i
]+='A'-'a';
650 /* mangle duplicates */
652 direntry_t
* entry1
=array_get(&(s
->directory
),directory_start
);
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 */
661 /* use all 8 characters of name */
662 if(entry
->name
[7]==' ') {
664 for(j
=6;j
>0 && entry
->name
[j
]==' ';j
--)
668 /* increment number */
669 for(j
=7;j
>0 && entry
->name
[j
]=='9';j
--)
672 if(entry
->name
[j
]<'0' || entry
->name
[j
]>'9')
679 /* calculate checksum; propagate to long name */
681 uint8_t chksum
=fat_chksum(entry
);
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
;
695 * Read a directory. (the index of the corresponding mapping must be passed).
697 static int read_directory(BDRVVVFATState
* s
, int mapping_index
)
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;
708 DIR* dir
=opendir(dirname
);
709 struct dirent
* entry
;
712 assert(mapping
->mode
& MODE_DIRECTORY
);
715 mapping
->end
= mapping
->begin
;
719 i
= mapping
->info
.dir
.first_dir_index
=
720 first_cluster
== 0 ? 0 : s
->directory
.next
;
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
);
726 direntry_t
* direntry
;
728 int is_dot
=!strcmp(entry
->d_name
,".");
729 int is_dotdot
=!strcmp(entry
->d_name
,"..");
731 if(first_cluster
== 0 && (is_dotdot
|| is_dot
))
734 buffer
= g_malloc(length
);
735 snprintf(buffer
,length
,"%s/%s",dirname
,entry
->d_name
);
737 if(stat(buffer
,&st
)<0) {
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);
754 set_begin_of_direntry(direntry
, first_cluster_of_parent
);
756 set_begin_of_direntry(direntry
, first_cluster
);
758 direntry
->begin
=0; /* do that later */
759 if (st
.st_size
> 0x7fffffff) {
760 fprintf(stderr
, "File %s is larger than 2GB\n", buffer
);
765 direntry
->size
=cpu_to_le32(S_ISDIR(st
.st_mode
)?0:st
.st_size
);
767 /* create mapping for this file */
768 if(!is_dot
&& !is_dotdot
&& (S_ISDIR(st
.st_mode
) || st
.st_size
)) {
769 s
->current_mapping
= array_get_next(&(s
->mapping
));
770 s
->current_mapping
->begin
=0;
771 s
->current_mapping
->end
=st
.st_size
;
773 * we get the direntry of the most recent direntry, which
774 * contains the short name and all the relevant information.
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
=
783 s
->current_mapping
->mode
= MODE_UNDEFINED
;
784 s
->current_mapping
->info
.file
.offset
= 0;
786 s
->current_mapping
->path
=buffer
;
787 s
->current_mapping
->read_only
=
788 (st
.st_mode
& (S_IWUSR
| S_IWGRP
| S_IWOTH
)) == 0;
795 /* fill with zeroes up to the end of the cluster */
796 while(s
->directory
.next
%(0x10*s
->sectors_per_cluster
)) {
797 direntry_t
* direntry
=array_get_next(&(s
->directory
));
798 memset(direntry
,0,sizeof(direntry_t
));
801 /* TODO: if there are more entries, bootsector has to be adjusted! */
802 #define ROOT_ENTRIES (0x02 * 0x10 * s->sectors_per_cluster)
803 if (mapping_index
== 0 && s
->directory
.next
< ROOT_ENTRIES
) {
805 int cur
= s
->directory
.next
;
806 array_ensure_allocated(&(s
->directory
), ROOT_ENTRIES
- 1);
807 s
->directory
.next
= ROOT_ENTRIES
;
808 memset(array_get(&(s
->directory
), cur
), 0,
809 (ROOT_ENTRIES
- cur
) * sizeof(direntry_t
));
812 /* reget the mapping, since s->mapping was possibly realloc()ed */
813 mapping
= array_get(&(s
->mapping
), mapping_index
);
814 first_cluster
+= (s
->directory
.next
- mapping
->info
.dir
.first_dir_index
)
815 * 0x20 / s
->cluster_size
;
816 mapping
->end
= first_cluster
;
818 direntry
= array_get(&(s
->directory
), mapping
->dir_index
);
819 set_begin_of_direntry(direntry
, mapping
->begin
);
824 static inline uint32_t sector2cluster(BDRVVVFATState
* s
,off_t sector_num
)
826 return (sector_num
-s
->faked_sectors
)/s
->sectors_per_cluster
;
829 static inline off_t
cluster2sector(BDRVVVFATState
* s
, uint32_t cluster_num
)
831 return s
->faked_sectors
+ s
->sectors_per_cluster
* cluster_num
;
834 static int init_directories(BDRVVVFATState
* s
,
835 const char *dirname
, int heads
, int secs
,
838 bootsector_t
* bootsector
;
841 unsigned int cluster
;
843 memset(&(s
->first_sectors
[0]),0,0x40*0x200);
845 s
->cluster_size
=s
->sectors_per_cluster
*0x200;
846 s
->cluster_buffer
=g_malloc(s
->cluster_size
);
849 * The formula: sc = spf+1+spf*spc*(512*8/fat_type),
850 * where sc is sector_count,
851 * spf is sectors_per_fat,
852 * spc is sectors_per_clusters, and
853 * fat_type = 12, 16 or 32.
855 i
= 1+s
->sectors_per_cluster
*0x200*8/s
->fat_type
;
856 s
->sectors_per_fat
=(s
->sector_count
+i
)/i
; /* round up */
858 array_init(&(s
->mapping
),sizeof(mapping_t
));
859 array_init(&(s
->directory
),sizeof(direntry_t
));
861 /* add volume label */
863 direntry_t
* entry
=array_get_next(&(s
->directory
));
864 entry
->attributes
=0x28; /* archive | volume label */
865 memcpy(entry
->name
, s
->volume_label
, sizeof(entry
->name
));
868 /* Now build FAT, and write back information into directory */
871 s
->faked_sectors
=s
->first_sectors_number
+s
->sectors_per_fat
*2;
872 s
->cluster_count
=sector2cluster(s
, s
->sector_count
);
874 mapping
= array_get_next(&(s
->mapping
));
876 mapping
->dir_index
= 0;
877 mapping
->info
.dir
.parent_mapping_index
= -1;
878 mapping
->first_mapping_index
= -1;
879 mapping
->path
= g_strdup(dirname
);
880 i
= strlen(mapping
->path
);
881 if (i
> 0 && mapping
->path
[i
- 1] == '/')
882 mapping
->path
[i
- 1] = '\0';
883 mapping
->mode
= MODE_DIRECTORY
;
884 mapping
->read_only
= 0;
885 s
->path
= mapping
->path
;
887 for (i
= 0, cluster
= 0; i
< s
->mapping
.next
; i
++) {
888 /* MS-DOS expects the FAT to be 0 for the root directory
889 * (except for the media byte). */
890 /* LATER TODO: still true for FAT32? */
891 int fix_fat
= (i
!= 0);
892 mapping
= array_get(&(s
->mapping
), i
);
894 if (mapping
->mode
& MODE_DIRECTORY
) {
895 mapping
->begin
= cluster
;
896 if(read_directory(s
, i
)) {
897 error_setg(errp
, "Could not read directory %s",
901 mapping
= array_get(&(s
->mapping
), i
);
903 assert(mapping
->mode
== MODE_UNDEFINED
);
904 mapping
->mode
=MODE_NORMAL
;
905 mapping
->begin
= cluster
;
906 if (mapping
->end
> 0) {
907 direntry_t
* direntry
= array_get(&(s
->directory
),
910 mapping
->end
= cluster
+ 1 + (mapping
->end
-1)/s
->cluster_size
;
911 set_begin_of_direntry(direntry
, mapping
->begin
);
913 mapping
->end
= cluster
+ 1;
918 assert(mapping
->begin
< mapping
->end
);
920 /* next free cluster */
921 cluster
= mapping
->end
;
923 if(cluster
> s
->cluster_count
) {
925 "Directory does not fit in FAT%d (capacity %.2f MB)",
926 s
->fat_type
, s
->sector_count
/ 2000.0);
930 /* fix fat for entry */
933 for(j
= mapping
->begin
; j
< mapping
->end
- 1; j
++)
935 fat_set(s
, mapping
->end
- 1, s
->max_fat_value
);
939 mapping
= array_get(&(s
->mapping
), 0);
940 s
->sectors_of_root_directory
= mapping
->end
* s
->sectors_per_cluster
;
941 s
->last_cluster_of_root_directory
= mapping
->end
;
943 /* the FAT signature */
944 fat_set(s
,0,s
->max_fat_value
);
945 fat_set(s
,1,s
->max_fat_value
);
947 s
->current_mapping
= NULL
;
949 bootsector
=(bootsector_t
*)(s
->first_sectors
+(s
->first_sectors_number
-1)*0x200);
950 bootsector
->jump
[0]=0xeb;
951 bootsector
->jump
[1]=0x3e;
952 bootsector
->jump
[2]=0x90;
953 memcpy(bootsector
->name
,"QEMU ",8);
954 bootsector
->sector_size
=cpu_to_le16(0x200);
955 bootsector
->sectors_per_cluster
=s
->sectors_per_cluster
;
956 bootsector
->reserved_sectors
=cpu_to_le16(1);
957 bootsector
->number_of_fats
=0x2; /* number of FATs */
958 bootsector
->root_entries
=cpu_to_le16(s
->sectors_of_root_directory
*0x10);
959 bootsector
->total_sectors16
=s
->sector_count
>0xffff?0:cpu_to_le16(s
->sector_count
);
960 bootsector
->media_type
=(s
->first_sectors_number
>1?0xf8:0xf0); /* media descriptor (f8=hd, f0=3.5 fd)*/
961 s
->fat
.pointer
[0] = bootsector
->media_type
;
962 bootsector
->sectors_per_fat
=cpu_to_le16(s
->sectors_per_fat
);
963 bootsector
->sectors_per_track
= cpu_to_le16(secs
);
964 bootsector
->number_of_heads
= cpu_to_le16(heads
);
965 bootsector
->hidden_sectors
=cpu_to_le32(s
->first_sectors_number
==1?0:0x3f);
966 bootsector
->total_sectors
=cpu_to_le32(s
->sector_count
>0xffff?s
->sector_count
:0);
968 /* LATER TODO: if FAT32, this is wrong */
969 bootsector
->u
.fat16
.drive_number
=s
->first_sectors_number
==1?0:0x80; /* fda=0, hda=0x80 */
970 bootsector
->u
.fat16
.current_head
=0;
971 bootsector
->u
.fat16
.signature
=0x29;
972 bootsector
->u
.fat16
.id
=cpu_to_le32(0xfabe1afd);
974 memcpy(bootsector
->u
.fat16
.volume_label
, s
->volume_label
,
975 sizeof(bootsector
->u
.fat16
.volume_label
));
976 memcpy(bootsector
->fat_type
,(s
->fat_type
==12?"FAT12 ":s
->fat_type
==16?"FAT16 ":"FAT32 "),8);
977 bootsector
->magic
[0]=0x55; bootsector
->magic
[1]=0xaa;
983 static BDRVVVFATState
*vvv
= NULL
;
986 static int enable_write_target(BDRVVVFATState
*s
, Error
**errp
);
987 static int is_consistent(BDRVVVFATState
*s
);
989 static QemuOptsList runtime_opts
= {
991 .head
= QTAILQ_HEAD_INITIALIZER(runtime_opts
.head
),
995 .type
= QEMU_OPT_STRING
,
996 .help
= "Host directory to map to the vvfat device",
1000 .type
= QEMU_OPT_NUMBER
,
1001 .help
= "FAT type (12, 16 or 32)",
1005 .type
= QEMU_OPT_BOOL
,
1006 .help
= "Create a floppy rather than a hard disk image",
1010 .type
= QEMU_OPT_STRING
,
1011 .help
= "Use a volume label other than QEMU VVFAT",
1015 .type
= QEMU_OPT_BOOL
,
1016 .help
= "Make the image writable",
1018 { /* end of list */ }
1022 static void vvfat_parse_filename(const char *filename
, QDict
*options
,
1026 bool floppy
= false;
1030 if (!strstart(filename
, "fat:", NULL
)) {
1031 error_setg(errp
, "File name string must start with 'fat:'");
1036 if (strstr(filename
, ":32:")) {
1038 } else if (strstr(filename
, ":16:")) {
1040 } else if (strstr(filename
, ":12:")) {
1044 if (strstr(filename
, ":floppy:")) {
1048 if (strstr(filename
, ":rw:")) {
1052 /* Get the directory name without options */
1053 i
= strrchr(filename
, ':') - filename
;
1055 if (filename
[i
- 2] == ':' && qemu_isalpha(filename
[i
- 1])) {
1056 /* workaround for DOS drive names */
1062 /* Fill in the options QDict */
1063 qdict_put(options
, "dir", qstring_from_str(filename
));
1064 qdict_put(options
, "fat-type", qint_from_int(fat_type
));
1065 qdict_put(options
, "floppy", qbool_from_bool(floppy
));
1066 qdict_put(options
, "rw", qbool_from_bool(rw
));
1069 static int vvfat_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
1072 BDRVVVFATState
*s
= bs
->opaque
;
1073 int cyls
, heads
, secs
;
1075 const char *dirname
, *label
;
1077 Error
*local_err
= NULL
;
1084 opts
= qemu_opts_create(&runtime_opts
, NULL
, 0, &error_abort
);
1085 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
1087 error_propagate(errp
, local_err
);
1092 dirname
= qemu_opt_get(opts
, "dir");
1094 error_setg(errp
, "vvfat block driver requires a 'dir' option");
1099 s
->fat_type
= qemu_opt_get_number(opts
, "fat-type", 0);
1100 floppy
= qemu_opt_get_bool(opts
, "floppy", false);
1102 memset(s
->volume_label
, ' ', sizeof(s
->volume_label
));
1103 label
= qemu_opt_get(opts
, "label");
1105 size_t label_length
= strlen(label
);
1106 if (label_length
> 11) {
1107 error_setg(errp
, "vvfat label cannot be longer than 11 bytes");
1111 memcpy(s
->volume_label
, label
, label_length
);
1113 memcpy(s
->volume_label
, "QEMU VVFAT", 10);
1117 /* 1.44MB or 2.88MB floppy. 2.88MB can be FAT12 (default) or FAT16. */
1121 s
->sectors_per_cluster
= 2;
1123 secs
= s
->fat_type
== 12 ? 18 : 36;
1124 s
->sectors_per_cluster
= 1;
1126 s
->first_sectors_number
= 1;
1130 /* 32MB or 504MB disk*/
1134 s
->first_sectors_number
= 0x40;
1135 cyls
= s
->fat_type
== 12 ? 64 : 1024;
1140 switch (s
->fat_type
) {
1142 fprintf(stderr
, "Big fat greek warning: FAT32 has not been tested. "
1143 "You are welcome to do so!\n");
1149 error_setg(errp
, "Valid FAT types are only 12, 16 and 32");
1157 /* LATER TODO: if FAT32, adjust */
1158 s
->sectors_per_cluster
=0x10;
1160 s
->current_cluster
=0xffffffff;
1162 /* read only is the default for safety */
1164 s
->qcow
= s
->write_target
= NULL
;
1165 s
->qcow_filename
= NULL
;
1167 s
->downcase_short_names
= 1;
1169 fprintf(stderr
, "vvfat %s chs %d,%d,%d\n",
1170 dirname
, cyls
, heads
, secs
);
1172 s
->sector_count
= cyls
* heads
* secs
- (s
->first_sectors_number
- 1);
1174 if (qemu_opt_get_bool(opts
, "rw", false)) {
1175 ret
= enable_write_target(s
, errp
);
1182 bs
->request_alignment
= BDRV_SECTOR_SIZE
; /* No sub-sector I/O supported */
1183 bs
->total_sectors
= cyls
* heads
* secs
;
1185 if (init_directories(s
, dirname
, heads
, secs
, errp
)) {
1190 s
->sector_count
= s
->faked_sectors
+ s
->sectors_per_cluster
*s
->cluster_count
;
1192 if (s
->first_sectors_number
== 0x40) {
1193 init_mbr(s
, cyls
, heads
, secs
);
1196 // assert(is_consistent(s));
1197 qemu_co_mutex_init(&s
->lock
);
1199 /* Disable migration when vvfat is used rw */
1201 error_setg(&s
->migration_blocker
,
1202 "The vvfat (rw) format used by node '%s' "
1203 "does not support live migration",
1204 bdrv_get_device_or_node_name(bs
));
1205 migrate_add_blocker(s
->migration_blocker
);
1210 qemu_opts_del(opts
);
1214 static inline void vvfat_close_current_file(BDRVVVFATState
*s
)
1216 if(s
->current_mapping
) {
1217 s
->current_mapping
= NULL
;
1218 if (s
->current_fd
) {
1219 qemu_close(s
->current_fd
);
1223 s
->current_cluster
= -1;
1226 /* mappings between index1 and index2-1 are supposed to be ordered
1227 * return value is the index of the last mapping for which end>cluster_num
1229 static inline int find_mapping_for_cluster_aux(BDRVVVFATState
* s
,int cluster_num
,int index1
,int index2
)
1234 index3
=(index1
+index2
)/2;
1235 mapping
=array_get(&(s
->mapping
),index3
);
1236 assert(mapping
->begin
< mapping
->end
);
1237 if(mapping
->begin
>=cluster_num
) {
1238 assert(index2
!=index3
|| index2
==0);
1244 return mapping
->end
<=cluster_num
? index2
: index1
;
1247 assert(index1
<=index2
);
1248 DLOG(mapping
=array_get(&(s
->mapping
),index1
);
1249 assert(mapping
->begin
<=cluster_num
);
1250 assert(index2
>= s
->mapping
.next
||
1251 ((mapping
= array_get(&(s
->mapping
),index2
)) &&
1252 mapping
->end
>cluster_num
)));
1256 static inline mapping_t
* find_mapping_for_cluster(BDRVVVFATState
* s
,int cluster_num
)
1258 int index
=find_mapping_for_cluster_aux(s
,cluster_num
,0,s
->mapping
.next
);
1260 if(index
>=s
->mapping
.next
)
1262 mapping
=array_get(&(s
->mapping
),index
);
1263 if(mapping
->begin
>cluster_num
)
1265 assert(mapping
->begin
<=cluster_num
&& mapping
->end
>cluster_num
);
1269 static int open_file(BDRVVVFATState
* s
,mapping_t
* mapping
)
1273 if(!s
->current_mapping
||
1274 strcmp(s
->current_mapping
->path
,mapping
->path
)) {
1276 int fd
= qemu_open(mapping
->path
, O_RDONLY
| O_BINARY
| O_LARGEFILE
);
1279 vvfat_close_current_file(s
);
1281 s
->current_mapping
= mapping
;
1286 static inline int read_cluster(BDRVVVFATState
*s
,int cluster_num
)
1288 if(s
->current_cluster
!= cluster_num
) {
1291 assert(!s
->current_mapping
|| s
->current_fd
|| (s
->current_mapping
->mode
& MODE_DIRECTORY
));
1292 if(!s
->current_mapping
1293 || s
->current_mapping
->begin
>cluster_num
1294 || s
->current_mapping
->end
<=cluster_num
) {
1295 /* binary search of mappings for file */
1296 mapping_t
* mapping
=find_mapping_for_cluster(s
,cluster_num
);
1298 assert(!mapping
|| (cluster_num
>=mapping
->begin
&& cluster_num
<mapping
->end
));
1300 if (mapping
&& mapping
->mode
& MODE_DIRECTORY
) {
1301 vvfat_close_current_file(s
);
1302 s
->current_mapping
= mapping
;
1303 read_cluster_directory
:
1304 offset
= s
->cluster_size
*(cluster_num
-s
->current_mapping
->begin
);
1305 s
->cluster
= (unsigned char*)s
->directory
.pointer
+offset
1306 + 0x20*s
->current_mapping
->info
.dir
.first_dir_index
;
1307 assert(((s
->cluster
-(unsigned char*)s
->directory
.pointer
)%s
->cluster_size
)==0);
1308 assert((char*)s
->cluster
+s
->cluster_size
<= s
->directory
.pointer
+s
->directory
.next
*s
->directory
.item_size
);
1309 s
->current_cluster
= cluster_num
;
1313 if(open_file(s
,mapping
))
1315 } else if (s
->current_mapping
->mode
& MODE_DIRECTORY
)
1316 goto read_cluster_directory
;
1318 assert(s
->current_fd
);
1320 offset
=s
->cluster_size
*(cluster_num
-s
->current_mapping
->begin
)+s
->current_mapping
->info
.file
.offset
;
1321 if(lseek(s
->current_fd
, offset
, SEEK_SET
)!=offset
)
1323 s
->cluster
=s
->cluster_buffer
;
1324 result
=read(s
->current_fd
,s
->cluster
,s
->cluster_size
);
1326 s
->current_cluster
= -1;
1329 s
->current_cluster
= cluster_num
;
1335 static void print_direntry(const direntry_t
* direntry
)
1340 fprintf(stderr
, "direntry %p: ", direntry
);
1343 if(is_long_name(direntry
)) {
1344 unsigned char* c
=(unsigned char*)direntry
;
1346 for(i
=1;i
<11 && c
[i
] && c
[i
]!=0xff;i
+=2)
1347 #define ADD_CHAR(c) {buffer[j] = (c); if (buffer[j] < ' ') buffer[j] = 0xb0; j++;}
1349 for(i
=14;i
<26 && c
[i
] && c
[i
]!=0xff;i
+=2)
1351 for(i
=28;i
<32 && c
[i
] && c
[i
]!=0xff;i
+=2)
1354 fprintf(stderr
, "%s\n", buffer
);
1358 ADD_CHAR(direntry
->name
[i
]);
1360 fprintf(stderr
,"%s attributes=0x%02x begin=%d size=%d\n",
1362 direntry
->attributes
,
1363 begin_of_direntry(direntry
),le32_to_cpu(direntry
->size
));
1367 static void print_mapping(const mapping_t
* mapping
)
1369 fprintf(stderr
, "mapping (%p): begin, end = %d, %d, dir_index = %d, "
1370 "first_mapping_index = %d, name = %s, mode = 0x%x, " ,
1371 mapping
, mapping
->begin
, mapping
->end
, mapping
->dir_index
,
1372 mapping
->first_mapping_index
, mapping
->path
, mapping
->mode
);
1374 if (mapping
->mode
& MODE_DIRECTORY
)
1375 fprintf(stderr
, "parent_mapping_index = %d, first_dir_index = %d\n", mapping
->info
.dir
.parent_mapping_index
, mapping
->info
.dir
.first_dir_index
);
1377 fprintf(stderr
, "offset = %d\n", mapping
->info
.file
.offset
);
1381 static int vvfat_read(BlockDriverState
*bs
, int64_t sector_num
,
1382 uint8_t *buf
, int nb_sectors
)
1384 BDRVVVFATState
*s
= bs
->opaque
;
1387 for(i
=0;i
<nb_sectors
;i
++,sector_num
++) {
1388 if (sector_num
>= bs
->total_sectors
)
1392 if (bdrv_is_allocated(s
->qcow
, sector_num
, nb_sectors
-i
, &n
)) {
1393 DLOG(fprintf(stderr
, "sectors %d+%d allocated\n", (int)sector_num
, n
));
1394 if (bdrv_read(s
->qcow
, sector_num
, buf
+ i
*0x200, n
)) {
1398 sector_num
+= n
- 1;
1401 DLOG(fprintf(stderr
, "sector %d not allocated\n", (int)sector_num
));
1403 if(sector_num
<s
->faked_sectors
) {
1404 if(sector_num
<s
->first_sectors_number
)
1405 memcpy(buf
+i
*0x200,&(s
->first_sectors
[sector_num
*0x200]),0x200);
1406 else if(sector_num
-s
->first_sectors_number
<s
->sectors_per_fat
)
1407 memcpy(buf
+i
*0x200,&(s
->fat
.pointer
[(sector_num
-s
->first_sectors_number
)*0x200]),0x200);
1408 else if(sector_num
-s
->first_sectors_number
-s
->sectors_per_fat
<s
->sectors_per_fat
)
1409 memcpy(buf
+i
*0x200,&(s
->fat
.pointer
[(sector_num
-s
->first_sectors_number
-s
->sectors_per_fat
)*0x200]),0x200);
1411 uint32_t sector
=sector_num
-s
->faked_sectors
,
1412 sector_offset_in_cluster
=(sector
%s
->sectors_per_cluster
),
1413 cluster_num
=sector
/s
->sectors_per_cluster
;
1414 if(cluster_num
> s
->cluster_count
|| read_cluster(s
, cluster_num
) != 0) {
1415 /* LATER TODO: strict: return -1; */
1416 memset(buf
+i
*0x200,0,0x200);
1419 memcpy(buf
+i
*0x200,s
->cluster
+sector_offset_in_cluster
*0x200,0x200);
1425 static int coroutine_fn
1426 vvfat_co_preadv(BlockDriverState
*bs
, uint64_t offset
, uint64_t bytes
,
1427 QEMUIOVector
*qiov
, int flags
)
1430 BDRVVVFATState
*s
= bs
->opaque
;
1431 uint64_t sector_num
= offset
>> BDRV_SECTOR_BITS
;
1432 int nb_sectors
= bytes
>> BDRV_SECTOR_BITS
;
1435 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
1436 assert((bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
1438 buf
= g_try_malloc(bytes
);
1439 if (bytes
&& buf
== NULL
) {
1443 qemu_co_mutex_lock(&s
->lock
);
1444 ret
= vvfat_read(bs
, sector_num
, buf
, nb_sectors
);
1445 qemu_co_mutex_unlock(&s
->lock
);
1447 qemu_iovec_from_buf(qiov
, 0, buf
, bytes
);
1453 /* LATER TODO: statify all functions */
1456 * Idea of the write support (use snapshot):
1458 * 1. check if all data is consistent, recording renames, modifications,
1459 * new files and directories (in s->commits).
1461 * 2. if the data is not consistent, stop committing
1463 * 3. handle renames, and create new files and directories (do not yet
1464 * write their contents)
1466 * 4. walk the directories, fixing the mapping and direntries, and marking
1467 * the handled mappings as not deleted
1469 * 5. commit the contents of the files
1471 * 6. handle deleted files and directories
1475 typedef struct commit_t
{
1478 struct { uint32_t cluster
; } rename
;
1479 struct { int dir_index
; uint32_t modified_offset
; } writeout
;
1480 struct { uint32_t first_cluster
; } new_file
;
1481 struct { uint32_t cluster
; } mkdir
;
1483 /* DELETEs and RMDIRs are handled differently: see handle_deletes() */
1485 ACTION_RENAME
, ACTION_WRITEOUT
, ACTION_NEW_FILE
, ACTION_MKDIR
1489 static void clear_commits(BDRVVVFATState
* s
)
1492 DLOG(fprintf(stderr
, "clear_commits (%d commits)\n", s
->commits
.next
));
1493 for (i
= 0; i
< s
->commits
.next
; i
++) {
1494 commit_t
* commit
= array_get(&(s
->commits
), i
);
1495 assert(commit
->path
|| commit
->action
== ACTION_WRITEOUT
);
1496 if (commit
->action
!= ACTION_WRITEOUT
) {
1497 assert(commit
->path
);
1498 g_free(commit
->path
);
1500 assert(commit
->path
== NULL
);
1502 s
->commits
.next
= 0;
1505 static void schedule_rename(BDRVVVFATState
* s
,
1506 uint32_t cluster
, char* new_path
)
1508 commit_t
* commit
= array_get_next(&(s
->commits
));
1509 commit
->path
= new_path
;
1510 commit
->param
.rename
.cluster
= cluster
;
1511 commit
->action
= ACTION_RENAME
;
1514 static void schedule_writeout(BDRVVVFATState
* s
,
1515 int dir_index
, uint32_t modified_offset
)
1517 commit_t
* commit
= array_get_next(&(s
->commits
));
1518 commit
->path
= NULL
;
1519 commit
->param
.writeout
.dir_index
= dir_index
;
1520 commit
->param
.writeout
.modified_offset
= modified_offset
;
1521 commit
->action
= ACTION_WRITEOUT
;
1524 static void schedule_new_file(BDRVVVFATState
* s
,
1525 char* path
, uint32_t first_cluster
)
1527 commit_t
* commit
= array_get_next(&(s
->commits
));
1528 commit
->path
= path
;
1529 commit
->param
.new_file
.first_cluster
= first_cluster
;
1530 commit
->action
= ACTION_NEW_FILE
;
1533 static void schedule_mkdir(BDRVVVFATState
* s
, uint32_t cluster
, char* path
)
1535 commit_t
* commit
= array_get_next(&(s
->commits
));
1536 commit
->path
= path
;
1537 commit
->param
.mkdir
.cluster
= cluster
;
1538 commit
->action
= ACTION_MKDIR
;
1543 * Since the sequence number is at most 0x3f, and the filename
1544 * length is at most 13 times the sequence number, the maximal
1545 * filename length is 0x3f * 13 bytes.
1547 unsigned char name
[0x3f * 13 + 1];
1549 int sequence_number
;
1552 static void lfn_init(long_file_name
* lfn
)
1554 lfn
->sequence_number
= lfn
->len
= 0;
1555 lfn
->checksum
= 0x100;
1558 /* return 0 if parsed successfully, > 0 if no long name, < 0 if error */
1559 static int parse_long_name(long_file_name
* lfn
,
1560 const direntry_t
* direntry
)
1563 const unsigned char* pointer
= (const unsigned char*)direntry
;
1565 if (!is_long_name(direntry
))
1568 if (pointer
[0] & 0x40) {
1569 lfn
->sequence_number
= pointer
[0] & 0x3f;
1570 lfn
->checksum
= pointer
[13];
1572 lfn
->name
[lfn
->sequence_number
* 13] = 0;
1573 } else if ((pointer
[0] & 0x3f) != --lfn
->sequence_number
)
1575 else if (pointer
[13] != lfn
->checksum
)
1577 else if (pointer
[12] || pointer
[26] || pointer
[27])
1580 offset
= 13 * (lfn
->sequence_number
- 1);
1581 for (i
= 0, j
= 1; i
< 13; i
++, j
+=2) {
1587 if (pointer
[j
+1] == 0)
1588 lfn
->name
[offset
+ i
] = pointer
[j
];
1589 else if (pointer
[j
+1] != 0xff || (pointer
[0] & 0x40) == 0)
1592 lfn
->name
[offset
+ i
] = 0;
1595 if (pointer
[0] & 0x40)
1596 lfn
->len
= offset
+ strlen((char*)lfn
->name
+ offset
);
1601 /* returns 0 if successful, >0 if no short_name, and <0 on error */
1602 static int parse_short_name(BDRVVVFATState
* s
,
1603 long_file_name
* lfn
, direntry_t
* direntry
)
1607 if (!is_short_name(direntry
))
1610 for (j
= 7; j
>= 0 && direntry
->name
[j
] == ' '; j
--);
1611 for (i
= 0; i
<= j
; i
++) {
1612 if (direntry
->name
[i
] <= ' ' || direntry
->name
[i
] > 0x7f)
1614 else if (s
->downcase_short_names
)
1615 lfn
->name
[i
] = qemu_tolower(direntry
->name
[i
]);
1617 lfn
->name
[i
] = direntry
->name
[i
];
1620 for (j
= 2; j
>= 0 && direntry
->name
[8 + j
] == ' '; j
--) {
1623 lfn
->name
[i
++] = '.';
1624 lfn
->name
[i
+ j
+ 1] = '\0';
1625 for (;j
>= 0; j
--) {
1626 uint8_t c
= direntry
->name
[8 + j
];
1627 if (c
<= ' ' || c
> 0x7f) {
1629 } else if (s
->downcase_short_names
) {
1630 lfn
->name
[i
+ j
] = qemu_tolower(c
);
1632 lfn
->name
[i
+ j
] = c
;
1636 lfn
->name
[i
+ j
+ 1] = '\0';
1638 lfn
->len
= strlen((char*)lfn
->name
);
1643 static inline uint32_t modified_fat_get(BDRVVVFATState
* s
,
1644 unsigned int cluster
)
1646 if (cluster
< s
->last_cluster_of_root_directory
) {
1647 if (cluster
+ 1 == s
->last_cluster_of_root_directory
)
1648 return s
->max_fat_value
;
1653 if (s
->fat_type
==32) {
1654 uint32_t* entry
=((uint32_t*)s
->fat2
)+cluster
;
1655 return le32_to_cpu(*entry
);
1656 } else if (s
->fat_type
==16) {
1657 uint16_t* entry
=((uint16_t*)s
->fat2
)+cluster
;
1658 return le16_to_cpu(*entry
);
1660 const uint8_t* x
=s
->fat2
+cluster
*3/2;
1661 return ((x
[0]|(x
[1]<<8))>>(cluster
&1?4:0))&0x0fff;
1665 static inline int cluster_was_modified(BDRVVVFATState
* s
, uint32_t cluster_num
)
1667 int was_modified
= 0;
1670 if (s
->qcow
== NULL
)
1673 for (i
= 0; !was_modified
&& i
< s
->sectors_per_cluster
; i
++)
1674 was_modified
= bdrv_is_allocated(s
->qcow
,
1675 cluster2sector(s
, cluster_num
) + i
, 1, &dummy
);
1677 return was_modified
;
1680 static const char* get_basename(const char* path
)
1682 char* basename
= strrchr(path
, '/');
1683 if (basename
== NULL
)
1686 return basename
+ 1; /* strip '/' */
1690 * The array s->used_clusters holds the states of the clusters. If it is
1691 * part of a file, it has bit 2 set, in case of a directory, bit 1. If it
1692 * was modified, bit 3 is set.
1693 * If any cluster is allocated, but not part of a file or directory, this
1694 * driver refuses to commit.
1697 USED_DIRECTORY
= 1, USED_FILE
= 2, USED_ANY
= 3, USED_ALLOCATED
= 4
1701 * get_cluster_count_for_direntry() not only determines how many clusters
1702 * are occupied by direntry, but also if it was renamed or modified.
1704 * A file is thought to be renamed *only* if there already was a file with
1705 * exactly the same first cluster, but a different name.
1707 * Further, the files/directories handled by this function are
1708 * assumed to be *not* deleted (and *only* those).
1710 static uint32_t get_cluster_count_for_direntry(BDRVVVFATState
* s
,
1711 direntry_t
* direntry
, const char* path
)
1714 * This is a little bit tricky:
1715 * IF the guest OS just inserts a cluster into the file chain,
1716 * and leaves the rest alone, (i.e. the original file had clusters
1717 * 15 -> 16, but now has 15 -> 32 -> 16), then the following happens:
1719 * - do_commit will write the cluster into the file at the given
1722 * - the cluster which is overwritten should be moved to a later
1723 * position in the file.
1725 * I am not aware that any OS does something as braindead, but this
1726 * situation could happen anyway when not committing for a long time.
1727 * Just to be sure that this does not bite us, detect it, and copy the
1728 * contents of the clusters to-be-overwritten into the qcow.
1731 int was_modified
= 0;
1734 uint32_t cluster_num
= begin_of_direntry(direntry
);
1735 uint32_t offset
= 0;
1736 int first_mapping_index
= -1;
1737 mapping_t
* mapping
= NULL
;
1738 const char* basename2
= NULL
;
1740 vvfat_close_current_file(s
);
1742 /* the root directory */
1743 if (cluster_num
== 0)
1748 basename2
= get_basename(path
);
1750 mapping
= find_mapping_for_cluster(s
, cluster_num
);
1753 const char* basename
;
1755 assert(mapping
->mode
& MODE_DELETED
);
1756 mapping
->mode
&= ~MODE_DELETED
;
1758 basename
= get_basename(mapping
->path
);
1760 assert(mapping
->mode
& MODE_NORMAL
);
1763 if (strcmp(basename
, basename2
))
1764 schedule_rename(s
, cluster_num
, g_strdup(path
));
1765 } else if (is_file(direntry
))
1767 schedule_new_file(s
, g_strdup(path
), cluster_num
);
1776 if (!copy_it
&& cluster_was_modified(s
, cluster_num
)) {
1777 if (mapping
== NULL
||
1778 mapping
->begin
> cluster_num
||
1779 mapping
->end
<= cluster_num
)
1780 mapping
= find_mapping_for_cluster(s
, cluster_num
);
1784 (mapping
->mode
& MODE_DIRECTORY
) == 0) {
1786 /* was modified in qcow */
1787 if (offset
!= mapping
->info
.file
.offset
+ s
->cluster_size
1788 * (cluster_num
- mapping
->begin
)) {
1789 /* offset of this cluster in file chain has changed */
1792 } else if (offset
== 0) {
1793 const char* basename
= get_basename(mapping
->path
);
1795 if (strcmp(basename
, basename2
))
1797 first_mapping_index
= array_index(&(s
->mapping
), mapping
);
1800 if (mapping
->first_mapping_index
!= first_mapping_index
1801 && mapping
->info
.file
.offset
> 0) {
1806 /* need to write out? */
1807 if (!was_modified
&& is_file(direntry
)) {
1809 schedule_writeout(s
, mapping
->dir_index
, offset
);
1817 * This is horribly inefficient, but that is okay, since
1818 * it is rarely executed, if at all.
1820 int64_t offset
= cluster2sector(s
, cluster_num
);
1822 vvfat_close_current_file(s
);
1823 for (i
= 0; i
< s
->sectors_per_cluster
; i
++) {
1824 if (!bdrv_is_allocated(s
->qcow
, offset
+ i
, 1, &dummy
)) {
1825 if (vvfat_read(s
->bs
, offset
, s
->cluster_buffer
, 1)) {
1828 if (bdrv_write(s
->qcow
, offset
, s
->cluster_buffer
, 1)) {
1837 if (s
->used_clusters
[cluster_num
] & USED_ANY
)
1839 s
->used_clusters
[cluster_num
] = USED_FILE
;
1841 cluster_num
= modified_fat_get(s
, cluster_num
);
1843 if (fat_eof(s
, cluster_num
))
1845 else if (cluster_num
< 2 || cluster_num
> s
->max_fat_value
- 16)
1848 offset
+= s
->cluster_size
;
1853 * This function looks at the modified data (qcow).
1854 * It returns 0 upon inconsistency or error, and the number of clusters
1855 * used by the directory, its subdirectories and their files.
1857 static int check_directory_consistency(BDRVVVFATState
*s
,
1858 int cluster_num
, const char* path
)
1861 unsigned char* cluster
= g_malloc(s
->cluster_size
);
1862 direntry_t
* direntries
= (direntry_t
*)cluster
;
1863 mapping_t
* mapping
= find_mapping_for_cluster(s
, cluster_num
);
1866 int path_len
= strlen(path
);
1867 char path2
[PATH_MAX
+ 1];
1869 assert(path_len
< PATH_MAX
); /* len was tested before! */
1870 pstrcpy(path2
, sizeof(path2
), path
);
1871 path2
[path_len
] = '/';
1872 path2
[path_len
+ 1] = '\0';
1875 const char* basename
= get_basename(mapping
->path
);
1876 const char* basename2
= get_basename(path
);
1878 assert(mapping
->mode
& MODE_DIRECTORY
);
1880 assert(mapping
->mode
& MODE_DELETED
);
1881 mapping
->mode
&= ~MODE_DELETED
;
1883 if (strcmp(basename
, basename2
))
1884 schedule_rename(s
, cluster_num
, g_strdup(path
));
1887 schedule_mkdir(s
, cluster_num
, g_strdup(path
));
1896 if (s
->used_clusters
[cluster_num
] & USED_ANY
) {
1897 fprintf(stderr
, "cluster %d used more than once\n", (int)cluster_num
);
1900 s
->used_clusters
[cluster_num
] = USED_DIRECTORY
;
1902 DLOG(fprintf(stderr
, "read cluster %d (sector %d)\n", (int)cluster_num
, (int)cluster2sector(s
, cluster_num
)));
1903 subret
= vvfat_read(s
->bs
, cluster2sector(s
, cluster_num
), cluster
,
1904 s
->sectors_per_cluster
);
1906 fprintf(stderr
, "Error fetching direntries\n");
1912 for (i
= 0; i
< 0x10 * s
->sectors_per_cluster
; i
++) {
1913 int cluster_count
= 0;
1915 DLOG(fprintf(stderr
, "check direntry %d:\n", i
); print_direntry(direntries
+ i
));
1916 if (is_volume_label(direntries
+ i
) || is_dot(direntries
+ i
) ||
1917 is_free(direntries
+ i
))
1920 subret
= parse_long_name(&lfn
, direntries
+ i
);
1922 fprintf(stderr
, "Error in long name\n");
1925 if (subret
== 0 || is_free(direntries
+ i
))
1928 if (fat_chksum(direntries
+i
) != lfn
.checksum
) {
1929 subret
= parse_short_name(s
, &lfn
, direntries
+ i
);
1931 fprintf(stderr
, "Error in short name (%d)\n", subret
);
1934 if (subret
> 0 || !strcmp((char*)lfn
.name
, ".")
1935 || !strcmp((char*)lfn
.name
, ".."))
1938 lfn
.checksum
= 0x100; /* cannot use long name twice */
1940 if (path_len
+ 1 + lfn
.len
>= PATH_MAX
) {
1941 fprintf(stderr
, "Name too long: %s/%s\n", path
, lfn
.name
);
1944 pstrcpy(path2
+ path_len
+ 1, sizeof(path2
) - path_len
- 1,
1947 if (is_directory(direntries
+ i
)) {
1948 if (begin_of_direntry(direntries
+ i
) == 0) {
1949 DLOG(fprintf(stderr
, "invalid begin for directory: %s\n", path2
); print_direntry(direntries
+ i
));
1952 cluster_count
= check_directory_consistency(s
,
1953 begin_of_direntry(direntries
+ i
), path2
);
1954 if (cluster_count
== 0) {
1955 DLOG(fprintf(stderr
, "problem in directory %s:\n", path2
); print_direntry(direntries
+ i
));
1958 } else if (is_file(direntries
+ i
)) {
1959 /* check file size with FAT */
1960 cluster_count
= get_cluster_count_for_direntry(s
, direntries
+ i
, path2
);
1961 if (cluster_count
!=
1962 (le32_to_cpu(direntries
[i
].size
) + s
->cluster_size
1963 - 1) / s
->cluster_size
) {
1964 DLOG(fprintf(stderr
, "Cluster count mismatch\n"));
1968 abort(); /* cluster_count = 0; */
1970 ret
+= cluster_count
;
1973 cluster_num
= modified_fat_get(s
, cluster_num
);
1974 } while(!fat_eof(s
, cluster_num
));
1980 /* returns 1 on success */
1981 static int is_consistent(BDRVVVFATState
* s
)
1984 int used_clusters_count
= 0;
1988 * - get modified FAT
1989 * - compare the two FATs (TODO)
1990 * - get buffer for marking used clusters
1991 * - recurse direntries from root (using bs->bdrv_read to make
1992 * sure to get the new data)
1993 * - check that the FAT agrees with the size
1994 * - count the number of clusters occupied by this directory and
1996 * - check that the cumulative used cluster count agrees with the
1998 * - if all is fine, return number of used clusters
2000 if (s
->fat2
== NULL
) {
2001 int size
= 0x200 * s
->sectors_per_fat
;
2002 s
->fat2
= g_malloc(size
);
2003 memcpy(s
->fat2
, s
->fat
.pointer
, size
);
2005 check
= vvfat_read(s
->bs
,
2006 s
->first_sectors_number
, s
->fat2
, s
->sectors_per_fat
);
2008 fprintf(stderr
, "Could not copy fat\n");
2011 assert (s
->used_clusters
);
2012 for (i
= 0; i
< sector2cluster(s
, s
->sector_count
); i
++)
2013 s
->used_clusters
[i
] &= ~USED_ANY
;
2017 /* mark every mapped file/directory as deleted.
2018 * (check_directory_consistency() will unmark those still present). */
2020 for (i
= 0; i
< s
->mapping
.next
; i
++) {
2021 mapping_t
* mapping
= array_get(&(s
->mapping
), i
);
2022 if (mapping
->first_mapping_index
< 0)
2023 mapping
->mode
|= MODE_DELETED
;
2026 used_clusters_count
= check_directory_consistency(s
, 0, s
->path
);
2027 if (used_clusters_count
<= 0) {
2028 DLOG(fprintf(stderr
, "problem in directory\n"));
2032 check
= s
->last_cluster_of_root_directory
;
2033 for (i
= check
; i
< sector2cluster(s
, s
->sector_count
); i
++) {
2034 if (modified_fat_get(s
, i
)) {
2035 if(!s
->used_clusters
[i
]) {
2036 DLOG(fprintf(stderr
, "FAT was modified (%d), but cluster is not used?\n", i
));
2042 if (s
->used_clusters
[i
] == USED_ALLOCATED
) {
2043 /* allocated, but not used... */
2044 DLOG(fprintf(stderr
, "unused, modified cluster: %d\n", i
));
2049 if (check
!= used_clusters_count
)
2052 return used_clusters_count
;
2055 static inline void adjust_mapping_indices(BDRVVVFATState
* s
,
2056 int offset
, int adjust
)
2060 for (i
= 0; i
< s
->mapping
.next
; i
++) {
2061 mapping_t
* mapping
= array_get(&(s
->mapping
), i
);
2063 #define ADJUST_MAPPING_INDEX(name) \
2064 if (mapping->name >= offset) \
2065 mapping->name += adjust
2067 ADJUST_MAPPING_INDEX(first_mapping_index
);
2068 if (mapping
->mode
& MODE_DIRECTORY
)
2069 ADJUST_MAPPING_INDEX(info
.dir
.parent_mapping_index
);
2073 /* insert or update mapping */
2074 static mapping_t
* insert_mapping(BDRVVVFATState
* s
,
2075 uint32_t begin
, uint32_t end
)
2078 * - find mapping where mapping->begin >= begin,
2079 * - if mapping->begin > begin: insert
2080 * - adjust all references to mappings!
2084 int index
= find_mapping_for_cluster_aux(s
, begin
, 0, s
->mapping
.next
);
2085 mapping_t
* mapping
= NULL
;
2086 mapping_t
* first_mapping
= array_get(&(s
->mapping
), 0);
2088 if (index
< s
->mapping
.next
&& (mapping
= array_get(&(s
->mapping
), index
))
2089 && mapping
->begin
< begin
) {
2090 mapping
->end
= begin
;
2092 mapping
= array_get(&(s
->mapping
), index
);
2094 if (index
>= s
->mapping
.next
|| mapping
->begin
> begin
) {
2095 mapping
= array_insert(&(s
->mapping
), index
, 1);
2096 mapping
->path
= NULL
;
2097 adjust_mapping_indices(s
, index
, +1);
2100 mapping
->begin
= begin
;
2103 DLOG(mapping_t
* next_mapping
;
2104 assert(index
+ 1 >= s
->mapping
.next
||
2105 ((next_mapping
= array_get(&(s
->mapping
), index
+ 1)) &&
2106 next_mapping
->begin
>= end
)));
2108 if (s
->current_mapping
&& first_mapping
!= (mapping_t
*)s
->mapping
.pointer
)
2109 s
->current_mapping
= array_get(&(s
->mapping
),
2110 s
->current_mapping
- first_mapping
);
2115 static int remove_mapping(BDRVVVFATState
* s
, int mapping_index
)
2117 mapping_t
* mapping
= array_get(&(s
->mapping
), mapping_index
);
2118 mapping_t
* first_mapping
= array_get(&(s
->mapping
), 0);
2121 if (mapping
->first_mapping_index
< 0) {
2122 g_free(mapping
->path
);
2125 /* remove from s->mapping */
2126 array_remove(&(s
->mapping
), mapping_index
);
2128 /* adjust all references to mappings */
2129 adjust_mapping_indices(s
, mapping_index
, -1);
2131 if (s
->current_mapping
&& first_mapping
!= (mapping_t
*)s
->mapping
.pointer
)
2132 s
->current_mapping
= array_get(&(s
->mapping
),
2133 s
->current_mapping
- first_mapping
);
2138 static void adjust_dirindices(BDRVVVFATState
* s
, int offset
, int adjust
)
2141 for (i
= 0; i
< s
->mapping
.next
; i
++) {
2142 mapping_t
* mapping
= array_get(&(s
->mapping
), i
);
2143 if (mapping
->dir_index
>= offset
)
2144 mapping
->dir_index
+= adjust
;
2145 if ((mapping
->mode
& MODE_DIRECTORY
) &&
2146 mapping
->info
.dir
.first_dir_index
>= offset
)
2147 mapping
->info
.dir
.first_dir_index
+= adjust
;
2151 static direntry_t
* insert_direntries(BDRVVVFATState
* s
,
2152 int dir_index
, int count
)
2155 * make room in s->directory,
2158 direntry_t
* result
= array_insert(&(s
->directory
), dir_index
, count
);
2161 adjust_dirindices(s
, dir_index
, count
);
2165 static int remove_direntries(BDRVVVFATState
* s
, int dir_index
, int count
)
2167 int ret
= array_remove_slice(&(s
->directory
), dir_index
, count
);
2170 adjust_dirindices(s
, dir_index
, -count
);
2175 * Adapt the mappings of the cluster chain starting at first cluster
2176 * (i.e. if a file starts at first_cluster, the chain is followed according
2177 * to the modified fat, and the corresponding entries in s->mapping are
2180 static int commit_mappings(BDRVVVFATState
* s
,
2181 uint32_t first_cluster
, int dir_index
)
2183 mapping_t
* mapping
= find_mapping_for_cluster(s
, first_cluster
);
2184 direntry_t
* direntry
= array_get(&(s
->directory
), dir_index
);
2185 uint32_t cluster
= first_cluster
;
2187 vvfat_close_current_file(s
);
2190 assert(mapping
->begin
== first_cluster
);
2191 mapping
->first_mapping_index
= -1;
2192 mapping
->dir_index
= dir_index
;
2193 mapping
->mode
= (dir_index
<= 0 || is_directory(direntry
)) ?
2194 MODE_DIRECTORY
: MODE_NORMAL
;
2196 while (!fat_eof(s
, cluster
)) {
2199 for (c
= cluster
, c1
= modified_fat_get(s
, c
); c
+ 1 == c1
;
2200 c
= c1
, c1
= modified_fat_get(s
, c1
));
2203 if (c
> mapping
->end
) {
2204 int index
= array_index(&(s
->mapping
), mapping
);
2205 int i
, max_i
= s
->mapping
.next
- index
;
2206 for (i
= 1; i
< max_i
&& mapping
[i
].begin
< c
; i
++);
2208 remove_mapping(s
, index
+ 1);
2210 assert(mapping
== array_get(&(s
->mapping
), s
->mapping
.next
- 1)
2211 || mapping
[1].begin
>= c
);
2214 if (!fat_eof(s
, c1
)) {
2215 int i
= find_mapping_for_cluster_aux(s
, c1
, 0, s
->mapping
.next
);
2216 mapping_t
* next_mapping
= i
>= s
->mapping
.next
? NULL
:
2217 array_get(&(s
->mapping
), i
);
2219 if (next_mapping
== NULL
|| next_mapping
->begin
> c1
) {
2220 int i1
= array_index(&(s
->mapping
), mapping
);
2222 next_mapping
= insert_mapping(s
, c1
, c1
+1);
2226 mapping
= array_get(&(s
->mapping
), i1
);
2229 next_mapping
->dir_index
= mapping
->dir_index
;
2230 next_mapping
->first_mapping_index
=
2231 mapping
->first_mapping_index
< 0 ?
2232 array_index(&(s
->mapping
), mapping
) :
2233 mapping
->first_mapping_index
;
2234 next_mapping
->path
= mapping
->path
;
2235 next_mapping
->mode
= mapping
->mode
;
2236 next_mapping
->read_only
= mapping
->read_only
;
2237 if (mapping
->mode
& MODE_DIRECTORY
) {
2238 next_mapping
->info
.dir
.parent_mapping_index
=
2239 mapping
->info
.dir
.parent_mapping_index
;
2240 next_mapping
->info
.dir
.first_dir_index
=
2241 mapping
->info
.dir
.first_dir_index
+
2242 0x10 * s
->sectors_per_cluster
*
2243 (mapping
->end
- mapping
->begin
);
2245 next_mapping
->info
.file
.offset
= mapping
->info
.file
.offset
+
2246 mapping
->end
- mapping
->begin
;
2248 mapping
= next_mapping
;
2257 static int commit_direntries(BDRVVVFATState
* s
,
2258 int dir_index
, int parent_mapping_index
)
2260 direntry_t
* direntry
= array_get(&(s
->directory
), dir_index
);
2261 uint32_t first_cluster
= dir_index
== 0 ? 0 : begin_of_direntry(direntry
);
2262 mapping_t
* mapping
= find_mapping_for_cluster(s
, first_cluster
);
2264 int factor
= 0x10 * s
->sectors_per_cluster
;
2265 int old_cluster_count
, new_cluster_count
;
2266 int current_dir_index
= mapping
->info
.dir
.first_dir_index
;
2267 int first_dir_index
= current_dir_index
;
2271 DLOG(fprintf(stderr
, "commit_direntries for %s, parent_mapping_index %d\n", mapping
->path
, parent_mapping_index
));
2275 assert(mapping
->begin
== first_cluster
);
2276 assert(mapping
->info
.dir
.first_dir_index
< s
->directory
.next
);
2277 assert(mapping
->mode
& MODE_DIRECTORY
);
2278 assert(dir_index
== 0 || is_directory(direntry
));
2280 mapping
->info
.dir
.parent_mapping_index
= parent_mapping_index
;
2282 if (first_cluster
== 0) {
2283 old_cluster_count
= new_cluster_count
=
2284 s
->last_cluster_of_root_directory
;
2286 for (old_cluster_count
= 0, c
= first_cluster
; !fat_eof(s
, c
);
2288 old_cluster_count
++;
2290 for (new_cluster_count
= 0, c
= first_cluster
; !fat_eof(s
, c
);
2291 c
= modified_fat_get(s
, c
))
2292 new_cluster_count
++;
2295 if (new_cluster_count
> old_cluster_count
) {
2296 if (insert_direntries(s
,
2297 current_dir_index
+ factor
* old_cluster_count
,
2298 factor
* (new_cluster_count
- old_cluster_count
)) == NULL
)
2300 } else if (new_cluster_count
< old_cluster_count
)
2301 remove_direntries(s
,
2302 current_dir_index
+ factor
* new_cluster_count
,
2303 factor
* (old_cluster_count
- new_cluster_count
));
2305 for (c
= first_cluster
; !fat_eof(s
, c
); c
= modified_fat_get(s
, c
)) {
2306 direntry_t
*first_direntry
;
2307 void* direntry
= array_get(&(s
->directory
), current_dir_index
);
2308 int ret
= vvfat_read(s
->bs
, cluster2sector(s
, c
), direntry
,
2309 s
->sectors_per_cluster
);
2313 /* The first directory entry on the filesystem is the volume name */
2314 first_direntry
= (direntry_t
*) s
->directory
.pointer
;
2315 assert(!memcmp(first_direntry
->name
, s
->volume_label
, 11));
2317 current_dir_index
+= factor
;
2320 ret
= commit_mappings(s
, first_cluster
, dir_index
);
2325 for (i
= 0; i
< factor
* new_cluster_count
; i
++) {
2326 direntry
= array_get(&(s
->directory
), first_dir_index
+ i
);
2327 if (is_directory(direntry
) && !is_dot(direntry
)) {
2328 mapping
= find_mapping_for_cluster(s
, first_cluster
);
2329 assert(mapping
->mode
& MODE_DIRECTORY
);
2330 ret
= commit_direntries(s
, first_dir_index
+ i
,
2331 array_index(&(s
->mapping
), mapping
));
2340 /* commit one file (adjust contents, adjust mapping),
2341 return first_mapping_index */
2342 static int commit_one_file(BDRVVVFATState
* s
,
2343 int dir_index
, uint32_t offset
)
2345 direntry_t
* direntry
= array_get(&(s
->directory
), dir_index
);
2346 uint32_t c
= begin_of_direntry(direntry
);
2347 uint32_t first_cluster
= c
;
2348 mapping_t
* mapping
= find_mapping_for_cluster(s
, c
);
2349 uint32_t size
= filesize_of_direntry(direntry
);
2350 char* cluster
= g_malloc(s
->cluster_size
);
2354 assert(offset
< size
);
2355 assert((offset
% s
->cluster_size
) == 0);
2357 for (i
= s
->cluster_size
; i
< offset
; i
+= s
->cluster_size
)
2358 c
= modified_fat_get(s
, c
);
2360 fd
= qemu_open(mapping
->path
, O_RDWR
| O_CREAT
| O_BINARY
, 0666);
2362 fprintf(stderr
, "Could not open %s... (%s, %d)\n", mapping
->path
,
2363 strerror(errno
), errno
);
2368 if (lseek(fd
, offset
, SEEK_SET
) != offset
) {
2375 while (offset
< size
) {
2377 int rest_size
= (size
- offset
> s
->cluster_size
?
2378 s
->cluster_size
: size
- offset
);
2381 c1
= modified_fat_get(s
, c
);
2383 assert((size
- offset
== 0 && fat_eof(s
, c
)) ||
2384 (size
> offset
&& c
>=2 && !fat_eof(s
, c
)));
2386 ret
= vvfat_read(s
->bs
, cluster2sector(s
, c
),
2387 (uint8_t*)cluster
, (rest_size
+ 0x1ff) / 0x200);
2395 if (write(fd
, cluster
, rest_size
) < 0) {
2401 offset
+= rest_size
;
2405 if (ftruncate(fd
, size
)) {
2406 perror("ftruncate()");
2414 return commit_mappings(s
, first_cluster
, dir_index
);
2418 /* test, if all mappings point to valid direntries */
2419 static void check1(BDRVVVFATState
* s
)
2422 for (i
= 0; i
< s
->mapping
.next
; i
++) {
2423 mapping_t
* mapping
= array_get(&(s
->mapping
), i
);
2424 if (mapping
->mode
& MODE_DELETED
) {
2425 fprintf(stderr
, "deleted\n");
2428 assert(mapping
->dir_index
< s
->directory
.next
);
2429 direntry_t
* direntry
= array_get(&(s
->directory
), mapping
->dir_index
);
2430 assert(mapping
->begin
== begin_of_direntry(direntry
) || mapping
->first_mapping_index
>= 0);
2431 if (mapping
->mode
& MODE_DIRECTORY
) {
2432 assert(mapping
->info
.dir
.first_dir_index
+ 0x10 * s
->sectors_per_cluster
* (mapping
->end
- mapping
->begin
) <= s
->directory
.next
);
2433 assert((mapping
->info
.dir
.first_dir_index
% (0x10 * s
->sectors_per_cluster
)) == 0);
2438 /* test, if all direntries have mappings */
2439 static void check2(BDRVVVFATState
* s
)
2442 int first_mapping
= -1;
2444 for (i
= 0; i
< s
->directory
.next
; i
++) {
2445 direntry_t
* direntry
= array_get(&(s
->directory
), i
);
2447 if (is_short_name(direntry
) && begin_of_direntry(direntry
)) {
2448 mapping_t
* mapping
= find_mapping_for_cluster(s
, begin_of_direntry(direntry
));
2450 assert(mapping
->dir_index
== i
|| is_dot(direntry
));
2451 assert(mapping
->begin
== begin_of_direntry(direntry
) || is_dot(direntry
));
2454 if ((i
% (0x10 * s
->sectors_per_cluster
)) == 0) {
2458 for (j
= 0; j
< s
->mapping
.next
; j
++) {
2459 mapping_t
* mapping
= array_get(&(s
->mapping
), j
);
2460 if (mapping
->mode
& MODE_DELETED
)
2462 if (mapping
->mode
& MODE_DIRECTORY
) {
2463 if (mapping
->info
.dir
.first_dir_index
<= i
&& mapping
->info
.dir
.first_dir_index
+ 0x10 * s
->sectors_per_cluster
> i
) {
2464 assert(++count
== 1);
2465 if (mapping
->first_mapping_index
== -1)
2466 first_mapping
= array_index(&(s
->mapping
), mapping
);
2468 assert(first_mapping
== mapping
->first_mapping_index
);
2469 if (mapping
->info
.dir
.parent_mapping_index
< 0)
2472 mapping_t
* parent
= array_get(&(s
->mapping
), mapping
->info
.dir
.parent_mapping_index
);
2473 assert(parent
->mode
& MODE_DIRECTORY
);
2474 assert(parent
->info
.dir
.first_dir_index
< mapping
->info
.dir
.first_dir_index
);
2486 static int handle_renames_and_mkdirs(BDRVVVFATState
* s
)
2491 fprintf(stderr
, "handle_renames\n");
2492 for (i
= 0; i
< s
->commits
.next
; i
++) {
2493 commit_t
* commit
= array_get(&(s
->commits
), i
);
2494 fprintf(stderr
, "%d, %s (%d, %d)\n", i
, commit
->path
? commit
->path
: "(null)", commit
->param
.rename
.cluster
, commit
->action
);
2498 for (i
= 0; i
< s
->commits
.next
;) {
2499 commit_t
* commit
= array_get(&(s
->commits
), i
);
2500 if (commit
->action
== ACTION_RENAME
) {
2501 mapping_t
* mapping
= find_mapping_for_cluster(s
,
2502 commit
->param
.rename
.cluster
);
2503 char* old_path
= mapping
->path
;
2505 assert(commit
->path
);
2506 mapping
->path
= commit
->path
;
2507 if (rename(old_path
, mapping
->path
))
2510 if (mapping
->mode
& MODE_DIRECTORY
) {
2511 int l1
= strlen(mapping
->path
);
2512 int l2
= strlen(old_path
);
2514 direntry_t
* direntry
= array_get(&(s
->directory
),
2515 mapping
->info
.dir
.first_dir_index
);
2516 uint32_t c
= mapping
->begin
;
2520 while (!fat_eof(s
, c
)) {
2522 direntry_t
* d
= direntry
+ i
;
2524 if (is_file(d
) || (is_directory(d
) && !is_dot(d
))) {
2525 mapping_t
* m
= find_mapping_for_cluster(s
,
2526 begin_of_direntry(d
));
2527 int l
= strlen(m
->path
);
2528 char* new_path
= g_malloc(l
+ diff
+ 1);
2530 assert(!strncmp(m
->path
, mapping
->path
, l2
));
2532 pstrcpy(new_path
, l
+ diff
+ 1, mapping
->path
);
2533 pstrcpy(new_path
+ l1
, l
+ diff
+ 1 - l1
,
2536 schedule_rename(s
, m
->begin
, new_path
);
2539 } while((i
% (0x10 * s
->sectors_per_cluster
)) != 0);
2545 array_remove(&(s
->commits
), i
);
2547 } else if (commit
->action
== ACTION_MKDIR
) {
2549 int j
, parent_path_len
;
2552 if (mkdir(commit
->path
))
2555 if (mkdir(commit
->path
, 0755))
2559 mapping
= insert_mapping(s
, commit
->param
.mkdir
.cluster
,
2560 commit
->param
.mkdir
.cluster
+ 1);
2561 if (mapping
== NULL
)
2564 mapping
->mode
= MODE_DIRECTORY
;
2565 mapping
->read_only
= 0;
2566 mapping
->path
= commit
->path
;
2567 j
= s
->directory
.next
;
2569 insert_direntries(s
, s
->directory
.next
,
2570 0x10 * s
->sectors_per_cluster
);
2571 mapping
->info
.dir
.first_dir_index
= j
;
2573 parent_path_len
= strlen(commit
->path
)
2574 - strlen(get_basename(commit
->path
)) - 1;
2575 for (j
= 0; j
< s
->mapping
.next
; j
++) {
2576 mapping_t
* m
= array_get(&(s
->mapping
), j
);
2577 if (m
->first_mapping_index
< 0 && m
!= mapping
&&
2578 !strncmp(m
->path
, mapping
->path
, parent_path_len
) &&
2579 strlen(m
->path
) == parent_path_len
)
2582 assert(j
< s
->mapping
.next
);
2583 mapping
->info
.dir
.parent_mapping_index
= j
;
2585 array_remove(&(s
->commits
), i
);
2595 * TODO: make sure that the short name is not matching *another* file
2597 static int handle_commits(BDRVVVFATState
* s
)
2601 vvfat_close_current_file(s
);
2603 for (i
= 0; !fail
&& i
< s
->commits
.next
; i
++) {
2604 commit_t
* commit
= array_get(&(s
->commits
), i
);
2605 switch(commit
->action
) {
2606 case ACTION_RENAME
: case ACTION_MKDIR
:
2610 case ACTION_WRITEOUT
: {
2612 /* these variables are only used by assert() below */
2613 direntry_t
* entry
= array_get(&(s
->directory
),
2614 commit
->param
.writeout
.dir_index
);
2615 uint32_t begin
= begin_of_direntry(entry
);
2616 mapping_t
* mapping
= find_mapping_for_cluster(s
, begin
);
2620 assert(mapping
->begin
== begin
);
2621 assert(commit
->path
== NULL
);
2623 if (commit_one_file(s
, commit
->param
.writeout
.dir_index
,
2624 commit
->param
.writeout
.modified_offset
))
2629 case ACTION_NEW_FILE
: {
2630 int begin
= commit
->param
.new_file
.first_cluster
;
2631 mapping_t
* mapping
= find_mapping_for_cluster(s
, begin
);
2636 for (i
= 0; i
< s
->directory
.next
; i
++) {
2637 entry
= array_get(&(s
->directory
), i
);
2638 if (is_file(entry
) && begin_of_direntry(entry
) == begin
)
2642 if (i
>= s
->directory
.next
) {
2647 /* make sure there exists an initial mapping */
2648 if (mapping
&& mapping
->begin
!= begin
) {
2649 mapping
->end
= begin
;
2652 if (mapping
== NULL
) {
2653 mapping
= insert_mapping(s
, begin
, begin
+1);
2655 /* most members will be fixed in commit_mappings() */
2656 assert(commit
->path
);
2657 mapping
->path
= commit
->path
;
2658 mapping
->read_only
= 0;
2659 mapping
->mode
= MODE_NORMAL
;
2660 mapping
->info
.file
.offset
= 0;
2662 if (commit_one_file(s
, i
, 0))
2671 if (i
> 0 && array_remove_slice(&(s
->commits
), 0, i
))
2676 static int handle_deletes(BDRVVVFATState
* s
)
2678 int i
, deferred
= 1, deleted
= 1;
2680 /* delete files corresponding to mappings marked as deleted */
2681 /* handle DELETEs and unused mappings (modified_fat_get(s, mapping->begin) == 0) */
2682 while (deferred
&& deleted
) {
2686 for (i
= 1; i
< s
->mapping
.next
; i
++) {
2687 mapping_t
* mapping
= array_get(&(s
->mapping
), i
);
2688 if (mapping
->mode
& MODE_DELETED
) {
2689 direntry_t
* entry
= array_get(&(s
->directory
),
2690 mapping
->dir_index
);
2692 if (is_free(entry
)) {
2693 /* remove file/directory */
2694 if (mapping
->mode
& MODE_DIRECTORY
) {
2695 int j
, next_dir_index
= s
->directory
.next
,
2696 first_dir_index
= mapping
->info
.dir
.first_dir_index
;
2698 if (rmdir(mapping
->path
) < 0) {
2699 if (errno
== ENOTEMPTY
) {
2706 for (j
= 1; j
< s
->mapping
.next
; j
++) {
2707 mapping_t
* m
= array_get(&(s
->mapping
), j
);
2708 if (m
->mode
& MODE_DIRECTORY
&&
2709 m
->info
.dir
.first_dir_index
>
2711 m
->info
.dir
.first_dir_index
<
2714 m
->info
.dir
.first_dir_index
;
2716 remove_direntries(s
, first_dir_index
,
2717 next_dir_index
- first_dir_index
);
2722 if (unlink(mapping
->path
))
2726 DLOG(fprintf(stderr
, "DELETE (%d)\n", i
); print_mapping(mapping
); print_direntry(entry
));
2727 remove_mapping(s
, i
);
2736 * synchronize mapping with new state:
2738 * - copy FAT (with bdrv_read)
2739 * - mark all filenames corresponding to mappings as deleted
2740 * - recurse direntries from root (using bs->bdrv_read)
2741 * - delete files corresponding to mappings marked as deleted
2743 static int do_commit(BDRVVVFATState
* s
)
2747 /* the real meat are the commits. Nothing to do? Move along! */
2748 if (s
->commits
.next
== 0)
2751 vvfat_close_current_file(s
);
2753 ret
= handle_renames_and_mkdirs(s
);
2755 fprintf(stderr
, "Error handling renames (%d)\n", ret
);
2760 /* copy FAT (with bdrv_read) */
2761 memcpy(s
->fat
.pointer
, s
->fat2
, 0x200 * s
->sectors_per_fat
);
2763 /* recurse direntries from root (using bs->bdrv_read) */
2764 ret
= commit_direntries(s
, 0, -1);
2766 fprintf(stderr
, "Fatal: error while committing (%d)\n", ret
);
2771 ret
= handle_commits(s
);
2773 fprintf(stderr
, "Error handling commits (%d)\n", ret
);
2778 ret
= handle_deletes(s
);
2780 fprintf(stderr
, "Error deleting\n");
2785 if (s
->qcow
->drv
->bdrv_make_empty
) {
2786 s
->qcow
->drv
->bdrv_make_empty(s
->qcow
);
2789 memset(s
->used_clusters
, 0, sector2cluster(s
, s
->sector_count
));
2795 static int try_commit(BDRVVVFATState
* s
)
2797 vvfat_close_current_file(s
);
2799 if(!is_consistent(s
))
2801 return do_commit(s
);
2804 static int vvfat_write(BlockDriverState
*bs
, int64_t sector_num
,
2805 const uint8_t *buf
, int nb_sectors
)
2807 BDRVVVFATState
*s
= bs
->opaque
;
2812 /* Check if we're operating in read-only mode */
2813 if (s
->qcow
== NULL
) {
2817 vvfat_close_current_file(s
);
2820 * Some sanity checks:
2821 * - do not allow writing to the boot sector
2822 * - do not allow to write non-ASCII filenames
2825 if (sector_num
< s
->first_sectors_number
)
2828 for (i
= sector2cluster(s
, sector_num
);
2829 i
<= sector2cluster(s
, sector_num
+ nb_sectors
- 1);) {
2830 mapping_t
* mapping
= find_mapping_for_cluster(s
, i
);
2832 if (mapping
->read_only
) {
2833 fprintf(stderr
, "Tried to write to write-protected file %s\n",
2838 if (mapping
->mode
& MODE_DIRECTORY
) {
2839 int begin
= cluster2sector(s
, i
);
2840 int end
= begin
+ s
->sectors_per_cluster
, k
;
2842 const direntry_t
* direntries
;
2847 if (begin
< sector_num
)
2849 if (end
> sector_num
+ nb_sectors
)
2850 end
= sector_num
+ nb_sectors
;
2851 dir_index
= mapping
->dir_index
+
2852 0x10 * (begin
- mapping
->begin
* s
->sectors_per_cluster
);
2853 direntries
= (direntry_t
*)(buf
+ 0x200 * (begin
- sector_num
));
2855 for (k
= 0; k
< (end
- begin
) * 0x10; k
++) {
2856 /* do not allow non-ASCII filenames */
2857 if (parse_long_name(&lfn
, direntries
+ k
) < 0) {
2858 fprintf(stderr
, "Warning: non-ASCII filename\n");
2861 /* no access to the direntry of a read-only file */
2862 else if (is_short_name(direntries
+k
) &&
2863 (direntries
[k
].attributes
& 1)) {
2864 if (memcmp(direntries
+ k
,
2865 array_get(&(s
->directory
), dir_index
+ k
),
2866 sizeof(direntry_t
))) {
2867 fprintf(stderr
, "Warning: tried to write to write-protected file\n");
2879 * Use qcow backend. Commit later.
2881 DLOG(fprintf(stderr
, "Write to qcow backend: %d + %d\n", (int)sector_num
, nb_sectors
));
2882 ret
= bdrv_write(s
->qcow
, sector_num
, buf
, nb_sectors
);
2884 fprintf(stderr
, "Error writing to qcow backend\n");
2888 for (i
= sector2cluster(s
, sector_num
);
2889 i
<= sector2cluster(s
, sector_num
+ nb_sectors
- 1); i
++)
2891 s
->used_clusters
[i
] |= USED_ALLOCATED
;
2894 /* TODO: add timeout */
2901 static int coroutine_fn
2902 vvfat_co_pwritev(BlockDriverState
*bs
, uint64_t offset
, uint64_t bytes
,
2903 QEMUIOVector
*qiov
, int flags
)
2906 BDRVVVFATState
*s
= bs
->opaque
;
2907 uint64_t sector_num
= offset
>> BDRV_SECTOR_BITS
;
2908 int nb_sectors
= bytes
>> BDRV_SECTOR_BITS
;
2911 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
2912 assert((bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
2914 buf
= g_try_malloc(bytes
);
2915 if (bytes
&& buf
== NULL
) {
2918 qemu_iovec_to_buf(qiov
, 0, buf
, bytes
);
2920 qemu_co_mutex_lock(&s
->lock
);
2921 ret
= vvfat_write(bs
, sector_num
, buf
, nb_sectors
);
2922 qemu_co_mutex_unlock(&s
->lock
);
2929 static int64_t coroutine_fn
vvfat_co_get_block_status(BlockDriverState
*bs
,
2930 int64_t sector_num
, int nb_sectors
, int *n
, BlockDriverState
**file
)
2932 BDRVVVFATState
* s
= bs
->opaque
;
2933 *n
= s
->sector_count
- sector_num
;
2934 if (*n
> nb_sectors
) {
2936 } else if (*n
< 0) {
2939 return BDRV_BLOCK_DATA
;
2942 static int coroutine_fn
2943 write_target_commit(BlockDriverState
*bs
, uint64_t offset
, uint64_t bytes
,
2944 QEMUIOVector
*qiov
, int flags
)
2946 BDRVVVFATState
* s
= *((BDRVVVFATState
**) bs
->opaque
);
2947 return try_commit(s
);
2950 static void write_target_close(BlockDriverState
*bs
) {
2951 BDRVVVFATState
* s
= *((BDRVVVFATState
**) bs
->opaque
);
2952 bdrv_unref(s
->qcow
);
2953 g_free(s
->qcow_filename
);
2956 static BlockDriver vvfat_write_target
= {
2957 .format_name
= "vvfat_write_target",
2958 .bdrv_co_pwritev
= write_target_commit
,
2959 .bdrv_close
= write_target_close
,
2962 static int enable_write_target(BDRVVVFATState
*s
, Error
**errp
)
2964 BlockDriver
*bdrv_qcow
= NULL
;
2965 BlockDriverState
*backing
;
2966 QemuOpts
*opts
= NULL
;
2968 int size
= sector2cluster(s
, s
->sector_count
);
2971 s
->used_clusters
= calloc(size
, 1);
2973 array_init(&(s
->commits
), sizeof(commit_t
));
2975 s
->qcow_filename
= g_malloc(PATH_MAX
);
2976 ret
= get_tmp_filename(s
->qcow_filename
, PATH_MAX
);
2978 error_setg_errno(errp
, -ret
, "can't create temporary file");
2982 bdrv_qcow
= bdrv_find_format("qcow");
2984 error_setg(errp
, "Failed to locate qcow driver");
2989 opts
= qemu_opts_create(bdrv_qcow
->create_opts
, NULL
, 0, &error_abort
);
2990 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, s
->sector_count
* 512,
2992 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FILE
, "fat:", &error_abort
);
2994 ret
= bdrv_create(bdrv_qcow
, s
->qcow_filename
, opts
, errp
);
2995 qemu_opts_del(opts
);
3001 options
= qdict_new();
3002 qdict_put(options
, "driver", qstring_from_str("qcow"));
3003 ret
= bdrv_open(&s
->qcow
, s
->qcow_filename
, NULL
, options
,
3004 BDRV_O_RDWR
| BDRV_O_NO_FLUSH
, errp
);
3010 unlink(s
->qcow_filename
);
3013 backing
= bdrv_new();
3014 bdrv_set_backing_hd(s
->bs
, backing
);
3015 bdrv_unref(backing
);
3017 s
->bs
->backing
->bs
->drv
= &vvfat_write_target
;
3018 s
->bs
->backing
->bs
->opaque
= g_new(void *, 1);
3019 *(void**)s
->bs
->backing
->bs
->opaque
= s
;
3024 g_free(s
->qcow_filename
);
3025 s
->qcow_filename
= NULL
;
3029 static void vvfat_close(BlockDriverState
*bs
)
3031 BDRVVVFATState
*s
= bs
->opaque
;
3033 vvfat_close_current_file(s
);
3034 array_free(&(s
->fat
));
3035 array_free(&(s
->directory
));
3036 array_free(&(s
->mapping
));
3037 g_free(s
->cluster_buffer
);
3040 migrate_del_blocker(s
->migration_blocker
);
3041 error_free(s
->migration_blocker
);
3045 static BlockDriver bdrv_vvfat
= {
3046 .format_name
= "vvfat",
3047 .protocol_name
= "fat",
3048 .instance_size
= sizeof(BDRVVVFATState
),
3050 .bdrv_parse_filename
= vvfat_parse_filename
,
3051 .bdrv_file_open
= vvfat_open
,
3052 .bdrv_close
= vvfat_close
,
3054 .bdrv_co_preadv
= vvfat_co_preadv
,
3055 .bdrv_co_pwritev
= vvfat_co_pwritev
,
3056 .bdrv_co_get_block_status
= vvfat_co_get_block_status
,
3059 static void bdrv_vvfat_init(void)
3061 bdrv_register(&bdrv_vvfat
);
3064 block_init(bdrv_vvfat_init
);
3067 static void checkpoint(void) {
3068 assert(((mapping_t
*)array_get(&(vvv
->mapping
), 0))->end
== 2);
3071 assert(!vvv
->current_mapping
|| vvv
->current_fd
|| (vvv
->current_mapping
->mode
& MODE_DIRECTORY
));
3073 if (((direntry_t
*)vvv
->directory
.pointer
)[1].attributes
!= 0xf)
3074 fprintf(stderr
, "Nonono!\n");
3076 direntry_t
* direntry
;
3077 assert(vvv
->mapping
.size
>= vvv
->mapping
.item_size
* vvv
->mapping
.next
);
3078 assert(vvv
->directory
.size
>= vvv
->directory
.item_size
* vvv
->directory
.next
);
3079 if (vvv
->mapping
.next
<47)
3081 assert((mapping
= array_get(&(vvv
->mapping
), 47)));
3082 assert(mapping
->dir_index
< vvv
->directory
.next
);
3083 direntry
= array_get(&(vvv
->directory
), mapping
->dir_index
);
3084 assert(!memcmp(direntry
->name
, "USB H ", 11) || direntry
->name
[0]==0);