Statistics
| Branch: | Revision:

root / block / vvfat.c @ 5c171afa

History | View | Annotate | Download (81.3 kB)

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