diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/debug.c xen-4.1.2-b/tools/ioemu-qemu-xen/debug.c
--- xen-4.1.2-a/tools/ioemu-qemu-xen/debug.c	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/debug.c	2012-12-28 16:02:40.999933925 +0800
@@ -0,0 +1,182 @@
+#include<time.h>
+#include<sys/stat.h>
+#include<stdarg.h>
+#include<fcntl.h>
+#include"debug.h"
+#include <unistd.h>
+#include <string.h>
+
+#define KB(x)    ((x)*1024)
+
+static int dbg_term = 0, dbg_file = 0, log_day = 0;
+static FILE* fp_log = NULL;
+static char dir[128]={0,}, filename[160];
+static void init_file_path(void);
+static char printbuf[1024]={};
+int mkdir_recursive(char* path);
+
+
+void print_error(char* file, char* function, int line, const char *fmt, ...)
+{
+  va_list args;
+  int i;
+
+  if( !dbg_term && !dbg_file )
+    return;
+
+  va_start(args, fmt);
+  i=vsprintf( printbuf, fmt, args );
+  printbuf[i] = 0;
+  va_end(args);
+
+  if( dbg_term )
+    {
+      printf("[%s]%s(%d):\n%s\n", file, function, line, printbuf);
+    }
+
+  if( dbg_file )
+    {
+      time_t t = time( NULL );
+      struct tm* tm1 = localtime(&t);
+      if( !tm1 ) return;
+      //if( tm1->tm_mday != log_day )
+      {
+	//init_file_path();
+      }
+      char tmp[16];
+      strftime( tmp, 15, "%X", tm1 );
+      fprintf( fp_log, "%s [%s]%s(%d): %s\n", tmp, file, function, line, printbuf);
+      fflush( fp_log );
+    }
+}
+
+static char* hex_str(unsigned char *buf, int len, char* outstr )
+{
+
+  const char *set = "0123456789abcdef";
+  char *tmp;
+  unsigned char *end;
+  if (len > 1024)
+    len = 1024;
+  end = buf + len;
+  tmp = &outstr[0];
+  while (buf < end)
+    {
+      *tmp++ = set[ (*buf) >> 4 ];
+      *tmp++ = set[ (*buf) & 0xF ];
+      *tmp++ = ' ';
+      buf ++;
+    }
+  *tmp = '\0';
+  return outstr;
+}
+
+void hex_dump( unsigned char * buf, int len )
+{
+  char str[KB(4)];
+  if( dbg_term )
+    puts( hex_str( buf, len, str ) );
+  if( dbg_file ){
+    fputs( hex_str( buf, len, str ), fp_log );
+    fprintf( fp_log, "\n" );
+    fflush( fp_log );
+  }
+  //fprintf( stderr, hex_str( buf, len ) );
+}
+
+void debug_term_on()
+{
+  dbg_term = 1;
+}
+
+void debug_term_off()
+{
+  dbg_term = 0;
+}
+
+
+int mkdir_recursive( char* path )
+{
+  char *p;
+
+  if( access( path, 0 ) == 0 )
+    return 0;
+
+  for( p=path; *p; p++ )
+    {
+      if( p>path && *p == '/' )
+	{
+	  *p = 0;
+	  if( access( path, 0 ) != 0 )
+	    {
+#ifdef __WIN32__
+	      mkdir( path );
+#else
+	      if( mkdir( path, S_IRWXU ) != 0 )
+		return -1;
+#endif
+	    }
+	  *p = '/';
+	}
+    }
+#ifdef __WIN32__
+  return mkdir( path );
+#else
+  return mkdir( path, S_IRWXU );
+#endif
+}
+
+void init_file_path()
+{
+  char tmp[64];
+  time_t t = time( NULL );
+  struct tm* tm1 = localtime(&t);
+  
+  if( !tm1 )
+    {
+      perror("debug.c init_file_path: ERROR GETTING SYSTEM TIME.");
+    }
+  log_day = tm1->tm_mday;
+  strftime( tmp, 64, "/%Y-%m-%d.txt", tm1 );
+  
+  if( access( dir, 0 )!=0 )
+    {
+      (mkdir_recursive( dir )<0) ? perror("mkdir_recursive fail!!\n") : 0;
+    }
+  strcpy( filename, dir );
+  strcat( filename, tmp );
+  if( fp_log )
+    fclose( fp_log );
+  fp_log = fopen( filename, "w" );
+  if(fp_log)
+    {
+      fprintf(fp_log,"======================LOG  START========================\n");
+      fclose(fp_log);  fp_log=NULL;
+      fp_log = fopen( filename, "a+" );
+      NULL==fp_log ? printf("init_file_path():fopen(a+) fail\n") : 0;
+    }
+}
+
+void debug_file_on(char *path)
+{
+  if( dbg_file )
+    return;
+  debug_set_dir(path);
+  init_file_path();
+  dbg_file = 1;
+}
+
+void debug_file_off()
+{
+  if( !dbg_file )
+    return;
+  dbg_file = 0;
+  if( fp_log )
+    fclose( fp_log );
+}
+
+void debug_set_dir(char* str)
+{
+  strcpy( dir, str );
+}
+
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/debug.h xen-4.1.2-b/tools/ioemu-qemu-xen/debug.h
--- xen-4.1.2-a/tools/ioemu-qemu-xen/debug.h	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/debug.h	2012-12-28 16:02:41.000934327 +0800
@@ -0,0 +1,34 @@
+#ifndef _DEBUG_H
+#define _DEBUG_H
+
+#include <stdio.h>
+#include <errno.h>
+#include <assert.h>
+
+//#define RELEASE
+
+#ifndef RELEASE
+#define DBG(args ...) \
+  print_error( (char*)__FILE__, (char*)__func__, __LINE__, ##args )
+#else
+#define DBG(args ...)				  \
+  do						  \
+    {                                               \
+fprintf(logfile,"%s::[%s]::(%d):\n",                \
+	(char*)__FILE__, (char*)__func__, __LINE__);      \
+fprintf(logfile, ##args);	fprintf(logfile, "\n");	  \
+}                                                    \
+while(0)
+//#define DBG printf
+#endif
+#define MSGprintf
+void print_error(char* file, char* function, int line, const char *fmt, ...);
+void hex_dump( unsigned char * buf, int len );
+void debug_term_on(void);
+void debug_term_off(void);
+void debug_file_on(char *path);
+void debug_file_off(void);
+void debug_set_dir(char* str);
+
+#endif //_DEBUG_H
+
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/fat.c xen-4.1.2-b/tools/ioemu-qemu-xen/fat.c
--- xen-4.1.2-a/tools/ioemu-qemu-xen/fat.c	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/fat.c	2012-12-28 16:02:41.001934709 +0800
@@ -0,0 +1,936 @@
+/* fat.c - FAT filesystem */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2000,2001,2002,2003,2004,2005,2007,2008,2009  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "misc.h"
+#include "fat.h"
+#include "debug.h"
+
+
+int g_err = GRUB_ERR_NONE;
+int64_t s_bpb_bytes_per_sector;
+int64_t s_part_off_sector;
+
+static int bdrv_pread_from_sector_of_volume(BlockDriverState *bs, int64_t offset,
+               void *buf1, int count1)
+{
+  int64_t off = s_bpb_bytes_per_sector * s_part_off_sector + offset;
+  return bdrv_pread(bs, off, buf1, count1);
+}
+
+
+static int
+fat_log2 (unsigned x)
+{
+  int i;
+
+  if (x == 0)
+    return -1;
+
+  for (i = 0; (x & 1) == 0; i++)
+    x >>= 1;
+
+  if (x != 1)
+    return -1;
+
+  return i;
+}
+
+
+char *
+grub_fat_find_dir (BlockDriverState *bs, struct grub_fat_data *data,
+		   const char *path,
+		   int (*hook) (const char *filename,
+				const struct grub_dirhook_info *info,
+				void *closure),
+		   void *closure);
+
+
+
+struct grub_fat_data *
+grub_fat_mount (BlockDriverState *bs, uint32_t part_off_sector)
+{
+  struct grub_fat_bpb bpb;
+  struct grub_fat_data *data = 0;
+  grub_uint32_t first_fat, magic;
+  int64_t off_bytes = (int64_t)part_off_sector << GRUB_DISK_SECTOR_BITS;
+
+  if (! bs)
+    goto fail;
+
+  data = (struct grub_fat_data *) malloc (sizeof (*data));
+  if (! data)
+    goto fail;
+
+  /* Read the BPB.  */
+  if (bdrv_pread(bs, off_bytes, &bpb, sizeof(bpb)) != sizeof(bpb))
+    {
+      DBG("bdrv_pread fail....");
+      goto fail;
+    }
+    
+  if (grub_strncmp((const char *) bpb.version_specific.fat12_or_fat16.fstype,
+		   "FAT12", 5)
+      && grub_strncmp((const char *) bpb.version_specific.fat12_or_fat16.fstype,
+		      "FAT16", 5)
+      && grub_strncmp((const char *) bpb.version_specific.fat32.fstype,
+		      "FAT32", 5)
+      )
+    {
+      
+      DBG("fail here-->grub_strncmp......");
+      goto fail;
+    }
+
+  /* Get the sizes of logical sectors and clusters.  */
+  s_bpb_bytes_per_sector = (bpb.bytes_per_sector);
+  s_part_off_sector = part_off_sector;
+  data->logical_sector_bits =
+    fat_log2 (grub_le_to_cpu16 (bpb.bytes_per_sector));
+  DBG("bpb.bytes_per_sector=0x%x, le_to_cpu16=0x%x",
+	 bpb.bytes_per_sector, grub_le_to_cpu16 (bpb.bytes_per_sector));
+  
+
+  if (data->logical_sector_bits < GRUB_DISK_SECTOR_BITS)
+  {
+    DBG("fail here-->logical_sector_bits"); 
+    goto fail;
+  }
+  data->logical_sector_bits -= GRUB_DISK_SECTOR_BITS;
+
+  DBG("bpb.sectors_per_cluster=%u", bpb.sectors_per_cluster);
+  data->cluster_bits = fat_log2 (bpb.sectors_per_cluster);
+  if (data->cluster_bits < 0)
+    {
+      DBG("fail here-->cluster_bits......line[%u]", __LINE__); 
+      goto fail;
+    }
+  data->cluster_bits += data->logical_sector_bits;
+
+  /* Get information about FATs.  */
+  DBG("bpb.num_reserved_sectors=%u,"
+      "le_to_cpu16=%u",
+      bpb.num_reserved_sectors,
+      grub_le_to_cpu16 (bpb.num_reserved_sectors));
+  data->fat_sector = (grub_le_to_cpu16 (bpb.num_reserved_sectors)
+		      << data->logical_sector_bits);
+  DBG("data->fat_sector=%u, part_off_sector=%u",
+      data->fat_sector, part_off_sector);
+  if (data->fat_sector == 0)
+    {
+      DBG("fail here-->fat_sector......"); 
+      goto fail;
+    }
+  data->sectors_per_fat = ((bpb.sectors_per_fat_16
+			    ? grub_le_to_cpu16 (bpb.sectors_per_fat_16)
+			    : grub_le_to_cpu32 (bpb.version_specific.fat32.sectors_per_fat_32))
+			   << data->logical_sector_bits);
+  DBG("bpb.version_specific.fat32.sectors_per_fat_32=%u\n"
+	 "grub_le_to_cpu32 (bpb.version_specific.fat32.sectors_per_fat_32)=%u",
+	 bpb.version_specific.fat32.sectors_per_fat_32,
+	 grub_le_to_cpu32 (bpb.version_specific.fat32.sectors_per_fat_32));
+  if (data->sectors_per_fat == 0)
+    goto fail;
+
+  /* Get the number of sectors in this volume.  */
+  data->num_sectors = ((bpb.num_total_sectors_16
+			? grub_le_to_cpu16 (bpb.num_total_sectors_16)
+			: grub_le_to_cpu32 (bpb.num_total_sectors_32))
+		       << data->logical_sector_bits);
+  if (data->num_sectors == 0)
+    {
+      DBG("fail here-->num_sectors......"); 
+      goto fail;
+    }
+  /* Get information about the root directory.  */
+  if (bpb.num_fats == 0)
+    {
+      DBG("fail here-->num_fats......"); 
+      goto fail;
+    }
+  data->root_sector = data->fat_sector + bpb.num_fats * data->sectors_per_fat;
+  data->num_root_sectors
+    = ((((grub_uint32_t) grub_le_to_cpu16 (bpb.num_root_entries)
+	 * GRUB_FAT_DIR_ENTRY_SIZE
+	 + grub_le_to_cpu16 (bpb.bytes_per_sector) - 1)
+	>> (data->logical_sector_bits + GRUB_DISK_SECTOR_BITS))
+       << (data->logical_sector_bits));
+  //in fat32 : root is not included in file cluster??
+  data->cluster_sector = data->root_sector + data->num_root_sectors;
+  data->num_clusters = (((data->num_sectors - data->cluster_sector)
+			 >> (data->cluster_bits + data->logical_sector_bits))
+			+ 2);
+
+  if (data->num_clusters <= 2)
+    {
+      DBG("fail here-->num_clusters......"); 
+      goto fail;
+    }
+  if (! bpb.sectors_per_fat_16)
+    {
+      /* FAT32.  */
+      grub_uint16_t flags = grub_le_to_cpu16 (bpb.version_specific.fat32.extended_flags);
+
+      data->root_cluster = grub_le_to_cpu32 (bpb.version_specific.fat32.root_cluster);
+      data->fat_size = 32;
+      data->cluster_eof_mark = 0x0ffffff8;
+
+      if (flags & 0x80)
+	{
+	  /* Get an active FAT.  */
+	  unsigned active_fat = flags & 0xf;
+
+	  if (active_fat > bpb.num_fats)
+	    goto fail;
+
+	  data->fat_sector += active_fat * data->sectors_per_fat;
+	}
+
+      if (bpb.num_root_entries != 0 || bpb.version_specific.fat32.fs_version != 0)
+	goto fail;
+    }
+  else
+    {
+      /* FAT12 or FAT16.  */
+      data->root_cluster = ~0U;
+
+      if (data->num_clusters <= 4085 + 2)
+	{
+	  /* FAT12.  */
+	  data->fat_size = 12;
+	  data->cluster_eof_mark = 0x0ff8;
+	}
+      else
+	{
+	  /* FAT16.  */
+	  data->fat_size = 16;
+	  data->cluster_eof_mark = 0xfff8;
+	}
+    }
+
+  /* More sanity checks.  */
+  if (data->num_sectors <= data->fat_sector)
+    goto fail;
+
+  
+  DBG("data->fat_sector=%u, data->sectors_per_fat=%u",
+	 data->fat_sector, data->sectors_per_fat);
+  if (bdrv_pread_from_sector_of_volume(bs,
+		 data->fat_sector << GRUB_DISK_SECTOR_BITS,
+		 &first_fat,
+		 sizeof (first_fat)) != sizeof(first_fat))
+    {
+      DBG("fail here-->bdrv_pread......"); 
+      goto fail;
+    }
+
+  first_fat = grub_le_to_cpu32 (first_fat);
+
+  if (data->fat_size == 32)
+    {
+      first_fat &= 0x0fffffff;
+      magic = 0x0fffff00;
+    }
+  else if (data->fat_size == 16)
+    {
+      first_fat &= 0x0000ffff;
+      magic = 0xff00;
+    }
+  else
+    {
+      first_fat &= 0x00000fff;
+      magic = 0x0f00;
+    }
+
+  /* Serial number.  */
+  if (bpb.sectors_per_fat_16)
+    data->uuid = grub_le_to_cpu32 (bpb.version_specific.fat12_or_fat16.num_serial);
+  else
+    data->uuid = grub_le_to_cpu32 (bpb.version_specific.fat32.num_serial);
+
+  /* Ignore the 3rd bit, because some BIOSes assigns 0xF0 to the media
+     descriptor, even if it is a so-called superfloppy (e.g. an USB key).
+     The check may be too strict for this kind of stupid BIOSes, as
+     they overwrite the media descriptor.  */
+  if ((first_fat | 0x8) != (magic | bpb.media | 0x8))
+    {
+      DBG("fail here-->first_fat=0x%x, magic=0x%x",
+	     first_fat, magic); 
+      goto fail;
+    }
+  /* Start from the root directory.  */
+  data->file_cluster = data->root_cluster;
+  data->cur_cluster_num = ~0U;
+  data->attr = GRUB_FAT_ATTR_DIRECTORY;
+  DBG("data->file_cluster=%u \ndata->cur_cluster_num=%u \ndata->attr=0x%x\n"
+	 "data->logical_sector_bits=%u\n"
+	 "data->cluster_bits=%u",
+	 data->file_cluster, data->cur_cluster_num, data->attr,
+	 data->logical_sector_bits, data->cluster_bits);
+  return data;
+
+ fail:
+
+  free (data);
+  printf("not a FAT filesystem!\n");
+  return 0;
+}
+
+
+
+//´ÓÎÄ¼þµÄÖ¸¶¨Æ«ÒÆoffset×Ö½Ú´¦¶ÁÈ¡len×Ö½ÚµÄÊý¾Ýµ½buf
+//ÎÄ¼þÓÉdata->file_clusterÖ¸¶¨
+//data->file_clusterÖ¸¶¨ÁËÎÄ¼þµÄÆðÊ¼´ØºÅ
+//Ä¬ÈÏdata->file_cluster=2£¬´ú±í¸ùÄ¿Â¼
+static grub_ssize_t
+grub_fat_read_data (BlockDriverState *bs, struct grub_fat_data *data,
+		    void (*read_hook) (grub_disk_addr_t sector,
+				       unsigned offset, unsigned length,
+				       void *closure),
+		    void *closure,
+		    grub_off_t offset, grub_size_t len, char *buf)
+{
+  grub_size_t size;
+  grub_uint32_t logical_cluster;
+  unsigned logical_cluster_bits;
+  grub_ssize_t ret = 0;
+  unsigned long sector;
+  uint64_t off_bytes = 0; 
+  /* This is a special case. FAT12 and FAT16 doesn't have the root directory
+     in clusters.  */
+  if (data->file_cluster == ~0U)
+    {
+      size = (data->num_root_sectors << GRUB_DISK_SECTOR_BITS) - offset;
+      if (size > len)
+	size = len;
+
+      off_bytes = ((uint64_t)data->root_sector << GRUB_DISK_SECTOR_BITS) + offset;
+      if(bdrv_pread_from_sector_of_volume(bs, off_bytes, buf, size ) != size) 
+	return -1;
+
+      return size;
+    }
+
+  /* Calculate the logical cluster number and offset.  */
+  logical_cluster_bits = (data->cluster_bits
+			  + data->logical_sector_bits
+			  + GRUB_DISK_SECTOR_BITS);
+  logical_cluster = offset >> logical_cluster_bits;    //which cluster to read 
+  offset &= (1 << logical_cluster_bits) - 1;           //mod
+
+  if (logical_cluster < data->cur_cluster_num)   //
+    {
+      data->cur_cluster_num = 0;
+      data->cur_cluster = data->file_cluster; // µÚ2¸öfat±íÏî¿ªÊ¼¼ÇÂ¼Ä¿Â¼ºÍÎÄ¼þ
+    }
+
+  while (len)
+    {
+      while (logical_cluster > data->cur_cluster_num)
+	{
+	  /* Find next cluster.  */
+	  grub_uint32_t next_cluster;
+	  unsigned long fat_offset;
+
+	  switch (data->fat_size)
+	    {
+	    case 32:
+	      fat_offset = data->cur_cluster << 2;
+	      break;
+	    case 16:
+	      fat_offset = data->cur_cluster << 1;
+	      break;
+	    default:
+	      /* case 12: */
+	      fat_offset = data->cur_cluster + (data->cur_cluster >> 1);
+	      break;
+	    }
+
+	  /* Read the FAT.  */
+	  int len = (data->fat_size + 7) >> 3;
+	  uint64_t off_bytes =  ((uint64_t)data->fat_sector << GRUB_DISK_SECTOR_BITS) + fat_offset; 
+	  if (bdrv_pread_from_sector_of_volume (bs, off_bytes, 
+			  (char *) &next_cluster, 
+			  len) != len)   //´Ófat±í¶ÁÈ¡´ØºÅ
+	    return -1;
+
+	  next_cluster = grub_le_to_cpu32 (next_cluster);
+	  switch (data->fat_size)
+	    {
+	    case 16:
+	      next_cluster &= 0xFFFF;
+	      break;
+	    case 12:
+	      if (data->cur_cluster & 1)
+		next_cluster >>= 4;
+
+	      next_cluster &= 0x0FFF;
+	      break;
+	    }
+
+	  DBG ("fat_size=%d, next_cluster=%u",
+			data->fat_size, next_cluster);
+
+	  /* Check the end.  */
+	  if (next_cluster >= data->cluster_eof_mark)
+	    return ret;
+
+	  if (next_cluster < 2 || next_cluster >= data->num_clusters)
+	    {
+	      DBG("invalid cluster %u................",
+			  next_cluster);
+	      return -1;
+	    }
+
+	  data->cur_cluster = next_cluster;
+	  data->cur_cluster_num++;
+	}
+
+      /* Read the data here.  */
+      //Âß¼­´ØËù¶ÔÓ¦µÄ¾ø¶ÔÉÈÇø
+      sector = (data->cluster_sector
+		+ ((data->cur_cluster - 2)
+		   << (data->cluster_bits + data->logical_sector_bits))); 
+      //¾ø¶ÔÉÈÇøÖÐÈ¥µôÆ«ÒÆºóµÄ×Ö½ÚÊý
+      size = (1 << logical_cluster_bits) - offset;
+      if (size > len)
+	size = len;
+
+      //disk->read_hook = read_hook;
+      //disk->closure = closure;
+      int64_t off_bytes = ((uint64_t)sector << GRUB_DISK_SECTOR_BITS) + offset;
+      //disk->read_hook = 0;
+      if (bdrv_pread_from_sector_of_volume (bs, off_bytes, buf, size) != size)
+	return -1;
+
+      len -= size;
+      buf += size;
+      ret += size;
+      logical_cluster++;
+      offset = 0;  //ÒÔºó¶ÁµÄ¶¼ÊÇÍêÕûÉÈÇø
+    }
+
+  return ret;
+}
+
+//±éÀúÓÉdata->file_clusterÖ¸¶¨µÄÄ¿Â¼
+static int
+grub_fat_iterate_dir (BlockDriverState *bs, struct grub_fat_data *data,
+		      int (*hook) (const char *filename,
+				   struct grub_fat_dir_entry *dir,
+				   void *closure),
+		      void *closure)
+{
+  struct grub_fat_dir_entry dir;
+  char *filename, *filep = 0;
+  grub_uint16_t *unibuf;
+  int slot = -1, slots = -1;
+  int checksum = -1;
+  grub_ssize_t offset = -sizeof(dir);
+
+  if (! (data->attr & GRUB_FAT_ATTR_DIRECTORY))
+    return printf("not a directory......\n");
+
+  /* Allocate space enough to hold a long name.  */
+  filename = (char*)malloc (0x40 * 13 * 4 + 1);
+  unibuf = (grub_uint16_t *) malloc (0x40 * 13 * 2);
+  char *gbname = (char*)malloc(0x40 * 13 * 2);
+  if (! filename || ! unibuf || !gbname)
+    {
+      free(gbname);
+      free (filename);
+      free (unibuf);
+      perror("iterate: malloc failed!...\n");
+      return -1;
+    }
+
+  
+  int count = 0;
+  while (1)
+    {
+      unsigned i;
+
+      /* Adjust the offset.  */
+      offset += sizeof (dir);
+      DBG("\n[%d]offset=%u,"
+	     "data->cur_cluster_num=%u,data->cur_cluster=%u", 
+	     count+1, offset, 
+	     data->cur_cluster_num, data->cur_cluster);
+      /* Read a directory entry.  */
+      //0x0±íÊ¾¿ÕÄ¿Â¼
+      if ((grub_fat_read_data (bs, data, 0, 0,
+			       offset, sizeof (dir), (char *) &dir)
+	   != sizeof (dir) || dir.name[0] == 0))
+	{
+	  DBG("break...dir.name[0]==%d", dir.name[0]);
+	  break;
+	}
+      /* Handle long name entries.  */
+      if (dir.attr == GRUB_FAT_ATTR_LONG_NAME)
+	{
+	  DBG("long name...");
+	  struct grub_fat_long_name_entry *long_name
+	    = (struct grub_fat_long_name_entry *) &dir;
+	  grub_uint8_t id = long_name->id;
+
+	  if (id & 0x40)  //the last item
+	    {
+	      id &= 0x3f;   //index or ordinal number  1~31
+	      slots = slot = id;
+	      checksum = long_name->checksum;
+	      DBG("the last ordinal num=%d!!!", id);
+	    }
+
+	  if (id != slot || slot == 0 || checksum != long_name->checksum)
+	    {
+	      DBG("not valid ordinal number ,ignore...continue");
+	      checksum = -1;
+	      continue;
+	    }
+
+	  slot--;
+	  memcpy (unibuf + slot * 13, long_name->name1, 5 * 2);
+	  memcpy (unibuf + slot * 13 + 5, long_name->name2, 6 * 2);
+	  memcpy (unibuf + slot * 13 + 11, long_name->name3, 2 * 2);
+	  DBG("memcpy...continue");
+	  continue;
+	}
+
+      
+      /* Check if this entry is valid.  */
+      //oxe5±íÊ¾ÒÑ¾­±»É¾³ý
+      if (dir.name[0] == 0xe5 || (dir.attr & ~GRUB_FAT_ATTR_VALID))
+	{
+	  DBG("dir.name[0]=0x%x, dir.attr=0x%x not valid...continue", 
+		 dir.name[0], dir.attr);
+	  continue;
+	}
+
+      DBG("checksum=%d, slot=%d", checksum, slot);
+      /* This is a workaround for Japanese.  */
+      if (dir.name[0] == 0x05)
+	dir.name[0] = 0xe5;
+
+      if (checksum != -1 && slot == 0)
+	{
+	  DBG("checksuming");
+	  grub_uint8_t sum;
+
+	  for (sum = 0, i = 0; i < sizeof (dir.name); i++)
+	    sum = ((sum >> 1) | (sum << 7)) + dir.name[i];
+
+	  if (sum == checksum)
+	    {//³¤Ãû±íÏîºóÃæ½ô½Ó¶ÌÃû±íÏî£¬ÑéÖ¤³É¹¦ÔòÖ¤Ã÷ÕæÕýÊÇ³¤Ãû×Ö
+	      int u;
+
+	      for (u = 0; u < slots * 13; u++)
+		unibuf[u] = grub_le_to_cpu16 (unibuf[u]);
+
+	      *grub_utf16_to_utf8 ((grub_uint8_t *) filename, unibuf,
+				   slots * 13) = '\0';
+
+	      
+	      checksum = -1;
+	      for (i = 0; i < sizeof (dir.name); i++)
+		DBG("0x%x  ", dir.name[i]);
+	      
+	      u2g(filename, strlen(filename), gbname, 0x40 * 13 * 2);
+	      DBG("\ndir.name=%s, filename=%s, dir.attr=0x%x,"
+		     "sum==checksum...continue",
+		     dir.name, gbname, dir.attr);
+	      
+	      count++;
+	      
+	      if (hook && hook (gbname, &dir, closure))
+	        break;
+	      
+	      continue;
+	    }
+
+	  checksum = -1;
+	}
+
+      //ºóÃæµÄ´¦ÀíÕë¶Ô·ÇÕæÊµ³¤ÃûºÍÕæÊµ¶ÌÃû
+      /* Convert the 8.3 file name.  */
+      //È¥µô¶ÌÃûµÄ¿Õ¸ñ£¬È«¸ÄÎªÐ¡Ð´
+      filep = filename;
+      if (dir.attr & GRUB_FAT_ATTR_VOLUME_ID)
+	{
+	  DBG("VOLUME");
+	  for (i = 0; i < sizeof (dir.name) && dir.name[i]
+		 && ! grub_isspace (dir.name[i]); i++)
+	    *filep++ = dir.name[i];
+	}
+      else
+	{
+	  for (i = 0; i < 8 && dir.name[i] && ! grub_isspace (dir.name[i]); i++)
+	    *filep++ = grub_tolower (dir.name[i]);
+
+	  *filep = '.';
+
+	  for (i = 8; i < 11 && dir.name[i] && ! grub_isspace (dir.name[i]); i++)
+	    *++filep = grub_tolower (dir.name[i]);
+
+	  if (*filep != '.')
+	    filep++;
+	}
+      *filep = '\0';
+      
+      //for (i = 0; i < sizeof (dir.name); i++)
+      //	DBG("0x%x  ", dir.name[i]);
+      DBG("\ndir.name=%s, filename=¡¾%s¡¿, dir.attr=0x%x,"
+	     "...next while",
+	     dir.name, filename, dir.attr);
+      count++;
+      /*if(strcmp(filename, ".") && strcmp(filename, ".."))
+	{
+	  DBG("{==============>");
+	  struct grub_fat_data *data2 = NULL;
+	  data2 = (struct grub_fat_data*)malloc(sizeof(*data));
+	  memcpy(data2, data, sizeof(*data));
+	  data2->attr = dir.attr;
+	  data2->file_size = grub_le_to_cpu32 (dir.file_size);
+	  data2->file_cluster = ((grub_le_to_cpu16 (dir.first_cluster_high) << 16)
+				 | grub_le_to_cpu16 (dir.first_cluster_low));
+	  data2->cur_cluster_num = ~0U;
+	  (grub_fat_iterate_dir(bs, data2, NULL, NULL) < 0) ? DBG("error !!!!!!") : 0;
+	  free(data2);
+	  DBG("<===================}");
+	}
+      */
+      if (hook && hook (filename, &dir, closure))
+        break;
+    }
+
+  free(gbname);
+  free (filename);
+  free (unibuf);
+
+  return 0;
+}
+
+
+
+//´«¸øgrub_fat_find_hookµÄ²ÎÊýclosure
+struct grub_fat_find_dir_closure
+{
+  struct grub_fat_data *data;
+  int (*hook) (const char *filename,
+	       const struct grub_dirhook_info *info,
+	       void *closure);
+  void *closure;
+  char *dirname;
+  int call_hook;
+  int found;
+};
+
+
+static int
+grub_fat_find_dir_hook (const char *filename, struct grub_fat_dir_entry *dir,
+			void *closure)
+{
+  struct grub_fat_find_dir_closure *c = closure;
+  struct grub_dirhook_info info;
+  memset (&info, 0, sizeof (info));
+
+  info.dir = !! (dir->attr & GRUB_FAT_ATTR_DIRECTORY);
+  info.case_insensitive = 1;
+  info.mtimeset = (dir->c_date || dir->c_time);
+  info.mtime = (((grub_uint32_t)dir->c_date << 16) | (dir->c_time));
+  info.filesize = dir->file_size;
+  
+  DBG("target file ¡¾%s¡¿======", c->dirname);
+  if (dir->attr & GRUB_FAT_ATTR_VOLUME_ID)
+    {
+      DBG("volume id , ignore======");
+      return 0;
+    }
+  
+  if (*(c->dirname) == '\0' && (c->call_hook))
+    { //´ò¿ªµÄÊÇÄ¿Â¼  /x/path1/path2/
+      //·µ»Ø0£¬ÈÃiterateÊ±Ö»ÊÇ´òÓ¡ÐÅÏ¢£¬¶ø²»ÍË³öwhile
+      c->found = 1;
+      if(!(c->data->attr & GRUB_FAT_ATTR_DIRECTORY))
+	{
+	  printf("it's not a directory!\n");
+	}
+      DBG("list the dir ¡¾%s¡¿===========",
+	  ((struct ls_ctrl*)c->closure)->dirname);
+      return c->hook (filename, &info, c->closure);
+    }
+
+  
+  if (grub_strcasecmp (c->dirname, filename) == 0)
+    { //´ò¿ªµÄÊÇÎÄ¼þ /x/path1/file
+      DBG("found======");
+      struct grub_fat_data *data = c->data;
+
+      c->found = 1;
+      data->attr = dir->attr;
+      data->file_size = grub_le_to_cpu32 (dir->file_size);
+      data->file_cluster = ((grub_le_to_cpu16 (dir->first_cluster_high) << 16)
+			       | grub_le_to_cpu16 (dir->first_cluster_low));
+      data->cur_cluster_num = ~0U;
+
+      if (c->call_hook)
+	c->hook (filename, &info, c->closure);
+
+      return 1;
+    }
+  else
+    {
+      DBG("not match======");
+    }
+  return 0;
+}
+
+
+/* Find the underlying directory or file in PATH and return the
+   next path. If there is no next path or an error occurs, return NULL.
+   If HOOK is specified, call it with each file name.  */
+//ÔÚÓÉdataÖ¸¶¨µÄÄ¿Â¼ÏÂ²éÕÒÓÉpathÂ·¾¶Ö¸¶¨µÄÎÄ¼þ¼Ð»òÎÄ¼þ
+//ÕÒµ½Ö®ºó½»ÓÉ grub_fat_find_dir_hookº¯Êý´¦Àí£¬ÆäÖÐclosure²ÎÊýÊÇ¹Ø¼ü
+char *
+grub_fat_find_dir (BlockDriverState *bs, struct grub_fat_data *data,
+		   const char *path,
+		   int (*hook) (const char *filename,
+				const struct grub_dirhook_info *info,
+				void *closure),
+		   void *closure)
+{
+  char *dirname, *dirp;
+  struct grub_fat_find_dir_closure c;
+  DBG("to search [%s]...in data->attr=0x%x", path, data->attr);
+  if (! (data->attr & GRUB_FAT_ATTR_DIRECTORY))
+    {
+      printf("not a directory...........\n");
+      return 0;
+    }
+
+  /* Extract a directory name.  */
+  while (*path == '/')
+    path++;
+
+  dirp = grub_strchr (path, '/');
+  if (dirp)
+    {
+      unsigned len = dirp - path;
+
+      dirname = (char*)malloc (len + 1);
+      if (! dirname)
+	return 0;
+
+      memcpy (dirname, path, len);
+      dirname[len] = '\0';
+    }
+  else
+    {
+    /* This is actually a file.  */
+      dirname = grub_strdup (path);
+    }
+  DBG("searching \"%s\"======", dirname);
+  c.data = data;
+  c.hook = hook;
+  c.closure = closure;
+  c.dirname =dirname;
+  c.found = 0;
+  c.call_hook = (! dirp && hook);  //Õë¶ÔÄ¿Â¼µÄhook
+  
+  int ret = grub_fat_iterate_dir (bs, data, grub_fat_find_dir_hook, &c);
+  if(0 == ret && !c.found)
+    {
+      g_err = GRUB_ERR_NOT_FOUND; 
+      printf("file not found..\n");
+    }
+  else if(ret < 0)
+    {
+      g_err = GRUB_ERR_UNKNOWN;
+      printf("iterate error!\n");
+    }
+    
+  
+  free (dirname);
+
+  return (c.found && 0==ret) ? dirp : 0;
+}
+
+
+
+
+
+grub_err_t
+grub_fat_open (grub_file_t file, const char *name)
+{
+  struct grub_fat_data *data = 0;
+  char *p = (char *) name;
+
+  
+  data = grub_fat_mount (file->bs, file->part_off_sector);
+  if (! data)
+    {
+      printf("[%s]: mount error!\n", name);
+      goto fail;
+    }
+
+  int i = 0;
+  do
+    {
+      p = grub_fat_find_dir (file->bs, data, p, 0, 0);
+      DBG("%d cycle past¡¾path=%s¡¿.......", i+1, p);
+      //error judge......
+    }
+  while (p);
+
+  DBG("exit while======");
+ 
+  if ((GRUB_ERR_NONE == g_err) 
+      && (data->attr & GRUB_FAT_ATTR_DIRECTORY))
+    {
+      printf ("[%s]: not a file!\n", name);
+      goto fail;
+    }
+  
+  if(GRUB_ERR_NONE == g_err)
+    {
+      DBG("found======");
+    }
+  else
+    {
+      printf("not found or error!\n");
+      goto fail;
+    }
+
+  DBG("11111111111111111111111");
+  file->data = data;
+  file->size = data->file_size;
+  return 0;
+
+ fail:
+  free(data); 
+  file->data = NULL;
+  DBG("2222222222222222222222");
+  return 1;
+}
+
+
+#define    TIME_BIT    0xFFFF
+#define    TIME_HOUR_BIT    0xF800
+#define    TIME_MINUTE_BIT    0x07E0
+#define    TIME_SECOND_BIT    0x001F
+#define    DATE_BIT    0xFFFF0000
+#define    DATE_YEAR_BIT    0xFE00
+#define    DATE_MONTH_BIT    0x01E0
+#define    DATE_DAY_BIT    0x001F
+static  int find_then_ls_hook(const char *filename,
+			   const struct grub_dirhook_info *info, void *closure)
+{
+  struct ls_ctrl* ctrl = (struct ls_ctrl*)closure;
+  DBG("detail=%d", ctrl->detail);
+  printf("%s", filename);
+  if(!ctrl->detail)
+    {
+      printf("\n");
+      return 0;
+    }
+  else
+    {
+      printf("\t");
+    }
+
+
+  printf("%ubytes\t", (info->filesize));
+  printf("%s\t", (info->dir ? "dir" : "file"));
+  grub_uint16_t time = ((info->mtime) & TIME_BIT);
+  grub_uint16_t date = ((info->mtime) & DATE_BIT) >> 16;
+  
+  printf("%04d/%02d/%02d\t",
+	 ((date & DATE_YEAR_BIT) >> 9) + 1980,
+	 (date & DATE_MONTH_BIT) >> 5,
+	 (date & DATE_DAY_BIT));
+  printf("%02d:%02d:%02d\n", 
+	 (time & TIME_HOUR_BIT) >> 11,
+	 (time & TIME_MINUTE_BIT) >> 5,
+	 time & TIME_SECOND_BIT) * 2;  
+  
+  return 0;  // ×îÖÕ·µ»Ø¸øiterate
+}
+
+
+grub_err_t
+grub_fat_ls (grub_file_t file, const char *path,
+	      int (*hook) (const char *filename,
+			   const struct grub_dirhook_info *info, void *closure),
+	      void *closure)
+{
+  struct grub_fat_data *data = 0;
+  grub_size_t len;
+  char *dirname = 0;
+  char *p;
+  
+  data = grub_fat_mount (file->bs, file->part_off_sector);
+  if (! data)
+    goto fail;
+
+  file->data = data;
+  /* Make sure that DIRNAME terminates with '/'.  */
+  len = strlen(path);
+  dirname = (char*)malloc (len + 1 + 1);
+  if (! dirname)
+    goto fail;
+  memcpy (dirname, path, len);
+  p = dirname + len;
+  if (path[len - 1] != '/')
+    *p++ = '/';
+  *p = '\0';
+  p = dirname;
+
+  do
+    {
+      p = grub_fat_find_dir (file->bs, data, p, find_then_ls_hook, closure);
+    }
+  while (p && g_err == GRUB_ERR_NONE);
+
+  
+
+ fail:
+
+  free (dirname);
+  free (data);  file->data = NULL;
+  
+  return g_err;
+}
+
+
+grub_err_t grub_fat_close(grub_file_t file)
+{
+  free(file->data);
+  return g_err;
+}
+
+
+grub_ssize_t grub_fat_read(grub_file_t file, grub_off_t offset,
+			   grub_size_t len, char *buf)
+{
+  return grub_fat_read_data(file->bs, file->data, NULL, NULL, offset, len, buf);
+}
+
+
+
+
+
+
+
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/fat.h xen-4.1.2-b/tools/ioemu-qemu-xen/fat.h
--- xen-4.1.2-a/tools/ioemu-qemu-xen/fat.h	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/fat.h	2012-12-28 16:02:41.002938019 +0800
@@ -0,0 +1,160 @@
+#ifndef FS_FAT_H
+#define FS_FAT_H
+
+
+#include "fs-types.h"
+#include "block_int.h"
+#include "fs-comm.h"
+#include "grub_err.h"
+
+
+#define GRUB_DISK_SECTOR_BITS      9
+#define GRUB_FAT_DIR_ENTRY_SIZE	32
+
+#define GRUB_FAT_ATTR_READ_ONLY	0x01
+#define GRUB_FAT_ATTR_HIDDEN	0x02
+#define GRUB_FAT_ATTR_SYSTEM	0x04
+#define GRUB_FAT_ATTR_VOLUME_ID	0x08
+#define GRUB_FAT_ATTR_DIRECTORY	0x10
+#define GRUB_FAT_ATTR_ARCHIVE	0x20
+
+#define GRUB_FAT_MAXFILE	256
+
+#define GRUB_FAT_ATTR_LONG_NAME	(GRUB_FAT_ATTR_READ_ONLY \
+				 | GRUB_FAT_ATTR_HIDDEN \
+				 | GRUB_FAT_ATTR_SYSTEM \
+				 | GRUB_FAT_ATTR_VOLUME_ID)
+#define GRUB_FAT_ATTR_VALID	(GRUB_FAT_ATTR_READ_ONLY \
+				 | GRUB_FAT_ATTR_HIDDEN \
+				 | GRUB_FAT_ATTR_SYSTEM \
+				 | GRUB_FAT_ATTR_DIRECTORY \
+				 | GRUB_FAT_ATTR_ARCHIVE \
+				 | GRUB_FAT_ATTR_VOLUME_ID)
+
+struct grub_fat_bpb
+{
+  grub_uint8_t jmp_boot[3];
+  grub_uint8_t oem_name[8];
+  grub_uint16_t bytes_per_sector;
+  grub_uint8_t sectors_per_cluster;
+  grub_uint16_t num_reserved_sectors;
+  grub_uint8_t num_fats;
+  grub_uint16_t num_root_entries;
+  grub_uint16_t num_total_sectors_16;
+  grub_uint8_t media;
+  grub_uint16_t sectors_per_fat_16;
+  grub_uint16_t sectors_per_track;
+  grub_uint16_t num_heads;
+  grub_uint32_t num_hidden_sectors;
+  grub_uint32_t num_total_sectors_32;
+  union
+  {
+    struct
+    {
+      grub_uint8_t num_ph_drive;
+      grub_uint8_t reserved;
+      grub_uint8_t boot_sig;
+      grub_uint32_t num_serial;
+      grub_uint8_t label[11];
+      grub_uint8_t fstype[8];
+    } __attribute__ ((packed)) fat12_or_fat16;
+    struct
+    {
+      grub_uint32_t sectors_per_fat_32;
+      grub_uint16_t extended_flags;
+      grub_uint16_t fs_version;
+      grub_uint32_t root_cluster;
+      grub_uint16_t fs_info;
+      grub_uint16_t backup_boot_sector;
+      grub_uint8_t reserved[12];
+      grub_uint8_t num_ph_drive;
+      grub_uint8_t reserved1;
+      grub_uint8_t boot_sig;
+      grub_uint32_t num_serial;
+      grub_uint8_t label[11];
+      grub_uint8_t fstype[8];
+    } __attribute__ ((packed)) fat32;
+  } __attribute__ ((packed)) version_specific;
+} __attribute__ ((packed));
+
+struct grub_fat_dir_entry
+{
+  grub_uint8_t name[11];
+  grub_uint8_t attr;
+  grub_uint8_t nt_reserved;
+  grub_uint8_t c_time_tenth;
+  grub_uint16_t c_time;
+  grub_uint16_t c_date;
+  grub_uint16_t a_date;
+  grub_uint16_t first_cluster_high;
+  grub_uint16_t w_time;
+  grub_uint16_t w_date;
+  grub_uint16_t first_cluster_low;
+  grub_uint32_t file_size;
+} __attribute__ ((packed));
+
+struct grub_fat_long_name_entry
+{
+  grub_uint8_t id;
+  grub_uint16_t name1[5];
+  grub_uint8_t attr;
+  grub_uint8_t reserved;
+  grub_uint8_t checksum;
+  grub_uint16_t name2[6];
+  grub_uint16_t first_cluster;
+  grub_uint16_t name3[2];
+} __attribute__ ((packed));
+
+struct grub_fat_data
+{
+  int logical_sector_bits;
+  grub_uint32_t num_sectors;
+
+  grub_uint32_t fat_sector;
+  grub_uint32_t sectors_per_fat;
+  int fat_size;
+
+  grub_uint32_t root_cluster;
+  grub_uint32_t root_sector;
+  grub_uint32_t num_root_sectors;
+
+  int cluster_bits;
+  grub_uint32_t cluster_eof_mark;
+  grub_uint32_t cluster_sector;
+  grub_uint32_t num_clusters;
+
+  grub_uint8_t attr;
+  grub_ssize_t file_size;
+  grub_uint32_t file_cluster;
+  grub_uint32_t cur_cluster_num;
+  grub_uint32_t cur_cluster;
+
+  grub_uint32_t uuid;
+};
+
+
+
+
+
+
+
+struct grub_fat_data* 
+grub_fat_mount (BlockDriverState *bs, grub_uint32_t part_off_sector);
+
+grub_err_t
+grub_fat_open (grub_file_t file, const char *name);
+
+grub_err_t
+grub_fat_ls (grub_file_t file, const char *path,
+	      int (*hook) (const char *filename,
+			   const struct grub_dirhook_info *info,
+			   void *closure),
+	     void *closure);
+
+grub_err_t grub_fat_close(grub_file_t file);
+
+grub_ssize_t grub_fat_read(grub_file_t file, grub_off_t offset,
+		  grub_size_t len, char *buf);
+
+
+#endif
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/fs-comm.h xen-4.1.2-b/tools/ioemu-qemu-xen/fs-comm.h
--- xen-4.1.2-a/tools/ioemu-qemu-xen/fs-comm.h	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/fs-comm.h	2012-12-28 16:02:41.003846897 +0800
@@ -0,0 +1,60 @@
+#ifndef _FS_COMM_H
+#define _FS_COMM_H
+
+#include "fs-types.h"
+#include "block_int.h"
+#include "grub_err.h"
+#include "debug.h"
+
+typedef struct  grub_file
+{
+  void *data;
+  BlockDriverState *bs;
+  uint32_t part_off_sector;
+  grub_size_t size;
+  grub_off_t offset;
+  /* This is called when a sector is read. Used only for a disk device.  */
+  void (*read_hook) (grub_disk_addr_t sector,
+		     unsigned offset, unsigned length, void *closure);
+  void *closure;
+}*grub_file_t;
+
+struct grub_dirhook_info
+{
+  unsigned dir:1;
+  unsigned mtimeset:1;
+  unsigned case_insensitive:1;
+  grub_uint32_t mtime;    //(date | time)
+  grub_uint32_t filesize;
+  grub_uint64_t filesize_ntfs;
+  grub_uint64_t time_ntfs;
+};
+
+struct ls_ctrl
+{
+  unsigned detail:1;
+  char* dirname;
+};
+
+
+
+
+typedef grub_err_t
+(*grub_open) (grub_file_t file, const char *name);
+
+typedef grub_err_t
+(*grub_ls) (grub_file_t file, const char *path,
+	      int (*hook) (const char *filename,
+			   const struct grub_dirhook_info *info,
+			   void *closure),
+	     void *closure);
+
+typedef grub_err_t 
+(*grub_close) (grub_file_t file);
+
+typedef grub_ssize_t 
+(*grub_read)(grub_file_t file, grub_off_t offset,
+		  grub_size_t len, char *buf);
+
+
+#endif
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/fshelp.c xen-4.1.2-b/tools/ioemu-qemu-xen/fshelp.c
--- xen-4.1.2-a/tools/ioemu-qemu-xen/fshelp.c	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/fshelp.c	2012-12-28 16:02:41.004932457 +0800
@@ -0,0 +1,362 @@
+/* fshelp.c -- Filesystem helper functions */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2004,2005,2006,2007,2008  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "err.h"
+#include "misc.h"
+#include "block_int.h"
+#include "fshelp.h"
+#include "ntfs.h"
+#include "debug.h"
+
+struct grub_fshelp_find_file_closure
+{
+  grub_fshelp_node_t rootnode;
+  int (*iterate_dir) (grub_fshelp_node_t dir,
+		      int (*hook)
+		      (const char *filename,
+		       enum grub_fshelp_filetype filetype,
+		       grub_fshelp_node_t node, void *closure),
+		      void *closure);
+  void *closure;
+  char *(*read_symlink) (grub_fshelp_node_t node);
+  int symlinknest;
+  enum grub_fshelp_filetype foundtype;
+  grub_fshelp_node_t currroot;
+};
+
+static void
+free_node (grub_fshelp_node_t node, struct grub_fshelp_find_file_closure *c)
+{
+  if (node != c->rootnode && node != c->currroot)
+    grub_free (node);
+}
+
+struct find_file_closure
+{
+  char *name;
+  enum grub_fshelp_filetype *type;
+  grub_fshelp_node_t *oldnode;
+  grub_fshelp_node_t *currnode;
+};
+
+static int
+iterate (const char *filename,
+	 enum grub_fshelp_filetype filetype,
+	 grub_fshelp_node_t node,
+	 void *closure)
+{
+  struct find_file_closure *c = closure;
+  DBG("list_file hooked by fshelp:iterate(), filename=%s", filename);
+  if (filetype == GRUB_FSHELP_UNKNOWN ||
+      (grub_strcmp (c->name, filename) &&
+       (! (filetype & GRUB_FSHELP_CASE_INSENSITIVE) ||
+	grub_strncasecmp (c->name, filename, GRUB_LONG_MAX))))
+    {
+      DBG("not match!!!>>>>>>");
+      grub_free (node);
+      return 0;
+    }
+
+  /* The node is found, stop iterating over the nodes.  */
+  *(c->type) = filetype & ~GRUB_FSHELP_CASE_INSENSITIVE;
+  *(c->oldnode) = *(c->currnode);
+  *(c->currnode) = node;
+  DBG("found!!>>>>>>");
+  return 1;
+}
+
+static grub_err_t
+find_file (const char *currpath, grub_fshelp_node_t currroot,
+	   grub_fshelp_node_t *currfound,
+	   struct grub_fshelp_find_file_closure *c)
+{
+  char fpath[grub_strlen (currpath) + 1];
+  char *name = fpath;
+  char *next;
+  enum grub_fshelp_filetype type = GRUB_FSHELP_DIR;
+  grub_fshelp_node_t currnode = currroot;
+  grub_fshelp_node_t oldnode = currroot;
+
+  c->currroot = currroot;
+
+  grub_strncpy (fpath, currpath, grub_strlen (currpath) + 1);
+
+  /* Remove all leading slashes.  */
+  while (*name == '/')
+    name++;
+
+  if (! *name)
+    {
+      *currfound = currnode;
+      return 0;
+    }
+
+  for (;;)
+    {
+      int found;
+      struct find_file_closure cc;
+
+      /* Extract the actual part from the pathname.  */
+      next = grub_strchr (name, '/');
+      if (next)
+	{
+	  /* Remove all leading slashes.  */
+	  while (*next == '/')
+	    *(next++) = '\0';
+	}
+
+      /* At this point it is expected that the current node is a
+	 directory, check if this is true.  */
+      if (type != GRUB_FSHELP_DIR)
+	{
+	  free_node (currnode, c);
+	  return grub_error (GRUB_ERR_BAD_FILE_TYPE, "not a directory");
+	}
+
+      DBG("find_file_closure cc.name=¡¾%s¡¿", name);
+      cc.name = name;
+      cc.type = &type;
+      cc.oldnode = &oldnode;
+      cc.currnode = &currnode;
+      /* Iterate over the directory.  */
+      DBG("******fshelp:find_file hooked by \'grub_ntfs_iterate_dir\',"
+	  "nested another hook \'fshelp:iterator\'");
+      found = c->iterate_dir (currnode, iterate, &cc); 
+      if (! found)
+	{
+	  if (grub_errno)
+	    return grub_errno;
+
+	  break;
+	}
+
+      /* Read in the symlink and follow it.  */
+      if (type == GRUB_FSHELP_SYMLINK)
+	{
+	  char *symlink;
+
+	  /* Test if the symlink does not loop.  */
+	  if (++(c->symlinknest) == 8)
+	    {
+	      free_node (currnode, c);
+	      free_node (oldnode, c);
+	      return grub_error (GRUB_ERR_SYMLINK_LOOP,
+				 "too deep nesting of symlinks");
+	    }
+
+	  symlink = c->read_symlink (currnode);
+	  free_node (currnode, c);
+
+	  if (!symlink)
+	    {
+	      free_node (oldnode, c);
+	      return grub_errno;
+	    }
+
+	  /* The symlink is an absolute path, go back to the root inode.  */
+	  if (symlink[0] == '/')
+	    {
+	      free_node (oldnode, c);
+	      oldnode = c->rootnode;
+	    }
+
+	  /* Lookup the node the symlink points to.  */
+	  find_file (symlink, oldnode, &currnode, c);
+	  type = c->foundtype;
+	  grub_free (symlink);
+
+	  if (grub_errno)
+	    {
+	      free_node (oldnode, c);
+	      return grub_errno;
+	    }
+	}
+
+      free_node (oldnode, c);
+
+      /* Found the node!  */
+      if (! next || *next == '\0')
+	{
+	  *currfound = currnode;
+	  c->foundtype = type;
+	  return 0;
+	}
+
+      name = next;
+    }
+
+  return grub_error (GRUB_ERR_FILE_NOT_FOUND, "file not found");
+}
+
+/* Lookup the node PATH.  The node ROOTNODE describes the root of the
+   directory tree.  The node found is returned in FOUNDNODE, which is
+   either a ROOTNODE or a new malloc'ed node.  ITERATE_DIR is used to
+   iterate over all directory entries in the current node.
+   READ_SYMLINK is used to read the symlink if a node is a symlink.
+   EXPECTTYPE is the type node that is expected by the called, an
+   error is generated if the node is not of the expected type.  Make
+   sure you use the NESTED_FUNC_ATTR macro for HOOK, this is required
+   because GCC has a nasty bug when using regparm=3.  */
+grub_err_t
+grub_fshelp_find_file (const char *path, grub_fshelp_node_t rootnode,
+		       grub_fshelp_node_t *foundnode,
+		       int (*iterate_dir) (grub_fshelp_node_t dir,
+					   int (*hook)
+					   (const char *filename,
+					    enum grub_fshelp_filetype filetype,
+					    grub_fshelp_node_t node,
+					    void *closure),
+					   void *closure),
+		       void *closure,
+		       char *(*read_symlink) (grub_fshelp_node_t node),
+		       enum grub_fshelp_filetype expecttype)
+{
+  grub_err_t err;
+  struct grub_fshelp_find_file_closure c;
+
+  c.rootnode = rootnode;
+  c.iterate_dir = iterate_dir;
+  c.closure = closure;
+  c.read_symlink = read_symlink;
+  c.symlinknest = 0;
+  c.foundtype = GRUB_FSHELP_DIR;
+
+  if (!path || path[0] != '/')
+    {
+      grub_error (GRUB_ERR_BAD_FILENAME, "bad filename");
+      return grub_errno;
+    }
+  
+  
+  DBG("going to find_file\n");
+  err = find_file (path, rootnode, foundnode, &c);
+  if (err)
+    return err;
+
+  /* Check if the node that was found was of the expected type.  */
+  if (expecttype == GRUB_FSHELP_REG && c.foundtype != expecttype)
+    return grub_error (GRUB_ERR_BAD_FILE_TYPE, "not a regular file");
+  else if (expecttype == GRUB_FSHELP_DIR && c.foundtype != expecttype)
+    return grub_error (GRUB_ERR_BAD_FILE_TYPE, "not a directory");
+
+  return 0;
+}
+
+/* Read LEN bytes from the file NODE on disk DISK into the buffer BUF,
+   beginning with the block POS.  READ_HOOK should be set before
+   reading a block from the file.  GET_BLOCK is used to translate file
+   blocks to disk blocks.  The file is FILESIZE bytes big and the
+   blocks have a size of LOG2BLOCKSIZE (in log2).  */
+grub_ssize_t
+grub_fshelp_read_file (BlockDriverState* bs, grub_fshelp_node_t node,
+		       void (*read_hook) (grub_disk_addr_t sector,
+					  unsigned offset,
+					  unsigned length,
+					  void *closure),
+		       void *closure,
+		       grub_off_t pos, grub_size_t len, char *buf,
+		       grub_disk_addr_t (*get_block) (grub_fshelp_node_t node,
+						      grub_disk_addr_t block),
+		       grub_off_t filesize, int log2blocksize)
+{
+  grub_disk_addr_t i, blockcnt;
+  grub_off_t off_bytes;
+  int blocksize = 1 << (log2blocksize + GRUB_DISK_SECTOR_BITS);
+
+  /* Adjust LEN so it we can't read past the end of the file.  */
+  if (pos + len > filesize)
+    len = filesize - pos;
+
+  blockcnt = ((len + pos) + blocksize - 1) >>
+    (log2blocksize + GRUB_DISK_SECTOR_BITS);
+
+  for (i = pos >> (log2blocksize + GRUB_DISK_SECTOR_BITS); i < blockcnt; i++)
+    {
+      grub_disk_addr_t blknr;
+      int blockoff = pos & (blocksize - 1);
+      int blockend = blocksize;
+
+      int skipfirst = 0;
+
+      blknr = get_block (node, i);
+      if (grub_errno)
+	return -1;
+
+      blknr = blknr << log2blocksize;
+      off_bytes = blknr << GRUB_DISK_SECTOR_BITS;
+
+      /* Last block.  */
+      if (i == blockcnt - 1)
+	{
+	  blockend = (len + pos) & (blocksize - 1);
+
+	  /* The last portion is exactly blocksize.  */
+	  if (! blockend)
+	    blockend = blocksize;
+	}
+
+      /* First block.  */
+      if (i == (pos >> (log2blocksize + GRUB_DISK_SECTOR_BITS)))
+	{
+	  skipfirst = blockoff;
+	  blockend -= skipfirst;
+	}
+
+      /* If the block number is 0 this block is not stored on disk but
+	 is zero filled instead.  */
+      if (blknr)
+	{
+	  //bs->read_hook = read_hook;
+	  //bs->closure = closure;
+	  
+	  bdrv_pread_from_lcn_of_volum(bs, off_bytes + skipfirst,
+		      buf, blockend);
+	  //bs->read_hook = 0;
+	  if (grub_errno)
+	    return -1;
+	}
+      else
+	grub_memset (buf, 0, blockend);
+
+      buf += blocksize - skipfirst;
+    }
+
+  return len;
+}
+
+unsigned int
+grub_fshelp_log2blksize (unsigned int blksize, unsigned int *pow)
+{
+  int mod;
+
+  *pow = 0;
+  while (blksize > 1)
+    {
+      mod = blksize - ((blksize >> 1) << 1);
+      blksize >>= 1;
+
+      /* Check if it really is a power of two.  */
+      if (mod)
+	return grub_error (GRUB_ERR_BAD_NUMBER,
+			   "the blocksize is not a power of two");
+      (*pow)++;
+    }
+
+  return GRUB_ERR_NONE;
+}
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/fshelp.h xen-4.1.2-b/tools/ioemu-qemu-xen/fshelp.h
--- xen-4.1.2-a/tools/ioemu-qemu-xen/fshelp.h	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/fshelp.h	2012-12-28 16:02:41.004932457 +0800
@@ -0,0 +1,86 @@
+/* fshelp.h -- Filesystem helper functions */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2004,2005,2006,2007,2008  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GRUB_FSHELP_HEADER
+#define GRUB_FSHELP_HEADER	1
+
+#include "fs-types.h"
+#include "grub_err.h"
+#include "block_int.h"
+typedef struct grub_fshelp_node *grub_fshelp_node_t;
+
+#define GRUB_FSHELP_CASE_INSENSITIVE	0x100
+#define GRUB_FSHELP_TYPE_MASK	0xff
+#define GRUB_FSHELP_FLAGS_MASK	0x100
+
+enum grub_fshelp_filetype
+  {
+    GRUB_FSHELP_UNKNOWN,
+    GRUB_FSHELP_REG,
+    GRUB_FSHELP_DIR,
+    GRUB_FSHELP_SYMLINK
+  };
+
+/* Lookup the node PATH.  The node ROOTNODE describes the root of the
+   directory tree.  The node found is returned in FOUNDNODE, which is
+   either a ROOTNODE or a new malloc'ed node.  ITERATE_DIR is used to
+   iterate over all directory entries in the current node.
+   READ_SYMLINK is used to read the symlink if a node is a symlink.
+   EXPECTTYPE is the type node that is expected by the called, an
+   error is generated if the node is not of the expected type.  Make
+   sure you use the NESTED_FUNC_ATTR macro for HOOK, this is required
+   because GCC has a nasty bug when using regparm=3.  */
+grub_err_t grub_fshelp_find_file (const char *path,
+				  grub_fshelp_node_t rootnode,
+				  grub_fshelp_node_t *foundnode,
+				  int (*iterate_dir)
+				  (grub_fshelp_node_t dir,
+				   int (*hook)
+				   (const char *filename,
+				    enum grub_fshelp_filetype filetype,
+				    grub_fshelp_node_t node,
+				    void *closure),
+				   void *closure),
+				  void *closure,
+				  char *(*read_symlink) (grub_fshelp_node_t node),
+				  enum grub_fshelp_filetype expect);
+
+
+/* Read LEN bytes from the file NODE on disk DISK into the buffer BUF,
+   beginning with the block POS.  READ_HOOK should be set before
+   reading a block from the file.  GET_BLOCK is used to translate file
+   blocks to disk blocks.  The file is FILESIZE bytes big and the
+   blocks have a size of LOG2BLOCKSIZE (in log2).  */
+grub_ssize_t grub_fshelp_read_file (BlockDriverState* bs, grub_fshelp_node_t node,
+				    void (*read_hook)
+				    (grub_disk_addr_t sector,
+				     unsigned offset,
+				     unsigned length,
+				     void *closure),
+				    void *closure,
+				    grub_off_t pos, grub_size_t len, char *buf,
+				    grub_disk_addr_t (*get_block)
+				    (grub_fshelp_node_t node,
+				     grub_disk_addr_t block),
+				    grub_off_t filesize, int log2blocksize);
+
+unsigned int grub_fshelp_log2blksize (unsigned int blksize,
+				      unsigned int *pow);
+
+#endif /* ! GRUB_FSHELP_HEADER */
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/fs-time.c xen-4.1.2-b/tools/ioemu-qemu-xen/fs-time.c
--- xen-4.1.2-a/tools/ioemu-qemu-xen/fs-time.c	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/fs-time.c	2012-12-28 16:02:41.005685798 +0800
@@ -0,0 +1,77 @@
+#include "fs-time.h"
+
+
+
+static uint64_t div64(uint64_t a, uint32_t b, uint32_t c)
+{
+    union {
+        uint64_t ll;
+        struct {
+#ifdef WORDS_BIGENDIAN
+            uint32_t high, low;
+#else
+            uint32_t low, high;
+#endif
+        } l;
+    } u, res;
+    uint64_t rl, rh;
+
+    u.ll = a;
+    rl = (uint64_t)u.l.low * (uint64_t)b;
+    rh = (uint64_t)u.l.high * (uint64_t)b;
+    rh += (rl >> 32);
+    res.l.high = rh / c;
+    res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
+    return res.ll;
+}
+
+static uint64_t sub64(uint64_t a, uint64_t b)
+{
+  struct
+  {
+#ifdef WORDS_BIGENDIAN
+            uint32_t high, low;
+#else
+            uint32_t low, high;
+#endif
+  }a1,b1,c;
+  
+  a1.high = a>>32;
+  a1.low = a&0xffffffff;
+  b1.high = b>>32;
+  b1.low = b&0xffffffff;
+  
+  if(a1.high < b1.high)
+    {
+      c=b1;
+      b1=a1;
+      a1=c;
+    }
+  
+  a1.high -= b1.high;
+  a1.low -= b1.low;
+  if(a1.low & 0x80000000)
+    {
+      a1.low = (~(a1.low & 0x7fffffff))+1;
+      a1.high -= 1;
+    }
+  
+  uint64_t ret = (uint64_t)a1.high<<32 | a1.low;
+  return ret;
+}
+
+struct tm* ntfs_utc2local(grub_uint64_t time, struct tm* ptm)
+{
+  //time_t time2 = sub64(time, NTFS_TIME_OFFSET);
+  time_t time2 = time - NTFS_TIME_OFFSET;
+  /*DBG("sizeof(int)=%d", sizeof(int));
+  DBG("sizeof(short)=%d", sizeof(short));
+  DBG("sizeof(long)=%d", sizeof(long));
+  DBG("sizeof(long long)=%d", sizeof(unsigned long long));
+  DBG("sizeof(time_t)=%d, time=%zu, time2=%zu", sizeof(time_t), time, time2);*/
+  //time2 = div64(time2,1,10000000);
+  time2 = time2 / 10000000;
+  DBG("sizeof(time_t)=%d, time=%zu, time2=%zu", sizeof(time_t), time, time2);
+  ////time2 = 0;//time(NULL);
+  return localtime_r(&time2, ptm);
+}
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/fs-time.h xen-4.1.2-b/tools/ioemu-qemu-xen/fs-time.h
--- xen-4.1.2-a/tools/ioemu-qemu-xen/fs-time.h	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/fs-time.h	2012-12-28 16:02:41.005685798 +0800
@@ -0,0 +1,12 @@
+#ifndef FS_TIME_H
+#define FS_TIME_H
+
+#include <time.h>
+#include "fs-comm.h"
+#define NTFS_TIME_OFFSET ((grub_uint64_t)(369 * 365 + 89) * 24 * 3600 * 10000000)
+
+struct tm* ntfs_utc2local(grub_uint64_t time, struct tm* ptm);
+
+
+#endif
+
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/fs-types.h xen-4.1.2-b/tools/ioemu-qemu-xen/fs-types.h
--- xen-4.1.2-a/tools/ioemu-qemu-xen/fs-types.h	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/fs-types.h	2012-12-28 16:02:41.006932417 +0800
@@ -0,0 +1,234 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2002,2005,2006,2007,2008,2009  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GRUB_TYPES_HEADER
+#define GRUB_TYPES_HEADER	1
+
+#include "grub-config.h"
+#include "x86_64/types.h"
+
+#ifdef GRUB_UTIL
+# define GRUB_CPU_SIZEOF_VOID_P	SIZEOF_VOID_P
+# define GRUB_CPU_SIZEOF_LONG	SIZEOF_LONG
+# ifdef WORDS_BIGENDIAN
+#  define GRUB_CPU_WORDS_BIGENDIAN	1
+# else
+#  undef GRUB_CPU_WORDS_BIGENDIAN
+# endif
+#else /* ! GRUB_UTIL */
+# define GRUB_CPU_SIZEOF_VOID_P	GRUB_TARGET_SIZEOF_VOID_P
+# define GRUB_CPU_SIZEOF_LONG	GRUB_TARGET_SIZEOF_LONG
+# ifdef GRUB_TARGET_WORDS_BIGENDIAN
+#  define GRUB_CPU_WORDS_BIGENDIAN	1
+# else
+#  undef GRUB_CPU_WORDS_BIGENDIAN
+# endif
+#endif /* ! GRUB_UTIL */
+
+#if GRUB_CPU_SIZEOF_VOID_P != 4 && GRUB_CPU_SIZEOF_VOID_P != 8
+# error "This architecture is not supported because sizeof(void *) != 4 and sizeof(void *) != 8"
+#endif
+
+#ifndef GRUB_TARGET_WORDSIZE
+# if GRUB_TARGET_SIZEOF_VOID_P == 4
+#  define GRUB_TARGET_WORDSIZE 32
+# elif GRUB_TARGET_SIZEOF_VOID_P == 8
+#  define GRUB_TARGET_WORDSIZE 64
+# endif
+#endif
+
+/* Define various wide integers.  */
+typedef signed char		grub_int8_t;
+typedef short			grub_int16_t;
+typedef int			grub_int32_t;
+#if GRUB_CPU_SIZEOF_LONG == 8
+typedef long			grub_int64_t;
+#else
+typedef long long		grub_int64_t;
+#endif
+
+typedef unsigned char		grub_uint8_t;
+typedef unsigned short		grub_uint16_t;
+typedef unsigned		grub_uint32_t;
+#if GRUB_CPU_SIZEOF_LONG == 8
+typedef unsigned long		grub_uint64_t;
+#else
+typedef unsigned long long	grub_uint64_t;
+#endif
+
+/* Misc types.  */
+#if GRUB_TARGET_SIZEOF_VOID_P == 8
+typedef grub_uint64_t	grub_target_addr_t;
+typedef grub_uint64_t	grub_target_off_t;
+typedef grub_uint64_t	grub_target_size_t;
+typedef grub_int64_t	grub_target_ssize_t;
+#else
+typedef grub_uint32_t	grub_target_addr_t;
+typedef grub_uint32_t	grub_target_off_t;
+typedef grub_uint32_t	grub_target_size_t;
+typedef grub_int32_t	grub_target_ssize_t;
+#endif
+
+#if GRUB_CPU_SIZEOF_VOID_P == 8
+typedef grub_uint64_t	grub_addr_t;
+typedef grub_uint64_t	grub_size_t;
+typedef grub_int64_t	grub_ssize_t;
+#else
+typedef grub_uint32_t	grub_addr_t;
+typedef grub_uint32_t	grub_size_t;
+typedef grub_int32_t	grub_ssize_t;
+#endif
+
+#if GRUB_CPU_SIZEOF_VOID_P == 8
+# define GRUB_ULONG_MAX 18446744073709551615UL
+# define GRUB_LONG_MAX 9223372036854775807L
+# define GRUB_LONG_MIN (-9223372036854775807L - 1)
+#else
+# define GRUB_ULONG_MAX 4294967295UL
+# define GRUB_LONG_MAX 2147483647L
+# define GRUB_LONG_MIN (-2147483647L - 1)
+#endif
+
+#if GRUB_CPU_SIZEOF_VOID_P == 4
+#define UINT_TO_PTR(x) ((void*)(grub_uint32_t)(x))
+#define PTR_TO_UINT64(x) ((grub_uint64_t)(grub_uint32_t)(x))
+#define PTR_TO_UINT32(x) ((grub_uint32_t)(x))
+#else
+#define UINT_TO_PTR(x) ((void*)(grub_uint64_t)(x))
+#define PTR_TO_UINT64(x) ((grub_uint64_t)(x))
+#define PTR_TO_UINT32(x) ((grub_uint32_t)(grub_uint64_t)(x))
+#endif
+
+/* The type for representing a file offset.  */
+typedef grub_uint64_t	grub_off_t;
+
+/* The type for representing a disk block address.  */
+typedef grub_uint64_t	grub_disk_addr_t;
+
+/* Byte-orders.  */
+#define grub_swap_bytes16(x)	\
+({ \
+   grub_uint16_t _x = (x); \
+   (grub_uint16_t) ((_x << 8) | (_x >> 8)); \
+})
+
+#if defined(__GNUC__) && (__GNUC__ > 3) && (__GNUC__ > 4 || __GNUC_MINOR__ >= 3) && defined(GRUB_TARGET_I386)
+static inline grub_uint32_t grub_swap_bytes32(grub_uint32_t x)
+{
+	return __builtin_bswap32(x);
+}
+
+static inline grub_uint64_t grub_swap_bytes64(grub_uint64_t x)
+{
+	return __builtin_bswap64(x);
+}
+#else					/* not gcc 4.3 or newer */
+#define grub_swap_bytes32(x)	\
+({ \
+   grub_uint32_t _x = (x); \
+   (grub_uint32_t) ((_x << 24) \
+                    | ((_x & (grub_uint32_t) 0xFF00UL) << 8) \
+                    | ((_x & (grub_uint32_t) 0xFF0000UL) >> 8) \
+                    | (_x >> 24)); \
+})
+
+#define grub_swap_bytes64(x)	\
+({ \
+   grub_uint64_t _x = (x); \
+   (grub_uint64_t) ((_x << 56) \
+                    | ((_x & (grub_uint64_t) 0xFF00ULL) << 40) \
+                    | ((_x & (grub_uint64_t) 0xFF0000ULL) << 24) \
+                    | ((_x & (grub_uint64_t) 0xFF000000ULL) << 8) \
+                    | ((_x & (grub_uint64_t) 0xFF00000000ULL) >> 8) \
+                    | ((_x & (grub_uint64_t) 0xFF0000000000ULL) >> 24) \
+                    | ((_x & (grub_uint64_t) 0xFF000000000000ULL) >> 40) \
+                    | (_x >> 56)); \
+})
+#endif					/* not gcc 4.3 or newer */
+
+#ifdef GRUB_CPU_WORDS_BIGENDIAN
+# define grub_cpu_to_le16(x)	grub_swap_bytes16(x)
+# define grub_cpu_to_le32(x)	grub_swap_bytes32(x)
+# define grub_cpu_to_le64(x)	grub_swap_bytes64(x)
+# define grub_le_to_cpu16(x)	grub_swap_bytes16(x)
+# define grub_le_to_cpu32(x)	grub_swap_bytes32(x)
+# define grub_le_to_cpu64(x)	grub_swap_bytes64(x)
+# define grub_cpu_to_be16(x)	((grub_uint16_t) (x))
+# define grub_cpu_to_be32(x)	((grub_uint32_t) (x))
+# define grub_cpu_to_be64(x)	((grub_uint64_t) (x))
+# define grub_be_to_cpu16(x)	((grub_uint16_t) (x))
+# define grub_be_to_cpu32(x)	((grub_uint32_t) (x))
+# define grub_be_to_cpu64(x)	((grub_uint64_t) (x))
+# ifdef GRUB_TARGET_WORDS_BIGENDIAN
+#  define grub_target_to_host16(x)	((grub_uint16_t) (x))
+#  define grub_target_to_host32(x)	((grub_uint32_t) (x))
+#  define grub_target_to_host64(x)	((grub_uint64_t) (x))
+#  define grub_host_to_target16(x)	((grub_uint16_t) (x))
+#  define grub_host_to_target32(x)	((grub_uint32_t) (x))
+#  define grub_host_to_target64(x)	((grub_uint64_t) (x))
+# else /* ! GRUB_TARGET_WORDS_BIGENDIAN */
+#  define grub_target_to_host16(x)	grub_swap_bytes16(x)
+#  define grub_target_to_host32(x)	grub_swap_bytes32(x)
+#  define grub_target_to_host64(x)	grub_swap_bytes64(x)
+#  define grub_host_to_target16(x)	grub_swap_bytes16(x)
+#  define grub_host_to_target32(x)	grub_swap_bytes32(x)
+#  define grub_host_to_target64(x)	grub_swap_bytes64(x)
+# endif
+#else /* ! WORDS_BIGENDIAN */
+# define grub_cpu_to_le16(x)	((grub_uint16_t) (x))
+# define grub_cpu_to_le32(x)	((grub_uint32_t) (x))
+# define grub_cpu_to_le64(x)	((grub_uint64_t) (x))
+# define grub_le_to_cpu16(x)	((grub_uint16_t) (x))
+# define grub_le_to_cpu32(x)	((grub_uint32_t) (x))
+# define grub_le_to_cpu64(x)	((grub_uint64_t) (x))
+# define grub_cpu_to_be16(x)	grub_swap_bytes16(x)
+# define grub_cpu_to_be32(x)	grub_swap_bytes32(x)
+# define grub_cpu_to_be64(x)	grub_swap_bytes64(x)
+# define grub_be_to_cpu16(x)	grub_swap_bytes16(x)
+# define grub_be_to_cpu32(x)	grub_swap_bytes32(x)
+# define grub_be_to_cpu64(x)	grub_swap_bytes64(x)
+# ifdef GRUB_TARGET_WORDS_BIGENDIAN
+#  define grub_target_to_host16(x)	grub_swap_bytes16(x)
+#  define grub_target_to_host32(x)	grub_swap_bytes32(x)
+#  define grub_target_to_host64(x)	grub_swap_bytes64(x)
+#  define grub_host_to_target16(x)	grub_swap_bytes16(x)
+#  define grub_host_to_target32(x)	grub_swap_bytes32(x)
+#  define grub_host_to_target64(x)	grub_swap_bytes64(x)
+# else /* ! GRUB_TARGET_WORDS_BIGENDIAN */
+#  define grub_target_to_host16(x)	((grub_uint16_t) (x))
+#  define grub_target_to_host32(x)	((grub_uint32_t) (x))
+#  define grub_target_to_host64(x)	((grub_uint64_t) (x))
+#  define grub_host_to_target16(x)	((grub_uint16_t) (x))
+#  define grub_host_to_target32(x)	((grub_uint32_t) (x))
+#  define grub_host_to_target64(x)	((grub_uint64_t) (x))
+# endif
+#endif /* ! WORDS_BIGENDIAN */
+
+#if GRUB_TARGET_SIZEOF_VOID_P == 8
+#  define grub_host_to_target_addr(x) grub_host_to_target64(x)
+#else
+#  define grub_host_to_target_addr(x) grub_host_to_target32(x)
+#endif
+
+
+
+
+
+
+
+#endif /* ! GRUB_TYPES_HEADER */
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/grub-config.h xen-4.1.2-b/tools/ioemu-qemu-xen/grub-config.h
--- xen-4.1.2-a/tools/ioemu-qemu-xen/grub-config.h	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/grub-config.h	2012-12-28 16:02:41.006932417 +0800
@@ -0,0 +1,251 @@
+/* config.h.  Generated from config.h.in by configure.  */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define it if GAS requires that absolute indirect calls/jumps are not
+   prefixed with an asterisk */
+/* #undef ABSOLUTE_WITHOUT_ASTERISK */
+
+/* Define it to \"addr32\" or \"addr32;\" to make GAS happy */
+#define ADDR32 addr32
+
+/* Define it to \"data32\" or \"data32;\" to make GAS happy */
+#define DATA32 data32
+
+/* Define to 1 if translation of program messages to the user's native
+   language is requested. */
+#define ENABLE_NLS 1
+
+/* Define if C symbols get an underscore after compilation */
+/* #undef HAVE_ASM_USCORE */
+
+/* Define to 1 if you have the `asprintf' function. */
+#define HAVE_ASPRINTF 1
+
+/* Define to 1 if you have the MacOS X function CFLocaleCopyCurrent in the
+   CoreFoundation framework. */
+/* #undef HAVE_CFLOCALECOPYCURRENT */
+
+/* Define to 1 if you have the MacOS X function CFPreferencesCopyAppValue in
+   the CoreFoundation framework. */
+/* #undef HAVE_CFPREFERENCESCOPYAPPVALUE */
+
+/* Define to 1 if you have the <curses.h> header file. */
+/* #undef HAVE_CURSES_H */
+
+/* Define if the GNU dcgettext() function is already present or preinstalled.
+   */
+#define HAVE_DCGETTEXT 1
+
+/* Define to 1 if you have the <dirent.h> header file, and it defines `DIR'.
+   */
+#define HAVE_DIRENT_H 1
+
+/* Define to 1 if you have the <ft2build.h> header file. */
+#define HAVE_FT2BUILD_H 1
+
+/* Define to 1 if you have the `getgid' function. */
+#define HAVE_GETGID 1
+
+/* Define if getrawpartition() in -lutil can be used */
+/* #undef HAVE_GETRAWPARTITION */
+
+/* Define if the GNU gettext() function is already present or preinstalled. */
+#define HAVE_GETTEXT 1
+
+/* Define to 1 if you have the `getuid' function. */
+#define HAVE_GETUID 1
+
+/* Define if you have the iconv() function and it works. */
+/* #undef HAVE_ICONV */
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the <limits.h> header file. */
+#define HAVE_LIMITS_H 1
+
+/* Define to 1 if you have the `lstat' function. */
+#define HAVE_LSTAT 1
+
+/* Define to 1 if you have the <malloc.h> header file. */
+#define HAVE_MALLOC_H 1
+
+/* Define to 1 if you have the `memalign' function. */
+#define HAVE_MEMALIGN 1
+
+/* Define to 1 if you have the `memmove' function. */
+#define HAVE_MEMMOVE 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the <ncurses/curses.h> header file. */
+/* #undef HAVE_NCURSES_CURSES_H */
+
+/* Define to 1 if you have the <ncurses.h> header file. */
+/* #undef HAVE_NCURSES_H */
+
+/* Define to 1 if you have the <ndir.h> header file, and it defines `DIR'. */
+/* #undef HAVE_NDIR_H */
+
+/* Define if opendisk() in -lutil can be used */
+/* #undef HAVE_OPENDISK */
+
+/* Define to 1 if you have the <pci/pci.h> header file. */
+/* #undef HAVE_PCI_PCI_H */
+
+/* Define to 1 if you have the `posix_memalign' function. */
+#define HAVE_POSIX_MEMALIGN 1
+
+/* Define if returns_twice attribute is supported */
+/* #undef HAVE_RETURNS_TWICE */
+
+/* Define to 1 if you have the `sbrk' function. */
+#define HAVE_SBRK 1
+
+/* Define to 1 if you have the <SDL/SDL.h> header file. */
+/* #undef HAVE_SDL_SDL_H */
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the `strdup' function. */
+#define HAVE_STRDUP 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the <sys/dir.h> header file, and it defines `DIR'.
+   */
+/* #undef HAVE_SYS_DIR_H */
+
+/* Define to 1 if you have the <sys/fcntl.h> header file. */
+#define HAVE_SYS_FCNTL_H 1
+
+/* Define to 1 if you have the <sys/mkdev.h> header file. */
+/* #undef HAVE_SYS_MKDEV_H */
+
+/* Define to 1 if you have the <sys/ndir.h> header file, and it defines `DIR'.
+   */
+/* #undef HAVE_SYS_NDIR_H */
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/sysmacros.h> header file. */
+#define HAVE_SYS_SYSMACROS_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <termios.h> header file. */
+#define HAVE_TERMIOS_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to 1 if you have the <usb.h> header file. */
+/* #undef HAVE_USB_H */
+
+/* Define to 1 if you have the `vasprintf' function. */
+#define HAVE_VASPRINTF 1
+
+/* Define to 1 if `major', `minor', and `makedev' are declared in <mkdev.h>.
+   */
+/* #undef MAJOR_IN_MKDEV */
+
+/* Define to 1 if `major', `minor', and `makedev' are declared in
+   <sysmacros.h>. */
+/* #undef MAJOR_IN_SYSMACROS */
+
+/* Define to 1 if you enable memory manager debugging. */
+/* #undef MM_DEBUG */
+
+/* Define to 1 if GCC generates calls to __register_frame_info() */
+/* #undef NEED_REGISTER_FRAME_INFO */
+
+/* Name of package */
+#define PACKAGE "burg"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "bean123ch@gmail.com"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "BURG"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "BURG 1.98"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "burg"
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "1.98"
+
+/* The size of `long', as computed by sizeof. */
+#define SIZEOF_LONG 8
+
+/* The size of `void *', as computed by sizeof. */
+#define SIZEOF_VOID_P 8
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Version number of package */
+#define VERSION "1.98"
+
+/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
+   significant byte first (like Motorola and SPARC, unlike Intel and VAX). */
+#if defined __BIG_ENDIAN__
+# define WORDS_BIGENDIAN 1
+#elif ! defined __LITTLE_ENDIAN__
+/* # undef WORDS_BIGENDIAN */
+#endif
+
+/* Define to 1 if `lex' declares `yytext' as a `char *' by default, not a
+   `char[]'. */
+#define YYTEXT_POINTER 1
+
+/* Number of bits in a file offset, on hosts where this is settable. */
+/* #undef _FILE_OFFSET_BITS */
+
+/* Define for large files, on AIX-style hosts. */
+/* #undef _LARGE_FILES */
+
+/* Define to 1 if on MINIX. */
+/* #undef _MINIX */
+
+/* Define to 2 if the system does not provide POSIX.1 features except with
+   this defined. */
+/* #undef _POSIX_1_SOURCE */
+
+/* Define to 1 if you need to in order for `stat' and other things to work. */
+/* #undef _POSIX_SOURCE */
+
+/* Enable extensions on AIX 3, Interix.  */
+#ifndef _ALL_SOURCE
+# define _ALL_SOURCE 1
+#endif
+/* Enable GNU extensions on systems that have them.  */
+#ifndef _GNU_SOURCE
+# define _GNU_SOURCE 1
+#endif
+/* Enable threading extensions on Solaris.  */
+#ifndef _POSIX_PTHREAD_SEMANTICS
+# define _POSIX_PTHREAD_SEMANTICS 1
+#endif
+/* Enable extensions on HP NonStop.  */
+#ifndef _TANDEM_SOURCE
+# define _TANDEM_SOURCE 1
+#endif
+/* Enable general extensions on Solaris.  */
+#ifndef __EXTENSIONS__
+# define __EXTENSIONS__ 1
+#endif
+
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/grub_err.c xen-4.1.2-b/tools/ioemu-qemu-xen/grub_err.c
--- xen-4.1.2-a/tools/ioemu-qemu-xen/grub_err.c	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/grub_err.c	2012-12-28 16:02:41.007734164 +0800
@@ -0,0 +1,186 @@
+/* err.c - error handling routines */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2002,2005,2007,2008  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "grub_err.h"
+#include "misc.h"
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define GRUB_MAX_ERRMSG		256
+#define GRUB_ERROR_STACK_SIZE	10
+
+grub_err_t grub_errno;
+char grub_errmsg[GRUB_MAX_ERRMSG];
+
+static struct
+{
+  grub_err_t errno;
+  char errmsg[GRUB_MAX_ERRMSG];
+} grub_error_stack_items[GRUB_ERROR_STACK_SIZE];
+
+static int grub_error_stack_pos;
+static int grub_error_stack_assert;
+
+
+
+static int
+grub_vsnprintf (char *str, grub_size_t n, const char *fmt, va_list ap)
+{
+  grub_size_t ret;
+
+  if (!n)
+    return 0;
+
+  
+  ret = vsnprintf(str, n, fmt, ap);
+  printf("%s\n", str);
+  return ret < n ? ret : n;
+}
+
+
+
+static int
+grub_vprintf (const char *fmt, va_list args)
+{
+  int ret;
+
+  ret = grub_vsnprintf (grub_errmsg, sizeof (grub_errmsg), fmt, args);
+
+  return ret;
+}
+
+int
+grub_err_printf (const char *fmt, ...)
+{
+  va_list ap;
+  int ret;
+
+  va_start (ap, fmt);
+  ret = grub_vprintf (fmt, ap);
+  va_end (ap);
+
+  return ret;
+}
+
+
+grub_err_t
+grub_error (grub_err_t n, const char *fmt, ...)
+{
+  va_list ap;
+
+  grub_errno = n;
+  va_start (ap, fmt);
+  grub_vsnprintf (grub_errmsg, sizeof (grub_errmsg), fmt, ap);
+  va_end (ap);
+  
+  return n;
+}
+
+void
+grub_fatal (const char *fmt, ...)
+{
+  va_list ap;
+
+  va_start (ap, fmt);
+  grub_vprintf (_(fmt), ap);
+  va_end (ap);
+
+  exit(1);
+}
+
+void
+grub_error_push (void)
+{
+  /* Only add items to stack, if there is enough room.  */
+  if (grub_error_stack_pos < GRUB_ERROR_STACK_SIZE)
+    {
+      /* Copy active error message to stack.  */
+      grub_error_stack_items[grub_error_stack_pos].errno = grub_errno;
+      grub_memcpy (grub_error_stack_items[grub_error_stack_pos].errmsg,
+                   grub_errmsg,
+                   sizeof (grub_errmsg));
+
+      /* Advance to next error stack position.  */
+      grub_error_stack_pos++;
+    }
+  else
+    {
+      /* There is no room for new error message. Discard new error message
+         and mark error stack assertion flag.  */
+      grub_error_stack_assert = 1;
+    }
+
+  /* Allow further operation of other components by resetting
+     active errno to GRUB_ERR_NONE.  */
+  grub_errno = GRUB_ERR_NONE;
+}
+
+int
+grub_error_pop (void)
+{
+  if (grub_error_stack_pos > 0)
+    {
+      /* Pop error message from error stack to current active error.  */
+      grub_error_stack_pos--;
+
+      grub_errno = grub_error_stack_items[grub_error_stack_pos].errno;
+      grub_memcpy (grub_errmsg,
+                   grub_error_stack_items[grub_error_stack_pos].errmsg,
+                   sizeof (grub_errmsg));
+
+      return 1;
+    }
+  else
+    {
+      /* There is no more items on error stack, reset to no error state.  */
+      grub_errno = GRUB_ERR_NONE;
+
+      return 0;
+    }
+}
+
+void
+grub_print_error (void)
+{
+  /* Print error messages in reverse order. First print active error message
+     and then empty error stack.  */
+  do
+    {
+      if (grub_errno != GRUB_ERR_NONE)
+        grub_err_printf ("error: %s.\n", grub_errmsg);
+    }
+  while (grub_error_pop ());
+
+  /* If there was an assert while using error stack, report about it.  */
+  if (grub_error_stack_assert)
+    {
+      grub_err_printf ("assert: error stack overflow detected!\n");
+      grub_error_stack_assert = 0;
+    }
+}
+
+
+int test_grub_err()
+{
+  grub_error(222, "test %s\n", "grub_error");
+  grub_err_printf("test %s\n", "grub_err_printf");
+  grub_fatal("test %s\n", "grub_fatal");
+}
+
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/grub_err.h xen-4.1.2-b/tools/ioemu-qemu-xen/grub_err.h
--- xen-4.1.2-a/tools/ioemu-qemu-xen/grub_err.h	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/grub_err.h	2012-12-28 16:02:41.007734164 +0800
@@ -0,0 +1,81 @@
+/* err.h - error numbers and prototypes */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2002,2005,2007,2008 Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GRUB_ERR_HEADER
+#define GRUB_ERR_HEADER	1
+
+
+typedef enum
+  {
+    GRUB_ERR_NONE = 0,
+    GRUB_ERR_TEST_FAILURE,
+    GRUB_ERR_BAD_MODULE,
+    GRUB_ERR_OUT_OF_MEMORY,
+    GRUB_ERR_BAD_FILE_TYPE,
+    GRUB_ERR_FILE_NOT_FOUND,
+    GRUB_ERR_FILE_READ_ERROR,
+    GRUB_ERR_BAD_FILENAME,
+    GRUB_ERR_UNKNOWN_FS,
+    GRUB_ERR_BAD_FS,
+    GRUB_ERR_BAD_NUMBER,
+    GRUB_ERR_OUT_OF_RANGE,
+    GRUB_ERR_UNKNOWN_DEVICE,
+    GRUB_ERR_BAD_DEVICE,
+    GRUB_ERR_READ_ERROR,
+    GRUB_ERR_WRITE_ERROR,
+    GRUB_ERR_UNKNOWN_COMMAND,
+    GRUB_ERR_INVALID_COMMAND,
+    GRUB_ERR_BAD_ARGUMENT,
+    GRUB_ERR_BAD_PART_TABLE,
+    GRUB_ERR_UNKNOWN_OS,
+    GRUB_ERR_BAD_OS,
+    GRUB_ERR_NO_KERNEL,
+    GRUB_ERR_BAD_FONT,
+    GRUB_ERR_NOT_IMPLEMENTED_YET,
+    GRUB_ERR_SYMLINK_LOOP,
+    GRUB_ERR_BAD_GZIP_DATA,
+    GRUB_ERR_MENU,
+    GRUB_ERR_TIMEOUT,
+    GRUB_ERR_IO,
+    GRUB_ERR_ACCESS_DENIED,
+    GRUB_ERR_MENU_ESCAPE,
+    GRUB_ERR_NOT_FOUND,
+    GRUB_ERR_UNKNOWN
+
+  }
+grub_err_t;
+
+
+#ifndef _
+# define _(String) String
+#endif
+
+extern grub_err_t grub_errno;
+extern char grub_errmsg[];
+
+grub_err_t grub_error (grub_err_t n, const char *fmt, ...);
+void grub_fatal (const char *fmt, ...) __attribute__((noreturn));
+void grub_error_push (void);
+int grub_error_pop (void);
+void grub_print_error (void);
+int grub_err_printf (const char *fmt, ...)
+     __attribute__ ((format (printf, 1, 2)));
+int test_grub_err(void);
+
+#endif /* ! GRUB_ERR_HEADER */
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/grub-fat/config.h xen-4.1.2-b/tools/ioemu-qemu-xen/grub-fat/config.h
--- xen-4.1.2-a/tools/ioemu-qemu-xen/grub-fat/config.h	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/grub-fat/config.h	2012-12-28 16:02:41.008640838 +0800
@@ -0,0 +1,251 @@
+/* config.h.  Generated from config.h.in by configure.  */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define it if GAS requires that absolute indirect calls/jumps are not
+   prefixed with an asterisk */
+/* #undef ABSOLUTE_WITHOUT_ASTERISK */
+
+/* Define it to \"addr32\" or \"addr32;\" to make GAS happy */
+#define ADDR32 addr32
+
+/* Define it to \"data32\" or \"data32;\" to make GAS happy */
+#define DATA32 data32
+
+/* Define to 1 if translation of program messages to the user's native
+   language is requested. */
+#define ENABLE_NLS 1
+
+/* Define if C symbols get an underscore after compilation */
+/* #undef HAVE_ASM_USCORE */
+
+/* Define to 1 if you have the `asprintf' function. */
+#define HAVE_ASPRINTF 1
+
+/* Define to 1 if you have the MacOS X function CFLocaleCopyCurrent in the
+   CoreFoundation framework. */
+/* #undef HAVE_CFLOCALECOPYCURRENT */
+
+/* Define to 1 if you have the MacOS X function CFPreferencesCopyAppValue in
+   the CoreFoundation framework. */
+/* #undef HAVE_CFPREFERENCESCOPYAPPVALUE */
+
+/* Define to 1 if you have the <curses.h> header file. */
+/* #undef HAVE_CURSES_H */
+
+/* Define if the GNU dcgettext() function is already present or preinstalled.
+   */
+#define HAVE_DCGETTEXT 1
+
+/* Define to 1 if you have the <dirent.h> header file, and it defines `DIR'.
+   */
+#define HAVE_DIRENT_H 1
+
+/* Define to 1 if you have the <ft2build.h> header file. */
+#define HAVE_FT2BUILD_H 1
+
+/* Define to 1 if you have the `getgid' function. */
+#define HAVE_GETGID 1
+
+/* Define if getrawpartition() in -lutil can be used */
+/* #undef HAVE_GETRAWPARTITION */
+
+/* Define if the GNU gettext() function is already present or preinstalled. */
+#define HAVE_GETTEXT 1
+
+/* Define to 1 if you have the `getuid' function. */
+#define HAVE_GETUID 1
+
+/* Define if you have the iconv() function and it works. */
+/* #undef HAVE_ICONV */
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the <limits.h> header file. */
+#define HAVE_LIMITS_H 1
+
+/* Define to 1 if you have the `lstat' function. */
+#define HAVE_LSTAT 1
+
+/* Define to 1 if you have the <malloc.h> header file. */
+#define HAVE_MALLOC_H 1
+
+/* Define to 1 if you have the `memalign' function. */
+#define HAVE_MEMALIGN 1
+
+/* Define to 1 if you have the `memmove' function. */
+#define HAVE_MEMMOVE 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the <ncurses/curses.h> header file. */
+/* #undef HAVE_NCURSES_CURSES_H */
+
+/* Define to 1 if you have the <ncurses.h> header file. */
+/* #undef HAVE_NCURSES_H */
+
+/* Define to 1 if you have the <ndir.h> header file, and it defines `DIR'. */
+/* #undef HAVE_NDIR_H */
+
+/* Define if opendisk() in -lutil can be used */
+/* #undef HAVE_OPENDISK */
+
+/* Define to 1 if you have the <pci/pci.h> header file. */
+/* #undef HAVE_PCI_PCI_H */
+
+/* Define to 1 if you have the `posix_memalign' function. */
+#define HAVE_POSIX_MEMALIGN 1
+
+/* Define if returns_twice attribute is supported */
+/* #undef HAVE_RETURNS_TWICE */
+
+/* Define to 1 if you have the `sbrk' function. */
+#define HAVE_SBRK 1
+
+/* Define to 1 if you have the <SDL/SDL.h> header file. */
+/* #undef HAVE_SDL_SDL_H */
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the `strdup' function. */
+#define HAVE_STRDUP 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the <sys/dir.h> header file, and it defines `DIR'.
+   */
+/* #undef HAVE_SYS_DIR_H */
+
+/* Define to 1 if you have the <sys/fcntl.h> header file. */
+#define HAVE_SYS_FCNTL_H 1
+
+/* Define to 1 if you have the <sys/mkdev.h> header file. */
+/* #undef HAVE_SYS_MKDEV_H */
+
+/* Define to 1 if you have the <sys/ndir.h> header file, and it defines `DIR'.
+   */
+/* #undef HAVE_SYS_NDIR_H */
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/sysmacros.h> header file. */
+#define HAVE_SYS_SYSMACROS_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <termios.h> header file. */
+#define HAVE_TERMIOS_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to 1 if you have the <usb.h> header file. */
+/* #undef HAVE_USB_H */
+
+/* Define to 1 if you have the `vasprintf' function. */
+#define HAVE_VASPRINTF 1
+
+/* Define to 1 if `major', `minor', and `makedev' are declared in <mkdev.h>.
+   */
+/* #undef MAJOR_IN_MKDEV */
+
+/* Define to 1 if `major', `minor', and `makedev' are declared in
+   <sysmacros.h>. */
+/* #undef MAJOR_IN_SYSMACROS */
+
+/* Define to 1 if you enable memory manager debugging. */
+/* #undef MM_DEBUG */
+
+/* Define to 1 if GCC generates calls to __register_frame_info() */
+/* #undef NEED_REGISTER_FRAME_INFO */
+
+/* Name of package */
+#define PACKAGE "burg"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "bean123ch@gmail.com"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "BURG"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "BURG 1.98"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "burg"
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "1.98"
+
+/* The size of `long', as computed by sizeof. */
+#define SIZEOF_LONG 8
+
+/* The size of `void *', as computed by sizeof. */
+#define SIZEOF_VOID_P 8
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Version number of package */
+#define VERSION "1.98"
+
+/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
+   significant byte first (like Motorola and SPARC, unlike Intel and VAX). */
+#if defined __BIG_ENDIAN__
+# define WORDS_BIGENDIAN 1
+#elif ! defined __LITTLE_ENDIAN__
+/* # undef WORDS_BIGENDIAN */
+#endif
+
+/* Define to 1 if `lex' declares `yytext' as a `char *' by default, not a
+   `char[]'. */
+#define YYTEXT_POINTER 1
+
+/* Number of bits in a file offset, on hosts where this is settable. */
+/* #undef _FILE_OFFSET_BITS */
+
+/* Define for large files, on AIX-style hosts. */
+/* #undef _LARGE_FILES */
+
+/* Define to 1 if on MINIX. */
+/* #undef _MINIX */
+
+/* Define to 2 if the system does not provide POSIX.1 features except with
+   this defined. */
+/* #undef _POSIX_1_SOURCE */
+
+/* Define to 1 if you need to in order for `stat' and other things to work. */
+/* #undef _POSIX_SOURCE */
+
+/* Enable extensions on AIX 3, Interix.  */
+#ifndef _ALL_SOURCE
+# define _ALL_SOURCE 1
+#endif
+/* Enable GNU extensions on systems that have them.  */
+#ifndef _GNU_SOURCE
+# define _GNU_SOURCE 1
+#endif
+/* Enable threading extensions on Solaris.  */
+#ifndef _POSIX_PTHREAD_SEMANTICS
+# define _POSIX_PTHREAD_SEMANTICS 1
+#endif
+/* Enable extensions on HP NonStop.  */
+#ifndef _TANDEM_SOURCE
+# define _TANDEM_SOURCE 1
+#endif
+/* Enable general extensions on Solaris.  */
+#ifndef __EXTENSIONS__
+# define __EXTENSIONS__ 1
+#endif
+
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/grub-fat/fat.c xen-4.1.2-b/tools/ioemu-qemu-xen/grub-fat/fat.c
--- xen-4.1.2-a/tools/ioemu-qemu-xen/grub-fat/fat.c	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/grub-fat/fat.c	2012-12-28 16:02:41.008640838 +0800
@@ -0,0 +1,711 @@
+/* fat.c - FAT filesystem */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2000,2001,2002,2003,2004,2005,2007,2008,2009  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "misc.h"
+#include "fat.h"
+
+
+static int
+fat_log2 (unsigned x)
+{
+  int i;
+
+  if (x == 0)
+    return -1;
+
+  for (i = 0; (x & 1) == 0; i++)
+    x >>= 1;
+
+  if (x != 1)
+    return -1;
+
+  return i;
+}
+
+
+struct grub_fat_data *
+grub_fat_mount (BlockDriverState *bs, uint32_t part_off_sector)
+{
+  struct grub_fat_bpb bpb;
+  struct grub_fat_data *data = 0;
+  grub_uint32_t first_fat, magic;
+  int64_t off_bytes = (int64_t)part_off_sector << GRUB_DISK_SECTOR_BITS;
+
+  if (! bs)
+    goto fail;
+
+  data = (struct grub_fat_data *) malloc (sizeof (*data));
+  if (! data)
+    goto fail;
+
+  /* Read the BPB.  */
+  if (bdrv_pread(bs, off_bytes, &bpb, sizeof(bpb)) != sizeof(bpb))
+    {
+      printf("bdrv_pread fail....\n");
+      goto fail;
+    }
+    
+  if (grub_strncmp((const char *) bpb.version_specific.fat12_or_fat16.fstype, "FAT12", 5)
+      && grub_strncmp((const char *) bpb.version_specific.fat12_or_fat16.fstype, "FAT16", 5)
+      && grub_strncmp((const char *) bpb.version_specific.fat32.fstype, "FAT32", 5))
+    {
+      
+      printf("fail here-->grub_strncmp......line[%u]\n", __LINE__);
+      goto fail;
+    }
+
+  /* Get the sizes of logical sectors and clusters.  */
+  data->logical_sector_bits =
+    fat_log2 (grub_le_to_cpu16 (bpb.bytes_per_sector));
+  printf("bpb.bytes_per_sector=0x%x, le_to_cpu16=0x%x\n",
+	 bpb.bytes_per_sector, grub_le_to_cpu16 (bpb.bytes_per_sector));
+  
+
+  if (data->logical_sector_bits < GRUB_DISK_SECTOR_BITS)
+  {
+    printf("fail here-->logical_sector_bits......line[%u]\n", __LINE__); 
+    goto fail;
+  }
+  data->logical_sector_bits -= GRUB_DISK_SECTOR_BITS;
+
+  printf("bpb.sectors_per_cluster=%u\n", bpb.sectors_per_cluster);
+  data->cluster_bits = fat_log2 (bpb.sectors_per_cluster);
+  if (data->cluster_bits < 0)
+    {
+      printf("fail here-->cluster_bits......line[%u]\n", __LINE__); 
+      goto fail;
+    }
+  data->cluster_bits += data->logical_sector_bits;
+
+  /* Get information about FATs.  */
+  printf("bpb.num_reserved_sectors=%u, le_to_cpu16=%u\n",
+	 bpb.num_reserved_sectors, grub_le_to_cpu16 (bpb.num_reserved_sectors));
+  data->fat_sector = part_off_sector + (grub_le_to_cpu16 (bpb.num_reserved_sectors)
+		      << data->logical_sector_bits);
+  printf("data->fat_sector=%u\n", data->fat_sector);
+  if (data->fat_sector == 0)
+    {
+      printf("fail here-->fat_sector......line[%u]\n", __LINE__); 
+      goto fail;
+    }
+  data->sectors_per_fat = ((bpb.sectors_per_fat_16
+			    ? grub_le_to_cpu16 (bpb.sectors_per_fat_16)
+			    : grub_le_to_cpu32 (bpb.version_specific.fat32.sectors_per_fat_32))
+			   << data->logical_sector_bits);
+  printf("bpb.version_specific.fat32.sectors_per_fat_32=%u\n"
+	 "grub_le_to_cpu32 (bpb.version_specific.fat32.sectors_per_fat_32)=%u\n",
+	 bpb.version_specific.fat32.sectors_per_fat_32,
+	 grub_le_to_cpu32 (bpb.version_specific.fat32.sectors_per_fat_32));
+  if (data->sectors_per_fat == 0)
+    goto fail;
+
+  /* Get the number of sectors in this volume.  */
+  data->num_sectors = ((bpb.num_total_sectors_16
+			? grub_le_to_cpu16 (bpb.num_total_sectors_16)
+			: grub_le_to_cpu32 (bpb.num_total_sectors_32))
+		       << data->logical_sector_bits);
+  if (data->num_sectors == 0)
+    {
+      printf("fail here-->num_sectors......line[%u]\n", __LINE__); 
+      goto fail;
+    }
+  /* Get information about the root directory.  */
+  if (bpb.num_fats == 0)
+    {
+      printf("fail here-->num_fats......line[%u]\n", __LINE__); 
+      goto fail;
+    }
+  data->root_sector = data->fat_sector + bpb.num_fats * data->sectors_per_fat;
+  data->num_root_sectors
+    = ((((grub_uint32_t) grub_le_to_cpu16 (bpb.num_root_entries)
+	 * GRUB_FAT_DIR_ENTRY_SIZE
+	 + grub_le_to_cpu16 (bpb.bytes_per_sector) - 1)
+	>> (data->logical_sector_bits + GRUB_DISK_SECTOR_BITS))
+       << (data->logical_sector_bits));
+
+  data->cluster_sector = data->root_sector + data->num_root_sectors;
+  data->num_clusters = (((data->num_sectors - data->cluster_sector)
+			 >> (data->cluster_bits + data->logical_sector_bits))
+			+ 2);
+
+  if (data->num_clusters <= 2)
+    {
+      printf("fail here-->num_clusters......line[%u]\n", __LINE__); 
+      goto fail;
+    }
+  if (! bpb.sectors_per_fat_16)
+    {
+      /* FAT32.  */
+      grub_uint16_t flags = grub_le_to_cpu16 (bpb.version_specific.fat32.extended_flags);
+
+      data->root_cluster = grub_le_to_cpu32 (bpb.version_specific.fat32.root_cluster);
+      data->fat_size = 32;
+      data->cluster_eof_mark = 0x0ffffff8;
+
+      if (flags & 0x80)
+	{
+	  /* Get an active FAT.  */
+	  unsigned active_fat = flags & 0xf;
+
+	  if (active_fat > bpb.num_fats)
+	    goto fail;
+
+	  data->fat_sector += active_fat * data->sectors_per_fat;
+	}
+
+      if (bpb.num_root_entries != 0 || bpb.version_specific.fat32.fs_version != 0)
+	goto fail;
+    }
+  else
+    {
+      /* FAT12 or FAT16.  */
+      data->root_cluster = ~0U;
+
+      if (data->num_clusters <= 4085 + 2)
+	{
+	  /* FAT12.  */
+	  data->fat_size = 12;
+	  data->cluster_eof_mark = 0x0ff8;
+	}
+      else
+	{
+	  /* FAT16.  */
+	  data->fat_size = 16;
+	  data->cluster_eof_mark = 0xfff8;
+	}
+    }
+
+  /* More sanity checks.  */
+  if (data->num_sectors <= data->fat_sector)
+    goto fail;
+
+  
+  printf("data->fat_sector=%u, data->sectors_per_fat=%u\n",
+	 data->fat_sector, data->sectors_per_fat);
+  if (bdrv_pread(bs,
+		 data->fat_sector << GRUB_DISK_SECTOR_BITS,
+		 &first_fat,
+		 sizeof (first_fat)) != sizeof(first_fat))
+    {
+      printf("fail here-->bdrv_pread......line[%u]\n", __LINE__); 
+      goto fail;
+    }
+
+  first_fat = grub_le_to_cpu32 (first_fat);
+
+  if (data->fat_size == 32)
+    {
+      first_fat &= 0x0fffffff;
+      magic = 0x0fffff00;
+    }
+  else if (data->fat_size == 16)
+    {
+      first_fat &= 0x0000ffff;
+      magic = 0xff00;
+    }
+  else
+    {
+      first_fat &= 0x00000fff;
+      magic = 0x0f00;
+    }
+
+  /* Serial number.  */
+  if (bpb.sectors_per_fat_16)
+    data->uuid = grub_le_to_cpu32 (bpb.version_specific.fat12_or_fat16.num_serial);
+  else
+    data->uuid = grub_le_to_cpu32 (bpb.version_specific.fat32.num_serial);
+
+  /* Ignore the 3rd bit, because some BIOSes assigns 0xF0 to the media
+     descriptor, even if it is a so-called superfloppy (e.g. an USB key).
+     The check may be too strict for this kind of stupid BIOSes, as
+     they overwrite the media descriptor.  */
+  if ((first_fat | 0x8) != (magic | bpb.media | 0x8))
+    {
+      printf("fail here-->first_fat=0x%x, magic=0x%x......line[%u]\n",
+	     first_fat, magic, __LINE__); 
+      goto fail;
+    }
+  /* Start from the root directory.  */
+  data->file_cluster = data->root_cluster;
+  data->cur_cluster_num = ~0U;
+  data->attr = GRUB_FAT_ATTR_DIRECTORY;
+  printf("data->file_cluster=%u \ndata->cur_cluster_num=%u \ndata->attr=0x%x\n"
+	 "data->logical_sector_bits=%u\n"
+	 "data->cluster_bits=%u\n",
+	 data->file_cluster, data->cur_cluster_num, data->attr,
+	 data->logical_sector_bits, data->cluster_bits);
+  return data;
+
+ fail:
+
+  free (data);
+  errx ("not a FAT filesystem...\n");
+  return 0;
+}
+
+
+
+//´ÓÎÄ¼þµÄÖ¸¶¨Æ«ÒÆoffset×Ö½Ú´¦¶ÁÈ¡len×Ö½ÚµÄÊý¾Ýµ½buf
+//ÎÄ¼þÓÉdata->file_clusterÖ¸¶¨
+//data->file_clusterÖ¸¶¨ÁËÎÄ¼þµÄÆðÊ¼´ØºÅ
+//Ä¬ÈÏdata->file_cluster=2£¬´ú±í¸ùÄ¿Â¼
+static grub_ssize_t
+grub_fat_read_data (BlockDriverState *bs, struct grub_fat_data *data,
+		    void (*read_hook) (grub_disk_addr_t sector,
+				       unsigned offset, unsigned length,
+				       void *closure),
+		    void *closure,
+		    grub_off_t offset, grub_size_t len, char *buf)
+{
+  grub_size_t size;
+  grub_uint32_t logical_cluster;
+  unsigned logical_cluster_bits;
+  grub_ssize_t ret = 0;
+  unsigned long sector;
+  uint64_t off_bytes = 0; 
+  /* This is a special case. FAT12 and FAT16 doesn't have the root directory
+     in clusters.  */
+  if (data->file_cluster == ~0U)
+    {
+      size = (data->num_root_sectors << GRUB_DISK_SECTOR_BITS) - offset;
+      if (size > len)
+	size = len;
+
+      off_bytes = ((uint64_t)data->root_sector << GRUB_DISK_SECTOR_BITS) + offset;
+      if(bdrv_read(bs, off_bytes, buf, size ) != size) 
+	return -1;
+
+      return size;
+    }
+
+  /* Calculate the logical cluster number and offset.  */
+  logical_cluster_bits = (data->cluster_bits
+			  + data->logical_sector_bits
+			  + GRUB_DISK_SECTOR_BITS);
+  logical_cluster = offset >> logical_cluster_bits;    //which cluster to read 
+  offset &= (1 << logical_cluster_bits) - 1;           //mod
+
+  if (logical_cluster < data->cur_cluster_num)   //
+    {
+      data->cur_cluster_num = 0;
+      data->cur_cluster = data->file_cluster; // µÚ2¸öfat±íÏî¿ªÊ¼¼ÇÂ¼Ä¿Â¼ºÍÎÄ¼þ
+    }
+
+  while (len)
+    {
+      while (logical_cluster > data->cur_cluster_num)
+	{
+	  /* Find next cluster.  */
+	  grub_uint32_t next_cluster;
+	  unsigned long fat_offset;
+
+	  switch (data->fat_size)
+	    {
+	    case 32:
+	      fat_offset = data->cur_cluster << 2;
+	      break;
+	    case 16:
+	      fat_offset = data->cur_cluster << 1;
+	      break;
+	    default:
+	      /* case 12: */
+	      fat_offset = data->cur_cluster + (data->cur_cluster >> 1);
+	      break;
+	    }
+
+	  /* Read the FAT.  */
+	  int len = (data->fat_size + 7) >> 3;
+	  uint64_t off_bytes =  ((uint64_t)data->fat_sector << GRUB_DISK_SECTOR_BITS) + fat_offset; 
+	  if (bdrv_pread (bs, off_bytes, 
+			  (char *) &next_cluster, 
+			  len) != len)   //´Ófat±í¶ÁÈ¡´ØºÅ
+	    return -1;
+
+	  next_cluster = grub_le_to_cpu32 (next_cluster);
+	  switch (data->fat_size)
+	    {
+	    case 16:
+	      next_cluster &= 0xFFFF;
+	      break;
+	    case 12:
+	      if (data->cur_cluster & 1)
+		next_cluster >>= 4;
+
+	      next_cluster &= 0x0FFF;
+	      break;
+	    }
+
+	  printf ("fat_size=%d, next_cluster=%u\n",
+			data->fat_size, next_cluster);
+
+	  /* Check the end.  */
+	  if (next_cluster >= data->cluster_eof_mark)
+	    return ret;
+
+	  if (next_cluster < 2 || next_cluster >= data->num_clusters)
+	    {
+	      printf("invalid cluster %u................\n",
+			  next_cluster);
+	      return -1;
+	    }
+
+	  data->cur_cluster = next_cluster;
+	  data->cur_cluster_num++;
+	}
+
+      /* Read the data here.  */
+      //Âß¼­´ØËù¶ÔÓ¦µÄ¾ø¶ÔÉÈÇø
+      sector = (data->cluster_sector
+		+ ((data->cur_cluster - 2)
+		   << (data->cluster_bits + data->logical_sector_bits))); 
+      //¾ø¶ÔÉÈÇøÖÐÈ¥µôÆ«ÒÆºóµÄ×Ö½ÚÊý
+      size = (1 << logical_cluster_bits) - offset;
+      if (size > len)
+	size = len;
+
+      //disk->read_hook = read_hook;
+      //disk->closure = closure;
+      int64_t off_bytes = ((uint64_t)sector << GRUB_DISK_SECTOR_BITS) + offset;
+      //disk->read_hook = 0;
+      if (bdrv_pread (bs, off_bytes, buf, size) != size)
+	return -1;
+
+      len -= size;
+      buf += size;
+      ret += size;
+      logical_cluster++;
+      offset = 0;  //ÒÔºó¶ÁµÄ¶¼ÊÇÍêÕûÉÈÇø
+    }
+
+  return ret;
+}
+
+//±éÀúÓÉdata->file_clusterÖ¸¶¨µÄÄ¿Â¼
+int
+grub_fat_iterate_dir (BlockDriverState *bs, struct grub_fat_data *data)
+{
+  struct grub_fat_dir_entry dir;
+  char *filename, *filep = 0;
+  grub_uint16_t *unibuf;
+  int slot = -1, slots = -1;
+  int checksum = -1;
+  grub_ssize_t offset = -sizeof(dir);
+
+  if (! (data->attr & GRUB_FAT_ATTR_DIRECTORY))
+    return printf("not a directory......\n");
+
+  /* Allocate space enough to hold a long name.  */
+  filename = (char*)malloc (0x40 * 13 * 4 + 1);
+  unibuf = (grub_uint16_t *) malloc (0x40 * 13 * 2);
+  if (! filename || ! unibuf)
+    {
+      free (filename);
+      free (unibuf);
+      return -1;
+    }
+
+
+  int count = 0;
+  while (1)
+    {
+      unsigned i;
+
+      /* Adjust the offset.  */
+      offset += sizeof (dir);
+      printf("[%d]offset=%u\n"
+	     "data->cur_cluster_num=%u,data->cur_cluster=%u\n", 
+	     count+1, offset, 
+	     data->cur_cluster_num, data->cur_cluster);
+      /* Read a directory entry.  */
+      //0x0±íÊ¾¿ÕÄ¿Â¼
+      if ((grub_fat_read_data (bs, data, 0, 0,
+			       offset, sizeof (dir), (char *) &dir)
+	   != sizeof (dir) || dir.name[0] == 0))
+	{
+	  printf("break...dir.name[0]==%d\n", dir.name[0]);
+	  break;
+	}
+      /* Handle long name entries.  */
+      if (dir.attr == GRUB_FAT_ATTR_LONG_NAME)
+	{
+	  printf("long name...\n");
+	  struct grub_fat_long_name_entry *long_name
+	    = (struct grub_fat_long_name_entry *) &dir;
+	  grub_uint8_t id = long_name->id;
+
+	  if (id & 0x40)  //the last item
+	    {
+	      id &= 0x3f;   //index or ordinal number  1~31
+	      slots = slot = id;
+	      checksum = long_name->checksum;
+	      printf("the last ordinal num=%d!!!\n", id);
+	    }
+
+	  if (id != slot || slot == 0 || checksum != long_name->checksum)
+	    {
+	      printf("not valid ordinal number ,ignore...continue\n");
+	      checksum = -1;
+	      continue;
+	    }
+
+	  slot--;
+	  memcpy (unibuf + slot * 13, long_name->name1, 5 * 2);
+	  memcpy (unibuf + slot * 13 + 5, long_name->name2, 6 * 2);
+	  memcpy (unibuf + slot * 13 + 11, long_name->name3, 2 * 2);
+	  printf("memcpy...continue\n");
+	  continue;
+	}
+
+      
+      /* Check if this entry is valid.  */
+      //oxe5±íÊ¾ÒÑ¾­±»É¾³ý
+      if (dir.name[0] == 0xe5 || (dir.attr & ~GRUB_FAT_ATTR_VALID))
+	{
+	  printf("dir.name[0]=0x%x, dir.attr=0x%x not valid...continue\n", 
+		 dir.name[0], dir.attr);
+	  continue;
+	}
+
+      printf("checksum=%d, slot=%d\n", checksum, slot);
+      /* This is a workaround for Japanese.  */
+      if (dir.name[0] == 0x05)
+	dir.name[0] = 0xe5;
+
+      if (checksum != -1 && slot == 0)
+	{
+	  printf("checksuming\n");
+	  grub_uint8_t sum;
+
+	  for (sum = 0, i = 0; i < sizeof (dir.name); i++)
+	    sum = ((sum >> 1) | (sum << 7)) + dir.name[i];
+
+	  if (sum == checksum)
+	    {//³¤Ãû±íÏîºóÃæ½ô½Ó¶ÌÃû±íÏî£¬ÑéÖ¤³É¹¦ÔòÖ¤Ã÷ÕæÕýÊÇ³¤Ãû×Ö
+	      int u;
+
+	      for (u = 0; u < slots * 13; u++)
+		unibuf[u] = grub_le_to_cpu16 (unibuf[u]);
+
+	      *grub_utf16_to_utf8 ((grub_uint8_t *) filename, unibuf,
+				   slots * 13) = '\0';
+
+	      //if (hook (filename, &dir, closure))
+	        //break;
+
+	      checksum = -1;
+	      for (i = 0; i < sizeof (dir.name); i++)
+		printf("0x%x  ", dir.name[i]);
+	      char *gbname = (char*)malloc(256);
+	      u2g(filename, strlen(filename), gbname, 256);
+	      printf("\ndir.name=%s, filename=%s, dir.attr=0x%x,"
+		     "sum==checksum...continue\n",
+		     dir.name, gbname, dir.attr);
+	      free(gbname);
+	      count++;
+	      continue;
+	    }
+
+	  checksum = -1;
+	}
+
+      //ºóÃæµÄ´¦ÀíÕë¶Ô·ÇÕæÊµ³¤ÃûºÍÕæÊµ¶ÌÃû
+      /* Convert the 8.3 file name.  */
+      //È¥µô¶ÌÃûµÄ¿Õ¸ñ£¬È«¸ÄÎªÐ¡Ð´
+      filep = filename;
+      if (dir.attr & GRUB_FAT_ATTR_VOLUME_ID)
+	{
+	  printf("VOLUME\n");
+	  for (i = 0; i < sizeof (dir.name) && dir.name[i]
+		 && ! grub_isspace (dir.name[i]); i++)
+	    *filep++ = dir.name[i];
+	}
+      else
+	{
+	  for (i = 0; i < 8 && dir.name[i] && ! grub_isspace (dir.name[i]); i++)
+	    *filep++ = grub_tolower (dir.name[i]);
+
+	  *filep = '.';
+
+	  for (i = 8; i < 11 && dir.name[i] && ! grub_isspace (dir.name[i]); i++)
+	    *++filep = grub_tolower (dir.name[i]);
+
+	  if (*filep != '.')
+	    filep++;
+	}
+      *filep = '\0';
+
+      
+      for (i = 0; i < sizeof (dir.name); i++)
+	printf("0x%x  ", dir.name[i]);
+      printf("\ndir.name=%s, filename=¡¾%s¡¿, dir.attr=0x%x,"
+	     "...next while\n",
+	     dir.name, filename, dir.attr);
+      count++;
+      /*if(strcmp(filename, ".") && strcmp(filename, ".."))
+	{
+	  printf("{==============>\n");
+	  struct grub_fat_data *data2 = NULL;
+	  data2 = (struct grub_fat_data*)malloc(sizeof(*data));
+	  memcpy(data2, data, sizeof(*data));
+	  data2->attr = dir.attr;
+	  data2->file_size = grub_le_to_cpu32 (dir.file_size);
+	  data2->file_cluster = ((grub_le_to_cpu16 (dir.first_cluster_high) << 16)
+				 | grub_le_to_cpu16 (dir.first_cluster_low));
+	  data2->cur_cluster_num = ~0U;
+	  (grub_fat_iterate_dir(bs, data2) < 0) ? printf("error !!!!!!\n") : 0;
+	  free(data2);
+	  printf("<===================}\n");
+	}
+      */
+      //if (hook (filename, &dir, closure))
+        //break;
+    }
+
+  free (filename);
+  free (unibuf);
+
+  return 0;
+}
+
+
+/*
+struct grub_fat_find_dir_closure
+{
+  struct grub_fat_data *data;
+  int (*hook) (const char *filename,
+	       const struct grub_dirhook_info *info,
+	       void *closure);
+  void *closure;
+  char *dirname;
+  int call_hook;
+  int found;
+};
+
+
+static int
+grub_fat_find_dir_hook (const char *filename, struct grub_fat_dir_entry *dir,
+			void *closure)
+{
+  struct grub_fat_find_dir_closure *c = closure;
+  struct grub_dirhook_info info;
+  grub_memset (&info, 0, sizeof (info));
+
+  info.dir = !! (dir->attr & GRUB_FAT_ATTR_DIRECTORY);
+  info.case_insensitive = 1;
+
+  if (dir->attr & GRUB_FAT_ATTR_VOLUME_ID)
+    return 0;
+  if (*(c->dirname) == '\0' && (c->call_hook))
+    return c->hook (filename, &info, c->closure);
+
+  if (grub_strcasecmp (c->dirname, filename) == 0)
+    {
+      struct grub_fat_data *data = c->data;
+
+      c->found = 1;
+      data->attr = dir->attr;
+      data->file_size = grub_le_to_cpu32 (dir->file_size);
+      data->file_cluster = ((grub_le_to_cpu16 (dir->first_cluster_high) << 16)
+			       | grub_le_to_cpu16 (dir->first_cluster_low));
+      data->cur_cluster_num = ~0U;
+
+      if (c->call_hook)
+	c->hook (filename, &info, c->closure);
+
+      return 1;
+    }
+  return 0;
+}
+*/
+
+/* Find the underlying directory or file in PATH and return the
+   next path. If there is no next path or an error occurs, return NULL.
+   If HOOK is specified, call it with each file name.  */
+char *
+grub_fat_find_dir (BlockDriverState *bs, struct grub_fat_data *data,
+		   const char *path,
+		   int (*hook) (const char *filename,
+				const struct grub_dirhook_info *info,
+				void *closure),
+		   void *closure)
+{
+  char *dirname, *dirp;
+  //struct grub_fat_find_dir_closure c;
+
+  if (! (data->attr & GRUB_FAT_ATTR_DIRECTORY))
+    {
+      printf("not a directory.............\n");
+      return 0;
+    }
+
+  /* Extract a directory name.  */
+  while (*path == '/')
+    path++;
+
+  dirp = grub_strchr (path, '/');
+  if (dirp)
+    {
+      unsigned len = dirp - path;
+
+      dirname = (char*)malloc (len + 1);
+      if (! dirname)
+	return 0;
+
+      memcpy (dirname, path, len);
+      dirname[len] = '\0';
+    }
+  else
+    {
+    /* This is actually a file.  */
+      dirname = grub_strdup (path);
+    }
+  //c.data = data;
+  //c.hook = hook;
+  //c.closure = closure;
+  //c.dirname =dirname;
+  //c.found = 0;
+  //c.call_hook = (! dirp && hook);
+  if(grub_fat_iterate_dir (bs, data)<0)
+    {
+       printf("file not found..\n");
+       return 0;
+    }
+    
+  
+  free (dirname);
+
+  return dirp;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/grub-fat/fat.h xen-4.1.2-b/tools/ioemu-qemu-xen/grub-fat/fat.h
--- xen-4.1.2-a/tools/ioemu-qemu-xen/grub-fat/fat.h	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/grub-fat/fat.h	2012-12-28 16:02:41.009937738 +0800
@@ -0,0 +1,146 @@
+#ifndef FS_FAT_H
+#define FS_FAT_H
+
+
+#include "fs-types.h"
+#include "block_int.h"
+
+#define GRUB_DISK_SECTOR_BITS      9
+#define GRUB_FAT_DIR_ENTRY_SIZE	32
+
+#define GRUB_FAT_ATTR_READ_ONLY	0x01
+#define GRUB_FAT_ATTR_HIDDEN	0x02
+#define GRUB_FAT_ATTR_SYSTEM	0x04
+#define GRUB_FAT_ATTR_VOLUME_ID	0x08
+#define GRUB_FAT_ATTR_DIRECTORY	0x10
+#define GRUB_FAT_ATTR_ARCHIVE	0x20
+
+#define GRUB_FAT_MAXFILE	256
+
+#define GRUB_FAT_ATTR_LONG_NAME	(GRUB_FAT_ATTR_READ_ONLY \
+				 | GRUB_FAT_ATTR_HIDDEN \
+				 | GRUB_FAT_ATTR_SYSTEM \
+				 | GRUB_FAT_ATTR_VOLUME_ID)
+#define GRUB_FAT_ATTR_VALID	(GRUB_FAT_ATTR_READ_ONLY \
+				 | GRUB_FAT_ATTR_HIDDEN \
+				 | GRUB_FAT_ATTR_SYSTEM \
+				 | GRUB_FAT_ATTR_DIRECTORY \
+				 | GRUB_FAT_ATTR_ARCHIVE \
+				 | GRUB_FAT_ATTR_VOLUME_ID)
+
+struct grub_fat_bpb
+{
+  grub_uint8_t jmp_boot[3];
+  grub_uint8_t oem_name[8];
+  grub_uint16_t bytes_per_sector;
+  grub_uint8_t sectors_per_cluster;
+  grub_uint16_t num_reserved_sectors;
+  grub_uint8_t num_fats;
+  grub_uint16_t num_root_entries;
+  grub_uint16_t num_total_sectors_16;
+  grub_uint8_t media;
+  grub_uint16_t sectors_per_fat_16;
+  grub_uint16_t sectors_per_track;
+  grub_uint16_t num_heads;
+  grub_uint32_t num_hidden_sectors;
+  grub_uint32_t num_total_sectors_32;
+  union
+  {
+    struct
+    {
+      grub_uint8_t num_ph_drive;
+      grub_uint8_t reserved;
+      grub_uint8_t boot_sig;
+      grub_uint32_t num_serial;
+      grub_uint8_t label[11];
+      grub_uint8_t fstype[8];
+    } __attribute__ ((packed)) fat12_or_fat16;
+    struct
+    {
+      grub_uint32_t sectors_per_fat_32;
+      grub_uint16_t extended_flags;
+      grub_uint16_t fs_version;
+      grub_uint32_t root_cluster;
+      grub_uint16_t fs_info;
+      grub_uint16_t backup_boot_sector;
+      grub_uint8_t reserved[12];
+      grub_uint8_t num_ph_drive;
+      grub_uint8_t reserved1;
+      grub_uint8_t boot_sig;
+      grub_uint32_t num_serial;
+      grub_uint8_t label[11];
+      grub_uint8_t fstype[8];
+    } __attribute__ ((packed)) fat32;
+  } __attribute__ ((packed)) version_specific;
+} __attribute__ ((packed));
+
+struct grub_fat_dir_entry
+{
+  grub_uint8_t name[11];
+  grub_uint8_t attr;
+  grub_uint8_t nt_reserved;
+  grub_uint8_t c_time_tenth;
+  grub_uint16_t c_time;
+  grub_uint16_t c_date;
+  grub_uint16_t a_date;
+  grub_uint16_t first_cluster_high;
+  grub_uint16_t w_time;
+  grub_uint16_t w_date;
+  grub_uint16_t first_cluster_low;
+  grub_uint32_t file_size;
+} __attribute__ ((packed));
+
+struct grub_fat_long_name_entry
+{
+  grub_uint8_t id;
+  grub_uint16_t name1[5];
+  grub_uint8_t attr;
+  grub_uint8_t reserved;
+  grub_uint8_t checksum;
+  grub_uint16_t name2[6];
+  grub_uint16_t first_cluster;
+  grub_uint16_t name3[2];
+} __attribute__ ((packed));
+
+struct grub_fat_data
+{
+  int logical_sector_bits;
+  grub_uint32_t num_sectors;
+
+  grub_uint16_t fat_sector;
+  grub_uint32_t sectors_per_fat;
+  int fat_size;
+
+  grub_uint32_t root_cluster;
+  grub_uint32_t root_sector;
+  grub_uint32_t num_root_sectors;
+
+  int cluster_bits;
+  grub_uint32_t cluster_eof_mark;
+  grub_uint32_t cluster_sector;
+  grub_uint32_t num_clusters;
+
+  grub_uint8_t attr;
+  grub_ssize_t file_size;
+  grub_uint32_t file_cluster;
+  grub_uint32_t cur_cluster_num;
+  grub_uint32_t cur_cluster;
+
+  grub_uint32_t uuid;
+};
+
+
+
+
+
+
+struct grub_fat_data* grub_fat_mount (BlockDriverState *bs, uint32_t part_off_sector);
+int grub_fat_iterate_dir (BlockDriverState *bs, struct grub_fat_data *data);
+
+
+
+
+
+
+
+#endif
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/grub-fat/fs-types.h xen-4.1.2-b/tools/ioemu-qemu-xen/grub-fat/fs-types.h
--- xen-4.1.2-a/tools/ioemu-qemu-xen/grub-fat/fs-types.h	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/grub-fat/fs-types.h	2012-12-28 16:02:41.009937738 +0800
@@ -0,0 +1,228 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2002,2005,2006,2007,2008,2009  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GRUB_TYPES_HEADER
+#define GRUB_TYPES_HEADER	1
+
+#include <config.h>
+#include <x86_64/types.h>
+
+#ifdef GRUB_UTIL
+# define GRUB_CPU_SIZEOF_VOID_P	SIZEOF_VOID_P
+# define GRUB_CPU_SIZEOF_LONG	SIZEOF_LONG
+# ifdef WORDS_BIGENDIAN
+#  define GRUB_CPU_WORDS_BIGENDIAN	1
+# else
+#  undef GRUB_CPU_WORDS_BIGENDIAN
+# endif
+#else /* ! GRUB_UTIL */
+# define GRUB_CPU_SIZEOF_VOID_P	GRUB_TARGET_SIZEOF_VOID_P
+# define GRUB_CPU_SIZEOF_LONG	GRUB_TARGET_SIZEOF_LONG
+# ifdef GRUB_TARGET_WORDS_BIGENDIAN
+#  define GRUB_CPU_WORDS_BIGENDIAN	1
+# else
+#  undef GRUB_CPU_WORDS_BIGENDIAN
+# endif
+#endif /* ! GRUB_UTIL */
+
+#if GRUB_CPU_SIZEOF_VOID_P != 4 && GRUB_CPU_SIZEOF_VOID_P != 8
+# error "This architecture is not supported because sizeof(void *) != 4 and sizeof(void *) != 8"
+#endif
+
+#ifndef GRUB_TARGET_WORDSIZE
+# if GRUB_TARGET_SIZEOF_VOID_P == 4
+#  define GRUB_TARGET_WORDSIZE 32
+# elif GRUB_TARGET_SIZEOF_VOID_P == 8
+#  define GRUB_TARGET_WORDSIZE 64
+# endif
+#endif
+
+/* Define various wide integers.  */
+typedef signed char		grub_int8_t;
+typedef short			grub_int16_t;
+typedef int			grub_int32_t;
+#if GRUB_CPU_SIZEOF_LONG == 8
+typedef long			grub_int64_t;
+#else
+typedef long long		grub_int64_t;
+#endif
+
+typedef unsigned char		grub_uint8_t;
+typedef unsigned short		grub_uint16_t;
+typedef unsigned		grub_uint32_t;
+#if GRUB_CPU_SIZEOF_LONG == 8
+typedef unsigned long		grub_uint64_t;
+#else
+typedef unsigned long long	grub_uint64_t;
+#endif
+
+/* Misc types.  */
+#if GRUB_TARGET_SIZEOF_VOID_P == 8
+typedef grub_uint64_t	grub_target_addr_t;
+typedef grub_uint64_t	grub_target_off_t;
+typedef grub_uint64_t	grub_target_size_t;
+typedef grub_int64_t	grub_target_ssize_t;
+#else
+typedef grub_uint32_t	grub_target_addr_t;
+typedef grub_uint32_t	grub_target_off_t;
+typedef grub_uint32_t	grub_target_size_t;
+typedef grub_int32_t	grub_target_ssize_t;
+#endif
+
+#if GRUB_CPU_SIZEOF_VOID_P == 8
+typedef grub_uint64_t	grub_addr_t;
+typedef grub_uint64_t	grub_size_t;
+typedef grub_int64_t	grub_ssize_t;
+#else
+typedef grub_uint32_t	grub_addr_t;
+typedef grub_uint32_t	grub_size_t;
+typedef grub_int32_t	grub_ssize_t;
+#endif
+
+#if GRUB_CPU_SIZEOF_VOID_P == 8
+# define GRUB_ULONG_MAX 18446744073709551615UL
+# define GRUB_LONG_MAX 9223372036854775807L
+# define GRUB_LONG_MIN (-9223372036854775807L - 1)
+#else
+# define GRUB_ULONG_MAX 4294967295UL
+# define GRUB_LONG_MAX 2147483647L
+# define GRUB_LONG_MIN (-2147483647L - 1)
+#endif
+
+#if GRUB_CPU_SIZEOF_VOID_P == 4
+#define UINT_TO_PTR(x) ((void*)(grub_uint32_t)(x))
+#define PTR_TO_UINT64(x) ((grub_uint64_t)(grub_uint32_t)(x))
+#define PTR_TO_UINT32(x) ((grub_uint32_t)(x))
+#else
+#define UINT_TO_PTR(x) ((void*)(grub_uint64_t)(x))
+#define PTR_TO_UINT64(x) ((grub_uint64_t)(x))
+#define PTR_TO_UINT32(x) ((grub_uint32_t)(grub_uint64_t)(x))
+#endif
+
+/* The type for representing a file offset.  */
+typedef grub_uint64_t	grub_off_t;
+
+/* The type for representing a disk block address.  */
+typedef grub_uint64_t	grub_disk_addr_t;
+
+/* Byte-orders.  */
+#define grub_swap_bytes16(x)	\
+({ \
+   grub_uint16_t _x = (x); \
+   (grub_uint16_t) ((_x << 8) | (_x >> 8)); \
+})
+
+#if defined(__GNUC__) && (__GNUC__ > 3) && (__GNUC__ > 4 || __GNUC_MINOR__ >= 3) && defined(GRUB_TARGET_I386)
+static inline grub_uint32_t grub_swap_bytes32(grub_uint32_t x)
+{
+	return __builtin_bswap32(x);
+}
+
+static inline grub_uint64_t grub_swap_bytes64(grub_uint64_t x)
+{
+	return __builtin_bswap64(x);
+}
+#else					/* not gcc 4.3 or newer */
+#define grub_swap_bytes32(x)	\
+({ \
+   grub_uint32_t _x = (x); \
+   (grub_uint32_t) ((_x << 24) \
+                    | ((_x & (grub_uint32_t) 0xFF00UL) << 8) \
+                    | ((_x & (grub_uint32_t) 0xFF0000UL) >> 8) \
+                    | (_x >> 24)); \
+})
+
+#define grub_swap_bytes64(x)	\
+({ \
+   grub_uint64_t _x = (x); \
+   (grub_uint64_t) ((_x << 56) \
+                    | ((_x & (grub_uint64_t) 0xFF00ULL) << 40) \
+                    | ((_x & (grub_uint64_t) 0xFF0000ULL) << 24) \
+                    | ((_x & (grub_uint64_t) 0xFF000000ULL) << 8) \
+                    | ((_x & (grub_uint64_t) 0xFF00000000ULL) >> 8) \
+                    | ((_x & (grub_uint64_t) 0xFF0000000000ULL) >> 24) \
+                    | ((_x & (grub_uint64_t) 0xFF000000000000ULL) >> 40) \
+                    | (_x >> 56)); \
+})
+#endif					/* not gcc 4.3 or newer */
+
+#ifdef GRUB_CPU_WORDS_BIGENDIAN
+# define grub_cpu_to_le16(x)	grub_swap_bytes16(x)
+# define grub_cpu_to_le32(x)	grub_swap_bytes32(x)
+# define grub_cpu_to_le64(x)	grub_swap_bytes64(x)
+# define grub_le_to_cpu16(x)	grub_swap_bytes16(x)
+# define grub_le_to_cpu32(x)	grub_swap_bytes32(x)
+# define grub_le_to_cpu64(x)	grub_swap_bytes64(x)
+# define grub_cpu_to_be16(x)	((grub_uint16_t) (x))
+# define grub_cpu_to_be32(x)	((grub_uint32_t) (x))
+# define grub_cpu_to_be64(x)	((grub_uint64_t) (x))
+# define grub_be_to_cpu16(x)	((grub_uint16_t) (x))
+# define grub_be_to_cpu32(x)	((grub_uint32_t) (x))
+# define grub_be_to_cpu64(x)	((grub_uint64_t) (x))
+# ifdef GRUB_TARGET_WORDS_BIGENDIAN
+#  define grub_target_to_host16(x)	((grub_uint16_t) (x))
+#  define grub_target_to_host32(x)	((grub_uint32_t) (x))
+#  define grub_target_to_host64(x)	((grub_uint64_t) (x))
+#  define grub_host_to_target16(x)	((grub_uint16_t) (x))
+#  define grub_host_to_target32(x)	((grub_uint32_t) (x))
+#  define grub_host_to_target64(x)	((grub_uint64_t) (x))
+# else /* ! GRUB_TARGET_WORDS_BIGENDIAN */
+#  define grub_target_to_host16(x)	grub_swap_bytes16(x)
+#  define grub_target_to_host32(x)	grub_swap_bytes32(x)
+#  define grub_target_to_host64(x)	grub_swap_bytes64(x)
+#  define grub_host_to_target16(x)	grub_swap_bytes16(x)
+#  define grub_host_to_target32(x)	grub_swap_bytes32(x)
+#  define grub_host_to_target64(x)	grub_swap_bytes64(x)
+# endif
+#else /* ! WORDS_BIGENDIAN */
+# define grub_cpu_to_le16(x)	((grub_uint16_t) (x))
+# define grub_cpu_to_le32(x)	((grub_uint32_t) (x))
+# define grub_cpu_to_le64(x)	((grub_uint64_t) (x))
+# define grub_le_to_cpu16(x)	((grub_uint16_t) (x))
+# define grub_le_to_cpu32(x)	((grub_uint32_t) (x))
+# define grub_le_to_cpu64(x)	((grub_uint64_t) (x))
+# define grub_cpu_to_be16(x)	grub_swap_bytes16(x)
+# define grub_cpu_to_be32(x)	grub_swap_bytes32(x)
+# define grub_cpu_to_be64(x)	grub_swap_bytes64(x)
+# define grub_be_to_cpu16(x)	grub_swap_bytes16(x)
+# define grub_be_to_cpu32(x)	grub_swap_bytes32(x)
+# define grub_be_to_cpu64(x)	grub_swap_bytes64(x)
+# ifdef GRUB_TARGET_WORDS_BIGENDIAN
+#  define grub_target_to_host16(x)	grub_swap_bytes16(x)
+#  define grub_target_to_host32(x)	grub_swap_bytes32(x)
+#  define grub_target_to_host64(x)	grub_swap_bytes64(x)
+#  define grub_host_to_target16(x)	grub_swap_bytes16(x)
+#  define grub_host_to_target32(x)	grub_swap_bytes32(x)
+#  define grub_host_to_target64(x)	grub_swap_bytes64(x)
+# else /* ! GRUB_TARGET_WORDS_BIGENDIAN */
+#  define grub_target_to_host16(x)	((grub_uint16_t) (x))
+#  define grub_target_to_host32(x)	((grub_uint32_t) (x))
+#  define grub_target_to_host64(x)	((grub_uint64_t) (x))
+#  define grub_host_to_target16(x)	((grub_uint16_t) (x))
+#  define grub_host_to_target32(x)	((grub_uint32_t) (x))
+#  define grub_host_to_target64(x)	((grub_uint64_t) (x))
+# endif
+#endif /* ! WORDS_BIGENDIAN */
+
+#if GRUB_TARGET_SIZEOF_VOID_P == 8
+#  define grub_host_to_target_addr(x) grub_host_to_target64(x)
+#else
+#  define grub_host_to_target_addr(x) grub_host_to_target32(x)
+#endif
+
+#endif /* ! GRUB_TYPES_HEADER */
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/grub-fat/i386/types.h xen-4.1.2-b/tools/ioemu-qemu-xen/grub-fat/i386/types.h
--- xen-4.1.2-a/tools/ioemu-qemu-xen/grub-fat/i386/types.h	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/grub-fat/i386/types.h	2012-12-28 16:02:41.010937619 +0800
@@ -0,0 +1,35 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2002,2006,2007  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GRUB_TYPES_CPU_HEADER
+#define GRUB_TYPES_CPU_HEADER	1
+
+/* The size of void *.  */
+#define GRUB_TARGET_SIZEOF_VOID_P	4
+
+/* The size of long.  */
+#define GRUB_TARGET_SIZEOF_LONG		4
+
+/* i386 is little-endian.  */
+#undef GRUB_TARGET_WORDS_BIGENDIAN
+
+#define GRUB_TARGET_I386		1
+
+#define GRUB_TARGET_MIN_ALIGN		1
+
+#endif /* ! GRUB_TYPES_CPU_HEADER */
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/grub-fat/misc.h xen-4.1.2-b/tools/ioemu-qemu-xen/grub-fat/misc.h
--- xen-4.1.2-a/tools/ioemu-qemu-xen/grub-fat/misc.h	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/grub-fat/misc.h	2012-12-28 16:02:41.010937619 +0800
@@ -0,0 +1,17 @@
+int
+grub_strncmp (const char *s1, const char *s2, grub_size_t n)
+{
+  if (n == 0)
+    return 0;
+
+  while (*s1 && *s2 && --n)
+    {
+      if (*s1 != *s2)
+        break;
+
+      s1++;
+      s2++;
+    }
+
+  return (int) *s1 - (int) *s2;
+}
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/grub-fat/x86_64/types.h xen-4.1.2-b/tools/ioemu-qemu-xen/grub-fat/x86_64/types.h
--- xen-4.1.2-a/tools/ioemu-qemu-xen/grub-fat/x86_64/types.h	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/grub-fat/x86_64/types.h	2012-12-28 16:02:41.011764159 +0800
@@ -0,0 +1,39 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GRUB_TYPES_CPU_HEADER
+#define GRUB_TYPES_CPU_HEADER	1
+
+/* The size of void *.  */
+#define GRUB_TARGET_SIZEOF_VOID_P	8
+
+/* The size of long.  */
+#ifdef __MINGW32__
+#define GRUB_TARGET_SIZEOF_LONG		4
+#else
+#define GRUB_TARGET_SIZEOF_LONG		8
+#endif
+
+/* x86_64 is little-endian.  */
+#undef GRUB_TARGET_WORDS_BIGENDIAN
+
+#define GRUB_TARGET_X86_64		1
+
+#define GRUB_TARGET_MIN_ALIGN		1
+
+#endif /* ! GRUB_TYPES_CPU_HEADER */
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/i386/types.h xen-4.1.2-b/tools/ioemu-qemu-xen/i386/types.h
--- xen-4.1.2-a/tools/ioemu-qemu-xen/i386/types.h	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/i386/types.h	2012-12-28 16:02:41.017802371 +0800
@@ -0,0 +1,35 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2002,2006,2007  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GRUB_TYPES_CPU_HEADER
+#define GRUB_TYPES_CPU_HEADER	1
+
+/* The size of void *.  */
+#define GRUB_TARGET_SIZEOF_VOID_P	4
+
+/* The size of long.  */
+#define GRUB_TARGET_SIZEOF_LONG		4
+
+/* i386 is little-endian.  */
+#undef GRUB_TARGET_WORDS_BIGENDIAN
+
+#define GRUB_TARGET_I386		1
+
+#define GRUB_TARGET_MIN_ALIGN		1
+
+#endif /* ! GRUB_TYPES_CPU_HEADER */
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/Makefile xen-4.1.2-b/tools/ioemu-qemu-xen/Makefile
--- xen-4.1.2-a/tools/ioemu-qemu-xen/Makefile	2011-02-12 01:54:51.000000000 +0800
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/Makefile	2012-12-28 16:02:41.011764159 +0800
@@ -188,17 +188,18 @@ libqemu_common.a: $(OBJS)
 #######################################################################
 # USER_OBJS is code used by qemu userspace emulation
 USER_OBJS=cutils.o  cache-utils.o
 
 libqemu_user.a: $(USER_OBJS)
 
 ######################################################################
 
-qemu-img$(EXESUF): qemu-img.o qemu-tool.o osdep.o $(BLOCK_OBJS)
+
+qemu-img$(EXESUF):fs-time.o grub_err.o partition.o fshelp.o ntfs.o fat.o misc.o debug.o qemu-img.o qemu-tool.o osdep.o $(BLOCK_OBJS)
 
 qemu-nbd$(EXESUF):  qemu-nbd.o qemu-tool.o osdep.o $(BLOCK_OBJS)
 
 qemu-img$(EXESUF) qemu-nbd$(EXESUF): LIBS += -lz
 
 
 clean:
 # avoid old build problems by removing potentially incorrect old files
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/Makefile.orig xen-4.1.2-b/tools/ioemu-qemu-xen/Makefile.orig
--- xen-4.1.2-a/tools/ioemu-qemu-xen/Makefile.orig	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/Makefile.orig	2012-12-28 15:59:35.354681634 +0800
@@ -0,0 +1,372 @@
+# Makefile for QEMU.
+
+include config-host.mak
+include $(SRC_PATH)/rules.mak
+
+.PHONY: all clean cscope distclean dvi html info install install-doc \
+	recurse-all speed tar tarbin test
+
+VPATH=$(SRC_PATH):$(SRC_PATH)/hw
+
+
+CFLAGS += $(OS_CFLAGS) $(ARCH_CFLAGS)
+LDFLAGS += $(OS_LDFLAGS) $(ARCH_LDFLAGS)
+
+CPPFLAGS += -I. -I$(SRC_PATH) -MMD -MP -MT $@
+CPPFLAGS += -D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE
+LIBS=
+ifdef CONFIG_STATIC
+LDFLAGS += -static
+endif
+ifdef BUILD_DOCS
+DOCS=qemu-doc.html qemu-tech.html qemu.1 qemu-img.1 qemu-nbd.8
+else
+DOCS=
+endif
+
+LIBS+=$(AIOLIBS)
+
+ifdef CONFIG_SOLARIS
+LIBS+=-lsocket -lnsl -lresolv
+endif
+
+ifdef CONFIG_WIN32
+LIBS+=-lwinmm -lws2_32 -liphlpapi
+endif
+
+all: $(TOOLS) $(DOCS) recurse-all
+
+SUBDIR_RULES=$(patsubst %,subdir-%, $(TARGET_DIRS))
+
+subdir-%:
+	$(call quiet-command,$(MAKE) -C $* V="$(V)" TARGET_DIR="$*/" all,)
+
+$(filter %-softmmu,$(SUBDIR_RULES)): libqemu_common.a
+$(filter %-user,$(SUBDIR_RULES)): libqemu_user.a
+
+recurse-all: $(SUBDIR_RULES)
+
+CPPFLAGS += -I$(XEN_ROOT)/tools/libxc
+CPPFLAGS += -I$(XEN_ROOT)/tools/blktap/lib
+CPPFLAGS += -I$(XEN_ROOT)/tools/xenstore
+CPPFLAGS += -I$(XEN_ROOT)/tools/include
+
+tapdisk-ioemu: tapdisk-ioemu.c cutils.c block.c block-raw.c block-cow.c block-qcow.c aes.c block-vmdk.c block-cloop.c block-dmg.c block-bochs.c block-vpc.c block-vvfat.c block-qcow2.c hw/xen_blktap.c osdep.c
+	$(CC) -DQEMU_TOOL $(CFLAGS) $(CPPFLAGS) $(BASE_CFLAGS) $(LDFLAGS) $(BASE_LDFLAGS) -o $@ $^ -lz $(LIBS)
+
+#######################################################################
+# BLOCK_OBJS is code used by both qemu system emulation and qemu-img
+
+BLOCK_OBJS=cutils.o osdep.o qemu-malloc.o
+BLOCK_OBJS+=block-cow.o block-qcow.o aes.o block-vmdk.o block-cloop.o
+BLOCK_OBJS+=block-dmg.o block-bochs.o block-vpc.o block-vvfat.o
+BLOCK_OBJS+=block-qcow2.o block-parallels.o block-nbd.o
+BLOCK_OBJS+=nbd.o block.o aio.o
+
+ifdef CONFIG_WIN32
+BLOCK_OBJS += block-raw-win32.o
+else
+ifdef CONFIG_AIO
+BLOCK_OBJS += posix-aio-compat.o
+endif
+BLOCK_OBJS += block-raw-posix.o
+endif
+
+######################################################################
+# libqemu_common.a: Target independent part of system emulation. The
+# long term path is to suppress *all* target specific code in case of
+# system emulation, i.e. a single QEMU executable should support all
+# CPUs and machines.
+
+OBJS=$(BLOCK_OBJS)
+OBJS+=readline.o console.o
+
+OBJS+=irq.o
+OBJS+=i2c.o smbus.o smbus_eeprom.o max7310.o max111x.o wm8750.o
+OBJS+=ssd0303.o ssd0323.o ads7846.o stellaris_input.o twl92230.o
+OBJS+=tmp105.o lm832x.o
+OBJS+=scsi-disk.o cdrom.o
+OBJS+=scsi-generic.o
+OBJS+=usb.o usb-hub.o usb-$(HOST_USB).o usb-hid.o usb-msd.o usb-wacom.o
+OBJS+=usb-serial.o usb-net.o
+OBJS+=sd.o ssi-sd.o
+OBJS+=bt.o bt-host.o bt-vhci.o bt-l2cap.o bt-sdp.o bt-hci.o bt-hid.o usb-bt.o
+OBJS+=buffered_file.o migration.o migration-tcp.o net.o qemu-sockets.o
+OBJS+=qemu-char.o aio.o net-checksum.o savevm.o cache-utils.o
+
+ifdef CONFIG_BRLAPI
+OBJS+= baum.o
+LIBS+=-lbrlapi
+endif
+
+ifdef CONFIG_WIN32
+OBJS+=tap-win32.o
+else
+OBJS+=migration-exec.o
+endif
+
+AUDIO_OBJS = audio.o noaudio.o wavaudio.o mixeng.o
+ifdef CONFIG_SDL
+AUDIO_OBJS += sdlaudio.o
+endif
+ifdef CONFIG_OSS
+AUDIO_OBJS += ossaudio.o
+endif
+ifdef CONFIG_COREAUDIO
+AUDIO_OBJS += coreaudio.o
+AUDIO_PT = yes
+endif
+ifdef CONFIG_ALSA
+AUDIO_OBJS += alsaaudio.o
+endif
+ifdef CONFIG_DSOUND
+AUDIO_OBJS += dsoundaudio.o
+endif
+ifdef CONFIG_FMOD
+AUDIO_OBJS += fmodaudio.o
+audio/audio.o audio/fmodaudio.o: CPPFLAGS := -I$(CONFIG_FMOD_INC) $(CPPFLAGS)
+endif
+ifdef CONFIG_ESD
+AUDIO_PT = yes
+AUDIO_PT_INT = yes
+AUDIO_OBJS += esdaudio.o
+endif
+ifdef CONFIG_PA
+AUDIO_PT = yes
+AUDIO_PT_INT = yes
+AUDIO_OBJS += paaudio.o
+endif
+ifdef AUDIO_PT
+LDFLAGS += -pthread
+endif
+ifdef AUDIO_PT_INT
+AUDIO_OBJS += audio_pt_int.o
+endif
+AUDIO_OBJS+= wavcapture.o
+ifdef CONFIG_AUDIO
+OBJS+=$(addprefix audio/, $(AUDIO_OBJS))
+endif
+
+ifdef CONFIG_SDL
+OBJS+=sdl.o x_keymap.o
+endif
+ifdef CONFIG_CURSES
+OBJS+=curses.o
+endif
+OBJS+=vnc.o d3des.o
+
+ifdef CONFIG_COCOA
+OBJS+=cocoa.o
+endif
+
+ifdef CONFIG_SLIRP
+CPPFLAGS+=-I$(SRC_PATH)/slirp
+SLIRP_OBJS=cksum.o if.o ip_icmp.o ip_input.o ip_output.o \
+slirp.o mbuf.o misc.o sbuf.o socket.o tcp_input.o tcp_output.o \
+tcp_subr.o tcp_timer.o udp.o bootp.o debug.o tftp.o
+OBJS+=$(addprefix slirp/, $(SLIRP_OBJS))
+endif
+
+LIBS+=$(VDE_LIBS)
+
+cocoa.o: cocoa.m
+
+sdl.o: sdl.c keymaps.c sdl_keysym.h
+
+sdl.o audio/sdlaudio.o: CFLAGS += $(SDL_CFLAGS)
+
+vnc.o: vnc.c keymaps.c sdl_keysym.h vnchextile.h d3des.c d3des.h
+
+vnc.o: CFLAGS += $(CONFIG_VNC_TLS_CFLAGS)
+
+curses.o: curses.c keymaps.c curses_keys.h
+
+bt-host.o: CFLAGS += $(CONFIG_BLUEZ_CFLAGS)
+
+libqemu_common.a: $(OBJS)
+
+#######################################################################
+# USER_OBJS is code used by qemu userspace emulation
+USER_OBJS=cutils.o  cache-utils.o
+
+libqemu_user.a: $(USER_OBJS)
+
+######################################################################
+
+qemu-img$(EXESUF): qemu-img.o qemu-tool.o osdep.o $(BLOCK_OBJS)
+
+qemu-nbd$(EXESUF):  qemu-nbd.o qemu-tool.o osdep.o $(BLOCK_OBJS)
+
+qemu-img$(EXESUF) qemu-nbd$(EXESUF): LIBS += -lz
+
+
+clean:
+# avoid old build problems by removing potentially incorrect old files
+	rm -f config.mak config.h op-i386.h opc-i386.h gen-op-i386.h op-arm.h opc-arm.h gen-op-arm.h
+	rm -f *.o .*.d *.a $(TOOLS) TAGS cscope.* *.pod *~ */*~
+	rm -f slirp/*.o slirp/.*.d audio/*.o audio/.*.d
+	$(MAKE) -C tests clean
+	for d in $(TARGET_DIRS); do \
+	$(MAKE) -C $$d $@ || exit 1 ; \
+        done
+
+distclean: clean
+	rm -f config-host.mak config-host.h $(DOCS)
+	rm -f qemu-{doc,tech}.{info,aux,cp,dvi,fn,info,ky,log,pg,toc,tp,vr}
+	for d in $(TARGET_DIRS); do \
+	rm -rf $$d || exit 1 ; \
+        done
+
+KEYMAPS=da     en-gb  et  fr     fr-ch  is  lt  modifiers  no  pt-br  sv \
+ar      de     en-us  fi  fr-be  hr     it  lv  nl         pl  ru     th \
+common  de-ch  es     fo  fr-ca  hu     ja  mk  nl-be      pt  sl     tr
+
+ifdef INSTALL_BLOBS
+BLOBS=bios.bin vgabios.bin vgabios-cirrus.bin ppc_rom.bin \
+video.x openbios-sparc32 openbios-sparc64 openbios-ppc \
+pxe-ne2k_pci.bin pxe-rtl8139.bin pxe-pcnet.bin pxe-e1000.bin \
+bamboo.dtb
+else
+BLOBS=
+endif
+
+install-doc: $(DOCS)
+	mkdir -p "$(DESTDIR)$(docdir)"
+	$(INSTALL) -m 644 qemu-doc.html  qemu-tech.html "$(DESTDIR)$(docdir)"
+ifndef CONFIG_WIN32
+	mkdir -p "$(DESTDIR)$(mandir)/man1"
+	$(INSTALL) -m 644 qemu.1 qemu-img.1 "$(DESTDIR)$(mandir)/man1"
+	mkdir -p "$(DESTDIR)$(mandir)/man8"
+	$(INSTALL) -m 644 qemu-nbd.8 "$(DESTDIR)$(mandir)/man8"
+endif
+
+install: all $(if $(BUILD_DOCS),install-doc)
+	mkdir -p "$(DESTDIR)$(bindir)"
+ifneq ($(TOOLS),)
+	$(INSTALL) -m 755 -s $(TOOLS) "$(DESTDIR)$(bindir)"
+endif
+ifneq ($(BLOBS),)
+	mkdir -p "$(DESTDIR)$(datadir)"
+	set -e; for x in $(BLOBS); do \
+		$(INSTALL) -m 644 $(SRC_PATH)/pc-bios/$$x "$(DESTDIR)$(datadir)"; \
+	done
+endif
+ifndef CONFIG_WIN32
+	mkdir -p "$(DESTDIR)$(datadir)/keymaps"
+	set -e; for x in $(KEYMAPS); do \
+		$(INSTALL) -m 644 $(SRC_PATH)/keymaps/$$x "$(DESTDIR)$(datadir)/keymaps"; \
+	done
+endif
+	for d in $(TARGET_DIRS); do \
+	$(MAKE) -C $$d $@ || exit 1 ; \
+        done
+
+# various test targets
+test speed: all
+	$(MAKE) -C tests $@
+
+TAGS:
+	etags *.[ch] tests/*.[ch]
+
+cscope:
+	rm -f ./cscope.*
+	find . -name "*.[ch]" -print | sed 's,^\./,,' > ./cscope.files
+	cscope -b
+
+# documentation
+%.html: %.texi
+	texi2html -monolithic -number $<
+
+%.info: %.texi
+	makeinfo $< -o $@
+
+%.dvi: %.texi
+	texi2dvi $<
+
+qemu.1: qemu-doc.texi
+	$(SRC_PATH)/texi2pod.pl $< qemu.pod
+	pod2man --section=1 --center=" " --release=" " qemu.pod > $@
+
+qemu-img.1: qemu-img.texi
+	$(SRC_PATH)/texi2pod.pl $< qemu-img.pod
+	pod2man --section=1 --center=" " --release=" " qemu-img.pod > $@
+
+qemu-nbd.8: qemu-nbd.texi
+	$(SRC_PATH)/texi2pod.pl $< qemu-nbd.pod
+	pod2man --section=8 --center=" " --release=" " qemu-nbd.pod > $@
+
+info: qemu-doc.info qemu-tech.info
+
+dvi: qemu-doc.dvi qemu-tech.dvi
+
+html: qemu-doc.html qemu-tech.html
+
+qemu-doc.dvi qemu-doc.html qemu-doc.info: qemu-img.texi qemu-nbd.texi
+
+VERSION ?= $(shell cat VERSION)
+FILE = qemu-$(VERSION)
+
+# tar release (use 'make -k tar' on a checkouted tree)
+tar:
+	rm -rf /tmp/$(FILE)
+	cp -r . /tmp/$(FILE)
+	cd /tmp && tar zcvf ~/$(FILE).tar.gz $(FILE) --exclude CVS --exclude .git --exclude .svn
+	rm -rf /tmp/$(FILE)
+
+# generate a binary distribution
+tarbin:
+	cd / && tar zcvf ~/qemu-$(VERSION)-$(ARCH).tar.gz \
+	$(bindir)/qemu \
+	$(bindir)/qemu-system-x86_64 \
+	$(bindir)/qemu-system-arm \
+	$(bindir)/qemu-system-cris \
+	$(bindir)/qemu-system-m68k \
+	$(bindir)/qemu-system-mips \
+	$(bindir)/qemu-system-mipsel \
+	$(bindir)/qemu-system-mips64 \
+	$(bindir)/qemu-system-mips64el \
+	$(bindir)/qemu-system-ppc \
+	$(bindir)/qemu-system-ppcemb \
+	$(bindir)/qemu-system-ppc64 \
+	$(bindir)/qemu-system-sh4 \
+	$(bindir)/qemu-system-sh4eb \
+	$(bindir)/qemu-system-sparc \
+	$(bindir)/qemu-i386 \
+	$(bindir)/qemu-x86_64 \
+	$(bindir)/qemu-alpha \
+	$(bindir)/qemu-arm \
+	$(bindir)/qemu-armeb \
+	$(bindir)/qemu-cris \
+	$(bindir)/qemu-m68k \
+	$(bindir)/qemu-mips \
+	$(bindir)/qemu-mipsel \
+	$(bindir)/qemu-ppc \
+	$(bindir)/qemu-ppc64 \
+	$(bindir)/qemu-ppc64abi32 \
+	$(bindir)/qemu-sh4 \
+	$(bindir)/qemu-sh4eb \
+	$(bindir)/qemu-sparc \
+	$(bindir)/qemu-sparc64 \
+	$(bindir)/qemu-sparc32plus \
+	$(bindir)/qemu-img \
+	$(bindir)/qemu-nbd \
+	$(datadir)/bios.bin \
+	$(datadir)/vgabios.bin \
+	$(datadir)/vgabios-cirrus.bin \
+	$(datadir)/ppc_rom.bin \
+	$(datadir)/video.x \
+	$(datadir)/openbios-sparc32 \
+	$(datadir)/openbios-sparc64 \
+	$(datadir)/openbios-ppc \
+	$(datadir)/pxe-ne2k_pci.bin \
+	$(datadir)/pxe-rtl8139.bin \
+	$(datadir)/pxe-pcnet.bin \
+	$(datadir)/pxe-e1000.bin \
+	$(docdir)/qemu-doc.html \
+	$(docdir)/qemu-tech.html \
+	$(mandir)/man1/qemu.1 \
+	$(mandir)/man1/qemu-img.1 \
+	$(mandir)/man8/qemu-nbd.8
+
+# Include automatically generated dependency files
+-include $(wildcard .*.d audio/.*.d slirp/.*.d)
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/misc.c xen-4.1.2-b/tools/ioemu-qemu-xen/misc.c
--- xen-4.1.2-a/tools/ioemu-qemu-xen/misc.c	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/misc.c	2012-12-28 16:02:41.012937846 +0800
@@ -0,0 +1,432 @@
+#include "misc.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "grub_err.h"
+
+
+int
+grub_isspace (int c)
+{
+  return (c == '\n' || c == '\r' || c == ' ' || c == '\t');
+}
+
+int
+grub_tolower (int c)
+{
+  if (c >= 'A' && c <= 'Z')
+    return c - 'A' + 'a';
+
+  return c;
+}
+
+
+char *
+grub_strchr (const char *s, int c)
+{
+  do
+    {
+      if (*s == c)
+	return (char *) s;
+    }
+  while (*s++);
+
+  return 0;
+}
+
+
+grub_size_t
+grub_strlen (const char *s)
+{
+  const char *p = s;
+
+  while (*p)
+    p++;
+
+  return p - s;
+}
+
+
+
+
+
+char *
+grub_strncpy (char *dest, const char *src, int c)
+{
+  char *p = dest;
+
+  while ((*p++ = *src++) != '\0' && --c)
+    ;
+
+  return dest;
+}
+
+char *
+grub_strdup (const char *s)
+{
+  grub_size_t len;
+  char *p;
+
+  len = grub_strlen (s) + 1;
+  p = (char *) malloc (len);
+  if (! p)
+    return 0;
+
+  return memcpy (p, s, len);
+}
+
+
+
+char *
+grub_strndup (const char *s, grub_size_t n)
+{
+  grub_size_t len;
+  char *p;
+
+  len = grub_strlen (s);
+  if (len > n)
+    len = n;
+  p = (char *) malloc (len + 1);
+  if (! p)
+    return 0;
+
+  memcpy (p, s, len);
+  p[len] = '\0';
+  return p;
+}
+
+
+
+
+int
+grub_strcmp (const char *s1, const char *s2)
+{
+  while (*s1 && *s2)
+    {
+      if (*s1 != *s2)
+	break;
+
+      s1++;
+      s2++;
+    }
+
+  return (int) *s1 - (int) *s2;
+}
+
+int
+grub_strncmp (const char *s1, const char *s2, grub_size_t n)
+{
+  if (n == 0)
+    return 0;
+
+  while (*s1 && *s2 && --n)
+    {
+      if (*s1 != *s2)
+	break;
+
+      s1++;
+      s2++;
+    }
+
+  return (int) *s1 - (int) *s2;
+}
+
+
+int
+grub_strcasecmp (const char *s1, const char *s2)
+{
+  while (*s1 && *s2)
+    {
+      if (grub_tolower (*s1) != grub_tolower (*s2))
+	break;
+
+      s1++;
+      s2++;
+    }
+
+  return (int) grub_tolower (*s1) - (int) grub_tolower (*s2);
+}
+
+
+int
+grub_strncasecmp (const char *s1, const char *s2, grub_size_t n)
+{
+  if (n == 0)
+    return 0;
+
+  while (*s1 && *s2 && --n)
+    {
+      if (grub_tolower (*s1) != grub_tolower (*s2))
+	break;
+
+      s1++;
+      s2++;
+    }
+
+  return (int) grub_tolower (*s1) - (int) grub_tolower (*s2);
+}
+
+void *
+grub_memmove (void *dest, const void *src, grub_size_t n)
+{
+  char *d = (char *) dest;
+  const char *s = (const char *) src;
+
+  if (d < s)
+    while (n--)
+      *d++ = *s++;
+  else
+    {
+      d += n;
+      s += n;
+
+      while (n--)
+	*--d = *--s;
+    }
+
+  return dest;
+}
+
+
+void *
+grub_malloc (grub_size_t size)
+{
+  void *ret;
+  ret = malloc (size);
+  if (!ret)
+    grub_error (GRUB_ERR_OUT_OF_MEMORY, "out of memory");
+  return ret;
+}
+
+
+
+void
+grub_free (void *ptr)
+{
+  free (ptr);
+}
+
+
+void *
+grub_memset (void *s, int c, grub_size_t n)
+{
+  unsigned char *p = (unsigned char *) s;
+
+  while (n--)
+    *p++ = (unsigned char) c;
+
+  return s;
+}
+
+int
+grub_memcmp (const void *s1, const void *s2, grub_size_t n)
+{
+  const char *t1 = s1;
+  const char *t2 = s2;
+
+  while (n--)
+    {
+      if (*t1 != *t2)
+	return (int) *t1 - (int) *t2;
+
+      t1++;
+      t2++;
+    }
+
+  return 0;
+}
+
+
+void *
+grub_zalloc (grub_size_t size)
+{
+  void *ret;
+
+  ret = grub_malloc (size);
+  if (!ret)
+    return NULL;
+  memset (ret, 0, size);
+  return ret;
+}
+
+/* Divide N by D, return the quotient, and store the remainder in *R.  */
+grub_uint64_t
+grub_divmod64 (grub_uint64_t n, grub_uint32_t d, grub_uint32_t *r)
+{
+  /* This algorithm is typically implemented by hardware. The idea
+     is to get the highest bit in N, 64 times, by keeping
+     upper(N * 2^i) = upper((Q * 10 + M) * 2^i), where upper
+     represents the high 64 bits in 128-bits space.  */
+  unsigned bits = 64;
+  unsigned long long q = 0;
+  unsigned m = 0;
+
+  /* Skip the slow computation if 32-bit arithmetic is possible.  */
+  if (n < 0xffffffff)
+    {
+      if (r)
+	*r = ((grub_uint32_t) n) % d;
+
+      return ((grub_uint32_t) n) / d;
+    }
+
+  while (bits--)
+    {
+      m <<= 1;
+
+      if (n & (1ULL << 63))
+	m |= 1;
+
+      q <<= 1;
+      n <<= 1;
+
+      if (m >= d)
+	{
+	  q |= 1;
+	  m -= d;
+	}
+    }
+
+  if (r)
+    *r = m;
+
+  return q;
+}
+
+
+
+/* Convert UTF-16 to UTF-8.  */
+grub_uint8_t *
+grub_utf16_to_utf8 (grub_uint8_t *dest, grub_uint16_t *src,
+                    grub_size_t size)
+{
+  grub_uint32_t code_high = 0;
+
+  while (size--)
+    {
+      grub_uint32_t code = *src++;
+
+      if (code_high)
+        {
+          if (code >= 0xDC00 && code <= 0xDFFF)
+            {
+              /* Surrogate pair.  */
+              code = ((code_high - 0xD800) << 12) + (code - 0xDC00) + 0x10000;
+
+              *dest++ = (code >> 18) | 0xF0;
+              *dest++ = ((code >> 12) & 0x3F) | 0x80;
+              *dest++ = ((code >> 6) & 0x3F) | 0x80;
+              *dest++ = (code & 0x3F) | 0x80;
+            }
+          else
+            {
+              /* Error...  */
+              *dest++ = '?';
+            }
+
+          code_high = 0;
+        }
+      else
+        {
+          if (code <= 0x007F)
+            *dest++ = code;
+          else if (code <= 0x07FF)
+            {
+              *dest++ = (code >> 6) | 0xC0;
+              *dest++ = (code & 0x3F) | 0x80;
+            }
+          else if (code >= 0xD800 && code <= 0xDBFF)
+            {
+              code_high = code;
+              continue;
+            }
+          else if (code >= 0xDC00 && code <= 0xDFFF)
+            {
+              /* Error... */
+              *dest++ = '?';
+            }
+          else
+            {
+              *dest++ = (code >> 12) | 0xE0;
+              *dest++ = ((code >> 6) & 0x3F) | 0x80;
+              *dest++ = (code & 0x3F) | 0x80;
+            }
+        }
+    }
+
+  return dest;
+}
+
+
+
+
+
+
+static void print_byte(char *p, int len)
+{
+  printf("\n****************start print %s********************\n", p);
+  int i;
+  unsigned char *pb = (unsigned char*)p;
+  for(i = 0; i < len; i++)
+    {
+      printf("0x%02x,", pb[i]);
+    }
+  printf("\n**********************end**************************\n");
+}
+
+
+
+#include   <iconv.h> 
+#define   OUTLEN   256 
+
+
+//´úÂë×ª»»:´ÓÒ»ÖÖ±àÂë×ªÎªÁíÒ»ÖÖ±àÂë 
+static int   code_convert(const char   *from_charset, const char   *to_charset, 
+		    char   *inbuf, size_t   inlen,
+		   char   *outbuf, size_t   outlen) 
+{ 
+  iconv_t   cd; 
+  int   rc; 
+  char   **pin   =   &inbuf; 
+  char   **pout   =   &outbuf; 
+
+  //printf("sizeof(int)=%d, sizeof(size_t)=%d\n", sizeof(int), sizeof(size_t));
+  cd   =   iconv_open(to_charset, from_charset); 
+  if   (cd==0)   return   -1; 
+  memset(outbuf, 0, outlen); 
+  if   (iconv(cd, pin, &inlen, pout, &outlen)==-1)   return   -1; 
+  iconv_close(cd); 
+  return   0; 
+} 
+//UNICODEÂë×ªÎªGB2312Âë 
+int   u2g(char   *inbuf, size_t   inlen, char   *outbuf, size_t  outlen) 
+{
+  return   code_convert("utf-8", "gb2312", inbuf, inlen, outbuf, outlen); 
+} 
+//GB2312Âë×ªÎªUNICODEÂë 
+int   g2u(char   *inbuf, size_t   inlen, char   *outbuf, size_t   outlen) 
+{ 
+  return   code_convert("gb2312", "utf-8", inbuf, inlen, outbuf, outlen); 
+} 
+
+
+
+void test(void) 
+{
+  //×Ö·û±àÂë×ª»»=ï»¿å?ç¬????½¬??
+  char   in_utf8[]   =   {0xe5,0xad,0x97,0xe7,0xac,0xa6,0xe7,0xbc,0x96,0xe7,0xa0,0x81,0xe8,0xbd,0xac,0xe6,0x8d,0xa2}; 
+  char   *in_gb2312   = (char*)  "×Ö·û±àÂë×ª»»"; 
+  char   out[OUTLEN]; 
+  int rc;
+  //utf8Âë×ªÎªgb2312Âë 
+  rc   =   u2g(in_utf8, strlen(in_utf8), out, OUTLEN); 
+  printf("utf8-->gb2312   out=%s\n", out);
+  print_byte(out, strlen(out));
+  //gb2312Âë×ªÎªutf8Âë 
+  rc   =   g2u(in_gb2312, strlen(in_gb2312), out, OUTLEN); 
+  print_byte(out, strlen(out));
+  printf("gb2312-->utf8   out=%s\n",out); 
+} 
+
+
+
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/misc.h xen-4.1.2-b/tools/ioemu-qemu-xen/misc.h
--- xen-4.1.2-a/tools/ioemu-qemu-xen/misc.h	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/misc.h	2012-12-28 16:02:41.012937846 +0800
@@ -0,0 +1,89 @@
+#include "fs-types.h"
+#include <stddef.h>
+
+
+
+
+
+#define grub_memcpy(d,s,n)grub_memmove ((d), (s), (n))
+
+
+int
+grub_isspace (int c);
+
+int
+grub_tolower (int c);
+
+
+char *
+grub_strchr (const char *s, int c);
+
+
+grub_size_t
+grub_strlen (const char *s);
+
+
+
+char *
+grub_strdup (const char *s);
+
+
+
+char *
+grub_strndup (const char *s, grub_size_t n);
+
+
+char *
+grub_strncpy (char *dest, const char *src, int c);
+
+
+int
+grub_strcmp (const char *s1, const char *s2);
+
+int
+grub_strncmp (const char *s1, const char *s2, grub_size_t n);
+
+int
+grub_strcasecmp (const char *s1, const char *s2);
+
+int
+grub_strncasecmp (const char *s1, const char *s2, grub_size_t n);
+
+void *
+grub_memmove (void *dest, const void *src, grub_size_t n);
+
+int
+grub_memcmp (const void *s1, const void *s2, grub_size_t n);
+
+void *
+grub_malloc (grub_size_t size);
+
+void *
+grub_memset (void *s, int c, grub_size_t n);
+
+void
+grub_free (void *ptr);
+
+void *
+grub_zalloc (grub_size_t size);
+
+grub_uint64_t
+grub_divmod64 (grub_uint64_t n, grub_uint32_t d, grub_uint32_t *r);
+
+/* Convert UTF-16 to UTF-8.  */
+grub_uint8_t *
+grub_utf16_to_utf8 (grub_uint8_t *dest, grub_uint16_t *src,
+                    grub_size_t size);
+
+
+//UNICODEÂë×ªÎªGB2312Âë 
+int   u2g(char   *inbuf, size_t   inlen, char   *outbuf, size_t   outlen);
+//GB2312Âë×ªÎªUNICODEÂë 
+int   g2u(char   *inbuf, size_t   inlen, char   *outbuf, size_t   outlen);
+
+
+
+void test(void);
+
+
+
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/ntfs.c xen-4.1.2-b/tools/ioemu-qemu-xen/ntfs.c
--- xen-4.1.2-a/tools/ioemu-qemu-xen/ntfs.c	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/ntfs.c	2012-12-28 16:02:41.013937038 +0800
@@ -0,0 +1,1188 @@
+/* ntfs.c - NTFS filesystem */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2007,2008,2009 Free Software Foundation, Inc.
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "misc.h"
+#include "fshelp.h"
+#include "ntfs.h"
+#include "debug.h"
+#include "grub_err.h"
+#include "err.h"
+
+#define GRUB_DISK_SECTOR_SIZE 0x200
+ntfscomp_func_t grub_ntfscomp_func;
+
+//important
+//lcn is relative to start sector of the volume
+static grub_off_t s_part_off_sector;
+static grub_uint32_t s_bpb_bytes_per_sector;
+int bdrv_pread_from_lcn_of_volum(BlockDriverState *bs, int64_t offset,
+				 void *buf1, int count1)
+{
+  return bdrv_pread(bs, s_part_off_sector * s_bpb_bytes_per_sector + offset,
+		 buf1, count1);
+}
+
+
+static grub_err_t
+fixup (struct grub_ntfs_data *data, char *buf, int len, char *magic)
+{
+  int ss;
+  char *pu;
+  grub_uint16_t us;
+  
+  DBG("%x-%x-%x-%x", buf[0], buf[1], buf[2], buf[3]);
+  if (grub_memcmp (buf, magic, 4))
+    return grub_error (GRUB_ERR_BAD_FS, "%s label not found", magic);
+
+  ss = u16at (buf, 6) - 1;
+  if (ss * (int) data->blocksize != len * GRUB_DISK_SECTOR_SIZE)
+    return grub_error (GRUB_ERR_BAD_FS, "size not match",
+		       ss * (int) data->blocksize,
+		       len * GRUB_DISK_SECTOR_SIZE);
+  pu = buf + u16at (buf, 4);
+  us = u16at (pu, 0);
+  buf -= 2;
+  while (ss > 0)
+    {
+      buf += data->blocksize;
+      pu += 2;
+      if (u16at (buf, 0) != us)
+	return grub_error (GRUB_ERR_BAD_FS, "fixup signature not match");
+      v16at (buf, 0) = v16at (pu, 0);
+      ss--;
+    }
+
+  return 0;
+}
+
+static grub_err_t read_mft (struct grub_ntfs_data *data, char *buf,
+			    grub_uint32_t mftno);
+static grub_err_t read_attr (struct grub_ntfs_attr *at, char *dest,
+			     grub_disk_addr_t ofs, grub_size_t len,
+			     int cached,
+			     void (*read_hook) (grub_disk_addr_t sector,
+						unsigned offset,
+						unsigned length,
+						void *closure),
+			     void *closure);
+
+static grub_err_t read_data (struct grub_ntfs_attr *at, char *pa, char *dest,
+			     grub_disk_addr_t ofs, grub_size_t len,
+			     int cached,
+			     void (*read_hook) (grub_disk_addr_t sector,
+						unsigned offset,
+						unsigned length,
+						void *closure),
+			     void *closure);
+
+static void
+init_attr (struct grub_ntfs_attr *at, struct grub_ntfs_file *mft)
+{
+  at->mft = mft;
+  at->flags = (mft == &mft->data->mmft) ? AF_MMFT : 0;
+  at->attr_nxt = mft->buf + u16at (mft->buf, 0x14);
+  at->attr_end = at->emft_buf = at->edat_buf = at->sbuf = NULL;
+}
+
+static void
+free_attr (struct grub_ntfs_attr *at)
+{
+  grub_free (at->emft_buf);
+  grub_free (at->edat_buf);
+  grub_free (at->sbuf);
+}
+
+static char *
+find_attr (struct grub_ntfs_attr *at, unsigned char attr)
+{
+  grub_off_t off_bytes1;
+  grub_off_t off_bytes2;
+ 
+  if (at->flags & AF_ALST)
+    {
+      DBG("!!!!!!\nin a attr list======");
+    retry:
+      while (at->attr_nxt < at->attr_end)
+	{
+	  at->attr_cur = at->attr_nxt;
+	  at->attr_nxt += u16at (at->attr_cur, 4);
+	  if (((unsigned char) *at->attr_cur == attr) || (attr == 0))
+	    {
+	      char *new_pos;
+
+	      if (at->flags & AF_MMFT)
+		{
+		  DBG("in AF_MMFT......");
+		  off_bytes1 = (grub_off_t)(v32at (at->attr_cur, 0x10)) << BLK_SHR;
+		  off_bytes2 = (grub_off_t)(v32at (at->attr_cur, 0x14)) << BLK_SHR;
+		  if ((bdrv_pread
+		       (at->mft->data->bs, off_bytes1,
+			at->emft_buf, 512))
+		      ||
+		      (bdrv_pread
+		       (at->mft->data->bs, off_bytes2,
+			at->emft_buf + 512, 512)))
+		    return NULL;
+
+		  if (fixup
+		      (at->mft->data, at->emft_buf, at->mft->data->mft_size,
+		       (char*)"FILE"))
+		    return NULL;
+		}
+	      else
+		{
+		  DBG("read extend mft FR======");
+		  if (read_mft (at->mft->data, at->emft_buf,
+				u32at (at->attr_cur, 0x10)))
+		    return NULL;
+		}
+
+	      new_pos = &at->emft_buf[u16at (at->emft_buf, 0x14)];
+	      while ((unsigned char) *new_pos != 0xFF)
+		{
+		  DBG("new pos in extend mft======");
+		  if (((unsigned char) *new_pos ==
+		       (unsigned char) *at->attr_cur)
+		      && (u16at (new_pos, 0xE) == u16at (at->attr_cur, 0x18)))
+		    {
+		      return new_pos;
+		    }
+		  new_pos += u16at (new_pos, 4);
+		}
+	      grub_error (GRUB_ERR_BAD_FS,
+			  "can\'t find 0x%X in attribute list",
+			  (unsigned char) *at->attr_cur);
+	      return NULL;
+	    }
+	}
+      return NULL;
+    }
+
+
+  DBG("not in a attr list======");
+  at->attr_cur = at->attr_nxt;
+  while ((unsigned char) *at->attr_cur != 0xFF)
+    {
+      at->attr_nxt += u16at (at->attr_cur, 4);
+      if ((unsigned char) *at->attr_cur == AT_ATTRIBUTE_LIST)
+	at->attr_end = at->attr_cur;
+      if (((unsigned char) *at->attr_cur == attr) || (attr == 0))
+	{
+	  DBG("found======");
+	  return at->attr_cur;
+	}
+      at->attr_cur = at->attr_nxt;
+    }
+  
+  
+  if (at->attr_end)
+    {
+      DBG("searching in attr list======");
+      char *pa;
+
+      at->emft_buf = grub_malloc (at->mft->data->mft_size << BLK_SHR);
+      if (at->emft_buf == NULL)
+	return NULL;
+
+      pa = at->attr_end;
+      if (pa[8])
+	{
+          int n;
+
+          n = ((u32at (pa, 0x30) + GRUB_DISK_SECTOR_SIZE - 1)
+               & (~(GRUB_DISK_SECTOR_SIZE - 1)));
+	  at->attr_cur = at->attr_end;
+	  at->edat_buf = grub_malloc (n);
+	  if (!at->edat_buf)
+	    return NULL;
+	  if (read_data (at, pa, at->edat_buf, 0, n, 0, 0, 0))
+	    {
+	      grub_error (GRUB_ERR_BAD_FS,
+			  "fail to read non-resident attribute list");
+	      return NULL;
+	    }
+	  at->attr_nxt = at->edat_buf;
+	  at->attr_end = at->edat_buf + u32at (pa, 0x30);
+	}
+      else
+	{
+	  at->attr_nxt = at->attr_end + u16at (pa, 0x14);
+	  at->attr_end = at->attr_end + u32at (pa, 4);
+	}
+      at->flags |= AF_ALST;
+      while (at->attr_nxt < at->attr_end)
+	{
+	  if (((unsigned char) *at->attr_nxt == attr) || (attr == 0))
+	    break;
+	  at->attr_nxt += u16at (at->attr_nxt, 4);
+	}
+      if (at->attr_nxt >= at->attr_end)
+	{
+	  DBG("not found in list");
+	  return NULL;
+	}
+      DBG("found in attr list======");
+      if ((at->flags & AF_MMFT) && (attr == AT_DATA))
+	{
+	  DBG("AF_GPOS!!!!!!======");
+	  at->flags |= AF_GPOS;
+	  at->attr_cur = at->attr_nxt;
+	  pa = at->attr_cur;
+	  v32at (pa, 0x10) = at->mft->data->mft_start;
+	  v32at (pa, 0x14) = at->mft->data->mft_start + 1;
+	  pa = at->attr_nxt + u16at (pa, 4);
+	  while (pa < at->attr_end)
+	    {
+	      if ((unsigned char) *pa != attr)
+		break;
+	      if (read_attr
+		  (at, pa + 0x10,
+		   u32at (pa, 0x10) * (at->mft->data->mft_size << BLK_SHR),
+		   at->mft->data->mft_size << BLK_SHR, 0, 0, 0))
+		return NULL;
+	      pa += u16at (pa, 4);
+	    }
+	  at->attr_nxt = at->attr_cur;
+	  at->flags &= ~AF_GPOS;
+	}
+      
+      DBG("goto retry======");
+      goto retry;
+    }
+
+  DBG("return NULL");
+  return NULL;
+}
+
+static char *
+locate_attr (struct grub_ntfs_attr *at, struct grub_ntfs_file *mft,
+	     unsigned char attr)
+{
+  
+
+  char *pa;
+  
+  init_attr (at, mft);
+
+  DBG("\n!!!!!!\nlocating attr=0x%02x, at->flag=0x%02x============",
+      attr, at->flags);
+  if ((pa = find_attr (at, attr)) == NULL)
+    {
+      DBG("1=========not found");
+      return NULL;
+    }
+  if ((at->flags & AF_ALST) == 0)
+    {
+      DBG("2=======not a attr list, continue searching");
+      while (1)
+	{
+	  if ((pa = find_attr (at, attr)) == NULL)
+	    break;
+	  if (at->flags & AF_ALST)
+	    {
+	      DBG("3==========in a attr list,found");
+	      return pa;
+	    }
+	}
+      DBG("4========start searching all over again");
+      grub_errno = GRUB_ERR_NONE;
+      free_attr (at);
+      init_attr (at, mft);
+      pa = find_attr (at, attr);
+    }
+  DBG("locate finish======\n\n");
+  return pa;
+}
+
+static char *
+read_run_data (char *run, int nn, grub_disk_addr_t * val, int sig)
+{
+  grub_disk_addr_t r, v;
+
+  r = 0;
+  v = 1;
+
+  while (nn--)
+    {
+      r += v * (*(unsigned char *) (run++));
+      v <<= 8;
+    }
+
+  if ((sig) && (r & (v >> 1)))
+    r -= v;
+
+  *val = r;
+  return run;
+}
+
+grub_err_t
+grub_ntfs_read_run_list (struct grub_ntfs_rlst * ctx)
+{
+  DBG("read run list");
+
+  int c1, c2;
+  grub_disk_addr_t val;
+  char *run;
+
+  run = ctx->cur_run;
+retry:
+  c1 = ((unsigned char) (*run) & 0xF);
+  c2 = ((unsigned char) (*run) >> 4);
+  if (!c1)
+    {
+      if ((ctx->attr) && (ctx->attr->flags & AF_ALST))
+	{
+	  void (*save_hook) (grub_disk_addr_t sector,
+			     unsigned offset,
+			     unsigned length,
+			     void *closure);
+	  
+	  //save_hook = ctx->comp.bs->read_hook;
+	  //ctx->comp.bs->read_hook = 0;
+	  run = find_attr (ctx->attr, (unsigned char) *ctx->attr->attr_cur);
+	  //ctx->comp.bs->read_hook = save_hook;
+	  if (run)
+	    {
+	      if (run[8] == 0)
+		return grub_error (GRUB_ERR_BAD_FS,
+				   "$DATA should be non-resident");
+
+	      run += u16at (run, 0x20);
+	      ctx->curr_lcn = 0;
+	      goto retry;
+	    }
+	}
+      return grub_error (GRUB_ERR_BAD_FS, "run list overflown");
+    }
+  run = read_run_data (run + 1, c1, &val, 0);	/* length of current VCN */
+  ctx->curr_vcn = ctx->next_vcn;
+  ctx->next_vcn += val;
+  run = read_run_data (run, c2, &val, 1);	/* offset to previous LCN */
+  ctx->curr_lcn += val;
+  if (val == 0)
+    ctx->flags |= RF_BLNK;
+  else
+    ctx->flags &= ~RF_BLNK;
+  ctx->cur_run = run;
+  return 0;
+}
+
+static grub_disk_addr_t
+grub_ntfs_read_block (grub_fshelp_node_t node, grub_disk_addr_t block)
+{
+  struct grub_ntfs_rlst *ctx;
+
+  ctx = (struct grub_ntfs_rlst *) node;
+  if (block >= ctx->next_vcn)
+    {
+      if (grub_ntfs_read_run_list (ctx))
+	return -1;
+      return ctx->curr_lcn;
+    }
+  else
+    return (ctx->flags & RF_BLNK) ? 0 : (block -
+					 ctx->curr_vcn + ctx->curr_lcn);
+}
+
+static grub_err_t
+read_data (struct grub_ntfs_attr *at, char *pa, char *dest,
+	   grub_disk_addr_t ofs, grub_size_t len, int cached,
+	   void (*read_hook) (grub_disk_addr_t sector,
+			      unsigned offset,
+			      unsigned length,
+			      void *closure),
+	   void *closure)
+{
+  grub_disk_addr_t vcn;
+  struct grub_ntfs_rlst cc, *ctx;
+
+  if (len == 0)
+    return 0;
+
+  grub_memset (&cc, 0, sizeof (cc));
+  ctx = &cc;
+  ctx->attr = at;
+  ctx->comp.spc = at->mft->data->spc;
+  ctx->comp.bs = at->mft->data->bs;
+
+  if (pa[8] == 0)
+    {
+      if (ofs + len > u32at (pa, 0x10))
+	return grub_error (GRUB_ERR_BAD_FS, "read out of range");
+      grub_memcpy (dest, pa + u32at (pa, 0x14) + ofs, len);
+      return 0;
+    }
+
+  if (u16at (pa, 0xC) & FLAG_COMPRESSED)
+    ctx->flags |= RF_COMP;
+  else
+    ctx->flags &= ~RF_COMP;
+  ctx->cur_run = pa + u16at (pa, 0x20);
+
+  if (ctx->flags & RF_COMP)
+    {
+      if (!cached)
+	return grub_error (GRUB_ERR_BAD_FS, "attribute can\'t be compressed");
+
+      if (at->sbuf)
+	{
+	  if ((ofs & (~(COM_LEN - 1))) == at->save_pos)
+	    {
+	      grub_disk_addr_t n;
+
+	      n = COM_LEN - (ofs - at->save_pos);
+	      if (n > len)
+		n = len;
+
+	      grub_memcpy (dest, at->sbuf + ofs - at->save_pos, n);
+	      if (n == len)
+		return 0;
+
+	      dest += n;
+	      len -= n;
+	      ofs += n;
+	    }
+	}
+      else
+	{
+	  at->sbuf = grub_malloc (COM_LEN);
+	  if (at->sbuf == NULL)
+	    return grub_errno;
+	  at->save_pos = 1;
+	}
+
+      vcn = ctx->target_vcn = (ofs >> COM_LOG_LEN) * (COM_SEC / ctx->comp.spc);
+      ctx->target_vcn &= ~0xF;
+    }
+  else
+    vcn = ctx->target_vcn = grub_divmod64 (ofs >> BLK_SHR, ctx->comp.spc, 0);
+
+  ctx->next_vcn = u32at (pa, 0x10);
+  ctx->curr_lcn = 0;
+  while (ctx->next_vcn <= ctx->target_vcn)
+    {
+      if (grub_ntfs_read_run_list (ctx))
+	return grub_errno;
+    }
+
+  if (at->flags & AF_GPOS)
+    {
+      grub_disk_addr_t st0, st1;
+      grub_uint32_t m;
+
+      grub_divmod64 (ofs >> BLK_SHR, ctx->comp.spc, &m);
+
+      st0 =
+	(ctx->target_vcn - ctx->curr_vcn + ctx->curr_lcn) * ctx->comp.spc + m;
+      st1 = st0 + 1;
+      if (st1 ==
+	  (ctx->next_vcn - ctx->curr_vcn + ctx->curr_lcn) * ctx->comp.spc)
+	{
+	  if (grub_ntfs_read_run_list (ctx))
+	    return grub_errno;
+	  st1 = ctx->curr_lcn * ctx->comp.spc;
+	}
+      v32at (dest, 0) = st0;
+      v32at (dest, 4) = st1;
+      return 0;
+    }
+
+  if (!(ctx->flags & RF_COMP))
+    {
+      unsigned int pow;
+
+      if (!grub_fshelp_log2blksize (ctx->comp.spc, &pow))
+	grub_fshelp_read_file (ctx->comp.bs, (grub_fshelp_node_t) ctx,
+			       read_hook, closure, ofs, len, dest,
+			       grub_ntfs_read_block, ofs + len, pow);
+      return grub_errno;
+    }
+
+  return (grub_ntfscomp_func) ? grub_ntfscomp_func (at, dest, ofs, len, ctx,
+						    vcn) :
+    grub_error (GRUB_ERR_BAD_FS, "ntfscomp module not loaded");
+}
+
+static grub_err_t
+read_attr (struct grub_ntfs_attr *at, char *dest, grub_disk_addr_t ofs,
+	   grub_size_t len, int cached,
+	   void (*read_hook) (grub_disk_addr_t sector,
+			      unsigned offset,
+			      unsigned length,
+			      void *closure),
+	   void *closure)
+{
+  DBG("read attr");
+  
+  char *save_cur;
+  unsigned char attr;
+  char *pp;
+  grub_err_t ret;
+
+  save_cur = at->attr_cur;
+  at->attr_nxt = at->attr_cur;
+  attr = (unsigned char) *at->attr_nxt;
+  if (at->flags & AF_ALST)
+    {
+      char *pa;
+      grub_disk_addr_t vcn;
+
+      vcn = grub_divmod64 (ofs, at->mft->data->spc << BLK_SHR, 0);
+      pa = at->attr_nxt + u16at (at->attr_nxt, 4);
+      while (pa < at->attr_end)
+	{
+	  if ((unsigned char) *pa != attr)
+	    break;
+	  if (u32at (pa, 8) > vcn)
+	    break;
+	  at->attr_nxt = pa;
+	  pa += u16at (pa, 4);
+	}
+    }
+  pp = find_attr (at, attr);
+  if (pp)
+    ret = read_data (at, pp, dest, ofs, len, cached, read_hook, closure);
+  else
+    ret =
+      (grub_errno) ? grub_errno : grub_error (GRUB_ERR_BAD_FS,
+					      "attribute not found");
+  at->attr_cur = save_cur;
+  return ret;
+}
+
+static grub_err_t
+read_mft (struct grub_ntfs_data *data, char *buf, grub_uint32_t mftno)
+{
+  if (read_attr
+      (&data->mmft.attr, buf, mftno * ((grub_disk_addr_t) data->mft_size) << BLK_SHR,
+       data->mft_size << BLK_SHR, 0, 0, 0))
+    return grub_error (GRUB_ERR_BAD_FS, "Read MFT 0x%X fails", mftno);
+  return fixup (data, buf, data->mft_size, (char*)"FILE");
+}
+
+static grub_err_t
+init_file (struct grub_ntfs_file *mft, grub_uint32_t mftno)
+{
+  DBG("init file");
+  
+  unsigned short flag;
+
+  mft->inode_read = 1;
+
+  mft->buf = grub_malloc (mft->data->mft_size << BLK_SHR);
+  if (mft->buf == NULL)
+    return grub_errno;
+
+  if (read_mft (mft->data, mft->buf, mftno))
+    return grub_errno;
+
+  flag = u16at (mft->buf, 0x16);
+  if ((flag & 1) == 0)
+    return grub_error (GRUB_ERR_BAD_FS, "MFT 0x%X is not in use", mftno);
+
+  if ((flag & 2) == 0)
+    {
+      char *pa;
+
+      pa = locate_attr (&mft->attr, mft, AT_DATA);
+      if (pa == NULL)
+	return grub_error (GRUB_ERR_BAD_FS, "no $DATA in MFT 0x%X", mftno);
+
+      if (!pa[8])
+	mft->size = u32at (pa, 0x10);
+      else
+	mft->size = u64at (pa, 0x30);
+
+      if ((mft->attr.flags & AF_ALST) == 0)
+	mft->attr.attr_end = 0;	/*  Don't jump to attribute list */
+    }
+  else
+    init_attr (&mft->attr, mft);
+
+  return 0;
+}
+
+static void
+free_file (struct grub_ntfs_file *mft)
+{
+  free_attr (&mft->attr);
+  grub_free (mft->buf);
+}
+
+static int
+list_file (struct grub_ntfs_file *diro, char *pos,
+	   int (*hook) (const char *filename,
+			enum grub_fshelp_filetype filetype,
+			grub_fshelp_node_t node,
+			void *closure),
+	   void *closure)
+{
+  char *np;
+  int ns;
+
+  while (1)
+    {
+      char *ustr, namespace;
+      char* gbstr;
+
+      if (pos[0xC] & 2)		/* end signature */
+	break;
+
+      np = pos + 0x50;
+      ns = (unsigned char) *(np++);
+      namespace = *(np++);
+
+      /*
+       *  Ignore files in DOS namespace, as they will reappear as Win32
+       *  names.
+       */
+      if ((ns) && (namespace != 2))
+	{
+	  enum grub_fshelp_filetype type;
+	  struct grub_ntfs_file *fdiro;
+
+	  if (u16at (pos, 4))
+	    {
+	      grub_error (GRUB_ERR_BAD_FS, "64-bit MFT number");
+	      return 0;
+	    }
+
+	  type =
+	    (u32at (pos, 0x48) & ATTR_DIRECTORY) ? GRUB_FSHELP_DIR :
+	    GRUB_FSHELP_REG;
+
+	  fdiro = grub_zalloc (sizeof (struct grub_ntfs_file));
+	  if (!fdiro)
+	    return 0;
+
+	  fdiro->data = diro->data;
+	  fdiro->ino = u32at (pos, 0);
+
+	  ustr = grub_malloc (ns * 4 + 1);
+	  gbstr = grub_malloc(ns * 2 + 1);
+	    if (ustr == NULL || gbstr == NULL)
+	    return 0;
+	  *grub_utf16_to_utf8 ((grub_uint8_t *) ustr, (grub_uint16_t *) np,
+			       ns) = '\0';
+	  u2g(ustr, strlen(ustr), gbstr, ns * 2 + 1);
+	  DBG("gbstr=%s", gbstr);
+          if (namespace)
+            type |= GRUB_FSHELP_CASE_INSENSITIVE;
+
+	  if (hook (gbstr, type, fdiro, closure))
+	    {
+	      grub_free (ustr);
+	      grub_free (gbstr);
+	      return 1;
+	    }
+	  grub_free(gbstr);
+	  grub_free (ustr);
+	}
+      pos += u16at (pos, 8);
+    }
+  return 0;
+}
+
+static int
+grub_ntfs_iterate_dir (grub_fshelp_node_t dir,
+		       int (*hook) (const char *filename,
+				    enum grub_fshelp_filetype filetype,
+				    grub_fshelp_node_t node,
+				    void *closure),
+		       void *closure)
+{
+  unsigned char *bitmap;
+  struct grub_ntfs_attr attr, *at;
+  char *cur_pos, *indx, *bmp;
+  int ret = 0;
+  grub_size_t bitmap_len;
+  struct grub_ntfs_file *mft;
+
+  mft = (struct grub_ntfs_file *) dir;
+
+  if (!mft->inode_read)
+    {
+      if (init_file (mft, mft->ino))
+	return 0;
+    }
+
+  indx = NULL;
+  bmp = NULL;
+
+  at = &attr;
+  init_attr (at, mft);
+  while (1)
+    {
+      if ((cur_pos = find_attr (at, AT_INDEX_ROOT)) == NULL)
+	{
+	  grub_error (GRUB_ERR_BAD_FS, "no $INDEX_ROOT");
+	  goto done;
+	}
+
+      /* Resident, Namelen=4, Offset=0x18, Flags=0x00, Name="$I30" */
+      if ((u32at (cur_pos, 8) != 0x180400) ||
+	  (u32at (cur_pos, 0x18) != 0x490024) ||
+	  (u32at (cur_pos, 0x1C) != 0x300033))
+	continue;
+      cur_pos += u16at (cur_pos, 0x14);
+      if (*cur_pos != 0x30)	/* Not filename index */
+	continue;
+      break;
+    }
+
+  cur_pos += 0x10;		/* Skip index root */
+  ret = list_file (mft, cur_pos + u16at (cur_pos, 0), hook, closure);
+  if (ret)
+    goto done;
+    
+
+  bitmap = NULL;
+  bitmap_len = 0;
+  free_attr (at);
+  init_attr (at, mft);
+  while ((cur_pos = find_attr (at, AT_BITMAP)) != NULL)
+    {
+      int ofs;
+
+      ofs = (unsigned char) cur_pos[0xA];
+      /* Namelen=4, Name="$I30" */
+      if ((cur_pos[9] == 4) &&
+	  (u32at (cur_pos, ofs) == 0x490024) &&
+	  (u32at (cur_pos, ofs + 4) == 0x300033))
+	{
+          int is_resident = (cur_pos[8] == 0);
+
+          bitmap_len = ((is_resident) ? u32at (cur_pos, 0x10) :
+                        u32at (cur_pos, 0x28));
+
+          bmp = grub_malloc (bitmap_len);
+          if (bmp == NULL)
+            goto done;
+
+	  if (is_resident)
+	    {
+              grub_memcpy (bmp, (char *) (cur_pos + u16at (cur_pos, 0x14)),
+                           bitmap_len);
+	    }
+          else
+            {
+              if (read_data (at, cur_pos, bmp, 0, bitmap_len, 0, 0, 0))
+                {
+                  grub_error (GRUB_ERR_BAD_FS,
+                              "fails to read non-resident $BITMAP");
+                  goto done;
+                }
+              bitmap_len = u32at (cur_pos, 0x30);
+            }
+
+          bitmap = (unsigned char *) bmp;
+	  break;
+	}
+    }
+
+  free_attr (at);
+  cur_pos = locate_attr (at, mft, AT_INDEX_ALLOCATION);
+  while (cur_pos != NULL)
+    {
+      /* Non-resident, Namelen=4, Offset=0x40, Flags=0, Name="$I30" */
+      if ((u32at (cur_pos, 8) == 0x400401) &&
+	  (u32at (cur_pos, 0x40) == 0x490024) &&
+	  (u32at (cur_pos, 0x44) == 0x300033))
+	break;
+      cur_pos = find_attr (at, AT_INDEX_ALLOCATION);
+    }
+
+  if ((!cur_pos) && (bitmap))
+    {
+      grub_error (GRUB_ERR_BAD_FS, "$BITMAP without $INDEX_ALLOCATION");
+      goto done;
+    }
+
+  if (bitmap)
+    {
+      grub_disk_addr_t v, i;
+
+      indx = grub_malloc (mft->data->idx_size << BLK_SHR);
+      if (indx == NULL)
+	goto done;
+
+      v = 1;
+      for (i = 0; i < (grub_disk_addr_t)bitmap_len * 8; i++)
+	{
+	  if (*bitmap & v)
+	    {
+	      if ((read_attr
+		   (at, indx, i * (mft->data->idx_size << BLK_SHR),
+		    (mft->data->idx_size << BLK_SHR), 0, 0, 0))
+		  || (fixup (mft->data, indx, mft->data->idx_size, (char*)"INDX")))
+		goto done;
+	      ret = list_file (mft, &indx[0x18 + u16at (indx, 0x18)], hook,
+			       closure);
+	      if (ret)
+		goto done;
+	    }
+	  v <<= 1;
+	  if (v >= 0x100)
+	    {
+	      v = 1;
+	      bitmap++;
+	    }
+	}
+    }
+
+done:
+  free_attr (at);
+  grub_free (indx);
+  grub_free (bmp);
+
+  return ret;
+}
+
+
+struct grub_ntfs_data *
+grub_ntfs_mount (BlockDriverState* bs, grub_uint32_t part_off_sector)
+{
+  struct grub_ntfs_bpb bpb;
+  struct grub_ntfs_data *data = 0;
+  grub_off_t off_bytes = (grub_off_t)part_off_sector << BLK_SHR; 
+  
+  if (!bs)
+    goto fail;
+
+  data = (struct grub_ntfs_data *) grub_zalloc (sizeof (*data));
+  if (!data)
+    goto fail;
+
+  data->bs = bs;
+
+  /* Read the BPB.  */
+  if (bdrv_pread (bs, off_bytes, &bpb, sizeof (bpb)) != sizeof(bpb))
+    {
+      DBG("read bpb err!");
+      goto fail;
+    }
+  if (grub_memcmp ((char *) &bpb.oem_name, "NTFS", 4))
+    {
+      DBG("bpb.oem_name=%s, not ntfs", bpb.oem_name);
+      goto fail;
+    }
+  data->blocksize = grub_le_to_cpu16 (bpb.bytes_per_sector);
+  data->spc = bpb.sectors_per_cluster * (data->blocksize >> BLK_SHR);
+
+  if (bpb.clusters_per_mft > 0)
+    data->mft_size = data->spc * bpb.clusters_per_mft;
+  else
+    data->mft_size = 1 << (-bpb.clusters_per_mft - BLK_SHR);
+
+  if (bpb.clusters_per_index > 0)
+    data->idx_size = data->spc * bpb.clusters_per_index;
+  else
+    data->idx_size = 1 << (-bpb.clusters_per_index - BLK_SHR);
+
+  data->mft_start = grub_le_to_cpu64 (bpb.mft_lcn) * data->spc;
+
+  if ((data->mft_size > MAX_MFT) || (data->idx_size > MAX_IDX))
+    goto fail;
+
+  data->mmft.data = data;
+  data->cmft.data = data;
+
+  data->mmft.buf = grub_malloc (data->mft_size << BLK_SHR);
+  if (!data->mmft.buf)
+    goto fail;
+
+  s_bpb_bytes_per_sector = (bpb.bytes_per_sector);
+  s_part_off_sector = part_off_sector;
+  DBG("bpb.bytes_per_sector=blocksize=%u\n"
+      "bpb.sector_per_cluster=%u\n"
+      "data->blocksize=%u\n"
+      "data->spc=%u\n"
+      "bpb.clusters_per_mft=%d\n"
+      "data->mft_size=%u\n"
+      "bpb.total_sectors=%zd\n"
+      "bpb.mft_lcn=%zd\n"
+      "data->mft_start=%u\n",
+      (bpb.bytes_per_sector), (bpb.sectors_per_cluster),
+      (data->blocksize), (data->spc),
+      (bpb.clusters_per_mft), (data->mft_size),
+      (bpb.num_total_sectors),
+      (grub_le_to_cpu64(bpb.mft_lcn)), (data->mft_start));
+  
+  off_bytes = (grub_off_t)data->mft_start << BLK_SHR;
+  grub_uint32_t len = data->mft_size << BLK_SHR;
+  if (bdrv_pread_from_lcn_of_volum(bs, off_bytes,
+		 data->mmft.buf, len) != len)
+    {
+      DBG("read mmft error!");
+      goto fail;
+    }
+  data->uuid = grub_le_to_cpu64 (bpb.num_serial);
+
+  if (fixup (data, data->mmft.buf, data->mft_size, (char*)"FILE"))
+    goto fail;
+
+  if (!locate_attr (&data->mmft.attr, &data->mmft, AT_DATA))
+    {
+      DBG("locate_attr AT_DATA in mmft failed! ");
+      goto fail;
+    }
+  if (init_file (&data->cmft, FILE_ROOT))
+    {
+      DBG("init_file FILE_ROOT failed!");
+      goto fail;
+    }
+  return data;
+
+fail:
+  grub_error (GRUB_ERR_BAD_FS, "not an ntfs filesystem");
+
+  if (data)
+    {
+      free_file (&data->mmft);
+      free_file (&data->cmft);
+      grub_free (data);
+    }
+  return 0;
+}
+
+struct grub_ntfs_dir_closure
+{
+  int (*hook) (const char *filename,
+	       const struct grub_dirhook_info *info,
+	       void *closure);
+  void *closure;
+  struct grub_ntfs_file file;
+};
+
+static int
+iterate (const char *filename,
+	 enum grub_fshelp_filetype filetype,
+	 grub_fshelp_node_t node,
+	 void *closure)
+{
+  struct grub_ntfs_dir_closure *c = closure;
+  struct grub_dirhook_info info;
+  grub_memset (&info, 0, sizeof (info));
+  info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
+  c->file.data = node->data;
+  c->file.ino = node->ino;
+  grub_free (node);
+  
+  
+  if(init_file(&c->file, c->file.ino))
+    {
+      errx(1, "iterate(): init_file error!\n");
+    }
+  else
+    {
+      DBG("......current file mft read successfully!\n");
+    }
+  char *pa = locate_attr(&c->file.attr,
+			 &c->file, AT_STANDARD_INFORMATION);
+  if(NULL == pa)
+    {
+      errx(2, "no $STANDARD_INFORMATION in MFT 0x%x\n", c->file.ino);
+    }
+  grub_uint64_t date= 0;
+  if(read_attr(&c->file.attr, (char*)&date, 0, 8, 1, NULL, NULL))
+    {
+      errx(3, "read date error\n");
+    }
+  else
+    {
+
+      info.time_ntfs = date;
+      DBG("......date: %zu\n", date);
+    }
+  DBG("......size of \'%s\': %zu\n", filename, (c->file.size));
+  info.filesize_ntfs = c->file.size;
+  free_file(&c->file);
+  return c->hook (filename, &info, c->closure);
+}
+
+
+#include "fs-time.h"
+static  int find_then_ls_hook(const char *filename,
+			   const struct grub_dirhook_info *info, void *closure)
+{
+  struct ls_ctrl* ctrl = (struct ls_ctrl*)closure;
+  DBG("detail=%d", ctrl->detail);
+  if('$' == *filename)
+    goto done;
+
+  printf("%s", filename);
+  if(!ctrl->detail)
+    {
+      printf("\n");
+      goto done;
+    }
+  else
+    {
+      printf("\t");
+    }
+  
+  char buffer[50]={};
+  struct tm tm0;  
+  struct tm* ptm= ntfs_utc2local(info->time_ntfs, &tm0);
+  if(NULL == ptm) errx(1, "ntfs_utc2local fail\n");
+           
+  printf("%zu\t", info->filesize_ntfs);
+  printf("%s\t", (info->dir ? "dir" : "file"));
+  strftime(buffer, 50, "%Y-%m-%d\t%H:%M:%S", ptm);
+  printf("%s", buffer);
+  //printf("%d-%d-%d\t", ptm->tm_year, ptm->tm_mon, ptm->tm_mday);
+  //printf("%d:%d:%d\t", ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
+  printf("\n");
+
+ done:
+  return 0;  // ×îÖÕ·µ»Ø¸øiterate
+}
+
+
+
+grub_err_t
+grub_ntfs_ls (grub_file_t file, const char *path,
+	       int (*hook) (const char *filename,
+			    const struct grub_dirhook_info *info,
+			    void *closure),
+	       void *closure)
+{
+  struct grub_ntfs_data *data = 0;
+  struct grub_fshelp_node *fdiro = 0;
+  struct grub_ntfs_dir_closure c = {0};
+
+  data = grub_ntfs_mount (file->bs, file->part_off_sector);
+  if (!data)
+    {
+      DBG("mount failed!");
+      goto fail;
+    }
+  grub_fshelp_find_file (path, &data->cmft, &fdiro, grub_ntfs_iterate_dir, 0,
+			 0, GRUB_FSHELP_DIR);
+
+  
+  if (grub_errno)
+    goto fail;
+
+  c.hook = (hook ? hook : find_then_ls_hook);
+  c.closure = closure;
+  grub_ntfs_iterate_dir (fdiro, iterate, &c);
+
+fail:
+  if ((fdiro) && (fdiro != &data->cmft))
+    {
+      free_file (fdiro);
+      grub_free (fdiro);
+    }
+  if (data)
+    {
+      free_file (&data->mmft);
+      free_file (&data->cmft);
+      grub_free (data);
+    }
+
+
+  return grub_errno;
+}
+
+grub_err_t
+grub_ntfs_open (grub_file_t file, const char *name)
+{
+  struct grub_ntfs_data *data = 0;
+  struct grub_fshelp_node *mft = 0;
+
+
+  data = grub_ntfs_mount (file->bs, file->part_off_sector);
+  if (!data)
+    {
+      DBG("mount failed!");
+      goto fail;
+    }
+  grub_fshelp_find_file (name, &data->cmft, &mft, grub_ntfs_iterate_dir, 0,
+			 0, GRUB_FSHELP_REG);
+
+  if (grub_errno)
+    goto fail;
+
+  if (mft != &data->cmft)
+    {
+      free_file (&data->cmft);
+      grub_memcpy (&data->cmft, mft, sizeof (*mft));
+      grub_free (mft);
+      if (!data->cmft.inode_read)
+	{
+	  if (init_file (&data->cmft, data->cmft.ino))
+	    goto fail;
+	}
+    }
+
+  file->size = data->cmft.size;
+  file->data = data;
+  file->offset = 0;
+
+  return 0;
+
+fail:
+  if (data)
+    {
+      free_file (&data->mmft);
+      free_file (&data->cmft);
+      grub_free (data);
+    }
+
+
+  return grub_errno;
+}
+
+grub_ssize_t
+grub_ntfs_read (grub_file_t file, grub_off_t offset, grub_size_t len, char *buf)
+{
+  struct grub_ntfs_file *mft;
+
+  mft = &((struct grub_ntfs_data *) file->data)->cmft;
+  if (file->read_hook)
+    mft->attr.save_pos = 1;
+  
+  read_attr (&mft->attr, buf, offset, len, 1,
+	     file->read_hook, file->closure);
+  
+  return (grub_errno) ? 0 : len;
+}
+
+grub_err_t
+grub_ntfs_close (grub_file_t file)
+{
+  struct grub_ntfs_data *data;
+
+  data = file->data;
+
+  if (data)
+    {
+      free_file (&data->mmft);
+      free_file (&data->cmft);
+      grub_free (data);
+    }
+
+
+  return grub_errno;
+}
+
+
+
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/ntfs.h xen-4.1.2-b/tools/ioemu-qemu-xen/ntfs.h
--- xen-4.1.2-a/tools/ioemu-qemu-xen/ntfs.h	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/ntfs.h	2012-12-28 16:02:41.014936701 +0800
@@ -0,0 +1,227 @@
+/* ntfs.h - header for the NTFS filesystem */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2007,2009  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GRUB_NTFS_H
+#define GRUB_NTFS_H	1
+
+
+#include "block_int.h"
+#include "fs-types.h"
+#include "grub_err.h"
+#include "fs-comm.h"
+
+#define FILE_MFT      0
+#define FILE_MFTMIRR  1
+#define FILE_LOGFILE  2
+#define FILE_VOLUME   3
+#define FILE_ATTRDEF  4
+#define FILE_ROOT     5
+#define FILE_BITMAP   6
+#define FILE_BOOT     7
+#define FILE_BADCLUS  8
+#define FILE_QUOTA    9
+#define FILE_UPCASE  10
+
+#define AT_STANDARD_INFORMATION	0x10
+#define AT_ATTRIBUTE_LIST	0x20
+#define AT_FILENAME		0x30
+#define AT_OBJECT_ID		0x40
+#define AT_SECURITY_DESCRIPTOR	0x50
+#define AT_VOLUME_NAME		0x60
+#define AT_VOLUME_INFORMATION	0x70
+#define AT_DATA			0x80
+#define AT_INDEX_ROOT		0x90
+#define AT_INDEX_ALLOCATION	0xA0
+#define AT_BITMAP		0xB0
+#define AT_SYMLINK		0xC0
+#define AT_EA_INFORMATION	0xD0
+#define AT_EA			0xE0
+
+#define ATTR_READ_ONLY		0x1
+#define ATTR_HIDDEN		0x2
+#define ATTR_SYSTEM		0x4
+#define ATTR_ARCHIVE		0x20
+#define ATTR_DEVICE		0x40
+#define ATTR_NORMAL		0x80
+#define ATTR_TEMPORARY		0x100
+#define ATTR_SPARSE		0x200
+#define ATTR_REPARSE		0x400
+#define ATTR_COMPRESSED		0x800
+#define ATTR_OFFLINE		0x1000
+#define ATTR_NOT_INDEXED	0x2000
+#define ATTR_ENCRYPTED		0x4000
+#define ATTR_DIRECTORY		0x10000000
+#define ATTR_INDEX_VIEW		0x20000000
+
+#define FLAG_COMPRESSED		1
+#define FLAG_ENCRYPTED		0x4000
+#define FLAG_SPARSE		0x8000
+
+
+#define GRUB_DISK_SECTOR_BITS   9
+#define BLK_SHR		GRUB_DISK_SECTOR_BITS
+
+#define MAX_MFT		(1024 >> BLK_SHR)
+#define MAX_IDX		(16384 >> BLK_SHR)
+
+#define COM_LEN		4096
+#define COM_LOG_LEN	12
+#define COM_SEC		(COM_LEN >> BLK_SHR)
+
+#define AF_ALST		1
+#define AF_MMFT		2
+#define AF_GPOS		4
+
+#define RF_COMP		1
+#define RF_CBLK		2
+#define RF_BLNK		4
+
+#define valueat(buf,ofs,type)	*((type*)(((char*)buf)+ofs))
+
+#define u16at(buf,ofs)	grub_le_to_cpu16(valueat(buf,ofs,grub_uint16_t))
+#define u32at(buf,ofs)	grub_le_to_cpu32(valueat(buf,ofs,grub_uint32_t))
+#define u64at(buf,ofs)	grub_le_to_cpu64(valueat(buf,ofs,grub_uint64_t))
+
+#define v16at(buf,ofs)	valueat(buf,ofs,grub_uint16_t)
+#define v32at(buf,ofs)	valueat(buf,ofs,grub_uint32_t)
+#define v64at(buf,ofs)	valueat(buf,ofs,grub_uint64_t)
+
+struct grub_ntfs_bpb
+{
+  grub_uint8_t jmp_boot[3];
+  grub_uint8_t oem_name[8];
+  grub_uint16_t bytes_per_sector;
+  grub_uint8_t sectors_per_cluster;
+  grub_uint8_t reserved_1[7];
+  grub_uint8_t media;
+  grub_uint16_t reserved_2;
+  grub_uint16_t sectors_per_track;
+  grub_uint16_t num_heads;
+  grub_uint32_t num_hidden_sectors;
+  grub_uint32_t reserved_3[2];
+  grub_uint64_t num_total_sectors;
+  grub_uint64_t mft_lcn;
+  grub_uint64_t mft_mirr_lcn;
+  grub_int8_t clusters_per_mft;
+  grub_int8_t reserved_4[3];
+  grub_int8_t clusters_per_index;
+  grub_int8_t reserved_5[3];
+  grub_uint64_t num_serial;
+  grub_uint32_t checksum;
+} __attribute__ ((packed));
+
+#define grub_ntfs_file grub_fshelp_node
+
+struct grub_ntfs_attr
+{
+  int flags;
+  char *emft_buf, *edat_buf;
+  char *attr_cur, *attr_nxt, *attr_end;
+  grub_uint32_t save_pos;
+  char *sbuf;
+  struct grub_ntfs_file *mft;
+};
+
+struct grub_fshelp_node
+{
+  struct grub_ntfs_data *data;
+  char *buf;
+  grub_uint64_t size;
+  grub_uint32_t ino;
+  int inode_read;
+  struct grub_ntfs_attr attr;
+};
+
+struct grub_ntfs_data
+{
+  struct grub_ntfs_file cmft;
+  struct grub_ntfs_file mmft;
+  BlockDriverState* bs;
+  grub_uint32_t mft_size;
+  grub_uint32_t idx_size;
+  grub_uint32_t spc;
+  grub_uint32_t blocksize;
+  grub_uint32_t mft_start;
+  grub_uint64_t uuid;
+};
+
+struct grub_ntfs_comp
+{
+  BlockDriverState* bs;
+  int comp_head, comp_tail;
+  grub_uint32_t comp_table[16][2];
+  grub_uint32_t cbuf_ofs, cbuf_vcn, spc;
+  char *cbuf;
+};
+
+struct grub_ntfs_rlst
+{
+  int flags;
+  grub_disk_addr_t target_vcn, curr_vcn, next_vcn, curr_lcn;
+  char *cur_run;
+  struct grub_ntfs_attr *attr;
+  struct grub_ntfs_comp comp;
+};
+
+
+
+
+
+
+
+typedef grub_err_t (*ntfscomp_func_t) (struct grub_ntfs_attr * at, char *dest,
+				       grub_uint32_t ofs, grub_uint32_t len,
+				       struct grub_ntfs_rlst * ctx,
+				       grub_uint32_t vcn);
+
+extern ntfscomp_func_t grub_ntfscomp_func;
+
+grub_err_t grub_ntfs_read_run_list (struct grub_ntfs_rlst *ctx);
+
+
+
+
+int bdrv_pread_from_lcn_of_volum(BlockDriverState *bs, int64_t offset,
+				 void *buf1, int count1);
+
+struct grub_ntfs_data *
+grub_ntfs_mount (BlockDriverState* bs, grub_uint32_t part_off_sector);
+
+
+grub_err_t
+grub_ntfs_ls (grub_file_t file, const char *path,
+	       int (*hook) (const char *filename,
+			    const struct grub_dirhook_info *info,
+			    void *closure),
+	      void *closure);
+
+grub_err_t
+grub_ntfs_open (grub_file_t file, const char *name);
+
+
+grub_ssize_t
+grub_ntfs_read (grub_file_t file, grub_off_t offset,
+		grub_size_t len, char *buf);
+
+
+grub_err_t
+grub_ntfs_close (grub_file_t file);
+
+
+#endif /* ! GRUB_NTFS_H */
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/partition.c xen-4.1.2-b/tools/ioemu-qemu-xen/partition.c
--- xen-4.1.2-a/tools/ioemu-qemu-xen/partition.c	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/partition.c	2012-12-28 16:02:41.014936701 +0800
@@ -0,0 +1,240 @@
+#include "partition.h"
+#include <err.h>
+
+static int is_full_zero(void *p, uint bytes)
+{
+  int i = 0;
+  uint8_t *p1 = (uint8_t*)p;
+  while(i < bytes)
+  {
+    if(*p1 != 0)
+    {
+      return 0;
+    }else
+    {
+      i++;
+      p1++;
+    }
+  }
+  //printf("..........full zero......\n");
+  return 1;
+}
+
+static void read_partition(uint8_t *p, struct partition_record *r)
+{
+    r->bootable = p[0];
+    r->start_head = p[1];
+    r->start_cylinder = p[3] | ((p[2] << 2) & 0x0300);
+    r->start_sector = p[2] & 0x3f;
+    r->system = p[4];
+    r->end_head = p[5];
+    r->end_cylinder = p[7] | ((p[6] << 2) & 0x300);
+    r->end_sector = p[6] & 0x3f;
+    r->start_sector_abs = p[8] | p[9] << 8 | p[10] << 16 | p[11] << 24;
+    r->nb_sectors_abs = p[12] | p[13] << 8 | p[14] << 16 | p[15] << 24;
+}
+
+
+
+char* judge_fs(ls_partition_t* pt)
+{
+  if(pt->part.system==0x0b || pt->part.system==0x01)
+    {
+      pt->fs_type = FS_FAT;
+      return (char*)"FAT32";
+    }
+  else if(pt->part.system==0x07)
+    {
+      pt->fs_type = FS_NTFS;
+      return (char*)"NTFS";
+    }
+  else
+    {
+      pt->fs_type = FS_UNKNOWN;
+      return  (char*)"UNKNOWN";
+    }
+}
+
+int enum_partition(BlockDriverState *bs, ls_partition_t* parts)
+{
+    struct partition_record mbr[4];
+    uint8_t data[512];
+    int i;
+    int ext_partnum = 4;
+    struct partition_record ext[10];
+    uint8_t data1[512];
+    int j = 0;
+
+    if (bdrv_read(bs, 0, data, 1))
+        errx(EINVAL, "error while reading");
+
+    if (data[510] != 0x55 || data[511] != 0xaa) 
+    {
+        errno = -EINVAL;
+        return -1;
+    }
+    
+    int k = 0;
+    for (i = 0; i < 4; i++) 
+    {
+        read_partition(&data[446 + 16 * i], &mbr[i]);
+
+        if (!mbr[i].nb_sectors_abs)
+            continue;
+	//printf("the %d partition:boot=0x%x, start=%u, system=0x%x, total=%u\t", 
+	//       i+1, mbr[i].bootable, mbr[i].start_sector_abs, mbr[i].system, mbr[i].nb_sectors_abs);
+	parts[k].part = mbr[i];
+	parts[k].id = i+1;
+	k++;
+        if (mbr[i].system == 0xF || mbr[i].system == 0x5) 
+	{
+	    //printf("is a extend partition......\n");
+	    if (bdrv_read(bs, mbr[i].start_sector_abs, data1, 1))
+                errx(EINVAL, "error while reading");
+	    ///////////////////////////
+	    //dump ebr
+	    ///////////////////////////
+	    uint32_t ext_start_sector = mbr[i].start_sector_abs;
+	    struct partition_record ext_next = {0};
+            while (1) 
+	    {
+	        read_partition(&data1[446 + 16 * 0], &ext[j]);
+		//printf("the %dth partition:boot=0x%x, start=%u, system=0x%x, total=%u\t",
+		//       ext_partnum+j+1, ext[j].bootable, ext[j].start_sector_abs+ext_start_sector, 
+		//       ext[j].system, ext[j].nb_sectors_abs);
+		
+		
+		if(0 != ext[j].nb_sectors_abs) 
+		{
+		  ext[j].start_sector_abs += ext_start_sector;
+		  if(j > 0)
+		    ext[j].start_sector_abs += ext_next.start_sector_abs;
+		  parts[k].part = ext[j];
+		  parts[k].id = ext_partnum + j +1;
+		  k++;
+		  j++;
+	        }
+		else
+		{
+		  printf("nb_sectors_abs=0>>>>>>>>>>>>\n");
+		}
+		//////////////////////
+		if(ext[j-1].system == 0xF )
+		  {
+		    printf("...............again extend.............\n");
+		    ext_start_sector = ext[j-1].start_sector_abs + ext_start_sector;
+		    if (bdrv_read(bs, ext_start_sector, data1, 1))
+		      errx(EINVAL, "error while reading");
+		    continue;
+		  }
+		else
+		  {
+		    ;//printf("is a logical part\n");
+		  }
+		/////////////////////
+		read_partition(&data1[446 + 16 * 1], &ext_next);
+		if (is_full_zero(&ext_next, sizeof(ext_next)))
+                    break;
+
+		if (bdrv_read(bs, ext_start_sector + ext_next.start_sector_abs , data1, 1))
+		  errx(EINVAL, "error while reading");
+	    }
+	}else
+	{
+	  ;//printf("is a main partition......\n");
+	}
+    }
+    
+    return k;
+}
+
+
+
+
+
+int find_partition(BlockDriverState *bs, int partition,
+                          off_t *offset, off_t *size)
+{
+    struct partition_record mbr[4];
+    uint8_t data[512];
+    int i;
+    int ext_partnum = 4;
+
+
+    if (bdrv_read(bs, 0, data, 1))
+        errx(EINVAL, "error while reading");
+
+    if (data[510] != 0x55 || data[511] != 0xaa) 
+    {
+        errno = -EINVAL;
+        return -1;
+    }
+    
+    int k = 0;
+    for (i = 0; i < 4; i++) 
+    {
+        read_partition(&data[446 + 16 * i], &mbr[i]);
+
+        if (!mbr[i].nb_sectors_abs)
+            continue;
+	//printf("the %d partition:", i+1);
+	
+        if (mbr[i].system == 0xF || mbr[i].system == 0x5) 
+	{
+	  //printf("is a extend partition......\n");
+            struct partition_record ext[10];
+            uint8_t data1[512];
+            int j = 0;
+
+            if (bdrv_read(bs, mbr[i].start_sector_abs, data1, 1))
+                errx(EINVAL, "error while reading");
+	    
+	    uint32_t ext_start_sector = mbr[i].start_sector_abs;
+	    struct partition_record ext_next = {0};
+            while (1) 
+	    {
+	        read_partition(&data1[446 + 16 * 0], &ext[j]);
+		printf("start=%u, total=%u, system=0x%x\t",
+		       ext[j].start_sector_abs, ext[j].nb_sectors_abs, ext[j].system);
+		printf("the %dth partition is a logical part\n", ext_partnum + j + 1);
+		
+		if(0 != ext[j].nb_sectors_abs) 
+		{
+		  if ((ext_partnum + j + 1) == partition) 
+		  {
+		    ext[j].start_sector_abs +=  ext_start_sector;
+		    if(j > 0)
+		      ext[j].start_sector_abs += ext_next.start_sector_abs;
+		    *offset = (uint64_t)ext[j].start_sector_abs << 9;
+		    *size = (uint64_t)ext[j].nb_sectors_abs << 9;
+		    return 0;
+		  }
+		  j++;
+	        }
+		
+		read_partition(&data1[446 + 16 * 1], &ext_next);
+		if (is_full_zero(&ext_next, sizeof(ext_next)))
+                    break;
+		//ext_start_sector += ext_next.start_sector_abs;
+		if (bdrv_read(bs, ext_start_sector + ext_next.start_sector_abs, data1, 1))
+		    errx(EINVAL, "error while reading");
+	    }
+            
+        } 
+	else 
+	{
+	  //printf("is a main partition......\n");
+	    if ((i + 1) == partition) 
+	    {
+	      *offset = (uint64_t)mbr[i].start_sector_abs << 9;
+	      *size = (uint64_t)mbr[i].nb_sectors_abs << 9;
+	      return 0;
+	    }
+	}
+    }
+
+    errno = -ENOENT;
+    return -1;
+}
+
+///////////////////////////////////////////////////////
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/partition.h xen-4.1.2-b/tools/ioemu-qemu-xen/partition.h
--- xen-4.1.2-a/tools/ioemu-qemu-xen/partition.h	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/partition.h	2012-12-28 16:02:41.015940225 +0800
@@ -0,0 +1,46 @@
+#ifndef _PARTITION_H
+#define _PARTITION_H
+
+#include <stdint.h>
+
+typedef struct partition_record
+{
+    uint8_t bootable;
+    uint8_t start_head;
+    uint32_t start_cylinder;
+    uint8_t start_sector;
+    uint8_t system;
+    uint8_t end_head;
+    uint8_t end_cylinder;
+    uint8_t end_sector;
+    uint32_t start_sector_abs;
+    uint32_t nb_sectors_abs;
+} __attribute__ ((packed)) part_record_t;
+
+
+
+typedef enum
+  {
+    FS_UNKNOWN = 0,
+    FS_FAT,
+    FS_NTFS
+  }FS_TYPE;
+
+typedef struct ls_partition
+{
+  part_record_t part;
+  int id;
+  FS_TYPE fs_type;
+}ls_partition_t;
+
+
+char* judge_fs(ls_partition_t* pt);
+
+#include "block_int.h"
+int enum_partition(BlockDriverState *bs, ls_partition_t* parts);
+
+int find_partition(BlockDriverState *bs, int partition,
+		   off_t *offset, off_t *size);
+
+
+#endif
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/qemu-img.c xen-4.1.2-b/tools/ioemu-qemu-xen/qemu-img.c
--- xen-4.1.2-a/tools/ioemu-qemu-xen/qemu-img.c	2011-02-12 01:54:51.000000000 +0800
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/qemu-img.c	2012-12-28 16:02:41.016932622 +0800
@@ -20,23 +20,35 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
 #include "qemu-common.h"
 #include "osdep.h"
 #include "block_int.h"
 #include <assert.h>
+#include <err.h>
+
+
+#include "partition.h"
+#include "fs-comm.h"
+#include "fat.h"
+#include "ntfs.h"
+#include "misc.h"
+
+
+
 
 #ifdef _WIN32
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #endif
 
 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
+#define MAX_PARTITIONS    20
 #define BRDV_O_FLAGS BDRV_O_CACHE_WB
 
 static void QEMU_NORETURN error(const char *fmt, ...)
 {
     va_list ap;
     va_start(ap, fmt);
     fprintf(stderr, "qemu-img: ");
     vfprintf(stderr, fmt, ap);
@@ -53,16 +65,18 @@ static void format_print(void *opaque, c
 /* Please keep in synch with qemu-img.texi */
 static void help(void)
 {
     printf("qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
            "usage: qemu-img command [command options]\n"
            "QEMU disk image utility\n"
            "\n"
            "Command syntax:\n"
+           "  ls [-v] [[-l] -d directory] imgfile\n"
+           "  cat [-v] -f file imgfile\n"
            "  create [-e] [-6] [-b base_image] [-f fmt] filename [size]\n"
            "  commit [-f fmt] filename\n"
            "  convert [-c] [-e] [-6] [-f fmt] [-O output_fmt] [-B output_base_image] filename [filename2 [...]] output_filename\n"
            "  info [-f fmt] filename\n"
            "  snapshot [-l | -a snapshot | -c snapshot | -d snapshot] filename\n"
            "\n"
            "Command parameters:\n"
            "  'filename' is a disk image filename\n"
@@ -209,16 +223,343 @@ static BlockDriverState *bdrv_new_open(c
         if (read_password(password, sizeof(password)) < 0)
             error("No password given");
         if (bdrv_set_key(bs, password) < 0)
             error("invalid password");
     }
     return bs;
 }
 
+static void get_partition_path(const char *dir, int *which_part, char **path)
+{
+    static char full_path[512];
+    char part[5]={};
+
+    strncpy(full_path, dir, 512);
+    full_path[511] = '\0';
+
+    //ÏÞÖÆÒÔ/¿ªÍ· ½áÎ²
+    char *p1 = full_path + 1;
+    char *p2 = strchr(full_path + 1, '/');
+    if(!p2)
+    {
+        errx(1, "check the file path!\n");
+    }
+
+    *path = p2;
+    strncpy(part, p1, p2-p1);
+    *which_part = atoi(part);
+}
+
+typedef struct grub_fs
+{
+    grub_open open;
+    grub_ls ls;
+    grub_read read;
+    grub_close close;
+}grub_fs_t;
+
+static grub_fs_t grub_fs_plug[10] = {};
+
+static void grub_fs_plugin(void)
+{
+  grub_fs_plug[FS_FAT].open = grub_fat_open;
+  grub_fs_plug[FS_FAT].read = grub_fat_read;
+  grub_fs_plug[FS_FAT].close = grub_fat_close;
+  grub_fs_plug[FS_FAT].ls = grub_fat_ls;
+
+  grub_fs_plug[FS_NTFS].open = grub_ntfs_open;
+  grub_fs_plug[FS_NTFS].read = grub_ntfs_read;
+  grub_fs_plug[FS_NTFS].close = grub_ntfs_close;
+  grub_fs_plug[FS_NTFS].ls = grub_ntfs_ls;
+}
+
+static int img_ls(int argc, char **argv)
+{
+    int c = -1;
+    char *imgfile = NULL;
+    char *dir = NULL;
+    char verbose = 0;
+    struct ls_ctrl ctrl={};
+
+    for(;;) 
+    {
+        c = getopt(argc, argv, "d:hlv");
+        if (c == -1)
+            break;
+
+        switch(c) 
+        {
+            case 'v':
+                verbose = 1;
+                break;
+            case 'l':
+                ctrl.detail = 1;
+                break;
+            case 'h':
+                help();
+                break;
+            case 'd':
+                dir = optarg;
+                break;
+            default:
+                break;
+        }
+    }
+    
+    imgfile = argv[optind++];
+    
+    if (optind > argc)
+      help();
+    
+    BlockDriverState *bs = bdrv_new("");
+    if(!bs)
+        error("Not enough memory for bdrv_new\n");
+    if(bdrv_open(bs, imgfile, BRDV_O_FLAGS) < 0)
+        error("Could not open '%s'\n", imgfile);
+    
+    off_t off_bytes = 0;
+    off_t size_bytes = 0;
+    int i = 0;
+    ls_partition_t* parts = (ls_partition_t*)malloc(MAX_PARTITIONS * sizeof(ls_partition_t));
+    int count = enum_partition(bs, parts);
+    
+    if(!dir)
+    {
+        //find_partition(bs, 15, &off_bytes, &size_bytes);
+        printf("id\tactive\ttype\tfs\tstart_sector\ttotal_sectors\n");
+        for(i = 0; i < count; i++)
+        {
+            printf("%d\t%s\t%s\t%s\t%u\t%u\n", 
+                   parts[i].id, 
+                   parts[i].part.bootable==0x80 ? "active" : "none-active",
+                   (parts[i].part.system==0x0f || parts[i].part.system==0x05) ? "extend" : (parts[i].id>=5 ? "logical" : "primary"),
+                   judge_fs(&parts[i]),
+                   parts[i].part.start_sector_abs,
+                   parts[i].part.nb_sectors_abs
+                   );
+        }
+
+        goto fail;
+    }
+    else
+    {
+        grub_fs_plugin();
+      
+        grub_file_t file = NULL;
+        char *path = NULL;
+        int which_part = 1;
+      
+        file = (grub_file_t)malloc(sizeof(*file));
+        file->bs = bs;
+        file->data = NULL;
+
+        if('/' != dir[strlen(dir) - 1])
+            strcat(dir, "/");
+
+        get_partition_path(dir, &which_part, &path);
+        if(which_part < 1 || which_part > count)
+        {
+            fprintf(stderr, "error: check the partition number!\n");
+            goto fail;
+        }
+
+        file->part_off_sector = parts[which_part - 1].part.start_sector_abs;
+        ctrl.dirname = dir;
+        printf("¡¾name\t"
+               "size(bytes)\t"
+               "dir?\t"
+               "date\t"
+               "time¡¿\n");
+
+        judge_fs(&parts[which_part - 1]);
+        FS_TYPE fs_type = parts[which_part - 1].fs_type;
+        if (fs_type == FS_UNKNOWN) 
+        {
+            errx(1, "unknown file system!\n");
+        }
+
+        grub_fs_plug[fs_type].ls(file, path, NULL, (void*)&ctrl);
+        file->data ? free(file->data) : 0;
+        free(file);
+    }
+    
+    
+  fail:
+    bdrv_delete(bs);
+    free(parts);
+    return 0;
+}
+
+
+
+static int img_cat(int argc, char **argv)
+{
+    int c = -1;
+    char *imgfile = NULL;
+    char *filename = NULL;
+    char verbose = 0;
+
+    for(;;) {
+        c = getopt(argc, argv, "f:hv");
+        if (c == -1)
+            break;
+        switch(c) {
+            case 'v':
+                verbose = 1;
+                break;
+            case 'h':
+                help();
+                break;
+            case 'f':
+                filename = optarg;
+                break;
+            default:
+                break;
+        }
+    }
+    
+    imgfile = argv[optind++];
+    if (optind > argc)
+        help();
+
+    
+    if(!filename)
+    {
+        printf("error: specific the file to show!\n");
+        return -1;
+    }
+        
+    BlockDriverState *bs = bdrv_new("");
+    if(!bs)
+        errx(-1, "Not enough memory for bdrv_new\n");
+    if(bdrv_open(bs, imgfile, BRDV_O_FLAGS) < 0)
+        errx(-1, "Could not open %s\n", imgfile);
+    
+
+    uint buf_size = 4096;
+    char* buf = (char*)malloc(buf_size);
+    off_t off_bytes = 0;
+    off_t size_bytes = 0;
+    int i = 0;
+    ls_partition_t *parts = (ls_partition_t*)malloc(MAX_PARTITIONS * sizeof(ls_partition_t));
+    int count = enum_partition(bs, parts);
+    
+       
+    {
+        grub_fs_plugin();
+
+        grub_file_t file = NULL;
+        char *path = NULL;
+        int which_part = 1;
+      
+        file = (grub_file_t)malloc(sizeof(*file));
+        file->bs = bs;
+        file->data = NULL;
+      
+        char* p = strchr(filename, '/');
+        if(!p)
+        {
+            errx(-1, "please check the file path!\n");
+        }
+        else
+        {
+            p = strchr(p, '/');
+            if(!p) errx(-1, "check the file path!!\n");
+        }
+	  
+        get_partition_path(filename, &which_part, &path);
+        DBG("part=%d, path=%s", which_part, path);
+        if(which_part < 1 || which_part > count)
+        {
+            printf("error: check the partition number!\n");
+            goto fail;
+        }
+        file->part_off_sector = parts[which_part - 1].part.start_sector_abs;
+        judge_fs(&parts[which_part - 1]);
+        FS_TYPE fs_type = parts[which_part - 1].fs_type;
+        (fs_type == FS_UNKNOWN) ? errx(1, "unknown file system!\n") : 0;
+        grub_fs_t grub_fs_plg = grub_fs_plug[fs_type];
+   
+        if(grub_fs_plg.open(file, path) == 0)
+        {
+            //printf("file size=%zd bytes\n", (file->size));
+	  
+            grub_size_t len = file->size;
+            grub_off_t off = 0;
+            char  tmpfile[256]={};
+            strncpy(tmpfile, getenv("HOME"), sizeof(tmpfile));
+            tmpfile[sizeof(tmpfile) - 1] = '\0';
+            strcat(tmpfile, "/tmp.file");
+	    
+            if(!buf)
+            {
+                perror("not enough memory!\n");
+                goto fail;
+            }
+            else
+            {
+                grub_size_t readed = 0;
+                grub_size_t left  = len;
+                grub_size_t total = 0;
+                FILE* f = fopen(tmpfile ,"w");
+                if(!f)
+                {
+                    perror("fopen error");
+                    goto fail;
+                }
+	      
+	      
+                (left > buf_size) ? (left = buf_size) : 0;
+                while((readed = grub_fs_plg.read(file, off, left, buf))
+                      && total <= len
+                      && readed > 0)
+                {
+                    DBG("readed=%zd", readed);
+                    total += fwrite(buf, 1, readed, f);
+                    off = total;
+                    left = len - total;
+                    (left <= buf_size) ? 0  : (left = buf_size);
+                    DBG("total=%zd", total);
+                };
+                fclose(f);
+	      
+                if(total != len)
+                {
+                    perror("read error");
+                    goto fail;
+                }
+                else
+                {
+                    sprintf(buf, "cat %s", tmpfile);
+                    system(buf);
+  
+                }
+            }
+        }
+        else
+        {
+            printf("open failed!\n");
+        }
+      
+      
+        grub_fs_plg.close(file);
+        free(file);
+    }
+    
+    
+  fail:
+    free(buf);
+    bdrv_delete(bs);
+    free(parts);
+    return 0;
+}
+
+
+
 static int img_create(int argc, char **argv)
 {
     int c, ret, flags;
     const char *fmt = "raw";
     const char *filename;
     const char *base_filename = NULL;
     uint64_t size;
     const char *p;
@@ -850,16 +1191,17 @@ static void img_snapshot(int argc, char 
     }
 
     /* Cleanup */
     bdrv_delete(bs);
 }
 
 int main(int argc, char **argv)
 {
+  
     const char *cmd;
 
     bdrv_init();
     if (argc < 2)
         help();
     cmd = argv[1];
     argc--; argv++;
     if (!strcmp(cmd, "create")) {
@@ -867,13 +1209,19 @@ int main(int argc, char **argv)
     } else if (!strcmp(cmd, "commit")) {
         img_commit(argc, argv);
     } else if (!strcmp(cmd, "convert")) {
         img_convert(argc, argv);
     } else if (!strcmp(cmd, "info")) {
         img_info(argc, argv);
     } else if (!strcmp(cmd, "snapshot")) {
         img_snapshot(argc, argv);
-    } else {
+    } else if (!strcmp(cmd, "ls")) {
+        img_ls(argc, argv);    
+    } else if (!strcmp(cmd, "cat")) {
+        img_cat(argc, argv);
+    }
+    else {
         help();
     }
+    
     return 0;
 }
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/types.h xen-4.1.2-b/tools/ioemu-qemu-xen/types.h
--- xen-4.1.2-a/tools/ioemu-qemu-xen/types.h	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/types.h	2012-12-28 16:02:41.016932622 +0800
@@ -0,0 +1,35 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2002,2006,2007  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GRUB_TYPES_CPU_HEADER
+#define GRUB_TYPES_CPU_HEADER	1
+
+/* The size of void *.  */
+#define GRUB_TARGET_SIZEOF_VOID_P	4
+
+/* The size of long.  */
+#define GRUB_TARGET_SIZEOF_LONG		4
+
+/* i386 is little-endian.  */
+#undef GRUB_TARGET_WORDS_BIGENDIAN
+
+#define GRUB_TARGET_I386		1
+
+#define GRUB_TARGET_MIN_ALIGN		1
+
+#endif /* ! GRUB_TYPES_CPU_HEADER */
diff --exclude=.svn -rpN -U8 xen-4.1.2-a/tools/ioemu-qemu-xen/x86_64/types.h xen-4.1.2-b/tools/ioemu-qemu-xen/x86_64/types.h
--- xen-4.1.2-a/tools/ioemu-qemu-xen/x86_64/types.h	1970-01-01 07:00:00.000000000 +0700
+++ xen-4.1.2-b/tools/ioemu-qemu-xen/x86_64/types.h	2012-12-28 16:02:41.017802371 +0800
@@ -0,0 +1,39 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GRUB_TYPES_CPU_HEADER
+#define GRUB_TYPES_CPU_HEADER	1
+
+/* The size of void *.  */
+#define GRUB_TARGET_SIZEOF_VOID_P	8
+
+/* The size of long.  */
+#ifdef __MINGW32__
+#define GRUB_TARGET_SIZEOF_LONG		4
+#else
+#define GRUB_TARGET_SIZEOF_LONG		8
+#endif
+
+/* x86_64 is little-endian.  */
+#undef GRUB_TARGET_WORDS_BIGENDIAN
+
+#define GRUB_TARGET_X86_64		1
+
+#define GRUB_TARGET_MIN_ALIGN		1
+
+#endif /* ! GRUB_TYPES_CPU_HEADER */
