Archipelago » qemu

/* 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

/* 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 */

	    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);

    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 */

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

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

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

    partition->start_head=1;

    partition->start_sector=1;

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

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

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

    return chksum;

}

		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);

    strncpy(entry->name,filename,i);

    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));

    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->qcow_filename = NULL;

    s->fat2 = NULL;

    s->downcase_short_names = 1;

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

	return -1;

	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)));

    }

}

#endif

                    uint8_t *buf, int nb_sectors)

{

    BDRVVVFATState *s = bs->opaque;

}

/*

 * 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;

	    }

	    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;

    }

	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,