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