kvm: testsuite: fix warning in msr.c
[qemu-kvm/fedora.git] / block-vvfat.c
blob01e9c0400ce6a893a2193f457a90694e2be8660c
1 /* vim:set shiftwidth=4 ts=8: */
2 /*
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
23 * THE SOFTWARE.
25 #include <sys/stat.h>
26 #include <dirent.h>
27 #include <assert.h>
28 #include "qemu-common.h"
29 #include "block_int.h"
31 #ifndef S_IWGRP
32 #define S_IWGRP 0
33 #endif
34 #ifndef S_IWOTH
35 #define S_IWOTH 0
36 #endif
38 /* TODO: add ":bootsector=blabla.img:" */
39 /* LATER TODO: add automatic boot sector generation from
40 BOOTEASY.ASM and Ranish Partition Manager
41 Note that DOS assumes the system files to be the first files in the
42 file system (test if the boot sector still relies on that fact)! */
43 /* MAYBE TODO: write block-visofs.c */
44 /* TODO: call try_commit() only after a timeout */
46 /* #define DEBUG */
48 #ifdef DEBUG
50 #define DLOG(a) a
52 #undef stderr
53 #define stderr STDERR
54 FILE* stderr = NULL;
56 static void checkpoint(void);
58 #ifdef __MINGW32__
59 void nonono(const char* file, int line, const char* msg) {
60 fprintf(stderr, "Nonono! %s:%d %s\n", file, line, msg);
61 exit(-5);
63 #undef assert
64 #define assert(a) do {if (!(a)) nonono(__FILE__, __LINE__, #a);}while(0)
65 #endif
67 #else
69 #define DLOG(a)
71 #endif
73 /* dynamic array functions */
74 typedef struct array_t {
75 char* pointer;
76 unsigned int size,next,item_size;
77 } array_t;
79 static inline void array_init(array_t* array,unsigned int item_size)
81 array->pointer = NULL;
82 array->size=0;
83 array->next=0;
84 array->item_size=item_size;
87 static inline void array_free(array_t* array)
89 if(array->pointer)
90 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 = qemu_realloc(array->pointer, new_size);
105 if (!array->pointer)
106 return -1;
107 array->size = new_size;
108 array->next = index + 1;
111 return 0;
114 static inline void* array_get_next(array_t* array) {
115 unsigned int next = array->next;
116 void* result;
118 if (array_ensure_allocated(array, next) < 0)
119 return NULL;
121 array->next = next + 1;
122 result = array_get(array, next);
124 return result;
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=qemu_realloc(array->pointer,array->size+increment);
131 if(!array->pointer)
132 return NULL;
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);
138 array->next+=count;
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)
146 char* buf;
147 char* from;
148 char* to;
149 int is;
151 if(!array ||
152 index_to<0 || index_to>=array->next ||
153 index_from<0 || index_from>=array->next)
154 return -1;
156 if(index_to==index_from)
157 return 0;
159 is=array->item_size;
160 from=array->pointer+index_from*is;
161 to=array->pointer+index_to*is;
162 buf=qemu_malloc(is*count);
163 memcpy(buf,from,is*count);
165 if(index_to<index_from)
166 memmove(to+is*count,to,from-to);
167 else
168 memmove(from,from+is*count,to-from);
170 memcpy(to,buf,is*count);
172 free(buf);
174 return 0;
177 static inline int array_remove_slice(array_t* array,int index, int count)
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;
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 __attribute__((packed)). */
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 } __attribute__((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 } __attribute__((packed)) fat32;
237 } u;
238 uint8_t fat_type[8];
239 uint8_t ignored[0x1c0];
240 uint8_t magic[2];
241 } __attribute__((packed)) bootsector_t;
243 typedef struct {
244 uint8_t head;
245 uint8_t sector;
246 uint8_t cylinder;
247 } mbr_chs_t;
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 } __attribute__((packed)) partition_t;
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 } __attribute__((packed)) mbr_t;
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 } __attribute__((packed)) direntry_t;
281 /* this structure are used to transparently access the files */
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
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;
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;
313 #ifdef DEBUG
314 static void print_direntry(const struct direntry_t*);
315 static void print_mapping(const struct mapping_t* mapping);
316 #endif
318 /* here begins the real VVFAT driver */
320 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;
328 unsigned int cluster_size;
329 unsigned int sectors_per_cluster;
330 unsigned int sectors_per_fat;
331 unsigned int sectors_of_root_directory;
332 uint32_t last_cluster_of_root_directory;
333 unsigned int faked_sectors; /* how many sectors are faked before file data */
334 uint32_t sector_count; /* total number of sectors of the partition */
335 uint32_t cluster_count; /* total number of clusters of this partition */
336 uint32_t max_fat_value;
338 int current_fd;
339 mapping_t* current_mapping;
340 unsigned char* cluster; /* points to current cluster */
341 unsigned char* cluster_buffer; /* points to a buffer to hold temp data */
342 unsigned int current_cluster;
344 /* write support */
345 BlockDriverState* write_target;
346 char* qcow_filename;
347 BlockDriverState* qcow;
348 void* fat2;
349 char* used_clusters;
350 array_t commits;
351 const char* path;
352 int downcase_short_names;
353 } BDRVVVFATState;
355 /* take the sector position spos and convert it to Cylinder/Head/Sector position
356 * if the position is outside the specified geometry, fill maximum value for CHS
357 * and return 1 to signal overflow.
359 static int sector2CHS(BlockDriverState* bs, mbr_chs_t * chs, int spos){
360 int head,sector;
361 sector = spos % (bs->secs); spos/= bs->secs;
362 head = spos % (bs->heads); spos/= bs->heads;
363 if(spos >= bs->cyls){
364 /* Overflow,
365 it happens if 32bit sector positions are used, while CHS is only 24bit.
366 Windows/Dos is said to take 1023/255/63 as nonrepresentable CHS */
367 chs->head = 0xFF;
368 chs->sector = 0xFF;
369 chs->cylinder = 0xFF;
370 return 1;
372 chs->head = (uint8_t)head;
373 chs->sector = (uint8_t)( (sector+1) | ((spos>>8)<<6) );
374 chs->cylinder = (uint8_t)spos;
375 return 0;
378 static void init_mbr(BDRVVVFATState* s)
380 /* TODO: if the files mbr.img and bootsect.img exist, use them */
381 mbr_t* real_mbr=(mbr_t*)s->first_sectors;
382 partition_t* partition=&(real_mbr->partition[0]);
383 int lba;
385 memset(s->first_sectors,0,512);
387 /* Win NT Disk Signature */
388 real_mbr->nt_id= cpu_to_le32(0xbe1afdfa);
390 partition->attributes=0x80; /* bootable */
392 /* LBA is used when partition is outside the CHS geometry */
393 lba = sector2CHS(s->bs, &partition->start_CHS, s->first_sectors_number-1);
394 lba|= sector2CHS(s->bs, &partition->end_CHS, s->sector_count);
396 /*LBA partitions are identified only by start/length_sector_long not by CHS*/
397 partition->start_sector_long =cpu_to_le32(s->first_sectors_number-1);
398 partition->length_sector_long=cpu_to_le32(s->sector_count - s->first_sectors_number+1);
400 /* FAT12/FAT16/FAT32 */
401 /* DOS uses different types when partition is LBA,
402 probably to prevent older versions from using CHS on them */
403 partition->fs_type= s->fat_type==12 ? 0x1:
404 s->fat_type==16 ? (lba?0xe:0x06):
405 /*fat_tyoe==32*/ (lba?0xc:0x0b);
407 real_mbr->magic[0]=0x55; real_mbr->magic[1]=0xaa;
410 /* direntry functions */
412 /* dest is assumed to hold 258 bytes, and pads with 0xffff up to next multiple of 26 */
413 static inline int short2long_name(char* dest,const char* src)
415 int i;
416 int len;
417 for(i=0;i<129 && src[i];i++) {
418 dest[2*i]=src[i];
419 dest[2*i+1]=0;
421 len=2*i;
422 dest[2*i]=dest[2*i+1]=0;
423 for(i=2*i+2;(i%26);i++)
424 dest[i]=0xff;
425 return len;
428 static inline direntry_t* create_long_filename(BDRVVVFATState* s,const char* filename)
430 char buffer[258];
431 int length=short2long_name(buffer,filename),
432 number_of_entries=(length+25)/26,i;
433 direntry_t* entry;
435 for(i=0;i<number_of_entries;i++) {
436 entry=array_get_next(&(s->directory));
437 entry->attributes=0xf;
438 entry->reserved[0]=0;
439 entry->begin=0;
440 entry->name[0]=(number_of_entries-i)|(i==0?0x40:0);
442 for(i=0;i<26*number_of_entries;i++) {
443 int offset=(i%26);
444 if(offset<10) offset=1+offset;
445 else if(offset<22) offset=14+offset-10;
446 else offset=28+offset-22;
447 entry=array_get(&(s->directory),s->directory.next-1-(i/26));
448 entry->name[offset]=buffer[i];
450 return array_get(&(s->directory),s->directory.next-number_of_entries);
453 static char is_free(const direntry_t* direntry)
455 return direntry->name[0]==0xe5 || direntry->name[0]==0x00;
458 static char is_volume_label(const direntry_t* direntry)
460 return direntry->attributes == 0x28;
463 static char is_long_name(const direntry_t* direntry)
465 return direntry->attributes == 0xf;
468 static char is_short_name(const direntry_t* direntry)
470 return !is_volume_label(direntry) && !is_long_name(direntry)
471 && !is_free(direntry);
474 static char is_directory(const direntry_t* direntry)
476 return direntry->attributes & 0x10 && direntry->name[0] != 0xe5;
479 static inline char is_dot(const direntry_t* direntry)
481 return is_short_name(direntry) && direntry->name[0] == '.';
484 static char is_file(const direntry_t* direntry)
486 return is_short_name(direntry) && !is_directory(direntry);
489 static inline uint32_t begin_of_direntry(const direntry_t* direntry)
491 return le16_to_cpu(direntry->begin)|(le16_to_cpu(direntry->begin_hi)<<16);
494 static inline uint32_t filesize_of_direntry(const direntry_t* direntry)
496 return le32_to_cpu(direntry->size);
499 static void set_begin_of_direntry(direntry_t* direntry, uint32_t begin)
501 direntry->begin = cpu_to_le16(begin & 0xffff);
502 direntry->begin_hi = cpu_to_le16((begin >> 16) & 0xffff);
505 /* fat functions */
507 static inline uint8_t fat_chksum(const direntry_t* entry)
509 uint8_t chksum=0;
510 int i;
512 for(i=0;i<11;i++)
513 chksum=(((chksum&0xfe)>>1)|((chksum&0x01)?0x80:0))
514 +(unsigned char)entry->name[i];
516 return chksum;
519 /* if return_time==0, this returns the fat_date, else the fat_time */
520 static uint16_t fat_datetime(time_t time,int return_time) {
521 struct tm* t;
522 #ifdef _WIN32
523 t=localtime(&time); /* this is not thread safe */
524 #else
525 struct tm t1;
526 t=&t1;
527 localtime_r(&time,t);
528 #endif
529 if(return_time)
530 return cpu_to_le16((t->tm_sec/2)|(t->tm_min<<5)|(t->tm_hour<<11));
531 return cpu_to_le16((t->tm_mday)|((t->tm_mon+1)<<5)|((t->tm_year-80)<<9));
534 static inline void fat_set(BDRVVVFATState* s,unsigned int cluster,uint32_t value)
536 if(s->fat_type==32) {
537 uint32_t* entry=array_get(&(s->fat),cluster);
538 *entry=cpu_to_le32(value);
539 } else if(s->fat_type==16) {
540 uint16_t* entry=array_get(&(s->fat),cluster);
541 *entry=cpu_to_le16(value&0xffff);
542 } else {
543 int offset = (cluster*3/2);
544 unsigned char* p = array_get(&(s->fat), offset);
545 switch (cluster&1) {
546 case 0:
547 p[0] = value&0xff;
548 p[1] = (p[1]&0xf0) | ((value>>8)&0xf);
549 break;
550 case 1:
551 p[0] = (p[0]&0xf) | ((value&0xf)<<4);
552 p[1] = (value>>4);
553 break;
558 static inline uint32_t fat_get(BDRVVVFATState* s,unsigned int cluster)
560 if(s->fat_type==32) {
561 uint32_t* entry=array_get(&(s->fat),cluster);
562 return le32_to_cpu(*entry);
563 } else if(s->fat_type==16) {
564 uint16_t* entry=array_get(&(s->fat),cluster);
565 return le16_to_cpu(*entry);
566 } else {
567 const uint8_t* x=(uint8_t*)(s->fat.pointer)+cluster*3/2;
568 return ((x[0]|(x[1]<<8))>>(cluster&1?4:0))&0x0fff;
572 static inline int fat_eof(BDRVVVFATState* s,uint32_t fat_entry)
574 if(fat_entry>s->max_fat_value-8)
575 return -1;
576 return 0;
579 static inline void init_fat(BDRVVVFATState* s)
581 if (s->fat_type == 12) {
582 array_init(&(s->fat),1);
583 array_ensure_allocated(&(s->fat),
584 s->sectors_per_fat * 0x200 * 3 / 2 - 1);
585 } else {
586 array_init(&(s->fat),(s->fat_type==32?4:2));
587 array_ensure_allocated(&(s->fat),
588 s->sectors_per_fat * 0x200 / s->fat.item_size - 1);
590 memset(s->fat.pointer,0,s->fat.size);
592 switch(s->fat_type) {
593 case 12: s->max_fat_value=0xfff; break;
594 case 16: s->max_fat_value=0xffff; break;
595 case 32: s->max_fat_value=0x0fffffff; break;
596 default: s->max_fat_value=0; /* error... */
601 /* TODO: in create_short_filename, 0xe5->0x05 is not yet handled! */
602 /* TODO: in parse_short_filename, 0x05->0xe5 is not yet handled! */
603 static inline direntry_t* create_short_and_long_name(BDRVVVFATState* s,
604 unsigned int directory_start, const char* filename, int is_dot)
606 int i,j,long_index=s->directory.next;
607 direntry_t* entry = NULL;
608 direntry_t* entry_long = NULL;
610 if(is_dot) {
611 entry=array_get_next(&(s->directory));
612 memset(entry->name,0x20,11);
613 memcpy(entry->name,filename,strlen(filename));
614 return entry;
617 entry_long=create_long_filename(s,filename);
619 i = strlen(filename);
620 for(j = i - 1; j>0 && filename[j]!='.';j--);
621 if (j > 0)
622 i = (j > 8 ? 8 : j);
623 else if (i > 8)
624 i = 8;
626 entry=array_get_next(&(s->directory));
627 memset(entry->name,0x20,11);
628 memcpy(entry->name, filename, i);
630 if(j > 0)
631 for (i = 0; i < 3 && filename[j+1+i]; i++)
632 entry->extension[i] = filename[j+1+i];
634 /* upcase & remove unwanted characters */
635 for(i=10;i>=0;i--) {
636 if(i==10 || i==7) for(;i>0 && entry->name[i]==' ';i--);
637 if(entry->name[i]<=' ' || entry->name[i]>0x7f
638 || strchr(".*?<>|\":/\\[];,+='",entry->name[i]))
639 entry->name[i]='_';
640 else if(entry->name[i]>='a' && entry->name[i]<='z')
641 entry->name[i]+='A'-'a';
644 /* mangle duplicates */
645 while(1) {
646 direntry_t* entry1=array_get(&(s->directory),directory_start);
647 int j;
649 for(;entry1<entry;entry1++)
650 if(!is_long_name(entry1) && !memcmp(entry1->name,entry->name,11))
651 break; /* found dupe */
652 if(entry1==entry) /* no dupe found */
653 break;
655 /* use all 8 characters of name */
656 if(entry->name[7]==' ') {
657 int j;
658 for(j=6;j>0 && entry->name[j]==' ';j--)
659 entry->name[j]='~';
662 /* increment number */
663 for(j=7;j>0 && entry->name[j]=='9';j--)
664 entry->name[j]='0';
665 if(j>0) {
666 if(entry->name[j]<'0' || entry->name[j]>'9')
667 entry->name[j]='0';
668 else
669 entry->name[j]++;
673 /* calculate checksum; propagate to long name */
674 if(entry_long) {
675 uint8_t chksum=fat_chksum(entry);
677 /* calculate anew, because realloc could have taken place */
678 entry_long=array_get(&(s->directory),long_index);
679 while(entry_long<entry && is_long_name(entry_long)) {
680 entry_long->reserved[1]=chksum;
681 entry_long++;
685 return entry;
689 * Read a directory. (the index of the corresponding mapping must be passed).
691 static int read_directory(BDRVVVFATState* s, int mapping_index)
693 mapping_t* mapping = array_get(&(s->mapping), mapping_index);
694 direntry_t* direntry;
695 const char* dirname = mapping->path;
696 int first_cluster = mapping->begin;
697 int parent_index = mapping->info.dir.parent_mapping_index;
698 mapping_t* parent_mapping = (mapping_t*)
699 (parent_index >= 0 ? array_get(&(s->mapping), parent_index) : NULL);
700 int first_cluster_of_parent = parent_mapping ? parent_mapping->begin : -1;
702 DIR* dir=opendir(dirname);
703 struct dirent* entry;
704 int i;
706 assert(mapping->mode & MODE_DIRECTORY);
708 if(!dir) {
709 mapping->end = mapping->begin;
710 return -1;
713 i = mapping->info.dir.first_dir_index =
714 first_cluster == 0 ? 0 : s->directory.next;
716 /* actually read the directory, and allocate the mappings */
717 while((entry=readdir(dir))) {
718 unsigned int length=strlen(dirname)+2+strlen(entry->d_name);
719 char* buffer;
720 direntry_t* direntry;
721 struct stat st;
722 int is_dot=!strcmp(entry->d_name,".");
723 int is_dotdot=!strcmp(entry->d_name,"..");
725 if(first_cluster == 0 && (is_dotdot || is_dot))
726 continue;
728 buffer=(char*)qemu_malloc(length);
729 snprintf(buffer,length,"%s/%s",dirname,entry->d_name);
731 if(stat(buffer,&st)<0) {
732 free(buffer);
733 continue;
736 /* create directory entry for this file */
737 direntry=create_short_and_long_name(s, i, entry->d_name,
738 is_dot || is_dotdot);
739 direntry->attributes=(S_ISDIR(st.st_mode)?0x10:0x20);
740 direntry->reserved[0]=direntry->reserved[1]=0;
741 direntry->ctime=fat_datetime(st.st_ctime,1);
742 direntry->cdate=fat_datetime(st.st_ctime,0);
743 direntry->adate=fat_datetime(st.st_atime,0);
744 direntry->begin_hi=0;
745 direntry->mtime=fat_datetime(st.st_mtime,1);
746 direntry->mdate=fat_datetime(st.st_mtime,0);
747 if(is_dotdot)
748 set_begin_of_direntry(direntry, first_cluster_of_parent);
749 else if(is_dot)
750 set_begin_of_direntry(direntry, first_cluster);
751 else
752 direntry->begin=0; /* do that later */
753 if (st.st_size > 0x7fffffff) {
754 fprintf(stderr, "File %s is larger than 2GB\n", buffer);
755 free(buffer);
756 return -2;
758 direntry->size=cpu_to_le32(S_ISDIR(st.st_mode)?0:st.st_size);
760 /* create mapping for this file */
761 if(!is_dot && !is_dotdot && (S_ISDIR(st.st_mode) || st.st_size)) {
762 s->current_mapping=(mapping_t*)array_get_next(&(s->mapping));
763 s->current_mapping->begin=0;
764 s->current_mapping->end=st.st_size;
766 * we get the direntry of the most recent direntry, which
767 * contains the short name and all the relevant information.
769 s->current_mapping->dir_index=s->directory.next-1;
770 s->current_mapping->first_mapping_index = -1;
771 if (S_ISDIR(st.st_mode)) {
772 s->current_mapping->mode = MODE_DIRECTORY;
773 s->current_mapping->info.dir.parent_mapping_index =
774 mapping_index;
775 } else {
776 s->current_mapping->mode = MODE_UNDEFINED;
777 s->current_mapping->info.file.offset = 0;
779 s->current_mapping->path=buffer;
780 s->current_mapping->read_only =
781 (st.st_mode & (S_IWUSR | S_IWGRP | S_IWOTH)) == 0;
784 closedir(dir);
786 /* fill with zeroes up to the end of the cluster */
787 while(s->directory.next%(0x10*s->sectors_per_cluster)) {
788 direntry_t* direntry=array_get_next(&(s->directory));
789 memset(direntry,0,sizeof(direntry_t));
792 /* TODO: if there are more entries, bootsector has to be adjusted! */
793 #define ROOT_ENTRIES (0x02 * 0x10 * s->sectors_per_cluster)
794 if (mapping_index == 0 && s->directory.next < ROOT_ENTRIES) {
795 /* root directory */
796 int cur = s->directory.next;
797 array_ensure_allocated(&(s->directory), ROOT_ENTRIES - 1);
798 memset(array_get(&(s->directory), cur), 0,
799 (ROOT_ENTRIES - cur) * sizeof(direntry_t));
802 /* reget the mapping, since s->mapping was possibly realloc()ed */
803 mapping = (mapping_t*)array_get(&(s->mapping), mapping_index);
804 first_cluster += (s->directory.next - mapping->info.dir.first_dir_index)
805 * 0x20 / s->cluster_size;
806 mapping->end = first_cluster;
808 direntry = (direntry_t*)array_get(&(s->directory), mapping->dir_index);
809 set_begin_of_direntry(direntry, mapping->begin);
811 return 0;
814 static inline uint32_t sector2cluster(BDRVVVFATState* s,off_t sector_num)
816 return (sector_num-s->faked_sectors)/s->sectors_per_cluster;
819 static inline off_t cluster2sector(BDRVVVFATState* s, uint32_t cluster_num)
821 return s->faked_sectors + s->sectors_per_cluster * cluster_num;
824 static inline uint32_t sector_offset_in_cluster(BDRVVVFATState* s,off_t sector_num)
826 return (sector_num-s->first_sectors_number-2*s->sectors_per_fat)%s->sectors_per_cluster;
829 #ifdef DBG
830 static direntry_t* get_direntry_for_mapping(BDRVVVFATState* s,mapping_t* mapping)
832 if(mapping->mode==MODE_UNDEFINED)
833 return 0;
834 return (direntry_t*)(s->directory.pointer+sizeof(direntry_t)*mapping->dir_index);
836 #endif
838 static int init_directories(BDRVVVFATState* s,
839 const char* dirname)
841 bootsector_t* bootsector;
842 mapping_t* mapping;
843 unsigned int i;
844 unsigned int cluster;
846 memset(&(s->first_sectors[0]),0,0x40*0x200);
848 s->cluster_size=s->sectors_per_cluster*0x200;
849 s->cluster_buffer=qemu_malloc(s->cluster_size);
852 * The formula: sc = spf+1+spf*spc*(512*8/fat_type),
853 * where sc is sector_count,
854 * spf is sectors_per_fat,
855 * spc is sectors_per_clusters, and
856 * fat_type = 12, 16 or 32.
858 i = 1+s->sectors_per_cluster*0x200*8/s->fat_type;
859 s->sectors_per_fat=(s->sector_count+i)/i; /* round up */
861 array_init(&(s->mapping),sizeof(mapping_t));
862 array_init(&(s->directory),sizeof(direntry_t));
864 /* add volume label */
866 direntry_t* entry=array_get_next(&(s->directory));
867 entry->attributes=0x28; /* archive | volume label */
868 snprintf((char*)entry->name,11,"QEMU VVFAT");
871 /* Now build FAT, and write back information into directory */
872 init_fat(s);
874 s->faked_sectors=s->first_sectors_number+s->sectors_per_fat*2;
875 s->cluster_count=sector2cluster(s, s->sector_count);
877 mapping = array_get_next(&(s->mapping));
878 mapping->begin = 0;
879 mapping->dir_index = 0;
880 mapping->info.dir.parent_mapping_index = -1;
881 mapping->first_mapping_index = -1;
882 mapping->path = strdup(dirname);
883 i = strlen(mapping->path);
884 if (i > 0 && mapping->path[i - 1] == '/')
885 mapping->path[i - 1] = '\0';
886 mapping->mode = MODE_DIRECTORY;
887 mapping->read_only = 0;
888 s->path = mapping->path;
890 for (i = 0, cluster = 0; i < s->mapping.next; i++) {
891 /* MS-DOS expects the FAT to be 0 for the root directory
892 * (except for the media byte). */
893 /* LATER TODO: still true for FAT32? */
894 int fix_fat = (i != 0);
895 mapping = array_get(&(s->mapping), i);
897 if (mapping->mode & MODE_DIRECTORY) {
898 mapping->begin = cluster;
899 if(read_directory(s, i)) {
900 fprintf(stderr, "Could not read directory %s\n",
901 mapping->path);
902 return -1;
904 mapping = array_get(&(s->mapping), i);
905 } else {
906 assert(mapping->mode == MODE_UNDEFINED);
907 mapping->mode=MODE_NORMAL;
908 mapping->begin = cluster;
909 if (mapping->end > 0) {
910 direntry_t* direntry = array_get(&(s->directory),
911 mapping->dir_index);
913 mapping->end = cluster + 1 + (mapping->end-1)/s->cluster_size;
914 set_begin_of_direntry(direntry, mapping->begin);
915 } else {
916 mapping->end = cluster + 1;
917 fix_fat = 0;
921 assert(mapping->begin < mapping->end);
923 /* next free cluster */
924 cluster = mapping->end;
926 if(cluster > s->cluster_count) {
927 fprintf(stderr,"Directory does not fit in FAT%d (capacity %s)\n",
928 s->fat_type,
929 s->fat_type == 12 ? s->sector_count == 2880 ? "1.44 MB"
930 : "2.88 MB"
931 : "504MB");
932 return -EINVAL;
935 /* fix fat for entry */
936 if (fix_fat) {
937 int j;
938 for(j = mapping->begin; j < mapping->end - 1; j++)
939 fat_set(s, j, j+1);
940 fat_set(s, mapping->end - 1, s->max_fat_value);
944 mapping = array_get(&(s->mapping), 0);
945 s->sectors_of_root_directory = mapping->end * s->sectors_per_cluster;
946 s->last_cluster_of_root_directory = mapping->end;
948 /* the FAT signature */
949 fat_set(s,0,s->max_fat_value);
950 fat_set(s,1,s->max_fat_value);
952 s->current_mapping = NULL;
954 bootsector=(bootsector_t*)(s->first_sectors+(s->first_sectors_number-1)*0x200);
955 bootsector->jump[0]=0xeb;
956 bootsector->jump[1]=0x3e;
957 bootsector->jump[2]=0x90;
958 memcpy(bootsector->name,"QEMU ",8);
959 bootsector->sector_size=cpu_to_le16(0x200);
960 bootsector->sectors_per_cluster=s->sectors_per_cluster;
961 bootsector->reserved_sectors=cpu_to_le16(1);
962 bootsector->number_of_fats=0x2; /* number of FATs */
963 bootsector->root_entries=cpu_to_le16(s->sectors_of_root_directory*0x10);
964 bootsector->total_sectors16=s->sector_count>0xffff?0:cpu_to_le16(s->sector_count);
965 bootsector->media_type=(s->fat_type!=12?0xf8:s->sector_count==5760?0xf9:0xf8); /* media descriptor */
966 s->fat.pointer[0] = bootsector->media_type;
967 bootsector->sectors_per_fat=cpu_to_le16(s->sectors_per_fat);
968 bootsector->sectors_per_track=cpu_to_le16(s->bs->secs);
969 bootsector->number_of_heads=cpu_to_le16(s->bs->heads);
970 bootsector->hidden_sectors=cpu_to_le32(s->first_sectors_number==1?0:0x3f);
971 bootsector->total_sectors=cpu_to_le32(s->sector_count>0xffff?s->sector_count:0);
973 /* LATER TODO: if FAT32, this is wrong */
974 bootsector->u.fat16.drive_number=s->fat_type==12?0:0x80; /* assume this is hda (TODO) */
975 bootsector->u.fat16.current_head=0;
976 bootsector->u.fat16.signature=0x29;
977 bootsector->u.fat16.id=cpu_to_le32(0xfabe1afd);
979 memcpy(bootsector->u.fat16.volume_label,"QEMU VVFAT ",11);
980 memcpy(bootsector->fat_type,(s->fat_type==12?"FAT12 ":s->fat_type==16?"FAT16 ":"FAT32 "),8);
981 bootsector->magic[0]=0x55; bootsector->magic[1]=0xaa;
983 return 0;
986 #ifdef DEBUG
987 static BDRVVVFATState *vvv = NULL;
988 #endif
990 static int enable_write_target(BDRVVVFATState *s);
991 static int is_consistent(BDRVVVFATState *s);
993 static int vvfat_open(BlockDriverState *bs, const char* dirname, int flags)
995 BDRVVVFATState *s = bs->opaque;
996 int floppy = 0;
997 int i;
999 #ifdef DEBUG
1000 vvv = s;
1001 #endif
1003 DLOG(if (stderr == NULL) {
1004 stderr = fopen("vvfat.log", "a");
1005 setbuf(stderr, NULL);
1008 s->bs = bs;
1010 s->fat_type=16;
1011 /* LATER TODO: if FAT32, adjust */
1012 s->sectors_per_cluster=0x10;
1013 /* 504MB disk*/
1014 bs->cyls=1024; bs->heads=16; bs->secs=63;
1016 s->current_cluster=0xffffffff;
1018 s->first_sectors_number=0x40;
1019 /* read only is the default for safety */
1020 bs->read_only = 1;
1021 s->qcow = s->write_target = NULL;
1022 s->qcow_filename = NULL;
1023 s->fat2 = NULL;
1024 s->downcase_short_names = 1;
1026 if (!strstart(dirname, "fat:", NULL))
1027 return -1;
1029 if (strstr(dirname, ":floppy:")) {
1030 floppy = 1;
1031 s->fat_type = 12;
1032 s->first_sectors_number = 1;
1033 s->sectors_per_cluster=2;
1034 bs->cyls = 80; bs->heads = 2; bs->secs = 36;
1037 s->sector_count=bs->cyls*bs->heads*bs->secs;
1039 if (strstr(dirname, ":32:")) {
1040 fprintf(stderr, "Big fat greek warning: FAT32 has not been tested. You are welcome to do so!\n");
1041 s->fat_type = 32;
1042 } else if (strstr(dirname, ":16:")) {
1043 s->fat_type = 16;
1044 } else if (strstr(dirname, ":12:")) {
1045 s->fat_type = 12;
1046 s->sector_count=2880;
1049 if (strstr(dirname, ":rw:")) {
1050 if (enable_write_target(s))
1051 return -1;
1052 bs->read_only = 0;
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;
1063 bs->total_sectors=bs->cyls*bs->heads*bs->secs;
1065 if(init_directories(s, dirname))
1066 return -1;
1068 s->sector_count = s->faked_sectors + s->sectors_per_cluster*s->cluster_count;
1070 if(s->first_sectors_number==0x40)
1071 init_mbr(s);
1073 /* for some reason or other, MS-DOS does not like to know about CHS... */
1074 if (floppy)
1075 bs->heads = bs->cyls = bs->secs = 0;
1077 // assert(is_consistent(s));
1078 return 0;
1081 static inline void vvfat_close_current_file(BDRVVVFATState *s)
1083 if(s->current_mapping) {
1084 s->current_mapping = NULL;
1085 if (s->current_fd) {
1086 close(s->current_fd);
1087 s->current_fd = 0;
1090 s->current_cluster = -1;
1093 /* mappings between index1 and index2-1 are supposed to be ordered
1094 * return value is the index of the last mapping for which end>cluster_num
1096 static inline int find_mapping_for_cluster_aux(BDRVVVFATState* s,int cluster_num,int index1,int index2)
1098 int index3=index1+1;
1099 while(1) {
1100 mapping_t* mapping;
1101 index3=(index1+index2)/2;
1102 mapping=array_get(&(s->mapping),index3);
1103 assert(mapping->begin < mapping->end);
1104 if(mapping->begin>=cluster_num) {
1105 assert(index2!=index3 || index2==0);
1106 if(index2==index3)
1107 return index1;
1108 index2=index3;
1109 } else {
1110 if(index1==index3)
1111 return mapping->end<=cluster_num ? index2 : index1;
1112 index1=index3;
1114 assert(index1<=index2);
1115 DLOG(mapping=array_get(&(s->mapping),index1);
1116 assert(mapping->begin<=cluster_num);
1117 assert(index2 >= s->mapping.next ||
1118 ((mapping = array_get(&(s->mapping),index2)) &&
1119 mapping->end>cluster_num)));
1123 static inline mapping_t* find_mapping_for_cluster(BDRVVVFATState* s,int cluster_num)
1125 int index=find_mapping_for_cluster_aux(s,cluster_num,0,s->mapping.next);
1126 mapping_t* mapping;
1127 if(index>=s->mapping.next)
1128 return NULL;
1129 mapping=array_get(&(s->mapping),index);
1130 if(mapping->begin>cluster_num)
1131 return NULL;
1132 assert(mapping->begin<=cluster_num && mapping->end>cluster_num);
1133 return mapping;
1137 * This function simply compares path == mapping->path. Since the mappings
1138 * are sorted by cluster, this is expensive: O(n).
1140 static inline mapping_t* find_mapping_for_path(BDRVVVFATState* s,
1141 const char* path)
1143 int i;
1145 for (i = 0; i < s->mapping.next; i++) {
1146 mapping_t* mapping = array_get(&(s->mapping), i);
1147 if (mapping->first_mapping_index < 0 &&
1148 !strcmp(path, mapping->path))
1149 return mapping;
1152 return NULL;
1155 static int open_file(BDRVVVFATState* s,mapping_t* mapping)
1157 if(!mapping)
1158 return -1;
1159 if(!s->current_mapping ||
1160 strcmp(s->current_mapping->path,mapping->path)) {
1161 /* open file */
1162 int fd = open(mapping->path, O_RDONLY | O_BINARY | O_LARGEFILE);
1163 if(fd<0)
1164 return -1;
1165 vvfat_close_current_file(s);
1166 s->current_fd = fd;
1167 s->current_mapping = mapping;
1169 return 0;
1172 static inline int read_cluster(BDRVVVFATState *s,int cluster_num)
1174 if(s->current_cluster != cluster_num) {
1175 int result=0;
1176 off_t offset;
1177 assert(!s->current_mapping || s->current_fd || (s->current_mapping->mode & MODE_DIRECTORY));
1178 if(!s->current_mapping
1179 || s->current_mapping->begin>cluster_num
1180 || s->current_mapping->end<=cluster_num) {
1181 /* binary search of mappings for file */
1182 mapping_t* mapping=find_mapping_for_cluster(s,cluster_num);
1184 assert(!mapping || (cluster_num>=mapping->begin && cluster_num<mapping->end));
1186 if (mapping && mapping->mode & MODE_DIRECTORY) {
1187 vvfat_close_current_file(s);
1188 s->current_mapping = mapping;
1189 read_cluster_directory:
1190 offset = s->cluster_size*(cluster_num-s->current_mapping->begin);
1191 s->cluster = (unsigned char*)s->directory.pointer+offset
1192 + 0x20*s->current_mapping->info.dir.first_dir_index;
1193 assert(((s->cluster-(unsigned char*)s->directory.pointer)%s->cluster_size)==0);
1194 assert((char*)s->cluster+s->cluster_size <= s->directory.pointer+s->directory.next*s->directory.item_size);
1195 s->current_cluster = cluster_num;
1196 return 0;
1199 if(open_file(s,mapping))
1200 return -2;
1201 } else if (s->current_mapping->mode & MODE_DIRECTORY)
1202 goto read_cluster_directory;
1204 assert(s->current_fd);
1206 offset=s->cluster_size*(cluster_num-s->current_mapping->begin)+s->current_mapping->info.file.offset;
1207 if(lseek(s->current_fd, offset, SEEK_SET)!=offset)
1208 return -3;
1209 s->cluster=s->cluster_buffer;
1210 result=read(s->current_fd,s->cluster,s->cluster_size);
1211 if(result<0) {
1212 s->current_cluster = -1;
1213 return -1;
1215 s->current_cluster = cluster_num;
1217 return 0;
1220 #ifdef DEBUG
1221 static void hexdump(const void* address, uint32_t len)
1223 const unsigned char* p = address;
1224 int i, j;
1226 for (i = 0; i < len; i += 16) {
1227 for (j = 0; j < 16 && i + j < len; j++)
1228 fprintf(stderr, "%02x ", p[i + j]);
1229 for (; j < 16; j++)
1230 fprintf(stderr, " ");
1231 fprintf(stderr, " ");
1232 for (j = 0; j < 16 && i + j < len; j++)
1233 fprintf(stderr, "%c", (p[i + j] < ' ' || p[i + j] > 0x7f) ? '.' : p[i + j]);
1234 fprintf(stderr, "\n");
1238 static void print_direntry(const direntry_t* direntry)
1240 int j = 0;
1241 char buffer[1024];
1243 fprintf(stderr, "direntry 0x%x: ", (int)direntry);
1244 if(!direntry)
1245 return;
1246 if(is_long_name(direntry)) {
1247 unsigned char* c=(unsigned char*)direntry;
1248 int i;
1249 for(i=1;i<11 && c[i] && c[i]!=0xff;i+=2)
1250 #define ADD_CHAR(c) {buffer[j] = (c); if (buffer[j] < ' ') buffer[j] = 0xb0; j++;}
1251 ADD_CHAR(c[i]);
1252 for(i=14;i<26 && c[i] && c[i]!=0xff;i+=2)
1253 ADD_CHAR(c[i]);
1254 for(i=28;i<32 && c[i] && c[i]!=0xff;i+=2)
1255 ADD_CHAR(c[i]);
1256 buffer[j] = 0;
1257 fprintf(stderr, "%s\n", buffer);
1258 } else {
1259 int i;
1260 for(i=0;i<11;i++)
1261 ADD_CHAR(direntry->name[i]);
1262 buffer[j] = 0;
1263 fprintf(stderr,"%s attributes=0x%02x begin=%d size=%d\n",
1264 buffer,
1265 direntry->attributes,
1266 begin_of_direntry(direntry),le32_to_cpu(direntry->size));
1270 static void print_mapping(const mapping_t* mapping)
1272 fprintf(stderr, "mapping (0x%x): begin, end = %d, %d, dir_index = %d, first_mapping_index = %d, name = %s, mode = 0x%x, " , (int)mapping, mapping->begin, mapping->end, mapping->dir_index, mapping->first_mapping_index, mapping->path, mapping->mode);
1273 if (mapping->mode & MODE_DIRECTORY)
1274 fprintf(stderr, "parent_mapping_index = %d, first_dir_index = %d\n", mapping->info.dir.parent_mapping_index, mapping->info.dir.first_dir_index);
1275 else
1276 fprintf(stderr, "offset = %d\n", mapping->info.file.offset);
1278 #endif
1280 static int vvfat_read(BlockDriverState *bs, int64_t sector_num,
1281 uint8_t *buf, int nb_sectors)
1283 BDRVVVFATState *s = bs->opaque;
1284 int i;
1286 for(i=0;i<nb_sectors;i++,sector_num++) {
1287 if (sector_num >= s->sector_count)
1288 return -1;
1289 if (s->qcow) {
1290 int n;
1291 if (s->qcow->drv->bdrv_is_allocated(s->qcow,
1292 sector_num, nb_sectors-i, &n)) {
1293 DLOG(fprintf(stderr, "sectors %d+%d allocated\n", (int)sector_num, n));
1294 if (s->qcow->drv->bdrv_read(s->qcow, sector_num, buf+i*0x200, n))
1295 return -1;
1296 i += n - 1;
1297 sector_num += n - 1;
1298 continue;
1300 DLOG(fprintf(stderr, "sector %d not allocated\n", (int)sector_num));
1302 if(sector_num<s->faked_sectors) {
1303 if(sector_num<s->first_sectors_number)
1304 memcpy(buf+i*0x200,&(s->first_sectors[sector_num*0x200]),0x200);
1305 else if(sector_num-s->first_sectors_number<s->sectors_per_fat)
1306 memcpy(buf+i*0x200,&(s->fat.pointer[(sector_num-s->first_sectors_number)*0x200]),0x200);
1307 else if(sector_num-s->first_sectors_number-s->sectors_per_fat<s->sectors_per_fat)
1308 memcpy(buf+i*0x200,&(s->fat.pointer[(sector_num-s->first_sectors_number-s->sectors_per_fat)*0x200]),0x200);
1309 } else {
1310 uint32_t sector=sector_num-s->faked_sectors,
1311 sector_offset_in_cluster=(sector%s->sectors_per_cluster),
1312 cluster_num=sector/s->sectors_per_cluster;
1313 if(read_cluster(s, cluster_num) != 0) {
1314 /* LATER TODO: strict: return -1; */
1315 memset(buf+i*0x200,0,0x200);
1316 continue;
1318 memcpy(buf+i*0x200,s->cluster+sector_offset_in_cluster*0x200,0x200);
1321 return 0;
1324 /* LATER TODO: statify all functions */
1327 * Idea of the write support (use snapshot):
1329 * 1. check if all data is consistent, recording renames, modifications,
1330 * new files and directories (in s->commits).
1332 * 2. if the data is not consistent, stop committing
1334 * 3. handle renames, and create new files and directories (do not yet
1335 * write their contents)
1337 * 4. walk the directories, fixing the mapping and direntries, and marking
1338 * the handled mappings as not deleted
1340 * 5. commit the contents of the files
1342 * 6. handle deleted files and directories
1346 typedef struct commit_t {
1347 char* path;
1348 union {
1349 struct { uint32_t cluster; } rename;
1350 struct { int dir_index; uint32_t modified_offset; } writeout;
1351 struct { uint32_t first_cluster; } new_file;
1352 struct { uint32_t cluster; } mkdir;
1353 } param;
1354 /* DELETEs and RMDIRs are handled differently: see handle_deletes() */
1355 enum {
1356 ACTION_RENAME, ACTION_WRITEOUT, ACTION_NEW_FILE, ACTION_MKDIR
1357 } action;
1358 } commit_t;
1360 static void clear_commits(BDRVVVFATState* s)
1362 int i;
1363 DLOG(fprintf(stderr, "clear_commits (%d commits)\n", s->commits.next));
1364 for (i = 0; i < s->commits.next; i++) {
1365 commit_t* commit = array_get(&(s->commits), i);
1366 assert(commit->path || commit->action == ACTION_WRITEOUT);
1367 if (commit->action != ACTION_WRITEOUT) {
1368 assert(commit->path);
1369 free(commit->path);
1370 } else
1371 assert(commit->path == NULL);
1373 s->commits.next = 0;
1376 static void schedule_rename(BDRVVVFATState* s,
1377 uint32_t cluster, char* new_path)
1379 commit_t* commit = array_get_next(&(s->commits));
1380 commit->path = new_path;
1381 commit->param.rename.cluster = cluster;
1382 commit->action = ACTION_RENAME;
1385 static void schedule_writeout(BDRVVVFATState* s,
1386 int dir_index, uint32_t modified_offset)
1388 commit_t* commit = array_get_next(&(s->commits));
1389 commit->path = NULL;
1390 commit->param.writeout.dir_index = dir_index;
1391 commit->param.writeout.modified_offset = modified_offset;
1392 commit->action = ACTION_WRITEOUT;
1395 static void schedule_new_file(BDRVVVFATState* s,
1396 char* path, uint32_t first_cluster)
1398 commit_t* commit = array_get_next(&(s->commits));
1399 commit->path = path;
1400 commit->param.new_file.first_cluster = first_cluster;
1401 commit->action = ACTION_NEW_FILE;
1404 static void schedule_mkdir(BDRVVVFATState* s, uint32_t cluster, char* path)
1406 commit_t* commit = array_get_next(&(s->commits));
1407 commit->path = path;
1408 commit->param.mkdir.cluster = cluster;
1409 commit->action = ACTION_MKDIR;
1412 typedef struct {
1414 * Since the sequence number is at most 0x3f, and the filename
1415 * length is at most 13 times the sequence number, the maximal
1416 * filename length is 0x3f * 13 bytes.
1418 unsigned char name[0x3f * 13 + 1];
1419 int checksum, len;
1420 int sequence_number;
1421 } long_file_name;
1423 static void lfn_init(long_file_name* lfn)
1425 lfn->sequence_number = lfn->len = 0;
1426 lfn->checksum = 0x100;
1429 /* return 0 if parsed successfully, > 0 if no long name, < 0 if error */
1430 static int parse_long_name(long_file_name* lfn,
1431 const direntry_t* direntry)
1433 int i, j, offset;
1434 const unsigned char* pointer = (const unsigned char*)direntry;
1436 if (!is_long_name(direntry))
1437 return 1;
1439 if (pointer[0] & 0x40) {
1440 lfn->sequence_number = pointer[0] & 0x3f;
1441 lfn->checksum = pointer[13];
1442 lfn->name[0] = 0;
1443 lfn->name[lfn->sequence_number * 13] = 0;
1444 } else if ((pointer[0] & 0x3f) != --lfn->sequence_number)
1445 return -1;
1446 else if (pointer[13] != lfn->checksum)
1447 return -2;
1448 else if (pointer[12] || pointer[26] || pointer[27])
1449 return -3;
1451 offset = 13 * (lfn->sequence_number - 1);
1452 for (i = 0, j = 1; i < 13; i++, j+=2) {
1453 if (j == 11)
1454 j = 14;
1455 else if (j == 26)
1456 j = 28;
1458 if (pointer[j+1] == 0)
1459 lfn->name[offset + i] = pointer[j];
1460 else if (pointer[j+1] != 0xff || (pointer[0] & 0x40) == 0)
1461 return -4;
1462 else
1463 lfn->name[offset + i] = 0;
1466 if (pointer[0] & 0x40)
1467 lfn->len = offset + strlen((char*)lfn->name + offset);
1469 return 0;
1472 /* returns 0 if successful, >0 if no short_name, and <0 on error */
1473 static int parse_short_name(BDRVVVFATState* s,
1474 long_file_name* lfn, direntry_t* direntry)
1476 int i, j;
1478 if (!is_short_name(direntry))
1479 return 1;
1481 for (j = 7; j >= 0 && direntry->name[j] == ' '; j--);
1482 for (i = 0; i <= j; i++) {
1483 if (direntry->name[i] <= ' ' || direntry->name[i] > 0x7f)
1484 return -1;
1485 else if (s->downcase_short_names)
1486 lfn->name[i] = qemu_tolower(direntry->name[i]);
1487 else
1488 lfn->name[i] = direntry->name[i];
1491 for (j = 2; j >= 0 && direntry->extension[j] == ' '; j--);
1492 if (j >= 0) {
1493 lfn->name[i++] = '.';
1494 lfn->name[i + j + 1] = '\0';
1495 for (;j >= 0; j--) {
1496 if (direntry->extension[j] <= ' ' || direntry->extension[j] > 0x7f)
1497 return -2;
1498 else if (s->downcase_short_names)
1499 lfn->name[i + j] = qemu_tolower(direntry->extension[j]);
1500 else
1501 lfn->name[i + j] = direntry->extension[j];
1503 } else
1504 lfn->name[i + j + 1] = '\0';
1506 lfn->len = strlen((char*)lfn->name);
1508 return 0;
1511 static inline uint32_t modified_fat_get(BDRVVVFATState* s,
1512 unsigned int cluster)
1514 if (cluster < s->last_cluster_of_root_directory) {
1515 if (cluster + 1 == s->last_cluster_of_root_directory)
1516 return s->max_fat_value;
1517 else
1518 return cluster + 1;
1521 if (s->fat_type==32) {
1522 uint32_t* entry=((uint32_t*)s->fat2)+cluster;
1523 return le32_to_cpu(*entry);
1524 } else if (s->fat_type==16) {
1525 uint16_t* entry=((uint16_t*)s->fat2)+cluster;
1526 return le16_to_cpu(*entry);
1527 } else {
1528 const uint8_t* x=s->fat2+cluster*3/2;
1529 return ((x[0]|(x[1]<<8))>>(cluster&1?4:0))&0x0fff;
1533 static inline int cluster_was_modified(BDRVVVFATState* s, uint32_t cluster_num)
1535 int was_modified = 0;
1536 int i, dummy;
1538 if (s->qcow == NULL)
1539 return 0;
1541 for (i = 0; !was_modified && i < s->sectors_per_cluster; i++)
1542 was_modified = s->qcow->drv->bdrv_is_allocated(s->qcow,
1543 cluster2sector(s, cluster_num) + i, 1, &dummy);
1545 return was_modified;
1548 static const char* get_basename(const char* path)
1550 char* basename = strrchr(path, '/');
1551 if (basename == NULL)
1552 return path;
1553 else
1554 return basename + 1; /* strip '/' */
1558 * The array s->used_clusters holds the states of the clusters. If it is
1559 * part of a file, it has bit 2 set, in case of a directory, bit 1. If it
1560 * was modified, bit 3 is set.
1561 * If any cluster is allocated, but not part of a file or directory, this
1562 * driver refuses to commit.
1564 typedef enum {
1565 USED_DIRECTORY = 1, USED_FILE = 2, USED_ANY = 3, USED_ALLOCATED = 4
1566 } used_t;
1569 * get_cluster_count_for_direntry() not only determines how many clusters
1570 * are occupied by direntry, but also if it was renamed or modified.
1572 * A file is thought to be renamed *only* if there already was a file with
1573 * exactly the same first cluster, but a different name.
1575 * Further, the files/directories handled by this function are
1576 * assumed to be *not* deleted (and *only* those).
1578 static uint32_t get_cluster_count_for_direntry(BDRVVVFATState* s,
1579 direntry_t* direntry, const char* path)
1582 * This is a little bit tricky:
1583 * IF the guest OS just inserts a cluster into the file chain,
1584 * and leaves the rest alone, (i.e. the original file had clusters
1585 * 15 -> 16, but now has 15 -> 32 -> 16), then the following happens:
1587 * - do_commit will write the cluster into the file at the given
1588 * offset, but
1590 * - the cluster which is overwritten should be moved to a later
1591 * position in the file.
1593 * I am not aware that any OS does something as braindead, but this
1594 * situation could happen anyway when not committing for a long time.
1595 * Just to be sure that this does not bite us, detect it, and copy the
1596 * contents of the clusters to-be-overwritten into the qcow.
1598 int copy_it = 0;
1599 int was_modified = 0;
1600 int32_t ret = 0;
1602 uint32_t cluster_num = begin_of_direntry(direntry);
1603 uint32_t offset = 0;
1604 int first_mapping_index = -1;
1605 mapping_t* mapping = NULL;
1606 const char* basename2 = NULL;
1608 vvfat_close_current_file(s);
1610 /* the root directory */
1611 if (cluster_num == 0)
1612 return 0;
1614 /* write support */
1615 if (s->qcow) {
1616 basename2 = get_basename(path);
1618 mapping = find_mapping_for_cluster(s, cluster_num);
1620 if (mapping) {
1621 const char* basename;
1623 assert(mapping->mode & MODE_DELETED);
1624 mapping->mode &= ~MODE_DELETED;
1626 basename = get_basename(mapping->path);
1628 assert(mapping->mode & MODE_NORMAL);
1630 /* rename */
1631 if (strcmp(basename, basename2))
1632 schedule_rename(s, cluster_num, strdup(path));
1633 } else if (is_file(direntry))
1634 /* new file */
1635 schedule_new_file(s, strdup(path), cluster_num);
1636 else {
1637 assert(0);
1638 return 0;
1642 while(1) {
1643 if (s->qcow) {
1644 if (!copy_it && cluster_was_modified(s, cluster_num)) {
1645 if (mapping == NULL ||
1646 mapping->begin > cluster_num ||
1647 mapping->end <= cluster_num)
1648 mapping = find_mapping_for_cluster(s, cluster_num);
1651 if (mapping &&
1652 (mapping->mode & MODE_DIRECTORY) == 0) {
1654 /* was modified in qcow */
1655 if (offset != mapping->info.file.offset + s->cluster_size
1656 * (cluster_num - mapping->begin)) {
1657 /* offset of this cluster in file chain has changed */
1658 assert(0);
1659 copy_it = 1;
1660 } else if (offset == 0) {
1661 const char* basename = get_basename(mapping->path);
1663 if (strcmp(basename, basename2))
1664 copy_it = 1;
1665 first_mapping_index = array_index(&(s->mapping), mapping);
1668 if (mapping->first_mapping_index != first_mapping_index
1669 && mapping->info.file.offset > 0) {
1670 assert(0);
1671 copy_it = 1;
1674 /* need to write out? */
1675 if (!was_modified && is_file(direntry)) {
1676 was_modified = 1;
1677 schedule_writeout(s, mapping->dir_index, offset);
1682 if (copy_it) {
1683 int i, dummy;
1685 * This is horribly inefficient, but that is okay, since
1686 * it is rarely executed, if at all.
1688 int64_t offset = cluster2sector(s, cluster_num);
1690 vvfat_close_current_file(s);
1691 for (i = 0; i < s->sectors_per_cluster; i++)
1692 if (!s->qcow->drv->bdrv_is_allocated(s->qcow,
1693 offset + i, 1, &dummy)) {
1694 if (vvfat_read(s->bs,
1695 offset, s->cluster_buffer, 1))
1696 return -1;
1697 if (s->qcow->drv->bdrv_write(s->qcow,
1698 offset, s->cluster_buffer, 1))
1699 return -2;
1704 ret++;
1705 if (s->used_clusters[cluster_num] & USED_ANY)
1706 return 0;
1707 s->used_clusters[cluster_num] = USED_FILE;
1709 cluster_num = modified_fat_get(s, cluster_num);
1711 if (fat_eof(s, cluster_num))
1712 return ret;
1713 else if (cluster_num < 2 || cluster_num > s->max_fat_value - 16)
1714 return -1;
1716 offset += s->cluster_size;
1721 * This function looks at the modified data (qcow).
1722 * It returns 0 upon inconsistency or error, and the number of clusters
1723 * used by the directory, its subdirectories and their files.
1725 static int check_directory_consistency(BDRVVVFATState *s,
1726 int cluster_num, const char* path)
1728 int ret = 0;
1729 unsigned char* cluster = qemu_malloc(s->cluster_size);
1730 direntry_t* direntries = (direntry_t*)cluster;
1731 mapping_t* mapping = find_mapping_for_cluster(s, cluster_num);
1733 long_file_name lfn;
1734 int path_len = strlen(path);
1735 char path2[PATH_MAX];
1737 assert(path_len < PATH_MAX); /* len was tested before! */
1738 pstrcpy(path2, sizeof(path2), path);
1739 path2[path_len] = '/';
1740 path2[path_len + 1] = '\0';
1742 if (mapping) {
1743 const char* basename = get_basename(mapping->path);
1744 const char* basename2 = get_basename(path);
1746 assert(mapping->mode & MODE_DIRECTORY);
1748 assert(mapping->mode & MODE_DELETED);
1749 mapping->mode &= ~MODE_DELETED;
1751 if (strcmp(basename, basename2))
1752 schedule_rename(s, cluster_num, strdup(path));
1753 } else
1754 /* new directory */
1755 schedule_mkdir(s, cluster_num, strdup(path));
1757 lfn_init(&lfn);
1758 do {
1759 int i;
1760 int subret = 0;
1762 ret++;
1764 if (s->used_clusters[cluster_num] & USED_ANY) {
1765 fprintf(stderr, "cluster %d used more than once\n", (int)cluster_num);
1766 return 0;
1768 s->used_clusters[cluster_num] = USED_DIRECTORY;
1770 DLOG(fprintf(stderr, "read cluster %d (sector %d)\n", (int)cluster_num, (int)cluster2sector(s, cluster_num)));
1771 subret = vvfat_read(s->bs, cluster2sector(s, cluster_num), cluster,
1772 s->sectors_per_cluster);
1773 if (subret) {
1774 fprintf(stderr, "Error fetching direntries\n");
1775 fail:
1776 free(cluster);
1777 return 0;
1780 for (i = 0; i < 0x10 * s->sectors_per_cluster; i++) {
1781 int cluster_count;
1783 DLOG(fprintf(stderr, "check direntry %d: \n", i); print_direntry(direntries + i));
1784 if (is_volume_label(direntries + i) || is_dot(direntries + i) ||
1785 is_free(direntries + i))
1786 continue;
1788 subret = parse_long_name(&lfn, direntries + i);
1789 if (subret < 0) {
1790 fprintf(stderr, "Error in long name\n");
1791 goto fail;
1793 if (subret == 0 || is_free(direntries + i))
1794 continue;
1796 if (fat_chksum(direntries+i) != lfn.checksum) {
1797 subret = parse_short_name(s, &lfn, direntries + i);
1798 if (subret < 0) {
1799 fprintf(stderr, "Error in short name (%d)\n", subret);
1800 goto fail;
1802 if (subret > 0 || !strcmp((char*)lfn.name, ".")
1803 || !strcmp((char*)lfn.name, ".."))
1804 continue;
1806 lfn.checksum = 0x100; /* cannot use long name twice */
1808 if (path_len + 1 + lfn.len >= PATH_MAX) {
1809 fprintf(stderr, "Name too long: %s/%s\n", path, lfn.name);
1810 goto fail;
1812 pstrcpy(path2 + path_len + 1, sizeof(path2) - path_len - 1,
1813 (char*)lfn.name);
1815 if (is_directory(direntries + i)) {
1816 if (begin_of_direntry(direntries + i) == 0) {
1817 DLOG(fprintf(stderr, "invalid begin for directory: %s\n", path2); print_direntry(direntries + i));
1818 goto fail;
1820 cluster_count = check_directory_consistency(s,
1821 begin_of_direntry(direntries + i), path2);
1822 if (cluster_count == 0) {
1823 DLOG(fprintf(stderr, "problem in directory %s:\n", path2); print_direntry(direntries + i));
1824 goto fail;
1826 } else if (is_file(direntries + i)) {
1827 /* check file size with FAT */
1828 cluster_count = get_cluster_count_for_direntry(s, direntries + i, path2);
1829 if (cluster_count !=
1830 (le32_to_cpu(direntries[i].size) + s->cluster_size
1831 - 1) / s->cluster_size) {
1832 DLOG(fprintf(stderr, "Cluster count mismatch\n"));
1833 goto fail;
1835 } else
1836 assert(0); /* cluster_count = 0; */
1838 ret += cluster_count;
1841 cluster_num = modified_fat_get(s, cluster_num);
1842 } while(!fat_eof(s, cluster_num));
1844 free(cluster);
1845 return ret;
1848 /* returns 1 on success */
1849 static int is_consistent(BDRVVVFATState* s)
1851 int i, check;
1852 int used_clusters_count = 0;
1854 DLOG(checkpoint());
1856 * - get modified FAT
1857 * - compare the two FATs (TODO)
1858 * - get buffer for marking used clusters
1859 * - recurse direntries from root (using bs->bdrv_read to make
1860 * sure to get the new data)
1861 * - check that the FAT agrees with the size
1862 * - count the number of clusters occupied by this directory and
1863 * its files
1864 * - check that the cumulative used cluster count agrees with the
1865 * FAT
1866 * - if all is fine, return number of used clusters
1868 if (s->fat2 == NULL) {
1869 int size = 0x200 * s->sectors_per_fat;
1870 s->fat2 = qemu_malloc(size);
1871 memcpy(s->fat2, s->fat.pointer, size);
1873 check = vvfat_read(s->bs,
1874 s->first_sectors_number, s->fat2, s->sectors_per_fat);
1875 if (check) {
1876 fprintf(stderr, "Could not copy fat\n");
1877 return 0;
1879 assert (s->used_clusters);
1880 for (i = 0; i < sector2cluster(s, s->sector_count); i++)
1881 s->used_clusters[i] &= ~USED_ANY;
1883 clear_commits(s);
1885 /* mark every mapped file/directory as deleted.
1886 * (check_directory_consistency() will unmark those still present). */
1887 if (s->qcow)
1888 for (i = 0; i < s->mapping.next; i++) {
1889 mapping_t* mapping = array_get(&(s->mapping), i);
1890 if (mapping->first_mapping_index < 0)
1891 mapping->mode |= MODE_DELETED;
1894 used_clusters_count = check_directory_consistency(s, 0, s->path);
1895 if (used_clusters_count <= 0) {
1896 DLOG(fprintf(stderr, "problem in directory\n"));
1897 return 0;
1900 check = s->last_cluster_of_root_directory;
1901 for (i = check; i < sector2cluster(s, s->sector_count); i++) {
1902 if (modified_fat_get(s, i)) {
1903 if(!s->used_clusters[i]) {
1904 DLOG(fprintf(stderr, "FAT was modified (%d), but cluster is not used?\n", i));
1905 return 0;
1907 check++;
1910 if (s->used_clusters[i] == USED_ALLOCATED) {
1911 /* allocated, but not used... */
1912 DLOG(fprintf(stderr, "unused, modified cluster: %d\n", i));
1913 return 0;
1917 if (check != used_clusters_count)
1918 return 0;
1920 return used_clusters_count;
1923 static inline void adjust_mapping_indices(BDRVVVFATState* s,
1924 int offset, int adjust)
1926 int i;
1928 for (i = 0; i < s->mapping.next; i++) {
1929 mapping_t* mapping = array_get(&(s->mapping), i);
1931 #define ADJUST_MAPPING_INDEX(name) \
1932 if (mapping->name >= offset) \
1933 mapping->name += adjust
1935 ADJUST_MAPPING_INDEX(first_mapping_index);
1936 if (mapping->mode & MODE_DIRECTORY)
1937 ADJUST_MAPPING_INDEX(info.dir.parent_mapping_index);
1941 /* insert or update mapping */
1942 static mapping_t* insert_mapping(BDRVVVFATState* s,
1943 uint32_t begin, uint32_t end)
1946 * - find mapping where mapping->begin >= begin,
1947 * - if mapping->begin > begin: insert
1948 * - adjust all references to mappings!
1949 * - else: adjust
1950 * - replace name
1952 int index = find_mapping_for_cluster_aux(s, begin, 0, s->mapping.next);
1953 mapping_t* mapping = NULL;
1954 mapping_t* first_mapping = array_get(&(s->mapping), 0);
1956 if (index < s->mapping.next && (mapping = array_get(&(s->mapping), index))
1957 && mapping->begin < begin) {
1958 mapping->end = begin;
1959 index++;
1960 mapping = array_get(&(s->mapping), index);
1962 if (index >= s->mapping.next || mapping->begin > begin) {
1963 mapping = array_insert(&(s->mapping), index, 1);
1964 mapping->path = NULL;
1965 adjust_mapping_indices(s, index, +1);
1968 mapping->begin = begin;
1969 mapping->end = end;
1971 DLOG(mapping_t* next_mapping;
1972 assert(index + 1 >= s->mapping.next ||
1973 ((next_mapping = array_get(&(s->mapping), index + 1)) &&
1974 next_mapping->begin >= end)));
1976 if (s->current_mapping && first_mapping != (mapping_t*)s->mapping.pointer)
1977 s->current_mapping = array_get(&(s->mapping),
1978 s->current_mapping - first_mapping);
1980 return mapping;
1983 static int remove_mapping(BDRVVVFATState* s, int mapping_index)
1985 mapping_t* mapping = array_get(&(s->mapping), mapping_index);
1986 mapping_t* first_mapping = array_get(&(s->mapping), 0);
1988 /* free mapping */
1989 if (mapping->first_mapping_index < 0)
1990 free(mapping->path);
1992 /* remove from s->mapping */
1993 array_remove(&(s->mapping), mapping_index);
1995 /* adjust all references to mappings */
1996 adjust_mapping_indices(s, mapping_index, -1);
1998 if (s->current_mapping && first_mapping != (mapping_t*)s->mapping.pointer)
1999 s->current_mapping = array_get(&(s->mapping),
2000 s->current_mapping - first_mapping);
2002 return 0;
2005 static void adjust_dirindices(BDRVVVFATState* s, int offset, int adjust)
2007 int i;
2008 for (i = 0; i < s->mapping.next; i++) {
2009 mapping_t* mapping = array_get(&(s->mapping), i);
2010 if (mapping->dir_index >= offset)
2011 mapping->dir_index += adjust;
2012 if ((mapping->mode & MODE_DIRECTORY) &&
2013 mapping->info.dir.first_dir_index >= offset)
2014 mapping->info.dir.first_dir_index += adjust;
2018 static direntry_t* insert_direntries(BDRVVVFATState* s,
2019 int dir_index, int count)
2022 * make room in s->directory,
2023 * adjust_dirindices
2025 direntry_t* result = array_insert(&(s->directory), dir_index, count);
2026 if (result == NULL)
2027 return NULL;
2028 adjust_dirindices(s, dir_index, count);
2029 return result;
2032 static int remove_direntries(BDRVVVFATState* s, int dir_index, int count)
2034 int ret = array_remove_slice(&(s->directory), dir_index, count);
2035 if (ret)
2036 return ret;
2037 adjust_dirindices(s, dir_index, -count);
2038 return 0;
2042 * Adapt the mappings of the cluster chain starting at first cluster
2043 * (i.e. if a file starts at first_cluster, the chain is followed according
2044 * to the modified fat, and the corresponding entries in s->mapping are
2045 * adjusted)
2047 static int commit_mappings(BDRVVVFATState* s,
2048 uint32_t first_cluster, int dir_index)
2050 mapping_t* mapping = find_mapping_for_cluster(s, first_cluster);
2051 direntry_t* direntry = array_get(&(s->directory), dir_index);
2052 uint32_t cluster = first_cluster;
2054 vvfat_close_current_file(s);
2056 assert(mapping);
2057 assert(mapping->begin == first_cluster);
2058 mapping->first_mapping_index = -1;
2059 mapping->dir_index = dir_index;
2060 mapping->mode = (dir_index <= 0 || is_directory(direntry)) ?
2061 MODE_DIRECTORY : MODE_NORMAL;
2063 while (!fat_eof(s, cluster)) {
2064 uint32_t c, c1;
2066 for (c = cluster, c1 = modified_fat_get(s, c); c + 1 == c1;
2067 c = c1, c1 = modified_fat_get(s, c1));
2069 c++;
2070 if (c > mapping->end) {
2071 int index = array_index(&(s->mapping), mapping);
2072 int i, max_i = s->mapping.next - index;
2073 for (i = 1; i < max_i && mapping[i].begin < c; i++);
2074 while (--i > 0)
2075 remove_mapping(s, index + 1);
2077 assert(mapping == array_get(&(s->mapping), s->mapping.next - 1)
2078 || mapping[1].begin >= c);
2079 mapping->end = c;
2081 if (!fat_eof(s, c1)) {
2082 int i = find_mapping_for_cluster_aux(s, c1, 0, s->mapping.next);
2083 mapping_t* next_mapping = i >= s->mapping.next ? NULL :
2084 array_get(&(s->mapping), i);
2086 if (next_mapping == NULL || next_mapping->begin > c1) {
2087 int i1 = array_index(&(s->mapping), mapping);
2089 next_mapping = insert_mapping(s, c1, c1+1);
2091 if (c1 < c)
2092 i1++;
2093 mapping = array_get(&(s->mapping), i1);
2096 next_mapping->dir_index = mapping->dir_index;
2097 next_mapping->first_mapping_index =
2098 mapping->first_mapping_index < 0 ?
2099 array_index(&(s->mapping), mapping) :
2100 mapping->first_mapping_index;
2101 next_mapping->path = mapping->path;
2102 next_mapping->mode = mapping->mode;
2103 next_mapping->read_only = mapping->read_only;
2104 if (mapping->mode & MODE_DIRECTORY) {
2105 next_mapping->info.dir.parent_mapping_index =
2106 mapping->info.dir.parent_mapping_index;
2107 next_mapping->info.dir.first_dir_index =
2108 mapping->info.dir.first_dir_index +
2109 0x10 * s->sectors_per_cluster *
2110 (mapping->end - mapping->begin);
2111 } else
2112 next_mapping->info.file.offset = mapping->info.file.offset +
2113 mapping->end - mapping->begin;
2115 mapping = next_mapping;
2118 cluster = c1;
2121 return 0;
2124 static int commit_direntries(BDRVVVFATState* s,
2125 int dir_index, int parent_mapping_index)
2127 direntry_t* direntry = array_get(&(s->directory), dir_index);
2128 uint32_t first_cluster = dir_index == 0 ? 0 : begin_of_direntry(direntry);
2129 mapping_t* mapping = find_mapping_for_cluster(s, first_cluster);
2131 int factor = 0x10 * s->sectors_per_cluster;
2132 int old_cluster_count, new_cluster_count;
2133 int current_dir_index = mapping->info.dir.first_dir_index;
2134 int first_dir_index = current_dir_index;
2135 int ret, i;
2136 uint32_t c;
2138 DLOG(fprintf(stderr, "commit_direntries for %s, parent_mapping_index %d\n", mapping->path, parent_mapping_index));
2140 assert(direntry);
2141 assert(mapping);
2142 assert(mapping->begin == first_cluster);
2143 assert(mapping->info.dir.first_dir_index < s->directory.next);
2144 assert(mapping->mode & MODE_DIRECTORY);
2145 assert(dir_index == 0 || is_directory(direntry));
2147 mapping->info.dir.parent_mapping_index = parent_mapping_index;
2149 if (first_cluster == 0) {
2150 old_cluster_count = new_cluster_count =
2151 s->last_cluster_of_root_directory;
2152 } else {
2153 for (old_cluster_count = 0, c = first_cluster; !fat_eof(s, c);
2154 c = fat_get(s, c))
2155 old_cluster_count++;
2157 for (new_cluster_count = 0, c = first_cluster; !fat_eof(s, c);
2158 c = modified_fat_get(s, c))
2159 new_cluster_count++;
2162 if (new_cluster_count > old_cluster_count) {
2163 if (insert_direntries(s,
2164 current_dir_index + factor * old_cluster_count,
2165 factor * (new_cluster_count - old_cluster_count)) == NULL)
2166 return -1;
2167 } else if (new_cluster_count < old_cluster_count)
2168 remove_direntries(s,
2169 current_dir_index + factor * new_cluster_count,
2170 factor * (old_cluster_count - new_cluster_count));
2172 for (c = first_cluster; !fat_eof(s, c); c = modified_fat_get(s, c)) {
2173 void* direntry = array_get(&(s->directory), current_dir_index);
2174 int ret = vvfat_read(s->bs, cluster2sector(s, c), direntry,
2175 s->sectors_per_cluster);
2176 if (ret)
2177 return ret;
2178 assert(!strncmp(s->directory.pointer, "QEMU", 4));
2179 current_dir_index += factor;
2182 ret = commit_mappings(s, first_cluster, dir_index);
2183 if (ret)
2184 return ret;
2186 /* recurse */
2187 for (i = 0; i < factor * new_cluster_count; i++) {
2188 direntry = array_get(&(s->directory), first_dir_index + i);
2189 if (is_directory(direntry) && !is_dot(direntry)) {
2190 mapping = find_mapping_for_cluster(s, first_cluster);
2191 assert(mapping->mode & MODE_DIRECTORY);
2192 ret = commit_direntries(s, first_dir_index + i,
2193 array_index(&(s->mapping), mapping));
2194 if (ret)
2195 return ret;
2199 return 0;
2202 /* commit one file (adjust contents, adjust mapping),
2203 return first_mapping_index */
2204 static int commit_one_file(BDRVVVFATState* s,
2205 int dir_index, uint32_t offset)
2207 direntry_t* direntry = array_get(&(s->directory), dir_index);
2208 uint32_t c = begin_of_direntry(direntry);
2209 uint32_t first_cluster = c;
2210 mapping_t* mapping = find_mapping_for_cluster(s, c);
2211 uint32_t size = filesize_of_direntry(direntry);
2212 char* cluster = qemu_malloc(s->cluster_size);
2213 uint32_t i;
2214 int fd = 0;
2216 assert(offset < size);
2217 assert((offset % s->cluster_size) == 0);
2219 for (i = s->cluster_size; i < offset; i += s->cluster_size)
2220 c = modified_fat_get(s, c);
2222 fd = open(mapping->path, O_RDWR | O_CREAT | O_BINARY, 0666);
2223 if (fd < 0) {
2224 fprintf(stderr, "Could not open %s... (%s, %d)\n", mapping->path,
2225 strerror(errno), errno);
2226 return fd;
2228 if (offset > 0)
2229 if (lseek(fd, offset, SEEK_SET) != offset)
2230 return -3;
2232 while (offset < size) {
2233 uint32_t c1;
2234 int rest_size = (size - offset > s->cluster_size ?
2235 s->cluster_size : size - offset);
2236 int ret;
2238 c1 = modified_fat_get(s, c);
2240 assert((size - offset == 0 && fat_eof(s, c)) ||
2241 (size > offset && c >=2 && !fat_eof(s, c)));
2243 ret = vvfat_read(s->bs, cluster2sector(s, c),
2244 (uint8_t*)cluster, (rest_size + 0x1ff) / 0x200);
2246 if (ret < 0)
2247 return ret;
2249 if (write(fd, cluster, rest_size) < 0)
2250 return -2;
2252 offset += rest_size;
2253 c = c1;
2256 ftruncate(fd, size);
2257 close(fd);
2259 return commit_mappings(s, first_cluster, dir_index);
2262 #ifdef DEBUG
2263 /* test, if all mappings point to valid direntries */
2264 static void check1(BDRVVVFATState* s)
2266 int i;
2267 for (i = 0; i < s->mapping.next; i++) {
2268 mapping_t* mapping = array_get(&(s->mapping), i);
2269 if (mapping->mode & MODE_DELETED) {
2270 fprintf(stderr, "deleted\n");
2271 continue;
2273 assert(mapping->dir_index >= 0);
2274 assert(mapping->dir_index < s->directory.next);
2275 direntry_t* direntry = array_get(&(s->directory), mapping->dir_index);
2276 assert(mapping->begin == begin_of_direntry(direntry) || mapping->first_mapping_index >= 0);
2277 if (mapping->mode & MODE_DIRECTORY) {
2278 assert(mapping->info.dir.first_dir_index + 0x10 * s->sectors_per_cluster * (mapping->end - mapping->begin) <= s->directory.next);
2279 assert((mapping->info.dir.first_dir_index % (0x10 * s->sectors_per_cluster)) == 0);
2284 /* test, if all direntries have mappings */
2285 static void check2(BDRVVVFATState* s)
2287 int i;
2288 int first_mapping = -1;
2290 for (i = 0; i < s->directory.next; i++) {
2291 direntry_t* direntry = array_get(&(s->directory), i);
2293 if (is_short_name(direntry) && begin_of_direntry(direntry)) {
2294 mapping_t* mapping = find_mapping_for_cluster(s, begin_of_direntry(direntry));
2295 assert(mapping);
2296 assert(mapping->dir_index == i || is_dot(direntry));
2297 assert(mapping->begin == begin_of_direntry(direntry) || is_dot(direntry));
2300 if ((i % (0x10 * s->sectors_per_cluster)) == 0) {
2301 /* cluster start */
2302 int j, count = 0;
2304 for (j = 0; j < s->mapping.next; j++) {
2305 mapping_t* mapping = array_get(&(s->mapping), j);
2306 if (mapping->mode & MODE_DELETED)
2307 continue;
2308 if (mapping->mode & MODE_DIRECTORY) {
2309 if (mapping->info.dir.first_dir_index <= i && mapping->info.dir.first_dir_index + 0x10 * s->sectors_per_cluster > i) {
2310 assert(++count == 1);
2311 if (mapping->first_mapping_index == -1)
2312 first_mapping = array_index(&(s->mapping), mapping);
2313 else
2314 assert(first_mapping == mapping->first_mapping_index);
2315 if (mapping->info.dir.parent_mapping_index < 0)
2316 assert(j == 0);
2317 else {
2318 mapping_t* parent = array_get(&(s->mapping), mapping->info.dir.parent_mapping_index);
2319 assert(parent->mode & MODE_DIRECTORY);
2320 assert(parent->info.dir.first_dir_index < mapping->info.dir.first_dir_index);
2325 if (count == 0)
2326 first_mapping = -1;
2330 #endif
2332 static int handle_renames_and_mkdirs(BDRVVVFATState* s)
2334 int i;
2336 #ifdef DEBUG
2337 fprintf(stderr, "handle_renames\n");
2338 for (i = 0; i < s->commits.next; i++) {
2339 commit_t* commit = array_get(&(s->commits), i);
2340 fprintf(stderr, "%d, %s (%d, %d)\n", i, commit->path ? commit->path : "(null)", commit->param.rename.cluster, commit->action);
2342 #endif
2344 for (i = 0; i < s->commits.next;) {
2345 commit_t* commit = array_get(&(s->commits), i);
2346 if (commit->action == ACTION_RENAME) {
2347 mapping_t* mapping = find_mapping_for_cluster(s,
2348 commit->param.rename.cluster);
2349 char* old_path = mapping->path;
2351 assert(commit->path);
2352 mapping->path = commit->path;
2353 if (rename(old_path, mapping->path))
2354 return -2;
2356 if (mapping->mode & MODE_DIRECTORY) {
2357 int l1 = strlen(mapping->path);
2358 int l2 = strlen(old_path);
2359 int diff = l1 - l2;
2360 direntry_t* direntry = array_get(&(s->directory),
2361 mapping->info.dir.first_dir_index);
2362 uint32_t c = mapping->begin;
2363 int i = 0;
2365 /* recurse */
2366 while (!fat_eof(s, c)) {
2367 do {
2368 direntry_t* d = direntry + i;
2370 if (is_file(d) || (is_directory(d) && !is_dot(d))) {
2371 mapping_t* m = find_mapping_for_cluster(s,
2372 begin_of_direntry(d));
2373 int l = strlen(m->path);
2374 char* new_path = qemu_malloc(l + diff + 1);
2376 assert(!strncmp(m->path, mapping->path, l2));
2378 pstrcpy(new_path, l + diff + 1, mapping->path);
2379 pstrcpy(new_path + l1, l + diff + 1 - l1,
2380 m->path + l2);
2382 schedule_rename(s, m->begin, new_path);
2384 i++;
2385 } while((i % (0x10 * s->sectors_per_cluster)) != 0);
2386 c = fat_get(s, c);
2390 free(old_path);
2391 array_remove(&(s->commits), i);
2392 continue;
2393 } else if (commit->action == ACTION_MKDIR) {
2394 mapping_t* mapping;
2395 int j, parent_path_len;
2397 #ifdef __MINGW32__
2398 if (mkdir(commit->path))
2399 return -5;
2400 #else
2401 if (mkdir(commit->path, 0755))
2402 return -5;
2403 #endif
2405 mapping = insert_mapping(s, commit->param.mkdir.cluster,
2406 commit->param.mkdir.cluster + 1);
2407 if (mapping == NULL)
2408 return -6;
2410 mapping->mode = MODE_DIRECTORY;
2411 mapping->read_only = 0;
2412 mapping->path = commit->path;
2413 j = s->directory.next;
2414 assert(j);
2415 insert_direntries(s, s->directory.next,
2416 0x10 * s->sectors_per_cluster);
2417 mapping->info.dir.first_dir_index = j;
2419 parent_path_len = strlen(commit->path)
2420 - strlen(get_basename(commit->path)) - 1;
2421 for (j = 0; j < s->mapping.next; j++) {
2422 mapping_t* m = array_get(&(s->mapping), j);
2423 if (m->first_mapping_index < 0 && m != mapping &&
2424 !strncmp(m->path, mapping->path, parent_path_len) &&
2425 strlen(m->path) == parent_path_len)
2426 break;
2428 assert(j < s->mapping.next);
2429 mapping->info.dir.parent_mapping_index = j;
2431 array_remove(&(s->commits), i);
2432 continue;
2435 i++;
2437 return 0;
2441 * TODO: make sure that the short name is not matching *another* file
2443 static int handle_commits(BDRVVVFATState* s)
2445 int i, fail = 0;
2447 vvfat_close_current_file(s);
2449 for (i = 0; !fail && i < s->commits.next; i++) {
2450 commit_t* commit = array_get(&(s->commits), i);
2451 switch(commit->action) {
2452 case ACTION_RENAME: case ACTION_MKDIR:
2453 assert(0);
2454 fail = -2;
2455 break;
2456 case ACTION_WRITEOUT: {
2457 direntry_t* entry = array_get(&(s->directory),
2458 commit->param.writeout.dir_index);
2459 uint32_t begin = begin_of_direntry(entry);
2460 mapping_t* mapping = find_mapping_for_cluster(s, begin);
2462 assert(mapping);
2463 assert(mapping->begin == begin);
2464 assert(commit->path == NULL);
2466 if (commit_one_file(s, commit->param.writeout.dir_index,
2467 commit->param.writeout.modified_offset))
2468 fail = -3;
2470 break;
2472 case ACTION_NEW_FILE: {
2473 int begin = commit->param.new_file.first_cluster;
2474 mapping_t* mapping = find_mapping_for_cluster(s, begin);
2475 direntry_t* entry;
2476 int i;
2478 /* find direntry */
2479 for (i = 0; i < s->directory.next; i++) {
2480 entry = array_get(&(s->directory), i);
2481 if (is_file(entry) && begin_of_direntry(entry) == begin)
2482 break;
2485 if (i >= s->directory.next) {
2486 fail = -6;
2487 continue;
2490 /* make sure there exists an initial mapping */
2491 if (mapping && mapping->begin != begin) {
2492 mapping->end = begin;
2493 mapping = NULL;
2495 if (mapping == NULL) {
2496 mapping = insert_mapping(s, begin, begin+1);
2498 /* most members will be fixed in commit_mappings() */
2499 assert(commit->path);
2500 mapping->path = commit->path;
2501 mapping->read_only = 0;
2502 mapping->mode = MODE_NORMAL;
2503 mapping->info.file.offset = 0;
2505 if (commit_one_file(s, i, 0))
2506 fail = -7;
2508 break;
2510 default:
2511 assert(0);
2514 if (i > 0 && array_remove_slice(&(s->commits), 0, i))
2515 return -1;
2516 return fail;
2519 static int handle_deletes(BDRVVVFATState* s)
2521 int i, deferred = 1, deleted = 1;
2523 /* delete files corresponding to mappings marked as deleted */
2524 /* handle DELETEs and unused mappings (modified_fat_get(s, mapping->begin) == 0) */
2525 while (deferred && deleted) {
2526 deferred = 0;
2527 deleted = 0;
2529 for (i = 1; i < s->mapping.next; i++) {
2530 mapping_t* mapping = array_get(&(s->mapping), i);
2531 if (mapping->mode & MODE_DELETED) {
2532 direntry_t* entry = array_get(&(s->directory),
2533 mapping->dir_index);
2535 if (is_free(entry)) {
2536 /* remove file/directory */
2537 if (mapping->mode & MODE_DIRECTORY) {
2538 int j, next_dir_index = s->directory.next,
2539 first_dir_index = mapping->info.dir.first_dir_index;
2541 if (rmdir(mapping->path) < 0) {
2542 if (errno == ENOTEMPTY) {
2543 deferred++;
2544 continue;
2545 } else
2546 return -5;
2549 for (j = 1; j < s->mapping.next; j++) {
2550 mapping_t* m = array_get(&(s->mapping), j);
2551 if (m->mode & MODE_DIRECTORY &&
2552 m->info.dir.first_dir_index >
2553 first_dir_index &&
2554 m->info.dir.first_dir_index <
2555 next_dir_index)
2556 next_dir_index =
2557 m->info.dir.first_dir_index;
2559 remove_direntries(s, first_dir_index,
2560 next_dir_index - first_dir_index);
2562 deleted++;
2564 } else {
2565 if (unlink(mapping->path))
2566 return -4;
2567 deleted++;
2569 DLOG(fprintf(stderr, "DELETE (%d)\n", i); print_mapping(mapping); print_direntry(entry));
2570 remove_mapping(s, i);
2575 return 0;
2579 * synchronize mapping with new state:
2581 * - copy FAT (with bdrv_read)
2582 * - mark all filenames corresponding to mappings as deleted
2583 * - recurse direntries from root (using bs->bdrv_read)
2584 * - delete files corresponding to mappings marked as deleted
2586 static int do_commit(BDRVVVFATState* s)
2588 int ret = 0;
2590 /* the real meat are the commits. Nothing to do? Move along! */
2591 if (s->commits.next == 0)
2592 return 0;
2594 vvfat_close_current_file(s);
2596 ret = handle_renames_and_mkdirs(s);
2597 if (ret) {
2598 fprintf(stderr, "Error handling renames (%d)\n", ret);
2599 assert(0);
2600 return ret;
2603 /* copy FAT (with bdrv_read) */
2604 memcpy(s->fat.pointer, s->fat2, 0x200 * s->sectors_per_fat);
2606 /* recurse direntries from root (using bs->bdrv_read) */
2607 ret = commit_direntries(s, 0, -1);
2608 if (ret) {
2609 fprintf(stderr, "Fatal: error while committing (%d)\n", ret);
2610 assert(0);
2611 return ret;
2614 ret = handle_commits(s);
2615 if (ret) {
2616 fprintf(stderr, "Error handling commits (%d)\n", ret);
2617 assert(0);
2618 return ret;
2621 ret = handle_deletes(s);
2622 if (ret) {
2623 fprintf(stderr, "Error deleting\n");
2624 assert(0);
2625 return ret;
2628 s->qcow->drv->bdrv_make_empty(s->qcow);
2630 memset(s->used_clusters, 0, sector2cluster(s, s->sector_count));
2632 DLOG(checkpoint());
2633 return 0;
2636 static int try_commit(BDRVVVFATState* s)
2638 vvfat_close_current_file(s);
2639 DLOG(checkpoint());
2640 if(!is_consistent(s))
2641 return -1;
2642 return do_commit(s);
2645 static int vvfat_write(BlockDriverState *bs, int64_t sector_num,
2646 const uint8_t *buf, int nb_sectors)
2648 BDRVVVFATState *s = bs->opaque;
2649 int i, ret;
2651 DLOG(checkpoint());
2653 vvfat_close_current_file(s);
2656 * Some sanity checks:
2657 * - do not allow writing to the boot sector
2658 * - do not allow to write non-ASCII filenames
2661 if (sector_num < s->first_sectors_number)
2662 return -1;
2664 for (i = sector2cluster(s, sector_num);
2665 i <= sector2cluster(s, sector_num + nb_sectors - 1);) {
2666 mapping_t* mapping = find_mapping_for_cluster(s, i);
2667 if (mapping) {
2668 if (mapping->read_only) {
2669 fprintf(stderr, "Tried to write to write-protected file %s\n",
2670 mapping->path);
2671 return -1;
2674 if (mapping->mode & MODE_DIRECTORY) {
2675 int begin = cluster2sector(s, i);
2676 int end = begin + s->sectors_per_cluster, k;
2677 int dir_index;
2678 const direntry_t* direntries;
2679 long_file_name lfn;
2681 lfn_init(&lfn);
2683 if (begin < sector_num)
2684 begin = sector_num;
2685 if (end > sector_num + nb_sectors)
2686 end = sector_num + nb_sectors;
2687 dir_index = mapping->dir_index +
2688 0x10 * (begin - mapping->begin * s->sectors_per_cluster);
2689 direntries = (direntry_t*)(buf + 0x200 * (begin - sector_num));
2691 for (k = 0; k < (end - begin) * 0x10; k++) {
2692 /* do not allow non-ASCII filenames */
2693 if (parse_long_name(&lfn, direntries + k) < 0) {
2694 fprintf(stderr, "Warning: non-ASCII filename\n");
2695 return -1;
2697 /* no access to the direntry of a read-only file */
2698 else if (is_short_name(direntries+k) &&
2699 (direntries[k].attributes & 1)) {
2700 if (memcmp(direntries + k,
2701 array_get(&(s->directory), dir_index + k),
2702 sizeof(direntry_t))) {
2703 fprintf(stderr, "Warning: tried to write to write-protected file\n");
2704 return -1;
2709 i = mapping->end;
2710 } else
2711 i++;
2715 * Use qcow backend. Commit later.
2717 DLOG(fprintf(stderr, "Write to qcow backend: %d + %d\n", (int)sector_num, nb_sectors));
2718 ret = s->qcow->drv->bdrv_write(s->qcow, sector_num, buf, nb_sectors);
2719 if (ret < 0) {
2720 fprintf(stderr, "Error writing to qcow backend\n");
2721 return ret;
2724 for (i = sector2cluster(s, sector_num);
2725 i <= sector2cluster(s, sector_num + nb_sectors - 1); i++)
2726 if (i >= 0)
2727 s->used_clusters[i] |= USED_ALLOCATED;
2729 DLOG(checkpoint());
2730 /* TODO: add timeout */
2731 try_commit(s);
2733 DLOG(checkpoint());
2734 return 0;
2737 static int vvfat_is_allocated(BlockDriverState *bs,
2738 int64_t sector_num, int nb_sectors, int* n)
2740 BDRVVVFATState* s = bs->opaque;
2741 *n = s->sector_count - sector_num;
2742 if (*n > nb_sectors)
2743 *n = nb_sectors;
2744 else if (*n < 0)
2745 return 0;
2746 return 1;
2749 static int write_target_commit(BlockDriverState *bs, int64_t sector_num,
2750 const uint8_t* buffer, int nb_sectors) {
2751 BDRVVVFATState* s = bs->opaque;
2752 return try_commit(s);
2755 static void write_target_close(BlockDriverState *bs) {
2756 BDRVVVFATState* s = bs->opaque;
2757 bdrv_delete(s->qcow);
2758 free(s->qcow_filename);
2761 static BlockDriver vvfat_write_target = {
2762 "vvfat_write_target", 0, NULL, NULL, NULL,
2763 write_target_commit,
2764 write_target_close,
2765 NULL, NULL, NULL
2768 static int enable_write_target(BDRVVVFATState *s)
2770 int size = sector2cluster(s, s->sector_count);
2771 s->used_clusters = calloc(size, 1);
2773 array_init(&(s->commits), sizeof(commit_t));
2775 s->qcow_filename = qemu_malloc(1024);
2776 get_tmp_filename(s->qcow_filename, 1024);
2777 if (bdrv_create(&bdrv_qcow,
2778 s->qcow_filename, s->sector_count, "fat:", 0) < 0)
2779 return -1;
2780 s->qcow = bdrv_new("");
2781 if (s->qcow == NULL || bdrv_open(s->qcow, s->qcow_filename, 0) < 0)
2782 return -1;
2784 #ifndef _WIN32
2785 unlink(s->qcow_filename);
2786 #endif
2788 s->bs->backing_hd = calloc(sizeof(BlockDriverState), 1);
2789 s->bs->backing_hd->drv = &vvfat_write_target;
2790 s->bs->backing_hd->opaque = s;
2792 return 0;
2795 static void vvfat_close(BlockDriverState *bs)
2797 BDRVVVFATState *s = bs->opaque;
2799 vvfat_close_current_file(s);
2800 array_free(&(s->fat));
2801 array_free(&(s->directory));
2802 array_free(&(s->mapping));
2803 if(s->cluster_buffer)
2804 free(s->cluster_buffer);
2807 BlockDriver bdrv_vvfat = {
2808 .format_name = "vvfat",
2809 .instance_size = sizeof(BDRVVVFATState),
2810 .bdrv_open = vvfat_open,
2811 .bdrv_read = vvfat_read,
2812 .bdrv_write = vvfat_write,
2813 .bdrv_close = vvfat_close,
2814 .bdrv_is_allocated = vvfat_is_allocated,
2815 .protocol_name = "fat",
2818 #ifdef DEBUG
2819 static void checkpoint(void) {
2820 assert(((mapping_t*)array_get(&(vvv->mapping), 0))->end == 2);
2821 check1(vvv);
2822 check2(vvv);
2823 assert(!vvv->current_mapping || vvv->current_fd || (vvv->current_mapping->mode & MODE_DIRECTORY));
2824 #if 0
2825 if (((direntry_t*)vvv->directory.pointer)[1].attributes != 0xf)
2826 fprintf(stderr, "Nonono!\n");
2827 mapping_t* mapping;
2828 direntry_t* direntry;
2829 assert(vvv->mapping.size >= vvv->mapping.item_size * vvv->mapping.next);
2830 assert(vvv->directory.size >= vvv->directory.item_size * vvv->directory.next);
2831 if (vvv->mapping.next<47)
2832 return;
2833 assert((mapping = array_get(&(vvv->mapping), 47)));
2834 assert(mapping->dir_index < vvv->directory.next);
2835 direntry = array_get(&(vvv->directory), mapping->dir_index);
2836 assert(!memcmp(direntry->name, "USB H ", 11) || direntry->name[0]==0);
2837 #endif
2838 return;
2839 /* avoid compiler warnings: */
2840 hexdump(NULL, 100);
2841 remove_mapping(vvv, NULL);
2842 print_mapping(NULL);
2843 print_direntry(NULL);
2845 #endif