[fedora-virt-maint] rpms/xen/devel xen-341-add-bzip2-lzma-pv-bootloader-support-v2.patch, NONE, 1.1 xen-fix-videoram-option.patch, NONE, 1.1 xen.spec, 1.246, 1.247 xen-bzip2-xz-1.patch, 1.1, NONE xen-bzip2-xz-2.patch, 1.1, NONE xen-bzip2-xz-3.patch, 1.1, NONE xen-stubdomain-bridging.patch, 1.1, NONE

Gerd Hoffmann kraxel at fedoraproject.org
Wed Sep 2 11:36:00 UTC 2009


Author: kraxel

Update of /cvs/pkgs/rpms/xen/devel
In directory cvs1.fedora.phx.redhat.com:/tmp/cvs-serv16108

Modified Files:
	xen.spec 
Added Files:
	xen-341-add-bzip2-lzma-pv-bootloader-support-v2.patch 
	xen-fix-videoram-option.patch 
Removed Files:
	xen-bzip2-xz-1.patch xen-bzip2-xz-2.patch xen-bzip2-xz-3.patch 
	xen-stubdomain-bridging.patch 
Log Message:
more backports

xen-341-add-bzip2-lzma-pv-bootloader-support-v2.patch:
 Makefile               |   19 ++
 xc_dom_bzimageloader.c |  386 +++++++++++++++++++++++++++++++++++++++++--------
 2 files changed, 348 insertions(+), 57 deletions(-)

--- NEW FILE xen-341-add-bzip2-lzma-pv-bootloader-support-v2.patch ---
--- xen-3.4-testing.hg/tools/libxc/Makefile	2009-09-01 17:19:44.000000000 +0300
+++ xen-unstable.hg/tools/libxc/Makefile	2009-09-01 17:12:45.000000000 +0300
@@ -149,6 +151,25 @@
 libxenguest.so.$(MAJOR): libxenguest.so.$(MAJOR).$(MINOR)
 	ln -sf $< $@
 
+ifeq ($(CONFIG_MiniOS),y)
+zlib-options =
+else
+zlib-options = $(shell					\
+	(. ../check/funcs.sh;				\
+	 if has_header bzlib.h; then			\
+           echo "-DHAVE_BZLIB";				\
+	   echo "-lbz2";				\
+	 fi;						\
+	 if has_header lzma.h; then			\
+	   echo "-DHAVE_LZMA";				\
+	   echo "-llzma";				\
+	 fi) | grep $(1))
+endif
+
+xc_dom_bzimageloader.o: CFLAGS += $(call zlib-options,D)
+xc_dom_bzimageloader.opic: CFLAGS += $(call zlib-options,D)
+
+libxenguest.so.$(MAJOR).$(MINOR): LDFLAGS += $(call zlib-options,l)
 libxenguest.so.$(MAJOR).$(MINOR): $(GUEST_PIC_OBJS) libxenctrl.so
 	$(CC) $(CFLAGS) $(LDFLAGS) -Wl,$(SONAME_LDFLAG) -Wl,libxenguest.so.$(MAJOR) $(SHLIB_CFLAGS) -o $@ $(GUEST_PIC_OBJS) -lz -lxenctrl $(PTHREAD_LIBS)
 
--- xen-3.4-testing.hg/tools/libxc/xc_dom_bzimageloader.c	2009-09-01 17:19:44.000000000 +0300
+++ xen-unstable.hg/tools/libxc/xc_dom_bzimageloader.c	2009-09-01 17:12:45.000000000 +0300
@@ -11,6 +11,7 @@
  * written 2006 by Gerd Hoffmann <kraxel at suse.de>.
  * written 2007 by Jeremy Fitzhardinge <jeremy at xensource.com>
  * written 2008 by Ian Campbell <ijc at hellion.org.uk>
+ * written 2009 by Chris Lalancette <clalance at redhat.com>
  *
  */
 #include <stdio.h>
@@ -20,43 +21,289 @@
 #include "xg_private.h"
 #include "xc_dom.h"
 
+#if defined(HAVE_BZLIB)
+
+#include <bzlib.h>
+
+static int xc_try_bzip2_decode(
+    struct xc_dom_image *dom, void **blob, size_t *size)
+{
+    bz_stream stream;
+    int ret;
+    char *out_buf;
+    int retval = -1;
+    int outsize;
+    uint64_t total;
+
+    stream.bzalloc = NULL;
+    stream.bzfree = NULL;
+    stream.opaque = NULL;
+
+    ret = BZ2_bzDecompressInit(&stream, 0, 0);
+    if ( ret != BZ_OK )
+    {
+        xc_dom_printf("Error initting bz2 stream\n");
+        return -1;
+    }
+
+    /* sigh.  We don't know up-front how much memory we are going to need
+     * for the output buffer.  Allocate the output buffer to be equal
+     * the input buffer to start, and we'll realloc as needed.
+     */
+    outsize = dom->kernel_size;
+    out_buf = malloc(outsize);
+    if ( out_buf == NULL )
+    {
+        xc_dom_printf("Failed to alloc memory\n");
+        goto bzip2_cleanup;
+    }
+
+    stream.next_in = dom->kernel_blob;
+    stream.avail_in = dom->kernel_size;
+
+    stream.next_out = out_buf;
+    stream.avail_out = dom->kernel_size;
+
+    for ( ; ; )
+    {
+        ret = BZ2_bzDecompress(&stream);
+        if ( (stream.avail_out == 0) || (ret != BZ_OK) )
+        {
+            out_buf = realloc(out_buf, outsize * 2);
+            if ( out_buf == NULL )
+            {
+                xc_dom_printf("Failed to realloc memory\n");
+                break;
+            }
+
+            stream.next_out = out_buf + outsize;
+            stream.avail_out = (outsize * 2) - outsize;
+            outsize *= 2;
+        }
+
+        if ( ret != BZ_OK )
+        {
+            if ( ret == BZ_STREAM_END )
+            {
+                xc_dom_printf("Saw data stream end\n");
+                retval = 0;
+                break;
+            }
+            xc_dom_printf("BZIP error\n");
+        }
+    }
+
+    total = (stream.total_out_hi32 << 31) | stream.total_out_lo32;
+
+    xc_dom_printf("%s: BZIP2 decompress OK, 0x%zx -> 0x%lx\n",
+                  __FUNCTION__, *size, (long unsigned int) total);
+
+    *blob = out_buf;
+    *size = total;
+
+ bzip2_cleanup:
+    BZ2_bzDecompressEnd(&stream);
+
+    return retval;
+}
+
+#else /* !defined(HAVE_BZLIB) */
+
+static int xc_try_bzip2_decode(
+    struct xc_dom_image *dom, void **blob, size_t *size)
+{
+    xc_dom_printf("%s: BZIP2 decompress support unavailable\n",
+                  __FUNCTION__);
+    return -1;
+}
+
+#endif
+
+#if defined(HAVE_LZMA)
+
+#include <lzma.h>
+
+static uint64_t physmem(void)
+{
+    uint64_t ret = 0;
+    const long pagesize = sysconf(_SC_PAGESIZE);
+    const long pages = sysconf(_SC_PHYS_PAGES);
+
+    if ( (pagesize != -1) || (pages != -1) )
+    {
+        /*
+         * According to docs, pagesize * pages can overflow.
+         * Simple case is 32-bit box with 4 GiB or more RAM,
+         * which may report exactly 4 GiB of RAM, and "long"
+         * being 32-bit will overflow. Casting to uint64_t
+         * hopefully avoids overflows in the near future.
+         */
+        ret = (uint64_t)(pagesize) * (uint64_t)(pages);
+    }
+
+    return ret;
+}
+
+static int xc_try_lzma_decode(
+    struct xc_dom_image *dom, void **blob, size_t *size)
+{
+    lzma_stream stream = LZMA_STREAM_INIT;
+    lzma_ret ret;
+    lzma_action action = LZMA_RUN;
+    unsigned char *out_buf;
+    int retval = -1;
+    int outsize;
+    const char *msg;
+
+    ret = lzma_alone_decoder(&stream, physmem() / 3);
+    if ( ret != LZMA_OK )
+    {
+        xc_dom_printf("Failed to init lzma stream decoder\n");
+        return -1;
+    }
+
+    /* sigh.  We don't know up-front how much memory we are going to need
+     * for the output buffer.  Allocate the output buffer to be equal
+     * the input buffer to start, and we'll realloc as needed.
+     */
+    outsize = dom->kernel_size;
+    out_buf = malloc(outsize);
+    if ( out_buf == NULL )
+    {
+        xc_dom_printf("Failed to alloc memory\n");
+        goto lzma_cleanup;
+    }
+
+    stream.next_in = dom->kernel_blob;
+    stream.avail_in = dom->kernel_size;
+
+    stream.next_out = out_buf;
+    stream.avail_out = dom->kernel_size;
+
+    for ( ; ; )
+    {
+        ret = lzma_code(&stream, action);
+        if ( (stream.avail_out == 0) || (ret != LZMA_OK) )
+        {
+            out_buf = realloc(out_buf, outsize * 2);
+            if ( out_buf == NULL )
+            {
+                xc_dom_printf("Failed to realloc memory\n");
+                break;
+            }
+
+            stream.next_out = out_buf + outsize;
+            stream.avail_out = (outsize * 2) - outsize;
+            outsize *= 2;
+        }
+
+        if ( ret != LZMA_OK )
+        {
+            if ( ret == LZMA_STREAM_END )
+            {
+                xc_dom_printf("Saw data stream end\n");
+                retval = 0;
+                break;
+            }
+
+            switch ( ret )
+            {
+            case LZMA_MEM_ERROR:
+                msg = strerror(ENOMEM);
+                break;
+
+            case LZMA_MEMLIMIT_ERROR:
+                msg = "Memory usage limit reached";
+                break;
+
+            case LZMA_FORMAT_ERROR:
+                msg = "File format not recognized";
+                break;
+
+            case LZMA_OPTIONS_ERROR:
+                // FIXME: Better message?
+                msg = "Unsupported compression options";
+                break;
+
+            case LZMA_DATA_ERROR:
+                msg = "File is corrupt";
+                break;
+
+            case LZMA_BUF_ERROR:
+                msg = "Unexpected end of input";
+                break;
+
+            default:
+                msg = "Internal program error (bug)";
+                break;
+            }
+            xc_dom_printf("%s: LZMA decompression error %s\n",
+                          __FUNCTION__, msg);
+            break;
+        }
+    }
+
+    xc_dom_printf("%s: LZMA decompress OK, 0x%zx -> 0x%zx\n",
+                  __FUNCTION__, *size, (size_t)stream.total_out);
+
+    *blob = out_buf;
+    *size = stream.total_out;
+
+ lzma_cleanup:
+    lzma_end(&stream);
+
+    return retval;
+}
+
+#else /* !defined(HAVE_LZMA) */
+
+static int xc_try_lzma_decode(
+    struct xc_dom_image *dom, void **blob, size_t *size)
+{
+    xc_dom_printf("%s: LZMA decompress support unavailable\n",
+                  __FUNCTION__);
+    return -1;
+}
+
+#endif
+
 struct setup_header {
-	uint8_t		_pad0[0x1f1];		/* skip uninteresting stuff */
-	uint8_t		setup_sects;
-	uint16_t	root_flags;
-	uint32_t	syssize;
-	uint16_t	ram_size;
-	uint16_t	vid_mode;
-	uint16_t	root_dev;
-	uint16_t	boot_flag;
-	uint16_t	jump;
-	uint32_t	header;
-#define HDR_MAGIC		"HdrS"
-#define HDR_MAGIC_SZ	4
-	uint16_t	version;
-#define VERSION(h,l)	(((h)<<8) | (l))
-	uint32_t	realmode_swtch;
-	uint16_t	start_sys;
-	uint16_t	kernel_version;
-	uint8_t		type_of_loader;
-	uint8_t		loadflags;
-	uint16_t	setup_move_size;
-	uint32_t	code32_start;
-	uint32_t	ramdisk_image;
-	uint32_t	ramdisk_size;
-	uint32_t	bootsect_kludge;
-	uint16_t	heap_end_ptr;
-	uint16_t	_pad1;
-	uint32_t	cmd_line_ptr;
-	uint32_t	initrd_addr_max;
-	uint32_t	kernel_alignment;
-	uint8_t		relocatable_kernel;
-	uint8_t		_pad2[3];
-	uint32_t	cmdline_size;
-	uint32_t	hardware_subarch;
-	uint64_t	hardware_subarch_data;
-	uint32_t	payload_offset;
-	uint32_t	payload_length;
+    uint8_t  _pad0[0x1f1];  /* skip uninteresting stuff */
+    uint8_t  setup_sects;
+    uint16_t root_flags;
+    uint32_t syssize;
+    uint16_t ram_size;
+    uint16_t vid_mode;
+    uint16_t root_dev;
+    uint16_t boot_flag;
+    uint16_t jump;
+    uint32_t header;
+#define HDR_MAGIC  "HdrS"
+#define HDR_MAGIC_SZ 4
+    uint16_t version;
+#define VERSION(h,l) (((h)<<8) | (l))
+    uint32_t realmode_swtch;
+    uint16_t start_sys;
+    uint16_t kernel_version;
+    uint8_t  type_of_loader;
+    uint8_t  loadflags;
+    uint16_t setup_move_size;
+    uint32_t code32_start;
+    uint32_t ramdisk_image;
+    uint32_t ramdisk_size;
+    uint32_t bootsect_kludge;
+    uint16_t heap_end_ptr;
+    uint16_t _pad1;
+    uint32_t cmd_line_ptr;
+    uint32_t initrd_addr_max;
+    uint32_t kernel_alignment;
+    uint8_t  relocatable_kernel;
+    uint8_t  _pad2[3];
+    uint32_t cmdline_size;
+    uint32_t hardware_subarch;
+    uint64_t hardware_subarch_data;
+    uint32_t payload_offset;
+    uint32_t payload_length;
 } __attribute__((packed));
 
 extern struct xc_dom_loader elf_loader;
@@ -70,22 +317,22 @@
     return off;
 }
 
-static int check_bzimage_kernel(struct xc_dom_image *dom, int verbose)
+static int xc_dom_probe_bzimage_kernel(struct xc_dom_image *dom)
 {
     struct setup_header *hdr;
+    int ret;
 
     if ( dom->kernel_blob == NULL )
     {
-        if ( verbose )
-            xc_dom_panic(XC_INTERNAL_ERROR, "%s: no kernel image loaded\n",
-                         __FUNCTION__);
+        xc_dom_panic(XC_INTERNAL_ERROR, "%s: no kernel image loaded\n",
+                     __FUNCTION__);
         return -EINVAL;
     }
+
     if ( dom->kernel_size < sizeof(struct setup_header) )
     {
-        if ( verbose )
-            xc_dom_panic(XC_INTERNAL_ERROR, "%s: kernel image too small\n",
-                         __FUNCTION__);
+        xc_dom_panic(XC_INTERNAL_ERROR, "%s: kernel image too small\n",
+                     __FUNCTION__);
         return -EINVAL;
     }
 
@@ -93,39 +340,64 @@
 
     if ( memcmp(&hdr->header, HDR_MAGIC, HDR_MAGIC_SZ) != 0 )
     {
-        if ( verbose )
-            xc_dom_panic(XC_INVALID_KERNEL, "%s: kernel is not a bzImage\n",
-                         __FUNCTION__);
+        xc_dom_panic(XC_INVALID_KERNEL, "%s: kernel is not a bzImage\n",
+                     __FUNCTION__);
         return -EINVAL;
     }
 
     if ( hdr->version < VERSION(2,8) )
     {
-        if ( verbose )
-            xc_dom_panic(XC_INVALID_KERNEL, "%s: boot protocol too old (%04x)\n",
-                         __FUNCTION__, hdr->version);
+        xc_dom_panic(XC_INVALID_KERNEL, "%s: boot protocol too old (%04x)\n",
+                     __FUNCTION__, hdr->version);
         return -EINVAL;
     }
 
     dom->kernel_blob = dom->kernel_blob + payload_offset(hdr);
     dom->kernel_size = hdr->payload_length;
 
-    if ( xc_dom_try_gunzip(dom, &dom->kernel_blob, &dom->kernel_size) == -1 )
+    if ( memcmp(dom->kernel_blob, "\037\213", 2) == 0 )
+    {
+        ret = xc_dom_try_gunzip(dom, &dom->kernel_blob, &dom->kernel_size);
+        if ( ret == -1 )
+        {
+            xc_dom_panic(XC_INVALID_KERNEL,
+                         "%s: unable to gzip decompress kernel\n",
+                         __FUNCTION__);
+            return -EINVAL;
+        }
+    }
+    else if ( memcmp(dom->kernel_blob, "\102\132\150", 3) == 0 )
     {
-        if ( verbose )
-            xc_dom_panic(XC_INVALID_KERNEL, "%s: unable to decompress kernel\n",
+        ret = xc_try_bzip2_decode(dom, &dom->kernel_blob, &dom->kernel_size);
+        if ( ret < 0 )
+        {
+            xc_dom_panic(XC_INVALID_KERNEL,
+                         "%s unable to BZIP2 decompress kernel",
                          __FUNCTION__);
+            return -EINVAL;
+        }
+    }
+    else if ( memcmp(dom->kernel_blob, "\135\000", 2) == 0 )
+    {
+        ret = xc_try_lzma_decode(dom, &dom->kernel_blob, &dom->kernel_size);
+        if ( ret < 0 )
+        {
+            xc_dom_panic(XC_INVALID_KERNEL,
+                         "%s unable to LZMA decompress kernel\n",
+                         __FUNCTION__);
+            return -EINVAL;
+        }
+    }
+    else
+    {
+        xc_dom_panic(XC_INVALID_KERNEL, "%s: unknown compression format\n",
+                     __FUNCTION__);
         return -EINVAL;
     }
 
     return elf_loader.probe(dom);
 }
 
-static int xc_dom_probe_bzimage_kernel(struct xc_dom_image *dom)
-{
-    return check_bzimage_kernel(dom, 0);
-}
-
 static int xc_dom_parse_bzimage_kernel(struct xc_dom_image *dom)
 {
     return elf_loader.parser(dom);

xen-fix-videoram-option.patch:
 vl.c |   15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

--- NEW FILE xen-fix-videoram-option.patch ---
Date: Mon, 10 Aug 2009 13:46:30 +0100
Message-ID: <f4527be0908100546s4e616654iabc67080961e7fa1 at mail.gmail.com>
Subject: Re: [Xen-devel] [ANNOUNCE] Xen 3.3.2 and 3.4.1 released
From: Andrew Lyon <andrew.lyon at gmail.com>

>
> If that's not what you meant, what did you mean ? :-)
>
> Ian.
>

Yes that is the correct pair of patches, I have tested on x86_64 and I
am able to create hvm with increased video ram, I do not see much
value in applying a patch which does not work and then fixing it if
both are not currently in 3.4 so here is a single patch instead,
perhaps KUWAMURA Shin'ya can add a signed-off-by to this too.

Signed-off-by: Andrew Lyon <andrew.lyon at gmail.com>


---

diff --git tools/ioemu-qemu-xen/vl.c tools/ioemu-qemu-xen/vl.c
index b5bb5cb..3506977 100644
--- a/tools/ioemu-qemu-xen/vl.c
+++ b/tools/ioemu-qemu-xen/vl.c
@@ -4801,7 +4801,6 @@ int main(int argc, char **argv, char **envp)
     machine = first_machine;
     cpu_model = NULL;
     initrd_filename = NULL;
-    ram_size = VGA_RAM_SIZE;
 #ifdef CONFIG_GDBSTUB
     use_gdbstub = 0;
     gdbstub_port = DEFAULT_GDBSTUB_PORT;
@@ -5654,13 +5653,6 @@ int main(int argc, char **argv, char **envp)
     }
 #endif

-#if defined (__ia64__)
-    if (ram_size > VGA_IO_START)
-        ram_size += VGA_IO_SIZE; /* skip VGA I/O hole */
-    if (ram_size > MMIO_START)
-        ram_size += 1 * MEM_G; /* skip 3G-4G MMIO, LEGACY_IO_SPACE etc. */
-#endif
-
     /* init the bluetooth world */
     for (i = 0; i < nb_bt_opts; i++)
         if (bt_parse(bt_opts[i]))
@@ -5677,6 +5669,13 @@ int main(int argc, char **argv, char **envp)

     phys_ram_size = (machine->ram_require + vga_ram_size) & ~RAMSIZE_FIXED;

+#if defined (__ia64__)
+    if (ram_size > VGA_IO_START)
+        ram_size += VGA_IO_SIZE; /* skip VGA I/O hole */
+    if (ram_size > MMIO_START)
+        ram_size += 1 * MEM_G; /* skip 3G-4G MMIO, LEGACY_IO_SPACE etc. */
+#endif
+
     if (machine->ram_require & RAMSIZE_FIXED) {
         if (ram_size > 0) {
             if (ram_size < phys_ram_size) {


Andy

_______________________________________________
Xen-devel mailing list
Xen-devel at lists.xensource.com
http://lists.xensource.com/xen-devel



Index: xen.spec
===================================================================
RCS file: /cvs/pkgs/rpms/xen/devel/xen.spec,v
retrieving revision 1.246
retrieving revision 1.247
diff -u -p -r1.246 -r1.247
--- xen.spec	1 Sep 2009 11:46:49 -0000	1.246
+++ xen.spec	2 Sep 2009 11:36:00 -0000	1.247
@@ -6,7 +6,7 @@
 Summary: Xen is a virtual machine monitor
 Name:    xen
 Version: 3.4.1
-Release: 2%{?dist}
+Release: 3%{?dist}
 Group:   Development/Libraries
 License: GPLv2+ and LGPLv2+ and BSD
 URL:     http://xen.org/
@@ -40,11 +40,8 @@ Patch10: xen-no-werror.patch
 # backports
 Patch20: xen-pygrub-fix-timeout-0.patch
 Patch21: xen-qemu-dm-fix-block-memory-leak.patch
-Patch22: xen-stubdomain-bridging.patch
-
-Patch30: xen-bzip2-xz-1.patch
-Patch31: xen-bzip2-xz-2.patch
-Patch32: xen-bzip2-xz-3.patch
+Patch22: xen-fix-videoram-option.patch
+Patch23: xen-341-add-bzip2-lzma-pv-bootloader-support-v2.patch
 
 Patch100: xen-configure-xend.patch
 
@@ -149,11 +146,8 @@ which manage Xen virtual machines.
 
 %patch20 -p1
 %patch21 -p1
-#%patch22 -p1
-
-%patch30 -p1
-%patch31 -p1
-#%patch32 -p1
+%patch22 -p1
+%patch23 -p1
 
 %patch100 -p1
 
@@ -468,6 +462,10 @@ rm -rf %{buildroot}
 %{_libdir}/*.a
 
 %changelog
+* Tue Sep 2 2009 Gerd Hoffmann <kraxel at redhat.com> - 3.4.1-3
+- swap bzip2+xz linux kernel compression support patches.
+- backport one more bugfix (videoram option).
+
 * Tue Sep 1 2009 Gerd Hoffmann <kraxel at redhat.com> - 3.4.1-2
 - backport bzip2+xz linux kernel compression support.
 - backport a few bugfixes.


--- xen-bzip2-xz-1.patch DELETED ---


--- xen-bzip2-xz-2.patch DELETED ---


--- xen-bzip2-xz-3.patch DELETED ---


--- xen-stubdomain-bridging.patch DELETED ---




More information about the Fedora-virt-maint mailing list