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] Add PV-GRUB

# HG changeset patch
# User Keir Fraser <keir.fraser@xxxxxxxxxx>
# Date 1213778207 -3600
# Node ID c8d9ade45781a9a68b179ace7e0efbd5aaab8f29
# Parent  8a0656950b1c2b2c91c282561a911379cc397bef
Add PV-GRUB

This fetches GRUB1 sources, applies the {graphical, print function,
save default, and ext3_256byte} patches from debian, and applies a
patch to make it work on x86_64 and port it to Mini-OS.  By using
libxc, PV-GRUB can then "kexec" the loaded kernel from inside the
domain itself, hence permitting to avoid the security-concerned
pygrub.

Signed-off-by: Samuel Thibault <samuel.thibault@xxxxxxxxxxxxx>
---
 .hgignore                                      |    3 
 extras/mini-os/arch/x86/mm.c                   |    2 
 extras/mini-os/blkfront.c                      |    8 
 extras/mini-os/fbfront.c                       |   24 
 extras/mini-os/include/x86/arch_mm.h           |    2 
 extras/mini-os/main.c                          |    4 
 extras/mini-os/netfront.c                      |   13 
 stubdom/Makefile                               |   41 
 stubdom/README                                 |   68 +
 stubdom/grub.patches/10graphics.diff           |  772 +++++++++++++++++
 stubdom/grub.patches/20print_func.diff         |   47 +
 stubdom/grub.patches/30savedefault.diff        |   60 +
 stubdom/grub.patches/40ext3_256byte_inode.diff |   51 +
 stubdom/grub.patches/99minios                  | 1085 +++++++++++++++++++++++++
 stubdom/grub/Makefile                          |   76 +
 stubdom/grub/boot-x86_32.S                     |  112 ++
 stubdom/grub/boot-x86_64.S                     |  108 ++
 stubdom/grub/config.h                          |   11 
 stubdom/grub/kexec.c                           |  324 +++++++
 stubdom/grub/mini-os.c                         |  702 ++++++++++++++++
 stubdom/grub/mini-os.h                         |    5 
 stubdom/grub/osdep.h                           |   30 
 tools/libxc/xc_dom.h                           |    3 
 tools/libxc/xc_dom_core.c                      |    6 
 24 files changed, 3534 insertions(+), 23 deletions(-)

diff -r 8a0656950b1c -r c8d9ade45781 .hgignore
--- a/.hgignore Wed Jun 18 09:35:06 2008 +0100
+++ b/.hgignore Wed Jun 18 09:36:47 2008 +0100
@@ -94,6 +94,9 @@
 ^stubdom/newlib-.*$
 ^stubdom/pciutils-.*$
 ^stubdom/zlib-.*$
+^stubdom/grub-cvs$
+^stubdom/grub/stage2$
+^stubdom/grub/netboot$
 ^tools/.*/TAGS$
 ^tools/.*/build/lib.*/.*\.py$
 ^tools/blktap/Makefile\.smh$
diff -r 8a0656950b1c -r c8d9ade45781 extras/mini-os/arch/x86/mm.c
--- a/extras/mini-os/arch/x86/mm.c      Wed Jun 18 09:35:06 2008 +0100
+++ b/extras/mini-os/arch/x86/mm.c      Wed Jun 18 09:36:47 2008 +0100
@@ -372,7 +372,7 @@ static pgentry_t *get_pgt(unsigned long 
     return &tab[offset];
 }
 
-static pgentry_t *need_pgt(unsigned long addr)
+pgentry_t *need_pgt(unsigned long addr)
 {
     unsigned long mfn;
     pgentry_t *tab;
diff -r 8a0656950b1c -r c8d9ade45781 extras/mini-os/blkfront.c
--- a/extras/mini-os/blkfront.c Wed Jun 18 09:35:06 2008 +0100
+++ b/extras/mini-os/blkfront.c Wed Jun 18 09:36:47 2008 +0100
@@ -242,9 +242,15 @@ void shutdown_blkfront(struct blkfront_d
     err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 6);
     xenbus_wait_for_value(path, "6", &dev->events);
 
+    err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 1);
+    xenbus_wait_for_value(path, "2", &dev->events);
+
     xenbus_unwatch_path(XBT_NIL, path);
 
-    err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 1);
+    snprintf(path, sizeof(path), "%s/ring-ref", nodename);
+    xenbus_rm(XBT_NIL, path);
+    snprintf(path, sizeof(path), "%s/event-channel", nodename);
+    xenbus_rm(XBT_NIL, path);
 
     free_blkfront(dev);
 }
diff -r 8a0656950b1c -r c8d9ade45781 extras/mini-os/fbfront.c
--- a/extras/mini-os/fbfront.c  Wed Jun 18 09:35:06 2008 +0100
+++ b/extras/mini-os/fbfront.c  Wed Jun 18 09:36:47 2008 +0100
@@ -229,9 +229,18 @@ void shutdown_kbdfront(struct kbdfront_d
     err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 6);
     xenbus_wait_for_value(path, "6", &dev->events);
 
+    err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 1);
+    // does not work yet.
+    //xenbus_wait_for_value(path, "2", &dev->events);
+
     xenbus_unwatch_path(XBT_NIL, path);
 
-    err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 1);
+    snprintf(path, sizeof(path), "%s/page-ref", nodename);
+    xenbus_rm(XBT_NIL, path);
+    snprintf(path, sizeof(path), "%s/event-channel", nodename);
+    xenbus_rm(XBT_NIL, path);
+    snprintf(path, sizeof(path), "%s/request-abs-pointer", nodename);
+    xenbus_rm(XBT_NIL, path);
 
     free_kbdfront(dev);
 }
@@ -561,9 +570,20 @@ void shutdown_fbfront(struct fbfront_dev
     err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 6);
     xenbus_wait_for_value(path, "6", &dev->events);
 
+    err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 1);
+    // does not work yet
+    //xenbus_wait_for_value(path, "2", &dev->events);
+
     xenbus_unwatch_path(XBT_NIL, path);
 
-    err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 1);
+    snprintf(path, sizeof(path), "%s/page-ref", nodename);
+    xenbus_rm(XBT_NIL, path);
+    snprintf(path, sizeof(path), "%s/event-channel", nodename);
+    xenbus_rm(XBT_NIL, path);
+    snprintf(path, sizeof(path), "%s/protocol", nodename);
+    xenbus_rm(XBT_NIL, path);
+    snprintf(path, sizeof(path), "%s/feature-update", nodename);
+    xenbus_rm(XBT_NIL, path);
 
     unbind_evtchn(dev->evtchn);
 
diff -r 8a0656950b1c -r c8d9ade45781 extras/mini-os/include/x86/arch_mm.h
--- a/extras/mini-os/include/x86/arch_mm.h      Wed Jun 18 09:35:06 2008 +0100
+++ b/extras/mini-os/include/x86/arch_mm.h      Wed Jun 18 09:36:47 2008 +0100
@@ -221,4 +221,6 @@ static __inline__ paddr_t machine_to_phy
 #define map_zero(n, a) map_frames_ex(&mfn_zero, n, 0, 0, a, DOMID_SELF, 0, 
L1_PROT_RO)
 #define do_map_zero(start, n) do_map_frames(start, &mfn_zero, n, 0, 0, 
DOMID_SELF, 0, L1_PROT_RO)
 
+pgentry_t *need_pgt(unsigned long addr);
+
 #endif /* _ARCH_MM_H_ */
diff -r 8a0656950b1c -r c8d9ade45781 extras/mini-os/main.c
--- a/extras/mini-os/main.c     Wed Jun 18 09:35:06 2008 +0100
+++ b/extras/mini-os/main.c     Wed Jun 18 09:36:47 2008 +0100
@@ -59,11 +59,13 @@ static void call_main(void *p)
      * crashing. */
     //sleep(1);
 
+#ifndef CONFIG_GRUB
     sparse((unsigned long) &__app_bss_start, &__app_bss_end - 
&__app_bss_start);
 #ifdef HAVE_LWIP
     start_networking();
 #endif
     init_fs_frontend();
+#endif
 
 #ifdef CONFIG_QEMU
     if (!fs_import) {
@@ -154,7 +156,7 @@ void _exit(int ret)
 #ifdef HAVE_LWIP
     stop_networking();
 #endif
-    unbind_all_ports();
+    stop_kernel();
     if (!ret) {
        /* No problem, just shutdown.  */
         struct sched_shutdown sched_shutdown = { .reason = SHUTDOWN_poweroff };
diff -r 8a0656950b1c -r c8d9ade45781 extras/mini-os/netfront.c
--- a/extras/mini-os/netfront.c Wed Jun 18 09:35:06 2008 +0100
+++ b/extras/mini-os/netfront.c Wed Jun 18 09:36:47 2008 +0100
@@ -497,15 +497,26 @@ void shutdown_netfront(struct netfront_d
     printk("close network: backend at %s\n",dev->backend);
 
     snprintf(path, sizeof(path), "%s/state", dev->backend);
+
     err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 5); /* closing */
     xenbus_wait_for_value(path, "5", &dev->events);
 
     err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 6);
     xenbus_wait_for_value(path, "6", &dev->events);
 
+    err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 1);
+    xenbus_wait_for_value(path, "2", &dev->events);
+
     xenbus_unwatch_path(XBT_NIL, path);
 
-    err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 1);
+    snprintf(path, sizeof(path), "%s/tx-ring-ref", nodename);
+    xenbus_rm(XBT_NIL, path);
+    snprintf(path, sizeof(path), "%s/rx-ring-ref", nodename);
+    xenbus_rm(XBT_NIL, path);
+    snprintf(path, sizeof(path), "%s/event-channel", nodename);
+    xenbus_rm(XBT_NIL, path);
+    snprintf(path, sizeof(path), "%s/request-rx-copy", nodename);
+    xenbus_rm(XBT_NIL, path);
 
     free_netfront(dev);
 }
diff -r 8a0656950b1c -r c8d9ade45781 stubdom/Makefile
--- a/stubdom/Makefile  Wed Jun 18 09:35:06 2008 +0100
+++ b/stubdom/Makefile  Wed Jun 18 09:36:47 2008 +0100
@@ -14,6 +14,7 @@ LIBPCI_VERSION=2.2.9
 LIBPCI_VERSION=2.2.9
 NEWLIB_DATE=2008-01-01
 LWIP_DATE=2008-06-01
+GRUB_DATE=2008-06-01
 
 WGET=wget -c
 
@@ -39,10 +40,10 @@ export CROSS_COMPILE=$(GNU_TARGET_ARCH)-
 export CROSS_COMPILE=$(GNU_TARGET_ARCH)-xen-elf-
 export PATH:=$(CROSS_PREFIX)/bin:$(PATH)
 
-TARGETS=ioemu c caml
+TARGETS=ioemu c caml grub
 
 .PHONY: all
-all: ioemu-stubdom c-stubdom
+all: ioemu-stubdom c-stubdom pv-grub
 
 ################
 # Cross-binutils
@@ -221,30 +222,53 @@ c: cross-newlib mk-symlinks
 c: cross-newlib mk-symlinks
        $(MAKE) -C $@ LWIPDIR=$(CURDIR)/lwip-cvs 
 
+######
+# Grub
+######
+
+grub-cvs:
+       cvs -z 9 -d :pserver:anonymous@xxxxxxxxxxxxxx:/sources/grub co -D 
$(GRUB_DATE) -d $@ grub
+       for i in grub.patches/* ; do \
+               patch -d $@ -p1 < $$i ; \
+       done
+
+.PHONY: grub
+grub: grub-cvs cross-newlib mk-symlinks
+       $(MAKE) -C $@
+
 ########
 # minios
 ########
 
 .PHONY: ioemu-stubdom
 ioemu-stubdom: mini-os-ioemu lwip-cvs libxc ioemu
-       $(MAKE) -C $(MINI_OS) OBJ_DIR=$(CURDIR)/$< LWIPDIR=$(CURDIR)/lwip-cvs 
APP_OBJS="$(CURDIR)/ioemu/i386-dm-stubdom/qemu.a 
$(CURDIR)/ioemu/i386-dm-stubdom/libqemu.a" CFLAGS=-DCONFIG_QEMU
+       DEF_CFLAGS=-DCONFIG_QEMU $(MAKE) -C $(MINI_OS) OBJ_DIR=$(CURDIR)/$< 
LWIPDIR=$(CURDIR)/lwip-cvs APP_OBJS="$(CURDIR)/ioemu/i386-dm-stubdom/qemu.a 
$(CURDIR)/ioemu/i386-dm-stubdom/libqemu.a"
 
 CAMLLIB = $(shell ocamlc -where)
 .PHONY: caml-stubdom
 caml-stubdom: mini-os-caml lwip-cvs libxc caml
-       $(MAKE) -C $(MINI_OS) OBJ_DIR=$(CURDIR)/$< LWIPDIR=$(CURDIR)/lwip-cvs 
APP_OBJS="$(CURDIR)/caml/main-caml.o $(CURDIR)/caml/caml.o 
$(CAMLLIB)/libasmrun.a" CFLAGS=-DCONFIG_CAML
+       DEF_CFLAGS=-DCONFIG_CAML $(MAKE) -C $(MINI_OS) OBJ_DIR=$(CURDIR)/$< 
LWIPDIR=$(CURDIR)/lwip-cvs APP_OBJS="$(CURDIR)/caml/main-caml.o 
$(CURDIR)/caml/caml.o $(CAMLLIB)/libasmrun.a"
 
 .PHONY: c-stubdom
 c-stubdom: mini-os-c lwip-cvs libxc c
-       $(MAKE) -C $(MINI_OS) OBJ_DIR=$(CURDIR)/$< LWIPDIR=$(CURDIR)/lwip-cvs 
APP_OBJS=$(CURDIR)/c/main.a CFLAGS=-DCONFIG_C
+       DEF_CFLAGS=-DCONFIG_C $(MAKE) -C $(MINI_OS) OBJ_DIR=$(CURDIR)/$< 
LWIPDIR=$(CURDIR)/lwip-cvs APP_OBJS=$(CURDIR)/c/main.a
+
+.PHONY: pv-grub
+pv-grub: mini-os-grub libxc grub
+       DEF_CFLAGS=-DCONFIG_GRUB $(MAKE) -C $(MINI_OS) OBJ_DIR=$(CURDIR)/$< 
APP_OBJS=$(CURDIR)/grub/main.a
 
 #########
 # install
 #########
 
-install: mini-os-ioemu/mini-os.gz
+install: install-ioemu install-grub
+
+install-ioemu: mini-os-ioemu/mini-os.gz
        $(INSTALL_PROG) stubdom-dm "$(DESTDIR)/usr/lib/xen/bin"
-       $(INSTALL_PROG) $< "$(DESTDIR)/usr/lib/xen/boot/stubdom.gz"
+       $(INSTALL_PROG) $< "$(DESTDIR)/usr/lib/xen/boot/ioemu-stubdom.gz"
+
+install-grub: mini-os-grub/mini-os.gz
+       $(INSTALL_PROG) $< "$(DESTDIR)/usr/lib/xen/boot/pv-grub.gz"
 
 #######
 # clean
@@ -256,8 +280,10 @@ clean:
        rm -fr mini-os-ioemu
        rm -fr mini-os-c
        rm -fr mini-os-caml
+       rm -fr mini-os-grub
        $(MAKE) -C caml clean
        $(MAKE) -C c clean
+       $(MAKE) -C grub clean
        rm -fr libxc ioemu mini-os include
 
 # clean the cross-compilation result
@@ -274,6 +300,7 @@ patchclean: crossclean
        rm -fr gcc-$(GCC_VERSION)
        rm -fr newlib-cvs
        rm -fr lwip-cvs
+       rm -fr grub-cvs
 
 # clean downloads
 .PHONY: downloadclean
diff -r 8a0656950b1c -r c8d9ade45781 stubdom/README
--- a/stubdom/README    Wed Jun 18 09:35:06 2008 +0100
+++ b/stubdom/README    Wed Jun 18 09:36:47 2008 +0100
@@ -6,12 +6,19 @@ Then make install to install the result.
 
 Also, run make and make install in $XEN_ROOT/tools/fs-back
 
+
+
+                                IOEMU stubdom
+                                =============
+
+  This boosts HVM performance by putting ioemu in its own lightweight domain.
+
 General Configuration
 =====================
 
 In your HVM config "hvmconfig",
 
-- use /usr/lib/xen/bin/stubdom-dm as dm script
+- use /usr/lib/xen/bin/stubdom-dm as dm script:
 
 device_model = '/usr/lib/xen/bin/stubdom-dm'
 
@@ -25,7 +32,7 @@ Create /etc/xen/stubdom-hvmconfig (where
 Create /etc/xen/stubdom-hvmconfig (where "hvmconfig" is the name of your HVM
 guest) with
 
-kernel = "/usr/lib/xen/boot/stubdom.gz"
+kernel = "/usr/lib/xen/boot/ioemu-stubdom.gz"
 vif = [ '', 'ip=10.0.1.1,mac=aa:00:00:12:23:34']
 disk = [  'file:/tmp/install.iso,hdc:cdrom,r', 'phy:/dev/sda6,hda,w', 
'file:/tmp/test,hdb,r' ]
 
@@ -42,34 +49,36 @@ There are three posibilities
 
 * Using SDL
 
-In hvmconfig, disable vnc:
+  - In hvmconfig, disable vnc and sdl:
 
 vnc = 0
+sdl = 0
 
-In stubdom-hvmconfig, set a vfb:
+  - In stubdom-hvmconfig, set an sdl vfb:
 
 vfb = [ 'type=sdl' ]
 
 * Using a VNC server in the stub domain
 
-In hvmconfig, set vnclisten to "172.30.206.1" for instance.  Do not use a host
-name as Mini-OS does not have a name resolver.  Do not use 127.0.0.1 since then
-you will not be able to connect to it.
+  - In hvmconfig, set vnclisten to "172.30.206.1" for instance.  Do not use a
+host name as Mini-OS does not have a name resolver.  Do not use 127.0.0.1 since
+then you will not be able to connect to it.
 
 vnc = 1
 vnclisten = "172.30.206.1"
 
-In stubdom-hvmconfig, fill the reserved vif with the same IP, for instance:
+  - In stubdom-hvmconfig, fill the reserved vif with the same IP, for instance:
 
 vif = [ 'ip=172.30.206.1', 'ip=10.0.1.1,mac=aa:00:00:12:23:34']
 
 * Using a VNC server in dom0
 
-In hvmconfig, disable vnc:
+  - In hvmconfig, disable vnc and sdl:
 
 vnc = 0
+sdl = 0
 
-In stubdom-hvmconfig, set a vfb:
+  - In stubdom-hvmconfig, set a vnc vfb:
 
 vfb = [ 'type=vnc' ]
 
@@ -85,3 +94,43 @@ ln -s /var/lib/xen /exports/var/lib
 /usr/sbin/fs-backend &
 
 xm create hvmconfig
+
+
+
+                                   PV-GRUB
+                                   =======
+
+  This replaces pygrub to boot domU images safely: it runs the regular grub
+inside the created domain itself and uses regular domU facilities to read the
+disk / fetch files from network etc. ; it eventually loads the PV kernel and
+chain-boots it.
+  
+Configuration
+=============
+
+In your PV config,
+
+- use /usr/lib/xen/boot/pv-grub.gz as kernel:
+
+kernel = "/usr/lib/xen/boot/pv-grub.gz"
+
+- set the path to menu.lst, as seen from the domU, in extra:
+
+extra = "(hd0,0)/boot/grub/menu.lst"
+
+you can also use a tftp path (dhcp will be automatically performed):
+
+extra = "(nd)/somepath/menu.lst"
+
+or you can set it in option 150 of your dhcp server and leave extra empty
+
+Limitations
+===========
+
+- You can not boot a 64bit kernel with a 32bit-compiled PV-GRUB and vice-versa.
+To cross-compile a 32bit PV-GRUB,
+
+export XEN_TARGET_ARCH=x86_32
+
+- bootsplash is supported, but the ioemu backend does not yet support restart
+for use by the booted kernel.
diff -r 8a0656950b1c -r c8d9ade45781 stubdom/grub.patches/10graphics.diff
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/stubdom/grub.patches/10graphics.diff      Wed Jun 18 09:36:47 2008 +0100
@@ -0,0 +1,2299 @@
+diff -Naur grub-0.97.orig/configure.ac grub-0.97/configure.ac
+--- grub-0.97.orig/configure.ac        2005-05-07 23:36:03.000000000 -0300
++++ grub-0.97/configure.ac     2005-06-12 20:56:49.000000000 -0300
+@@ -595,6 +595,11 @@
+   [  --enable-diskless       enable diskless support])
+ AM_CONDITIONAL(DISKLESS_SUPPORT, test "x$enable_diskless" = xyes)
+ 
++dnl Graphical splashscreen support
++AC_ARG_ENABLE(graphics,
++  [  --disable-graphics      disable graphics terminal support])
++AM_CONDITIONAL(GRAPHICS_SUPPORT, test "x$enable_graphics" != xno)
++
+ dnl Hercules terminal
+ AC_ARG_ENABLE(hercules,
+   [  --disable-hercules      disable hercules terminal support])
+diff -Naur grub-0.97.orig/stage2/asm.S grub-0.97/stage2/asm.S
+--- grub-0.97.orig/stage2/asm.S        2004-06-19 13:55:22.000000000 -0300
++++ grub-0.97/stage2/asm.S     2005-06-13 14:05:31.000000000 -0300
+@@ -2216,7 +2216,304 @@
+       pop     %ebx
+       pop     %ebp
+       ret
+-              
++
++
++/* graphics mode functions */
++#ifdef SUPPORT_GRAPHICS
++VARIABLE(cursorX)
++.word 0
++VARIABLE(cursorY)
++.word 0
++VARIABLE(cursorCount)
++.word 0
++VARIABLE(cursorBuf)
++.byte 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
++
++
++/*
++ * set_int1c_handler(void)
++ */
++ENTRY(set_int1c_handler)
++      pushl   %edi
++
++      /* save the original int1c handler */
++      movl    $0x70, %edi
++      movw    (%edi), %ax
++      movw    %ax, ABS(int1c_offset)
++      movw    2(%edi), %ax
++      movw    %ax, ABS(int1c_segment)
++
++      /* save the new int1c handler */
++      movw    $ABS(int1c_handler), %ax
++      movw    %ax, (%edi)
++      xorw    %ax, %ax
++      movw    %ax, 2(%edi)
++
++      popl    %edi
++      ret
++
++
++/*
++ * unset_int1c_handler(void)
++ */
++ENTRY(unset_int1c_handler)
++      pushl   %edi
++
++      /* check if int1c_handler is set */
++      movl    $0x70, %edi
++      movw    $ABS(int1c_handler), %ax
++      cmpw    %ax, (%edi)
++      jne     int1c_1
++      xorw    %ax, %ax
++      cmpw    %ax, 2(%edi)
++      jne     int1c_1
++
++      /* restore the original */
++      movw    ABS(int1c_offset), %ax
++      movw    %ax, (%edi)
++      movw    ABS(int1c_segment), %ax
++      movw    %ax, 2(%edi)
++
++int1c_1:
++      popl    %edi
++      ret
++
++
++/*
++ * blinks graphics cursor
++ */
++      .code16
++write_data:
++      movw    $0, %ax
++      movw    %ax, %ds
++
++      mov     $0xA000, %ax            /* video in es:di */
++      mov     %ax, %es
++      mov     $80, %ax
++      movw    $ABS(cursorY), %si
++      mov     %ds:(%si), %bx
++      mul     %bx
++      movw    $ABS(cursorX), %si
++      mov     %ds:(%si), %bx
++      shr     $3, %bx                 /* %bx /= 8 */
++      add     %bx, %ax
++      mov     %ax, %di
++
++      movw    $ABS(cursorBuf), %si    /* fontBuf in ds:si */
++
++      /* prepare for data moving */
++      mov     $16, %dx                /* altura da fonte */
++      mov     $80, %bx                /* bytes por linha */
++
++write_loop:
++      movb    %ds:(%si), %al
++      xorb    $0xff, %al
++      movb    %al, %ds:(%si)          /* invert cursorBuf */
++      movb    %al, %es:(%di)          /* write to video */
++      add     %bx, %di
++      inc     %si
++      dec     %dx
++      jg      write_loop
++      ret
++
++int1c_handler:
++      pusha
++      mov     $0, %ax
++      mov     %ax, %ds
++      mov     $ABS(cursorCount), %si
++      mov     %ds:(%si), %ax
++      inc     %ax
++      mov     %ax, %ds:(%si)
++      cmp     $9, %ax
++      jne     int1c_done
++
++      mov     $0, %ax
++      mov     %ax, %ds:(%si)
++      call    write_data
++
++int1c_done:
++      popa
++      iret
++      /* call previous int1c handler */
++      /* ljmp */
++      .byte   0xea
++int1c_offset:  .word   0
++int1c_segment: .word   0
++      .code32
++
++
++/*
++ * unsigned char set_videomode(unsigned char mode)
++ * BIOS call "INT 10H Function 0h" to set video mode
++ *    Call with       %ah = 0x0
++ *                    %al = video mode
++ *  Returns old videomode.
++ */
++ENTRY(set_videomode)
++      pushl   %ebp
++      movl    %esp,%ebp
++      pushl   %ebx
++      pushl   %ecx
++
++      movb    8(%ebp), %cl
++
++      call    EXT_C(prot_to_real)
++      .code16
++
++      xorb    %al, %al
++      movb    $0xf, %ah
++      int     $0x10                   /* Get Current Video mode */
++      movb    %al, %ch
++      xorb    %ah, %ah
++      movb    %cl, %al
++      int     $0x10                   /* Set Video mode */
++
++      DATA32  call    EXT_C(real_to_prot)
++      .code32
++
++      xorl    %eax, %eax
++      movb    %ch, %al
++
++      popl    %ecx
++      popl    %ebx
++      popl    %ebp
++      ret
++
++
++/*
++ * int get_videomode()
++ * BIOS call "INT 10H Function 0Fh" to get current video mode
++ *    Call with       %al = 0x0
++ *                    %ah = 0xF
++ *    Returns current videomode.
++ */
++ENTRY(get_videomode)
++      pushl   %ebp
++      movl    %esp,%ebp
++      pushl   %ebx
++      pushl   %ecx
++
++      call    EXT_C(prot_to_real)
++      .code16
++
++      xorb    %al, %al
++      movb    $0xF, %ah
++      int     $0x10                   /* Get Current Video mode */
++      movb    %al, %cl        /* For now we only want display mode */
++
++      DATA32  call    EXT_C(real_to_prot)
++      .code32
++
++      xorl    %eax, %eax
++      movb    %cl, %al
++
++      popl    %ecx
++      popl    %ebx
++      popl    %ebp
++      ret
++
++
++/*
++ * unsigned char * graphics_get_font()
++ * BIOS call "INT 10H Function 11h" to set font
++ *      Call with       %ah = 0x11
++ */
++ENTRY(graphics_get_font)
++      push    %ebp
++      push    %ebx
++      push    %ecx
++      push    %edx
++
++      call    EXT_C(prot_to_real)
++      .code16
++
++      movw    $0x1130, %ax
++      movb    $6, %bh         /* font 8x16 */
++      int     $0x10
++      movw    %bp, %dx
++      movw    %es, %cx
++
++      DATA32  call    EXT_C(real_to_prot)
++      .code32
++
++      xorl    %eax, %eax
++      movw    %cx, %ax
++      shll    $4, %eax
++      movw    %dx, %ax
++
++      pop     %edx
++      pop     %ecx
++      pop     %ebx
++      pop     %ebp
++      ret
++
++
++/*
++ * graphics_set_palette(index, red, green, blue)
++ * BIOS call "INT 10H Function 10h" to set individual dac register
++ *    Call with       %ah = 0x10
++ *                    %bx = register number
++ *                    %ch = new value for green (0-63)
++ *                    %cl = new value for blue (0-63)
++ *                    %dh = new value for red (0-63)
++ */
++
++ENTRY(graphics_set_palette)
++      push    %ebp
++      push    %eax
++      push    %ebx
++      push    %ecx
++      push    %edx
++
++      movw    $0x3c8, %bx             /* address write mode register */
++
++      /* wait vertical retrace */
++      movw    $0x3da, %dx
++l1b:
++      inb     %dx, %al        /* wait vertical active display */
++      test    $8, %al
++      jnz     l1b
++
++l2b:
++      inb     %dx, %al        /* wait vertical retrace */
++      test    $8, %al
++      jnz     l2b
++
++      mov     %bx, %dx
++      movb    0x18(%esp), %al         /* index */
++      outb    %al, %dx
++      inc     %dx
++
++      movb    0x1c(%esp), %al         /* red */
++      outb    %al, %dx
++
++      movb    0x20(%esp), %al         /* green */
++      outb    %al, %dx
++
++      movb    0x24(%esp), %al         /* blue */
++      outb    %al, %dx
++
++      movw    0x18(%esp), %bx
++
++      call    EXT_C(prot_to_real)
++      .code16
++
++      movb    %bl, %bh
++      movw    $0x1000, %ax
++      int     $0x10
++
++      DATA32  call    EXT_C(real_to_prot)
++      .code32
++
++      pop     %edx
++      pop     %ecx
++      pop     %ebx
++      pop     %eax
++      pop     %ebp
++      ret
++#endif /* SUPPORT_GRAPHICS */
++
++
+ /*
+  * getrtsecs()
+  *    if a seconds value can be read, read it and return it (BCD),
+diff -Naur grub-0.97.orig/stage2/builtins.c grub-0.97/stage2/builtins.c
+--- grub-0.97.orig/stage2/builtins.c   2005-02-15 19:58:23.000000000 -0200
++++ grub-0.97/stage2/builtins.c        2005-06-13 18:44:03.000000000 -0300
+@@ -28,6 +28,10 @@
+ #include <filesys.h>
+ #include <term.h>
+ 
++#ifdef SUPPORT_GRAPHICS
++# include <graphics.h>
++#endif
++
+ #ifdef SUPPORT_NETBOOT
+ # define GRUB 1
+ # include <etherboot.h>
+@@ -237,12 +241,22 @@
+ static int
+ boot_func (char *arg, int flags)
+ {
++  struct term_entry *prev_term = current_term;
+   /* Clear the int15 handler if we can boot the kernel successfully.
+      This assumes that the boot code never fails only if KERNEL_TYPE is
+      not KERNEL_TYPE_NONE. Is this assumption is bad?  */
+   if (kernel_type != KERNEL_TYPE_NONE)
+     unset_int15_handler ();
+ 
++  /* if our terminal needed initialization, we should shut it down
++   * before booting the kernel, but we want to save what it was so
++   * we can come back if needed */
++  if (current_term->shutdown) 
++    {
++      current_term->shutdown();
++      current_term = term_table; /* assumption: console is first */
++    }
++
+ #ifdef SUPPORT_NETBOOT
+   /* Shut down the networking.  */
+   cleanup_net ();
+@@ -306,6 +320,13 @@
+       return 1;
+     }
+ 
++  /* if we get back here, we should go back to what our term was before */
++  current_term = prev_term;
++  if (current_term->startup)
++      /* if our terminal fails to initialize, fall back to console since
++       * it should always work */
++      if (current_term->startup() == 0)
++          current_term = term_table; /* we know that console is first */
+   return 0;
+ }
+ 
+@@ -852,6 +873,251 @@
+ };
+ #endif /* SUPPORT_NETBOOT */
+ 
++#ifdef SUPPORT_GRAPHICS
++
++static int splashimage_func(char *arg, int flags) {
++  int i;
++    
++  /* filename can only be 256 characters due to our buffer size */
++  if (grub_strlen(arg) > 256) {
++    grub_printf("Splash image filename too large\n");
++    grub_printf("Press any key to continue...");
++    getkey();
++    return 1;
++  }
++
++  /* get rid of TERM_NEED_INIT from the graphics terminal. */
++  for (i = 0; term_table[i].name; i++) {
++    if (grub_strcmp (term_table[i].name, "graphics") == 0) {
++      term_table[i].flags &= ~TERM_NEED_INIT;
++      break;
++    }
++  }
++
++  graphics_set_splash(arg);
++
++  if (flags == BUILTIN_CMDLINE && graphics_inited) {
++    graphics_end();
++    if (graphics_init() == 0) {
++      /* Fallback to default term */
++      current_term = term_table;
++      max_lines = current_term->max_lines;
++      if (current_term->cls)
++        current_term->cls();
++      grub_printf("Failed to set splash image and/or graphics mode\n");
++      return 1;
++    }
++    graphics_cls();
++  }
++
++  if (flags == BUILTIN_MENU)
++    current_term = term_table + i;
++
++  return 0;
++}
++
++static struct builtin builtin_splashimage =
++{
++  "splashimage",
++  splashimage_func,
++  BUILTIN_CMDLINE | BUILTIN_MENU | BUILTIN_HELP_LIST,
++  "splashimage FILE",
++  "Load FILE as the background image when in graphics mode."
++};
++
++
++/* shade */
++static int
++shade_func(char *arg, int flags)
++{
++    int new_shade;
++
++    if (!arg || safe_parse_maxint(&arg, &new_shade) == 0)
++       return (1);
++
++    if (shade != new_shade) {
++       shade = new_shade;
++       if (flags == BUILTIN_CMDLINE && graphics_inited) {
++           graphics_end();
++           graphics_init();
++           graphics_cls();
++       }
++    }
++
++    return 0;
++}
++
++static struct builtin builtin_shade =
++{
++  "shade",
++  shade_func,
++  BUILTIN_CMDLINE | BUILTIN_MENU | BUILTIN_HELP_LIST,
++  "shade INTEGER",
++  "If set to 0, disables the use of shaded text, else enables it."
++};
++
++
++/* foreground */
++static int
++foreground_func(char *arg, int flags)
++{
++    if (grub_strlen(arg) == 6) {
++      int r = ((hex(arg[0]) << 4) | hex(arg[1])) >> 2;
++      int g = ((hex(arg[2]) << 4) | hex(arg[3])) >> 2;
++      int b = ((hex(arg[4]) << 4) | hex(arg[5])) >> 2;
++
++      foreground = (r << 16) | (g << 8) | b;
++      if (graphics_inited)
++          graphics_set_palette(15, r, g, b);
++
++      return 0;
++    }
++
++    return 1;
++}
++
++static struct builtin builtin_foreground =
++{
++  "foreground",
++  foreground_func,
++  BUILTIN_CMDLINE | BUILTIN_MENU | BUILTIN_HELP_LIST,
++  "foreground RRGGBB",
++  "Sets the foreground color when in graphics mode."
++  "RR is red, GG is green, and BB blue. Numbers must be in hexadecimal."
++};
++
++
++/* background */
++static int
++background_func(char *arg, int flags)
++{
++    if (grub_strlen(arg) == 6) {
++      int r = ((hex(arg[0]) << 4) | hex(arg[1])) >> 2;
++      int g = ((hex(arg[2]) << 4) | hex(arg[3])) >> 2;
++      int b = ((hex(arg[4]) << 4) | hex(arg[5])) >> 2;
++
++      background = (r << 16) | (g << 8) | b;
++      if (graphics_inited)
++          graphics_set_palette(0, r, g, b);
++      return 0;
++    }
++
++    return 1;
++}
++
++static struct builtin builtin_background =
++{
++  "background",
++  background_func,
++  BUILTIN_CMDLINE | BUILTIN_MENU | BUILTIN_HELP_LIST,
++  "background RRGGBB",
++  "Sets the background color when in graphics mode."
++  "RR is red, GG is green, and BB blue. Numbers must be in hexadecimal."
++};
++
++
++/* border */
++static int
++border_func(char *arg, int flags)
++{
++    if (grub_strlen(arg) == 6) {
++       int r = ((hex(arg[0]) << 4) | hex(arg[1])) >> 2;
++       int g = ((hex(arg[2]) << 4) | hex(arg[3])) >> 2;
++       int b = ((hex(arg[4]) << 4) | hex(arg[5])) >> 2;
++
++       window_border = (r << 16) | (g << 8) | b;
++       if (graphics_inited)
++           graphics_set_palette(0x11, r, g, b);
++
++       return 0;
++    }
++
++    return 1;
++}
++
++static struct builtin builtin_border =
++{
++  "border",
++  border_func,
++  BUILTIN_CMDLINE | BUILTIN_MENU | BUILTIN_HELP_LIST,
++  "border RRGGBB",
++  "Sets the border video color when in graphics mode."
++  "RR is red, GG is green, and BB blue. Numbers must be in hexadecimal."
++};
++
++
++/* viewport */
++static int
++viewport_func (char *arg, int flags)
++{
++    int i;
++    int x0 = 0, y0 = 0, x1 = 80, y1 = 30;
++    int *pos[4] = { &x0, &y0, &x1, &y1 };
++
++    if (!arg)
++       return (1);
++    for (i = 0; i < 4; i++) {
++       if (!*arg)
++           return (1);
++    while (*arg && (*arg == ' ' || *arg == '\t'))
++           ++arg;
++       if (!safe_parse_maxint(&arg, pos[i]))
++           return (1);
++       while (*arg && (*arg != ' ' && *arg != '\t'))
++           ++arg;
++    }
++
++    /* minimum size is 65 colums and 16 rows */
++    if (x0 > x1 - 66 || y0 > y1 - 16 || x0 < 0 || y0 < 0 || x1 > 80 || y1 > 
30)
++       return 1;
++
++    view_x0 = x0;
++    view_y0 = y0;
++    view_x1 = x1;
++    view_y1 = y1;
++
++    if (flags == BUILTIN_CMDLINE && graphics_inited) {
++       graphics_end();
++       graphics_init();
++       graphics_cls();
++    }
++
++    return 0;
++}
++
++static struct builtin builtin_viewport =
++{
++  "viewport",
++  viewport_func,
++  BUILTIN_CMDLINE | BUILTIN_MENU | BUILTIN_HELP_LIST,
++  "viewport x0 y0 x1 y1",
++  "Changes grub internals to output text in the window defined by"
++  " four parameters. The x and y parameters are 0 based. This option"
++  " only works with the graphics interface."
++};
++
++#endif /* SUPPORT_GRAPHICS */
++
++
++/* clear */
++static int 
++clear_func() 
++{
++  if (current_term->cls)
++    current_term->cls();
++
++  return 0;
++}
++
++static struct builtin builtin_clear =
++{
++  "clear",
++  clear_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "clear",
++  "Clear the screen"
++};
++
+ 
+ /* displayapm */
+ static int
+@@ -1454,14 +1720,20 @@
+ 
+ 
+ /* help */
+-#define MAX_SHORT_DOC_LEN     39
+-#define MAX_LONG_DOC_LEN      66
+-
+ static int
+ help_func (char *arg, int flags)
+ {
+-  int all = 0;
+-  
++  int all = 0, max_short_doc_len, max_long_doc_len;
++  max_short_doc_len = 39;
++  max_long_doc_len = 66;
++#ifdef SUPPORT_GRAPHICS
++  if (grub_memcmp (current_term->name, "graphics", sizeof ("graphics") - 1) 
== 0)
++    {
++      max_short_doc_len = (view_x1 - view_x0 + 1) / 2 - 1;
++      max_long_doc_len = (view_x1 - view_x0) - 14;
++    }
++#endif
++
+   if (grub_memcmp (arg, "--all", sizeof ("--all") - 1) == 0)
+     {
+       all = 1;
+@@ -1491,13 +1763,13 @@
+ 
+         len = grub_strlen ((*builtin)->short_doc);
+         /* If the length of SHORT_DOC is too long, truncate it.  */
+-        if (len > MAX_SHORT_DOC_LEN - 1)
+-          len = MAX_SHORT_DOC_LEN - 1;
++        if (len > max_short_doc_len - 1)
++          len = max_short_doc_len - 1;
+ 
+         for (i = 0; i < len; i++)
+           grub_putchar ((*builtin)->short_doc[i]);
+ 
+-        for (; i < MAX_SHORT_DOC_LEN; i++)
++        for (; i < max_short_doc_len; i++)
+           grub_putchar (' ');
+ 
+         if (! left)
+@@ -1546,10 +1818,10 @@
+                     int i;
+ 
+                     /* If LEN is too long, fold DOC.  */
+-                    if (len > MAX_LONG_DOC_LEN)
++                    if (len > max_long_doc_len)
+                       {
+                         /* Fold this line at the position of a space.  */
+-                        for (len = MAX_LONG_DOC_LEN; len > 0; len--)
++                        for (len = max_long_doc_len; len > 0; len--)
+                           if (doc[len - 1] == ' ')
+                             break;
+                       }
+@@ -4085,7 +4357,7 @@
+ };
+ 
+ 
+-#if defined(SUPPORT_SERIAL) || defined(SUPPORT_HERCULES)
++#if defined(SUPPORT_SERIAL) || defined(SUPPORT_HERCULES) || 
defined(SUPPORT_GRAPHICS)
+ /* terminal */
+ static int
+ terminal_func (char *arg, int flags)
+@@ -4244,17 +4516,29 @@
+  end:
+   current_term = term_table + default_term;
+   current_term->flags = term_flags;
+-  
++
+   if (lines)
+     max_lines = lines;
+   else
+-    /* 24 would be a good default value.  */
+-    max_lines = 24;
+-  
++    max_lines = current_term->max_lines;
++
+   /* If the interface is currently the command-line,
+      restart it to repaint the screen.  */
+-  if (current_term != prev_term && (flags & BUILTIN_CMDLINE))
++  if ((current_term != prev_term) && (flags & BUILTIN_CMDLINE)){
++    if (prev_term->shutdown)
++      prev_term->shutdown();
++    if (current_term->startup) {
++      /* If startup fails, return to previous term */
++      if (current_term->startup() == 0) {
++        current_term = prev_term;
++        max_lines = current_term->max_lines;
++        if (current_term->cls) {
++          current_term->cls();
++        }
++      }
++    }
+     grub_longjmp (restart_cmdline_env, 0);
++  }
+   
+   return 0;
+ }
+@@ -4264,7 +4548,7 @@
+   "terminal",
+   terminal_func,
+   BUILTIN_MENU | BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
+-  "terminal [--dumb] [--no-echo] [--no-edit] [--timeout=SECS] [--lines=LINES] 
[--silent] [console] [serial] [hercules]",
++  "terminal [--dumb] [--no-echo] [--no-edit] [--timeout=SECS] [--lines=LINES] 
[--silent] [console] [serial] [hercules] [graphics]",
+   "Select a terminal. When multiple terminals are specified, wait until"
+   " you push any key to continue. If both console and serial are specified,"
+   " the terminal to which you input a key first will be selected. If no"
+@@ -4276,7 +4560,7 @@
+   " seconds. The option --lines specifies the maximum number of lines."
+   " The option --silent is used to suppress messages."
+ };
+-#endif /* SUPPORT_SERIAL || SUPPORT_HERCULES */
++#endif /* SUPPORT_SERIAL || SUPPORT_HERCULES || SUPPORT_GRAPHICS */
+ 
+ 
+ #ifdef SUPPORT_SERIAL
+@@ -4795,13 +5079,20 @@
+ /* The table of builtin commands. Sorted in dictionary order.  */
+ struct builtin *builtin_table[] =
+ {
++#ifdef SUPPORT_GRAPHICS
++  &builtin_background,
++#endif
+   &builtin_blocklist,
+   &builtin_boot,
+ #ifdef SUPPORT_NETBOOT
+   &builtin_bootp,
+ #endif /* SUPPORT_NETBOOT */
++#ifdef SUPPORT_GRAPHICS
++  &builtin_border,
++#endif
+   &builtin_cat,
+   &builtin_chainloader,
++  &builtin_clear,
+   &builtin_cmp,
+   &builtin_color,
+   &builtin_configfile,
+@@ -4821,6 +5112,9 @@
+   &builtin_embed,
+   &builtin_fallback,
+   &builtin_find,
++#ifdef SUPPORT_GRAPHICS
++  &builtin_foreground,
++#endif
+   &builtin_fstest,
+   &builtin_geometry,
+   &builtin_halt,
+@@ -4864,9 +5158,13 @@
+ #endif /* SUPPORT_SERIAL */
+   &builtin_setkey,
+   &builtin_setup,
+-#if defined(SUPPORT_SERIAL) || defined(SUPPORT_HERCULES)
++#ifdef SUPPORT_GRAPHICS
++  &builtin_shade,
++  &builtin_splashimage,
++#endif /* SUPPORT_GRAPHICS */
++#if defined(SUPPORT_SERIAL) || defined(SUPPORT_HERCULES) || 
defined(SUPPORT_GRAPHICS)
+   &builtin_terminal,
+-#endif /* SUPPORT_SERIAL || SUPPORT_HERCULES */
++#endif /* SUPPORT_SERIAL || SUPPORT_HERCULES || SUPPORT_GRAPHICS */
+ #ifdef SUPPORT_SERIAL
+   &builtin_terminfo,
+ #endif /* SUPPORT_SERIAL */
+@@ -4880,5 +5178,8 @@
+   &builtin_unhide,
+   &builtin_uppermem,
+   &builtin_vbeprobe,
++#ifdef SUPPORT_GRAPHICS
++  &builtin_viewport,
++#endif
+   0
+ };
+diff -Naur grub-0.97.orig/stage2/char_io.c grub-0.97/stage2/char_io.c
+--- grub-0.97.orig/stage2/char_io.c    2005-02-01 18:51:23.000000000 -0200
++++ grub-0.97/stage2/char_io.c 2005-06-12 20:56:49.000000000 -0300
+@@ -29,12 +29,17 @@
+ # include <serial.h>
+ #endif
+ 
++#ifdef SUPPORT_GRAPHICS
++# include <graphics.h>
++#endif
++
+ #ifndef STAGE1_5
+ struct term_entry term_table[] =
+   {
+     {
+       "console",
+       0,
++      24,
+       console_putchar,
+       console_checkkey,
+       console_getkey,
+@@ -43,13 +48,16 @@
+       console_cls,
+       console_setcolorstate,
+       console_setcolor,
+-      console_setcursor
++      console_setcursor,
++      0, 
++      0
+     },
+ #ifdef SUPPORT_SERIAL
+     {
+       "serial",
+       /* A serial device must be initialized.  */
+       TERM_NEED_INIT,
++      24,
+       serial_putchar,
+       serial_checkkey,
+       serial_getkey,
+@@ -58,6 +66,8 @@
+       serial_cls,
+       serial_setcolorstate,
+       0,
++      0,
++      0, 
+       0
+     },
+ #endif /* SUPPORT_SERIAL */
+@@ -65,6 +75,7 @@
+     {
+       "hercules",
+       0,
++      24,
+       hercules_putchar,
+       console_checkkey,
+       console_getkey,
+@@ -73,11 +84,30 @@
+       hercules_cls,
+       hercules_setcolorstate,
+       hercules_setcolor,
+-      hercules_setcursor
++      hercules_setcursor,
++      0,
++      0
+     },      
+ #endif /* SUPPORT_HERCULES */
++#ifdef SUPPORT_GRAPHICS
++    { "graphics",
++      TERM_NEED_INIT, /* flags */
++      30, /* number of lines */
++      graphics_putchar, /* putchar */
++      console_checkkey, /* checkkey */
++      console_getkey, /* getkey */
++      graphics_getxy, /* getxy */
++      graphics_gotoxy, /* gotoxy */
++      graphics_cls, /* cls */
++      graphics_setcolorstate, /* setcolorstate */
++      graphics_setcolor, /* setcolor */
++      graphics_setcursor, /* nocursor */
++      graphics_init, /* initialize */
++      graphics_end /* shutdown */
++    },
++#endif /* SUPPORT_GRAPHICS */
+     /* This must be the last entry.  */
+-    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
++    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
+   };
+ 
+ /* This must be console.  */
+@@ -305,9 +335,10 @@
+ 
+   /* XXX: These should be defined in shared.h, but I leave these here,
+      until this code is freezed.  */
+-#define CMDLINE_WIDTH 78
+ #define CMDLINE_MARGIN        10
+-  
++
++  /* command-line limits */
++  int cmdline_width = 78, col_start = 0;
+   int xpos, lpos, c, section;
+   /* The length of PROMPT.  */
+   int plen;
+@@ -338,7 +369,7 @@
+       
+       /* If the cursor is in the first section, display the first section
+        instead of the second.  */
+-      if (section == 1 && plen + lpos < CMDLINE_WIDTH)
++      if (section == 1 && plen + lpos < cmdline_width)
+       cl_refresh (1, 0);
+       else if (xpos - count < 1)
+       cl_refresh (1, 0);
+@@ -354,7 +385,7 @@
+               grub_putchar ('\b');
+           }
+         else
+-          gotoxy (xpos, getxy () & 0xFF);
++          gotoxy (xpos + col_start, getxy () & 0xFF);
+       }
+     }
+ 
+@@ -364,7 +395,7 @@
+       lpos += count;
+ 
+       /* If the cursor goes outside, scroll the screen to the right.  */
+-      if (xpos + count >= CMDLINE_WIDTH)
++      if (xpos + count >= cmdline_width)
+       cl_refresh (1, 0);
+       else
+       {
+@@ -383,7 +414,7 @@
+               }
+           }
+         else
+-          gotoxy (xpos, getxy () & 0xFF);
++          gotoxy (xpos + col_start, getxy () & 0xFF);
+       }
+     }
+ 
+@@ -398,14 +429,14 @@
+       if (full)
+       {
+         /* Recompute the section number.  */
+-        if (lpos + plen < CMDLINE_WIDTH)
++        if (lpos + plen < cmdline_width)
+           section = 0;
+         else
+-          section = ((lpos + plen - CMDLINE_WIDTH)
+-                     / (CMDLINE_WIDTH - 1 - CMDLINE_MARGIN) + 1);
++          section = ((lpos + plen - cmdline_width)
++                     / (cmdline_width - 1 - CMDLINE_MARGIN) + 1);
+ 
+         /* From the start to the end.  */
+-        len = CMDLINE_WIDTH;
++        len = cmdline_width;
+         pos = 0;
+         grub_putchar ('\r');
+ 
+@@ -445,8 +476,8 @@
+         if (! full)
+           offset = xpos - 1;
+         
+-        start = ((section - 1) * (CMDLINE_WIDTH - 1 - CMDLINE_MARGIN)
+-                 + CMDLINE_WIDTH - plen - CMDLINE_MARGIN);
++        start = ((section - 1) * (cmdline_width - 1 - CMDLINE_MARGIN)
++                 + cmdline_width - plen - CMDLINE_MARGIN);
+         xpos = lpos + 1 - start;
+         start += offset;
+       }
+@@ -471,7 +502,7 @@
+       
+       /* If the cursor is at the last position, put `>' or a space,
+        depending on if there are more characters in BUF.  */
+-      if (pos == CMDLINE_WIDTH)
++      if (pos == cmdline_width)
+       {
+         if (start + len < llen)
+           grub_putchar ('>');
+@@ -488,7 +519,7 @@
+           grub_putchar ('\b');
+       }
+       else
+-      gotoxy (xpos, getxy () & 0xFF);
++      gotoxy (xpos + col_start, getxy () & 0xFF);
+     }
+ 
+   /* Initialize the command-line.  */
+@@ -518,10 +549,10 @@
+         
+         llen += l;
+         lpos += l;
+-        if (xpos + l >= CMDLINE_WIDTH)
++        if (xpos + l >= cmdline_width)
+           cl_refresh (1, 0);
+-        else if (xpos + l + llen - lpos > CMDLINE_WIDTH)
+-          cl_refresh (0, CMDLINE_WIDTH - xpos);
++        else if (xpos + l + llen - lpos > cmdline_width)
++          cl_refresh (0, cmdline_width - xpos);
+         else
+           cl_refresh (0, l + llen - lpos);
+       }
+@@ -533,12 +564,22 @@
+       grub_memmove (buf + lpos, buf + lpos + count, llen - count + 1);
+       llen -= count;
+       
+-      if (xpos + llen + count - lpos > CMDLINE_WIDTH)
+-      cl_refresh (0, CMDLINE_WIDTH - xpos);
++      if (xpos + llen + count - lpos > cmdline_width)
++      cl_refresh (0, cmdline_width - xpos);
+       else
+       cl_refresh (0, llen + count - lpos);
+     }
+ 
++  max_lines = current_term->max_lines;
++#ifdef SUPPORT_GRAPHICS
++  if (grub_memcmp (current_term->name, "graphics", sizeof ("graphics") - 1) 
== 0)
++    {
++      cmdline_width = (view_x1 - view_x0) - 2;
++      col_start = view_x0;
++      max_lines = view_y1 - view_y0;
++    }
++#endif
++
+   plen = grub_strlen (prompt);
+   llen = grub_strlen (cmdline);
+ 
+@@ -1006,6 +1047,48 @@
+ }
+ #endif /* ! STAGE1_5 */
+ 
++#ifndef STAGE1_5
++/* Internal pager.  */
++int
++do_more (void)
++{
++  if (count_lines >= 0)
++    {
++      count_lines++;
++      if (count_lines >= max_lines - 2)
++        {
++          int tmp;
++
++          /* It's important to disable the feature temporarily, because
++             the following grub_printf call will print newlines.  */
++          count_lines = -1;
++
++          grub_printf("\n");
++          if (current_term->setcolorstate)
++            current_term->setcolorstate (COLOR_STATE_HIGHLIGHT);
++
++          grub_printf ("[Hit return to continue]");
++
++          if (current_term->setcolorstate)
++            current_term->setcolorstate (COLOR_STATE_NORMAL);
++
++
++          do
++            {
++              tmp = ASCII_CHAR (getkey ());
++            }
++          while (tmp != '\n' && tmp != '\r');
++          grub_printf ("\r                        \r");
++
++          /* Restart to count lines.  */
++          count_lines = 0;
++          return 1;
++        }
++    }
++  return 0;
++}
++#endif
++
+ /* Display an ASCII character.  */
+ void
+ grub_putchar (int c)
+@@ -1034,38 +1117,11 @@
+ 
+   if (c == '\n')
+     {
++      int flag;
+       /* Internal `more'-like feature.  */
+-      if (count_lines >= 0)
+-      {
+-        count_lines++;
+-        if (count_lines >= max_lines - 2)
+-          {
+-            int tmp;
+-            
+-            /* It's important to disable the feature temporarily, because
+-               the following grub_printf call will print newlines.  */
+-            count_lines = -1;
+-
+-            if (current_term->setcolorstate)
+-              current_term->setcolorstate (COLOR_STATE_HIGHLIGHT);
+-            
+-            grub_printf ("\n[Hit return to continue]");
+-
+-            if (current_term->setcolorstate)
+-              current_term->setcolorstate (COLOR_STATE_NORMAL);
+-            
+-            do
+-              {
+-                tmp = ASCII_CHAR (getkey ());
+-              }
+-            while (tmp != '\n' && tmp != '\r');
+-            grub_printf ("\r                        \r");
+-            
+-            /* Restart to count lines.  */
+-            count_lines = 0;
+-            return;
+-          }
+-      }
++      flag = do_more ();
++      if (flag)
++        return;
+     }
+ 
+   current_term->putchar (c);
+@@ -1090,7 +1146,7 @@
+ cls (void)
+ {
+   /* If the terminal is dumb, there is no way to clean the terminal.  */
+-  if (current_term->flags & TERM_DUMB)
++  if (current_term->flags & TERM_DUMB) 
+     grub_putchar ('\n');
+   else
+     current_term->cls ();
+@@ -1217,6 +1273,16 @@
+   return ! errnum;
+ }
+ 
++void
++grub_memcpy(void *dest, const void *src, int len)
++{
++  int i;
++  register char *d = (char*)dest, *s = (char*)src;
++
++  for (i = 0; i < len; i++)
++    d[i] = s[i];
++}
++
+ void *
+ grub_memmove (void *to, const void *from, int len)
+ {
+diff -Naur grub-0.97.orig/stage2/cmdline.c grub-0.97/stage2/cmdline.c
+--- grub-0.97.orig/stage2/cmdline.c    2004-08-16 20:23:01.000000000 -0300
++++ grub-0.97/stage2/cmdline.c 2005-06-12 20:56:49.000000000 -0300
+@@ -50,10 +50,11 @@
+ void
+ print_cmdline_message (int forever)
+ {
+-  printf (" [ Minimal BASH-like line editing is supported.  For the first 
word, TAB\n"
+-        "   lists possible command completions.  Anywhere else TAB lists the 
possible\n"
+-        "   completions of a device/filename.%s ]\n",
+-        (forever ? "" : "  ESC at any time exits."));
++  grub_printf("       [ Minimal BASH-like line editing is supported.   For\n"
++              "         the   first   word,  TAB  lists  possible  command\n"
++              "         completions.  Anywhere else TAB lists the possible\n"
++              "         completions of a device/filename.%s ]\n",
++              (forever ? "" : "  ESC at any time\n         exits."));
+ }
+ 
+ /* Find the builtin whose command name is COMMAND and return the
+diff -Naur grub-0.97.orig/stage2/graphics.c grub-0.97/stage2/graphics.c
+--- grub-0.97.orig/stage2/graphics.c   1969-12-31 21:00:00.000000000 -0300
++++ grub-0.97/stage2/graphics.c        2005-06-13 19:13:31.000000000 -0300
+@@ -0,0 +1,585 @@
++/*
++ * graphics.c - graphics mode support for GRUB
++ * Implemented as a terminal type by Jeremy Katz <katzj@xxxxxxxxxx> based
++ * on a patch by Paulo César Pereira de Andrade <pcpa@xxxxxxxxxxxxxxxx>
++ * Options and enhancements made by Herton Ronaldo Krzesinski
++ * <herton@xxxxxxxxxxxx>
++ *
++ *  GRUB  --  GRand Unified Bootloader
++ *  Copyright (C) 2001,2002  Red Hat, Inc.
++ *  Portions copyright (C) 2000  Conectiva, 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 2 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, write to the Free Software
++ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ */
++
++#ifdef SUPPORT_GRAPHICS
++
++#include <term.h>
++#include <shared.h>
++#include <graphics.h>
++
++int saved_videomode;
++unsigned char *font8x16;
++
++int graphics_inited = 0;
++static char splashimage[256];
++
++int shade = 1, no_cursor = 0;
++
++#define VSHADOW VSHADOW1
++unsigned char VSHADOW1[38400];
++unsigned char VSHADOW2[38400];
++unsigned char VSHADOW4[38400];
++unsigned char VSHADOW8[38400];
++
++/* define the default viewable area */
++int view_x0 = 0;
++int view_y0 = 0;
++int view_x1 = 80;
++int view_y1 = 30;
++
++/* text buffer has to be kept around so that we can write things as we
++ * scroll and the like */
++unsigned short text[80 * 30];
++
++/* graphics options */
++int foreground = (63 << 16) | (63 << 8) | (63), background = 0, window_border 
= 0;
++
++/* current position */
++static int fontx = 0;
++static int fonty = 0;
++
++/* global state so that we don't try to recursively scroll or cursor */
++static int no_scroll = 0;
++
++/* color state */
++static int graphics_standard_color = A_NORMAL;
++static int graphics_normal_color = A_NORMAL;
++static int graphics_highlight_color = A_REVERSE;
++static int graphics_current_color = A_NORMAL;
++static color_state graphics_color_state = COLOR_STATE_STANDARD;
++
++static inline void outb(unsigned short port, unsigned char val)
++{
++    __asm __volatile ("outb %0,%1"::"a" (val), "d" (port));
++}
++
++static void MapMask(int value) {
++    outb(0x3c4, 2);
++    outb(0x3c5, value);
++}
++
++/* bit mask register */
++static void BitMask(int value) {
++    outb(0x3ce, 8);
++    outb(0x3cf, value);
++}
++
++/* move the graphics cursor location to col, row */
++static void graphics_setxy(int col, int row) {
++    if (col >= view_x0 && col < view_x1) {
++        fontx = col;
++        cursorX = col << 3;
++    }
++    if (row >= view_y0 && row < view_y1) {
++        fonty = row;
++        cursorY = row << 4;
++    }
++}
++
++/* scroll the screen */
++static void graphics_scroll() {
++    int i, j, k;
++
++    /* we don't want to scroll recursively... that would be bad */
++    if (no_scroll)
++        return;
++    no_scroll = 1;
++
++    /* disable pager temporarily */
++    k = count_lines;
++    count_lines = -1;
++    
++    /* move everything up a line */
++    for (j = view_y0 + 1; j < view_y1; j++) {
++        graphics_gotoxy(view_x0, j - 1);
++        for (i = view_x0; i < view_x1; i++) {
++            graphics_putchar(text[j * 80 + i]);
++        }
++    }
++
++    /* last line should be blank */
++    graphics_gotoxy(view_x0, view_y1 - 1);
++    for (i = view_x0; i < view_x1; i++)
++        graphics_putchar(' ');
++    graphics_setxy(view_x0, view_y1 - 1);
++
++    count_lines = k;
++
++    no_scroll = 0;
++}
++
++/* Set the splash image */
++void graphics_set_splash(char *splashfile) {
++    grub_strcpy(splashimage, splashfile);
++}
++
++/* Get the current splash image */
++char *graphics_get_splash(void) {
++    return splashimage;
++}
++
++/* 
++ * Initialize a vga16 graphics display with the palette based off of
++ * the image in splashimage.  If the image doesn't exist, leave graphics
++ * mode. The mode initiated is 12h. From "Ralf Brown's Interrupt List":
++ *      text/ text pixel   pixel   colors disply scrn  system
++ *      grph resol  box  resolution       pages  addr
++ * 12h   G   80x30  8x16  640x480  16/256K  .    A000  VGA,ATI VIP
++ *       G   80x30  8x16  640x480  16/64    .    A000  ATI EGA Wonder
++ *       G     .     .    640x480  16       .      .   UltraVision+256K EGA
++ */
++int graphics_init()
++{
++    if (!graphics_inited) {
++        saved_videomode = set_videomode(0x12);
++        if (get_videomode() != 0x12) {
++            set_videomode(saved_videomode);
++            return 0;
++        }
++        graphics_inited = 1;
++    }
++    else
++        return 1;
++
++    font8x16 = (unsigned char*)graphics_get_font();
++
++    /* make sure that the highlight color is set correctly */
++    graphics_highlight_color = ((graphics_normal_color >> 4) | 
++                                ((graphics_normal_color & 0xf) << 4));
++
++    graphics_cls();
++
++    if (!read_image(splashimage)) {
++        grub_printf("Failed to read splash image (%s)\n", splashimage);
++        grub_printf("Press any key to continue...");
++        getkey();
++        set_videomode(saved_videomode);
++        graphics_inited = 0;
++        return 0;
++    }
++
++    set_int1c_handler();
++
++    return 1;
++}
++
++/* Leave graphics mode */
++void graphics_end(void)
++{
++    if (graphics_inited) {
++        unset_int1c_handler();
++        set_videomode(saved_videomode);
++        graphics_inited = 0;
++        no_cursor = 0;
++    }
++}
++
++/* Print ch on the screen.  Handle any needed scrolling or the like */
++void graphics_putchar(int ch) {
++    ch &= 0xff;
++
++    graphics_cursor(0);
++
++    if (ch == '\n') {
++        if (fonty + 1 < view_y1)
++            graphics_setxy(fontx, fonty + 1);
++        else
++            graphics_scroll();
++        graphics_cursor(1);
++        return;
++    } else if (ch == '\r') {
++        graphics_setxy(view_x0, fonty);
++        graphics_cursor(1);
++        return;
++    }
++
++    graphics_cursor(0);
++
++    text[fonty * 80 + fontx] = ch;
++    text[fonty * 80 + fontx] &= 0x00ff;
++    if (graphics_current_color & 0xf0)
++        text[fonty * 80 + fontx] |= 0x100;
++
++    graphics_cursor(0);
++
++    if ((fontx + 1) >= view_x1) {
++        graphics_setxy(view_x0, fonty);
++        if (fonty + 1 < view_y1)
++            graphics_setxy(view_x0, fonty + 1);
++        else
++            graphics_scroll();
++        graphics_cursor(1);
++        do_more ();
++        graphics_cursor(0);
++    } else {
++        graphics_setxy(fontx + 1, fonty);
++    }
++
++    graphics_cursor(1);
++}
++
++/* get the current location of the cursor */
++int graphics_getxy(void) {
++    return (fontx << 8) | fonty;
++}
++
++void graphics_gotoxy(int x, int y) {
++    graphics_cursor(0);
++
++    graphics_setxy(x, y);
++
++    graphics_cursor(1);
++}
++
++void graphics_cls(void) {
++    int i;
++    unsigned char *mem, *s1, *s2, *s4, *s8;
++
++    graphics_cursor(0);
++    graphics_gotoxy(view_x0, view_y0);
++
++    mem = (unsigned char*)VIDEOMEM;
++    s1 = (unsigned char*)VSHADOW1;
++    s2 = (unsigned char*)VSHADOW2;
++    s4 = (unsigned char*)VSHADOW4;
++    s8 = (unsigned char*)VSHADOW8;
++
++    for (i = 0; i < 80 * 30; i++)
++        text[i] = ' ';
++    graphics_cursor(1);
++
++    BitMask(0xff);
++
++    /* plane 1 */
++    MapMask(1);
++    grub_memcpy(mem, s1, 38400);
++
++    /* plane 2 */
++    MapMask(2);
++    grub_memcpy(mem, s2, 38400);
++
++    /* plane 3 */
++    MapMask(4);
++    grub_memcpy(mem, s4, 38400);
++
++    /* plane 4 */
++    MapMask(8);
++    grub_memcpy(mem, s8, 38400);
++
++    MapMask(15);
++
++    if (no_cursor) {
++        no_cursor = 0;
++        set_int1c_handler();
++    }
++}
++
++void graphics_setcolorstate (color_state state) {
++    switch (state) {
++    case COLOR_STATE_STANDARD:
++        graphics_current_color = graphics_standard_color;
++        break;
++    case COLOR_STATE_NORMAL:
++        graphics_current_color = graphics_normal_color;
++        break;
++    case COLOR_STATE_HIGHLIGHT:
++        graphics_current_color = graphics_highlight_color;
++        break;
++    default:
++        graphics_current_color = graphics_standard_color;
++        break;
++    }
++
++    graphics_color_state = state;
++}
++
++void graphics_setcolor (int normal_color, int highlight_color) {
++    graphics_normal_color = normal_color;
++    graphics_highlight_color = highlight_color;
++
++    graphics_setcolorstate (graphics_color_state);
++}
++
++int graphics_setcursor (int on) {
++    if (!no_cursor && !on) {
++        no_cursor = 1;
++        unset_int1c_handler();
++        graphics_cursor(0);
++    }
++    else if(no_cursor && on) {
++        no_cursor = 0;
++        set_int1c_handler();
++        graphics_cursor(1);
++    }
++    return 0;
++}
++
++/* Read in the splashscreen image and set the palette up appropriately.
++ * Format of splashscreen is an xpm (can be gzipped) with 16 colors and
++ * 640x480. */
++int read_image(char *s)
++{
++    char buf[32], pal[16], c;
++    unsigned char base, mask, *s1, *s2, *s4, *s8;
++    unsigned i, len, idx, colors, x, y, width, height;
++
++    if (!grub_open(s))
++        return 0;
++
++    /* read header */
++    if (!grub_read((char*)&buf, 10) || grub_memcmp(buf, "/* XPM */\n", 10)) {
++        grub_close();
++        return 0;
++    }
++    
++    /* parse info */
++    while (grub_read(&c, 1)) {
++        if (c == '"')
++            break;
++    }
++
++    while (grub_read(&c, 1) && (c == ' ' || c == '\t'))
++        ;
++
++    i = 0;
++    width = c - '0';
++    while (grub_read(&c, 1)) {
++        if (c >= '0' && c <= '9')
++            width = width * 10 + c - '0';
++        else
++            break;
++    }
++    while (grub_read(&c, 1) && (c == ' ' || c == '\t'))
++        ;
++
++    height = c - '0';
++    while (grub_read(&c, 1)) {
++        if (c >= '0' && c <= '9')
++            height = height * 10 + c - '0';
++        else
++            break;
++    }
++    while (grub_read(&c, 1) && (c == ' ' || c == '\t'))
++        ;
++
++    colors = c - '0';
++    while (grub_read(&c, 1)) {
++        if (c >= '0' && c <= '9')
++            colors = colors * 10 + c - '0';
++        else
++            break;
++    }
++
++    base = 0;
++    while (grub_read(&c, 1) && c != '"')
++        ;
++
++    /* palette */
++    for (i = 0, idx = 1; i < colors; i++) {
++        len = 0;
++
++        while (grub_read(&c, 1) && c != '"')
++            ;
++        grub_read(&c, 1);       /* char */
++        base = c;
++        grub_read(buf, 4);      /* \t c # */
++
++        while (grub_read(&c, 1) && c != '"') {
++            if (len < sizeof(buf))
++                buf[len++] = c;
++        }
++
++        if (len == 6 && idx < 15) {
++            int r = ((hex(buf[0]) << 4) | hex(buf[1])) >> 2;
++            int g = ((hex(buf[2]) << 4) | hex(buf[3])) >> 2;
++            int b = ((hex(buf[4]) << 4) | hex(buf[5])) >> 2;
++
++            pal[idx] = base;
++            graphics_set_palette(idx, r, g, b);
++            ++idx;
++        }
++    }
++
++    x = y = len = 0;
++
++    s1 = (unsigned char*)VSHADOW1;
++    s2 = (unsigned char*)VSHADOW2;
++    s4 = (unsigned char*)VSHADOW4;
++    s8 = (unsigned char*)VSHADOW8;
++
++    for (i = 0; i < 38400; i++)
++        s1[i] = s2[i] = s4[i] = s8[i] = 0;
++
++    /* parse xpm data */
++    while (y < height) {
++        while (1) {
++            if (!grub_read(&c, 1)) {
++                grub_close();
++                return 0;
++            }
++            if (c == '"')
++                break;
++        }
++
++        while (grub_read(&c, 1) && c != '"') {
++            for (i = 1; i < 15; i++)
++                if (pal[i] == c) {
++                    c = i;
++                    break;
++                }
++
++            mask = 0x80 >> (x & 7);
++            if (c & 1)
++                s1[len + (x >> 3)] |= mask;
++            if (c & 2)
++                s2[len + (x >> 3)] |= mask;
++            if (c & 4)
++                s4[len + (x >> 3)] |= mask;
++            if (c & 8)
++                s8[len + (x >> 3)] |= mask;
++
++            if (++x >= 640) {
++                x = 0;
++
++                if (y < 480)
++                    len += 80;
++                ++y;
++            }
++        }
++    }
++
++    grub_close();
++
++    graphics_set_palette(0, (background >> 16), (background >> 8) & 63, 
++                background & 63);
++    graphics_set_palette(15, (foreground >> 16), (foreground >> 8) & 63, 
++                foreground & 63);
++    graphics_set_palette(0x11, (window_border >> 16), (window_border >> 8) & 
63, 
++                         window_border & 63);
++
++    return 1;
++}
++
++/* Convert a character which is a hex digit to the appropriate integer */
++int hex(int v)
++{
++    if (v >= 'A' && v <= 'F')
++        return (v - 'A' + 10);
++    if (v >= 'a' && v <= 'f')
++        return (v - 'a' + 10);
++    return (v - '0');
++}
++
++void graphics_cursor(int set) {
++    unsigned char *pat, *mem, *ptr, chr[16 << 2];
++    int i, ch, invert, offset;
++
++    if (set && (no_cursor || no_scroll))
++        return;
++
++    offset = cursorY * 80 + fontx;
++    ch = text[fonty * 80 + fontx] & 0xff;
++    invert = (text[fonty * 80 + fontx] & 0xff00) != 0;
++    pat = font8x16 + (ch << 4);
++
++    mem = (unsigned char*)VIDEOMEM + offset;
++
++    if (!set) {
++        for (i = 0; i < 16; i++) {
++            unsigned char mask = pat[i];
++
++            if (!invert) {
++                chr[i     ] = ((unsigned char*)VSHADOW1)[offset];
++                chr[16 + i] = ((unsigned char*)VSHADOW2)[offset];
++                chr[32 + i] = ((unsigned char*)VSHADOW4)[offset];
++                chr[48 + i] = ((unsigned char*)VSHADOW8)[offset];
++
++                if (shade) {
++                    if (ch == DISP_VERT || ch == DISP_LL ||
++                        ch == DISP_UR || ch == DISP_LR) {
++                        unsigned char pmask = ~(pat[i] >> 1);
++
++                        chr[i     ] &= pmask;
++                        chr[16 + i] &= pmask;
++                        chr[32 + i] &= pmask;
++                        chr[48 + i] &= pmask;
++                    }
++                    if (i > 0 && ch != DISP_VERT) {
++                        unsigned char pmask = ~(pat[i - 1] >> 1);
++
++                        chr[i     ] &= pmask;
++                        chr[16 + i] &= pmask;
++                        chr[32 + i] &= pmask;
++                        chr[48 + i] &= pmask;
++                        if (ch == DISP_HORIZ || ch == DISP_UR || ch == 
DISP_LR) {
++                            pmask = ~pat[i - 1];
++
++                            chr[i     ] &= pmask;
++                            chr[16 + i] &= pmask;
++                            chr[32 + i] &= pmask;
++                            chr[48 + i] &= pmask;
++                        }
++                    }
++                }
++                chr[i     ] |= mask;
++                chr[16 + i] |= mask;
++                chr[32 + i] |= mask;
++                chr[48 + i] |= mask;
++
++                offset += 80;
++            }
++            else {
++                chr[i     ] = mask;
++                chr[16 + i] = mask;
++                chr[32 + i] = mask;
++                chr[48 + i] = mask;
++            }
++        }
++    }
++    else {
++        MapMask(15);
++        ptr = mem;
++        for (i = 0; i < 16; i++, ptr += 80) {
++            cursorBuf[i] = pat[i];
++            *ptr = ~pat[i];
++        }
++        return;
++    }
++
++    offset = 0;
++    for (i = 1; i < 16; i <<= 1, offset += 16) {
++        int j;
++
++        MapMask(i);
++        ptr = mem;
++        for (j = 0; j < 16; j++, ptr += 80)
++            *ptr = chr[j + offset];
++    }
++
++    MapMask(15);
++}
++
++#endif /* SUPPORT_GRAPHICS */
+diff -Naur grub-0.97.orig/stage2/graphics.h grub-0.97/stage2/graphics.h
+--- grub-0.97.orig/stage2/graphics.h   1969-12-31 21:00:00.000000000 -0300
++++ grub-0.97/stage2/graphics.h        2005-06-12 20:56:49.000000000 -0300
+@@ -0,0 +1,44 @@
++/* graphics.h - graphics console interface */
++/*
++ *  GRUB  --  GRand Unified Bootloader
++ *  Copyright (C) 2002  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 2 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, write to the Free Software
++ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ */
++
++#ifndef GRAPHICS_H
++#define GRAPHICS_H
++
++/* magic constant */
++#define VIDEOMEM 0xA0000
++
++/* function prototypes */
++char *graphics_get_splash(void);
++
++int read_image(char *s);
++void graphics_cursor(int set);
++
++/* function prototypes for asm functions */
++void * graphics_get_font();
++void graphics_set_palette(int idx, int red, int green, int blue);
++void set_int1c_handler();
++void unset_int1c_handler();
++
++extern short cursorX, cursorY;
++extern char cursorBuf[16];
++extern int shade;
++extern int view_x0, view_y0, view_x1, view_y1;
++
++#endif /* GRAPHICS_H */
+diff -Naur grub-0.97.orig/stage2/Makefile.am grub-0.97/stage2/Makefile.am
+--- grub-0.97.orig/stage2/Makefile.am  2005-02-02 18:37:35.000000000 -0200
++++ grub-0.97/stage2/Makefile.am       2005-06-12 20:56:49.000000000 -0300
+@@ -7,7 +7,7 @@
+         fat.h filesys.h freebsd.h fs.h hercules.h i386-elf.h \
+       imgact_aout.h iso9660.h jfs.h mb_header.h mb_info.h md5.h \
+       nbi.h pc_slice.h serial.h shared.h smp-imps.h term.h \
+-      terminfo.h tparm.h nbi.h ufs2.h vstafs.h xfs.h
++      terminfo.h tparm.h nbi.h ufs2.h vstafs.h xfs.h graphics.h
+ EXTRA_DIST = setjmp.S apm.S $(noinst_SCRIPTS)
+ 
+ # For <stage1.h>.
+@@ -19,7 +19,7 @@
+       disk_io.c fsys_ext2fs.c fsys_fat.c fsys_ffs.c fsys_iso9660.c \
+       fsys_jfs.c fsys_minix.c fsys_reiserfs.c fsys_ufs2.c \
+       fsys_vstafs.c fsys_xfs.c gunzip.c md5.c serial.c stage2.c \
+-      terminfo.c tparm.c
++      terminfo.c tparm.c graphics.c
+ libgrub_a_CFLAGS = $(GRUB_CFLAGS) -I$(top_srcdir)/lib \
+       -DGRUB_UTIL=1 -DFSYS_EXT2FS=1 -DFSYS_FAT=1 -DFSYS_FFS=1 \
+       -DFSYS_ISO9660=1 -DFSYS_JFS=1 -DFSYS_MINIX=1 -DFSYS_REISERFS=1 \
+@@ -79,8 +79,14 @@
+ HERCULES_FLAGS =
+ endif
+ 
++if GRAPHICS_SUPPORT
++GRAPHICS_FLAGS = -DSUPPORT_GRAPHICS=1
++else
++GRAPHICS_FLAGS =
++endif
++
+ STAGE2_COMPILE = $(STAGE2_CFLAGS) -fno-builtin -nostdinc \
+-      $(NETBOOT_FLAGS) $(SERIAL_FLAGS) $(HERCULES_FLAGS)
++      $(NETBOOT_FLAGS) $(SERIAL_FLAGS) $(HERCULES_FLAGS) $(GRAPHICS_FLAGS)
+ 
+ STAGE1_5_LINK = -nostdlib -Wl,-N -Wl,-Ttext -Wl,2000
+ STAGE1_5_COMPILE = $(STAGE2_COMPILE) -DNO_DECOMPRESSION=1 -DSTAGE1_5=1
+@@ -90,7 +96,8 @@
+       cmdline.c common.c console.c disk_io.c fsys_ext2fs.c \
+       fsys_fat.c fsys_ffs.c fsys_iso9660.c fsys_jfs.c fsys_minix.c \
+       fsys_reiserfs.c fsys_ufs2.c fsys_vstafs.c fsys_xfs.c gunzip.c \
+-      hercules.c md5.c serial.c smp-imps.c stage2.c terminfo.c tparm.c
++      hercules.c md5.c serial.c smp-imps.c stage2.c terminfo.c tparm.c \
++      graphics.c
+ pre_stage2_exec_CFLAGS = $(STAGE2_COMPILE) $(FSYS_CFLAGS)
+ pre_stage2_exec_CCASFLAGS = $(STAGE2_COMPILE) $(FSYS_CFLAGS)
+ pre_stage2_exec_LDFLAGS = $(PRE_STAGE2_LINK)
+diff -Naur grub-0.97.orig/stage2/shared.h grub-0.97/stage2/shared.h
+--- grub-0.97.orig/stage2/shared.h     2004-06-19 13:40:09.000000000 -0300
++++ grub-0.97/stage2/shared.h  2005-06-12 20:56:49.000000000 -0300
+@@ -792,6 +792,11 @@
+ /* Set the cursor position. */
+ void gotoxy (int x, int y);
+ 
++/* Internal pager
++   Returns 1 = if pager was used
++           0 = if pager wasn't used  */
++int do_more (void);
++
+ /* Displays an ASCII character.  IBM displays will translate some
+    characters to special graphical ones (see the DISP_* constants). */
+ void grub_putchar (int c);
+@@ -871,6 +876,7 @@
+ int grub_tolower (int c);
+ int grub_isspace (int c);
+ int grub_strncat (char *s1, const char *s2, int n);
++void grub_memcpy(void *dest, const void *src, int len);
+ void *grub_memmove (void *to, const void *from, int len);
+ void *grub_memset (void *start, int c, int len);
+ int grub_strncat (char *s1, const char *s2, int n);
+diff -Naur grub-0.97.orig/stage2/stage2.c grub-0.97/stage2/stage2.c
+--- grub-0.97.orig/stage2/stage2.c     2005-03-19 14:51:57.000000000 -0300
++++ grub-0.97/stage2/stage2.c  2005-06-13 22:38:08.000000000 -0300
+@@ -20,6 +20,12 @@
+ #include <shared.h>
+ #include <term.h>
+ 
++#ifdef SUPPORT_GRAPHICS
++# include <graphics.h>
++#endif
++
++int col_start, col_end, row_start, box_size;
++
+ grub_jmp_buf restart_env;
+ 
+ #if defined(PRESET_MENU_STRING) || defined(SUPPORT_DISKLESS)
+@@ -105,13 +111,13 @@
+   if (highlight && current_term->setcolorstate)
+     current_term->setcolorstate (COLOR_STATE_HIGHLIGHT);
+ 
+-  gotoxy (2, y);
++  gotoxy (2 + col_start, y);
+   grub_putchar (' ');
+-  for (x = 3; x < 75; x++)
++  for (x = 3 + col_start; x < (col_end - 5); x++)
+     {
+-      if (*entry && x <= 72)
++      if (*entry && x <= (col_end - 8))
+       {
+-        if (x == 72)
++        if (x == (col_end - 8))
+           grub_putchar (DISP_RIGHT);
+         else
+           grub_putchar (*entry++);
+@@ -119,7 +125,7 @@
+       else
+       grub_putchar (' ');
+     }
+-  gotoxy (74, y);
++  gotoxy ((col_end - 6), y);
+ 
+   if (current_term->setcolorstate)
+     current_term->setcolorstate (COLOR_STATE_STANDARD);
+@@ -131,7 +137,7 @@
+ {
+   int i;
+   
+-  gotoxy (77, y + 1);
++  gotoxy ((col_end - 3), y + 1);
+ 
+   if (first)
+     grub_putchar (DISP_UP);
+@@ -151,14 +157,14 @@
+       menu_entries++;
+     }
+ 
+-  gotoxy (77, y + size);
++  gotoxy ((col_end - 3), y + size);
+ 
+   if (*menu_entries)
+     grub_putchar (DISP_DOWN);
+   else
+     grub_putchar (' ');
+ 
+-  gotoxy (74, y + entryno + 1);
++  gotoxy ((col_end - 6), y + entryno + 1);
+ }
+ 
+ static void
+@@ -196,30 +202,30 @@
+   if (current_term->setcolorstate)
+     current_term->setcolorstate (COLOR_STATE_NORMAL);
+   
+-  gotoxy (1, y);
++  gotoxy (1 + col_start, y);
+ 
+   grub_putchar (DISP_UL);
+-  for (i = 0; i < 73; i++)
++  for (i = col_start; i < (col_end - 7); i++)
+     grub_putchar (DISP_HORIZ);
+   grub_putchar (DISP_UR);
+ 
+   i = 1;
+   while (1)
+     {
+-      gotoxy (1, y + i);
++      gotoxy (1 + col_start, y + i);
+ 
+       if (i > size)
+       break;
+       
+       grub_putchar (DISP_VERT);
+-      gotoxy (75, y + i);
++      gotoxy ((col_end - 5), y + i);
+       grub_putchar (DISP_VERT);
+ 
+       i++;
+     }
+ 
+   grub_putchar (DISP_LL);
+-  for (i = 0; i < 73; i++)
++  for (i = col_start; i < (col_end - 7); i++)
+     grub_putchar (DISP_HORIZ);
+   grub_putchar (DISP_LR);
+ 
+@@ -233,6 +239,7 @@
+ {
+   int c, time1, time2 = -1, first_entry = 0;
+   char *cur_entry = 0;
++  struct term_entry *prev_term = NULL;
+ 
+   /*
+    *  Main loop for menu UI.
+@@ -250,6 +257,22 @@
+       }
+     }
+ 
++  col_start = 0;
++  col_end = 80;
++  row_start = 0;
++  box_size = 12;
++  /* if we're using viewport we need to make sure to setup
++     coordinates correctly.  */
++#ifdef SUPPORT_GRAPHICS
++  if (grub_memcmp (current_term->name, "graphics", sizeof ("graphics") - 1) 
== 0)
++    {
++      col_start = view_x0;
++      col_end = view_x1;
++      row_start = view_y0;
++      box_size = (view_y1 - view_y0) - 13;
++    }
++#endif
++
+   /* If the timeout was expired or wasn't set, force to show the menu
+      interface. */
+   if (grub_timeout < 0)
+@@ -302,36 +325,36 @@
+       if (current_term->flags & TERM_DUMB)
+       print_entries_raw (num_entries, first_entry, menu_entries);
+       else
+-      print_border (3, 12);
++      print_border (3 + row_start, box_size);
+ 
+       grub_printf ("\n\
+-      Use the %c and %c keys to select which entry is highlighted.\n",
++    Use the %c and %c keys to select which entry is highlighted.\n",
+                  DISP_UP, DISP_DOWN);
+       
+       if (! auth && password)
+       {
+         printf ("\
+-      Press enter to boot the selected OS or \'p\' to enter a\n\
+-      password to unlock the next set of features.");
++    Press enter to boot the selected OS or \'p\' to enter a\n\
++    password to unlock the next set of features.");
+       }
+       else
+       {
+         if (config_entries)
+           printf ("\
+-      Press enter to boot the selected OS, \'e\' to edit the\n\
+-      commands before booting, or \'c\' for a command-line.");
++    Press enter to boot the selected OS, \'e\' to edit the\n\
++    commands before booting, or \'c\' for a command-line.");
+         else
+           printf ("\
+-      Press \'b\' to boot, \'e\' to edit the selected command in the\n\
+-      boot sequence, \'c\' for a command-line, \'o\' to open a new line\n\
+-      after (\'O\' for before) the selected line, \'d\' to remove the\n\
+-      selected line, or escape to go back to the main menu.");
++    Press \'b\' to boot, \'e\' to edit the selected command in the\n\
++    boot sequence, \'c\' for a command-line, \'o\' to open a new line\n\
++    after (\'O\' for before) the selected line, \'d\' to remove the\n\
++    selected line, or escape to go back to the main menu.");
+       }
+ 
+       if (current_term->flags & TERM_DUMB)
+       grub_printf ("\n\nThe selected entry is %d ", entryno);
+       else
+-      print_entries (3, 12, first_entry, entryno, menu_entries);
++      print_entries (3 + row_start, box_size, first_entry, entryno, 
menu_entries);
+     }
+ 
+   /* XX using RT clock now, need to initialize value */
+@@ -358,10 +381,10 @@
+                          entryno, grub_timeout);
+         else
+           {
+-            gotoxy (3, 22);
+-            grub_printf ("The highlighted entry will be booted automatically 
in %d seconds.    ",
++            gotoxy (3 + col_start, 10 + box_size + row_start);
++            grub_printf (" The highlighted entry will be booted automatically 
in %d seconds.   ",
+                          grub_timeout);
+-            gotoxy (74, 4 + entryno);
++            gotoxy ((col_end - 6), 4 + entryno + row_start);
+         }
+         
+         grub_timeout--;
+@@ -387,12 +410,12 @@
+             if (current_term->flags & TERM_DUMB)
+               grub_putchar ('\r');
+             else
+-              gotoxy (3, 22);
++              gotoxy (3 + col_start, 10 + box_size + row_start);
+             printf ("                                                         
           ");
+             grub_timeout = -1;
+             fallback_entryno = -1;
+             if (! (current_term->flags & TERM_DUMB))
+-              gotoxy (74, 4 + entryno);
++              gotoxy ((col_end - 6), 4 + entryno + row_start);
+           }
+ 
+         /* We told them above (at least in SUPPORT_SERIAL) to use
+@@ -408,12 +431,12 @@
+               {
+                 if (entryno > 0)
+                   {
+-                    print_entry (4 + entryno, 0,
++                    print_entry (4 + entryno + row_start, 0,
+                                  get_entry (menu_entries,
+                                             first_entry + entryno,
+                                             0));
+                     entryno--;
+-                    print_entry (4 + entryno, 1,
++                    print_entry (4 + entryno + row_start, 1,
+                                  get_entry (menu_entries,
+                                             first_entry + entryno,
+                                             0));
+@@ -421,7 +444,7 @@
+                 else if (first_entry > 0)
+                   {
+                     first_entry--;
+-                    print_entries (3, 12, first_entry, entryno,
++                    print_entries (3 + row_start, box_size, first_entry, 
entryno,
+                                    menu_entries);
+                   }
+               }
+@@ -433,29 +456,29 @@
+               entryno++;
+             else
+               {
+-                if (entryno < 11)
++                if (entryno < (box_size - 1))
+                   {
+-                    print_entry (4 + entryno, 0,
++                    print_entry (4 + entryno + row_start, 0,
+                                  get_entry (menu_entries,
+                                             first_entry + entryno,
+                                             0));
+                     entryno++;
+-                    print_entry (4 + entryno, 1,
++                    print_entry (4 + entryno + row_start, 1,
+                                  get_entry (menu_entries,
+                                             first_entry + entryno,
+                                             0));
+                 }
+-              else if (num_entries > 12 + first_entry)
++              else if (num_entries > box_size + first_entry)
+                 {
+                   first_entry++;
+-                  print_entries (3, 12, first_entry, entryno, menu_entries);
++                  print_entries (3 + row_start, box_size, first_entry, 
entryno, menu_entries);
+                 }
+               }
+           }
+         else if (c == 7)
+           {
+             /* Page Up */
+-            first_entry -= 12;
++            first_entry -= box_size;
+             if (first_entry < 0)
+               {
+                 entryno += first_entry;
+@@ -463,20 +486,20 @@
+                 if (entryno < 0)
+                   entryno = 0;
+               }
+-            print_entries (3, 12, first_entry, entryno, menu_entries);
++            print_entries (3 + row_start, box_size, first_entry, entryno, 
menu_entries);
+           }
+         else if (c == 3)
+           {
+             /* Page Down */
+-            first_entry += 12;
++            first_entry += box_size;
+             if (first_entry + entryno + 1 >= num_entries)
+               {
+-                first_entry = num_entries - 12;
++                first_entry = num_entries - box_size;
+                 if (first_entry < 0)
+                   first_entry = 0;
+                 entryno = num_entries - first_entry - 1;
+               }
+-            print_entries (3, 12, first_entry, entryno, menu_entries);
++            print_entries (3 + row_start, box_size, first_entry, entryno, 
menu_entries);
+           }
+ 
+         if (config_entries)
+@@ -489,7 +512,7 @@
+             if ((c == 'd') || (c == 'o') || (c == 'O'))
+               {
+                 if (! (current_term->flags & TERM_DUMB))
+-                  print_entry (4 + entryno, 0,
++                  print_entry (4 + entryno + row_start, 0,
+                                get_entry (menu_entries,
+                                           first_entry + entryno,
+                                           0));
+@@ -537,7 +560,7 @@
+ 
+                     if (entryno >= num_entries)
+                       entryno--;
+-                    if (first_entry && num_entries < 12 + first_entry)
++                    if (first_entry && num_entries < box_size + first_entry)
+                       first_entry--;
+                   }
+ 
+@@ -549,7 +572,7 @@
+                     grub_printf ("\n");
+                   }
+                 else
+-                  print_entries (3, 12, first_entry, entryno, menu_entries);
++                  print_entries (3 + row_start, box_size, first_entry, 
entryno, menu_entries);
+               }
+ 
+             cur_entry = menu_entries;
+@@ -570,7 +593,7 @@
+                 if (current_term->flags & TERM_DUMB)
+                   grub_printf ("\r                                    ");
+                 else
+-                  gotoxy (1, 21);
++                  gotoxy (1 + col_start, 9 + box_size + row_start);
+ 
+                 /* Wipe out the previously entered password */
+                 grub_memset (entered, 0, sizeof (entered));
+@@ -714,6 +737,15 @@
+   
+   cls ();
+   setcursor (1);
++  /* if our terminal needed initialization, we should shut it down
++   * before booting the kernel, but we want to save what it was so
++   * we can come back if needed */
++  prev_term = current_term;
++  if (current_term->shutdown) 
++    {
++      current_term->shutdown();
++      current_term = term_table; /* assumption: console is first */
++    }
+   
+   while (1)
+     {
+@@ -748,6 +780,13 @@
+       break;
+     }
+ 
++  /* if we get back here, we should go back to what our term was before */
++  current_term = prev_term;
++  if (current_term->startup)
++      /* if our terminal fails to initialize, fall back to console since
++       * it should always work */
++      if (current_term->startup() == 0)
++          current_term = term_table; /* we know that console is first */
+   show_menu = 1;
+   goto restart;
+ }
+@@ -1050,6 +1089,16 @@
+         while (is_preset);
+       }
+ 
++      /* go ahead and make sure the terminal is setup */
++      if (current_term->startup)
++      {
++        /* If initialization fails, go back to default terminal */
++        if (current_term->startup() == 0)
++                {
++                    current_term = term_table;
++                }
++      }
++
+       if (! num_entries)
+       {
+         /* If no acceptable config file, goto command-line, starting
+diff -Naur grub-0.97.orig/stage2/term.h grub-0.97/stage2/term.h
+--- grub-0.97.orig/stage2/term.h       2003-07-09 08:45:53.000000000 -0300
++++ grub-0.97/stage2/term.h    2005-06-13 14:07:40.000000000 -0300
+@@ -60,6 +60,8 @@
+   const char *name;
+   /* The feature flags defined above.  */
+   unsigned long flags;
++  /* Default for maximum number of lines if not specified */
++  unsigned short max_lines;
+   /* Put a character.  */
+   void (*putchar) (int c);
+   /* Check if any input character is available.  */
+@@ -79,6 +81,10 @@
+   void (*setcolor) (int normal_color, int highlight_color);
+   /* Turn on/off the cursor.  */
+   int (*setcursor) (int on);
++  /* function to start a terminal */
++  int (*startup) (void);
++  /* function to use to shutdown a terminal */
++  void (*shutdown) (void);
+ };
+ 
+ /* This lists up available terminals.  */
+@@ -124,4 +130,24 @@
+ int hercules_setcursor (int on);
+ #endif
+ 
++#ifdef SUPPORT_GRAPHICS
++extern int foreground, background, window_border, graphics_inited, 
saved_videomode;
++
++void graphics_set_splash(char *splashfile);
++int set_videomode(int mode);
++int get_videomode(void);
++void graphics_putchar (int c);
++int graphics_getxy(void);
++void graphics_gotoxy(int x, int y);
++void graphics_cls(void);
++void graphics_setcolorstate (color_state state);
++void graphics_setcolor (int normal_color, int highlight_color);
++int graphics_setcursor (int on);
++int graphics_init(void);
++void graphics_end(void);
++
++int hex(int v);
++void graphics_set_palette(int idx, int red, int green, int blue);
++#endif /* SUPPORT_GRAPHICS */
++
+ #endif /* ! GRUB_TERM_HEADER */
diff -r 8a0656950b1c -r c8d9ade45781 stubdom/grub.patches/20print_func.diff
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/stubdom/grub.patches/20print_func.diff    Wed Jun 18 09:36:47 2008 +0100
@@ -0,0 +1,80 @@
+2006-01-05  Otavio Salvador  <otavio@xxxxxxxxxx>
+
+       * Rediff.
+
+2005-16-10  Samuel Thibault  <samuel.thibault@xxxxxxxxxxxx>
+
+       * docs/grub.texi: Added print command description.
+       * stage2/builtins.c(print_func): New function.
+       (builtin_print): New variable.
+       (builtin_table): Added builtin_print in table.
+
+Debian Status Following:
+   Added by: Otavio Salvador
+       Date: 2006-01-05
+
+diff -Nur grub-0.97-bkp/docs/grub.texi grub-0.97/docs/grub.texi
+--- grub-0.97-bkp/docs/grub.texi       2006-01-05 10:59:05.564347912 -0200
++++ grub-0.97/docs/grub.texi   2006-01-05 11:18:59.033912960 -0200
+@@ -2685,6 +2685,7 @@
+ * module::                      Load a module
+ * modulenounzip::               Load a module without decompression
+ * pause::                       Wait for a key press
++* print::                       Print a message
+ * quit::                        Exit from the grub shell
+ * reboot::                      Reboot your computer
+ * read::                        Read data from memory
+@@ -3091,6 +3092,16 @@
+ @end deffn
+ 
+ 
++@node print
++@subsection print
++
++@deffn Command print message @dots{}
++Print the @var{message}. Note that placing @key{^G} (ASCII code 7) in the
++message will cause the speaker to emit the standard beep sound, which is
++useful for visually impaired people.
++@end deffn
++
++
+ @node quit
+ @subsection quit
+ 
+diff -Nur grub-0.97-bkp/stage2/builtins.c grub-0.97/stage2/builtins.c
+--- grub-0.97-bkp/stage2/builtins.c    2006-01-05 10:59:05.550350040 -0200
++++ grub-0.97/stage2/builtins.c        2006-01-05 11:19:28.422445224 -0200
+@@ -2323,6 +2323,25 @@
+   "Probe I/O ports used for the drive DRIVE."
+ };
+ 
++/* print */
++static int
++print_func (char *arg, int flags)
++{
++  printf("%s\n", arg);
++
++  return 0;
++}
++
++static struct builtin builtin_print =
++{
++  "print",
++  print_func,
++  BUILTIN_CMDLINE | BUILTIN_MENU | BUILTIN_NO_ECHO,
++  "print [MESSAGE ...]",
++  "Print MESSAGE."
++};
++
++
+ 
+ /* kernel */
+ static int
+@@ -4848,6 +4867,7 @@
+   &builtin_parttype,
+   &builtin_password,
+   &builtin_pause,
++  &builtin_print,
+ #ifdef GRUB_UTIL
+   &builtin_quit,
+ #endif /* GRUB_UTIL */
diff -r 8a0656950b1c -r c8d9ade45781 stubdom/grub.patches/30savedefault.diff
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/stubdom/grub.patches/30savedefault.diff   Wed Jun 18 09:36:47 2008 +0100
@@ -0,0 +1,186 @@
+Index: grub/stage2/builtins.c
+===================================================================
+--- grub.orig/stage2/builtins.c        2008-06-02 18:06:08.942580000 +0100
++++ grub/stage2/builtins.c     2008-06-06 18:35:07.548390000 +0100
+@@ -86,6 +86,10 @@
+    inside other functions.  */
+ static int configfile_func (char *arg, int flags);
+ 
++static int savedefault_helper (char *arg, int flags);
++
++static int savedefault_shell (char *arg, int flags);
++
+ /* Initialize the data for builtins.  */
+ void
+ init_builtins (void)
+@@ -3512,7 +3516,109 @@
+ static int
+ savedefault_func (char *arg, int flags)
+ {
+-#if !defined(SUPPORT_DISKLESS) && !defined(GRUB_UTIL)
++#if !defined(SUPPORT_DISKLESS)
++  #if !defined(GRUB_UTIL)
++      return savedefault_helper(arg, flags);
++  #else
++      return savedefault_shell(arg, flags);
++  #endif
++#else /* !SUPPORT_DISKLESS */ 
++  errnum = ERR_UNRECOGNIZED;
++  return 1;
++#endif /* !SUPPORT_DISKLESS */
++}
++
++#if !defined(SUPPORT_DISKLESS) && defined(GRUB_UTIL)
++/* savedefault_shell */
++static int
++savedefault_shell(char *arg, int flags)
++ {
++  int once_only = 0;
++  int new_default;
++  int curr_default = -1;
++  int curr_prev_default = -1;
++  int new_prev_default = -1;
++  FILE *fp;
++  size_t bytes = 10;
++  char line[bytes];
++  char *default_file = (char *) DEFAULT_FILE_BUF;
++  char buf[bytes];
++  int i;
++  
++  while (1)
++    {
++      if (grub_memcmp ("--default=", arg, sizeof ("--default=") - 1) == 0)
++        {
++          char *p = arg + sizeof ("--default=") - 1;
++          if (! safe_parse_maxint (&p, &new_default))
++            return 1;
++          arg = skip_to (0, arg);
++        }
++      else if (grub_memcmp ("--once", arg, sizeof ("--once") - 1) == 0)
++        {
++         once_only = 1;
++         arg = skip_to (0, arg);
++      }
++      else
++        break;
++    }
++
++  *default_file = 0;
++  grub_strncat (default_file, config_file, DEFAULT_FILE_BUFLEN);
++  for (i = grub_strlen(default_file); i >= 0; i--)
++    if (default_file[i] == '/')
++    {
++      i++;
++      break;
++    }
++  default_file[i] = 0;
++  grub_strncat (default_file + i, "default", DEFAULT_FILE_BUFLEN - i);
++
++  if(!(fp = fopen(default_file,"r")))
++    {
++      errnum = ERR_READ;
++      goto fail;
++    }
++  
++  fgets(line, bytes, fp);
++  fclose(fp);
++ 
++  sscanf(line, "%d:%d", &curr_prev_default, &curr_default);
++     
++  if(curr_default != -1)
++    new_prev_default = curr_default;
++  else
++    {
++      if(curr_prev_default != -1)
++        new_prev_default = curr_prev_default;
++      else
++        new_prev_default = 0;
++    }
++     
++  if(once_only)
++    sprintf(buf, "%d:%d", new_prev_default, new_default);
++  else
++    sprintf(buf, "%d", new_default);
++
++  if(!(fp = fopen(default_file,"w")))
++    {
++      errnum = ERR_READ;
++      goto fail;
++    }
++     
++  fprintf(fp, buf);   
++     
++fail:
++  fclose(fp);
++  return errnum;
++}
++#endif
++
++/* savedefault_helper */
++static int
++savedefault_helper (char *arg, int flags)
++{
++#if !defined(SUPPORT_DISKLESS)
+   unsigned long tmp_drive = saved_drive;
+   unsigned long tmp_partition = saved_partition;
+   char *default_file = (char *) DEFAULT_FILE_BUF;
+@@ -3588,22 +3694,26 @@
+       
+       disk_read_hook = disk_read_savesect_func;
+       len = grub_read (buf, sizeof (buf));
++      buf[9]='\0';/* Make sure grub_strstr() below terminates */
+       disk_read_hook = 0;
+       grub_close ();
+       
+-      if (len != sizeof (buf))
+-      {
+-        /* This is too small. Do not modify the file manually, please!  */
+-        errnum = ERR_READ;
+-        goto fail;
+-      }
+-
+       if (sector_count > 2)
+       {
+         /* Is this possible?! Too fragmented!  */
+         errnum = ERR_FSYS_CORRUPT;
+         goto fail;
+       }
++
++      char *tmp;
++      if((tmp = grub_strstr(buf, ":")) != NULL)
++      {
++       int f_len = grub_strlen(buf) - grub_strlen(tmp);
++       char *def;
++       buf[f_len] = '\0';
++       def = buf;
++       safe_parse_maxint (&def, &entryno);
++      }
+       
+       /* Set up a string to be written.  */
+       grub_memset (buf, '\n', sizeof (buf));
+Index: grub/stage2/stage2.c
+===================================================================
+--- grub.orig/stage2/stage2.c  2008-06-02 18:06:08.858579000 +0100
++++ grub/stage2/stage2.c       2008-06-06 18:04:03.585354000 +0100
+@@ -49,7 +49,8 @@
+     return 0;
+ #endif /* GRUB_UTIL */
+   
+-  preset_menu_offset = 0;
++  if (preset_menu_offset)
++    return 0;
+   return preset_menu != 0;
+ }
+ 
+@@ -934,7 +935,11 @@
+             len = grub_read (buf, sizeof (buf));
+             if (len > 0)
+               {
++                char *tmp;
+                 buf[sizeof (buf) - 1] = 0;
++                if((tmp = grub_strstr(p, ":")) != NULL)
++                  p = tmp + 1;
++                
+                 safe_parse_maxint (&p, &saved_entryno);
+               }
+ 
diff -r 8a0656950b1c -r c8d9ade45781 
stubdom/grub.patches/40ext3_256byte_inode.diff
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/stubdom/grub.patches/40ext3_256byte_inode.diff    Wed Jun 18 09:36:47 
2008 +0100
@@ -0,0 +1,114 @@
+
+Patch from Red Hat. See #463236, #463123.
+
+Index: grub/stage2/fsys_ext2fs.c
+===================================================================
+--- grub.orig/stage2/fsys_ext2fs.c     2008-05-27 18:47:19.045183000 +0100
++++ grub/stage2/fsys_ext2fs.c  2008-05-27 19:09:21.293187000 +0100
+@@ -79,7 +79,52 @@
+     __u32 s_rev_level;                /* Revision level */
+     __u16 s_def_resuid;               /* Default uid for reserved blocks */
+     __u16 s_def_resgid;               /* Default gid for reserved blocks */
+-    __u32 s_reserved[235];    /* Padding to the end of the block */
++    /*
++     * These fields are for EXT2_DYNAMIC_REV superblocks only.
++     *
++     * Note: the difference between the compatible feature set and
++     * the incompatible feature set is that if there is a bit set
++     * in the incompatible feature set that the kernel doesn't
++     * know about, it should refuse to mount the filesystem.
++     *
++     * e2fsck's requirements are more strict; if it doesn't know
++     * about a feature in either the compatible or incompatible
++     * feature set, it must abort and not try to meddle with
++     * things it doesn't understand...
++     */
++    __u32 s_first_ino;                /* First non-reserved inode */
++    __u16 s_inode_size;               /* size of inode structure */
++    __u16 s_block_group_nr;   /* block group # of this superblock */
++    __u32 s_feature_compat;   /* compatible feature set */
++    __u32 s_feature_incompat; /* incompatible feature set */
++    __u32 s_feature_ro_compat;        /* readonly-compatible feature set */
++    __u8  s_uuid[16];         /* 128-bit uuid for volume */
++    char  s_volume_name[16];  /* volume name */
++    char  s_last_mounted[64]; /* directory where last mounted */
++    __u32 s_algorithm_usage_bitmap; /* For compression */
++    /*
++     * Performance hints.  Directory preallocation should only
++     * happen if the EXT2_FEATURE_COMPAT_DIR_PREALLOC flag is on.
++     */
++    __u8  s_prealloc_blocks;  /* Nr of blocks to try to preallocate*/
++    __u8  s_prealloc_dir_blocks;      /* Nr to preallocate for dirs */
++    __u16 s_reserved_gdt_blocks;/* Per group table for online growth */
++    /*
++     * Journaling support valid if EXT2_FEATURE_COMPAT_HAS_JOURNAL set.
++     */
++    __u8 s_journal_uuid[16];  /* uuid of journal superblock */
++    __u32 s_journal_inum;     /* inode number of journal file */
++    __u32 s_journal_dev;      /* device number of journal file */
++    __u32 s_last_orphan;      /* start of list of inodes to delete */
++    __u32 s_hash_seed[4];     /* HTREE hash seed */
++    __u8  s_def_hash_version; /* Default hash version to use */
++    __u8  s_jnl_backup_type;  /* Default type of journal backup */
++    __u16 s_reserved_word_pad;
++    __u32 s_default_mount_opts;
++    __u32 s_first_meta_bg;    /* First metablock group */
++    __u32 s_mkfs_time;                /* When the filesystem was created */
++    __u32 s_jnl_blocks[17];   /* Backup of the journal inode */
++    __u32 s_reserved[172];    /* Padding to the end of the block */
+   };
+ 
+ struct ext2_group_desc
+@@ -218,6 +263,9 @@
+ #define EXT2_ADDR_PER_BLOCK(s)          (EXT2_BLOCK_SIZE(s) / sizeof (__u32))
+ #define EXT2_ADDR_PER_BLOCK_BITS(s)           (log2(EXT2_ADDR_PER_BLOCK(s)))
+ 
++#define EXT2_INODE_SIZE(s)            (SUPERBLOCK->s_inode_size)
++#define EXT2_INODES_PER_BLOCK(s)      (EXT2_BLOCK_SIZE(s)/EXT2_INODE_SIZE(s))
++
+ /* linux/ext2_fs.h */
+ #define EXT2_BLOCK_SIZE_BITS(s)        ((s)->s_log_block_size + 10)
+ /* kind of from ext2/super.c */
+@@ -242,7 +290,14 @@
+ static __inline__ unsigned long
+ ffz (unsigned long word)
+ {
+-  __asm__ ("bsfl %1,%0"
++  __asm__ ("bsf"
++#ifdef __i386__
++                "l"
++#endif
++#ifdef __x86_64__
++                "q"
++#endif
++                " %1,%0"
+ :        "=r" (word)
+ :        "r" (~word));
+   return word;
+@@ -553,7 +608,7 @@
+       gdp = GROUP_DESC;
+       ino_blk = gdp[desc].bg_inode_table +
+       (((current_ino - 1) % (SUPERBLOCK->s_inodes_per_group))
+-       >> log2 (EXT2_BLOCK_SIZE (SUPERBLOCK) / sizeof (struct ext2_inode)));
++       >> log2 (EXT2_INODES_PER_BLOCK (SUPERBLOCK)));
+ #ifdef E2DEBUG
+       printf ("inode table fsblock=%d\n", ino_blk);
+ #endif /* E2DEBUG */
+@@ -565,13 +620,12 @@
+       /* reset indirect blocks! */
+       mapblock2 = mapblock1 = -1;
+ 
+-      raw_inode = INODE +
+-      ((current_ino - 1)
+-       & (EXT2_BLOCK_SIZE (SUPERBLOCK) / sizeof (struct ext2_inode) - 1));
++      raw_inode = (struct ext2_inode *)((char *)INODE +
++      ((current_ino - 1) & (EXT2_INODES_PER_BLOCK (SUPERBLOCK) - 1)) *
++      EXT2_INODE_SIZE (SUPERBLOCK));
+ #ifdef E2DEBUG
+       printf ("ipb=%d, sizeof(inode)=%d\n",
+-            (EXT2_BLOCK_SIZE (SUPERBLOCK) / sizeof (struct ext2_inode)),
+-            sizeof (struct ext2_inode));
++            EXT2_INODES_PER_BLOCK (SUPERBLOCK), EXT2_INODE_SIZE (SUPERBLOCK));
+       printf ("inode=%x, raw_inode=%x\n", INODE, raw_inode);
+       printf ("offset into inode table block=%d\n", (int) raw_inode - (int) 
INODE);
+       for (i = (unsigned char *) INODE; i <= (unsigned char *) raw_inode;
diff -r 8a0656950b1c -r c8d9ade45781 stubdom/grub.patches/99minios
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/stubdom/grub.patches/99minios     Wed Jun 18 09:36:47 2008 +0100
@@ -0,0 +1,1456 @@
+Index: grub/stage2/builtins.c
+===================================================================
+--- grub.orig/stage2/builtins.c        2008-06-16 15:18:14.649009000 +0100
++++ grub/stage2/builtins.c     2008-06-16 15:18:14.719009000 +0100
+@@ -45,8 +45,10 @@
+ #ifdef GRUB_UTIL
+ # include <device.h>
+ #else /* ! GRUB_UTIL */
++#ifndef __MINIOS
+ # include <apic.h>
+ # include <smp-imps.h>
++#endif
+ #endif /* ! GRUB_UTIL */
+ 
+ #ifdef USE_MD5_PASSWORDS
+@@ -246,11 +248,13 @@
+ boot_func (char *arg, int flags)
+ {
+   struct term_entry *prev_term = current_term;
++#ifndef __MINIOS__
+   /* Clear the int15 handler if we can boot the kernel successfully.
+      This assumes that the boot code never fails only if KERNEL_TYPE is
+      not KERNEL_TYPE_NONE. Is this assumption is bad?  */
+   if (kernel_type != KERNEL_TYPE_NONE)
+     unset_int15_handler ();
++#endif
+ 
+   /* if our terminal needed initialization, we should shut it down
+    * before booting the kernel, but we want to save what it was so
+@@ -261,13 +265,21 @@
+       current_term = term_table; /* assumption: console is first */
+     }
+ 
++#ifndef __MINIOS__
+ #ifdef SUPPORT_NETBOOT
+   /* Shut down the networking.  */
+   cleanup_net ();
+ #endif
++#endif
+   
+   switch (kernel_type)
+     {
++#ifdef __MINIOS__
++    case KERNEL_TYPE_PV:
++      /* Paravirtualized */
++      pv_boot();
++      break;
++#else
+     case KERNEL_TYPE_FREEBSD:
+     case KERNEL_TYPE_NETBSD:
+       /* *BSD */
+@@ -319,6 +331,7 @@
+       multi_boot ((int) entry_addr, (int) &mbi);
+       break;
+ 
++#endif
+     default:
+       errnum = ERR_BOOT_COMMAND;
+       return 1;
+@@ -1123,6 +1136,7 @@
+ };
+ 
+ 
++#ifndef __MINIOS__
+ /* displayapm */
+ static int
+ displayapm_func (char *arg, int flags)
+@@ -1163,8 +1177,10 @@
+   "displayapm",
+   "Display APM BIOS information."
+ };
++#endif
+ 
+ 
++#ifndef __MINIOS__
+ /* displaymem */
+ static int
+ displaymem_func (char *arg, int flags)
+@@ -1218,6 +1234,7 @@
+   "Display what GRUB thinks the system address space map of the"
+   " machine is, including all regions of physical RAM installed."
+ };
++#endif
+ 
+ 
+ /* dump FROM TO */
+@@ -1280,6 +1297,7 @@
+ #endif /* GRUB_UTIL */
+ 
+ 
++#ifndef __MINIOS__
+ static char embed_info[32];
+ /* embed */
+ /* Embed a Stage 1.5 in the first cylinder after MBR or in the
+@@ -1413,6 +1431,7 @@
+   " is a drive, or in the \"bootloader\" area if DEVICE is a FFS partition."
+   " Print the number of sectors which STAGE1_5 occupies if successful."
+ };
++#endif
+ 
+ 
+ /* fallback */
+@@ -1956,6 +1975,7 @@
+ #endif /* SUPPORT_NETBOOT */
+ 
+ 
++#ifndef __MINIOS__
+ /* impsprobe */
+ static int
+ impsprobe_func (char *arg, int flags)
+@@ -1982,6 +2002,7 @@
+   " configuration table and boot the various CPUs which are found into"
+   " a tight loop."
+ };
++#endif
+ 
+ 
+ /* initrd */
+@@ -1992,6 +2013,7 @@
+     {
+     case KERNEL_TYPE_LINUX:
+     case KERNEL_TYPE_BIG_LINUX:
++    case KERNEL_TYPE_PV:
+       if (! load_initrd (arg))
+       return 1;
+       break;
+@@ -2015,6 +2037,7 @@
+ };
+ 
+ 
++#ifndef __MINIOS__
+ /* install */
+ static int
+ install_func (char *arg, int flags)
+@@ -2555,8 +2578,10 @@
+   " for LBA mode. If the option `--stage2' is specified, rewrite the Stage"
+   " 2 via your OS's filesystem instead of the raw device."
+ };
++#endif
+ 
+ 
++#ifndef __MINIOS__
+ /* ioprobe */
+ static int
+ ioprobe_func (char *arg, int flags)
+@@ -2598,6 +2623,7 @@
+   "ioprobe DRIVE",
+   "Probe I/O ports used for the drive DRIVE."
+ };
++#endif
+ 
+ /* print */
+ static int
+@@ -3776,6 +3802,7 @@
+ };
+ 
+ 
++#ifndef __MINIOS__
+ #ifdef SUPPORT_SERIAL
+ /* serial */
+ static int
+@@ -3927,8 +3954,10 @@
+   " default values are COM1, 9600, 8N1."
+ };
+ #endif /* SUPPORT_SERIAL */
++#endif
+ 
+ 
++#ifndef __MINIOS__
+ /* setkey */
+ struct keysym
+ {
+@@ -4174,8 +4203,10 @@
+   " is a digit), and delete. If no argument is specified, reset key"
+   " mappings."
+ };
++#endif
+ 
+ 
++#ifndef __MINIOS__
+ /* setup */
+ static int
+ setup_func (char *arg, int flags)
+@@ -4484,6 +4515,7 @@
+   " partition where GRUB images reside, specify the option `--stage2'"
+   " to tell GRUB the file name under your OS."
+ };
++#endif
+ 
+ 
+ #if defined(SUPPORT_SERIAL) || defined(SUPPORT_HERCULES) || 
defined(SUPPORT_GRAPHICS)
+@@ -4788,6 +4820,7 @@
+ #endif /* SUPPORT_SERIAL */
+         
+ 
++#ifndef __MINIOS__
+ /* testload */
+ static int
+ testload_func (char *arg, int flags)
+@@ -4874,8 +4907,10 @@
+   " consistent offset error. If this test succeeds, then a good next"
+   " step is to try loading a kernel."
+ };
++#endif
+ 
+ 
++#ifndef __MINIOS__
+ /* testvbe MODE */
+ static int
+ testvbe_func (char *arg, int flags)
+@@ -4979,6 +5014,7 @@
+   "testvbe MODE",
+   "Test the VBE mode MODE. Hit any key to return."
+ };
++#endif
+ 
+ 
+ #ifdef SUPPORT_NETBOOT
+@@ -5075,6 +5111,7 @@
+ };
+ 
+ 
++#ifndef __MINIOS__
+ /* uppermem */
+ static int
+ uppermem_func (char *arg, int flags)
+@@ -5095,8 +5132,10 @@
+   "Force GRUB to assume that only KBYTES kilobytes of upper memory are"
+   " installed.  Any system address range maps are discarded."
+ };
++#endif
+ 
+ 
++#ifndef __MINIOS__
+ /* vbeprobe */
+ static int
+ vbeprobe_func (char *arg, int flags)
+@@ -5203,6 +5242,7 @@
+   "Probe VBE information. If the mode number MODE is specified, show only"
+   " the information about only the mode."
+ };
++#endif
+   
+ 
+ /* The table of builtin commands. Sorted in dictionary order.  */
+@@ -5233,12 +5273,16 @@
+ #ifdef SUPPORT_NETBOOT
+   &builtin_dhcp,
+ #endif /* SUPPORT_NETBOOT */
++#ifndef __MINIOS__
+   &builtin_displayapm,
+   &builtin_displaymem,
++#endif
+ #ifdef GRUB_UTIL
+   &builtin_dump,
+ #endif /* GRUB_UTIL */
++#ifndef __MINIOS__
+   &builtin_embed,
++#endif
+   &builtin_fallback,
+   &builtin_find,
+ #ifdef SUPPORT_GRAPHICS
+@@ -5253,10 +5297,14 @@
+ #ifdef SUPPORT_NETBOOT
+   &builtin_ifconfig,
+ #endif /* SUPPORT_NETBOOT */
++#ifndef __MINIOS__
+   &builtin_impsprobe,
++#endif
+   &builtin_initrd,
++#ifndef __MINIOS__
+   &builtin_install,
+   &builtin_ioprobe,
++#endif
+   &builtin_kernel,
+   &builtin_lock,
+   &builtin_makeactive,
+@@ -5283,11 +5331,13 @@
+   &builtin_root,
+   &builtin_rootnoverify,
+   &builtin_savedefault,
++#ifndef __MINIOS__
+ #ifdef SUPPORT_SERIAL
+   &builtin_serial,
+ #endif /* SUPPORT_SERIAL */
+   &builtin_setkey,
+   &builtin_setup,
++#endif
+ #ifdef SUPPORT_GRAPHICS
+   &builtin_shade,
+   &builtin_splashimage,
+@@ -5298,16 +5348,20 @@
+ #ifdef SUPPORT_SERIAL
+   &builtin_terminfo,
+ #endif /* SUPPORT_SERIAL */
++#ifndef __MINIOS__
+   &builtin_testload,
+   &builtin_testvbe,
++#endif
+ #ifdef SUPPORT_NETBOOT
+   &builtin_tftpserver,
+ #endif /* SUPPORT_NETBOOT */
+   &builtin_timeout,
+   &builtin_title,
+   &builtin_unhide,
++#ifndef __MINIOS__
+   &builtin_uppermem,
+   &builtin_vbeprobe,
++#endif
+ #ifdef SUPPORT_GRAPHICS
+   &builtin_viewport,
+ #endif
+Index: grub/stage2/char_io.c
+===================================================================
+--- grub.orig/stage2/char_io.c 2008-06-16 15:18:14.516009000 +0100
++++ grub/stage2/char_io.c      2008-06-16 15:18:14.726009000 +0100
+@@ -20,6 +20,7 @@
+ 
+ #include <shared.h>
+ #include <term.h>
++#include <stdarg.h>
+ 
+ #ifdef SUPPORT_HERCULES
+ # include <hercules.h>
+@@ -36,6 +37,7 @@
+ #ifndef STAGE1_5
+ struct term_entry term_table[] =
+   {
++#ifdef SUPPORT_CONSOLE
+     {
+       "console",
+       0,
+@@ -52,6 +54,7 @@
+       0, 
+       0
+     },
++#endif
+ #ifdef SUPPORT_SERIAL
+     {
+       "serial",
+@@ -131,9 +134,9 @@
+ }
+ 
+ char *
+-convert_to_ascii (char *buf, int c,...)
++convert_to_ascii (char *buf, int c, int _num)
+ {
+-  unsigned long num = *((&c) + 1), mult = 10;
++  unsigned long num = _num, mult = 10;
+   char *ptr = buf;
+ 
+ #ifndef STAGE1_5
+@@ -182,11 +185,11 @@
+ void
+ grub_printf (const char *format,...)
+ {
+-  int *dataptr = (int *) &format;
++  va_list ap;
+   char c, str[16];
+-  
+-  dataptr++;
+ 
++  va_start(ap, format);
++  
+   while ((c = *(format++)) != 0)
+     {
+       if (c != '%')
+@@ -200,21 +203,32 @@
+         case 'X':
+ #endif
+         case 'u':
+-          *convert_to_ascii (str, c, *((unsigned long *) dataptr++)) = 0;
++        {
++          unsigned i = va_arg(ap, unsigned);
++          *convert_to_ascii (str, c, i) = 0;
+           grub_putstr (str);
+           break;
++          }
+ 
+ #ifndef STAGE1_5
+         case 'c':
+-          grub_putchar ((*(dataptr++)) & 0xff);
++        {
++          int c = va_arg(ap, int);
++          grub_putchar (c & 0xff);
+           break;
++        }
+ 
+         case 's':
+-          grub_putstr ((char *) *(dataptr++));
++        {
++          char *s = va_arg(ap, char*);
++          grub_putstr (s);
+           break;
++        }
+ #endif
+         }
+     }
++
++  va_end(ap);
+ }
+ 
+ #ifndef STAGE1_5
+@@ -223,11 +237,11 @@
+ {
+   /* XXX hohmuth
+      ugly hack -- should unify with printf() */
+-  int *dataptr = (int *) &format;
++  va_list ap;
+   char c, *ptr, str[16];
+   char *bp = buffer;
+ 
+-  dataptr++;
++  va_start(ap, format);
+ 
+   while ((c = *format++) != 0)
+     {
+@@ -237,20 +251,27 @@
+       switch (c = *(format++))
+         {
+         case 'd': case 'u': case 'x':
+-          *convert_to_ascii (str, c, *((unsigned long *) dataptr++)) = 0;
++        {
++          unsigned i = va_arg(ap, unsigned);
++          *convert_to_ascii (str, c, i) = 0;
+ 
+           ptr = str;
+ 
+           while (*ptr)
+             *bp++ = *(ptr++); /* putchar(*(ptr++)); */
+           break;
++        }
+ 
+-        case 'c': *bp++ = (*(dataptr++))&0xff;
++        case 'c':
++        {
++          int c = va_arg(ap, int);
++          *bp++ = c&0xff;
+           /* putchar((*(dataptr++))&0xff); */
+           break;
++        }
+ 
+         case 's':
+-          ptr = (char *) (*(dataptr++));
++          ptr = va_arg(ap, char *);
+ 
+           while ((c = *ptr++) != 0)
+             *bp++ = c; /* putchar(c); */
+@@ -258,6 +279,8 @@
+         }
+     }
+ 
++  va_end(ap);
++
+   *bp = 0;
+   return bp - buffer;
+ }
+@@ -1263,12 +1286,14 @@
+     return ! errnum;
+ #endif /* GRUB_UTIL */
+ 
++#ifndef __MINIOS__
+   if ((addr < RAW_ADDR (0x1000))
+       || (addr < RAW_ADDR (0x100000)
+         && RAW_ADDR (mbi.mem_lower * 1024) < (addr + len))
+       || (addr >= RAW_ADDR (0x100000)
+         && RAW_ADDR (mbi.mem_upper * 1024) < ((addr - 0x100000) + len)))
+     errnum = ERR_WONT_FIT;
++#endif
+ 
+   return ! errnum;
+ }
+@@ -1342,7 +1367,7 @@
+ }
+ #endif /* ! STAGE1_5 */
+ 
+-#ifndef GRUB_UTIL
++#if !defined(GRUB_UTIL) && !defined(__MINIOS__)
+ # undef memcpy
+ /* GCC emits references to memcpy() for struct copies etc.  */
+ void *memcpy (void *dest, const void *src, int n)  __attribute__ ((alias 
("grub_memmove")));
+Index: grub/stage2/disk_io.c
+===================================================================
+--- grub.orig/stage2/disk_io.c 2008-06-16 15:18:03.327932000 +0100
++++ grub/stage2/disk_io.c      2008-06-16 15:18:14.733009000 +0100
+@@ -130,7 +130,14 @@
+ static inline unsigned long
+ log2 (unsigned long word)
+ {
+-  asm volatile ("bsfl %1,%0"
++  asm volatile ("bsf"
++#ifdef __i386__
++                "l"
++#endif
++#ifdef __x86_64__
++                "q"
++#endif  
++                " %1,%0"
+               : "=r" (word)
+               : "r" (word));
+   return word;
+Index: grub/stage2/fsys_fat.c
+===================================================================
+--- grub.orig/stage2/fsys_fat.c        2008-06-16 15:18:03.337934000 +0100
++++ grub/stage2/fsys_fat.c     2008-06-16 15:18:14.737009000 +0100
+@@ -57,7 +57,14 @@
+ static __inline__ unsigned long
+ log2 (unsigned long word)
+ {
+-  __asm__ ("bsfl %1,%0"
++  __asm__ ("bsf"
++#ifdef __i386__
++                "l"
++#endif
++#ifdef __x86_64__
++                "q"
++#endif
++                " %1,%0"
+          : "=r" (word)
+          : "r" (word));
+   return word;
+Index: grub/stage2/pc_slice.h
+===================================================================
+--- grub.orig/stage2/pc_slice.h        2008-06-16 15:18:03.347932000 +0100
++++ grub/stage2/pc_slice.h     2008-06-16 15:18:14.746009000 +0100
+@@ -38,50 +38,50 @@
+  */
+ 
+ #define PC_MBR_CHECK_SIG(mbr_ptr) \
+-  ( *( (unsigned short *) (((int) mbr_ptr) + PC_MBR_SIG_OFFSET) ) \
++  ( *( (unsigned short *) (((long) mbr_ptr) + PC_MBR_SIG_OFFSET) ) \
+    == PC_MBR_SIGNATURE )
+ 
+ #define PC_MBR_SIG(mbr_ptr) \
+-  ( *( (unsigned short *) (((int) mbr_ptr) + PC_MBR_SIG_OFFSET) ) )
++  ( *( (unsigned short *) (((long) mbr_ptr) + PC_MBR_SIG_OFFSET) ) )
+ 
+ #define PC_SLICE_FLAG(mbr_ptr, part) \
+-  ( *( (unsigned char *) (((int) mbr_ptr) + PC_SLICE_OFFSET \
++  ( *( (unsigned char *) (((long) mbr_ptr) + PC_SLICE_OFFSET \
+                         + (part << 4)) ) )
+ 
+ #define PC_SLICE_HEAD(mbr_ptr, part) \
+-  ( *( (unsigned char *) (((int) mbr_ptr) + PC_SLICE_OFFSET + 1 \
++  ( *( (unsigned char *) (((long) mbr_ptr) + PC_SLICE_OFFSET + 1 \
+                         + (part << 4)) ) )
+ 
+ #define PC_SLICE_SEC(mbr_ptr, part) \
+-  ( *( (unsigned char *) (((int) mbr_ptr) + PC_SLICE_OFFSET + 2 \
++  ( *( (unsigned char *) (((long) mbr_ptr) + PC_SLICE_OFFSET + 2 \
+                         + (part << 4)) ) )
+ 
+ #define PC_SLICE_CYL(mbr_ptr, part) \
+-  ( *( (unsigned char *) (((int) mbr_ptr) + PC_SLICE_OFFSET + 3 \
++  ( *( (unsigned char *) (((long) mbr_ptr) + PC_SLICE_OFFSET + 3 \
+                         + (part << 4)) ) )
+ 
+ #define PC_SLICE_TYPE(mbr_ptr, part) \
+-  ( *( (unsigned char *) (((int) mbr_ptr) + PC_SLICE_OFFSET + 4 \
++  ( *( (unsigned char *) (((long) mbr_ptr) + PC_SLICE_OFFSET + 4 \
+                         + (part << 4)) ) )
+ 
+ #define PC_SLICE_EHEAD(mbr_ptr, part) \
+-  ( *( (unsigned char *) (((int) mbr_ptr) + PC_SLICE_OFFSET + 5 \
++  ( *( (unsigned char *) (((long) mbr_ptr) + PC_SLICE_OFFSET + 5 \
+                         + (part << 4)) ) )
+ 
+ #define PC_SLICE_ESEC(mbr_ptr, part) \
+-  ( *( (unsigned char *) (((int) mbr_ptr) + PC_SLICE_OFFSET + 6 \
++  ( *( (unsigned char *) (((long) mbr_ptr) + PC_SLICE_OFFSET + 6 \
+                         + (part << 4)) ) )
+ 
+ #define PC_SLICE_ECYL(mbr_ptr, part) \
+-  ( *( (unsigned char *) (((int) mbr_ptr) + PC_SLICE_OFFSET + 7 \
++  ( *( (unsigned char *) (((long) mbr_ptr) + PC_SLICE_OFFSET + 7 \
+                         + (part << 4)) ) )
+ 
+ #define PC_SLICE_START(mbr_ptr, part) \
+-  ( *( (unsigned long *) (((int) mbr_ptr) + PC_SLICE_OFFSET + 8 \
++  ( *( (unsigned long *) (((long) mbr_ptr) + PC_SLICE_OFFSET + 8 \
+                         + (part << 4)) ) )
+ 
+ #define PC_SLICE_LENGTH(mbr_ptr, part) \
+-  ( *( (unsigned long *) (((int) mbr_ptr) + PC_SLICE_OFFSET + 12 \
++  ( *( (unsigned long *) (((long) mbr_ptr) + PC_SLICE_OFFSET + 12 \
+                         + (part << 4)) ) )
+ 
+ 
+Index: grub/stage2/shared.h
+===================================================================
+--- grub.orig/stage2/shared.h  2008-06-16 15:18:14.537009000 +0100
++++ grub/stage2/shared.h       2008-06-17 14:25:08.443906000 +0100
+@@ -39,6 +39,10 @@
+ extern char *grub_scratch_mem;
+ # define RAW_ADDR(x) ((x) + (int) grub_scratch_mem)
+ # define RAW_SEG(x) (RAW_ADDR ((x) << 4) >> 4)
++#elif defined(__MINIOS__)
++extern char grub_scratch_mem[];
++# define RAW_ADDR(x) ((x) + (int) grub_scratch_mem)
++# define RAW_SEG(x) (RAW_ADDR ((x) << 4) >> 4)
+ #else
+ # define RAW_ADDR(x) (x)
+ # define RAW_SEG(x) (x)
+@@ -707,7 +711,9 @@
+ 
+ /* Halt the system, using APM if possible. If NO_APM is true, don't use
+    APM even if it is available.  */
++#ifndef __MINIOS__
+ void grub_halt (int no_apm) __attribute__ ((noreturn));
++#endif
+ 
+ /* Copy MAP to the drive map and set up int13_handler.  */
+ void set_int13_handler (unsigned short *map);
+@@ -857,7 +863,8 @@
+   KERNEL_TYPE_BIG_LINUX,      /* Big Linux.  */
+   KERNEL_TYPE_FREEBSD,                /* FreeBSD.  */
+   KERNEL_TYPE_NETBSD,         /* NetBSD.  */
+-  KERNEL_TYPE_CHAINLOADER     /* Chainloader.  */
++  KERNEL_TYPE_CHAINLOADER,    /* Chainloader.  */
++  KERNEL_TYPE_PV              /* Paravirtualized.  */
+ }
+ kernel_t;
+ 
+@@ -890,7 +897,7 @@
+ int grub_strlen (const char *str);
+ char *grub_strcpy (char *dest, const char *src);
+ 
+-#ifndef GRUB_UTIL
++#if !defined(GRUB_UTIL) && !defined(__MINIOS__)
+ typedef unsigned long grub_jmp_buf[6];
+ #else
+ /* In the grub shell, use the libc jmp_buf instead.  */
+@@ -898,7 +905,7 @@
+ # define grub_jmp_buf jmp_buf
+ #endif
+ 
+-#ifdef GRUB_UTIL
++#if defined(GRUB_UTIL) || defined(__MINIOS__)
+ # define grub_setjmp  setjmp
+ # define grub_longjmp longjmp
+ #else /* ! GRUB_UTIL */
+@@ -914,7 +921,7 @@
+ /* misc */
+ void init_page (void);
+ void print_error (void);
+-char *convert_to_ascii (char *buf, int c, ...);
++char *convert_to_ascii (char *buf, int c, int num);
+ int get_cmdline (char *prompt, char *cmdline, int maxlen,
+                int echo_char, int history);
+ int substring (const char *s1, const char *s2);
+Index: grub/netboot/etherboot.h
+===================================================================
+--- grub.orig/netboot/etherboot.h      2008-06-16 15:18:03.446934000 +0100
++++ grub/netboot/etherboot.h   2008-06-16 15:18:14.760009000 +0100
+@@ -246,7 +246,7 @@
+ 
+ typedef struct
+ {
+-  unsigned long       s_addr;
++  unsigned int        s_addr;
+ }
+ in_addr;
+ 
+@@ -302,7 +302,7 @@
+   char bp_htype;
+   char bp_hlen;
+   char bp_hops;
+-  unsigned long bp_xid;
++  unsigned int bp_xid;
+   unsigned short bp_secs;
+   unsigned short unused;
+   in_addr bp_ciaddr;
+@@ -411,25 +411,25 @@
+     
+     struct
+     {
+-      long id;
+-      long type;
+-      long rpcvers;
+-      long prog;
+-      long vers;
+-      long proc;
+-      long data[1];
++      int id;
++      int type;
++      int rpcvers;
++      int prog;
++      int vers;
++      int proc;
++      int data[1];
+     }
+     call;
+     
+     struct
+     {
+-      long id;
+-      long type;
+-      long rstatus;
+-      long verifier;
+-      long v2;
+-      long astatus;
+-      long data[1];
++      int id;
++      int type;
++      int rstatus;
++      int verifier;
++      int v2;
++      int astatus;
++      int data[1];
+     }
+     reply;
+   }
+@@ -517,7 +517,9 @@
+ 
+ /* misc.c */
+ extern void twiddle (void);
++#ifndef __MINIOS__
+ extern void sleep (int secs);
++#endif
+ extern int getdec (char **s);
+ extern void etherboot_printf (const char *, ...);
+ extern int etherboot_sprintf (char *, const char *, ...);
+Index: grub/stage2/common.c
+===================================================================
+--- grub.orig/stage2/common.c  2008-06-16 15:18:03.366934000 +0100
++++ grub/stage2/common.c       2008-06-16 15:18:14.764009000 +0100
+@@ -137,6 +137,7 @@
+ }
+ #endif /* ! STAGE1_5 */
+ 
++#ifndef __MINIOS__
+ /* This queries for BIOS information.  */
+ void
+ init_bios_info (void)
+@@ -335,3 +336,4 @@
+   /* Start main routine here.  */
+   cmain ();
+ }
++#endif
+Index: grub/stage2/serial.c
+===================================================================
+--- grub.orig/stage2/serial.c  2008-06-16 15:18:03.376934000 +0100
++++ grub/stage2/serial.c       2008-06-16 15:18:14.769009000 +0100
+@@ -37,7 +37,7 @@
+ 
+ /* Hardware-dependent definitions.  */
+ 
+-#ifndef GRUB_UTIL
++#if !defined(GRUB_UTIL) && !defined(__MINIOS__)
+ /* The structure for speed vs. divisor.  */
+ struct divisor
+ {
+@@ -222,6 +222,8 @@
+       {('3' | ('~' << 8)), 4},
+       {('5' | ('~' << 8)), 7},
+       {('6' | ('~' << 8)), 3},
++      {('7' | ('~' << 8)), 1},
++      {('8' | ('~' << 8)), 5},
+     };
+   
+   /* The buffer must start with ``ESC [''.  */
+Index: grub/stage2/tparm.c
+===================================================================
+--- grub.orig/stage2/tparm.c   2008-06-16 15:18:03.390933000 +0100
++++ grub/stage2/tparm.c        2008-06-16 15:18:14.774010000 +0100
+@@ -48,6 +48,7 @@
+ #include "shared.h"
+ 
+ #include "tparm.h"
++#include <stdarg.h>
+ 
+ /*
+  * Common/troublesome character definitions
+@@ -320,7 +321,7 @@
+ #define isLOWER(c) ((c) >= 'a' && (c) <= 'z')
+ 
+ static inline char *
+-tparam_internal(const char *string, int *dataptr)
++tparam_internal(const char *string, va_list ap)
+ {
+ #define NUM_VARS 26
+     char *p_is_s[9];
+@@ -461,9 +462,9 @@
+        * a char* and an int may not be the same size on the stack.
+        */
+       if (p_is_s[i] != 0) {
+-        p_is_s[i] = (char *)(*(dataptr++));
++        p_is_s[i] = va_arg(ap, char *);
+       } else {
+-        param[i] = (int)(*(dataptr++));
++        param[i] = va_arg(ap, int);
+       }
+     }
+ 
+@@ -716,11 +717,13 @@
+ grub_tparm(const char *string,...)
+ {
+     char *result;
+-    int *dataptr = (int *) &string;
++    va_list ap;
+ 
+-    dataptr++;
++    va_start(ap, string);
+ 
+-    result = tparam_internal(string, dataptr);
++    result = tparam_internal(string, ap);
++
++    va_end(ap);
+ 
+     return result;
+ }
+Index: grub/stage2/fsys_iso9660.c
+===================================================================
+--- grub.orig/stage2/fsys_iso9660.c    2008-06-16 15:18:03.400933000 +0100
++++ grub/stage2/fsys_iso9660.c 2008-06-16 15:18:14.779009000 +0100
+@@ -59,7 +59,14 @@
+ static inline unsigned long
+ log2 (unsigned long word)
+ {
+-  asm volatile ("bsfl %1,%0"
++  asm volatile ("bsf"
++#ifdef __i386__
++                "l"
++#endif
++#ifdef __x86_64__
++                "q"
++#endif
++                " %1,%0"
+               :          "=r" (word)
+               :          "r" (word));
+   return word;
+Index: grub/stage2/fsys_reiserfs.c
+===================================================================
+--- grub.orig/stage2/fsys_reiserfs.c   2008-06-16 15:18:03.410933000 +0100
++++ grub/stage2/fsys_reiserfs.c        2008-06-16 15:18:14.786009000 +0100
+@@ -369,7 +369,14 @@
+ static __inline__ unsigned long
+ log2 (unsigned long word)
+ {
+-  __asm__ ("bsfl %1,%0"
++  __asm__ ("bsf"
++#ifdef __i386__
++                "l"
++#endif
++#ifdef __x86_64__
++                "q"
++#endif
++                " %1,%0"
+          : "=r" (word)
+          : "r" (word));
+   return word;
+Index: grub/netboot/misc.c
+===================================================================
+--- grub.orig/netboot/misc.c   2008-06-16 15:18:03.456934000 +0100
++++ grub/netboot/misc.c        2008-06-16 15:18:14.790009000 +0100
+@@ -21,7 +21,9 @@
+ 
+ #define GRUB  1
+ #include <etherboot.h>
++#include <stdarg.h>
+ 
++#ifndef __MINIOS__
+ void
+ sleep (int secs)
+ {
+@@ -30,6 +32,7 @@
+   while (currticks () < tmo)
+     ;
+ }
++#endif
+ 
+ void
+ twiddle (void)
+@@ -71,7 +74,7 @@
+       Note: width specification not supported
+ **************************************************************************/
+ static int
+-etherboot_vsprintf (char *buf, const char *fmt, const int *dp)
++etherboot_vsprintf (char *buf, const char *fmt, va_list ap)
+ {
+   char *p, *s;
+   
+@@ -86,7 +89,7 @@
+       
+       if (*++fmt == 's')
+       {
+-        for (p = (char *) *dp++; *p != '\0'; p++)
++        for (p = va_arg(ap, char *); *p != '\0'; p++)
+           buf ? *s++ = *p : grub_putchar (*p);
+       }
+       else
+@@ -121,11 +124,9 @@
+         if ((*fmt | 0x20) == 'x')
+           {
+             /* With x86 gcc, sizeof(long) == sizeof(int) */
+-            const long *lp = (const long *) dp;
+-            long h = *lp++;
++            long h = va_arg(ap, int);
+             int ncase = (*fmt & 0x20);
+             
+-            dp = (const int *) lp;
+             if (alt)
+               {
+                 *q++ = '0';
+@@ -136,7 +137,7 @@
+           }
+         else if (*fmt == 'd')
+           {
+-            int i = *dp++;
++            int i = va_arg(ap, int);
+             char *r;
+             
+             if (i < 0)
+@@ -171,10 +172,8 @@
+               unsigned char   c[4];
+             }
+             u;
+-            const long *lp = (const long *) dp;
+             
+-            u.l = *lp++;
+-            dp = (const int *) lp;
++            u.l = va_arg(ap, int);
+             
+             for (r = &u.c[0]; r < &u.c[4]; ++r)
+               q += etherboot_sprintf (q, "%d.", *r);
+@@ -184,7 +183,7 @@
+         else if (*fmt == '!')
+           {
+             char *r;
+-            p = (char *) *dp++;
++            p = va_arg(ap, char *);
+             
+             for (r = p + ETH_ALEN; p < r; ++p)
+               q += etherboot_sprintf (q, "%hhX:", *p);
+@@ -192,7 +191,7 @@
+             --q;
+           }
+         else if (*fmt == 'c')
+-          *q++ = *dp++;
++          *q++ = va_arg(ap, int);
+         else
+           *q++ = *fmt;
+         
+@@ -211,13 +210,21 @@
+ int
+ etherboot_sprintf (char *buf, const char *fmt, ...)
+ {
+-  return etherboot_vsprintf (buf, fmt, ((const int *) &fmt) + 1);
++  va_list ap;
++  int ret;
++  va_start(ap, fmt);
++  ret = etherboot_vsprintf (buf, fmt, ap);
++  va_end(ap);
++  return ret;
+ }
+ 
+ void
+ etherboot_printf (const char *fmt, ...)
+ {
+-  (void) etherboot_vsprintf (0, fmt, ((const int *) &fmt) + 1);
++  va_list ap;
++  va_start(ap, fmt);
++  etherboot_vsprintf (0, fmt, ap);
++  va_end(ap);
+ }
+ 
+ int
+Index: grub/netboot/main.c
+===================================================================
+--- grub.orig/netboot/main.c   2008-06-16 15:18:03.470932000 +0100
++++ grub/netboot/main.c        2008-06-16 15:18:14.797009000 +0100
+@@ -55,7 +55,7 @@
+ static int vendorext_isvalid;
+ static unsigned long netmask;
+ static struct bootpd_t bootp_data;
+-static unsigned long xid;
++static unsigned int xid;
+ 
+ #define       BOOTP_DATA_ADDR (&bootp_data)
+ 
+@@ -778,7 +778,7 @@
+ 
+             arpreply = (struct arprequest *) &nic.packet[ETH_HLEN];
+             
+-            if (arpreply->opcode == htons (ARP_REPLY)
++            if (arpreply->opcode == htons (ARP_REPLY) && ptr
+                 && ! grub_memcmp (arpreply->sipaddr, ptr, sizeof (in_addr))
+                 && type == AWAIT_ARP)
+               {
+@@ -827,7 +827,7 @@
+           {
+             arpreply = (struct arprequest *) &nic.packet[ETH_HLEN];
+             
+-            if (arpreply->opcode == htons (RARP_REPLY)
++            if (arpreply->opcode == htons (RARP_REPLY) && ptr
+                 && ! grub_memcmp (arpreply->thwaddr, ptr, ETH_ALEN))
+               {
+                 grub_memmove ((char *) arptable[ARP_SERVER].node,
+@@ -1135,7 +1135,7 @@
+ long
+ rfc2131_sleep_interval (int base, int exp)
+ {
+-  static long seed = 0;
++  static unsigned seed = 0;
+   long q;
+   unsigned long tmo;
+   
+Index: grub/stage2/graphics.c
+===================================================================
+--- grub.orig/stage2/graphics.c        2008-06-16 15:18:14.524009000 +0100
++++ grub/stage2/graphics.c     2008-06-17 14:29:05.204328000 +0100
+@@ -30,7 +30,29 @@
+ #include <shared.h>
+ #include <graphics.h>
+ 
++#ifdef __MINIOS__
++#include <stdint.h>
++typedef uint8_t Bit8u;
++#include <vgafonts.h>
++#include <fbfront.h>
++#include <malloc.h>
++#define set_int1c_handler() (void)0
++#define unset_int1c_handler() (void)0
++static uint32_t *VIDEOMEM;
++static struct fbfront_dev *fb_dev;
++static uint32_t palette[17];
++short cursorX, cursorY;
++/* TODO: blink */
++uint32_t cursorBuf32[16*8];
++#define WIDTH 640
++#define HEIGHT 480
++#define DEPTH 32
++#define RAMSIZE (WIDTH * HEIGHT * (DEPTH / 8))
++#else
++#define fbfront_update(dev, x, y, w, h) (void)0
+ int saved_videomode;
++#endif
++
+ unsigned char *font8x16;
+ 
+ int graphics_inited = 0;
+@@ -38,11 +60,15 @@
+ 
+ int shade = 1, no_cursor = 0;
+ 
++#ifdef __MINIOS__
++uint32_t VSHADOW[RAMSIZE];
++#else
+ #define VSHADOW VSHADOW1
+ unsigned char VSHADOW1[38400];
+ unsigned char VSHADOW2[38400];
+ unsigned char VSHADOW4[38400];
+ unsigned char VSHADOW8[38400];
++#endif
+ 
+ /* define the default viewable area */
+ int view_x0 = 0;
+@@ -129,6 +155,8 @@
+     count_lines = k;
+ 
+     no_scroll = 0;
++
++    fbfront_update(fb_dev, view_x0 * 8, view_y0 * 16, (view_x1 - view_x0) * 
8, (view_y1 - view_y0) * 16);
+ }
+ 
+ /* Set the splash image */
+@@ -154,17 +182,29 @@
+ int graphics_init()
+ {
+     if (!graphics_inited) {
++#ifdef __MINIOS__
++      VIDEOMEM = memalign(PAGE_SIZE, RAMSIZE);
++      if (!(fb_dev = fb_open(VIDEOMEM, WIDTH, HEIGHT, DEPTH))) {
++          free(VIDEOMEM);
++          return 0;
++      }
++#else
+         saved_videomode = set_videomode(0x12);
+         if (get_videomode() != 0x12) {
+             set_videomode(saved_videomode);
+             return 0;
+         }
++#endif
+         graphics_inited = 1;
+     }
+     else
+         return 1;
+ 
++#ifdef __MINIOS__
++    font8x16 = vgafont16;
++#else
+     font8x16 = (unsigned char*)graphics_get_font();
++#endif
+ 
+     /* make sure that the highlight color is set correctly */
+     graphics_highlight_color = ((graphics_normal_color >> 4) | 
+@@ -176,7 +216,11 @@
+         grub_printf("Failed to read splash image (%s)\n", splashimage);
+         grub_printf("Press any key to continue...");
+         getkey();
++#ifdef __MINIOS__
++      fb_close();
++#else
+         set_videomode(saved_videomode);
++#endif
+         graphics_inited = 0;
+         return 0;
+     }
+@@ -190,8 +234,13 @@
+ void graphics_end(void)
+ {
+     if (graphics_inited) {
++#ifdef __MINIOS__
++      fb_close();
++      free(VIDEOMEM);
++#else
+         unset_int1c_handler();
+         set_videomode(saved_videomode);
++#endif
+         graphics_inited = 0;
+         no_cursor = 0;
+     }
+@@ -204,15 +253,19 @@
+     graphics_cursor(0);
+ 
+     if (ch == '\n') {
++      fbfront_update(fb_dev, cursorX, cursorY, 8, 16);
+         if (fonty + 1 < view_y1)
+             graphics_setxy(fontx, fonty + 1);
+         else
+             graphics_scroll();
+         graphics_cursor(1);
++      fbfront_update(fb_dev, cursorX, cursorY, 8, 16);
+         return;
+     } else if (ch == '\r') {
++      fbfront_update(fb_dev, cursorX, cursorY, 8, 16);
+         graphics_setxy(view_x0, fonty);
+         graphics_cursor(1);
++      fbfront_update(fb_dev, cursorX, cursorY, 8, 16);
+         return;
+     }
+ 
+@@ -224,6 +277,7 @@
+         text[fonty * 80 + fontx] |= 0x100;
+ 
+     graphics_cursor(0);
++    fbfront_update(fb_dev, cursorX, cursorY, 8, 16);
+ 
+     if ((fontx + 1) >= view_x1) {
+         graphics_setxy(view_x0, fonty);
+@@ -232,13 +286,16 @@
+         else
+             graphics_scroll();
+         graphics_cursor(1);
++      fbfront_update(fb_dev, cursorX, cursorY, 8, 16);
+         do_more ();
+         graphics_cursor(0);
++      fbfront_update(fb_dev, cursorX, cursorY, 8, 16);
+     } else {
+         graphics_setxy(fontx + 1, fonty);
+     }
+ 
+     graphics_cursor(1);
++    fbfront_update(fb_dev, cursorX, cursorY, 8, 16);
+ }
+ 
+ /* get the current location of the cursor */
+@@ -248,10 +305,12 @@
+ 
+ void graphics_gotoxy(int x, int y) {
+     graphics_cursor(0);
++    fbfront_update(fb_dev, cursorX, cursorY, 8, 16);
+ 
+     graphics_setxy(x, y);
+ 
+     graphics_cursor(1);
++    fbfront_update(fb_dev, cursorX, cursorY, 8, 16);
+ }
+ 
+ void graphics_cls(void) {
+@@ -262,15 +321,21 @@
+     graphics_gotoxy(view_x0, view_y0);
+ 
+     mem = (unsigned char*)VIDEOMEM;
++#ifndef __MINIOS__
+     s1 = (unsigned char*)VSHADOW1;
+     s2 = (unsigned char*)VSHADOW2;
+     s4 = (unsigned char*)VSHADOW4;
+     s8 = (unsigned char*)VSHADOW8;
++#endif
+ 
+     for (i = 0; i < 80 * 30; i++)
+         text[i] = ' ';
+     graphics_cursor(1);
+ 
++#ifdef __MINIOS__
++    memcpy(mem, VSHADOW, RAMSIZE);
++    fbfront_update(fb_dev, 0, 0, 640, 480);
++#else
+     BitMask(0xff);
+ 
+     /* plane 1 */
+@@ -290,6 +355,7 @@
+     grub_memcpy(mem, s8, 38400);
+ 
+     MapMask(15);
++#endif
+ 
+     if (no_cursor) {
+         no_cursor = 0;
+@@ -337,6 +403,11 @@
+     return 0;
+ }
+ 
++void graphics_set_palette(int idx, int red, int green, int blue)
++{
++    palette[idx] = (red << (16 + 2)) | (green << (8 + 2)) | (blue << 2);
++}
++
+ /* Read in the splashscreen image and set the palette up appropriately.
+  * Format of splashscreen is an xpm (can be gzipped) with 16 colors and
+  * 640x480. */
+@@ -413,18 +484,19 @@
+         }
+ 
+         if (len == 6 && idx < 15) {
+-            int r = ((hex(buf[0]) << 4) | hex(buf[1])) >> 2;
+-            int g = ((hex(buf[2]) << 4) | hex(buf[3])) >> 2;
+-            int b = ((hex(buf[4]) << 4) | hex(buf[5])) >> 2;
++            int r = ((hex(buf[0]) << 4) | hex(buf[1]));
++            int g = ((hex(buf[2]) << 4) | hex(buf[3]));
++            int b = ((hex(buf[4]) << 4) | hex(buf[5]));
+ 
+             pal[idx] = base;
+-            graphics_set_palette(idx, r, g, b);
++            graphics_set_palette(idx, r / 4, g / 4, b / 4);
+             ++idx;
+         }
+     }
+ 
+     x = y = len = 0;
+ 
++#ifndef __MINIOS__
+     s1 = (unsigned char*)VSHADOW1;
+     s2 = (unsigned char*)VSHADOW2;
+     s4 = (unsigned char*)VSHADOW4;
+@@ -432,6 +504,7 @@
+ 
+     for (i = 0; i < 38400; i++)
+         s1[i] = s2[i] = s4[i] = s8[i] = 0;
++#endif
+ 
+     /* parse xpm data */
+     while (y < height) {
+@@ -451,6 +524,9 @@
+                     break;
+                 }
+ 
++#ifdef __MINIOS__
++          VSHADOW[x + y * 640] = palette[i];
++#else
+             mask = 0x80 >> (x & 7);
+             if (c & 1)
+                 s1[len + (x >> 3)] |= mask;
+@@ -460,6 +536,7 @@
+                 s4[len + (x >> 3)] |= mask;
+             if (c & 8)
+                 s8[len + (x >> 3)] |= mask;
++#endif
+ 
+             if (++x >= 640) {
+                 x = 0;
+@@ -494,7 +571,13 @@
+ }
+ 
+ void graphics_cursor(int set) {
+-    unsigned char *pat, *mem, *ptr, chr[16 << 2];
++    unsigned char *pat;
++#ifdef __MINIOS__
++    uint32_t *mem, *ptr, chr[16 * 8];
++    int j;
++#else
++    unsigned char *mem, *ptr, chr[16 << 2];
++#endif
+     int i, ch, invert, offset;
+ 
+     if (set && (no_cursor || no_scroll))
+@@ -505,71 +588,127 @@
+     invert = (text[fonty * 80 + fontx] & 0xff00) != 0;
+     pat = font8x16 + (ch << 4);
+ 
+-    mem = (unsigned char*)VIDEOMEM + offset;
++    mem = (unsigned char*)VIDEOMEM + offset
++#ifdef __MINIOS__
++      * 8 * 4
++#endif
++      ;
+ 
+     if (!set) {
+         for (i = 0; i < 16; i++) {
+             unsigned char mask = pat[i];
+ 
+             if (!invert) {
++#ifdef __MINIOS__
++              memcpy(chr + i * 8, VSHADOW + offset * 8, 8 * 4);
++#else
+                 chr[i     ] = ((unsigned char*)VSHADOW1)[offset];
+                 chr[16 + i] = ((unsigned char*)VSHADOW2)[offset];
+                 chr[32 + i] = ((unsigned char*)VSHADOW4)[offset];
+                 chr[48 + i] = ((unsigned char*)VSHADOW8)[offset];
++#endif
+ 
+                 if (shade) {
+                     if (ch == DISP_VERT || ch == DISP_LL ||
+                         ch == DISP_UR || ch == DISP_LR) {
+                         unsigned char pmask = ~(pat[i] >> 1);
+ 
++#ifdef __MINIOS__
++                      for (j = 0; j < 8; j++)
++                          if (!(pmask & (1U << j)))
++                              chr[i * 8 + (7 - j)] = palette[0];
++#else
+                         chr[i     ] &= pmask;
+                         chr[16 + i] &= pmask;
+                         chr[32 + i] &= pmask;
+                         chr[48 + i] &= pmask;
++#endif
+                     }
+                     if (i > 0 && ch != DISP_VERT) {
+                         unsigned char pmask = ~(pat[i - 1] >> 1);
+ 
++#ifdef __MINIOS__
++                      for (j = 0; j < 8; j++)
++                          if (!(pmask & (1U << j)))
++                              chr[i * 8 + (7 - j)] = palette[0];
++#else
+                         chr[i     ] &= pmask;
+                         chr[16 + i] &= pmask;
+                         chr[32 + i] &= pmask;
+                         chr[48 + i] &= pmask;
++#endif
+                         if (ch == DISP_HORIZ || ch == DISP_UR || ch == 
DISP_LR) {
+                             pmask = ~pat[i - 1];
+ 
++#ifdef __MINIOS__
++                          for (j = 0; j < 8; j++)
++                              if (!(pmask & (1U << j)))
++                                  chr[i * 8 + (7 - j)] = palette[0];
++#else
+                             chr[i     ] &= pmask;
+                             chr[16 + i] &= pmask;
+                             chr[32 + i] &= pmask;
+                             chr[48 + i] &= pmask;
++#endif
+                         }
+                     }
+                 }
++#ifdef __MINIOS__
++              for (j = 0; j < 8; j++)
++                  if (mask & (1U << j))
++                      chr[i * 8 + (7 - j)] = palette[15];
++#else
+                 chr[i     ] |= mask;
+                 chr[16 + i] |= mask;
+                 chr[32 + i] |= mask;
+                 chr[48 + i] |= mask;
++#endif
+ 
+                 offset += 80;
+             }
+             else {
++#ifdef __MINIOS__
++              for (j = 0; j < 8; j++)
++                  if (mask & (1U << j))
++                      chr[i * 8 + (7 - j)] = palette[15];
++                  else
++                      chr[i * 8 + (7 - j)] = palette[0];
++#else
+                 chr[i     ] = mask;
+                 chr[16 + i] = mask;
+                 chr[32 + i] = mask;
+                 chr[48 + i] = mask;
++#endif
+             }
+         }
+     }
+     else {
++#ifdef __MINIOS__
++        ptr = mem;
++        for (i = 0; i < 16; i++, ptr += 80 * 8)
++          for (j = 0; j < 8; j++) {
++              if (pat[i] & (1U << (7 - j)))
++                  cursorBuf32[i * 8 + j] = ptr[j] = palette[0];
++              else
++                  cursorBuf32[i * 8 + j] = ptr[j] = palette[15];
++          }
++#else
+         MapMask(15);
+         ptr = mem;
+         for (i = 0; i < 16; i++, ptr += 80) {
+             cursorBuf[i] = pat[i];
+             *ptr = ~pat[i];
+         }
++#endif
+         return;
+     }
+ 
+     offset = 0;
++#ifdef __MINIOS__
++    ptr = mem;
++    for (j = 0; j < 16; j++, ptr += 80 * 8)
++      memcpy(ptr, chr + j * 8 + offset * 8, 8 * 4);
++#else
+     for (i = 1; i < 16; i <<= 1, offset += 16) {
+         int j;
+ 
+@@ -580,6 +719,7 @@
+     }
+ 
+     MapMask(15);
++#endif
+ }
+ 
+ #endif /* SUPPORT_GRAPHICS */
+Index: grub/stage2/graphics.h
+===================================================================
+--- grub.orig/stage2/graphics.h        2008-06-16 15:18:14.527010000 +0100
++++ grub/stage2/graphics.h     2008-06-16 15:18:14.805010000 +0100
+@@ -21,8 +21,10 @@
+ #ifndef GRAPHICS_H
+ #define GRAPHICS_H
+ 
++#ifndef __MINIOS__
+ /* magic constant */
+ #define VIDEOMEM 0xA0000
++#endif
+ 
+ /* function prototypes */
+ char *graphics_get_splash(void);
+Index: grub/stage2/stage2.c
+===================================================================
+--- grub.orig/stage2/stage2.c  2008-06-17 11:06:47.873523000 +0100
++++ grub/stage2/stage2.c       2008-06-17 11:07:05.225628000 +0100
+@@ -31,10 +31,10 @@
+ #if defined(PRESET_MENU_STRING) || defined(SUPPORT_DISKLESS)
+ 
+ # if defined(PRESET_MENU_STRING)
+-static const char *preset_menu = PRESET_MENU_STRING;
++const char *preset_menu = PRESET_MENU_STRING;
+ # elif defined(SUPPORT_DISKLESS)
+ /* Execute the command "bootp" automatically.  */
+-static const char *preset_menu = "bootp\n";
++const char *preset_menu = "bootp\n";
+ # endif /* SUPPORT_DISKLESS */
+ 
+ static int preset_menu_offset;
diff -r 8a0656950b1c -r c8d9ade45781 stubdom/grub/Makefile
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/stubdom/grub/Makefile     Wed Jun 18 09:36:47 2008 +0100
@@ -0,0 +1,76 @@
+XEN_ROOT = ../..
+
+include $(XEN_ROOT)/Config.mk
+vpath %.c ../grub-cvs
+
+BOOT=boot-$(XEN_TARGET_ARCH).o
+
+DEF_CPPFLAGS += -I$(XEN_ROOT)/tools/libxc -I.
+DEF_CPPFLAGS += -I../grub-cvs/stage1
+DEF_CPPFLAGS += -I../grub-cvs/stage2
+DEF_CPPFLAGS += -I../grub-cvs/netboot
+DEF_CPPFLAGS += -I$(XEN_ROOT)/tools/firmware/vgabios
+DEF_CPPFLAGS += -DWITHOUT_LIBC_STUBS
+DEF_CPPFLAGS += -DSUPPORT_NETBOOT
+DEF_CPPFLAGS += -DSUPPORT_GRAPHICS
+DEF_CPPFLAGS += -DSUPPORT_SERIAL
+DEF_CPPFLAGS += -DPRESET_MENU_STRING='""'
+DEF_CPPFLAGS += -DPACKAGE='"grubdom"' -DVERSION='"0.97"'
+
+all: main.a
+
+STAGE2_SOURCES=builtins.c char_io.c cmdline.c common.c console.c disk_io.c 
graphics.c gunzip.c md5.c serial.c stage2.c terminfo.c tparm.c
+
+NETBOOT_SOURCES=fsys_tftp.c main.c misc.c
+CPPFLAGS += -DFSYS_TFTP=1
+
+STAGE2_SOURCES+=fsys_ext2fs.c
+CPPFLAGS += -DFSYS_EXT2FS=1
+
+STAGE2_SOURCES+=fsys_fat.c
+CPPFLAGS += -DFSYS_FAT=1
+
+STAGE2_SOURCES+=fsys_ffs.c
+CPPFLAGS += -DFSYS_FFS=1
+
+STAGE2_SOURCES+=fsys_iso9660.c
+CPPFLAGS += -DFSYS_ISO9660=1
+
+STAGE2_SOURCES+=fsys_jfs.c
+CPPFLAGS += -DFSYS_JFS=1
+
+STAGE2_SOURCES+=fsys_minix.c
+CPPFLAGS += -DFSYS_MINIX=1
+
+STAGE2_SOURCES+=fsys_reiserfs.c
+CPPFLAGS += -DFSYS_REISERFS=1
+
+STAGE2_SOURCES+=fsys_ufs2.c
+CPPFLAGS += -DFSYS_UFS2=1
+
+STAGE2_SOURCES+=fsys_vstafs.c
+CPPFLAGS += -DFSYS_VSTAFS=1
+
+ifeq (0,1)
+STAGE2_SOURCES+=fsys_xfs.c
+CPPFLAGS += -DFSYS_XFS=1
+endif
+
+STAGE2_SOURCES:=$(addprefix stage2/,$(STAGE2_SOURCES))
+NETBOOT_SOURCES:=$(addprefix netboot/,$(NETBOOT_SOURCES))
+
+$(BOOT): DEF_CPPFLAGS+=-D__ASSEMBLY__
+
+OBJS = $(NETBOOT_SOURCES:.c=.o) $(STAGE2_SOURCES:.c=.o) kexec.o mini-os.o
+
+dirs:
+       mkdir -p netboot stage2
+       touch $@
+
+$(OBJS): dirs
+
+main.a: $(BOOT) $(OBJS)
+       $(AR) cr $@ $^
+
+clean:
+       rm -fr dirs *.a *.o stage2 netboot
diff -r 8a0656950b1c -r c8d9ade45781 stubdom/grub/boot-x86_32.S
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/stubdom/grub/boot-x86_32.S        Wed Jun 18 09:36:47 2008 +0100
@@ -0,0 +1,112 @@
+#include <os.h>
+#include <arch_limits.h>
+#include <xen/arch-x86_32.h>
+
+/* For simplicity, we keep all of this into just one data page */
+.data
+.globl _boot_page
+_boot_page:
+        .align __PAGE_SIZE
+
+/*
+ * The following data is initialized from C code
+ */
+
+/* Pte of this page */
+.globl _boot_page_entry
+_boot_page_entry:
+_boot_page_entry_lo:
+        .long 0
+_boot_page_entry_hi:
+        .long 0
+
+/* mmuext_op structure */
+/* Set new page directory */
+_boot_mmuext:
+        /* Op # */
+        .long MMUEXT_NEW_BASEPTR
+
+        /* MFN of target page table directory */
+.globl _boot_pdmfn
+_boot_pdmfn:
+        .long 0
+
+        /* Unused */
+        .long 0
+
+/* Unpin old page directory */
+        /* Op # */
+        .long MMUEXT_UNPIN_TABLE
+
+        /* MFN of old page table directory */
+.globl _boot_oldpdmfn
+_boot_oldpdmfn:
+        .long 0
+
+        /* Unused */
+        .long 0
+
+/* Target stack address, also target virtual address of this page */
+.globl _boot_stack
+_boot_stack:
+        .long 0
+        .long __KERNEL_SS
+.globl _boot_target
+_boot_target:
+        .long 0
+
+/* Target start info */
+.globl _boot_start_info
+_boot_start_info:
+        .long 0
+
+/* Target start address */
+.globl _boot_start
+_boot_start:
+        .long 0
+
+/*
+ * Boot target OS, does not return
+ */
+.globl _boot
+_boot:
+        /* Project ourselves at the target place. */
+        movl    _boot_target, %ebx
+        movl    %ebx, %ebp     /* also keep it in ebp for relative addressing 
*/
+        movl    _boot_page_entry_lo, %ecx
+        movl    _boot_page_entry_hi, %edx
+        movl    $2, %esi /* UVMF_INVLPG */
+        movl    $__HYPERVISOR_update_va_mapping, %eax
+        int     $0x82
+        testl   %eax, %eax
+        jz      0f
+        ud2
+
+0:
+        /* Go there. */
+        movl    $(0f - _boot_page), %eax
+        movl    _boot_target, %ebx
+        addl    %ebx, %eax
+        jmpl    *%eax
+0:
+        
+        /* Load target page table and unpin old page table.  */
+        /* We shouldn't have any problem since in the new page table our page 
is
+           mapped at the same place.  */
+        leal    (_boot_mmuext-_boot_page)(%ebp), %ebx
+        movl    $2, %ecx
+        xorl    %edx, %edx
+        movl    $0x7FF0, %esi /* DOMID_SELF */
+        movl    $__HYPERVISOR_mmuext_op, %eax
+        int     $0x82
+        testl   %eax, %eax
+        jns     0f
+        ud2
+
+0:
+        /* Initialize registers.  */
+        lss     (_boot_stack-_boot_page)(%ebp), %esp
+        movl    (_boot_start_info-_boot_page)(%ebp), %esi
+
+        /* Jump!  */
+        jmpl    *(_boot_start-_boot_page)(%ebp)
diff -r 8a0656950b1c -r c8d9ade45781 stubdom/grub/boot-x86_64.S
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/stubdom/grub/boot-x86_64.S        Wed Jun 18 09:36:47 2008 +0100
@@ -0,0 +1,108 @@
+#include <os.h>
+#include <arch_limits.h>
+#include <xen/arch-x86_64.h>
+
+/* For simplicity, we keep all of this into just one data page */
+.data
+.globl _boot_page
+_boot_page:
+        .align __PAGE_SIZE
+
+/*
+ * The following data is initialized from C code
+ */
+
+/* Pte of this page */
+.globl _boot_page_entry
+_boot_page_entry:
+        .quad 0
+
+/* mmuext_op structure */
+/* Set new page directory */
+_boot_mmuext:
+        /* Op # */
+        .long MMUEXT_NEW_BASEPTR
+        .long 0 /* pad */
+
+        /* MFN of target page table directory */
+.globl _boot_pdmfn
+_boot_pdmfn:
+        .quad 0
+
+        /* Unused */
+        .quad 0
+
+/* Unpin old page directory */
+        /* Op # */
+        .long MMUEXT_UNPIN_TABLE
+        .long 0 /* pad */
+
+        /* MFN of old page table directory */
+.globl _boot_oldpdmfn
+_boot_oldpdmfn:
+        .quad 0
+
+        /* Unused */
+        .quad 0
+
+/* Target stack address, also target virtual address of this page */
+.globl _boot_stack
+_boot_stack:
+        .quad 0
+.globl _boot_target
+_boot_target:
+        .quad 0
+
+/* Target start info */
+.globl _boot_start_info
+_boot_start_info:
+        .quad 0
+
+/* Target start address */
+.globl _boot_start
+_boot_start:
+        .quad 0
+
+/*
+ * Boot target OS, does not return
+ */
+.globl _boot
+_boot:
+        /* Project ourselves at the target place. */
+        movq    _boot_target, %rdi
+        movq    _boot_page_entry, %rsi
+        movq    $2, %rdx /* UVMF_INVLPG */
+        movq    $__HYPERVISOR_update_va_mapping, %rax
+        syscall
+        testq   %rax, %rax
+        jz      0f
+        ud2
+
+0:
+        /* Go there. */
+        movq    $(0f - _boot_page), %rax
+        movq    _boot_target, %rbx
+        addq    %rbx, %rax
+        jmpq    *%rax
+0:
+        
+        /* Load target page table and unpin old page table.  */
+        /* We shouldn't have any problem since in the new page table our page 
is
+           mapped at the same place.  */
+        leaq    _boot_mmuext(%rip), %rdi
+        movq    $2, %rsi
+        xorq    %rdx, %rdx
+        movq    $0x7FF0, %r10 /* DOMID_SELF */
+        movq    $__HYPERVISOR_mmuext_op, %rax
+        syscall
+        testq   %rax, %rax
+        jns     0f
+        ud2
+
+0:
+        /* Initialize registers.  */
+        movq    _boot_stack(%rip), %rsp
+        movq    _boot_start_info(%rip), %rsi
+
+        /* Jump!  */
+        jmpq    *_boot_start(%rip)
diff -r 8a0656950b1c -r c8d9ade45781 stubdom/grub/config.h
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/stubdom/grub/config.h     Wed Jun 18 09:36:47 2008 +0100
@@ -0,0 +1,11 @@
+#include <stdio.h>
+#undef putchar
+#include <ctype.h>
+#include <string.h>
+#define debug _debug
+#define grub_halt(a) do_exit()
+#define printf grub_printf
+void kexec(void *kernel, long kernel_size, void *module, long module_size, 
char *cmdline);
+struct fbfront_dev *fb_open(void *fb, int width, int height, int depth);
+void fb_close(void);
+void pv_boot (void);
diff -r 8a0656950b1c -r c8d9ade45781 stubdom/grub/kexec.c
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/stubdom/grub/kexec.c      Wed Jun 18 09:36:47 2008 +0100
@@ -0,0 +1,324 @@
+/*
+ * This supports booting another PV kernel from Mini-OS
+ *
+ * The idea is to setup it using libxc, answer to day0 memory allocation
+ * requests, and using a trampoline boot page to switch to the new page table.
+ *
+ * The procedure of the boot page is:
+ * - map itself at the target position (that may overwrite some C stuff, but we
+ *   do not care any more)
+ * - jump there
+ * - switch to the target page table
+ * - unpin the old page table
+ * - jump to the new kernel
+ *
+ * Samuel Thibault <Samuel.Thibault@xxxxxxxxxxxxx>, May 2008
+ */
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+
+#include <xenctrl.h>
+#include <xc_dom.h>
+
+#include <kernel.h>
+#include <console.h>
+#include <os.h>
+#include <blkfront.h>
+#include <netfront.h>
+#include <fbfront.h>
+#include <shared.h>
+
+#include "mini-os.h"
+
+#if 0
+#define DEBUG(fmt, ...) printk(fmt, ## __VA_ARGS__)
+#else
+#define DEBUG(fmt, ...) (void)0
+#endif
+
+/* Assembly boot page from boot.S */
+extern void _boot_page;
+extern pgentry_t _boot_page_entry;
+extern unsigned long _boot_pdmfn;
+extern unsigned long _boot_stack, _boot_target, _boot_start_info, _boot_start;
+extern xen_pfn_t _boot_oldpdmfn;
+extern void _boot(void);
+
+static unsigned long *pages;
+static unsigned long *pages_mfns;
+static unsigned long allocated;
+
+int pin_table(int xc_handle, unsigned int type, unsigned long mfn,
+              domid_t dom);
+
+/* We need mfn to appear as target_pfn, so exchange with the MFN there */
+static void do_exchange(struct xc_dom_image *dom, xen_pfn_t target_pfn, 
xen_pfn_t source_mfn)
+{
+    xen_pfn_t source_pfn;
+    xen_pfn_t target_mfn;
+
+    for (source_pfn = 0; source_pfn < start_info.nr_pages; source_pfn++)
+        if (dom->p2m_host[source_pfn] == source_mfn)
+            break;
+    ASSERT(source_pfn < start_info.nr_pages);
+
+    target_mfn = dom->p2m_host[target_pfn];
+
+    /* Put target MFN at source PFN */
+    dom->p2m_host[source_pfn] = target_mfn;
+
+    /* Put source MFN at target PFN */
+    dom->p2m_host[target_pfn] = source_mfn;
+}
+
+int kexec_allocate(struct xc_dom_image *dom, xen_vaddr_t up_to)
+{
+    unsigned long new_allocated = (up_to - dom->parms.virt_base) / PAGE_SIZE;
+    unsigned long i;
+
+    pages = realloc(pages, new_allocated * sizeof(*pages));
+    pages_mfns = realloc(pages_mfns, new_allocated * sizeof(*pages_mfns));
+    for (i = allocated; i < new_allocated; i++) {
+        /* Exchange old page of PFN i with a newly allocated page.  */
+        xen_pfn_t old_mfn = dom->p2m_host[i];
+        xen_pfn_t new_pfn;
+        xen_pfn_t new_mfn;
+
+        pages[i] = alloc_page();
+        memset((void*) pages[i], 0, PAGE_SIZE);
+        new_pfn = PHYS_PFN(to_phys(pages[i]));
+        pages_mfns[i] = new_mfn = pfn_to_mfn(new_pfn);
+
+        /* Put old page at new PFN */
+        dom->p2m_host[new_pfn] = old_mfn;
+
+        /* Put new page at PFN i */
+        dom->p2m_host[i] = new_mfn;
+    }
+
+    allocated = new_allocated;
+
+    return 0;
+}
+
+void kexec(void *kernel, long kernel_size, void *module, long module_size, 
char *cmdline)
+{
+    struct xc_dom_image *dom;
+    int rc;
+    domid_t domid = DOMID_SELF;
+    xen_pfn_t pfn;
+    int xc_handle;
+    unsigned long i;
+    void *seg;
+    xen_pfn_t boot_page_mfn = virt_to_mfn(&_boot_page);
+    char features[] = "";
+    struct mmu_update *m2p_updates;
+    unsigned long nr_m2p_updates;
+
+    DEBUG("booting with cmdline %s\n", cmdline);
+    xc_handle = xc_interface_open();
+
+    dom = xc_dom_allocate(cmdline, features);
+    dom->allocate = kexec_allocate;
+
+    dom->kernel_blob = kernel;
+    dom->kernel_size = kernel_size;
+
+    dom->ramdisk_blob = module;
+    dom->ramdisk_size = module_size;
+
+    dom->flags = 0;
+    dom->console_evtchn = start_info.console.domU.evtchn;
+    dom->xenstore_evtchn = start_info.store_evtchn;
+
+    if ( (rc = xc_dom_boot_xen_init(dom, xc_handle, domid)) != 0 ) {
+        grub_printf("xc_dom_boot_xen_init returned %d\n", rc);
+        errnum = ERR_BOOT_FAILURE;
+        goto out;
+    }
+    if ( (rc = xc_dom_parse_image(dom)) != 0 ) {
+        grub_printf("xc_dom_parse_image returned %d\n", rc);
+        errnum = ERR_BOOT_FAILURE;
+        goto out;
+    }
+
+#ifdef __i386__
+    if (strcmp(dom->guest_type, "xen-3.0-x86_32p")) {
+        grub_printf("can only boot x86 32 PAE kernels, not %s\n", 
dom->guest_type);
+        errnum = ERR_EXEC_FORMAT;
+        goto out;
+    }
+#endif
+#ifdef __x86_64__
+    if (strcmp(dom->guest_type, "xen-3.0-x86_64")) {
+        grub_printf("can only boot x86 64 kernels, not %s\n", dom->guest_type);
+        errnum = ERR_EXEC_FORMAT;
+        goto out;
+    }
+#endif
+
+    /* equivalent of xc_dom_mem_init */
+    dom->arch_hooks = xc_dom_find_arch_hooks(dom->guest_type);
+    dom->total_pages = start_info.nr_pages;
+
+    /* equivalent of arch_setup_meminit */
+
+    /* setup initial p2m */
+    dom->p2m_host = malloc(sizeof(*dom->p2m_host) * dom->total_pages);
+
+    /* Start with our current P2M */
+    for (i = 0; i < dom->total_pages; i++)
+        dom->p2m_host[i] = pfn_to_mfn(i);
+
+    if ( (rc = xc_dom_build_image(dom)) != 0 ) {
+        grub_printf("xc_dom_build_image returned %d\n", rc);
+        errnum = ERR_BOOT_FAILURE;
+        goto out;
+    }
+
+    /* copy hypercall page */
+    /* TODO: domctl instead, but requires privileges */
+    if (dom->parms.virt_hypercall != -1) {
+        pfn = PHYS_PFN(dom->parms.virt_hypercall - dom->parms.virt_base);
+        memcpy((void *) pages[pfn], hypercall_page, PAGE_SIZE);
+    }
+
+    /* Equivalent of xc_dom_boot_image */
+    dom->shared_info_mfn = PHYS_PFN(start_info.shared_info);
+
+    if (!xc_dom_compat_check(dom)) {
+        grub_printf("xc_dom_compat_check failed\n");
+        errnum = ERR_EXEC_FORMAT;
+        goto out;
+    }
+
+    /* Move current console, xenstore and boot MFNs to the allocated place */
+    do_exchange(dom, dom->console_pfn, start_info.console.domU.mfn);
+    do_exchange(dom, dom->xenstore_pfn, start_info.store_mfn);
+    DEBUG("virt base at %llx\n", dom->parms.virt_base);
+    DEBUG("bootstack_pfn %lx\n", dom->bootstack_pfn);
+    _boot_target = dom->parms.virt_base + PFN_PHYS(dom->bootstack_pfn);
+    DEBUG("_boot_target %lx\n", _boot_target);
+    do_exchange(dom, PHYS_PFN(_boot_target - dom->parms.virt_base),
+            virt_to_mfn(&_boot_page));
+
+    /* Make sure the bootstrap page table does not RW-map any of our current
+     * page table frames */
+    kexec_allocate(dom, dom->virt_pgtab_end);
+
+    if ( (rc = xc_dom_update_guest_p2m(dom))) {
+        grub_printf("xc_dom_update_guest_p2m returned %d\n", rc);
+        errnum = ERR_BOOT_FAILURE;
+        goto out;
+    }
+
+    if ( dom->arch_hooks->setup_pgtables )
+        if ( (rc = dom->arch_hooks->setup_pgtables(dom))) {
+            grub_printf("setup_pgtables returned %d\n", rc);
+            errnum = ERR_BOOT_FAILURE;
+            goto out;
+        }
+
+    /* start info page */
+#undef start_info
+    if ( dom->arch_hooks->start_info )
+        dom->arch_hooks->start_info(dom);
+#define start_info (start_info_union.start_info)
+
+    xc_dom_log_memory_footprint(dom);
+
+    /* Unmap libxc's projection of the boot page table */
+    seg = xc_dom_seg_to_ptr(dom, &dom->pgtables_seg);
+    munmap(seg, dom->pgtables_seg.vend - dom->pgtables_seg.vstart);
+
+    /* Unmap day0 pages to avoid having a r/w mapping of the future page table 
*/
+    for (pfn = 0; pfn < allocated; pfn++)
+        munmap((void*) pages[pfn], PAGE_SIZE);
+
+    /* Pin the boot page table base */
+    if ( (rc = pin_table(dom->guest_xc, 
+#ifdef __i386__
+                MMUEXT_PIN_L3_TABLE,
+#endif
+#ifdef __x86_64__
+                MMUEXT_PIN_L4_TABLE,
+#endif
+                xc_dom_p2m_host(dom, dom->pgtables_seg.pfn),
+                dom->guest_domid)) != 0 ) {
+        grub_printf("pin_table(%lx) returned %d\n", xc_dom_p2m_host(dom,
+                    dom->pgtables_seg.pfn), rc);
+        errnum = ERR_BOOT_FAILURE;
+        goto out_remap;
+    }
+
+    /* We populate the Mini-OS page table here so that boot.S can just call
+     * update_va_mapping to project itself there.  */
+    need_pgt(_boot_target);
+    DEBUG("day0 pages %lx\n", allocated);
+    DEBUG("boot target page %lx\n", _boot_target);
+    DEBUG("boot page %p\n", &_boot_page);
+    DEBUG("boot page mfn %lx\n", boot_page_mfn);
+    _boot_page_entry = PFN_PHYS(boot_page_mfn) | L1_PROT;
+    DEBUG("boot page entry %llx\n", _boot_page_entry);
+    _boot_oldpdmfn = virt_to_mfn(start_info.pt_base);
+    DEBUG("boot old pd mfn %lx\n", _boot_oldpdmfn);
+    DEBUG("boot pd virt %lx\n", dom->pgtables_seg.vstart);
+    _boot_pdmfn = dom->p2m_host[PHYS_PFN(dom->pgtables_seg.vstart - 
dom->parms.virt_base)];
+    DEBUG("boot pd mfn %lx\n", _boot_pdmfn);
+    _boot_stack = _boot_target + PAGE_SIZE;
+    DEBUG("boot stack %lx\n", _boot_stack);
+    _boot_start_info = dom->parms.virt_base + PFN_PHYS(dom->start_info_pfn);
+    DEBUG("boot start info %lx\n", _boot_start_info);
+    _boot_start = dom->parms.virt_entry;
+    DEBUG("boot start %lx\n", _boot_start);
+
+    /* Keep only useful entries */
+    for (nr_m2p_updates = pfn = 0; pfn < start_info.nr_pages; pfn++)
+        if (dom->p2m_host[pfn] != pfn_to_mfn(pfn))
+            nr_m2p_updates++;
+
+    m2p_updates = malloc(sizeof(*m2p_updates) * nr_m2p_updates);
+    for (i = pfn = 0; pfn < start_info.nr_pages; pfn++)
+        if (dom->p2m_host[pfn] != pfn_to_mfn(pfn)) {
+            m2p_updates[i].ptr = PFN_PHYS(dom->p2m_host[pfn]) | 
MMU_MACHPHYS_UPDATE;
+            m2p_updates[i].val = pfn;
+            i++;
+        }
+
+    for (i = 0; i < blk_nb; i++)
+        shutdown_blkfront(blk_dev[i]);
+    if (net_dev)
+        shutdown_netfront(net_dev);
+    if (kbd_dev)
+        shutdown_kbdfront(kbd_dev);
+    stop_kernel();
+
+    /* Update M2P */
+    if ((rc = HYPERVISOR_mmu_update(m2p_updates, nr_m2p_updates, NULL, 
DOMID_SELF)) < 0) {
+        xprintk("Could not update M2P\n");
+        ASSERT(0);
+    }
+
+    xprintk("go!\n");
+
+    /* Jump to trampoline boot page */
+    _boot();
+
+    ASSERT(0);
+
+out_remap:
+    for (pfn = 0; pfn < allocated; pfn++)
+        do_map_frames(pages[pfn], &pages_mfns[pfn], 1, 0, 0, DOMID_SELF, 0, 
L1_PROT);
+out:
+    xc_dom_release(dom);
+    for (pfn = 0; pfn < allocated; pfn++)
+        free_page((void*)pages[pfn]);
+    free(pages);
+    free(pages_mfns);
+    pages = NULL;
+    pages_mfns = NULL;
+    allocated = 0;
+    xc_interface_close(xc_handle );
+}
diff -r 8a0656950b1c -r c8d9ade45781 stubdom/grub/mini-os.c
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/stubdom/grub/mini-os.c    Wed Jun 18 09:36:47 2008 +0100
@@ -0,0 +1,702 @@
+/*
+ * Mini-OS support for GRUB.
+ *
+ * Samuel Thibault <Samuel.Thibault@xxxxxxxxxxxxx>, May 2008
+ */
+#include <sys/types.h>
+#include <sys/time.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <malloc.h>
+#include <unistd.h>
+
+#include <hypervisor.h>
+#include <blkfront.h>
+#include <netfront.h>
+#include <fbfront.h>
+#include <semaphore.h>
+
+#include <osdep.h>
+#include <shared.h>
+#include <nic.h>
+#include <etherboot.h>
+#include <terminfo.h>
+#include <term.h>
+
+#include "mini-os.h"
+
+extern const char *preset_menu;
+char config_file[DEFAULT_FILE_BUFLEN] = "(hd0,0)/boot/grub/menu.lst";
+unsigned long boot_drive = NETWORK_DRIVE;
+unsigned long install_partition = 0xFFFFFF;
+
+char version_string[] = VERSION;
+
+/* Variables from asm.S */
+int saved_entryno;
+
+/*
+ * Disk
+ */
+
+struct blkfront_dev **blk_dev;
+int blk_nb;
+static struct blkfront_info *blk_info;
+
+static int vbdcmp(const void *_vbd1, const void *_vbd2) {
+    char *vbd1 = *(char **)_vbd1;
+    char *vbd2 = *(char **)_vbd2;
+    int vbdn1 = atoi(vbd1);
+    int vbdn2 = atoi(vbd2);
+    return vbdn1 - vbdn2;
+}
+
+void init_disk (void)
+{
+    char **list;
+    char *msg;
+    int i;
+    char *path;
+
+    msg = xenbus_ls(XBT_NIL, "device/vbd", &list);
+    if (msg) {
+        printk("Error %s while reading list of disks\n", msg);
+        free(msg);
+        return;
+    }
+    blk_nb = 0;
+    while (list[blk_nb])
+        blk_nb++;
+    blk_dev = malloc(blk_nb * sizeof(*blk_dev));
+    blk_info = malloc(blk_nb * sizeof(*blk_info));
+
+    qsort(list, blk_nb, sizeof(*list), vbdcmp);
+
+    for (i = 0; i < blk_nb; i++) {
+        printk("vbd %s is hd%d\n", list[i], i);
+        asprintf(&path, "device/vbd/%s", list[i]);
+        blk_dev[i] = init_blkfront(path, &blk_info[i]);
+        free(path);
+        free(list[i]);
+    }
+}
+
+/* Return the geometry of DRIVE in GEOMETRY. If an error occurs, return
+   non-zero, otherwise zero.  */
+int get_diskinfo (int drive, struct geometry *geometry)
+{
+    int i;
+    if (!(drive & 0x80))
+        return -1;
+
+    i = drive - 0x80;
+    if (i >= blk_nb)
+        return -1;
+
+    /* Bogus geometry */
+    geometry->cylinders = 65535;
+    geometry->heads = 255;
+    geometry->sectors = 63;
+
+    geometry->total_sectors = blk_info[i].sectors;
+    geometry->sector_size = blk_info[i].sector_size;
+    geometry->flags = BIOSDISK_FLAG_LBA_EXTENSION;
+    if (blk_info[i].info & VDISK_CDROM)
+        geometry->flags |= BIOSDISK_FLAG_CDROM;
+    return 0;
+}
+
+/* Read/write NSEC sectors starting from SECTOR in DRIVE disk with GEOMETRY
+   from/into SEGMENT segment. If READ is BIOSDISK_READ, then read it,
+   else if READ is BIOSDISK_WRITE, then write it. If an geometry error
+   occurs, return BIOSDISK_ERROR_GEOMETRY, and if other error occurs, then
+   return the error number. Otherwise, return 0.  */
+int
+biosdisk (int read, int drive, struct geometry *geometry,
+          unsigned int sector, int nsec, int segment)
+{
+    void *addr = (void *) ((unsigned long)segment << 4);
+    struct blkfront_aiocb aiocb;
+    int i;
+
+    if (!(drive & 0x80))
+        return -1;
+
+    i = drive - 0x80;
+    if (i >= blk_nb)
+        return -1;
+
+    aiocb.aio_dev = blk_dev[i];
+    aiocb.aio_buf = addr;
+    aiocb.aio_nbytes = (size_t)nsec * blk_info[i].sector_size;
+    aiocb.aio_offset = (off_t)sector * blk_info[i].sector_size;
+    aiocb.aio_cb = NULL;
+
+    blkfront_io(&aiocb, read == BIOSDISK_WRITE);
+
+    return 0;
+}
+
+static int
+load_file(char *name, void **ptr, long *size)
+{
+    char *buf = NULL;
+    int allocated = 1 * 1024 * 1024;
+    int len, filled = 0;
+
+    if (!grub_open (name))
+        return -1;
+
+    buf = malloc(allocated);
+
+    errnum = 0;
+    while (1) {
+        len = grub_read (buf + filled, allocated - filled);
+        if (! len) {
+            if (!errnum)
+                break;
+            grub_close ();
+            return -1;
+        }
+        filled += len;
+        if (filled < allocated)
+            break;
+        allocated *= 2;
+        buf = realloc(buf, allocated);
+    }
+    grub_close ();
+    *ptr = buf;
+    *size = filled;
+    return 0;
+}
+
+void *kernel_image, *module_image;
+long  kernel_size, module_size;
+char *kernel_arg, *module_arg;
+
+kernel_t
+load_image (char *kernel, char *arg, kernel_t suggested_type,
+            unsigned long load_flags)
+{
+    arg = skip_to(0, arg);
+    if (kernel_image)
+        free(kernel_image);
+    kernel_image = NULL;
+    if (load_file (kernel, &kernel_image, &kernel_size))
+        return KERNEL_TYPE_NONE;
+    if (kernel_arg)
+        free(kernel_arg);
+    kernel_arg = strdup(arg);
+    return KERNEL_TYPE_PV;
+}
+
+int
+load_initrd (char *initrd)
+{
+    if (module_image)
+        free(module_image);
+    module_image = NULL;
+    load_file (initrd, &module_image, &module_size);
+    return ! errnum;
+}
+
+int
+load_module (char *module, char *arg)
+{
+    if (module_image)
+        free(module_image);
+    module_image = NULL;
+    load_file (module, &module_image, &module_size);
+    if (module_arg)
+        free(module_arg);
+    module_arg = strdup(arg);
+    return ! errnum;
+}
+
+void
+pv_boot (void)
+{
+    kexec(kernel_image, kernel_size, module_image, module_size, kernel_arg);
+}
+
+/*
+ * Network
+ */
+
+struct netfront_dev *net_dev;
+
+int
+minios_probe (struct nic *nic)
+{
+    char *ip;
+
+    if (net_dev)
+        return 1;
+
+    /* Clear the ARP table.  */
+    grub_memset ((char *) arptable, 0,
+                 MAX_ARP * sizeof (struct arptable_t));
+
+    net_dev = init_netfront(NULL, (void*) -1, nic->node_addr, &ip);
+    if (!net_dev)
+        return 0;
+
+    return 1;
+}
+
+/* reset adapter */
+static void minios_reset(struct nic *nic)
+{
+    /* TODO? */
+}
+
+static void minios_disable(struct nic *nic)
+{
+}
+
+/* Wait for a frame */
+static int minios_poll(struct nic *nic)
+{
+    return !! (nic->packetlen = netfront_receive(net_dev, (void*) nic->packet, 
ETH_FRAME_LEN));
+}
+
+/* Transmit a frame */
+struct frame {
+        uint8_t dest[ETH_ALEN];
+        uint8_t src[ETH_ALEN];
+        uint16_t type;
+        unsigned char data[];
+};
+static void minios_transmit (struct nic *nic, const char *d, unsigned int t,
+                             unsigned int s, const char *p)
+{
+    struct frame *frame = alloca(sizeof(frame) + s);
+
+    memcpy(frame->dest, d, ETH_ALEN);
+    memcpy(frame->src, nic->node_addr, ETH_ALEN);
+    frame->type = htons(t);
+    memcpy(frame->data, p, s);
+
+    netfront_xmit(net_dev, (void*) frame, sizeof(*frame) + s);
+}
+
+static char packet[ETH_FRAME_LEN];
+
+struct nic nic = {
+    .reset = minios_reset,
+    .poll = minios_poll,
+    .transmit = minios_transmit,
+    .disable = minios_disable,
+    .flags = 0,
+    .rom_info = NULL,
+    .node_addr = arptable[ARP_CLIENT].node,
+    .packet = packet,
+    .packetlen = 0,
+    .priv_data = NULL,
+};
+
+int
+eth_probe (void)
+{
+    return minios_probe(&nic);
+}
+
+int
+eth_poll (void)
+{
+    return minios_poll (&nic);
+}
+
+void
+eth_disable (void)
+{
+    minios_disable (&nic);
+}
+
+void
+eth_transmit (const char *d, unsigned int t,
+              unsigned int s, const void *p)
+{
+    minios_transmit (&nic, d, t, s, p);
+    if (t == IP)
+        twiddle();
+}
+
+/*
+ * Console
+ */
+void
+serial_hw_put (int _c)
+{
+  char c = _c;
+  console_print(&c, 1);
+}
+
+int
+serial_hw_fetch (void)
+{
+    char key;
+
+    if (!xencons_ring_avail())
+        return -1;
+
+    read(STDIN_FILENO, &key, 1);
+    switch (key) {
+    case 0x7f: key = '\b'; break;
+    }
+    return key;
+}
+
+/*
+ * PVFB
+ */
+struct kbdfront_dev *kbd_dev;
+struct fbfront_dev *fb_dev;
+static union xenkbd_in_event ev;
+static int has_ev;
+int console_checkkey (void)
+{
+    if (has_ev)
+        return 1;
+    has_ev = kbdfront_receive(kbd_dev, &ev, 1);
+    return has_ev;
+}
+
+/* static QWERTY layout, that's what most PC BIOSes do anyway */
+static char linux2ascii[] = {
+    [ 1 ] = 27,
+    [ 2 ] = '1',
+    [ 3 ] = '2',
+    [ 4 ] = '3',
+    [ 5 ] = '4',
+    [ 6 ] = '5',
+    [ 7 ] = '6',
+    [ 8 ] = '7',
+    [ 9 ] = '8',
+    [ 10 ] = '9',
+    [ 11 ] = '0',
+    [ 12 ] = '-',
+    [ 13 ] = '=',
+    [ 14 ] = '\b',
+    [ 15 ] = '\t',
+    [ 16 ] = 'q',
+    [ 17 ] = 'w',
+    [ 18 ] = 'e',
+    [ 19 ] = 'r',
+    [ 20 ] = 't',
+    [ 21 ] = 'y',
+    [ 22 ] = 'u',
+    [ 23 ] = 'i',
+    [ 24 ] = 'o',
+    [ 25 ] = 'p',
+    [ 26 ] = '[',
+    [ 27 ] = ']',
+    [ 28 ] = '\n',
+
+    [ 30 ] = 'a',
+    [ 31 ] = 's',
+    [ 32 ] = 'd',
+    [ 33 ] = 'f',
+    [ 34 ] = 'g',
+    [ 35 ] = 'h',
+    [ 36 ] = 'j',
+    [ 37 ] = 'k',
+    [ 38 ] = 'l',
+    [ 39 ] = ';',
+    [ 40 ] = '\'',
+    [ 41 ] = '`',
+
+    [ 43 ] = '\\',
+    [ 44 ] = 'z',
+    [ 45 ] = 'x',
+    [ 46 ] = 'c',
+    [ 47 ] = 'v',
+    [ 48 ] = 'b',
+    [ 49 ] = 'n',
+    [ 50 ] = 'm',
+    [ 51 ] = ',',
+    [ 52 ] = '.',
+    [ 53 ] = '/',
+
+    [ 55 ] = '*',
+    [ 57 ] = ' ',
+
+    [ 71 ] = '7',
+    [ 72 ] = '8',
+    [ 73 ] = '9',
+    [ 74 ] = '-',
+    [ 75 ] = '4',
+    [ 76 ] = '5',
+    [ 77 ] = '6',
+    [ 78 ] = '+',
+    [ 79 ] = '1',
+    [ 80 ] = '2',
+    [ 81 ] = '3',
+    [ 82 ] = '0',
+    [ 83 ] = '.',
+
+    [ 86 ] = '<',
+
+    [ 96 ] = '\n',
+
+    [ 98 ] = '/',
+
+    [ 102 ] = 1,  /* home */
+    [ 103 ] = 16, /* up */
+    [ 104 ] = 7,  /* page up */
+    [ 105 ] = 2,  /* left */
+    [ 106 ] = 6,  /* right */
+    [ 107 ] = 5,  /* end */
+    [ 108 ] = 14, /* down */
+    [ 109 ] = 3,  /* page down */
+
+    [ 111 ] = 4,  /* delete */
+};
+
+static char linux2ascii_shifted[] = {
+    [ 1 ] = 27,
+    [ 2 ] = '!',
+    [ 3 ] = '@',
+    [ 4 ] = '#',
+    [ 5 ] = '$',
+    [ 6 ] = '%',
+    [ 7 ] = '^',
+    [ 8 ] = '&',
+    [ 9 ] = '*',
+    [ 10 ] = '(',
+    [ 11 ] = ')',
+    [ 12 ] = '_',
+    [ 13 ] = '+',
+    [ 14 ] = '\b',
+    [ 15 ] = '\t',
+    [ 16 ] = 'Q',
+    [ 17 ] = 'W',
+    [ 18 ] = 'E',
+    [ 19 ] = 'R',
+    [ 20 ] = 'T',
+    [ 21 ] = 'Y',
+    [ 22 ] = 'U',
+    [ 23 ] = 'I',
+    [ 24 ] = 'O',
+    [ 25 ] = 'P',
+    [ 26 ] = '{',
+    [ 27 ] = '}',
+    [ 28 ] = '\n',
+
+    [ 30 ] = 'A',
+    [ 31 ] = 'S',
+    [ 32 ] = 'D',
+    [ 33 ] = 'F',
+    [ 34 ] = 'G',
+    [ 35 ] = 'H',
+    [ 36 ] = 'J',
+    [ 37 ] = 'K',
+    [ 38 ] = 'L',
+    [ 39 ] = ':',
+    [ 40 ] = '"',
+    [ 41 ] = '~',
+
+    [ 43 ] = '|',
+    [ 44 ] = 'Z',
+    [ 45 ] = 'X',
+    [ 46 ] = 'C',
+    [ 47 ] = 'V',
+    [ 48 ] = 'B',
+    [ 49 ] = 'N',
+    [ 50 ] = 'M',
+    [ 51 ] = '<',
+    [ 52 ] = '>',
+    [ 53 ] = '?',
+
+    [ 55 ] = '*',
+    [ 57 ] = ' ',
+
+    [ 71 ] = '7',
+    [ 72 ] = '8',
+    [ 73 ] = '9',
+    [ 74 ] = '-',
+    [ 75 ] = '4',
+    [ 76 ] = '5',
+    [ 77 ] = '6',
+    [ 78 ] = '+',
+    [ 79 ] = '1',
+    [ 80 ] = '2',
+    [ 81 ] = '3',
+    [ 82 ] = '0',
+    [ 83 ] = '.',
+
+    [ 86 ] = '>',
+
+    [ 96 ] = '\n',
+
+    [ 98 ] = '/',
+
+    [ 102 ] = 1,  /* home */
+    [ 103 ] = 16, /* up */
+    [ 104 ] = 7,  /* page up */
+    [ 105 ] = 2,  /* left */
+    [ 106 ] = 6,  /* right */
+    [ 107 ] = 5,  /* end */
+    [ 108 ] = 14, /* down */
+    [ 109 ] = 3,  /* page down */
+
+    [ 111 ] = 4,  /* delete */
+};
+
+int console_getkey (void)
+{
+    static int shift, control, alt, caps_lock;
+
+    if (!has_ev)
+        has_ev = kbdfront_receive(kbd_dev, &ev, 1);
+    if (!has_ev)
+        return 0;
+
+    has_ev = 0;
+    if (ev.type != XENKBD_TYPE_KEY)
+        return 0;
+
+    if (ev.key.keycode == 42 || ev.key.keycode == 54) {
+        caps_lock = 0;
+        shift = ev.key.pressed;
+        return 0;
+    }
+    if (ev.key.keycode == 58) {
+        caps_lock ^= 1;
+        return 0;
+    }
+    if (ev.key.keycode == 29 || ev.key.keycode == 97) {
+        control = ev.key.pressed;
+        return 0;
+    }
+    if (ev.key.keycode == 56) {
+        alt = ev.key.pressed;
+        return 0;
+    }
+
+    if (!ev.key.pressed)
+        return 0;
+
+    if (ev.key.keycode < sizeof(linux2ascii) / sizeof(*linux2ascii)) {
+        char val;
+        if (shift || caps_lock)
+            val = linux2ascii_shifted[ev.key.keycode];
+        else
+            val = linux2ascii[ev.key.keycode];
+        if (control)
+            val &= ~0x60;
+        return val;
+    }
+
+    return 0;
+}
+
+static void kbd_thread(void *p)
+{
+    struct semaphore *sem = p;
+
+    kbd_dev = init_kbdfront(NULL, 1);
+    up(sem);
+}
+
+struct fbfront_dev *fb_open(void *fb, int width, int height, int depth)
+{
+    unsigned long *mfns;
+    int linesize = width * (depth / 8);
+    int memsize = linesize * height;
+    int numpages = (memsize + PAGE_SIZE - 1) / PAGE_SIZE;
+    DECLARE_MUTEX_LOCKED(sem);
+    int i;
+
+    create_thread("kbdfront", kbd_thread, &sem);
+
+    mfns = malloc(numpages * sizeof(*mfns));
+    for (i = 0; i < numpages; i++) {
+        memset(fb + i * PAGE_SIZE, 0, PAGE_SIZE);
+        mfns[i] = virtual_to_mfn(fb + i * PAGE_SIZE);
+    }
+    fb_dev = init_fbfront(NULL, mfns, width, height, depth, linesize, 
numpages);
+    free(mfns);
+
+    if (!fb_dev)
+        return NULL;
+
+    down(&sem);
+    if (!kbd_dev)
+        return NULL;
+
+    return fb_dev;
+}
+
+void kbd_close(void *foo)
+{
+    shutdown_kbdfront(kbd_dev);
+    kbd_dev = NULL;
+}
+
+void fb_close(void)
+{
+    create_thread("kbdfront close", kbd_close, NULL);
+    shutdown_fbfront(fb_dev);
+    fb_dev = NULL;
+}
+
+/*
+ * Misc
+ */
+
+int getrtsecs (void)
+{
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return tv.tv_sec;
+}
+
+int currticks (void)
+{
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return ((tv.tv_sec * 1000000ULL + tv.tv_usec) * TICKS_PER_SEC) / 1000000;
+}
+
+void __attribute__ ((noreturn)) grub_reboot (void)
+{
+    for ( ;; )
+    {
+        struct sched_shutdown sched_shutdown = { .reason = SHUTDOWN_reboot };
+        HYPERVISOR_sched_op(SCHEDOP_shutdown, &sched_shutdown);
+    }
+}
+
+#define SCRATCH_MEMSIZE (4 * 1024 * 1024)
+
+/* Note: not allocating it dynamically permits to make sure it lays below 4G
+ * for grub's 32bit pointers to work */
+char grub_scratch_mem[SCRATCH_MEMSIZE] __attribute__((aligned(PAGE_SIZE)));
+
+int main(int argc, char *argv[])
+{
+    if (argc > 1) {
+        strncpy(config_file, argv[1], sizeof(config_file) - 1);
+        config_file[sizeof(config_file) - 1] = 0;
+        if (!strncmp(config_file, "(nd)", 4))
+            preset_menu = "dhcp";
+    } else
+        preset_menu = "dhcp --with-configfile";
+
+    mbi.drives_addr = BOOTSEC_LOCATION + (60 * 1024);
+    mbi.drives_length = 0;
+
+    mbi.boot_loader_name = (unsigned long) "GNU GRUB " VERSION;
+    mbi.mem_lower = (start_info.nr_pages * PAGE_SIZE) / 1024;
+    mbi.mem_upper = 0;
+    saved_drive = boot_drive;
+    saved_partition = install_partition;
+
+    init_disk();
+
+    /* Try to make sure the client part got launched */
+    sleep(1);
+    cmain();
+    printk("cmain returned!\n");
+}
diff -r 8a0656950b1c -r c8d9ade45781 stubdom/grub/mini-os.h
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/stubdom/grub/mini-os.h    Wed Jun 18 09:36:47 2008 +0100
@@ -0,0 +1,5 @@
+extern int blk_nb;
+extern struct blkfront_dev **blk_dev;
+extern struct netfront_dev *net_dev;
+extern struct kbdfront_dev *kbd_dev;
+extern struct fbfront_dev *fb_dev;
diff -r 8a0656950b1c -r c8d9ade45781 stubdom/grub/osdep.h
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/stubdom/grub/osdep.h      Wed Jun 18 09:36:47 2008 +0100
@@ -0,0 +1,30 @@
+#ifndef __OSDEP_H__
+#define __OSDEP_H__
+
+#include <byteswap.h>
+#define swap32(x) bswap_32(x)
+#define swap16(x) bswap_16(x)
+
+#include <machine/endian.h>
+#if BYTE_ORDER == BIG_ENDIAN
+#define htons(x) (x)
+#define ntohs(x) (x)
+#define htonl(x) (x)
+#define ntohl(x) (x)
+#else
+#define htons(x) swap16(x)
+#define ntohs(x) swap16(x)
+#define htonl(x) swap32(x)
+#define ntohl(x) swap32(x)
+#endif
+
+typedef unsigned long Address;
+
+/* ANSI prototyping macro */
+#ifdef  __STDC__
+#define P(x)   x
+#else
+#define P(x)   ()
+#endif
+
+#endif
diff -r 8a0656950b1c -r c8d9ade45781 tools/libxc/xc_dom.h
--- a/tools/libxc/xc_dom.h      Wed Jun 18 09:35:06 2008 +0100
+++ b/tools/libxc/xc_dom.h      Wed Jun 18 09:36:47 2008 +0100
@@ -107,6 +107,8 @@ struct xc_dom_image {
 
     /* kernel loader */
     struct xc_dom_arch *arch_hooks;
+    /* allocate up to virt_alloc_end */
+    int (*allocate) (struct xc_dom_image * dom, xen_vaddr_t up_to);
 };
 
 /* --- pluggable kernel loader ------------------------------------- */
@@ -167,6 +169,7 @@ int xc_dom_ramdisk_mem(struct xc_dom_ima
                        size_t memsize);
 
 int xc_dom_parse_image(struct xc_dom_image *dom);
+struct xc_dom_arch *xc_dom_find_arch_hooks(char *guest_type);
 int xc_dom_build_image(struct xc_dom_image *dom);
 int xc_dom_update_guest_p2m(struct xc_dom_image *dom);
 
diff -r 8a0656950b1c -r c8d9ade45781 tools/libxc/xc_dom_core.c
--- a/tools/libxc/xc_dom_core.c Wed Jun 18 09:35:06 2008 +0100
+++ b/tools/libxc/xc_dom_core.c Wed Jun 18 09:36:47 2008 +0100
@@ -409,6 +409,8 @@ int xc_dom_alloc_segment(struct xc_dom_i
     seg->vend = start + pages * page_size;
     seg->pfn = (seg->vstart - dom->parms.virt_base) / page_size;
     dom->virt_alloc_end = seg->vend;
+    if (dom->allocate)
+        dom->allocate(dom, dom->virt_alloc_end);
 
     xc_dom_printf("%-20s:   %-12s : 0x%" PRIx64 " -> 0x%" PRIx64
                   "  (pfn 0x%" PRIpfn " + 0x%" PRIpfn " pages)\n",
@@ -431,6 +433,8 @@ int xc_dom_alloc_page(struct xc_dom_imag
 
     start = dom->virt_alloc_end;
     dom->virt_alloc_end += page_size;
+    if (dom->allocate)
+        dom->allocate(dom, dom->virt_alloc_end);
     pfn = (start - dom->parms.virt_base) / page_size;
 
     xc_dom_printf("%-20s:   %-12s : 0x%" PRIx64 " (pfn 0x%" PRIpfn ")\n",
@@ -506,7 +510,7 @@ void xc_dom_register_arch_hooks(struct x
     first_hook = hooks;
 }
 
-static struct xc_dom_arch *xc_dom_find_arch_hooks(char *guest_type)
+struct xc_dom_arch *xc_dom_find_arch_hooks(char *guest_type)
 {
     struct xc_dom_arch *hooks = first_hook;
 

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

<Prev in Thread] Current Thread [Next in Thread>
  • [Xen-changelog] [xen-unstable] Add PV-GRUB, Xen patchbot-unstable <=