WARNING - OLD ARCHIVES

This is an archived copy of the Xen.org mailing list, which we have preserved to ensure that existing links to archives are not broken. The live archive, which contains the latest emails, can be found at http://lists.xen.org/
   
 
 
Xen 
 
Home Products Support Community News
 
   
 

xen-changelog

[Xen-changelog] [xen-unstable] merge

# HG changeset patch
# User kfraser@xxxxxxxxxxxxxxxxxxxxx
# Date 1168266417 0
# Node ID 5eeb4bac1b173d972f16f031fc8fa264c186cc5a
# Parent  037f49cd8016405d290b37a2352fef4d6663329e
# Parent  a06ee98fa3b67fd59bbf900e8feb7f60aaa45075
merge
---
 tools/firmware/rombios/rombios.c |  475 ++++++++++++++++++++++++---------------
 tools/ioemu/hw/pc.c              |    2 
 tools/ioemu/vl.c                 |    2 
 3 files changed, 306 insertions(+), 173 deletions(-)

diff -r 037f49cd8016 -r 5eeb4bac1b17 tools/firmware/rombios/rombios.c
--- a/tools/firmware/rombios/rombios.c  Mon Jan 08 14:25:28 2007 +0000
+++ b/tools/firmware/rombios/rombios.c  Mon Jan 08 14:26:57 2007 +0000
@@ -278,7 +278,6 @@ typedef unsigned short bx_bool;
 typedef unsigned short bx_bool;
 typedef unsigned long  Bit32u;
 
-#if BX_USE_ATADRV
 
   void memsetb(seg,offset,value,count);
   void memcpyb(dseg,doffset,sseg,soffset,count);
@@ -418,7 +417,6 @@ typedef unsigned long  Bit32u;
   ASM_END
   }
 #endif
-#endif //BX_USE_ATADRV
 
   // read_dword and write_dword functions
   static Bit32u         read_dword();
@@ -728,6 +726,8 @@ typedef struct {
   //     The EBDA structure should conform to 
   //     http://www.cybertrails.com/~fys/rombios.htm document
   //     I made the ata and cdemu structs begin at 0x121 in the EBDA seg
+  // EBDA must be at most 768 bytes; it lives at 0x9fc00, and the boot 
+  // device tables are at 0x9ff00 -- 0x9ffff
   typedef struct {
     unsigned char filler1[0x3D];
 
@@ -885,7 +885,7 @@ static void           int15_function();
 static void           int15_function();
 static void           int16_function();
 static void           int17_function();
-static Bit32u         int19_function();
+static void           int19_function();
 static void           int1a_function();
 static void           int70_function();
 static void           int74_function();
@@ -1854,28 +1854,100 @@ print_bios_banner()
   printf("\n");
 }
 
+
+//--------------------------------------------------------------------------
+// BIOS Boot Specification 1.0.1 compatibility
+//
+// Very basic support for the BIOS Boot Specification, which allows expansion 
+// ROMs to register themselves as boot devices, instead of just stealing the 
+// INT 19h boot vector.
+// 
+// This is a hack: to do it properly requires a proper PnP BIOS and we aren't
+// one; we just lie to the option ROMs to make them behave correctly. 
+// We also don't support letting option ROMs register as bootable disk 
+// drives (BCVs), only as bootable devices (BEVs). 
+//
+// 
http://www.phoenix.com/en/Customer+Services/White+Papers-Specs/pc+industry+specifications.htm
+//--------------------------------------------------------------------------
+
+/* 256 bytes at 0x9ff00 -- 0x9ffff is used for the IPL boot table. */
+#define IPL_SEG              0x9ff0
+#define IPL_TABLE_OFFSET     0x0000
+#define IPL_TABLE_ENTRIES    8
+#define IPL_COUNT_OFFSET     0x0080  /* u16: number of valid table entries */
+#define IPL_SEQUENCE_OFFSET  0x0082  /* u16: next boot device */
+
+struct ipl_entry {
+  Bit16u type;
+  Bit16u flags;
+  Bit32u vector;
+  Bit32u description;
+  Bit32u reserved;
+};
+
+static void 
+init_boot_vectors() 
+{
+  struct ipl_entry e; 
+  Bit16u count = 0;
+  Bit16u ss = get_SS();
+
+  /* Clear out the IPL table. */
+  memsetb(IPL_SEG, IPL_TABLE_OFFSET, 0, 0xff);
+
+  /* Floppy drive */
+  e.type = 1; e.flags = 0; e.vector = 0; e.description = 0; e.reserved = 0;
+  memcpyb(IPL_SEG, IPL_TABLE_OFFSET + count * sizeof (e), ss, &e, sizeof (e));
+  count++;
+
+  /* First HDD */
+  e.type = 2; e.flags = 0; e.vector = 0; e.description = 0; e.reserved = 0;
+  memcpyb(IPL_SEG, IPL_TABLE_OFFSET + count * sizeof (e), ss, &e, sizeof (e));
+  count++;
+
+#if BX_ELTORITO_BOOT
+  /* CDROM */
+  e.type = 3; e.flags = 0; e.vector = 0; e.description = 0; e.reserved = 0;
+  memcpyb(IPL_SEG, IPL_TABLE_OFFSET + count * sizeof (e), ss, &e, sizeof (e));
+  count++;
+#endif  
+
+  /* Remember how many devices we have */
+  write_word(IPL_SEG, IPL_COUNT_OFFSET, count);
+  /* Not tried booting anything yet */
+  write_word(IPL_SEG, IPL_SEQUENCE_OFFSET, 0xffff);
+}
+
+static Bit8u
+get_boot_vector(i, e)
+Bit16u i; struct ipl_entry *e; 
+{
+  Bit16u count;
+  Bit16u ss = get_SS();
+  /* Get the count of boot devices, and refuse to overrun the array */
+  count = read_word(IPL_SEG, IPL_COUNT_OFFSET);
+  if (i >= count) return 0;
+  /* OK to read this device */
+  memcpyb(ss, e, IPL_SEG, IPL_TABLE_OFFSET + i * sizeof (*e), sizeof (*e));
+  return 1;
+}
+
+
 //--------------------------------------------------------------------------
 // print_boot_device
 //   displays the boot device
 //--------------------------------------------------------------------------
 
-static char drivetypes[][10]={"Floppy","Hard Disk","CD-Rom"};
+static char drivetypes[][10]={"", "Floppy","Hard Disk","CD-Rom", "Network"};
 
 void
-print_boot_device(cdboot, drive)
-  Bit8u cdboot; Bit16u drive;
+print_boot_device(type)
+  Bit16u type;
 {
-  Bit8u i;
-
-  // cdboot contains 0 if floppy/harddisk, 1 otherwise
-  // drive contains real/emulated boot drive
-
-  if(cdboot)i=2;                    // CD-Rom
-  else if((drive&0x0080)==0x00)i=0; // Floppy
-  else if((drive&0x0080)==0x80)i=1; // Hard drive
-  else return;
-  
-  printf("Booting from %s...\n",drivetypes[i]);
+  /* NIC appears as type 0x80 */ 
+  if (type == 0x80 ) type = 0x4;
+  if (type == 0 || type > 0x4) BX_PANIC("Bad drive type\n"); 
+  printf("Booting from %s...\n", drivetypes[type]);
 }
 
 //--------------------------------------------------------------------------
@@ -1883,29 +1955,20 @@ print_boot_device(cdboot, drive)
 //   displays the reason why boot failed
 //--------------------------------------------------------------------------
   void
-print_boot_failure(cdboot, drive, reason, lastdrive)
-  Bit8u cdboot; Bit8u drive; Bit8u lastdrive;
+print_boot_failure(type, reason)
+  Bit16u type; Bit8u reason;
 {
-  Bit16u drivenum = drive&0x7f;
-
-  // cdboot: 1 if boot from cd, 0 otherwise
-  // drive : drive number
-  // reason: 0 signature check failed, 1 read error
-  // lastdrive: 1 boot drive is the last one in boot sequence
- 
-  if (cdboot)
-    bios_printf(BIOS_PRINTF_INFO | BIOS_PRINTF_SCREEN, "Boot from %s 
failed\n",drivetypes[2]);
-  else if (drive & 0x80)
-    bios_printf(BIOS_PRINTF_INFO | BIOS_PRINTF_SCREEN, "Boot from %s %d 
failed\n", drivetypes[1],drivenum);
+  if (type == 0 || type > 0x3) BX_PANIC("Bad drive type\n"); 
+
+  printf("Boot from %s failed", drivetypes[type]);
+  if (type < 4) {
+    /* Report the reason too */
+  if (reason==0) 
+    printf(": not a bootable disk");
   else
-    bios_printf(BIOS_PRINTF_INFO | BIOS_PRINTF_SCREEN, "Boot from %s %d 
failed\n", drivetypes[0],drivenum);
-
-  if (lastdrive==1) {
-    if (reason==0)
-      BX_PANIC("Not a bootable disk\n");
-    else
-      BX_PANIC("Could not read the boot disk\n");
+    printf(": could not read the boot disk");
   }
+  printf("\n");
 }
 
 //--------------------------------------------------------------------------
@@ -7553,19 +7616,19 @@ int17_function(regs, ds, iret_addr)
   }
 }
 
-// returns bootsegment in ax, drive in bl
-  Bit32u 
-int19_function(bseqnr)
-Bit8u bseqnr;
+void
+int19_function(seq_nr)
+Bit16u seq_nr;
 {
   Bit16u ebda_seg=read_word(0x0040,0x000E);
-  Bit16u bootseq;
+  Bit16u bootdev;
   Bit8u  bootdrv;
-  Bit8u  bootcd;
   Bit8u  bootchk;
   Bit16u bootseg;
+  Bit16u bootip;
   Bit16u status;
-  Bit8u  lastdrive=0;
+
+  struct ipl_entry e;
 
   // if BX_ELTORITO_BOOT is not defined, old behavior
   //   check bit 5 in CMOS reg 0x2d.  load either 0x00 or 0x80 into DL
@@ -7582,62 +7645,54 @@ Bit8u bseqnr;
   //     0x01 : first floppy 
   //     0x02 : first harddrive
   //     0x03 : first cdrom
+  //     0x04 - 0x0f : PnP expansion ROMs (e.g. Etherboot)
   //     else : boot failure
 
   // Get the boot sequence
 #if BX_ELTORITO_BOOT
-  bootseq=inb_cmos(0x3d);
-  bootseq|=((inb_cmos(0x38) & 0xf0) << 4);
-
-  if (bseqnr==2) bootseq >>= 4;
-  if (bseqnr==3) bootseq >>= 8;
-  if (bootseq<0x10) lastdrive = 1;
-  bootdrv=0x00; bootcd=0;
-  switch(bootseq & 0x0f) {
-    case 0x01: bootdrv=0x00; bootcd=0; break;
-    case 0x02: bootdrv=0x80; bootcd=0; break;
-    case 0x03: bootdrv=0x00; bootcd=1; break;
-    default:   return 0x00000000;
-    }
-#else
-  bootseq=inb_cmos(0x2d);
-
-  if (bseqnr==2) {
-    bootseq ^= 0x20;
-    lastdrive = 1;
+  bootdev = inb_cmos(0x3d);
+  bootdev |= ((inb_cmos(0x38) & 0xf0) << 4);
+  bootdev >>= 4 * seq_nr;
+  bootdev &= 0xf;
+  if (bootdev == 0) BX_PANIC("No bootable device.\n");
+  
+  /* Translate from CMOS runes to an IPL table offset by subtracting 1 */
+  bootdev -= 1;
+#else  
+  if (seq_nr ==2) BX_PANIC("No more boot devices.");
+  if (!!(inb_cmos(0x2d) & 0x20) ^ (seq_nr == 1)) 
+      /* Boot from floppy if the bit is set or it's the second boot */
+    bootdev = 0x00;
+  else 
+    bootdev = 0x01;
+#endif
+
+  /* Read the boot device from the IPL table */
+  if (get_boot_vector(bootdev, &e) == 0) {
+    BX_INFO("Invalid boot device (0x%x)\n", bootdev);
+    return;
   }
-  bootdrv=0x00; bootcd=0;
-  if((bootseq&0x20)==0) bootdrv=0x80;
-#endif // BX_ELTORITO_BOOT
-
-#if BX_ELTORITO_BOOT
-  // We have to boot from cd
-  if (bootcd != 0) {
-    status = cdrom_boot();
-
-    // If failure
-    if ( (status & 0x00ff) !=0 ) {
-      print_cdromboot_failure(status);
-      print_boot_failure(bootcd, bootdrv, 1, lastdrive);
-      return 0x00000000;
-      }
-
-    bootseg = read_word(ebda_seg,&EbdaData->cdemu.load_segment);
-    bootdrv = (Bit8u)(status>>8);
-    }
-
-#endif // BX_ELTORITO_BOOT
-
-  // We have to boot from harddisk or floppy
-  if (bootcd == 0) {
-    bootseg=0x07c0;
+
+  /* Do the loading, and set up vector as a far pointer to the boot
+   * address, and bootdrv as the boot drive */
+  print_boot_device(e.type);
+
+  switch(e.type) {
+  case 0x01: /* FDD */
+  case 0x02: /* HDD */
+
+    bootdrv = (e.type == 0x02) ? 0x80 : 0x00;
+    bootseg = 0x07c0;
+    status = 0;
 
 ASM_START
     push bp
     mov  bp, sp
-
-    mov  ax, #0x0000
-    mov  _int19_function.status + 2[bp], ax
+    push ax
+    push bx
+    push cx
+    push dx
+
     mov  dl, _int19_function.bootdrv + 2[bp]
     mov  ax, _int19_function.bootseg + 2[bp]
     mov  es, ax         ;; segment
@@ -7653,43 +7708,83 @@ ASM_START
     mov  _int19_function.status + 2[bp], ax
 
 int19_load_done:
+    pop  dx
+    pop  cx
+    pop  bx
+    pop  ax
     pop  bp
 ASM_END
     
     if (status != 0) {
-      print_boot_failure(bootcd, bootdrv, 1, lastdrive);
-      return 0x00000000;
+      print_boot_failure(e.type, 1);
+      return;
+    }
+
+    /* Always check the signature on a HDD boot sector; on FDD, only do
+     * the check if the CMOS doesn't tell us to skip it */
+    if (e.type != 0x00 || !((inb_cmos(0x38) & 0x01))) {
+      if (read_word(bootseg,0x1fe) != 0xaa55) {
+        print_boot_failure(e.type, 0);
+        return;
       }
     }
 
-  // check signature if instructed by cmos reg 0x38, only for floppy
-  // bootchk = 1 : signature check disabled
-  // bootchk = 0 : signature check enabled
-  if (bootdrv != 0) bootchk = 0;
-  else bootchk = inb_cmos(0x38) & 0x01;
+    /* Canonicalize bootseg:bootip */
+    bootip = (bootseg & 0x0fff) << 4;
+    bootseg &= 0xf000;
+  break;
 
 #if BX_ELTORITO_BOOT
-  // if boot from cd, no signature check
-  if (bootcd != 0)
-    bootchk = 1;
-#endif // BX_ELTORITO_BOOT
-
-  if (bootchk == 0) {
-    if (read_word(bootseg,0x1fe) != 0xaa55) {
-      print_boot_failure(bootcd, bootdrv, 0, lastdrive);
-      return 0x00000000;
-      }
+  case 0x03: /* CD-ROM */
+    status = cdrom_boot();
+
+    // If failure
+    if ( (status & 0x00ff) !=0 ) {
+      print_cdromboot_failure(status);
+      print_boot_failure(e.type, 1);
+      return;
     }
+
+    bootdrv = (Bit8u)(status>>8);
+    bootseg = read_word(ebda_seg,&EbdaData->cdemu.load_segment);
+    /* Canonicalize bootseg:bootip */
+    bootip = (bootseg & 0x0fff) << 4;
+    bootseg &= 0xf000;
+    break;
+#endif
+
+  case 0x80: /* Expansion ROM with a Bootstrap Entry Vector (a far pointer) */
+    bootseg = e.vector >> 16;
+    bootip = e.vector & 0xffff;
+    break;
+
+  default: return;
+  }
+
+  /* Debugging info */
+  printf("Booting from %x:%x\n", bootseg, bootip);
   
-#if BX_ELTORITO_BOOT
-  // Print out the boot string
-  print_boot_device(bootcd, bootdrv);
-#else // BX_ELTORITO_BOOT
-  print_boot_device(0, bootdrv);
-#endif // BX_ELTORITO_BOOT
-
-  // return the boot segment
-  return (((Bit32u)bootdrv) << 16) + bootseg;
+  /* Jump to the boot vector */
+ASM_START
+    mov  bp, sp
+    ;; Build an iret stack frame that will take us to the boot vector.
+    ;; iret pops ip, then cs, then flags, so push them in the opposite order.
+    pushf
+    mov  ax, _int19_function.bootseg + 0[bp] 
+    push ax
+    mov  ax, _int19_function.bootip + 0[bp] 
+    push ax
+    ;; Set the magic number in ax and the boot drive in dl.
+    mov  ax, #0xaa55
+    mov  dl, _int19_function.bootdrv + 0[bp]
+    ;; Zero some of the other registers.
+    xor  bx, bx
+    mov  ds, bx
+    mov  es, bx
+    mov  bp, bx
+    ;; Go!
+    iret
+ASM_END
 }
 
   void
@@ -8146,14 +8241,29 @@ int13_out:
   popa
   iret 
 
-
 ;----------
 ;- INT18h -
 ;----------
-int18_handler: ;; Boot Failure routing
-  call _int18_panic_msg
-  hlt
-  iret
+int18_handler: ;; Boot Failure recovery: try the next device.
+
+  ;; Reset SP and SS
+  mov  ax, #0xfffe
+  mov  sp, ax
+  xor  ax, ax
+  mov  ss, ax
+
+  ;; Get the boot sequence number out of the IPL memory
+  mov  bx, #IPL_SEG 
+  mov  ds, bx                     ;; Set segment
+  mov  bx, IPL_SEQUENCE_OFFSET    ;; BX is now the sequence number
+  inc  bx                         ;; ++
+  mov  IPL_SEQUENCE_OFFSET, bx    ;; Write it back
+  mov  ds, ax                     ;; and reset the segment to zero. 
+
+  ;; Carry on in the INT 19h handler, using the new sequence number
+  push bx
+
+  jmp  int19_next_boot
 
 ;----------
 ;- INT19h -
@@ -8161,62 +8271,32 @@ int19_relocated: ;; Boot function, reloc
 int19_relocated: ;; Boot function, relocated
 
   ;; int19 was beginning to be really complex, so now it
-  ;; just calls an C function, that does the work
-  ;; it returns in BL the boot drive, and in AX the boot segment
-  ;; the boot segment will be 0x0000 if something has failed
+  ;; just calls a C function that does the work
 
   push bp
   mov  bp, sp
-
-  ;; drop ds
+  
+  ;; Reset SS and SP
+  mov  ax, #0xfffe
+  mov  sp, ax
   xor  ax, ax
-  mov  ds, ax
-
-  ;; 1st boot device
-  mov  ax, #0x0001
+  mov  ss, ax
+
+  ;; Start from the first boot device (0, in AX)
+  mov  bx, #IPL_SEG 
+  mov  ds, bx                     ;; Set segment to write to the IPL memory
+  mov  IPL_SEQUENCE_OFFSET, ax    ;; Save the sequence number 
+  mov  ds, ax                     ;; and reset the segment.
+
   push ax
+
+int19_next_boot:
+
+  ;; Call the C code for the next boot device
   call _int19_function
-  inc  sp
-  inc  sp
-  ;; bl contains the boot drive
-  ;; ax contains the boot segment or 0 if failure
-
-  test       ax, ax  ;; if ax is 0 try next boot device
-  jnz        boot_setup
-
-  ;; 2nd boot device
-  mov  ax, #0x0002
-  push ax
-  call _int19_function
-  inc  sp
-  inc  sp
-  test       ax, ax  ;; if ax is 0 try next boot device
-  jnz        boot_setup
-
-  ;; 3rd boot device
-  mov  ax, #0x0003
-  push ax
-  call _int19_function
-  inc  sp
-  inc  sp
-  test       ax, ax  ;; if ax is 0 call int18
-  jz         int18_handler
-
-boot_setup:
-  mov dl,    bl      ;; set drive so guest os find it
-  shl eax,   #0x04   ;; convert seg to ip
-  mov 2[bp], ax      ;; set ip
-
-  shr eax,   #0x04   ;; get cs back
-  and ax,    #0xF000 ;; remove what went in ip
-  mov 4[bp], ax      ;; set cs
-  xor ax,    ax
-  mov es,    ax      ;; set es to zero fixes [ 549815 ]
-  mov [bp],  ax      ;; set bp to zero
-  mov ax,    #0xaa55 ;; set ok flag
-
-  pop bp
-  iret               ;; Beam me up Scotty
+
+  ;; Boot failed: invoke the boot recovery function
+  int  #0x18
 
 ;----------
 ;- INT1Ch -
@@ -9394,6 +9474,15 @@ checksum_loop:
   pop  ax
   ret
 
+
+;; We need a copy of this string, but we are not actually a PnP BIOS, 
+;; so make sure it is *not* aligned, so OSes will not see it if they scan.
+.align 16
+  db 0
+pnp_string:
+  .ascii "$PnP"
+
+
 rom_scan:
   ;; Scan for existence of valid expansion ROMS.
   ;;   Video ROM:   from 0xC0000..0xC7FFF in 2k increments
@@ -9428,9 +9517,17 @@ block_count_rounded:
   xor  bx, bx   ;; Restore DS back to 0000:
   mov  ds, bx
   push ax       ;; Save AX
+  push di       ;; Save DI
   ;; Push addr of ROM entry point
   push cx       ;; Push seg
   push #0x0003  ;; Push offset
+
+  ;; Point ES:DI at "$PnP", which tells the ROM that we are a PnP BIOS.  
+  ;; That should stop it grabbing INT 19h; we will use its BEV instead.
+  mov  ax, #0xf000
+  mov  es, ax
+  lea  di, pnp_string 
+
   mov  bp, sp   ;; Call ROM init routine using seg:off on stack
   db   0xff     ;; call_far ss:[bp+0]
   db   0x5e
@@ -9438,6 +9535,38 @@ block_count_rounded:
   cli           ;; In case expansion ROM BIOS turns IF on
   add  sp, #2   ;; Pop offset value
   pop  cx       ;; Pop seg value (restore CX)
+
+  ;; Look at the ROM's PnP Expansion header.  Properly, we're supposed 
+  ;; to init all the ROMs and then go back and build an IPL table of 
+  ;; all the bootable devices, but we can get away with one pass.
+  mov  ds, cx       ;; ROM base
+  mov  bx, 0x001a   ;; 0x1A is the offset into ROM header that contains...
+  mov  ax, [bx]     ;; the offset of PnP expansion header, where...
+  cmp  ax, #0x5024  ;; we look for signature "$PnP"
+  jne  no_bev
+  mov  ax, 2[bx]
+  cmp  ax, #0x506e 
+  jne  no_bev
+  mov  ax, 0x1a[bx] ;; 0x1A is also the offset into the expansion header of...
+  cmp  ax, #0x0000  ;; the Bootstrap Entry Vector, or zero if there is none.
+  je   no_bev
+
+  ;; Found a device that thinks it can boot the system.  Record its BEV.
+  mov  bx, #IPL_SEG            ;; Go to the segment where the IPL table lives 
+  mov  ds, bx
+  mov  bx, IPL_COUNT_OFFSET    ;; Read the number of entries so far
+  cmp  bx, #IPL_TABLE_ENTRIES
+  je   no_bev                  ;; Get out if the table is full
+  shl  bx, #0x4                ;; Turn count into offset (entries are 16 bytes)
+  mov  0[bx], #0x80            ;; This entry is a BEV device
+  mov  6[bx], cx               ;; Build a far pointer from the segment...
+  mov  4[bx], ax               ;; and the offset
+  shr  bx, #0x4                ;; Turn the offset back into a count
+  inc  bx                      ;; We have one more entry now
+  mov  IPL_COUNT_OFFSET, bx    ;; Remember that.
+
+no_bev:
+  pop  di       ;; Restore DI
   pop  ax       ;; Restore AX
 rom_scan_increment:
   shl  ax, #5   ;; convert 512-bytes blocks to 16-byte increments
@@ -9770,6 +9899,8 @@ post_default_ints:
   call _copy_e820_table
   call smbios_init
 #endif
+
+  call _init_boot_vectors
 
   call rom_scan
 
diff -r 037f49cd8016 -r 5eeb4bac1b17 tools/ioemu/hw/pc.c
--- a/tools/ioemu/hw/pc.c       Mon Jan 08 14:25:28 2007 +0000
+++ b/tools/ioemu/hw/pc.c       Mon Jan 08 14:26:57 2007 +0000
@@ -168,6 +168,8 @@ static int get_bios_disk(char *boot_devi
             return 0x02;            /* hard drive */
         case 'd':
             return 0x03;            /* cdrom */
+        case 'n':
+            return 0x04;            /* network */
         }
     }
     return 0x00;                /* no device */
diff -r 037f49cd8016 -r 5eeb4bac1b17 tools/ioemu/vl.c
--- a/tools/ioemu/vl.c  Mon Jan 08 14:25:28 2007 +0000
+++ b/tools/ioemu/vl.c  Mon Jan 08 14:26:57 2007 +0000
@@ -6153,7 +6153,7 @@ int main(int argc, char **argv)
             case QEMU_OPTION_boot:
                 boot_device = strdup(optarg);
                 if (strspn(boot_device, "acd"
-#ifdef TARGET_SPARC
+#if defined(TARGET_SPARC) || defined(TARGET_I386)
                            "n"
 #endif
                         ) != strlen(boot_device)) {

_______________________________________________
Xen-changelog mailing list
Xen-changelog@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-changelog

<Prev in Thread] Current Thread [Next in Thread>