~vcs-imports/qemu/git

/* vim:set shiftwidth=4 ts=8: */

/*

 * QEMU Block driver for virtual VFAT (shadows a local directory)

 * Copyright (c) 2004,2005 Johannes E. Schindelin

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

#include <sys/stat.h>

#include <dirent.h>

#include <assert.h>

#include "block_int.h"

 

#ifndef S_IWGRP

/* TODO: add ":bootsector=blabla.img:" */

/* LATER TODO: add automatic boot sector generation from

    BOOTEASY.ASM and Ranish Partition Manager

    file system (test if the boot sector still relies on that fact)! */

/* MAYBE TODO: write block-visofs.c */

/* TODO: call try_commit() only after a timeout */

#define stderr STDERR

FILE* stderr = NULL;

 

 

#ifdef __MINGW32__

void nonono(const char* file, int line, const char* msg) {

            index_to<0 || index_to>=array->next ||

            index_from<0 || index_from>=array->next)

        return -1;

    if(index_to==index_from)

        return 0;

 

        memmove(to+is*count,to,from-to);

    else

        memmove(from,from+is*count,to-from);

    memcpy(to,buf,is*count);

 

    free(buf);

    return 0;

}

 

{

    assert(index >=0);

    assert(count > 0);

    return 0;

}

 

{

    return array_remove_slice(array, index, 1);

}

 

/* return the index for a given member */

{

    size_t offset = (char*)pointer - array->pointer;

    assert(offset >= 0);

    uint8_t magic[2];

} __attribute__((packed)) bootsector_t;

 

typedef struct partition_t {

    uint8_t attributes; /* 0x80 = bootable */

    uint32_t start_sector_long;

} __attribute__((packed)) partition_t;

 

typedef struct mbr_t {

    partition_t partition[4];

    uint8_t magic[2];

} __attribute__((packed)) mbr_t;

    BlockDriverState* bs; /* pointer to parent */

    unsigned int first_sectors_number; /* 1 for a single partition, 0x40 for a disk with partition table */

    unsigned char first_sectors[0x40*0x200];

    int fat_type; /* 16 or 32 */

    array_t fat,directory,mapping;

    unsigned int cluster_size;

    unsigned int sectors_per_cluster;

    unsigned int sectors_per_fat;

    uint32_t sector_count; /* total number of sectors of the partition */

    uint32_t cluster_count; /* total number of clusters of this partition */

    uint32_t max_fat_value;

    int current_fd;

    mapping_t* current_mapping;

    unsigned char* cluster; /* points to current cluster */

    int downcase_short_names;

} BDRVVVFATState;

 

 

static void init_mbr(BDRVVVFATState* s)

{

    /* TODO: if the files mbr.img and bootsect.img exist, use them */

    mbr_t* real_mbr=(mbr_t*)s->first_sectors;

    partition_t* partition=&(real_mbr->partition[0]);

 

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

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

    /* FAT12/FAT16/FAT32 */

 

    real_mbr->magic[0]=0x55; real_mbr->magic[1]=0xaa;

}

/* direntry functions */

 

/* dest is assumed to hold 258 bytes, and pads with 0xffff up to next multiple of 26 */

{

    int i;

    for(i=0;i<129 && src[i];i++) {

        dest[2*i]=src[i];

        dest[2*i+1]=0;

    }

    dest[2*i]=dest[2*i+1]=0;

    for(i=2*i+2;(i%26);i++)

        dest[i]=0xff;

}

 

static inline direntry_t* create_long_filename(BDRVVVFATState* s,const char* filename)

        entry->begin=0;

        entry->name[0]=(number_of_entries-i)|(i==0?0x40:0);

    }

        int offset=(i%26);

        if(offset<10) offset=1+offset;

        else if(offset<22) offset=14+offset-10;

    for(i=0;i<11;i++)

        chksum=(((chksum&0xfe)>>1)|((chksum&0x01)?0x80:0))

            +(unsigned char)entry->name[i];

    return chksum;

}

 

        uint16_t* entry=array_get(&(s->fat),cluster);

        return le16_to_cpu(*entry);

    } else {

        return ((x[0]|(x[1]<<8))>>(cluster&1?4:0))&0x0fff;

    }

}

                s->sectors_per_fat * 0x200 / s->fat.item_size - 1);

    }

    memset(s->fat.pointer,0,s->fat.size);

    switch(s->fat_type) {

        case 12: s->max_fat_value=0xfff; break;

        case 16: s->max_fat_value=0xffff; break;

        memcpy(entry->name,filename,strlen(filename));

        return entry;

    }

    entry_long=create_long_filename(s,filename);

    for(j = i - 1; j>0  && filename[j]!='.';j--);

    if (j > 0)

        i = (j > 8 ? 8 : j);

 

    entry=array_get_next(&(s->directory));

    memset(entry->name,0x20,11);

    if(j > 0)

        for (i = 0; i < 3 && filename[j+1+i]; i++)

            entry->extension[i] = filename[j+1+i];

        if(entry1==entry) /* no dupe found */

            break;

 

        if(entry->name[7]==' ') {

            int j;

            for(j=6;j>0 && entry->name[j]==' ';j--)

        mapping->end = mapping->begin;

        return -1;

    }

    i = mapping->info.dir.first_dir_index =

            first_cluster == 0 ? 0 : s->directory.next;

 

    while((entry=readdir(dir))) {

        unsigned int length=strlen(dirname)+2+strlen(entry->d_name);

        char* buffer;

 

        if(first_cluster == 0 && (is_dotdot || is_dot))

            continue;

        buffer=(char*)malloc(length);

        assert(buffer);

        snprintf(buffer,length,"%s/%s",dirname,entry->d_name);

        memset(array_get(&(s->directory), cur), 0,

                (ROOT_ENTRIES - cur) * sizeof(direntry_t));

    }

     /* reget the mapping, since s->mapping was possibly realloc()ed */

    mapping = (mapping_t*)array_get(&(s->mapping), mapping_index);

    first_cluster += (s->directory.next - mapping->info.dir.first_dir_index)

 

    direntry = (direntry_t*)array_get(&(s->directory), mapping->dir_index);

    set_begin_of_direntry(direntry, mapping->begin);

    return 0;

}

 

     */

    i = 1+s->sectors_per_cluster*0x200*8/s->fat_type;

    s->sectors_per_fat=(s->sector_count+i)/i; /* round up */

    array_init(&(s->mapping),sizeof(mapping_t));

    array_init(&(s->directory),sizeof(direntry_t));

 

    {

        direntry_t* entry=array_get_next(&(s->directory));

        entry->attributes=0x28; /* archive | volume label */

    }

 

    /* Now build FAT, and write back information into directory */

 

    for (i = 0, cluster = 0; i < s->mapping.next; i++) {

        int j;

         * (except for the media byte). */

        /* LATER TODO: still true for FAT32? */

        int fix_fat = (i != 0);

 

    s->fat_type=16;

    /* LATER TODO: if FAT32, adjust */

    s->sectors_per_cluster=0x10;

 

    s->current_cluster=0xffffffff;

 

    s->qcow_filename = NULL;

    s->fat2 = NULL;

    s->downcase_short_names = 1;

    if (!strstart(dirname, "fat:", NULL))

        return -1;

 

    if (strstr(dirname, ":floppy:")) {

        floppy = 1;

        s->fat_type = 12;

        bs->cyls = 80; bs->heads = 2; bs->secs = 36;

    }

 

    if (strstr(dirname, ":32:")) {

        fprintf(stderr, "Big fat greek warning: FAT32 has not been tested. You are welcome to do so!\n");

        s->fat_type = 32;

        s->sector_count=2880;

    }

 

    i = strrchr(dirname, ':') - dirname;

    assert(i >= 3);

    if (dirname[i-2] == ':' && isalpha(dirname[i-1]))

        dirname += i+1;

 

    bs->total_sectors=bs->cyls*bs->heads*bs->secs;

    if(init_directories(s, dirname))

        return -1;

 

    if(s->first_sectors_number==0x40)

        init_mbr(s);

 

        assert(index1<=index2);

        DLOG(mapping=array_get(&(s->mapping),index1);

        assert(mapping->begin<=cluster_num);

                ((mapping = array_get(&(s->mapping),index2)) &&

                mapping->end>cluster_num)));

    }

                s->current_mapping = mapping;

read_cluster_directory:

                offset = s->cluster_size*(cluster_num-s->current_mapping->begin);

                        + 0x20*s->current_mapping->info.dir.first_dir_index;

                assert(((s->cluster-(unsigned char*)s->directory.pointer)%s->cluster_size)==0);

                assert((char*)s->cluster+s->cluster_size <= s->directory.pointer+s->directory.next*s->directory.item_size);

}

#endif

 

                    uint8_t *buf, int nb_sectors)

{

    BDRVVVFATState *s = bs->opaque;

    }

 

    if (pointer[0] & 0x40)

 

    return 0;

}

    } else

        lfn->name[i + j + 1] = '\0';

 

 

    return 0;

}

}

 

/*

 * It returns 0 upon inconsistency or error, and the number of clusters

 * used by the directory, its subdirectories and their files.

 */

    } else

        /* new directory */

        schedule_mkdir(s, cluster_num, strdup(path));

    lfn_init(&lfn);

    do {

        int i;

                    fprintf(stderr, "Error in short name (%d)\n", subret);

                    goto fail;

                }

                    continue;

            }

            lfn.checksum = 0x100; /* cannot use long name twice */

                fprintf(stderr, "Name too long: %s/%s\n", path, lfn.name);

                goto fail;

            }

 

            if (is_directory(direntries + i)) {

                if (begin_of_direntry(direntries + i) == 0) {

            }

 

            next_mapping->dir_index = mapping->dir_index;

                mapping->first_mapping_index < 0 ?

                array_index(&(s->mapping), mapping) :

                mapping->first_mapping_index;

 

            mapping = next_mapping;

        }

        cluster = c1;

    }

 

        assert(size >= 0);

 

        ret = vvfat_read(s->bs, cluster2sector(s, c),

 

        if (ret < 0)

            return ret;

        return ret;

    }

 

    memcpy(s->fat.pointer, s->fat2, 0x200 * s->sectors_per_fat);

 

    /* recurse direntries from root (using bs->bdrv_read) */

    return do_commit(s);

}

 

                    const uint8_t *buf, int nb_sectors)

{

    int i, ret;

 

DLOG(checkpoint());

                    begin = sector_num;

                if (end > sector_num + nb_sectors)

                    end = sector_num + nb_sectors;

                    0x10 * (begin - mapping->begin * s->sectors_per_cluster);

                direntries = (direntry_t*)(buf + 0x200 * (begin - sector_num));

 

        *n = nb_sectors;

    else if (*n < 0)

        return 0;

}

 

static int write_target_commit(BlockDriverState *bs, int64_t sector_num,

};

 

#ifdef DEBUG

    assert(((mapping_t*)array_get(&(vvv->mapping), 0))->end == 2);

    check1(vvv);

    check2(vvv);