Archipelago » qemu

3. Naming

4. Block structure

#include "cpu-defs.h"

void qemu_add_balloon_handler(QEMUBalloonEvent *func, void *opaque);

#endif

#endif

/* dynamic array functions */

    char* pointer;

    unsigned int size,next,item_size;

{

    array->pointer = NULL;

    array->size=0;

    array->item_size=item_size;

}

{

    if(array->pointer)

        free(array->pointer);

}

/* does not automatically grow */

    assert(index < array->next);

    return array->pointer + index * array->item_size;

}

{

    if((index + 1) * array->item_size > array->size) {

	int new_size = (index + 32) * array->item_size;

    return 0;

}

    unsigned int next = array->next;

    void* result;

    return result;

}

    if((array->next+count)*array->item_size>array->size) {

	int increment=count*array->item_size;

	array->pointer=qemu_realloc(array->pointer,array->size+increment);

/* this performs a "roll", so that the element which was at index_from becomes

 * index_to, but the order of all other elements is preserved. */

{

    char* buf;

    char* from;

    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 % array->item_size) == 0);

/* These structures are used to fake a disk and the VFAT filesystem.

 * For this reason we need to use __attribute__((packed)). */

    uint8_t jump[3];

    uint8_t name[8];

    uint16_t sector_size;

    uint8_t fat_type[8];

    uint8_t ignored[0x1c0];

    uint8_t magic[2];

typedef struct {

    uint8_t head;

    uint8_t sector;

    uint8_t cylinder;

    uint8_t attributes; /* 0x80 = bootable */

    uint8_t   fs_type; /* 0x1 = FAT12, 0x6 = FAT16, 0xe = FAT16_LBA, 0xb = FAT32, 0xc = FAT32_LBA */

    uint32_t start_sector_long;

    uint32_t length_sector_long;

    uint8_t ignored[0x1b8];

    uint32_t nt_id;

    uint8_t ignored2[2];

    uint8_t magic[2];

    uint8_t name[8];

    uint8_t extension[3];

    uint8_t attributes;

    uint16_t mdate;

    uint16_t begin;

    uint32_t size;

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

    /* begin is the first cluster, end is the last+1 */

    uint32_t begin,end;

    /* as s->directory is growable, no pointer may be used here */

	MODE_DIRECTORY = 4, MODE_FAKED = 8,

	MODE_DELETED = 16, MODE_RENAMED = 32 } mode;

    int read_only;

#ifdef DEBUG

#endif

/* here begins the real VVFAT driver */

    unsigned char first_sectors[0x40*0x200];

    int fat_type; /* 16 or 32 */

    unsigned int cluster_size;

    unsigned int sectors_per_cluster;

    uint32_t max_fat_value;

    int current_fd;

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

    unsigned char* cluster_buffer; /* points to a buffer to hold temp data */

    unsigned int current_cluster;

    BlockDriverState* qcow;

    void* fat2;

    char* used_clusters;

    const char* path;

    int downcase_short_names;

} BDRVVVFATState;

 * if the position is outside the specified geometry, fill maximum value for CHS

 * and return 1 to signal overflow.

 */

    int head,sector;

    sector   = spos % (bs->secs);  spos/= bs->secs;

    head     = spos % (bs->heads); spos/= bs->heads;

static void init_mbr(BDRVVVFATState* s)

{

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

    int lba;

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

    return len;

}

{

    char buffer[258];

    int length=short2long_name(buffer,filename),

        number_of_entries=(length+25)/26,i;

    for(i=0;i<number_of_entries;i++) {

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

    return array_get(&(s->directory),s->directory.next-number_of_entries);

}

{

    return direntry->name[0]==0xe5 || direntry->name[0]==0x00;

}

{

    return direntry->attributes == 0x28;

}

{

    return direntry->attributes == 0xf;

}

{

    return !is_volume_label(direntry) && !is_long_name(direntry)

	&& !is_free(direntry);

}

{

    return direntry->attributes & 0x10 && direntry->name[0] != 0xe5;

}

{

    return is_short_name(direntry) && direntry->name[0] == '.';

}

{

    return is_short_name(direntry) && !is_directory(direntry);

}

{

    return le16_to_cpu(direntry->begin)|(le16_to_cpu(direntry->begin_hi)<<16);

}

{

    return le32_to_cpu(direntry->size);

}

{

    direntry->begin = cpu_to_le16(begin & 0xffff);

    direntry->begin_hi = cpu_to_le16((begin >> 16) & 0xffff);

/* fat functions */

{

    uint8_t chksum=0;

    int i;

/* TODO: in create_short_filename, 0xe5->0x05 is not yet handled! */

/* TODO: in parse_short_filename, 0x05->0xe5 is not yet handled! */

	unsigned int directory_start, const char* filename, int is_dot)

{

    int i,j,long_index=s->directory.next;

    if(is_dot) {

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

    /* mangle duplicates */

    while(1) {

	int j;

	for(;entry1<entry;entry1++)

 */

static int read_directory(BDRVVVFATState* s, int mapping_index)

{

    const char* dirname = mapping->path;

    int first_cluster = mapping->begin;

    int parent_index = mapping->info.dir.parent_mapping_index;

        (parent_index >= 0 ? array_get(&(s->mapping), parent_index) : NULL);

    int first_cluster_of_parent = parent_mapping ? parent_mapping->begin : -1;

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

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

        char* buffer;

        struct stat st;

	int is_dot=!strcmp(entry->d_name,".");

	int is_dotdot=!strcmp(entry->d_name,"..");

	/* create mapping for this file */

	if(!is_dot && !is_dotdot && (S_ISDIR(st.st_mode) || st.st_size)) {

	    s->current_mapping->begin=0;

	    s->current_mapping->end=st.st_size;

	    /*

    /* fill with zeroes up to the end of the cluster */

    while(s->directory.next%(0x10*s->sectors_per_cluster)) {

    }

/* TODO: if there are more entries, bootsector has to be adjusted! */

	int cur = s->directory.next;

	array_ensure_allocated(&(s->directory), ROOT_ENTRIES - 1);

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

    }

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

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

	* 0x20 / s->cluster_size;

    mapping->end = first_cluster;

    set_begin_of_direntry(direntry, mapping->begin);

    return 0;

}

#ifdef DBG

{

    if(mapping->mode==MODE_UNDEFINED)

	return 0;

}

#endif

static int init_directories(BDRVVVFATState* s,

	const char* dirname)

{

    unsigned int i;

    unsigned int cluster;

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

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

    /* add volume label */

    {

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

	snprintf((char*)entry->name,11,"QEMU VVFAT");

    }

	    mapping->mode=MODE_NORMAL;

	    mapping->begin = cluster;

	    if (mapping->end > 0) {

			mapping->dir_index);

		mapping->end = cluster + 1 + (mapping->end-1)/s->cluster_size;

    s->current_mapping = NULL;

    bootsector->jump[0]=0xeb;

    bootsector->jump[1]=0x3e;

    bootsector->jump[2]=0x90;

{

    int index3=index1+1;

    while(1) {

	index3=(index1+index2)/2;

	mapping=array_get(&(s->mapping),index3);

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

    }

}

{

    int index=find_mapping_for_cluster_aux(s,cluster_num,0,s->mapping.next);

    if(index>=s->mapping.next)

        return NULL;

    mapping=array_get(&(s->mapping),index);

 * This function simply compares path == mapping->path. Since the mappings

 * are sorted by cluster, this is expensive: O(n).

 */

	const char* path)

{

    int i;

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

	if (mapping->first_mapping_index < 0 &&

		!strcmp(path, mapping->path))

	    return mapping;

    return NULL;

}

{

    if(!mapping)

	return -1;

		|| s->current_mapping->begin>cluster_num

		|| s->current_mapping->end<=cluster_num) {

	    /* binary search of mappings for file */

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

    }

}

{

    int j = 0;

    char buffer[1024];

    }

}

{

    fprintf(stderr, "mapping (0x%x): begin, end = %d, %d, dir_index = %d, first_mapping_index = %d, name = %s, mode = 0x%x, " , (int)mapping, mapping->begin, mapping->end, mapping->dir_index, mapping->first_mapping_index, mapping->path, mapping->mode);

    if (mapping->mode & MODE_DIRECTORY)

 *

 */

    char* path;

    union {

	struct { uint32_t cluster; } rename;

    enum {

	ACTION_RENAME, ACTION_WRITEOUT, ACTION_NEW_FILE, ACTION_MKDIR

    } action;

static void clear_commits(BDRVVVFATState* s)

{

    int i;

DLOG(fprintf(stderr, "clear_commits (%d commits)\n", s->commits.next));

    for (i = 0; i < s->commits.next; i++) {

	assert(commit->path || commit->action == ACTION_WRITEOUT);

	if (commit->action != ACTION_WRITEOUT) {

	    assert(commit->path);

static void schedule_rename(BDRVVVFATState* s,

	uint32_t cluster, char* new_path)

{

    commit->path = new_path;

    commit->param.rename.cluster = cluster;

    commit->action = ACTION_RENAME;

static void schedule_writeout(BDRVVVFATState* s,

	int dir_index, uint32_t modified_offset)

{

    commit->path = NULL;

    commit->param.writeout.dir_index = dir_index;

    commit->param.writeout.modified_offset = modified_offset;

static void schedule_new_file(BDRVVVFATState* s,

	char* path, uint32_t first_cluster)

{

    commit->path = path;

    commit->param.new_file.first_cluster = first_cluster;

    commit->action = ACTION_NEW_FILE;

static void schedule_mkdir(BDRVVVFATState* s, uint32_t cluster, char* path)

{

    commit->path = path;

    commit->param.mkdir.cluster = cluster;

    commit->action = ACTION_MKDIR;

/* return 0 if parsed successfully, > 0 if no long name, < 0 if error */

static int parse_long_name(long_file_name* lfn,

{

    int i, j, offset;

    const unsigned char* pointer = (const unsigned char*)direntry;

/* returns 0 if successful, >0 if no short_name, and <0 on error */

static int parse_short_name(BDRVVVFATState* s,

{

    int i, j;

 */

typedef enum {

     USED_DIRECTORY = 1, USED_FILE = 2, USED_ANY = 3, USED_ALLOCATED = 4

/*

 * get_cluster_count_for_direntry() not only determines how many clusters

 * assumed to be *not* deleted (and *only* those).

 */

static uint32_t get_cluster_count_for_direntry(BDRVVVFATState* s,

{

    /*

     * This is a little bit tricky:

    uint32_t cluster_num = begin_of_direntry(direntry);

    uint32_t offset = 0;

    int first_mapping_index = -1;

    const char* basename2 = NULL;

    vvfat_close_current_file(s);

{

    int ret = 0;

    unsigned char* cluster = qemu_malloc(s->cluster_size);

    long_file_name lfn;

    int path_len = strlen(path);

     * (check_directory_consistency() will unmark those still present). */

    if (s->qcow)

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

	    if (mapping->first_mapping_index < 0)

		mapping->mode |= MODE_DELETED;

	}

    int i;

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

#define ADJUST_MAPPING_INDEX(name) \

	if (mapping->name >= offset) \

}

/* insert or update mapping */

	uint32_t begin, uint32_t end)

{

    /*

     * - replace name

     */

    int index = find_mapping_for_cluster_aux(s, begin, 0, s->mapping.next);

    if (index < s->mapping.next && (mapping = array_get(&(s->mapping), index))

	    && mapping->begin < begin) {

    mapping->begin = begin;

    mapping->end = end;

assert(index + 1 >= s->mapping.next ||

((next_mapping = array_get(&(s->mapping), index + 1)) &&

 next_mapping->begin >= end)));

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

		s->current_mapping - first_mapping);

static int remove_mapping(BDRVVVFATState* s, int mapping_index)

{

    /* free mapping */

    if (mapping->first_mapping_index < 0)

    /* adjust all references to mappings */

    adjust_mapping_indices(s, mapping_index, -1);

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

		s->current_mapping - first_mapping);

{

    int i;

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

	if (mapping->dir_index >= offset)

	    mapping->dir_index += adjust;

	if ((mapping->mode & MODE_DIRECTORY) &&

    }

}

	int dir_index, int count)

{

    /*

     * make room in s->directory,

     * adjust_dirindices

     */

    if (result == NULL)

	return NULL;

    adjust_dirindices(s, dir_index, count);

static int commit_mappings(BDRVVVFATState* s,

	uint32_t first_cluster, int dir_index)

{

    uint32_t cluster = first_cluster;

    vvfat_close_current_file(s);

	if (!fat_eof(s, c1)) {

	    int i = find_mapping_for_cluster_aux(s, c1, 0, s->mapping.next);

		array_get(&(s->mapping), i);

	    if (next_mapping == NULL || next_mapping->begin > c1) {

static int commit_direntries(BDRVVVFATState* s,

	int dir_index, int parent_mapping_index)

{

    uint32_t first_cluster = dir_index == 0 ? 0 : begin_of_direntry(direntry);

    int factor = 0x10 * s->sectors_per_cluster;

    int old_cluster_count, new_cluster_count;

static int commit_one_file(BDRVVVFATState* s,

	int dir_index, uint32_t offset)

{

    uint32_t c = begin_of_direntry(direntry);

    uint32_t first_cluster = c;

    uint32_t size = filesize_of_direntry(direntry);

    char* cluster = qemu_malloc(s->cluster_size);

    uint32_t i;

{

    int i;

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

	if (mapping->mode & MODE_DELETED) {

	    fprintf(stderr, "deleted\n");

	    continue;

	}

	assert(mapping->dir_index >= 0);

	assert(mapping->dir_index < s->directory.next);

	assert(mapping->begin == begin_of_direntry(direntry) || mapping->first_mapping_index >= 0);

	if (mapping->mode & MODE_DIRECTORY) {

	    assert(mapping->info.dir.first_dir_index + 0x10 * s->sectors_per_cluster * (mapping->end - mapping->begin) <= s->directory.next);

    int first_mapping = -1;

    for (i = 0; i < s->directory.next; i++) {

	if (is_short_name(direntry) && begin_of_direntry(direntry)) {

	    assert(mapping);

	    assert(mapping->dir_index == i || is_dot(direntry));

	    assert(mapping->begin == begin_of_direntry(direntry) || is_dot(direntry));

	    int j, count = 0;

	    for (j = 0; j < s->mapping.next; j++) {

		if (mapping->mode & MODE_DELETED)

		    continue;

		if (mapping->mode & MODE_DIRECTORY) {

			if (mapping->info.dir.parent_mapping_index < 0)

			    assert(j == 0);

			else {

			    assert(parent->mode & MODE_DIRECTORY);

			    assert(parent->info.dir.first_dir_index < mapping->info.dir.first_dir_index);

			}

#ifdef DEBUG

    fprintf(stderr, "handle_renames\n");

    for (i = 0; i < s->commits.next; i++) {

	fprintf(stderr, "%d, %s (%d, %d)\n", i, commit->path ? commit->path : "(null)", commit->param.rename.cluster, commit->action);

    }

#endif

    for (i = 0; i < s->commits.next;) {

	if (commit->action == ACTION_RENAME) {

		    commit->param.rename.cluster);

	    char* old_path = mapping->path;

		int l1 = strlen(mapping->path);

		int l2 = strlen(old_path);

		int diff = l1 - l2;

			mapping->info.dir.first_dir_index);

		uint32_t c = mapping->begin;

		int i = 0;

		/* recurse */

		while (!fat_eof(s, c)) {

		    do {

			if (is_file(d) || (is_directory(d) && !is_dot(d))) {

				    begin_of_direntry(d));

			    int l = strlen(m->path);

			    char* new_path = qemu_malloc(l + diff + 1);

	    array_remove(&(s->commits), i);

	    continue;

	} else if (commit->action == ACTION_MKDIR) {

	    int j, parent_path_len;

#ifdef __MINGW32__

	    parent_path_len = strlen(commit->path)

		- strlen(get_basename(commit->path)) - 1;

	    for (j = 0; j < s->mapping.next; j++) {

		if (m->first_mapping_index < 0 && m != mapping &&

			!strncmp(m->path, mapping->path, parent_path_len) &&

			strlen(m->path) == parent_path_len)

    vvfat_close_current_file(s);

    for (i = 0; !fail && i < s->commits.next; i++) {

	switch(commit->action) {

	case ACTION_RENAME: case ACTION_MKDIR:

	    assert(0);

	    fail = -2;

	    break;

	case ACTION_WRITEOUT: {

		    commit->param.writeout.dir_index);

	    uint32_t begin = begin_of_direntry(entry);

	    assert(mapping);

	    assert(mapping->begin == begin);

	}

	case ACTION_NEW_FILE: {

	    int begin = commit->param.new_file.first_cluster;

	    int i;

	    /* find direntry */

	deleted = 0;

	for (i = 1; i < s->mapping.next; i++) {

	    if (mapping->mode & MODE_DELETED) {

			mapping->dir_index);

		if (is_free(entry)) {

			}

			for (j = 1; j < s->mapping.next; j++) {

			    if (m->mode & MODE_DIRECTORY &&

				    m->info.dir.first_dir_index >

				    first_dir_index &&

    for (i = sector2cluster(s, sector_num);

	    i <= sector2cluster(s, sector_num + nb_sectors - 1);) {

	if (mapping) {

	    if (mapping->read_only) {

		fprintf(stderr, "Tried to write to write-protected file %s\n",

		int begin = cluster2sector(s, i);

		int end = begin + s->sectors_per_cluster, k;

		int dir_index;

		long_file_name lfn;

		lfn_init(&lfn);

		    end = sector_num + nb_sectors;

		dir_index  = mapping->dir_index +

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

		for (k = 0; k < (end - begin) * 0x10; k++) {

		    /* do not allow non-ASCII filenames */

			    (direntries[k].attributes & 1)) {

			if (memcmp(direntries + k,

				    array_get(&(s->directory), dir_index + k),

			    fprintf(stderr, "Warning: tried to write to write-protected file\n");

			    return -1;

			}

    int size = sector2cluster(s, s->sector_count);

    s->used_clusters = calloc(size, 1);

    s->qcow_filename = qemu_malloc(1024);

    get_tmp_filename(s->qcow_filename, 1024);

#ifdef DEBUG

static void checkpoint(void) {

    check1(vvv);

    check2(vvv);

    assert(!vvv->current_mapping || vvv->current_fd || (vvv->current_mapping->mode & MODE_DIRECTORY));

#if 0

	fprintf(stderr, "Nonono!\n");

    assert(vvv->mapping.size >= vvv->mapping.item_size * vvv->mapping.next);

    assert(vvv->directory.size >= vvv->directory.item_size * vvv->directory.next);

    if (vvv->mapping.next<47)

    GRAPHIC_CONSOLE,

    TEXT_CONSOLE,

    TEXT_CONSOLE_FIXED_SIZE

/* ??? This is mis-named.

   It is used for both text and graphical consoles.  */

struct TextConsole {

    DisplayState *ds;

    /* Graphic console state.  */

    vga_hw_update_ptr hw_update;

    active_console = previous_active_console;

}

{

    if (active_console && active_console->hw_text_update)

        active_console->hw_text_update(active_console->hw, chardata);

    console_refresh(s);

}

{

    TextConsole *s = (TextConsole *) opaque;

    int i, j, src;

    return NULL;

}

{

    TextConsole *s;

    int i;

    return ds->surface->pf.bytes_per_pixel;

}

{

    cpu_to_le32wu((uint32_t *) dest, ch);

}

typedef void (*vga_hw_update_ptr)(void *);

typedef void (*vga_hw_invalidate_ptr)(void *);

typedef void (*vga_hw_screen_dump_ptr)(void *, const char *);

DisplayState *graphic_console_init(vga_hw_update_ptr update,

                                   vga_hw_invalidate_ptr invalidate,

void vga_hw_update(void);

void vga_hw_invalidate(void);

void vga_hw_screen_dump(const char *filename);

int is_graphic_console(void);

int is_fixedsize_console(void);

/* Return the physical page corresponding to a virtual one. Use it

   only for debugging because no protection checks are done. Return -1

   if no page found. */

#define CPU_LOG_TB_OUT_ASM (1 << 0)

#define CPU_LOG_TB_IN_ASM  (1 << 1)

extern int phys_ram_fd;

extern uint8_t *phys_ram_dirty;

/* physical memory access */

#define MIGRATION_DIRTY_FLAG 0x08

/* read dirty bit (return 0 or 1) */

{

    return phys_ram_dirty[addr >> TARGET_PAGE_BITS] == 0xff;

}

                                                int dirty_flags)

{

    return phys_ram_dirty[addr >> TARGET_PAGE_BITS] & dirty_flags;

}

{

    phys_ram_dirty[addr >> TARGET_PAGE_BITS] = 0xff;

}

                                     int dirty_flags);

void cpu_tlb_update_dirty(CPUState *env);

int cpu_physical_memory_get_dirty_tracking(void);

void dump_exec_info(FILE *f,

                    int (*cpu_fprintf)(FILE *f, const char *fmt, ...));

 * batching which can make a major impact on performance when using

 * virtualization.

 */

/*******************************************/

/* host CPU ticks (if available) */

#include "bswap.h"

/* address in the RAM (different from a physical address) */

/* memory API */

{

    cpu_register_physical_memory_offset(start_addr, size, phys_offset, 0);

}

/* This should only be used for ram local to a device.  */

/* This should not be used by devices.  */

int cpu_register_io_memory(CPUReadMemoryFunc * const *mem_read,

                           CPUWriteMemoryFunc * const *mem_write,

                           void *opaque);

void cpu_unregister_io_memory(int table_address);

                            int len, int is_write);

                                            uint8_t *buf, int len)

{

    cpu_physical_memory_rw(addr, buf, len, 0);

}

                                             const uint8_t *buf, int len)

{

    cpu_physical_memory_rw(addr, (uint8_t *)buf, len, 1);

}

                              int is_write);

void *cpu_register_map_client(void *opaque, void (*callback)(void *opaque));

void cpu_unregister_map_client(void *cookie);

                                   const uint8_t *buf, int len);

#define IO_MEM_SHIFT       3

       use the corresponding iotlb value.  */

#if TARGET_PHYS_ADDR_BITS == 64

    /* on i386 Linux make sure it is aligned */

#else

#endif

    /* padding to get a power of two size */

    uint8_t dummy[(1 << CPU_TLB_ENTRY_BITS) - 

                  (sizeof(target_ulong) * 3 + 

} CPUTLBEntry;

#ifdef HOST_WORDS_BIGENDIAN

    volatile sig_atomic_t exit_request;                                 \

    /* The meaning of the MMU modes is defined in the target code. */   \

    CPUTLBEntry tlb_table[NB_MMU_MODES][CPU_TLB_SIZE];                  \

    struct TranslationBlock *tb_jmp_cache[TB_JMP_CACHE_SIZE];           \

    /* buffer for temporaries in the code generator */                  \

    long temp_buf[CPU_TEMP_BUF_NLONGS];                                 \

#define FONT_HEIGHT 16

#define FONT_WIDTH 8

static WINDOW *screenpad = NULL;

static int width, height, gwidth, gheight, invalidate;

static int px, py, sminx, sminy, smaxx, smaxy;

#include "curses_keys.h"

static int keycode2keysym[CURSES_KEYS];

static void curses_refresh(DisplayState *ds)

};

    /* Plain ASCII */

    { "space", 0x020 },

    { "exclam", 0x021 },

    COMMPAGE_ENTRY(add_atomic_word64,     0, 0x1c0,  unimpl_commpage,       CALL_INDIRECT | HAS_PTR),

    COMMPAGE_ENTRY(mach_absolute_time,    0, 0x200,  unimpl_commpage,       CALL_INDIRECT),

    COMMPAGE_ENTRY(spinlock_lock,         1, 0x260,  OSSpinLockLock,        CALL_DIRECT),

    COMMPAGE_ENTRY(spinlock_unlock,       1, 0x2a0,  OSSpinLockUnlock,      CALL_DIRECT),

    COMMPAGE_ENTRY(pthread_getspecific,   0, 0x2c0,  unimpl_commpage,       CALL_INDIRECT),

    unsigned int    es;

    unsigned int    fs;

    unsigned int    gs;

void bswap_i386_thread_state(struct mach_i386_thread_state *ts)

{

#include "gdbstub.h"

#define target_sigaction	sigaction

#ifdef TARGET_I386

struct target_pt_regs {

struct elf32_sym;

struct elf64_sym;

struct syminfo {

    lookup_symbol_t lookup_symbol;

    qsg->size = 0;

}

{

    if (qsg->nsg == qsg->nalloc) {

        qsg->nalloc = 2 * qsg->nalloc + 1;

    uint64_t sector_num;

    int is_write;

    int sg_cur_index;

    QEMUIOVector iov;

    QEMUBH *bh;

} DMAAIOCB;

static void dma_bdrv_cb(void *opaque, int ret)

{

    DMAAIOCB *dbs = (DMAAIOCB *)opaque;

    void *mem;

    dbs->acb = NULL;

#include "block.h"