qemu

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

26
#include "qemu/osdep.h"
27
#include <dirent.h>
28
#include <glib/gstdio.h>
29
#include "qapi/error.h"
30
#include "block/block-io.h"
31
#include "block/block_int.h"
32
#include "block/qdict.h"
33
#include "qemu/module.h"
34
#include "qemu/option.h"
35
#include "qemu/bswap.h"
36
#include "migration/blocker.h"
37
#include "qapi/qmp/qdict.h"
38
#include "qapi/qmp/qstring.h"
39
#include "qemu/ctype.h"
40
#include "qemu/cutils.h"
41
#include "qemu/error-report.h"
42

43
#ifndef S_IWGRP
44
#define S_IWGRP 0
45
#endif
46
#ifndef S_IWOTH
47
#define S_IWOTH 0
48
#endif
49

50
/* TODO: add ":bootsector=blabla.img:" */
51
/* LATER TODO: add automatic boot sector generation from
52
    BOOTEASY.ASM and Ranish Partition Manager
53
    Note that DOS assumes the system files to be the first files in the
54
    file system (test if the boot sector still relies on that fact)! */
55
/* MAYBE TODO: write block-visofs.c */
56
/* TODO: call try_commit() only after a timeout */
57

58
/* #define DEBUG */
59

60
#ifdef DEBUG
61

62
#define DLOG(a) a
63

64
static void checkpoint(void);
65

66
#else
67

68
#define DLOG(a)
69

70
#endif
71

72
/* bootsector OEM name. see related compatibility problems at:
73
 * https://jdebp.eu/FGA/volume-boot-block-oem-name-field.html
74
 * http://seasip.info/Misc/oemid.html
75
 */
76
#define BOOTSECTOR_OEM_NAME "MSWIN4.1"
77

78
#define DIR_DELETED 0xe5
79
#define DIR_KANJI DIR_DELETED
80
#define DIR_KANJI_FAKE 0x05
81
#define DIR_FREE 0x00
82

83
/* dynamic array functions */
84
typedef struct array_t {
85
    char* pointer;
86
    unsigned int size,next,item_size;
87
} array_t;
88

89
static inline void array_init(array_t* array,unsigned int item_size)
90
{
91
    array->pointer = NULL;
92
    array->size=0;
93
    array->next=0;
94
    array->item_size=item_size;
95
}
96

97
static inline void array_free(array_t* array)
98
{
99
    g_free(array->pointer);
100
    array->size=array->next=0;
101
}
102

103
/* does not automatically grow */
104
static inline void* array_get(array_t* array,unsigned int index) {
105
    assert(index < array->next);
106
    assert(array->pointer);
107
    return array->pointer + index * array->item_size;
108
}
109

110
static inline void array_ensure_allocated(array_t *array, int index)
111
{
112
    if((index + 1) * array->item_size > array->size) {
113
        int new_size = (index + 32) * array->item_size;
114
        array->pointer = g_realloc(array->pointer, new_size);
115
        assert(array->pointer);
116
        memset(array->pointer + array->size, 0, new_size - array->size);
117
        array->size = new_size;
118
        array->next = index + 1;
119
    }
120
}
121

122
static inline void* array_get_next(array_t* array) {
123
    unsigned int next = array->next;
124

125
    array_ensure_allocated(array, next);
126
    array->next = next + 1;
127
    return array_get(array, next);
128
}
129

130
static inline void* array_insert(array_t* array,unsigned int index,unsigned int count) {
131
    if((array->next+count)*array->item_size>array->size) {
132
        int increment=count*array->item_size;
133
        array->pointer=g_realloc(array->pointer,array->size+increment);
134
        if(!array->pointer)
135
            return NULL;
136
        array->size+=increment;
137
    }
138
    memmove(array->pointer+(index+count)*array->item_size,
139
                array->pointer+index*array->item_size,
140
                (array->next-index)*array->item_size);
141
    array->next+=count;
142
    return array->pointer+index*array->item_size;
143
}
144

145
static inline int array_remove_slice(array_t* array,int index, int count)
146
{
147
    assert(index >=0);
148
    assert(count > 0);
149
    assert(index + count <= array->next);
150

151
    memmove(array->pointer + index * array->item_size,
152
            array->pointer + (index + count) * array->item_size,
153
            (array->next - index - count) * array->item_size);
154

155
    array->next -= count;
156
    return 0;
157
}
158

159
static int array_remove(array_t* array,int index)
160
{
161
    return array_remove_slice(array, index, 1);
162
}
163

164
/* return the index for a given member */
165
static int array_index(array_t* array, void* pointer)
166
{
167
    size_t offset = (char*)pointer - array->pointer;
168
    assert((offset % array->item_size) == 0);
169
    assert(offset/array->item_size < array->next);
170
    return offset/array->item_size;
171
}
172

173
/* These structures are used to fake a disk and the VFAT filesystem.
174
 * For this reason we need to use QEMU_PACKED. */
175

176
typedef struct bootsector_t {
177
    uint8_t jump[3];
178
    uint8_t name[8];
179
    uint16_t sector_size;
180
    uint8_t sectors_per_cluster;
181
    uint16_t reserved_sectors;
182
    uint8_t number_of_fats;
183
    uint16_t root_entries;
184
    uint16_t total_sectors16;
185
    uint8_t media_type;
186
    uint16_t sectors_per_fat;
187
    uint16_t sectors_per_track;
188
    uint16_t number_of_heads;
189
    uint32_t hidden_sectors;
190
    uint32_t total_sectors;
191
    union {
192
        struct {
193
            uint8_t drive_number;
194
            uint8_t reserved1;
195
            uint8_t signature;
196
            uint32_t id;
197
            uint8_t volume_label[11];
198
            uint8_t fat_type[8];
199
            uint8_t ignored[0x1c0];
200
        } QEMU_PACKED fat16;
201
        struct {
202
            uint32_t sectors_per_fat;
203
            uint16_t flags;
204
            uint8_t major,minor;
205
            uint32_t first_cluster_of_root_dir;
206
            uint16_t info_sector;
207
            uint16_t backup_boot_sector;
208
            uint8_t reserved[12];
209
            uint8_t drive_number;
210
            uint8_t reserved1;
211
            uint8_t signature;
212
            uint32_t id;
213
            uint8_t volume_label[11];
214
            uint8_t fat_type[8];
215
            uint8_t ignored[0x1a4];
216
        } QEMU_PACKED fat32;
217
    } u;
218
    uint8_t magic[2];
219
} QEMU_PACKED bootsector_t;
220

221
typedef struct {
222
    uint8_t head;
223
    uint8_t sector;
224
    uint8_t cylinder;
225
} mbr_chs_t;
226

227
typedef struct partition_t {
228
    uint8_t attributes; /* 0x80 = bootable */
229
    mbr_chs_t start_CHS;
230
    uint8_t   fs_type; /* 0x1 = FAT12, 0x6 = FAT16, 0xe = FAT16_LBA, 0xb = FAT32, 0xc = FAT32_LBA */
231
    mbr_chs_t end_CHS;
232
    uint32_t start_sector_long;
233
    uint32_t length_sector_long;
234
} QEMU_PACKED partition_t;
235

236
typedef struct mbr_t {
237
    uint8_t ignored[0x1b8];
238
    uint32_t nt_id;
239
    uint8_t ignored2[2];
240
    partition_t partition[4];
241
    uint8_t magic[2];
242
} QEMU_PACKED mbr_t;
243

244
typedef struct direntry_t {
245
    uint8_t name[8 + 3];
246
    uint8_t attributes;
247
    uint8_t reserved[2];
248
    uint16_t ctime;
249
    uint16_t cdate;
250
    uint16_t adate;
251
    uint16_t begin_hi;
252
    uint16_t mtime;
253
    uint16_t mdate;
254
    uint16_t begin;
255
    uint32_t size;
256
} QEMU_PACKED direntry_t;
257

258
/* this structure are used to transparently access the files */
259

260
typedef struct mapping_t {
261
    /* begin is the first cluster, end is the last+1 */
262
    uint32_t begin,end;
263
    /* as s->directory is growable, no pointer may be used here */
264
    unsigned int dir_index;
265
    /* the clusters of a file may be in any order; this points to the first */
266
    int first_mapping_index;
267
    union {
268
        /* offset is
269
         * - the offset in the file (in clusters) for a file, or
270
         * - the next cluster of the directory for a directory
271
         */
272
        struct {
273
            uint32_t offset;
274
        } file;
275
        struct {
276
            int parent_mapping_index;
277
            int first_dir_index;
278
        } dir;
279
    } info;
280
    /* path contains the full path, i.e. it always starts with s->path */
281
    char* path;
282

283
    enum {
284
        MODE_UNDEFINED = 0,
285
        MODE_NORMAL = 1,
286
        MODE_MODIFIED = 2,
287
        MODE_DIRECTORY = 4,
288
        MODE_DELETED = 8,
289
    } mode;
290
    int read_only;
291
} mapping_t;
292

293
#ifdef DEBUG
294
static void print_direntry(const struct direntry_t*);
295
static void print_mapping(const struct mapping_t* mapping);
296
#endif
297

298
/* here begins the real VVFAT driver */
299

300
typedef struct BDRVVVFATState {
301
    CoMutex lock;
302
    BlockDriverState* bs; /* pointer to parent */
303
    unsigned char first_sectors[0x40*0x200];
304

305
    int fat_type; /* 16 or 32 */
306
    array_t fat,directory,mapping;
307
    char volume_label[11];
308

309
    uint32_t offset_to_bootsector; /* 0 for floppy, 0x3f for disk */
310

311
    unsigned int cluster_size;
312
    unsigned int sectors_per_cluster;
313
    unsigned int sectors_per_fat;
314
    uint32_t last_cluster_of_root_directory;
315
    /* how many entries are available in root directory (0 for FAT32) */
316
    uint16_t root_entries;
317
    uint32_t sector_count; /* total number of sectors of the partition */
318
    uint32_t cluster_count; /* total number of clusters of this partition */
319
    uint32_t max_fat_value;
320
    uint32_t offset_to_fat;
321
    uint32_t offset_to_root_dir;
322

323
    int current_fd;
324
    mapping_t* current_mapping;
325
    unsigned char* cluster; /* points to current cluster */
326
    unsigned char* cluster_buffer; /* points to a buffer to hold temp data */
327
    unsigned int current_cluster;
328

329
    /* write support */
330
    char* qcow_filename;
331
    BdrvChild* qcow;
332
    void* fat2;
333
    char* used_clusters;
334
    array_t commits;
335
    const char* path;
336
    int downcase_short_names;
337

338
    Error *migration_blocker;
339
} BDRVVVFATState;
340

341
/* take the sector position spos and convert it to Cylinder/Head/Sector position
342
 * if the position is outside the specified geometry, fill maximum value for CHS
343
 * and return 1 to signal overflow.
344
 */
345
static int sector2CHS(mbr_chs_t *chs, int spos, int cyls, int heads, int secs)
346
{
347
    int head,sector;
348
    sector   = spos % secs;  spos /= secs;
349
    head     = spos % heads; spos /= heads;
350
    if (spos >= cyls) {
351
        /* Overflow,
352
        it happens if 32bit sector positions are used, while CHS is only 24bit.
353
        Windows/Dos is said to take 1023/255/63 as nonrepresentable CHS */
354
        chs->head     = 0xFF;
355
        chs->sector   = 0xFF;
356
        chs->cylinder = 0xFF;
357
        return 1;
358
    }
359
    chs->head     = (uint8_t)head;
360
    chs->sector   = (uint8_t)( (sector+1) | ((spos>>8)<<6) );
361
    chs->cylinder = (uint8_t)spos;
362
    return 0;
363
}
364

365
static void init_mbr(BDRVVVFATState *s, int cyls, int heads, int secs)
366
{
367
    /* TODO: if the files mbr.img and bootsect.img exist, use them */
368
    mbr_t* real_mbr=(mbr_t*)s->first_sectors;
369
    partition_t* partition = &(real_mbr->partition[0]);
370
    int lba;
371

372
    memset(s->first_sectors,0,512);
373

374
    /* Win NT Disk Signature */
375
    real_mbr->nt_id= cpu_to_le32(0xbe1afdfa);
376

377
    partition->attributes=0x80; /* bootable */
378

379
    /* LBA is used when partition is outside the CHS geometry */
380
    lba  = sector2CHS(&partition->start_CHS, s->offset_to_bootsector,
381
                     cyls, heads, secs);
382
    lba |= sector2CHS(&partition->end_CHS,   s->bs->total_sectors - 1,
383
                     cyls, heads, secs);
384

385
    /*LBA partitions are identified only by start/length_sector_long not by CHS*/
386
    partition->start_sector_long  = cpu_to_le32(s->offset_to_bootsector);
387
    partition->length_sector_long = cpu_to_le32(s->bs->total_sectors
388
                                                - s->offset_to_bootsector);
389

390
    /* FAT12/FAT16/FAT32 */
391
    /* DOS uses different types when partition is LBA,
392
       probably to prevent older versions from using CHS on them */
393
    partition->fs_type = s->fat_type == 12 ? 0x1 :
394
                         s->fat_type == 16 ? (lba ? 0xe : 0x06) :
395
                       /*s->fat_type == 32*/ (lba ? 0xc : 0x0b);
396

397
    real_mbr->magic[0]=0x55; real_mbr->magic[1]=0xaa;
398
}
399

400
/* direntry functions */
401

402
static direntry_t *create_long_filename(BDRVVVFATState *s, const char *filename)
403
{
404
    int number_of_entries, i;
405
    glong length;
406
    direntry_t *entry;
407

408
    gunichar2 *longname = g_utf8_to_utf16(filename, -1, NULL, &length, NULL);
409
    if (!longname) {
410
        fprintf(stderr, "vvfat: invalid UTF-8 name: %s\n", filename);
411
        return NULL;
412
    }
413

414
    number_of_entries = DIV_ROUND_UP(length * 2, 26);
415

416
    for(i=0;i<number_of_entries;i++) {
417
        entry=array_get_next(&(s->directory));
418
        entry->attributes=0xf;
419
        entry->reserved[0]=0;
420
        entry->begin=0;
421
        entry->name[0]=(number_of_entries-i)|(i==0?0x40:0);
422
    }
423
    for(i=0;i<26*number_of_entries;i++) {
424
        int offset=(i%26);
425
        if(offset<10) offset=1+offset;
426
        else if(offset<22) offset=14+offset-10;
427
        else offset=28+offset-22;
428
        entry=array_get(&(s->directory),s->directory.next-1-(i/26));
429
        if (i >= 2 * length + 2) {
430
            entry->name[offset] = 0xff;
431
        } else if (i % 2 == 0) {
432
            entry->name[offset] = longname[i / 2] & 0xff;
433
        } else {
434
            entry->name[offset] = longname[i / 2] >> 8;
435
        }
436
    }
437
    g_free(longname);
438
    return array_get(&(s->directory),s->directory.next-number_of_entries);
439
}
440

441
static char is_free(const direntry_t* direntry)
442
{
443
    return direntry->name[0] == DIR_DELETED || direntry->name[0] == DIR_FREE;
444
}
445

446
static char is_volume_label(const direntry_t* direntry)
447
{
448
    return direntry->attributes == 0x28;
449
}
450

451
static char is_long_name(const direntry_t* direntry)
452
{
453
    return direntry->attributes == 0xf;
454
}
455

456
static char is_short_name(const direntry_t* direntry)
457
{
458
    return !is_volume_label(direntry) && !is_long_name(direntry)
459
        && !is_free(direntry);
460
}
461

462
static char is_directory(const direntry_t* direntry)
463
{
464
    return direntry->attributes & 0x10 && direntry->name[0] != DIR_DELETED;
465
}
466

467
static inline char is_dot(const direntry_t* direntry)
468
{
469
    return is_short_name(direntry) && direntry->name[0] == '.';
470
}
471

472
static char is_file(const direntry_t* direntry)
473
{
474
    return is_short_name(direntry) && !is_directory(direntry);
475
}
476

477
static inline uint32_t begin_of_direntry(const direntry_t* direntry)
478
{
479
    return le16_to_cpu(direntry->begin)|(le16_to_cpu(direntry->begin_hi)<<16);
480
}
481

482
static inline uint32_t filesize_of_direntry(const direntry_t* direntry)
483
{
484
    return le32_to_cpu(direntry->size);
485
}
486

487
static void set_begin_of_direntry(direntry_t* direntry, uint32_t begin)
488
{
489
    direntry->begin = cpu_to_le16(begin & 0xffff);
490
    direntry->begin_hi = cpu_to_le16((begin >> 16) & 0xffff);
491
}
492

493
static bool valid_filename(const unsigned char *name)
494
{
495
    unsigned char c;
496
    if (!strcmp((const char*)name, ".") || !strcmp((const char*)name, "..")) {
497
        return false;
498
    }
499
    for (; (c = *name); name++) {
500
        if (!((c >= '0' && c <= '9') ||
501
              (c >= 'A' && c <= 'Z') ||
502
              (c >= 'a' && c <= 'z') ||
503
              c > 127 ||
504
              strchr(" $%'-_@~`!(){}^#&.+,;=[]", c) != NULL))
505
        {
506
            return false;
507
        }
508
    }
509
    return true;
510
}
511

512
static uint8_t to_valid_short_char(gunichar c)
513
{
514
    c = g_unichar_toupper(c);
515
    if ((c >= '0' && c <= '9') ||
516
        (c >= 'A' && c <= 'Z') ||
517
        strchr("$%'-_@~`!(){}^#&", c) != NULL) {
518
        return c;
519
    } else {
520
        return 0;
521
    }
522
}
523

524
static direntry_t *create_short_filename(BDRVVVFATState *s,
525
                                         const char *filename,
526
                                         unsigned int directory_start)
527
{
528
    int i, j = 0;
529
    direntry_t *entry = array_get_next(&(s->directory));
530
    const gchar *p, *last_dot = NULL;
531
    gunichar c;
532
    bool lossy_conversion = false;
533
    char tail[8];
534

535
    if (!entry) {
536
        return NULL;
537
    }
538
    memset(entry->name, 0x20, sizeof(entry->name));
539

540
    /* copy filename and search last dot */
541
    for (p = filename; ; p = g_utf8_next_char(p)) {
542
        c = g_utf8_get_char(p);
543
        if (c == '\0') {
544
            break;
545
        } else if (c == '.') {
546
            if (j == 0) {
547
                /* '.' at start of filename */
548
                lossy_conversion = true;
549
            } else {
550
                if (last_dot) {
551
                    lossy_conversion = true;
552
                }
553
                last_dot = p;
554
            }
555
        } else if (!last_dot) {
556
            /* first part of the name; copy it */
557
            uint8_t v = to_valid_short_char(c);
558
            if (j < 8 && v) {
559
                entry->name[j++] = v;
560
            } else {
561
                lossy_conversion = true;
562
            }
563
        }
564
    }
565

566
    /* copy extension (if any) */
567
    if (last_dot) {
568
        j = 0;
569
        for (p = g_utf8_next_char(last_dot); ; p = g_utf8_next_char(p)) {
570
            c = g_utf8_get_char(p);
571
            if (c == '\0') {
572
                break;
573
            } else {
574
                /* extension; copy it */
575
                uint8_t v = to_valid_short_char(c);
576
                if (j < 3 && v) {
577
                    entry->name[8 + (j++)] = v;
578
                } else {
579
                    lossy_conversion = true;
580
                }
581
            }
582
        }
583
    }
584

585
    if (entry->name[0] == DIR_KANJI) {
586
        entry->name[0] = DIR_KANJI_FAKE;
587
    }
588

589
    /* numeric-tail generation */
590
    for (j = 0; j < 8; j++) {
591
        if (entry->name[j] == ' ') {
592
            break;
593
        }
594
    }
595
    for (i = lossy_conversion ? 1 : 0; i < 999999; i++) {
596
        direntry_t *entry1;
597
        if (i > 0) {
598
            int len = snprintf(tail, sizeof(tail), "~%u", (unsigned)i);
599
            assert(len <= 7);
600
            memcpy(entry->name + MIN(j, 8 - len), tail, len);
601
        }
602
        for (entry1 = array_get(&(s->directory), directory_start);
603
             entry1 < entry; entry1++) {
604
            if (!is_long_name(entry1) &&
605
                !memcmp(entry1->name, entry->name, 11)) {
606
                break; /* found dupe */
607
            }
608
        }
609
        if (entry1 == entry) {
610
            /* no dupe found */
611
            return entry;
612
        }
613
    }
614
    return NULL;
615
}
616

617
/* fat functions */
618

619
static inline uint8_t fat_chksum(const direntry_t* entry)
620
{
621
    uint8_t chksum=0;
622
    int i;
623

624
    for (i = 0; i < ARRAY_SIZE(entry->name); i++) {
625
        chksum = (((chksum & 0xfe) >> 1) |
626
                  ((chksum & 0x01) ? 0x80 : 0)) + entry->name[i];
627
    }
628

629
    return chksum;
630
}
631

632
/* if return_time==0, this returns the fat_date, else the fat_time */
633
static uint16_t fat_datetime(time_t time,int return_time) {
634
    struct tm* t;
635
    struct tm t1;
636
    t = &t1;
637
    localtime_r(&time,t);
638
    if(return_time)
639
        return cpu_to_le16((t->tm_sec/2)|(t->tm_min<<5)|(t->tm_hour<<11));
640
    return cpu_to_le16((t->tm_mday)|((t->tm_mon+1)<<5)|((t->tm_year-80)<<9));
641
}
642

643
static inline void fat_set(BDRVVVFATState* s,unsigned int cluster,uint32_t value)
644
{
645
    if(s->fat_type==32) {
646
        uint32_t* entry=array_get(&(s->fat),cluster);
647
        *entry=cpu_to_le32(value);
648
    } else if(s->fat_type==16) {
649
        uint16_t* entry=array_get(&(s->fat),cluster);
650
        *entry=cpu_to_le16(value&0xffff);
651
    } else {
652
        int offset = (cluster*3/2);
653
        unsigned char* p = array_get(&(s->fat), offset);
654
        switch (cluster&1) {
655
        case 0:
656
                p[0] = value&0xff;
657
                p[1] = (p[1]&0xf0) | ((value>>8)&0xf);
658
                break;
659
        case 1:
660
                p[0] = (p[0]&0xf) | ((value&0xf)<<4);
661
                p[1] = (value>>4);
662
                break;
663
        }
664
    }
665
}
666

667
static inline uint32_t fat_get(BDRVVVFATState* s,unsigned int cluster)
668
{
669
    if(s->fat_type==32) {
670
        uint32_t* entry=array_get(&(s->fat),cluster);
671
        return le32_to_cpu(*entry);
672
    } else if(s->fat_type==16) {
673
        uint16_t* entry=array_get(&(s->fat),cluster);
674
        return le16_to_cpu(*entry);
675
    } else {
676
        const uint8_t* x=(uint8_t*)(s->fat.pointer)+cluster*3/2;
677
        return ((x[0]|(x[1]<<8))>>(cluster&1?4:0))&0x0fff;
678
    }
679
}
680

681
static inline int fat_eof(BDRVVVFATState* s,uint32_t fat_entry)
682
{
683
    if(fat_entry>s->max_fat_value-8)
684
        return -1;
685
    return 0;
686
}
687

688
static inline void init_fat(BDRVVVFATState* s)
689
{
690
    if (s->fat_type == 12) {
691
        array_init(&(s->fat),1);
692
        array_ensure_allocated(&(s->fat),
693
                s->sectors_per_fat * 0x200 * 3 / 2 - 1);
694
    } else {
695
        array_init(&(s->fat),(s->fat_type==32?4:2));
696
        array_ensure_allocated(&(s->fat),
697
                s->sectors_per_fat * 0x200 / s->fat.item_size - 1);
698
    }
699
    memset(s->fat.pointer,0,s->fat.size);
700

701
    switch(s->fat_type) {
702
        case 12: s->max_fat_value=0xfff; break;
703
        case 16: s->max_fat_value=0xffff; break;
704
        case 32: s->max_fat_value=0x0fffffff; break;
705
        default: s->max_fat_value=0; /* error... */
706
    }
707

708
}
709

710
static inline direntry_t* create_short_and_long_name(BDRVVVFATState* s,
711
        unsigned int directory_start, const char* filename, int is_dot)
712
{
713
    int long_index = s->directory.next;
714
    direntry_t* entry = NULL;
715
    direntry_t* entry_long = NULL;
716

717
    if(is_dot) {
718
        entry=array_get_next(&(s->directory));
719
        memset(entry->name, 0x20, sizeof(entry->name));
720
        memcpy(entry->name,filename,strlen(filename));
721
        return entry;
722
    }
723

724
    entry_long=create_long_filename(s,filename);
725
    entry = create_short_filename(s, filename, directory_start);
726

727
    /* calculate checksum; propagate to long name */
728
    if(entry_long) {
729
        uint8_t chksum=fat_chksum(entry);
730

731
        /* calculate anew, because realloc could have taken place */
732
        entry_long=array_get(&(s->directory),long_index);
733
        while(entry_long<entry && is_long_name(entry_long)) {
734
            entry_long->reserved[1]=chksum;
735
            entry_long++;
736
        }
737
    }
738

739
    return entry;
740
}
741

742
/*
743
 * Read a directory. (the index of the corresponding mapping must be passed).
744
 */
745
static int read_directory(BDRVVVFATState* s, int mapping_index)
746
{
747
    mapping_t* mapping = array_get(&(s->mapping), mapping_index);
748
    direntry_t* direntry;
749
    const char* dirname = mapping->path;
750
    int first_cluster = mapping->begin;
751
    int parent_index = mapping->info.dir.parent_mapping_index;
752
    mapping_t* parent_mapping = (mapping_t*)
753
        (parent_index >= 0 ? array_get(&(s->mapping), parent_index) : NULL);
754
    int first_cluster_of_parent = parent_mapping ? parent_mapping->begin : -1;
755

756
    DIR* dir=opendir(dirname);
757
    struct dirent* entry;
758
    int i;
759

760
    assert(mapping->mode & MODE_DIRECTORY);
761

762
    if(!dir) {
763
        mapping->end = mapping->begin;
764
        return -1;
765
    }
766

767
    i = mapping->info.dir.first_dir_index =
768
            first_cluster == 0 ? 0 : s->directory.next;
769

770
    if (first_cluster != 0) {
771
        /* create the top entries of a subdirectory */
772
        (void)create_short_and_long_name(s, i, ".", 1);
773
        (void)create_short_and_long_name(s, i, "..", 1);
774
    }
775

776
    /* actually read the directory, and allocate the mappings */
777
    while((entry=readdir(dir))) {
778
        unsigned int length=strlen(dirname)+2+strlen(entry->d_name);
779
        char* buffer;
780
        struct stat st;
781
        int is_dot=!strcmp(entry->d_name,".");
782
        int is_dotdot=!strcmp(entry->d_name,"..");
783

784
        if (first_cluster == 0 && s->directory.next >= s->root_entries - 1) {
785
            fprintf(stderr, "Too many entries in root directory\n");
786
            closedir(dir);
787
            return -2;
788
        }
789

790
        if(first_cluster == 0 && (is_dotdot || is_dot))
791
            continue;
792

793
        buffer = g_malloc(length);
794
        snprintf(buffer,length,"%s/%s",dirname,entry->d_name);
795

796
        if(stat(buffer,&st)<0) {
797
            g_free(buffer);
798
            continue;
799
        }
800

801
        /* create directory entry for this file */
802
        if (!is_dot && !is_dotdot) {
803
            direntry = create_short_and_long_name(s, i, entry->d_name, 0);
804
        } else {
805
            direntry = array_get(&(s->directory), is_dot ? i : i + 1);
806
        }
807
        direntry->attributes=(S_ISDIR(st.st_mode)?0x10:0x20);
808
        direntry->reserved[0]=direntry->reserved[1]=0;
809
        direntry->ctime=fat_datetime(st.st_ctime,1);
810
        direntry->cdate=fat_datetime(st.st_ctime,0);
811
        direntry->adate=fat_datetime(st.st_atime,0);
812
        direntry->begin_hi=0;
813
        direntry->mtime=fat_datetime(st.st_mtime,1);
814
        direntry->mdate=fat_datetime(st.st_mtime,0);
815
        if(is_dotdot)
816
            set_begin_of_direntry(direntry, first_cluster_of_parent);
817
        else if(is_dot)
818
            set_begin_of_direntry(direntry, first_cluster);
819
        else
820
            direntry->begin=0; /* do that later */
821
        if (st.st_size > 0x7fffffff) {
822
            fprintf(stderr, "File %s is larger than 2GB\n", buffer);
823
            g_free(buffer);
824
            closedir(dir);
825
            return -2;
826
        }
827
        direntry->size=cpu_to_le32(S_ISDIR(st.st_mode)?0:st.st_size);
828

829
        /* create mapping for this file */
830
        if(!is_dot && !is_dotdot && (S_ISDIR(st.st_mode) || st.st_size)) {
831
            s->current_mapping = array_get_next(&(s->mapping));
832
            s->current_mapping->begin=0;
833
            s->current_mapping->end=st.st_size;
834
            /*
835
             * we get the direntry of the most recent direntry, which
836
             * contains the short name and all the relevant information.
837
             */
838
            s->current_mapping->dir_index=s->directory.next-1;
839
            s->current_mapping->first_mapping_index = -1;
840
            if (S_ISDIR(st.st_mode)) {
841
                s->current_mapping->mode = MODE_DIRECTORY;
842
                s->current_mapping->info.dir.parent_mapping_index =
843
                    mapping_index;
844
            } else {
845
                s->current_mapping->mode = MODE_UNDEFINED;
846
                s->current_mapping->info.file.offset = 0;
847
            }
848
            s->current_mapping->path=buffer;
849
            s->current_mapping->read_only =
850
                (st.st_mode & (S_IWUSR | S_IWGRP | S_IWOTH)) == 0;
851
        } else {
852
            g_free(buffer);
853
        }
854
    }
855
    closedir(dir);
856

857
    /* fill with zeroes up to the end of the cluster */
858
    while(s->directory.next%(0x10*s->sectors_per_cluster)) {
859
        direntry = array_get_next(&(s->directory));
860
        memset(direntry,0,sizeof(direntry_t));
861
    }
862

863
    if (s->fat_type != 32 &&
864
        mapping_index == 0 &&
865
        s->directory.next < s->root_entries) {
866
        /* root directory */
867
        int cur = s->directory.next;
868
        array_ensure_allocated(&(s->directory), s->root_entries - 1);
869
        s->directory.next = s->root_entries;
870
        memset(array_get(&(s->directory), cur), 0,
871
                (s->root_entries - cur) * sizeof(direntry_t));
872
    }
873

874
    /* re-get the mapping, since s->mapping was possibly realloc()ed */
875
    mapping = array_get(&(s->mapping), mapping_index);
876
    first_cluster += (s->directory.next - mapping->info.dir.first_dir_index)
877
        * 0x20 / s->cluster_size;
878
    mapping->end = first_cluster;
879

880
    direntry = array_get(&(s->directory), mapping->dir_index);
881
    set_begin_of_direntry(direntry, mapping->begin);
882

883
    return 0;
884
}
885

886
static inline int32_t sector2cluster(BDRVVVFATState* s,off_t sector_num)
887
{
888
    return (sector_num - s->offset_to_root_dir) / s->sectors_per_cluster;
889
}
890

891
static inline off_t cluster2sector(BDRVVVFATState* s, uint32_t cluster_num)
892
{
893
    return s->offset_to_root_dir + s->sectors_per_cluster * cluster_num;
894
}
895

896
static int init_directories(BDRVVVFATState* s,
897
                            const char *dirname, int heads, int secs,
898
                            Error **errp)
899
{
900
    bootsector_t* bootsector;
901
    mapping_t* mapping;
902
    unsigned int i;
903
    unsigned int cluster;
904

905
    memset(&(s->first_sectors[0]),0,0x40*0x200);
906

907
    s->cluster_size=s->sectors_per_cluster*0x200;
908
    s->cluster_buffer=g_malloc(s->cluster_size);
909

910
    /*
911
     * The formula: sc = spf+1+spf*spc*(512*8/fat_type),
912
     * where sc is sector_count,
913
     * spf is sectors_per_fat,
914
     * spc is sectors_per_clusters, and
915
     * fat_type = 12, 16 or 32.
916
     */
917
    i = 1+s->sectors_per_cluster*0x200*8/s->fat_type;
918
    s->sectors_per_fat=(s->sector_count+i)/i; /* round up */
919

920
    s->offset_to_fat = s->offset_to_bootsector + 1;
921
    s->offset_to_root_dir = s->offset_to_fat + s->sectors_per_fat * 2;
922

923
    array_init(&(s->mapping),sizeof(mapping_t));
924
    array_init(&(s->directory),sizeof(direntry_t));
925

926
    /* add volume label */
927
    {
928
        direntry_t* entry=array_get_next(&(s->directory));
929
        entry->attributes=0x28; /* archive | volume label */
930
        memcpy(entry->name, s->volume_label, sizeof(entry->name));
931
    }
932

933
    /* Now build FAT, and write back information into directory */
934
    init_fat(s);
935

936
    /* TODO: if there are more entries, bootsector has to be adjusted! */
937
    s->root_entries = 0x02 * 0x10 * s->sectors_per_cluster;
938
    s->cluster_count=sector2cluster(s, s->sector_count);
939

940
    mapping = array_get_next(&(s->mapping));
941
    mapping->begin = 0;
942
    mapping->dir_index = 0;
943
    mapping->info.dir.parent_mapping_index = -1;
944
    mapping->first_mapping_index = -1;
945
    mapping->path = g_strdup(dirname);
946
    i = strlen(mapping->path);
947
    if (i > 0 && mapping->path[i - 1] == '/')
948
        mapping->path[i - 1] = '\0';
949
    mapping->mode = MODE_DIRECTORY;
950
    mapping->read_only = 0;
951
    s->path = mapping->path;
952

953
    for (i = 0, cluster = 0; i < s->mapping.next; i++) {
954
        /* MS-DOS expects the FAT to be 0 for the root directory
955
         * (except for the media byte). */
956
        /* LATER TODO: still true for FAT32? */
957
        int fix_fat = (i != 0);
958
        mapping = array_get(&(s->mapping), i);
959

960
        if (mapping->mode & MODE_DIRECTORY) {
961
            char *path = mapping->path;
962
            mapping->begin = cluster;
963
            if(read_directory(s, i)) {
964
                error_setg(errp, "Could not read directory %s", path);
965
                return -1;
966
            }
967
            mapping = array_get(&(s->mapping), i);
968
        } else {
969
            assert(mapping->mode == MODE_UNDEFINED);
970
            mapping->mode=MODE_NORMAL;
971
            mapping->begin = cluster;
972
            if (mapping->end > 0) {
973
                direntry_t* direntry = array_get(&(s->directory),
974
                        mapping->dir_index);
975

976
                mapping->end = cluster + 1 + (mapping->end-1)/s->cluster_size;
977
                set_begin_of_direntry(direntry, mapping->begin);
978
            } else {
979
                mapping->end = cluster + 1;
980
                fix_fat = 0;
981
            }
982
        }
983

984
        assert(mapping->begin < mapping->end);
985

986
        /* next free cluster */
987
        cluster = mapping->end;
988

989
        if(cluster > s->cluster_count) {
990
            error_setg(errp,
991
                       "Directory does not fit in FAT%d (capacity %.2f MB)",
992
                       s->fat_type, s->sector_count / 2000.0);
993
            return -1;
994
        }
995

996
        /* fix fat for entry */
997
        if (fix_fat) {
998
            int j;
999
            for(j = mapping->begin; j < mapping->end - 1; j++)
1000
                fat_set(s, j, j+1);
1001
            fat_set(s, mapping->end - 1, s->max_fat_value);
1002
        }
1003
    }
1004

1005
    mapping = array_get(&(s->mapping), 0);
1006
    s->last_cluster_of_root_directory = mapping->end;
1007

1008
    /* the FAT signature */
1009
    fat_set(s,0,s->max_fat_value);
1010
    fat_set(s,1,s->max_fat_value);
1011

1012
    s->current_mapping = NULL;
1013

1014
    bootsector = (bootsector_t *)(s->first_sectors
1015
                                  + s->offset_to_bootsector * 0x200);
1016
    bootsector->jump[0]=0xeb;
1017
    bootsector->jump[1]=0x3e;
1018
    bootsector->jump[2]=0x90;
1019
    memcpy(bootsector->name, BOOTSECTOR_OEM_NAME, 8);
1020
    bootsector->sector_size=cpu_to_le16(0x200);
1021
    bootsector->sectors_per_cluster=s->sectors_per_cluster;
1022
    bootsector->reserved_sectors=cpu_to_le16(1);
1023
    bootsector->number_of_fats=0x2; /* number of FATs */
1024
    bootsector->root_entries = cpu_to_le16(s->root_entries);
1025
    bootsector->total_sectors16=s->sector_count>0xffff?0:cpu_to_le16(s->sector_count);
1026
    /* media descriptor: hard disk=0xf8, floppy=0xf0 */
1027
    bootsector->media_type = (s->offset_to_bootsector > 0 ? 0xf8 : 0xf0);
1028
    s->fat.pointer[0] = bootsector->media_type;
1029
    bootsector->sectors_per_fat=cpu_to_le16(s->sectors_per_fat);
1030
    bootsector->sectors_per_track = cpu_to_le16(secs);
1031
    bootsector->number_of_heads = cpu_to_le16(heads);
1032
    bootsector->hidden_sectors = cpu_to_le32(s->offset_to_bootsector);
1033
    bootsector->total_sectors=cpu_to_le32(s->sector_count>0xffff?s->sector_count:0);
1034

1035
    /* LATER TODO: if FAT32, this is wrong */
1036
    /* drive_number: fda=0, hda=0x80 */
1037
    bootsector->u.fat16.drive_number = s->offset_to_bootsector == 0 ? 0 : 0x80;
1038
    bootsector->u.fat16.signature=0x29;
1039
    bootsector->u.fat16.id=cpu_to_le32(0xfabe1afd);
1040

1041
    memcpy(bootsector->u.fat16.volume_label, s->volume_label,
1042
           sizeof(bootsector->u.fat16.volume_label));
1043
    memcpy(bootsector->u.fat16.fat_type,
1044
           s->fat_type == 12 ? "FAT12   " : "FAT16   ", 8);
1045
    bootsector->magic[0]=0x55; bootsector->magic[1]=0xaa;
1046

1047
    return 0;
1048
}
1049

1050
#ifdef DEBUG
1051
static BDRVVVFATState *vvv = NULL;
1052
#endif
1053

1054
static int enable_write_target(BlockDriverState *bs, Error **errp);
1055
static int coroutine_fn is_consistent(BDRVVVFATState *s);
1056

1057
static QemuOptsList runtime_opts = {
1058
    .name = "vvfat",
1059
    .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
1060
    .desc = {
1061
        {
1062
            .name = "dir",
1063
            .type = QEMU_OPT_STRING,
1064
            .help = "Host directory to map to the vvfat device",
1065
        },
1066
        {
1067
            .name = "fat-type",
1068
            .type = QEMU_OPT_NUMBER,
1069
            .help = "FAT type (12, 16 or 32)",
1070
        },
1071
        {
1072
            .name = "floppy",
1073
            .type = QEMU_OPT_BOOL,
1074
            .help = "Create a floppy rather than a hard disk image",
1075
        },
1076
        {
1077
            .name = "label",
1078
            .type = QEMU_OPT_STRING,
1079
            .help = "Use a volume label other than QEMU VVFAT",
1080
        },
1081
        {
1082
            .name = "rw",
1083
            .type = QEMU_OPT_BOOL,
1084
            .help = "Make the image writable",
1085
        },
1086
        { /* end of list */ }
1087
    },
1088
};
1089

1090
static void vvfat_parse_filename(const char *filename, QDict *options,
1091
                                 Error **errp)
1092
{
1093
    int fat_type = 0;
1094
    bool floppy = false;
1095
    bool rw = false;
1096
    int i;
1097

1098
    if (!strstart(filename, "fat:", NULL)) {
1099
        error_setg(errp, "File name string must start with 'fat:'");
1100
        return;
1101
    }
1102

1103
    /* Parse options */
1104
    if (strstr(filename, ":32:")) {
1105
        fat_type = 32;
1106
    } else if (strstr(filename, ":16:")) {
1107
        fat_type = 16;
1108
    } else if (strstr(filename, ":12:")) {
1109
        fat_type = 12;
1110
    }
1111

1112
    if (strstr(filename, ":floppy:")) {
1113
        floppy = true;
1114
    }
1115

1116
    if (strstr(filename, ":rw:")) {
1117
        rw = true;
1118
    }
1119

1120
    /* Get the directory name without options */
1121
    i = strrchr(filename, ':') - filename;
1122
    assert(i >= 3);
1123
    if (filename[i - 2] == ':' && qemu_isalpha(filename[i - 1])) {
1124
        /* workaround for DOS drive names */
1125
        filename += i - 1;
1126
    } else {
1127
        filename += i + 1;
1128
    }
1129

1130
    /* Fill in the options QDict */
1131
    qdict_put_str(options, "dir", filename);
1132
    qdict_put_int(options, "fat-type", fat_type);
1133
    qdict_put_bool(options, "floppy", floppy);
1134
    qdict_put_bool(options, "rw", rw);
1135
}
1136

1137
static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
1138
                      Error **errp)
1139
{
1140
    BDRVVVFATState *s = bs->opaque;
1141
    int cyls, heads, secs;
1142
    bool floppy;
1143
    const char *dirname, *label;
1144
    QemuOpts *opts;
1145
    int ret;
1146

1147
    GRAPH_RDLOCK_GUARD_MAINLOOP();
1148

1149
#ifdef DEBUG
1150
    vvv = s;
1151
#endif
1152

1153
    opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
1154
    if (!qemu_opts_absorb_qdict(opts, options, errp)) {
1155
        ret = -EINVAL;
1156
        goto fail;
1157
    }
1158

1159
    dirname = qemu_opt_get(opts, "dir");
1160
    if (!dirname) {
1161
        error_setg(errp, "vvfat block driver requires a 'dir' option");
1162
        ret = -EINVAL;
1163
        goto fail;
1164
    }
1165

1166
    s->fat_type = qemu_opt_get_number(opts, "fat-type", 0);
1167
    floppy = qemu_opt_get_bool(opts, "floppy", false);
1168

1169
    memset(s->volume_label, ' ', sizeof(s->volume_label));
1170
    label = qemu_opt_get(opts, "label");
1171
    if (label) {
1172
        size_t label_length = strlen(label);
1173
        if (label_length > 11) {
1174
            error_setg(errp, "vvfat label cannot be longer than 11 bytes");
1175
            ret = -EINVAL;
1176
            goto fail;
1177
        }
1178
        memcpy(s->volume_label, label, label_length);
1179
    } else {
1180
        memcpy(s->volume_label, "QEMU VVFAT", 10);
1181
    }
1182

1183
    if (floppy) {
1184
        /* 1.44MB or 2.88MB floppy.  2.88MB can be FAT12 (default) or FAT16. */
1185
        if (!s->fat_type) {
1186
            s->fat_type = 12;
1187
            secs = 36;
1188
            s->sectors_per_cluster = 2;
1189
        } else {
1190
            secs = s->fat_type == 12 ? 18 : 36;
1191
            s->sectors_per_cluster = 1;
1192
        }
1193
        cyls = 80;
1194
        heads = 2;
1195
    } else {
1196
        /* 32MB or 504MB disk*/
1197
        if (!s->fat_type) {
1198
            s->fat_type = 16;
1199
        }
1200
        s->offset_to_bootsector = 0x3f;
1201
        cyls = s->fat_type == 12 ? 64 : 1024;
1202
        heads = 16;
1203
        secs = 63;
1204
    }
1205

1206
    switch (s->fat_type) {
1207
    case 32:
1208
        warn_report("FAT32 has not been tested. You are welcome to do so!");
1209
        break;
1210
    case 16:
1211
    case 12:
1212
        break;
1213
    default:
1214
        error_setg(errp, "Valid FAT types are only 12, 16 and 32");
1215
        ret = -EINVAL;
1216
        goto fail;
1217
    }
1218

1219

1220
    s->bs = bs;
1221

1222
    /* LATER TODO: if FAT32, adjust */
1223
    s->sectors_per_cluster=0x10;
1224

1225
    s->current_cluster=0xffffffff;
1226

1227
    s->qcow = NULL;
1228
    s->qcow_filename = NULL;
1229
    s->fat2 = NULL;
1230
    s->downcase_short_names = 1;
1231

1232
    DLOG(fprintf(stderr, "vvfat %s chs %d,%d,%d\n",
1233
                 dirname, cyls, heads, secs));
1234

1235
    s->sector_count = cyls * heads * secs - s->offset_to_bootsector;
1236
    bs->total_sectors = cyls * heads * secs;
1237

1238
    if (qemu_opt_get_bool(opts, "rw", false)) {
1239
        if (!bdrv_is_read_only(bs)) {
1240
            ret = enable_write_target(bs, errp);
1241
            if (ret < 0) {
1242
                goto fail;
1243
            }
1244
        } else {
1245
            ret = -EPERM;
1246
            error_setg(errp,
1247
                       "Unable to set VVFAT to 'rw' when drive is read-only");
1248
            goto fail;
1249
        }
1250
    } else {
1251
        ret = bdrv_apply_auto_read_only(bs, NULL, errp);
1252
        if (ret < 0) {
1253
            goto fail;
1254
        }
1255
    }
1256

1257
    if (init_directories(s, dirname, heads, secs, errp)) {
1258
        ret = -EIO;
1259
        goto fail;
1260
    }
1261

1262
    s->sector_count = s->offset_to_root_dir
1263
                    + s->sectors_per_cluster * s->cluster_count;
1264

1265
    /* Disable migration when vvfat is used rw */
1266
    if (s->qcow) {
1267
        error_setg(&s->migration_blocker,
1268
                   "The vvfat (rw) format used by node '%s' "
1269
                   "does not support live migration",
1270
                   bdrv_get_device_or_node_name(bs));
1271
        ret = migrate_add_blocker_normal(&s->migration_blocker, errp);
1272
        if (ret < 0) {
1273
            goto fail;
1274
        }
1275
    }
1276

1277
    if (s->offset_to_bootsector > 0) {
1278
        init_mbr(s, cyls, heads, secs);
1279
    }
1280

1281
    qemu_co_mutex_init(&s->lock);
1282

1283
    qemu_opts_del(opts);
1284

1285
    return 0;
1286

1287
fail:
1288
    g_free(s->qcow_filename);
1289
    s->qcow_filename = NULL;
1290
    g_free(s->cluster_buffer);
1291
    s->cluster_buffer = NULL;
1292
    g_free(s->used_clusters);
1293
    s->used_clusters = NULL;
1294

1295
    qemu_opts_del(opts);
1296
    return ret;
1297
}
1298

1299
static void vvfat_refresh_limits(BlockDriverState *bs, Error **errp)
1300
{
1301
    bs->bl.request_alignment = BDRV_SECTOR_SIZE; /* No sub-sector I/O */
1302
}
1303

1304
static inline void vvfat_close_current_file(BDRVVVFATState *s)
1305
{
1306
    if(s->current_mapping) {
1307
        s->current_mapping = NULL;
1308
        if (s->current_fd) {
1309
                qemu_close(s->current_fd);
1310
                s->current_fd = 0;
1311
        }
1312
    }
1313
    s->current_cluster = -1;
1314
}
1315

1316
/* mappings between index1 and index2-1 are supposed to be ordered
1317
 * return value is the index of the last mapping for which end>cluster_num
1318
 */
1319
static inline int find_mapping_for_cluster_aux(BDRVVVFATState* s,int cluster_num,int index1,int index2)
1320
{
1321
    while(1) {
1322
        int index3;
1323
        mapping_t* mapping;
1324
        index3=(index1+index2)/2;
1325
        mapping=array_get(&(s->mapping),index3);
1326
        assert(mapping->begin < mapping->end);
1327
        if(mapping->begin>=cluster_num) {
1328
            assert(index2!=index3 || index2==0);
1329
            if(index2==index3)
1330
                return index1;
1331
            index2=index3;
1332
        } else {
1333
            if(index1==index3)
1334
                return mapping->end<=cluster_num ? index2 : index1;
1335
            index1=index3;
1336
        }
1337
        assert(index1<=index2);
1338
        DLOG(mapping=array_get(&(s->mapping),index1);
1339
        assert(mapping->begin<=cluster_num);
1340
        assert(index2 >= s->mapping.next ||
1341
                ((mapping = array_get(&(s->mapping),index2)) &&
1342
                mapping->end>cluster_num)));
1343
    }
1344
}
1345

1346
static inline mapping_t* find_mapping_for_cluster(BDRVVVFATState* s,int cluster_num)
1347
{
1348
    int index=find_mapping_for_cluster_aux(s,cluster_num,0,s->mapping.next);
1349
    mapping_t* mapping;
1350
    if(index>=s->mapping.next)
1351
        return NULL;
1352
    mapping=array_get(&(s->mapping),index);
1353
    if(mapping->begin>cluster_num)
1354
        return NULL;
1355
    assert(mapping->begin<=cluster_num && mapping->end>cluster_num);
1356
    return mapping;
1357
}
1358

1359
static int open_file(BDRVVVFATState* s,mapping_t* mapping)
1360
{
1361
    if(!mapping)
1362
        return -1;
1363
    if(!s->current_mapping ||
1364
            strcmp(s->current_mapping->path,mapping->path)) {
1365
        /* open file */
1366
        int fd = qemu_open_old(mapping->path,
1367
                               O_RDONLY | O_BINARY | O_LARGEFILE);
1368
        if(fd<0)
1369
            return -1;
1370
        vvfat_close_current_file(s);
1371
        s->current_fd = fd;
1372
    }
1373

1374
    s->current_mapping = mapping;
1375
    return 0;
1376
}
1377

1378
static inline int read_cluster(BDRVVVFATState *s,int cluster_num)
1379
{
1380
    if(s->current_cluster != cluster_num) {
1381
        int result=0;
1382
        off_t offset;
1383
        assert(!s->current_mapping || s->current_fd || (s->current_mapping->mode & MODE_DIRECTORY));
1384
        if(!s->current_mapping
1385
                || s->current_mapping->begin>cluster_num
1386
                || s->current_mapping->end<=cluster_num) {
1387
            /* binary search of mappings for file */
1388
            mapping_t* mapping=find_mapping_for_cluster(s,cluster_num);
1389

1390
            assert(!mapping || (cluster_num>=mapping->begin && cluster_num<mapping->end));
1391

1392
            if (mapping && mapping->mode & MODE_DIRECTORY) {
1393
                vvfat_close_current_file(s);
1394
                s->current_mapping = mapping;
1395
read_cluster_directory:
1396
                offset = s->cluster_size*(cluster_num-s->current_mapping->begin);
1397
                s->cluster = (unsigned char*)s->directory.pointer+offset
1398
                        + 0x20*s->current_mapping->info.dir.first_dir_index;
1399
                assert(((s->cluster-(unsigned char*)s->directory.pointer)%s->cluster_size)==0);
1400
                assert((char*)s->cluster+s->cluster_size <= s->directory.pointer+s->directory.next*s->directory.item_size);
1401
                s->current_cluster = cluster_num;
1402
                return 0;
1403
            }
1404

1405
            if(open_file(s,mapping))
1406
                return -2;
1407
        } else if (s->current_mapping->mode & MODE_DIRECTORY)
1408
            goto read_cluster_directory;
1409

1410
        assert(s->current_fd);
1411

1412
        offset = s->cluster_size *
1413
            ((cluster_num - s->current_mapping->begin)
1414
            + s->current_mapping->info.file.offset);
1415
        if(lseek(s->current_fd, offset, SEEK_SET)!=offset)
1416
            return -3;
1417
        s->cluster=s->cluster_buffer;
1418
        result=read(s->current_fd,s->cluster,s->cluster_size);
1419
        if(result<0) {
1420
            s->current_cluster = -1;
1421
            return -1;
1422
        }
1423
        s->current_cluster = cluster_num;
1424
    }
1425
    return 0;
1426
}
1427

1428
#ifdef DEBUG
1429
static void print_direntry(const direntry_t* direntry)
1430
{
1431
    int j = 0;
1432
    char buffer[1024];
1433

1434
    fprintf(stderr, "direntry %p: ", direntry);
1435
    if(!direntry)
1436
        return;
1437
    if(is_long_name(direntry)) {
1438
        unsigned char* c=(unsigned char*)direntry;
1439
        int i;
1440
        for(i=1;i<11 && c[i] && c[i]!=0xff;i+=2)
1441
#define ADD_CHAR(c) {buffer[j] = (c); if (buffer[j] < ' ') buffer[j] = 0xb0; j++;}
1442
            ADD_CHAR(c[i]);
1443
        for(i=14;i<26 && c[i] && c[i]!=0xff;i+=2)
1444
            ADD_CHAR(c[i]);
1445
        for(i=28;i<32 && c[i] && c[i]!=0xff;i+=2)
1446
            ADD_CHAR(c[i]);
1447
        buffer[j] = 0;
1448
        fprintf(stderr, "%s\n", buffer);
1449
    } else {
1450
        int i;
1451
        for(i=0;i<11;i++)
1452
            ADD_CHAR(direntry->name[i]);
1453
        buffer[j] = 0;
1454
        fprintf(stderr, "%s attributes=0x%02x begin=%u size=%u\n",
1455
                buffer,
1456
                direntry->attributes,
1457
                begin_of_direntry(direntry),le32_to_cpu(direntry->size));
1458
    }
1459
}
1460

1461
static void print_mapping(const mapping_t* mapping)
1462
{
1463
    fprintf(stderr, "mapping (%p): begin, end = %u, %u, dir_index = %u, "
1464
        "first_mapping_index = %d, name = %s, mode = 0x%x, " ,
1465
        mapping, mapping->begin, mapping->end, mapping->dir_index,
1466
        mapping->first_mapping_index, mapping->path, mapping->mode);
1467

1468
    if (mapping->mode & MODE_DIRECTORY)
1469
        fprintf(stderr, "parent_mapping_index = %d, first_dir_index = %d\n", mapping->info.dir.parent_mapping_index, mapping->info.dir.first_dir_index);
1470
    else
1471
        fprintf(stderr, "offset = %u\n", mapping->info.file.offset);
1472
}
1473
#endif
1474

1475
static int coroutine_fn GRAPH_RDLOCK
1476
vvfat_read(BlockDriverState *bs, int64_t sector_num, uint8_t *buf, int nb_sectors)
1477
{
1478
    BDRVVVFATState *s = bs->opaque;
1479
    int i;
1480

1481
    for(i=0;i<nb_sectors;i++,sector_num++) {
1482
        if (sector_num >= bs->total_sectors)
1483
           return -1;
1484
        if (s->qcow) {
1485
            int64_t n;
1486
            int ret;
1487
            ret = bdrv_co_is_allocated(s->qcow->bs, sector_num * BDRV_SECTOR_SIZE,
1488
                                       (nb_sectors - i) * BDRV_SECTOR_SIZE, &n);
1489
            if (ret < 0) {
1490
                return ret;
1491
            }
1492
            if (ret) {
1493
                DLOG(fprintf(stderr, "sectors %" PRId64 "+%" PRId64
1494
                             " allocated\n", sector_num,
1495
                             n >> BDRV_SECTOR_BITS));
1496
                if (bdrv_co_pread(s->qcow, sector_num * BDRV_SECTOR_SIZE, n,
1497
                                  buf + i * 0x200, 0) < 0) {
1498
                    return -1;
1499
                }
1500
                i += (n >> BDRV_SECTOR_BITS) - 1;
1501
                sector_num += (n >> BDRV_SECTOR_BITS) - 1;
1502
                continue;
1503
            }
1504
            DLOG(fprintf(stderr, "sector %" PRId64 " not allocated\n",
1505
                         sector_num));
1506
        }
1507
        if (sector_num < s->offset_to_root_dir) {
1508
            if (sector_num < s->offset_to_fat) {
1509
                memcpy(buf + i * 0x200,
1510
                       &(s->first_sectors[sector_num * 0x200]),
1511
                       0x200);
1512
            } else if (sector_num < s->offset_to_fat + s->sectors_per_fat) {
1513
                memcpy(buf + i * 0x200,
1514
                       &(s->fat.pointer[(sector_num
1515
                                       - s->offset_to_fat) * 0x200]),
1516
                       0x200);
1517
            } else if (sector_num < s->offset_to_root_dir) {
1518
                memcpy(buf + i * 0x200,
1519
                       &(s->fat.pointer[(sector_num - s->offset_to_fat
1520
                                       - s->sectors_per_fat) * 0x200]),
1521
                       0x200);
1522
            }
1523
        } else {
1524
            uint32_t sector = sector_num - s->offset_to_root_dir,
1525
            sector_offset_in_cluster=(sector%s->sectors_per_cluster),
1526
            cluster_num=sector/s->sectors_per_cluster;
1527
            if(cluster_num > s->cluster_count || read_cluster(s, cluster_num) != 0) {
1528
                /* LATER TODO: strict: return -1; */
1529
                memset(buf+i*0x200,0,0x200);
1530
                continue;
1531
            }
1532
            memcpy(buf+i*0x200,s->cluster+sector_offset_in_cluster*0x200,0x200);
1533
        }
1534
    }
1535
    return 0;
1536
}
1537

1538
static int coroutine_fn GRAPH_RDLOCK
1539
vvfat_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
1540
                QEMUIOVector *qiov, BdrvRequestFlags flags)
1541
{
1542
    int ret;
1543
    BDRVVVFATState *s = bs->opaque;
1544
    uint64_t sector_num = offset >> BDRV_SECTOR_BITS;
1545
    int nb_sectors = bytes >> BDRV_SECTOR_BITS;
1546
    void *buf;
1547

1548
    assert(QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE));
1549
    assert(QEMU_IS_ALIGNED(bytes, BDRV_SECTOR_SIZE));
1550

1551
    buf = g_try_malloc(bytes);
1552
    if (bytes && buf == NULL) {
1553
        return -ENOMEM;
1554
    }
1555

1556
    qemu_co_mutex_lock(&s->lock);
1557
    ret = vvfat_read(bs, sector_num, buf, nb_sectors);
1558
    qemu_co_mutex_unlock(&s->lock);
1559

1560
    qemu_iovec_from_buf(qiov, 0, buf, bytes);
1561
    g_free(buf);
1562

1563
    return ret;
1564
}
1565

1566
/* LATER TODO: statify all functions */
1567

1568
/*
1569
 * Idea of the write support (use snapshot):
1570
 *
1571
 * 1. check if all data is consistent, recording renames, modifications,
1572
 *    new files and directories (in s->commits).
1573
 *
1574
 * 2. if the data is not consistent, stop committing
1575
 *
1576
 * 3. handle renames, and create new files and directories (do not yet
1577
 *    write their contents)
1578
 *
1579
 * 4. walk the directories, fixing the mapping and direntries, and marking
1580
 *    the handled mappings as not deleted
1581
 *
1582
 * 5. commit the contents of the files
1583
 *
1584
 * 6. handle deleted files and directories
1585
 *
1586
 */
1587

1588
typedef struct commit_t {
1589
    char* path;
1590
    union {
1591
        struct { uint32_t cluster; } rename;
1592
        struct { int dir_index; uint32_t modified_offset; } writeout;
1593
        struct { uint32_t first_cluster; } new_file;
1594
        struct { uint32_t cluster; } mkdir;
1595
    } param;
1596
    /* DELETEs and RMDIRs are handled differently: see handle_deletes() */
1597
    enum {
1598
        ACTION_RENAME, ACTION_WRITEOUT, ACTION_NEW_FILE, ACTION_MKDIR
1599
    } action;
1600
} commit_t;
1601

1602
static void clear_commits(BDRVVVFATState* s)
1603
{
1604
    int i;
1605
DLOG(fprintf(stderr, "clear_commits (%u commits)\n", s->commits.next));
1606
    for (i = 0; i < s->commits.next; i++) {
1607
        commit_t* commit = array_get(&(s->commits), i);
1608
        assert(commit->path || commit->action == ACTION_WRITEOUT);
1609
        if (commit->action != ACTION_WRITEOUT) {
1610
            assert(commit->path);
1611
            g_free(commit->path);
1612
        } else
1613
            assert(commit->path == NULL);
1614
    }
1615
    s->commits.next = 0;
1616
}
1617

1618
static void schedule_rename(BDRVVVFATState* s,
1619
        uint32_t cluster, char* new_path)
1620
{
1621
    commit_t* commit = array_get_next(&(s->commits));
1622
    commit->path = new_path;
1623
    commit->param.rename.cluster = cluster;
1624
    commit->action = ACTION_RENAME;
1625
}
1626

1627
static void schedule_writeout(BDRVVVFATState* s,
1628
        int dir_index, uint32_t modified_offset)
1629
{
1630
    commit_t* commit = array_get_next(&(s->commits));
1631
    commit->path = NULL;
1632
    commit->param.writeout.dir_index = dir_index;
1633
    commit->param.writeout.modified_offset = modified_offset;
1634
    commit->action = ACTION_WRITEOUT;
1635
}
1636

1637
static void schedule_new_file(BDRVVVFATState* s,
1638
        char* path, uint32_t first_cluster)
1639
{
1640
    commit_t* commit = array_get_next(&(s->commits));
1641
    commit->path = path;
1642
    commit->param.new_file.first_cluster = first_cluster;
1643
    commit->action = ACTION_NEW_FILE;
1644
}
1645

1646
static void schedule_mkdir(BDRVVVFATState* s, uint32_t cluster, char* path)
1647
{
1648
    commit_t* commit = array_get_next(&(s->commits));
1649
    commit->path = path;
1650
    commit->param.mkdir.cluster = cluster;
1651
    commit->action = ACTION_MKDIR;
1652
}
1653

1654
typedef struct {
1655
    /*
1656
     * Since the sequence number is at most 0x3f, and the filename
1657
     * length is at most 13 times the sequence number, the maximal
1658
     * filename length is 0x3f * 13 bytes.
1659
     */
1660
    unsigned char name[0x3f * 13 + 1];
1661
    gunichar2 name2[0x3f * 13 + 1];
1662
    int checksum, len;
1663
    int sequence_number;
1664
} long_file_name;
1665

1666
static void lfn_init(long_file_name* lfn)
1667
{
1668
   lfn->sequence_number = lfn->len = 0;
1669
   lfn->checksum = 0x100;
1670
}
1671

1672
/* return 0 if parsed successfully, > 0 if no long name, < 0 if error */
1673
static int parse_long_name(long_file_name* lfn,
1674
        const direntry_t* direntry)
1675
{
1676
    int i, j, offset;
1677
    const unsigned char* pointer = (const unsigned char*)direntry;
1678

1679
    if (!is_long_name(direntry))
1680
        return 1;
1681

1682
    if (pointer[0] & 0x40) {
1683
        /* first entry; do some initialization */
1684
        lfn->sequence_number = pointer[0] & 0x3f;
1685
        lfn->checksum = pointer[13];
1686
        lfn->name[0] = 0;
1687
        lfn->name[lfn->sequence_number * 13] = 0;
1688
    } else if ((pointer[0] & 0x3f) != --lfn->sequence_number) {
1689
        /* not the expected sequence number */
1690
        return -1;
1691
    } else if (pointer[13] != lfn->checksum) {
1692
        /* not the expected checksum */
1693
        return -2;
1694
    } else if (pointer[12] || pointer[26] || pointer[27]) {
1695
        /* invalid zero fields */
1696
        return -3;
1697
    }
1698

1699
    offset = 13 * (lfn->sequence_number - 1);
1700
    for (i = 0, j = 1; i < 13; i++, j+=2) {
1701
        if (j == 11)
1702
            j = 14;
1703
        else if (j == 26)
1704
            j = 28;
1705

1706
        if (pointer[j] == 0 && pointer[j + 1] == 0) {
1707
            /* end of long file name */
1708
            break;
1709
        }
1710
        gunichar2 c = (pointer[j + 1] << 8) + pointer[j];
1711
        lfn->name2[offset + i] = c;
1712
    }
1713

1714
    if (pointer[0] & 0x40) {
1715
        /* first entry; set len */
1716
        lfn->len = offset + i;
1717
    }
1718
    if ((pointer[0] & 0x3f) == 0x01) {
1719
        /* last entry; finalize entry */
1720
        glong olen;
1721
        gchar *utf8 = g_utf16_to_utf8(lfn->name2, lfn->len, NULL, &olen, NULL);
1722
        if (!utf8) {
1723
            return -4;
1724
        }
1725
        lfn->len = olen;
1726
        memcpy(lfn->name, utf8, olen + 1);
1727
        g_free(utf8);
1728
    }
1729

1730
    return 0;
1731
}
1732

1733
/* returns 0 if successful, >0 if no short_name, and <0 on error */
1734
static int parse_short_name(BDRVVVFATState* s,
1735
        long_file_name* lfn, direntry_t* direntry)
1736
{
1737
    int i, j;
1738

1739
    if (!is_short_name(direntry))
1740
        return 1;
1741

1742
    for (j = 7; j >= 0 && direntry->name[j] == ' '; j--);
1743
    for (i = 0; i <= j; i++) {
1744
        uint8_t c = direntry->name[i];
1745
        if (c != to_valid_short_char(c)) {
1746
            return -1;
1747
        } else if (s->downcase_short_names) {
1748
            lfn->name[i] = qemu_tolower(direntry->name[i]);
1749
        } else {
1750
            lfn->name[i] = direntry->name[i];
1751
        }
1752
    }
1753

1754
    for (j = 2; j >= 0 && direntry->name[8 + j] == ' '; j--) {
1755
    }
1756
    if (j >= 0) {
1757
        lfn->name[i++] = '.';
1758
        lfn->name[i + j + 1] = '\0';
1759
        for (;j >= 0; j--) {
1760
            uint8_t c = direntry->name[8 + j];
1761
            if (c != to_valid_short_char(c)) {
1762
                return -2;
1763
            } else if (s->downcase_short_names) {
1764
                lfn->name[i + j] = qemu_tolower(c);
1765
            } else {
1766
                lfn->name[i + j] = c;
1767
            }
1768
        }
1769
    } else
1770
        lfn->name[i + j + 1] = '\0';
1771

1772
    if (lfn->name[0] == DIR_KANJI_FAKE) {
1773
        lfn->name[0] = DIR_KANJI;
1774
    }
1775
    lfn->len = strlen((char*)lfn->name);
1776

1777
    return 0;
1778
}
1779

1780
static inline uint32_t modified_fat_get(BDRVVVFATState* s,
1781
        unsigned int cluster)
1782
{
1783
    if (cluster < s->last_cluster_of_root_directory) {
1784
        if (cluster + 1 == s->last_cluster_of_root_directory)
1785
            return s->max_fat_value;
1786
        else
1787
            return cluster + 1;
1788
    }
1789

1790
    if (s->fat_type==32) {
1791
        uint32_t* entry=((uint32_t*)s->fat2)+cluster;
1792
        return le32_to_cpu(*entry);
1793
    } else if (s->fat_type==16) {
1794
        uint16_t* entry=((uint16_t*)s->fat2)+cluster;
1795
        return le16_to_cpu(*entry);
1796
    } else {
1797
        const uint8_t* x=s->fat2+cluster*3/2;
1798
        return ((x[0]|(x[1]<<8))>>(cluster&1?4:0))&0x0fff;
1799
    }
1800
}
1801

1802
static inline bool coroutine_fn GRAPH_RDLOCK
1803
cluster_was_modified(BDRVVVFATState *s, uint32_t cluster_num)
1804
{
1805
    int was_modified = 0;
1806
    int i;
1807

1808
    if (s->qcow == NULL) {
1809
        return 0;
1810
    }
1811

1812
    for (i = 0; !was_modified && i < s->sectors_per_cluster; i++) {
1813
        was_modified = bdrv_co_is_allocated(s->qcow->bs,
1814
                                            (cluster2sector(s, cluster_num) +
1815
                                             i) * BDRV_SECTOR_SIZE,
1816
                                            BDRV_SECTOR_SIZE, NULL);
1817
    }
1818

1819
    /*
1820
     * Note that this treats failures to learn allocation status the
1821
     * same as if an allocation has occurred.  It's as safe as
1822
     * anything else, given that a failure to learn allocation status
1823
     * will probably result in more failures.
1824
     */
1825
    return !!was_modified;
1826
}
1827

1828
static const char* get_basename(const char* path)
1829
{
1830
    char* basename = strrchr(path, '/');
1831
    if (basename == NULL)
1832
        return path;
1833
    else
1834
        return basename + 1; /* strip '/' */
1835
}
1836

1837
/*
1838
 * The array s->used_clusters holds the states of the clusters. If it is
1839
 * part of a file, it has bit 2 set, in case of a directory, bit 1. If it
1840
 * was modified, bit 3 is set.
1841
 * If any cluster is allocated, but not part of a file or directory, this
1842
 * driver refuses to commit.
1843
 */
1844
typedef enum {
1845
     USED_DIRECTORY = 1, USED_FILE = 2, USED_ANY = 3, USED_ALLOCATED = 4
1846
} used_t;
1847

1848
/*
1849
 * get_cluster_count_for_direntry() not only determines how many clusters
1850
 * are occupied by direntry, but also if it was renamed or modified.
1851
 *
1852
 * A file is thought to be renamed *only* if there already was a file with
1853
 * exactly the same first cluster, but a different name.
1854
 *
1855
 * Further, the files/directories handled by this function are
1856
 * assumed to be *not* deleted (and *only* those).
1857
 */
1858
static uint32_t coroutine_fn GRAPH_RDLOCK
1859
get_cluster_count_for_direntry(BDRVVVFATState* s, direntry_t* direntry, const char* path)
1860
{
1861
    /*
1862
     * This is a little bit tricky:
1863
     * IF the guest OS just inserts a cluster into the file chain,
1864
     * and leaves the rest alone, (i.e. the original file had clusters
1865
     * 15 -> 16, but now has 15 -> 32 -> 16), then the following happens:
1866
     *
1867
     * - do_commit will write the cluster into the file at the given
1868
     *   offset, but
1869
     *
1870
     * - the cluster which is overwritten should be moved to a later
1871
     *   position in the file.
1872
     *
1873
     * I am not aware that any OS does something as braindead, but this
1874
     * situation could happen anyway when not committing for a long time.
1875
     * Just to be sure that this does not bite us, detect it, and copy the
1876
     * contents of the clusters to-be-overwritten into the qcow.
1877
     */
1878
    int copy_it = 0;
1879
    int was_modified = 0;
1880
    int32_t ret = 0;
1881

1882
    uint32_t cluster_num = begin_of_direntry(direntry);
1883
    uint32_t offset = 0;
1884
    mapping_t* mapping = NULL;
1885
    const char* basename2 = NULL;
1886

1887
    vvfat_close_current_file(s);
1888

1889
    /* the root directory */
1890
    if (cluster_num == 0)
1891
        return 0;
1892

1893
    /* write support */
1894
    if (s->qcow) {
1895
        basename2 = get_basename(path);
1896

1897
        mapping = find_mapping_for_cluster(s, cluster_num);
1898

1899
        if (mapping) {
1900
            const char* basename;
1901

1902
            assert(mapping->mode & MODE_DELETED);
1903
            mapping->mode &= ~MODE_DELETED;
1904

1905
            basename = get_basename(mapping->path);
1906

1907
            assert(mapping->mode & MODE_NORMAL);
1908

1909
            /* rename */
1910
            if (strcmp(basename, basename2))
1911
                schedule_rename(s, cluster_num, g_strdup(path));
1912
        } else if (is_file(direntry))
1913
            /* new file */
1914
            schedule_new_file(s, g_strdup(path), cluster_num);
1915
        else {
1916
            abort();
1917
            return 0;
1918
        }
1919
    }
1920

1921
    while(1) {
1922
        if (s->qcow) {
1923
            if (!copy_it && cluster_was_modified(s, cluster_num)) {
1924
                if (mapping == NULL ||
1925
                        mapping->begin > cluster_num ||
1926
                        mapping->end <= cluster_num)
1927
                mapping = find_mapping_for_cluster(s, cluster_num);
1928

1929

1930
                if (mapping &&
1931
                        (mapping->mode & MODE_DIRECTORY) == 0) {
1932

1933
                    /* was modified in qcow */
1934
                    if (offset != s->cluster_size
1935
                            * ((cluster_num - mapping->begin)
1936
                            + mapping->info.file.offset)) {
1937
                        /* offset of this cluster in file chain has changed */
1938
                        abort();
1939
                        copy_it = 1;
1940
                    } else if (offset == 0) {
1941
                        const char* basename = get_basename(mapping->path);
1942

1943
                        if (strcmp(basename, basename2))
1944
                            copy_it = 1;
1945
                    }
1946
                    assert(mapping->first_mapping_index == -1
1947
                            || mapping->info.file.offset > 0);
1948

1949
                    /* need to write out? */
1950
                    if (!was_modified && is_file(direntry)) {
1951
                        was_modified = 1;
1952
                        schedule_writeout(s, mapping->dir_index, offset);
1953
                    }
1954
                }
1955
            }
1956

1957
            if (copy_it) {
1958
                int i;
1959
                /*
1960
                 * This is horribly inefficient, but that is okay, since
1961
                 * it is rarely executed, if at all.
1962
                 */
1963
                int64_t offs = cluster2sector(s, cluster_num);
1964

1965
                vvfat_close_current_file(s);
1966
                for (i = 0; i < s->sectors_per_cluster; i++) {
1967
                    int res;
1968

1969
                    res = bdrv_co_is_allocated(s->qcow->bs,
1970
                                               (offs + i) * BDRV_SECTOR_SIZE,
1971
                                               BDRV_SECTOR_SIZE, NULL);
1972
                    if (res < 0) {
1973
                        return -1;
1974
                    }
1975
                    if (!res) {
1976
                        res = vvfat_read(s->bs, offs, s->cluster_buffer, 1);
1977
                        if (res) {
1978
                            return -1;
1979
                        }
1980
                        res = bdrv_co_pwrite(s->qcow, offs * BDRV_SECTOR_SIZE,
1981
                                             BDRV_SECTOR_SIZE, s->cluster_buffer,
1982
                                             0);
1983
                        if (res < 0) {
1984
                            return -2;
1985
                        }
1986
                    }
1987
                }
1988
            }
1989
        }
1990

1991
        ret++;
1992
        if (s->used_clusters[cluster_num] & USED_ANY)
1993
            return 0;
1994
        s->used_clusters[cluster_num] = USED_FILE;
1995

1996
        cluster_num = modified_fat_get(s, cluster_num);
1997

1998
        if (fat_eof(s, cluster_num))
1999
            return ret;
2000
        else if (cluster_num < 2 || cluster_num > s->max_fat_value - 16)
2001
            return -1;
2002

2003
        offset += s->cluster_size;
2004
    }
2005
}
2006

2007
/*
2008
 * This function looks at the modified data (qcow).
2009
 * It returns 0 upon inconsistency or error, and the number of clusters
2010
 * used by the directory, its subdirectories and their files.
2011
 */
2012
static int coroutine_fn GRAPH_RDLOCK
2013
check_directory_consistency(BDRVVVFATState *s, int cluster_num, const char* path)
2014
{
2015
    int ret = 0;
2016
    unsigned char* cluster = g_malloc(s->cluster_size);
2017
    direntry_t* direntries = (direntry_t*)cluster;
2018
    mapping_t* mapping = find_mapping_for_cluster(s, cluster_num);
2019

2020
    long_file_name lfn;
2021
    int path_len = strlen(path);
2022
    char path2[PATH_MAX + 1];
2023

2024
    assert(path_len < PATH_MAX); /* len was tested before! */
2025
    pstrcpy(path2, sizeof(path2), path);
2026
    path2[path_len] = '/';
2027
    path2[path_len + 1] = '\0';
2028

2029
    if (mapping) {
2030
        const char* basename = get_basename(mapping->path);
2031
        const char* basename2 = get_basename(path);
2032

2033
        assert(mapping->mode & MODE_DIRECTORY);
2034

2035
        assert(mapping->mode & MODE_DELETED);
2036
        mapping->mode &= ~MODE_DELETED;
2037

2038
        if (strcmp(basename, basename2))
2039
            schedule_rename(s, cluster_num, g_strdup(path));
2040
    } else
2041
        /* new directory */
2042
        schedule_mkdir(s, cluster_num, g_strdup(path));
2043

2044
    lfn_init(&lfn);
2045
    do {
2046
        int i;
2047
        int subret = 0;
2048

2049
        ret++;
2050

2051
        if (s->used_clusters[cluster_num] & USED_ANY) {
2052
            fprintf(stderr, "cluster %d used more than once\n", (int)cluster_num);
2053
            goto fail;
2054
        }
2055
        s->used_clusters[cluster_num] = USED_DIRECTORY;
2056

2057
DLOG(fprintf(stderr, "read cluster %d (sector %d)\n", (int)cluster_num, (int)cluster2sector(s, cluster_num)));
2058
        subret = vvfat_read(s->bs, cluster2sector(s, cluster_num), cluster,
2059
                s->sectors_per_cluster);
2060
        if (subret) {
2061
            fprintf(stderr, "Error fetching direntries\n");
2062
        fail:
2063
            g_free(cluster);
2064
            return 0;
2065
        }
2066

2067
        for (i = 0; i < 0x10 * s->sectors_per_cluster; i++) {
2068
            int cluster_count = 0;
2069

2070
DLOG(fprintf(stderr, "check direntry %d:\n", i); print_direntry(direntries + i));
2071
            if (is_volume_label(direntries + i) || is_dot(direntries + i) ||
2072
                    is_free(direntries + i))
2073
                continue;
2074

2075
            subret = parse_long_name(&lfn, direntries + i);
2076
            if (subret < 0) {
2077
                fprintf(stderr, "Error in long name\n");
2078
                goto fail;
2079
            }
2080
            if (subret == 0 || is_free(direntries + i))
2081
                continue;
2082

2083
            if (fat_chksum(direntries+i) != lfn.checksum) {
2084
                subret = parse_short_name(s, &lfn, direntries + i);
2085
                if (subret < 0) {
2086
                    fprintf(stderr, "Error in short name (%d)\n", subret);
2087
                    goto fail;
2088
                }
2089
                if (subret > 0 || !strcmp((char*)lfn.name, ".")
2090
                        || !strcmp((char*)lfn.name, ".."))
2091
                    continue;
2092
            }
2093
            lfn.checksum = 0x100; /* cannot use long name twice */
2094

2095
            if (!valid_filename(lfn.name)) {
2096
                fprintf(stderr, "Invalid file name\n");
2097
                goto fail;
2098
            }
2099
            if (path_len + 1 + lfn.len >= PATH_MAX) {
2100
                fprintf(stderr, "Name too long: %s/%s\n", path, lfn.name);
2101
                goto fail;
2102
            }
2103
            pstrcpy(path2 + path_len + 1, sizeof(path2) - path_len - 1,
2104
                    (char*)lfn.name);
2105

2106
            if (is_directory(direntries + i)) {
2107
                if (begin_of_direntry(direntries + i) == 0) {
2108
                    DLOG(fprintf(stderr, "invalid begin for directory: %s\n", path2); print_direntry(direntries + i));
2109
                    goto fail;
2110
                }
2111
                cluster_count = check_directory_consistency(s,
2112
                        begin_of_direntry(direntries + i), path2);
2113
                if (cluster_count == 0) {
2114
                    DLOG(fprintf(stderr, "problem in directory %s:\n", path2); print_direntry(direntries + i));
2115
                    goto fail;
2116
                }
2117
            } else if (is_file(direntries + i)) {
2118
                /* check file size with FAT */
2119
                cluster_count = get_cluster_count_for_direntry(s, direntries + i, path2);
2120
                if (cluster_count !=
2121
            DIV_ROUND_UP(le32_to_cpu(direntries[i].size), s->cluster_size)) {
2122
                    DLOG(fprintf(stderr, "Cluster count mismatch\n"));
2123
                    goto fail;
2124
                }
2125
            } else
2126
                abort(); /* cluster_count = 0; */
2127

2128
            ret += cluster_count;
2129
        }
2130

2131
        cluster_num = modified_fat_get(s, cluster_num);
2132
    } while(!fat_eof(s, cluster_num));
2133

2134
    g_free(cluster);
2135
    return ret;
2136
}
2137

2138
/* returns 1 on success */
2139
static int coroutine_fn GRAPH_RDLOCK
2140
is_consistent(BDRVVVFATState* s)
2141
{
2142
    int i, check;
2143
    int used_clusters_count = 0;
2144

2145
DLOG(checkpoint());
2146
    /*
2147
     * - get modified FAT
2148
     * - compare the two FATs (TODO)
2149
     * - get buffer for marking used clusters
2150
     * - recurse direntries from root (using bs->bdrv_pread to make
2151
     *    sure to get the new data)
2152
     *   - check that the FAT agrees with the size
2153
     *   - count the number of clusters occupied by this directory and
2154
     *     its files
2155
     * - check that the cumulative used cluster count agrees with the
2156
     *   FAT
2157
     * - if all is fine, return number of used clusters
2158
     */
2159
    if (s->fat2 == NULL) {
2160
        int size = 0x200 * s->sectors_per_fat;
2161
        s->fat2 = g_malloc(size);
2162
        memcpy(s->fat2, s->fat.pointer, size);
2163
    }
2164
    check = vvfat_read(s->bs,
2165
            s->offset_to_fat, s->fat2, s->sectors_per_fat);
2166
    if (check) {
2167
        fprintf(stderr, "Could not copy fat\n");
2168
        return 0;
2169
    }
2170
    assert (s->used_clusters);
2171
    for (i = 0; i < sector2cluster(s, s->sector_count); i++)
2172
        s->used_clusters[i] &= ~USED_ANY;
2173

2174
    clear_commits(s);
2175

2176
    /* mark every mapped file/directory as deleted.
2177
     * (check_directory_consistency() will unmark those still present). */
2178
    if (s->qcow)
2179
        for (i = 0; i < s->mapping.next; i++) {
2180
            mapping_t* mapping = array_get(&(s->mapping), i);
2181
            if (mapping->first_mapping_index < 0)
2182
                mapping->mode |= MODE_DELETED;
2183
        }
2184

2185
    used_clusters_count = check_directory_consistency(s, 0, s->path);
2186
    if (used_clusters_count <= 0) {
2187
        DLOG(fprintf(stderr, "problem in directory\n"));
2188
        return 0;
2189
    }
2190

2191
    check = s->last_cluster_of_root_directory;
2192
    for (i = check; i < sector2cluster(s, s->sector_count); i++) {
2193
        if (modified_fat_get(s, i)) {
2194
            if(!s->used_clusters[i]) {
2195
                DLOG(fprintf(stderr, "FAT was modified (%d), but cluster is not used?\n", i));
2196
                return 0;
2197
            }
2198
            check++;
2199
        }
2200

2201
        if (s->used_clusters[i] == USED_ALLOCATED) {
2202
            /* allocated, but not used... */
2203
            DLOG(fprintf(stderr, "unused, modified cluster: %d\n", i));
2204
            return 0;
2205
        }
2206
    }
2207

2208
    if (check != used_clusters_count)
2209
        return 0;
2210

2211
    return used_clusters_count;
2212
}
2213

2214
static inline void adjust_mapping_indices(BDRVVVFATState* s,
2215
        int offset, int adjust)
2216
{
2217
    int i;
2218

2219
    for (i = 0; i < s->mapping.next; i++) {
2220
        mapping_t* mapping = array_get(&(s->mapping), i);
2221

2222
#define ADJUST_MAPPING_INDEX(name) \
2223
        if (mapping->name >= offset) \
2224
            mapping->name += adjust
2225

2226
        ADJUST_MAPPING_INDEX(first_mapping_index);
2227
        if (mapping->mode & MODE_DIRECTORY)
2228
            ADJUST_MAPPING_INDEX(info.dir.parent_mapping_index);
2229
    }
2230
}
2231

2232
/* insert or update mapping */
2233
static mapping_t* insert_mapping(BDRVVVFATState* s,
2234
        uint32_t begin, uint32_t end)
2235
{
2236
    /*
2237
     * - find mapping where mapping->begin >= begin,
2238
     * - if mapping->begin > begin: insert
2239
     *   - adjust all references to mappings!
2240
     * - else: adjust
2241
     * - replace name
2242
     */
2243
    int index = find_mapping_for_cluster_aux(s, begin, 0, s->mapping.next);
2244
    mapping_t* mapping = NULL;
2245
    mapping_t* first_mapping = array_get(&(s->mapping), 0);
2246

2247
    if (index < s->mapping.next && (mapping = array_get(&(s->mapping), index))
2248
            && mapping->begin < begin) {
2249
        mapping->end = begin;
2250
        index++;
2251
        mapping = array_get(&(s->mapping), index);
2252
    }
2253
    if (index >= s->mapping.next || mapping->begin > begin) {
2254
        mapping = array_insert(&(s->mapping), index, 1);
2255
        mapping->path = NULL;
2256
        adjust_mapping_indices(s, index, +1);
2257
    }
2258

2259
    mapping->begin = begin;
2260
    mapping->end = end;
2261

2262
DLOG(mapping_t* next_mapping;
2263
assert(index + 1 >= s->mapping.next ||
2264
((next_mapping = array_get(&(s->mapping), index + 1)) &&
2265
 next_mapping->begin >= end)));
2266

2267
    if (s->current_mapping && first_mapping != (mapping_t*)s->mapping.pointer)
2268
        s->current_mapping = array_get(&(s->mapping),
2269
                s->current_mapping - first_mapping);
2270

2271
    return mapping;
2272
}
2273

2274
static int remove_mapping(BDRVVVFATState* s, int mapping_index)
2275
{
2276
    mapping_t* mapping = array_get(&(s->mapping), mapping_index);
2277
    mapping_t* first_mapping = array_get(&(s->mapping), 0);
2278

2279
    /* free mapping */
2280
    if (mapping->first_mapping_index < 0) {
2281
        g_free(mapping->path);
2282
    }
2283

2284
    /* remove from s->mapping */
2285
    array_remove(&(s->mapping), mapping_index);
2286

2287
    /* adjust all references to mappings */
2288
    adjust_mapping_indices(s, mapping_index, -1);
2289

2290
    if (s->current_mapping && first_mapping != (mapping_t*)s->mapping.pointer)
2291
        s->current_mapping = array_get(&(s->mapping),
2292
                s->current_mapping - first_mapping);
2293

2294
    return 0;
2295
}
2296

2297
static void adjust_dirindices(BDRVVVFATState* s, int offset, int adjust)
2298
{
2299
    int i;
2300
    for (i = 0; i < s->mapping.next; i++) {
2301
        mapping_t* mapping = array_get(&(s->mapping), i);
2302
        if (mapping->dir_index >= offset)
2303
            mapping->dir_index += adjust;
2304
        if ((mapping->mode & MODE_DIRECTORY) &&
2305
                mapping->info.dir.first_dir_index >= offset)
2306
            mapping->info.dir.first_dir_index += adjust;
2307
    }
2308
}
2309

2310
static direntry_t* insert_direntries(BDRVVVFATState* s,
2311
        int dir_index, int count)
2312
{
2313
    /*
2314
     * make room in s->directory,
2315
     * adjust_dirindices
2316
     */
2317
    direntry_t* result = array_insert(&(s->directory), dir_index, count);
2318
    if (result == NULL)
2319
        return NULL;
2320
    adjust_dirindices(s, dir_index, count);
2321
    return result;
2322
}
2323

2324
static int remove_direntries(BDRVVVFATState* s, int dir_index, int count)
2325
{
2326
    int ret = array_remove_slice(&(s->directory), dir_index, count);
2327
    if (ret)
2328
        return ret;
2329
    adjust_dirindices(s, dir_index, -count);
2330
    return 0;
2331
}
2332

2333
/*
2334
 * Adapt the mappings of the cluster chain starting at first cluster
2335
 * (i.e. if a file starts at first_cluster, the chain is followed according
2336
 * to the modified fat, and the corresponding entries in s->mapping are
2337
 * adjusted)
2338
 */
2339
static int commit_mappings(BDRVVVFATState* s,
2340
        uint32_t first_cluster, int dir_index)
2341
{
2342
    mapping_t* mapping = find_mapping_for_cluster(s, first_cluster);
2343
    direntry_t* direntry = array_get(&(s->directory), dir_index);
2344
    uint32_t cluster = first_cluster;
2345

2346
    vvfat_close_current_file(s);
2347

2348
    assert(mapping);
2349
    assert(mapping->begin == first_cluster);
2350
    mapping->first_mapping_index = -1;
2351
    mapping->dir_index = dir_index;
2352
    mapping->mode = (dir_index <= 0 || is_directory(direntry)) ?
2353
        MODE_DIRECTORY : MODE_NORMAL;
2354

2355
    while (!fat_eof(s, cluster)) {
2356
        uint32_t c, c1;
2357

2358
        for (c = cluster, c1 = modified_fat_get(s, c); c + 1 == c1;
2359
                c = c1, c1 = modified_fat_get(s, c1));
2360

2361
        c++;
2362
        if (c > mapping->end) {
2363
            int index = array_index(&(s->mapping), mapping);
2364
            int i, max_i = s->mapping.next - index;
2365
            for (i = 1; i < max_i && mapping[i].begin < c; i++);
2366
            while (--i > 0)
2367
                remove_mapping(s, index + 1);
2368
        }
2369
        assert(mapping == array_get(&(s->mapping), s->mapping.next - 1)
2370
                || mapping[1].begin >= c);
2371
        mapping->end = c;
2372

2373
        if (!fat_eof(s, c1)) {
2374
            int i = find_mapping_for_cluster_aux(s, c1, 0, s->mapping.next);
2375
            mapping_t* next_mapping = i >= s->mapping.next ? NULL :
2376
                array_get(&(s->mapping), i);
2377

2378
            if (next_mapping == NULL || next_mapping->begin > c1) {
2379
                int i1 = array_index(&(s->mapping), mapping);
2380

2381
                next_mapping = insert_mapping(s, c1, c1+1);
2382

2383
                if (c1 < c)
2384
                    i1++;
2385
                mapping = array_get(&(s->mapping), i1);
2386
            }
2387

2388
            next_mapping->dir_index = mapping->dir_index;
2389
            next_mapping->first_mapping_index =
2390
                mapping->first_mapping_index < 0 ?
2391
                array_index(&(s->mapping), mapping) :
2392
                mapping->first_mapping_index;
2393
            next_mapping->path = mapping->path;
2394
            next_mapping->mode = mapping->mode;
2395
            next_mapping->read_only = mapping->read_only;
2396
            if (mapping->mode & MODE_DIRECTORY) {
2397
                next_mapping->info.dir.parent_mapping_index =
2398
                        mapping->info.dir.parent_mapping_index;
2399
                next_mapping->info.dir.first_dir_index =
2400
                        mapping->info.dir.first_dir_index +
2401
                        0x10 * s->sectors_per_cluster *
2402
                        (mapping->end - mapping->begin);
2403
            } else
2404
                next_mapping->info.file.offset = mapping->info.file.offset +
2405
                        (mapping->end - mapping->begin);
2406

2407
            mapping = next_mapping;
2408
        }
2409

2410
        cluster = c1;
2411
    }
2412

2413
    return 0;
2414
}
2415

2416
static int coroutine_fn GRAPH_RDLOCK
2417
commit_direntries(BDRVVVFATState* s, int dir_index, int parent_mapping_index)
2418
{
2419
    direntry_t* direntry = array_get(&(s->directory), dir_index);
2420
    uint32_t first_cluster = dir_index == 0 ? 0 : begin_of_direntry(direntry);
2421
    mapping_t* mapping = find_mapping_for_cluster(s, first_cluster);
2422
    int factor = 0x10 * s->sectors_per_cluster;
2423
    int old_cluster_count, new_cluster_count;
2424
    int current_dir_index;
2425
    int first_dir_index;
2426
    int ret, i;
2427
    uint32_t c;
2428

2429
    assert(direntry);
2430
    assert(mapping);
2431
    assert(mapping->begin == first_cluster);
2432
    assert(mapping->info.dir.first_dir_index < s->directory.next);
2433
    assert(mapping->mode & MODE_DIRECTORY);
2434
    assert(dir_index == 0 || is_directory(direntry));
2435

2436
    DLOG(fprintf(stderr, "commit_direntries for %s, parent_mapping_index %d\n",
2437
                 mapping->path, parent_mapping_index));
2438

2439
    current_dir_index = mapping->info.dir.first_dir_index;
2440
    first_dir_index = current_dir_index;
2441
    mapping->info.dir.parent_mapping_index = parent_mapping_index;
2442

2443
    if (first_cluster == 0) {
2444
        old_cluster_count = new_cluster_count =
2445
            s->last_cluster_of_root_directory;
2446
    } else {
2447
        for (old_cluster_count = 0, c = first_cluster; !fat_eof(s, c);
2448
                c = fat_get(s, c))
2449
            old_cluster_count++;
2450

2451
        for (new_cluster_count = 0, c = first_cluster; !fat_eof(s, c);
2452
                c = modified_fat_get(s, c))
2453
            new_cluster_count++;
2454
    }
2455

2456
    if (new_cluster_count > old_cluster_count) {
2457
        if (insert_direntries(s,
2458
                current_dir_index + factor * old_cluster_count,
2459
                factor * (new_cluster_count - old_cluster_count)) == NULL)
2460
            return -1;
2461
    } else if (new_cluster_count < old_cluster_count)
2462
        remove_direntries(s,
2463
                current_dir_index + factor * new_cluster_count,
2464
                factor * (old_cluster_count - new_cluster_count));
2465

2466
    for (c = first_cluster; !fat_eof(s, c); c = modified_fat_get(s, c)) {
2467
        direntry_t *first_direntry;
2468

2469
        direntry = array_get(&(s->directory), current_dir_index);
2470
        ret = vvfat_read(s->bs, cluster2sector(s, c), (uint8_t *)direntry,
2471
                s->sectors_per_cluster);
2472
        if (ret)
2473
            return ret;
2474

2475
        /* The first directory entry on the filesystem is the volume name */
2476
        first_direntry = (direntry_t*) s->directory.pointer;
2477
        assert(!memcmp(first_direntry->name, s->volume_label, 11));
2478

2479
        current_dir_index += factor;
2480
    }
2481

2482
    ret = commit_mappings(s, first_cluster, dir_index);
2483
    if (ret)
2484
        return ret;
2485

2486
    /* recurse */
2487
    for (i = 0; i < factor * new_cluster_count; i++) {
2488
        direntry = array_get(&(s->directory), first_dir_index + i);
2489
        if (is_directory(direntry) && !is_dot(direntry)) {
2490
            mapping = find_mapping_for_cluster(s, first_cluster);
2491
            if (mapping == NULL) {
2492
                return -1;
2493
            }
2494
            assert(mapping->mode & MODE_DIRECTORY);
2495
            ret = commit_direntries(s, first_dir_index + i,
2496
                array_index(&(s->mapping), mapping));
2497
            if (ret)
2498
                return ret;
2499
        }
2500
    }
2501

2502
    return 0;
2503
}
2504

2505
/* commit one file (adjust contents, adjust mapping),
2506
   return first_mapping_index */
2507
static int coroutine_fn GRAPH_RDLOCK
2508
commit_one_file(BDRVVVFATState* s, int dir_index, uint32_t offset)
2509
{
2510
    direntry_t* direntry = array_get(&(s->directory), dir_index);
2511
    uint32_t c = begin_of_direntry(direntry);
2512
    uint32_t first_cluster = c;
2513
    mapping_t* mapping = find_mapping_for_cluster(s, c);
2514
    uint32_t size = filesize_of_direntry(direntry);
2515
    char *cluster;
2516
    uint32_t i;
2517
    int fd = 0;
2518

2519
    assert(offset < size);
2520
    assert((offset % s->cluster_size) == 0);
2521

2522
    if (mapping == NULL) {
2523
        return -1;
2524
    }
2525

2526
    for (i = 0; i < offset; i += s->cluster_size) {
2527
        c = modified_fat_get(s, c);
2528
    }
2529

2530
    fd = qemu_open_old(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
        return fd;
2535
    }
2536
    if (offset > 0) {
2537
        if (lseek(fd, offset, SEEK_SET) != offset) {
2538
            qemu_close(fd);
2539
            return -3;
2540
        }
2541
    }
2542

2543
    cluster = g_malloc(s->cluster_size);
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, DIV_ROUND_UP(rest_size, 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 (%u, %d)\n", i,
2665
                commit->path ? commit->path : "(null)",
2666
                commit->param.rename.cluster, commit->action);
2667
    }
2668
#endif
2669

2670
    for (i = 0; i < s->commits.next;) {
2671
        commit_t* commit = array_get(&(s->commits), i);
2672
        if (commit->action == ACTION_RENAME) {
2673
            mapping_t* mapping = find_mapping_for_cluster(s,
2674
                    commit->param.rename.cluster);
2675
            char *old_path;
2676

2677
            if (mapping == NULL) {
2678
                return -1;
2679
            }
2680
            old_path = mapping->path;
2681
            assert(commit->path);
2682
            mapping->path = commit->path;
2683
            if (rename(old_path, mapping->path))
2684
                return -2;
2685

2686
            if (mapping->mode & MODE_DIRECTORY) {
2687
                int l1 = strlen(mapping->path);
2688
                int l2 = strlen(old_path);
2689
                int diff = l1 - l2;
2690
                direntry_t* direntry = array_get(&(s->directory),
2691
                        mapping->info.dir.first_dir_index);
2692
                uint32_t c = mapping->begin;
2693
                int j = 0;
2694

2695
                /* recurse */
2696
                while (!fat_eof(s, c)) {
2697
                    do {
2698
                        direntry_t *d = direntry + j;
2699

2700
                        if (is_file(d) || (is_directory(d) && !is_dot(d))) {
2701
                            int l;
2702
                            char *new_path;
2703
                            mapping_t* m = find_mapping_for_cluster(s,
2704
                                    begin_of_direntry(d));
2705
                            if (m == NULL) {
2706
                                return -1;
2707
                            }
2708
                            l = strlen(m->path);
2709
                            new_path = g_malloc(l + diff + 1);
2710

2711
                            assert(!strncmp(m->path, mapping->path, l2));
2712

2713
                            pstrcpy(new_path, l + diff + 1, mapping->path);
2714
                            pstrcpy(new_path + l1, l + diff + 1 - l1,
2715
                                    m->path + l2);
2716

2717
                            schedule_rename(s, m->begin, new_path);
2718
                        }
2719
                        j++;
2720
                    } while (j % (0x10 * s->sectors_per_cluster) != 0);
2721
                    c = fat_get(s, c);
2722
                }
2723
            }
2724

2725
            g_free(old_path);
2726
            array_remove(&(s->commits), i);
2727
            continue;
2728
        } else if (commit->action == ACTION_MKDIR) {
2729
            mapping_t* mapping;
2730
            int j, parent_path_len;
2731

2732
            if (g_mkdir(commit->path, 0755)) {
2733
                return -5;
2734
            }
2735

2736
            mapping = insert_mapping(s, commit->param.mkdir.cluster,
2737
                    commit->param.mkdir.cluster + 1);
2738
            if (mapping == NULL)
2739
                return -6;
2740

2741
            mapping->mode = MODE_DIRECTORY;
2742
            mapping->read_only = 0;
2743
            mapping->path = commit->path;
2744
            j = s->directory.next;
2745
            assert(j);
2746
            insert_direntries(s, s->directory.next,
2747
                    0x10 * s->sectors_per_cluster);
2748
            mapping->info.dir.first_dir_index = j;
2749

2750
            parent_path_len = strlen(commit->path)
2751
                - strlen(get_basename(commit->path)) - 1;
2752
            for (j = 0; j < s->mapping.next; j++) {
2753
                mapping_t* m = array_get(&(s->mapping), j);
2754
                if (m->first_mapping_index < 0 && m != mapping &&
2755
                        !strncmp(m->path, mapping->path, parent_path_len) &&
2756
                        strlen(m->path) == parent_path_len)
2757
                    break;
2758
            }
2759
            assert(j < s->mapping.next);
2760
            mapping->info.dir.parent_mapping_index = j;
2761

2762
            array_remove(&(s->commits), i);
2763
            continue;
2764
        }
2765

2766
        i++;
2767
    }
2768
    return 0;
2769
}
2770

2771
/*
2772
 * TODO: make sure that the short name is not matching *another* file
2773
 */
2774
static int coroutine_fn GRAPH_RDLOCK handle_commits(BDRVVVFATState* s)
2775
{
2776
    int i, fail = 0;
2777

2778
    vvfat_close_current_file(s);
2779

2780
    for (i = 0; !fail && i < s->commits.next; i++) {
2781
        commit_t* commit = array_get(&(s->commits), i);
2782
        switch(commit->action) {
2783
        case ACTION_RENAME: case ACTION_MKDIR:
2784
            abort();
2785
            fail = -2;
2786
            break;
2787
        case ACTION_WRITEOUT: {
2788
            direntry_t* entry = array_get(&(s->directory),
2789
                    commit->param.writeout.dir_index);
2790
            uint32_t begin = begin_of_direntry(entry);
2791
            mapping_t* mapping = find_mapping_for_cluster(s, begin);
2792

2793
            assert(mapping);
2794
            assert(mapping->begin == begin);
2795
            assert(commit->path == NULL);
2796

2797
            if (commit_one_file(s, commit->param.writeout.dir_index,
2798
                        commit->param.writeout.modified_offset))
2799
                fail = -3;
2800

2801
            break;
2802
        }
2803
        case ACTION_NEW_FILE: {
2804
            int begin = commit->param.new_file.first_cluster;
2805
            mapping_t* mapping = find_mapping_for_cluster(s, begin);
2806
            direntry_t* entry;
2807
            int j;
2808

2809
            /* find direntry */
2810
            for (j = 0; j < s->directory.next; j++) {
2811
                entry = array_get(&(s->directory), j);
2812
                if (is_file(entry) && begin_of_direntry(entry) == begin)
2813
                    break;
2814
            }
2815

2816
            if (j >= s->directory.next) {
2817
                fail = -6;
2818
                continue;
2819
            }
2820

2821
            /* make sure there exists an initial mapping */
2822
            if (mapping && mapping->begin != begin) {
2823
                mapping->end = begin;
2824
                mapping = NULL;
2825
            }
2826
            if (mapping == NULL) {
2827
                mapping = insert_mapping(s, begin, begin+1);
2828
            }
2829
            /* most members will be fixed in commit_mappings() */
2830
            assert(commit->path);
2831
            mapping->path = commit->path;
2832
            mapping->read_only = 0;
2833
            mapping->mode = MODE_NORMAL;
2834
            mapping->info.file.offset = 0;
2835

2836
            if (commit_one_file(s, j, 0)) {
2837
                fail = -7;
2838
            }
2839

2840
            break;
2841
        }
2842
        default:
2843
            abort();
2844
        }
2845
    }
2846
    if (i > 0 && array_remove_slice(&(s->commits), 0, i))
2847
        return -1;
2848
    return fail;
2849
}
2850

2851
static int handle_deletes(BDRVVVFATState* s)
2852
{
2853
    int i, deferred = 1, deleted = 1;
2854

2855
    /* delete files corresponding to mappings marked as deleted */
2856
    /* handle DELETEs and unused mappings (modified_fat_get(s, mapping->begin) == 0) */
2857
    while (deferred && deleted) {
2858
        deferred = 0;
2859
        deleted = 0;
2860

2861
        for (i = 1; i < s->mapping.next; i++) {
2862
            mapping_t* mapping = array_get(&(s->mapping), i);
2863
            if (mapping->mode & MODE_DELETED) {
2864
                direntry_t* entry = array_get(&(s->directory),
2865
                        mapping->dir_index);
2866

2867
                if (is_free(entry)) {
2868
                    /* remove file/directory */
2869
                    if (mapping->mode & MODE_DIRECTORY) {
2870
                        int j, next_dir_index = s->directory.next,
2871
                        first_dir_index = mapping->info.dir.first_dir_index;
2872

2873
                        if (rmdir(mapping->path) < 0) {
2874
                            if (errno == ENOTEMPTY) {
2875
                                deferred++;
2876
                                continue;
2877
                            } else
2878
                                return -5;
2879
                        }
2880

2881
                        for (j = 1; j < s->mapping.next; j++) {
2882
                            mapping_t* m = array_get(&(s->mapping), j);
2883
                            if (m->mode & MODE_DIRECTORY &&
2884
                                    m->info.dir.first_dir_index >
2885
                                    first_dir_index &&
2886
                                    m->info.dir.first_dir_index <
2887
                                    next_dir_index)
2888
                                next_dir_index =
2889
                                    m->info.dir.first_dir_index;
2890
                        }
2891
                        remove_direntries(s, first_dir_index,
2892
                                next_dir_index - first_dir_index);
2893

2894
                        deleted++;
2895
                    }
2896
                } else {
2897
                    if (unlink(mapping->path))
2898
                        return -4;
2899
                    deleted++;
2900
                }
2901
                DLOG(fprintf(stderr, "DELETE (%d)\n", i); print_mapping(mapping); print_direntry(entry));
2902
                remove_mapping(s, i);
2903
            }
2904
        }
2905
    }
2906

2907
    return 0;
2908
}
2909

2910
/*
2911
 * synchronize mapping with new state:
2912
 *
2913
 * - copy FAT (with bdrv_pread)
2914
 * - mark all filenames corresponding to mappings as deleted
2915
 * - recurse direntries from root (using bs->bdrv_pread)
2916
 * - delete files corresponding to mappings marked as deleted
2917
 */
2918
static int coroutine_fn GRAPH_RDLOCK do_commit(BDRVVVFATState* s)
2919
{
2920
    int ret = 0;
2921

2922
    /* the real meat are the commits. Nothing to do? Move along! */
2923
    if (s->commits.next == 0)
2924
        return 0;
2925

2926
    vvfat_close_current_file(s);
2927

2928
    ret = handle_renames_and_mkdirs(s);
2929
    if (ret) {
2930
        fprintf(stderr, "Error handling renames (%d)\n", ret);
2931
        abort();
2932
        return ret;
2933
    }
2934

2935
    /* copy FAT (with bdrv_pread) */
2936
    memcpy(s->fat.pointer, s->fat2, 0x200 * s->sectors_per_fat);
2937

2938
    /* recurse direntries from root (using bs->bdrv_pread) */
2939
    ret = commit_direntries(s, 0, -1);
2940
    if (ret) {
2941
        fprintf(stderr, "Fatal: error while committing (%d)\n", ret);
2942
        abort();
2943
        return ret;
2944
    }
2945

2946
    ret = handle_commits(s);
2947
    if (ret) {
2948
        fprintf(stderr, "Error handling commits (%d)\n", ret);
2949
        abort();
2950
        return ret;
2951
    }
2952

2953
    ret = handle_deletes(s);
2954
    if (ret) {
2955
        fprintf(stderr, "Error deleting\n");
2956
        abort();
2957
        return ret;
2958
    }
2959

2960
    bdrv_make_empty(s->qcow, NULL);
2961

2962
    memset(s->used_clusters, 0, sector2cluster(s, s->sector_count));
2963

2964
DLOG(checkpoint());
2965
    return 0;
2966
}
2967

2968
static int coroutine_fn GRAPH_RDLOCK try_commit(BDRVVVFATState* s)
2969
{
2970
    vvfat_close_current_file(s);
2971
DLOG(checkpoint());
2972
    if(!is_consistent(s))
2973
        return -1;
2974
    return do_commit(s);
2975
}
2976

2977
static int coroutine_fn GRAPH_RDLOCK
2978
vvfat_write(BlockDriverState *bs, int64_t sector_num,
2979
            const uint8_t *buf, int nb_sectors)
2980
{
2981
    BDRVVVFATState *s = bs->opaque;
2982
    int i, ret;
2983
    int first_cluster, last_cluster;
2984

2985
DLOG(checkpoint());
2986

2987
    /* Check if we're operating in read-only mode */
2988
    if (s->qcow == NULL) {
2989
        return -EACCES;
2990
    }
2991

2992
    vvfat_close_current_file(s);
2993

2994
    if (sector_num == s->offset_to_bootsector && nb_sectors == 1) {
2995
        /*
2996
         * Write on bootsector. Allow only changing the reserved1 field,
2997
         * used to mark volume dirtiness
2998
         */
2999
        unsigned char *bootsector = s->first_sectors
3000
                                    + s->offset_to_bootsector * 0x200;
3001
        /*
3002
         * LATER TODO: if FAT32, this is wrong (see init_directories(),
3003
         * which always creates a FAT16 bootsector)
3004
         */
3005
        const int reserved1_offset = offsetof(bootsector_t, u.fat16.reserved1);
3006

3007
        for (i = 0; i < 0x200; i++) {
3008
            if (i != reserved1_offset && bootsector[i] != buf[i]) {
3009
                fprintf(stderr, "Tried to write to protected bootsector\n");
3010
                return -1;
3011
            }
3012
        }
3013

3014
        /* Update bootsector with the only updatable byte, and return success */
3015
        bootsector[reserved1_offset] = buf[reserved1_offset];
3016
        return 0;
3017
    }
3018

3019
    /*
3020
     * Some sanity checks:
3021
     * - do not allow writing to the boot sector
3022
     */
3023
    if (sector_num < s->offset_to_fat)
3024
        return -1;
3025

3026
    /*
3027
     * Values will be negative for writes to the FAT, which is located before
3028
     * the root directory.
3029
     */
3030
    first_cluster = sector2cluster(s, sector_num);
3031
    last_cluster = sector2cluster(s, sector_num + nb_sectors - 1);
3032

3033
    for (i = first_cluster; i <= last_cluster;) {
3034
        mapping_t *mapping = NULL;
3035

3036
        if (i >= 0) {
3037
            mapping = find_mapping_for_cluster(s, i);
3038
        }
3039

3040
        if (mapping) {
3041
            if (mapping->read_only) {
3042
                fprintf(stderr, "Tried to write to write-protected file %s\n",
3043
                        mapping->path);
3044
                return -1;
3045
            }
3046

3047
            if (mapping->mode & MODE_DIRECTORY) {
3048
                int begin = cluster2sector(s, i);
3049
                int end = begin + s->sectors_per_cluster, k;
3050
                int dir_index;
3051
                const direntry_t* direntries;
3052
                long_file_name lfn;
3053

3054
                lfn_init(&lfn);
3055

3056
                if (begin < sector_num)
3057
                    begin = sector_num;
3058
                if (end > sector_num + nb_sectors)
3059
                    end = sector_num + nb_sectors;
3060
                dir_index  = mapping->dir_index +
3061
                    0x10 * (begin - mapping->begin * s->sectors_per_cluster);
3062
                direntries = (direntry_t*)(buf + 0x200 * (begin - sector_num));
3063

3064
                for (k = 0; k < (end - begin) * 0x10; k++) {
3065
                    /* no access to the direntry of a read-only file */
3066
                    if (is_short_name(direntries + k) &&
3067
                            (direntries[k].attributes & 1)) {
3068
                        if (memcmp(direntries + k,
3069
                                    array_get(&(s->directory), dir_index + k),
3070
                                    sizeof(direntry_t))) {
3071
                            warn_report("tried to write to write-protected "
3072
                                        "file");
3073
                            return -1;
3074
                        }
3075
                    }
3076
                }
3077
            }
3078
            i = mapping->end;
3079
        } else {
3080
            i++;
3081
        }
3082
    }
3083

3084
    /*
3085
     * Use qcow backend. Commit later.
3086
     */
3087
DLOG(fprintf(stderr, "Write to qcow backend: %d + %d\n", (int)sector_num, nb_sectors));
3088
    ret = bdrv_co_pwrite(s->qcow, sector_num * BDRV_SECTOR_SIZE,
3089
                         nb_sectors * BDRV_SECTOR_SIZE, buf, 0);
3090
    if (ret < 0) {
3091
        fprintf(stderr, "Error writing to qcow backend\n");
3092
        return ret;
3093
    }
3094

3095
    for (i = first_cluster; i <= last_cluster; i++) {
3096
        if (i >= 0) {
3097
            s->used_clusters[i] |= USED_ALLOCATED;
3098
        }
3099
    }
3100

3101
DLOG(checkpoint());
3102
    /* TODO: add timeout */
3103
    try_commit(s);
3104

3105
DLOG(checkpoint());
3106
    return 0;
3107
}
3108

3109
static int coroutine_fn GRAPH_RDLOCK
3110
vvfat_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
3111
                 QEMUIOVector *qiov, BdrvRequestFlags flags)
3112
{
3113
    int ret;
3114
    BDRVVVFATState *s = bs->opaque;
3115
    uint64_t sector_num = offset >> BDRV_SECTOR_BITS;
3116
    int nb_sectors = bytes >> BDRV_SECTOR_BITS;
3117
    void *buf;
3118

3119
    assert(QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE));
3120
    assert(QEMU_IS_ALIGNED(bytes, BDRV_SECTOR_SIZE));
3121

3122
    buf = g_try_malloc(bytes);
3123
    if (bytes && buf == NULL) {
3124
        return -ENOMEM;
3125
    }
3126
    qemu_iovec_to_buf(qiov, 0, buf, bytes);
3127

3128
    qemu_co_mutex_lock(&s->lock);
3129
    ret = vvfat_write(bs, sector_num, buf, nb_sectors);
3130
    qemu_co_mutex_unlock(&s->lock);
3131

3132
    g_free(buf);
3133

3134
    return ret;
3135
}
3136

3137
static int coroutine_fn vvfat_co_block_status(BlockDriverState *bs,
3138
                                              bool want_zero, int64_t offset,
3139
                                              int64_t bytes, int64_t *n,
3140
                                              int64_t *map,
3141
                                              BlockDriverState **file)
3142
{
3143
    *n = bytes;
3144
    return BDRV_BLOCK_DATA;
3145
}
3146

3147
static void vvfat_qcow_options(BdrvChildRole role, bool parent_is_format,
3148
                               int *child_flags, QDict *child_options,
3149
                               int parent_flags, QDict *parent_options)
3150
{
3151
    qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "off");
3152
    qdict_set_default_str(child_options, BDRV_OPT_AUTO_READ_ONLY, "off");
3153
    qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");
3154
}
3155

3156
static BdrvChildClass child_vvfat_qcow;
3157

3158
static int enable_write_target(BlockDriverState *bs, Error **errp)
3159
{
3160
    BDRVVVFATState *s = bs->opaque;
3161
    BlockDriver *bdrv_qcow = NULL;
3162
    QemuOpts *opts = NULL;
3163
    int ret;
3164
    int size = sector2cluster(s, s->sector_count);
3165
    QDict *options;
3166

3167
    s->used_clusters = g_malloc0(size);
3168

3169
    array_init(&(s->commits), sizeof(commit_t));
3170

3171
    s->qcow_filename = create_tmp_file(errp);
3172
    if (!s->qcow_filename) {
3173
        ret = -ENOENT;
3174
        goto err;
3175
    }
3176

3177
    bdrv_qcow = bdrv_find_format("qcow");
3178
    if (!bdrv_qcow) {
3179
        error_setg(errp, "Failed to locate qcow driver");
3180
        ret = -ENOENT;
3181
        goto err;
3182
    }
3183

3184
    opts = qemu_opts_create(bdrv_qcow->create_opts, NULL, 0, &error_abort);
3185
    qemu_opt_set_number(opts, BLOCK_OPT_SIZE,
3186
                        bs->total_sectors * BDRV_SECTOR_SIZE, &error_abort);
3187
    qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, "fat:", &error_abort);
3188

3189
    ret = bdrv_create(bdrv_qcow, s->qcow_filename, opts, errp);
3190
    qemu_opts_del(opts);
3191
    if (ret < 0) {
3192
        goto err;
3193
    }
3194

3195
    options = qdict_new();
3196
    qdict_put_str(options, "write-target.driver", "qcow");
3197
    s->qcow = bdrv_open_child(s->qcow_filename, options, "write-target", bs,
3198
                              &child_vvfat_qcow,
3199
                              BDRV_CHILD_DATA | BDRV_CHILD_METADATA,
3200
                              false, errp);
3201
    qobject_unref(options);
3202
    if (!s->qcow) {
3203
        ret = -EINVAL;
3204
        goto err;
3205
    }
3206

3207
#ifndef _WIN32
3208
    unlink(s->qcow_filename);
3209
#endif
3210

3211
    return 0;
3212

3213
err:
3214
    return ret;
3215
}
3216

3217
static void vvfat_child_perm(BlockDriverState *bs, BdrvChild *c,
3218
                             BdrvChildRole role,
3219
                             BlockReopenQueue *reopen_queue,
3220
                             uint64_t perm, uint64_t shared,
3221
                             uint64_t *nperm, uint64_t *nshared)
3222
{
3223
    assert(role & BDRV_CHILD_DATA);
3224
    /* This is a private node, nobody should try to attach to it */
3225
    *nperm = BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE;
3226
    *nshared = BLK_PERM_WRITE_UNCHANGED;
3227
}
3228

3229
static void vvfat_close(BlockDriverState *bs)
3230
{
3231
    BDRVVVFATState *s = bs->opaque;
3232

3233
    vvfat_close_current_file(s);
3234
    array_free(&(s->fat));
3235
    array_free(&(s->directory));
3236
    array_free(&(s->mapping));
3237
    g_free(s->cluster_buffer);
3238

3239
    if (s->qcow) {
3240
        migrate_del_blocker(&s->migration_blocker);
3241
    }
3242
}
3243

3244
static const char *const vvfat_strong_runtime_opts[] = {
3245
    "dir",
3246
    "fat-type",
3247
    "floppy",
3248
    "label",
3249
    "rw",
3250

3251
    NULL
3252
};
3253

3254
static BlockDriver bdrv_vvfat = {
3255
    .format_name            = "vvfat",
3256
    .protocol_name          = "fat",
3257
    .instance_size          = sizeof(BDRVVVFATState),
3258

3259
    .bdrv_parse_filename    = vvfat_parse_filename,
3260
    .bdrv_open              = vvfat_open,
3261
    .bdrv_refresh_limits    = vvfat_refresh_limits,
3262
    .bdrv_close             = vvfat_close,
3263
    .bdrv_child_perm        = vvfat_child_perm,
3264

3265
    .bdrv_co_preadv         = vvfat_co_preadv,
3266
    .bdrv_co_pwritev        = vvfat_co_pwritev,
3267
    .bdrv_co_block_status   = vvfat_co_block_status,
3268

3269
    .strong_runtime_opts    = vvfat_strong_runtime_opts,
3270
};
3271

3272
static void bdrv_vvfat_init(void)
3273
{
3274
    child_vvfat_qcow = child_of_bds;
3275
    child_vvfat_qcow.inherit_options = vvfat_qcow_options;
3276
    bdrv_register(&bdrv_vvfat);
3277
}
3278

3279
block_init(bdrv_vvfat_init);
3280

3281
#ifdef DEBUG
3282
static void checkpoint(void)
3283
{
3284
    assert(((mapping_t*)array_get(&(vvv->mapping), 0))->end == 2);
3285
    check1(vvv);
3286
    check2(vvv);
3287
    assert(!vvv->current_mapping || vvv->current_fd || (vvv->current_mapping->mode & MODE_DIRECTORY));
3288
}
3289
#endif
3290