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