diff --git a/Makefile.common b/Makefile.common
index c3f6820..5e21ccd 100644
--- a/Makefile.common
+++ b/Makefile.common
@@ -150,6 +150,7 @@
 	android/utils/stralloc.c \
 	android/utils/system.c \
 	android/utils/tempfile.c \
+	android/utils/uncompress.cpp \
 	android/utils/vector.c \
 	android/utils/win32_cmdline_quote.c \
 
diff --git a/Makefile.qemu-launcher b/Makefile.qemu-launcher
index 7be48d7..9c26567 100644
--- a/Makefile.qemu-launcher
+++ b/Makefile.qemu-launcher
@@ -25,7 +25,8 @@
 LOCAL_SRC_FILES := $(qemu_launcher_SOURCES)
 LOCAL_CFLAGS := $(qemu_launcher_CFLAGS)
 LOCAL_STATIC_LIBRARIES := \
-    emulator-common
+    emulator-common \
+    emulator-zlib
 LOCAL_LDLIBS := $(qemu_launcher_LDLIBS)
 $(call gen-hw-config-defs)
 $(call end-emulator-program)
@@ -34,7 +35,8 @@
 LOCAL_SRC_FILES := $(qemu_launcher_SOURCES)
 LOCAL_CFLAGS := $(qemu_launcher_CFLAGS)
 LOCAL_STATIC_LIBRARIES := \
-    emulator64-common
+    emulator64-common \
+    emulator64-zlib
 LOCAL_LDLIBS := $(qemu_launcher_LDLIBS)
 $(call gen-hw-config-defs)
 $(call end-emulator-program)
diff --git a/android/kernel/kernel_utils.cpp b/android/kernel/kernel_utils.cpp
old mode 100644
new mode 100755
index 50b7094..cbc4f4e
--- a/android/kernel/kernel_utils.cpp
+++ b/android/kernel/kernel_utils.cpp
@@ -9,14 +9,16 @@
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
 
-#include "android/kernel/kernel_utils.h"
-
+#include "android/base/containers/PodVector.h"
+#include "android/base/Limits.h"
 #include "android/base/Log.h"
-#include "android/base/files/ScopedStdioFile.h"
-#include "android/base/String.h"
+#include "android/kernel/kernel_utils.h"
 #include "android/kernel/kernel_utils_testing.h"
+#include "android/utils/file_data.h"
 #include "android/utils/path.h"
+#include "android/utils/uncompress.h"
 
+#include <algorithm>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -30,144 +32,179 @@
 #define KERNEL_ERROR   LOG_IF(ERROR, DEBUG_KERNEL)
 #define KERNEL_PERROR  PLOG_IF(ERROR, DEBUG_KERNEL)
 
-using android::base::String;
-
-namespace {
-
-#ifndef _WIN32
-// Helper class to perform launch a command through popen() and call
-// pclose() on destruction.
-class ScopedPopenFile {
-public:
-    ScopedPopenFile(const char* command) {
-        mFile = ::popen(command, "r");
-    }
-
-    FILE* get() const { return mFile; }
-
-    ~ScopedPopenFile() {
-        if (mFile) {
-            ::pclose(mFile);
-        }
-    }
-
-private:
-    FILE* mFile;
-};
-#endif  // !_WIN32
-
-bool getFileDescription(void* opaque, const char* filePath, String* text) {
-    if (!filePath) {
-        KERNEL_ERROR << "NULL path parameter";
-        return false;
-    }
-
-    if (!path_exists(filePath)) {
-        KERNEL_ERROR << "Kernel file doesn't exist: " << filePath;
-        return false;
-    }
-
-#ifdef _WIN32
-    // TODO(digit): Better/portable detection based on libmagic or something.
-    KERNEL_ERROR << "Can't detect kernel version on Windows!";
-    return false;
-#else
-    // NOTE: Use /usr/bin/file instead of 'file' because the latter can
-    // be broken in certain environments (e.g. some versions of MacPorts).
-    String command("/usr/bin/file ");
-    command += filePath;
-
-    ScopedPopenFile file(command.c_str());
-    if (!file.get()) {
-        KERNEL_PERROR << "Could not launch command: " << command.c_str();
-        return false;
-    }
-
-    String result;
-    const size_t kReserveSize = 256U;
-    result.resize(kReserveSize);
-
-    int ret = ::fread(&result[0], 1, kReserveSize, file.get());
-    if (ret < static_cast<int>(kReserveSize) && ferror(file.get())) {
-        KERNEL_ERROR << "Could not read file command output!?";
-        return false;
-    }
-    result.resize(ret);
-    text->assign(result);
-    return true;
-#endif
-}
-
-android::kernel::GetFileDescriptionFunction* sGetFileDescription =
-        getFileDescription;
-
-void* sGetFileDescriptionOpaque = NULL;
-
-}  // namespace
+using android::base::PodVector;
 
 namespace android {
 namespace kernel {
 
-void setFileDescriptionFunction(GetFileDescriptionFunction* file_func,
-                                void* file_opaque) {
-    sGetFileDescription = file_func ? file_func : &getFileDescription;
-    sGetFileDescriptionOpaque = file_func ? file_opaque : NULL;
-}
+static const char kVersionStringPrefix[] = "Linux version ";
+static const size_t kVersionStringPrefixLen = sizeof(kVersionStringPrefix) - 1U;
 
 }  // namespace kernel
 }  // namespace android
 
-bool android_pathProbeKernelType(const char* kernelPath, KernelType* ktype) {
-    String description;
+#ifndef __APPLE__
+size_t strlcpy(char* dst, const char * src, size_t size)
+{
+    size_t srcLen = strlen(src);
+    if (size > 0) {
+        size_t copyLen = std::min(srcLen, size-1);
+        memcpy(dst, src, copyLen);
+        dst[copyLen] = 0;
+    }
+    return srcLen;
+}
+#endif
 
-    if (!sGetFileDescription(sGetFileDescriptionOpaque,
-                             kernelPath,
-                             &description)) {
-        return false;
+#ifdef _WIN32
+// TODO: (vharron) move somewhere more generally useful?
+// Returns a pointer to the first occurrence of |needle| in |haystack|, or a 
+// NULL pointer if |needle| is not part of |haystack|.
+const void* memmem(const void* haystack, size_t haystackLen,
+                   const void* needle, size_t needleLen) {
+    if (needleLen == 0 ) {
+        return haystack;
     }
-    const char* bzImage = ::strstr(description.c_str(), "bzImage");
-    if (!bzImage) {
-        KERNEL_ERROR << "Not a compressed Linux kernel image!";
-        return false;
-    }
-    const char* version = ::strstr(bzImage, "version ");
-    if (!version) {
-        KERNEL_ERROR << "Could not determine version!";
-        return false;
-    }
-    version += ::strlen("version ");
-    KERNEL_LOG << "Found kernel version " << version;
 
-    char* end;
-    unsigned long major = ::strtoul(version, &end, 10);
-    if (end == version || *end != '.') {
-        KERNEL_ERROR << "Could not find kernel major version!";
+    if (haystackLen < needleLen) {
+        return NULL;
+    }
+
+    const char* haystackPos = (const char*)haystack;
+    const char* haystackEnd = haystackPos + (haystackLen - needleLen);
+    for (; haystackPos < haystackEnd; haystackPos++) {
+        if (0==memcmp(haystackPos, needle, needleLen)) {
+            return haystackPos;
+        }
+    }
+    return NULL;
+}
+#endif
+
+
+bool android_parseLinuxVersionString(const char* versionString,
+                                     KernelVersion* kernelVersion) {
+    if (strncmp(versionString, android::kernel::kVersionStringPrefix,
+                android::kernel::kVersionStringPrefixLen)) {
+        KERNEL_ERROR << "unsupported kernel version string:" << versionString;
         return false;
     }
-    KERNEL_LOG << "Kernel major version: " << major;
-    if (major > 3) {
-        *ktype = KERNEL_TYPE_3_10_OR_ABOVE;
-    } else if (major < 3) {
-        *ktype = KERNEL_TYPE_LEGACY;
-    } else /* major == 3 */ {
-        version = end + 1;
-        unsigned long minor = ::strtoul(version, &end, 10);
-        if (end == version) {
-            KERNEL_ERROR << "Could not find kernel minor version!";
+    // skip past the prefix to the version number
+    versionString += android::kernel::kVersionStringPrefixLen;
+
+    uint32_t temp = 0;
+    for (int i = 0; i < 3; i++) {
+        // skip '.' delimeters
+        while (i > 0 && *versionString == '.') {
+            versionString++;
+        }
+
+        char* end;
+        unsigned long number = ::strtoul(versionString, &end, 10);
+        if (end == versionString || number > 0xff) {
+            KERNEL_ERROR << "unsupported kernel version string:"
+                         << versionString;
             return false;
         }
-        KERNEL_LOG << "Kernel minor version: " << minor;
-
-        *ktype = (minor >= 10)
-                ? KERNEL_TYPE_3_10_OR_ABOVE : KERNEL_TYPE_LEGACY;
+        temp <<= 8;
+        temp |= number;
+        versionString = end;
     }
+    *kernelVersion = (KernelVersion)temp;
+
+    KERNEL_LOG << android::base::LogString("Kernel version hex 0x%06x", temp);
     return true;
 }
 
-const char* android_kernelSerialDevicePrefix(KernelType ktype) {
-    switch (ktype) {
-        case KERNEL_TYPE_LEGACY: return "ttyS";
-        case KERNEL_TYPE_3_10_OR_ABOVE: return "ttyGF";
-        default: return "";
+const char* android_kernelSerialDevicePrefix(KernelVersion kernelVersion) {
+    if (kernelVersion >= KERNEL_VERSION_3_10_0) {
+        return "ttyGF";
     }
+    return "ttyS";
+}
+
+bool android_imageProbeKernelVersionString(const uint8_t* kernelFileData,
+                                           size_t kernelFileSize,
+                                           char* dst/*[dstLen]*/,
+                                           size_t dstLen) {
+    PodVector<uint8_t> uncompressed;
+
+    const uint8_t* uncompressedKernel = NULL;
+    size_t uncompressedKernelLen = 0;
+
+    const char kElfHeader[] = { 0x7f, 'E', 'L', 'F' };
+
+    if (kernelFileSize < sizeof(kElfHeader)) {
+        KERNEL_ERROR << "Kernel image too short";
+        return false;
+    }
+
+    if (0 == memcmp(kElfHeader, kernelFileData, sizeof(kElfHeader))) {
+        // this is an uncompressed ELF file (probably mips)
+        uncompressedKernel = kernelFileData;
+        uncompressedKernelLen = kernelFileSize;
+    }
+    else {
+        // handle compressed kernels here
+        const uint8_t kGZipMagic[4] = { 0x1f, 0x8b, 0x08, 0x00 };
+        const uint8_t* compressedKernel = (const uint8_t*)memmem(kernelFileData,
+                                                                 kernelFileSize,
+                                                                 kGZipMagic,
+                                                                 sizeof(kGZipMagic));
+        if (!compressedKernel) {
+            KERNEL_ERROR << "Could not find gzip header in kernel file!";
+            return false;
+        }
+
+        size_t compressedKernelLen = kernelFileSize -
+            (compressedKernel - kernelFileData);
+
+        // inflate ratios for all prebuilt kernels on 2014-07-14 is 1.9:1 ~
+        // 3.43:1 not sure how big the uncompressed size is, so make an
+        // absurdly large buffer
+        uncompressedKernelLen = compressedKernelLen * 10;
+        uncompressed.resize(uncompressedKernelLen);
+        uncompressedKernel = uncompressed.begin();
+
+        bool zOk = uncompress_gzipStream(uncompressed.begin(),
+                                         &uncompressedKernelLen,
+                                         compressedKernel,
+                                         compressedKernelLen);
+        if (!zOk) {
+            KERNEL_ERROR << "Kernel decompression error";
+            // it may have been partially decompressed, so we're going to 
+            // try to find the version string anyway
+        }
+    }
+
+    // okay, now we have a pointer to an uncompressed kernel, let's find the
+    // version string
+    const char* versionStringStart = (const char*)memmem(
+        uncompressedKernel,
+        uncompressedKernelLen,
+        android::kernel::kVersionStringPrefix,
+        android::kernel::kVersionStringPrefixLen);
+    if (!versionStringStart) {
+        KERNEL_ERROR << "Could not find 'Linux version ' in kernel!";
+        return false;
+    }
+
+    strlcpy(dst, versionStringStart, dstLen);
+
+    return true;
+}
+
+bool android_pathProbeKernelVersionString(const char* kernelPath,
+                                          char* dst/*[dstLen]*/,
+                                          size_t dstLen) {
+    FileData kernelFileData;
+    if (fileData_initFromFile(&kernelFileData, kernelPath) < 0) {
+        KERNEL_ERROR << "Could not open kernel file!";
+        return false;
+    }
+
+    return android_imageProbeKernelVersionString(kernelFileData.data,
+                                                 kernelFileData.size,
+                                                 dst,
+                                                 dstLen);
 }
diff --git a/android/kernel/kernel_utils.h b/android/kernel/kernel_utils.h
old mode 100644
new mode 100755
index e10eb34..2e6fb45
--- a/android/kernel/kernel_utils.h
+++ b/android/kernel/kernel_utils.h
@@ -13,6 +13,8 @@
 #define ANDROID_KERNEL_KERNEL_UTILS_H
 
 #include "android/utils/compiler.h"
+
+#include <stddef.h>
 #include <stdint.h>
 
 ANDROID_BEGIN_HEADER
@@ -20,24 +22,36 @@
 // An enum used to list of the types of Linux kernel images we need to
 // handle. Unfortunately, this affects how we setup the kernel command-line
 // when launching the system.
-//
-// KERNEL_TYPE_LEGACY is any Linux kernel image before 3.10
-// KERNEL_TYPE_3_10_OR_ABOVE is anything at 3.10 or above.
 typedef enum {
-    KERNEL_TYPE_LEGACY = 0,
-    KERNEL_TYPE_3_10_OR_ABOVE = 1,
-} KernelType;
+    KERNEL_VERSION_2_6_29 = 0x02061d,
+    KERNEL_VERSION_3_4_0  = 0x030400,
+    KERNEL_VERSION_3_4_67 = 0x030443,
+    KERNEL_VERSION_3_10_0 = 0x030a00,
+} KernelVersion;
 
-// Probe the kernel image at |kernelPath| and returns the corresponding
-// KernelType value. On success, returns true and sets |*ktype| appropriately.
+// Converts a string at |versionString| in the format "Linux version MM.mm.rr..."
+// into a hex value 0x00MMmmrr.  On success, returns true and sets |*kernelVersion|
+// appropriately
+// On failure, returns false and doesn't touch |*kernelVersion|.
+bool android_parseLinuxVersionString(const char* versionString,
+                                     KernelVersion* kernelVersion);
+
+// Probe the kernel image at |kernelPath| and copy the corresponding
+// 'Linux version ' string into the |dst| buffer.  On success, returns true
+// and copies up to |dstLen-1| characters into dst.  dst will always be NUL
+// terminated if |dstLen| >= 1
+//
 // On failure (e.g. if the file doesn't exist or cannot be probed), return
-// false and doesn't touch |*ktype|.
-bool android_pathProbeKernelType(const char* kernelPath, KernelType *ktype);
+// false and doesn't touch |dst| buffer.
+bool android_pathProbeKernelVersionString(const char* kernelPath,
+                                          char* dst,
+                                          size_t dstLen);
 
-// Return the serial device name prefix matching a given kernel type |ktype|.
-// I.e. this should be "/dev/ttyS" for KERNEL_TYPE_LEGACY, and
-// "/dev/ttyGF" for KERNEL_TYPE_3_10_OR_ABOVE.
-const char* android_kernelSerialDevicePrefix(KernelType ktype);
+// Return the serial device name prefix matching a given kernel type 
+// |kernelVersion|.  I.e. this should be "/dev/ttyS" for before 3.10.0 and 
+// "/dev/ttyGF" for 3.10.0 and later.
+const char* android_kernelSerialDevicePrefix(KernelVersion kernelVersion);
+
 
 ANDROID_END_HEADER
 
diff --git a/android/kernel/kernel_utils_testing.h b/android/kernel/kernel_utils_testing.h
old mode 100644
new mode 100755
index f2d64ec..51b476a
--- a/android/kernel/kernel_utils_testing.h
+++ b/android/kernel/kernel_utils_testing.h
@@ -12,36 +12,17 @@
 #ifndef ANDROID_KERNEL_KERNEL_UTILS_TESTING_H
 #define ANDROID_KERNEL_KERNEL_UTILS_TESTING_H
 
-namespace android {
-
-namespace base {
-class String;
-}  // namespace base
-
-namespace kernel {
-
-// Type of a function used to retrieve the textual description of a given
-// file at |filePath|. On success, return true and sets |*text| to the
-// description text, as if running through the 'file' command on Unix.
-// |opaque| is a client-provided value set by calling
-// setFileDescriptionFunction() below.
-typedef bool (GetFileDescriptionFunction)(void* opaque,
-                                          const char* filePath,
-                                          android::base::String* text);
-
-// Change the implementation of the function that extracts textual
-// descriptions from a given file. |file_func| is a pointer to the
-// new function, and |file_opaque| is the value that will be passed
-// as its first parameter. Note that if |file_func| is NULL, the
-// default implementation will be selected instead.
+// Probe the kernel image at |kernelPath| and copy the corresponding
+// 'Linux version ' string into the |dst| buffer.  On success, returns true
+// and copies up to |dstLen-1| characters into dst.  dst will always be NUL
+// terminated if |dstLen| >= 1
 //
-// Only use this during unit-testing to force different description
-// values on arbitrary file content.
-void setFileDescriptionFunction(GetFileDescriptionFunction* file_func,
-                                void* file_opaque);
+// On failure (e.g. if the file doesn't exist or cannot be probed), return
+// false and doesn't touch |dst| buffer.
+bool android_imageProbeKernelVersionString(const uint8_t* kernelFileData,
+                                           size_t kernelFileSize,
+                                           char* dst,
+                                           size_t dstLen);
 
-}  // namespace kernel
-
-}  // namespace android
 
 #endif  // ANDROID_KERNEL_KERNEL_UTILS_TESTING_H
diff --git a/android/kernel/kernel_utils_unittest.cpp b/android/kernel/kernel_utils_unittest.cpp
old mode 100644
new mode 100755
index a5afa2a..40ad06c
--- a/android/kernel/kernel_utils_unittest.cpp
+++ b/android/kernel/kernel_utils_unittest.cpp
@@ -11,121 +11,141 @@
 
 #include "android/kernel/kernel_utils.h"
 
-#include "android/base/String.h"
 #include "android/kernel/kernel_utils_testing.h"
 
 #include <gtest/gtest.h>
 
-using android::base::String;
-
 namespace android {
 namespace kernel {
 
-namespace {
-
-class ScopedDescriptionFunc {
-public:
-    explicit ScopedDescriptionFunc(GetFileDescriptionFunction* file_func) {
-        setFileDescriptionFunction(file_func, NULL);
-    }
-
-    ScopedDescriptionFunc(GetFileDescriptionFunction* file_func,
-                          void* file_opaque) {
-        setFileDescriptionFunction(file_func, file_opaque);
-    }
-
-    ~ScopedDescriptionFunc() {
-        setFileDescriptionFunction(NULL, NULL);
-    }
-};
-
-}  // namespace
-
 TEST(KernelUtils, GetKernelSerialDevicePrefix) {
     EXPECT_STREQ("ttyS",
-            android_kernelSerialDevicePrefix(KERNEL_TYPE_LEGACY));
+                 android_kernelSerialDevicePrefix(KERNEL_VERSION_2_6_29));
+    EXPECT_STREQ("ttyS",
+                 android_kernelSerialDevicePrefix(KERNEL_VERSION_3_4_0));
+    EXPECT_STREQ("ttyS",
+                 android_kernelSerialDevicePrefix(KERNEL_VERSION_3_4_67));
     EXPECT_STREQ("ttyGF",
-            android_kernelSerialDevicePrefix(KERNEL_TYPE_3_10_OR_ABOVE));
+                 android_kernelSerialDevicePrefix(KERNEL_VERSION_3_10_0));
 }
 
-static bool failFunc(void* opaque, const char* path, String* text) {
-    return false;
-}
+TEST(KernelUtils, ProbeKernelVersionString) {
+    // you can regenerate these tables using 
+    // android/kernel/testing/print_mock_kernel_data.sh
 
-TEST(KernelUtils, ProbeKernelTypeWithNoKernelFile) {
-    ScopedDescriptionFunc func(&failFunc);
+    const char kMockKernelVersion[] =
+        "Linux version 3.10.0+ (vharron@tifa.mtv.corp.google.com) "
+        "(gcc version 4.7 (GCC) ) #1 PREEMPT Sat Jan 5 2:45:24 PDT 2008\n";
 
-    KernelType ktype;
-    EXPECT_FALSE(android_pathProbeKernelType("/tmp/kernel", &ktype));
-}
-
-struct Expectation {
-    const char* description;
-    bool result;
-    KernelType ktype;
-
-    static bool getDescriptionFunc(void* opaque,
-                                   const char* path,
-                                   String* text) {
-        const Expectation* expectation = static_cast<const Expectation*>(opaque);
-        if (!expectation->result)
-            return false;
-        text->assign(expectation->description);
-        return true;
-    }
-};
-
-#ifdef _WIN32
-#define DISABLED_ON_WIN32(x)  DISABLED_ ## x
-#else
-#define DISABLED_ON_WIN32(x)  x
-#endif
-
-TEST(KernelUtils, DISABLED_ON_WIN32(PathProbeKernelType)) {
-    static const Expectation kData[] = {
-        { NULL, false, KERNEL_TYPE_LEGACY },
-        // Missing bzImage.
-        { "Linux kernel x86 boot executable raw image, version 3.10.0+",
-                false, KERNEL_TYPE_LEGACY },
-        // Missing version
-        { "Linux kernel x86 boot executable bzImage, 3.10.0+",
-                false, KERNEL_TYPE_LEGACY },
-        // Legacy 2.6.29 kernel
-        { "Linux kernel x86 boot executable bzImage, version 2.6.29 (foo...)",
-                true,
-                KERNEL_TYPE_LEGACY },
-        // Legacy 3.4
-        { "Linux kernel x86 boot executable bzImage, version 3.4.1 (foo...)",
-                true,
-                KERNEL_TYPE_LEGACY },
-        // 3.10
-        { "Linux kernel x86 boot executable bzImage, version 3.10.0+",
-                true,
-                KERNEL_TYPE_3_10_OR_ABOVE },
-        // 3.40
-        { "Linux kernel x86 boot executable bzImage, version 3.40.0",
-                true,
-                KERNEL_TYPE_3_10_OR_ABOVE },
-        // 4.0
-        { "Linux kernel x86 boot executable bzImage, version 4.0.9",
-                true,
-                KERNEL_TYPE_3_10_OR_ABOVE },
+    // a mock uncompressed kernel
+    // ELF header, followed by an unspecified number of bytes
+    // followed by a 'Linux version ' string
+    static const unsigned char kMockKernelElf[] = {
+        0x7f, 0x45, 0x4c, 0x46, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+        0x38, 0x39, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x20, 0x76, 0x65, 0x72, 0x73,
+        0x69, 0x6f, 0x6e, 0x20, 0x33, 0x2e, 0x31, 0x30, 0x2e, 0x30, 0x2b, 0x20,
+        0x28, 0x76, 0x68, 0x61, 0x72, 0x72, 0x6f, 0x6e, 0x40, 0x74, 0x69, 0x66,
+        0x61, 0x2e, 0x6d, 0x74, 0x76, 0x2e, 0x63, 0x6f, 0x72, 0x70, 0x2e, 0x67,
+        0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x29, 0x20, 0x28,
+        0x67, 0x63, 0x63, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20,
+        0x34, 0x2e, 0x37, 0x20, 0x28, 0x47, 0x43, 0x43, 0x29, 0x20, 0x29, 0x20,
+        0x23, 0x31, 0x20, 0x50, 0x52, 0x45, 0x45, 0x4d, 0x50, 0x54, 0x20, 0x53,
+        0x61, 0x74, 0x20, 0x4a, 0x61, 0x6e, 0x20, 0x35, 0x20, 0x32, 0x3a, 0x34,
+        0x35, 0x3a, 0x32, 0x34, 0x20, 0x50, 0x44, 0x54, 0x20, 0x32, 0x30, 0x30,
+        0x38, 0x0a, 0x00, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39
     };
-    const size_t kDataSize = sizeof(kData) / sizeof(kData[0]);
-    static const char kKernelPath[] = "/tmp/kernel";
-    for (size_t n = 0; n < kDataSize; ++n) {
-        KernelType kernelType;
-        const Expectation& expectation = kData[n];
-        ScopedDescriptionFunc func(&Expectation::getDescriptionFunc,
-                                   (void*)&expectation);
-        EXPECT_EQ(expectation.result,
-                  android_pathProbeKernelType(kKernelPath, &kernelType))
-                        << "For [" << expectation.description << "]";
-        if (expectation.result) {
-            EXPECT_EQ(expectation.ktype, kernelType) << "For ["
-                    << expectation.description << "]";
-        }
-    }
+
+    // a mock uncompressed kernel without version string
+    // ELF header, followed by an unspecified number of bytes
+    static const unsigned char kMockKernelElfNoString[] = {
+        0x7f, 0x45, 0x4c, 0x46, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+        0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
+        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30, 0x31,
+        0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39
+    };
+
+    // a mock compressed kernel
+    // an unspecified number of bytes, followed by a gzip header
+    // gzip stream starts 10 bytes after gzip header, uncompressed gzip stream
+    // begins with an ELF header as above
+    static const unsigned char kMockKernelGzip[] = {
+        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x1f, 0x8b,
+        0x08, 0x00, 0x24, 0xc7, 0xc6, 0x53, 0x00, 0x03, 0xab, 0x77, 0xf5, 0x71,
+        0x33, 0x30, 0x34, 0x32, 0x36, 0x31, 0x35, 0x33, 0xb7, 0xb0, 0xf4, 0xc9,
+        0xcc, 0x2b, 0xad, 0x50, 0x28, 0x4b, 0x2d, 0x2a, 0xce, 0xcc, 0xcf, 0x53,
+        0x30, 0xd6, 0x33, 0x34, 0xd0, 0x33, 0xd0, 0x56, 0xd0, 0x28, 0xcb, 0x48,
+        0x2c, 0x2a, 0xca, 0xcf, 0x73, 0x28, 0xc9, 0x4c, 0x4b, 0xd4, 0xcb, 0x2d,
+        0x29, 0xd3, 0x4b, 0xce, 0x2f, 0x2a, 0xd0, 0x4b, 0xcf, 0xcf, 0x4f, 0xcf,
+        0x49, 0x05, 0xb2, 0x73, 0x35, 0x15, 0x34, 0xd2, 0x93, 0x93, 0xe1, 0xfa,
+        0x4c, 0xf4, 0xcc, 0x15, 0x34, 0xdc, 0x9d, 0x9d, 0x35, 0x15, 0x34, 0x15,
+        0x94, 0x0d, 0x15, 0x02, 0x82, 0x5c, 0x5d, 0x7d, 0x03, 0x42, 0x14, 0x82,
+        0x13, 0x4b, 0x14, 0xbc, 0x12, 0xf3, 0x14, 0x4c, 0x15, 0x8c, 0xac, 0x4c,
+        0x4c, 0xad, 0x8c, 0x4c, 0x14, 0x02, 0x5c, 0x42, 0x14, 0x8c, 0x0c, 0x0c,
+        0x2c, 0xb8, 0x18, 0xe0, 0x2e, 0x00, 0x00, 0xd3, 0x6e, 0x68, 0xa6, 0x90,
+        0x00, 0x00, 0x00
+    };
+
+    char kernelVersionString[256];
+
+    kernelVersionString[0] = 0;
+    EXPECT_EQ(true, android_imageProbeKernelVersionString(
+        kMockKernelElf,
+        sizeof(kMockKernelElf),
+        kernelVersionString,
+        sizeof(kernelVersionString)));
+    EXPECT_STREQ(kMockKernelVersion, kernelVersionString);
+
+    kernelVersionString[0] = 0;
+    EXPECT_EQ(true, android_imageProbeKernelVersionString(
+        kMockKernelGzip,
+        sizeof(kMockKernelGzip),
+        kernelVersionString,
+        sizeof(kernelVersionString)));
+    EXPECT_STREQ(kMockKernelVersion, kernelVersionString);
+
+    kernelVersionString[0] = 127;
+    EXPECT_EQ(false, android_imageProbeKernelVersionString(
+        0,
+        0,
+        kernelVersionString,
+        sizeof(kernelVersionString)));
+    EXPECT_EQ(127, kernelVersionString[0]);
+
+    kernelVersionString[0] = 127;
+    EXPECT_EQ(false, android_imageProbeKernelVersionString(
+        kMockKernelElfNoString,
+        sizeof(kMockKernelElfNoString),
+        kernelVersionString,
+        sizeof(kernelVersionString)));
+    EXPECT_EQ(127, kernelVersionString[0]);
+}
+
+void ParseKernelVersionString(const char* versionString,
+                              KernelVersion expectedVersion) {
+    KernelVersion actualVersion;
+    EXPECT_EQ(true, android_parseLinuxVersionString(versionString,
+                                                    &actualVersion));
+    EXPECT_EQ(expectedVersion, actualVersion);
+}
+
+TEST(KernelUtils, ParseKernelVersionString) {
+    ParseKernelVersionString("Linux version 2.6.29-gea477bb (kroo...\n",
+                             KERNEL_VERSION_2_6_29);
+
+    ParseKernelVersionString("Linux version 2.6.29 (vcht...\n",
+                             KERNEL_VERSION_2_6_29);
+
+    ParseKernelVersionString("Linux version 3.4.0-66985-gb04946b (digi...\n",
+                             KERNEL_VERSION_3_4_0);
+
+    ParseKernelVersionString("Linux version 3.4.67+ (ghac...\n",
+                             KERNEL_VERSION_3_4_67 );
+
+    ParseKernelVersionString("Linux version 3.4.67-01413-g9ac497f (ghac...\n",
+                             KERNEL_VERSION_3_4_67);
+
+    ParseKernelVersionString("Linux version 3.10.0+ (ghac...\n",
+                             KERNEL_VERSION_3_10_0);
 }
 
 }  // namespace kernel
diff --git a/android/kernel/testing/print_mock_kernel_data.sh b/android/kernel/testing/print_mock_kernel_data.sh
new file mode 100755
index 0000000..1a1a5cb
--- /dev/null
+++ b/android/kernel/testing/print_mock_kernel_data.sh
@@ -0,0 +1,31 @@
+#!/bin/bash -e
+
+LINUX_VERSION="Linux version 3.10.0+ (vharron@tifa.mtv.corp.google.com) (gcc version 4.7 (GCC) ) #1 PREEMPT Sat Jan 5 2:45:24 PDT 2008\xA\x0"
+TMP_FILE=/tmp/print_mock_kernel_tmp
+
+printf "// a mock uncompressed kernel\n"
+printf "// ELF header, followed by an unspecified number of bytes\n"
+printf "// followed by a 'Linux version ' string\n"
+printf "static const unsigned char kMockKernelElf[] = {\n"
+printf '\x7f'ELF0123456789"${LINUX_VERSION}"0123456789 | xxd -i
+printf "};\n\n"
+
+printf "// a mock uncompressed kernel without version string\n"
+printf "// ELF header, followed by an unspecified number of bytes\n"
+printf "static const unsigned char kMockKernelElfNoString[] = {\n"
+printf '\x7f'ELF0123456789012345678901234567890123456789 | xxd -i
+printf "};\n\n"
+
+printf "// a mock compressed kernel\n"
+printf "// an unspecified number of bytes, followed by a gzip header\n"
+printf "// gzip stream starts 10 bytes after gzip header, uncompressed gzip stream\n"
+printf "// begins with an ELF header as above\n"
+printf "static const unsigned char kMockKernelGzip[] = {\n"
+printf "0123456789" > $TMP_FILE
+printf '\x7f'ELF0123456789"${LINUX_VERSION}"0123456789 | gzip >> $TMP_FILE
+cat $TMP_FILE | xxd -i
+printf "};\n\n"
+
+rm $TMP_FILE
+
+
diff --git a/android/main.c b/android/main.c
old mode 100644
new mode 100755
index b1a3053..a5b479a
--- a/android/main.c
+++ b/android/main.c
@@ -453,17 +453,26 @@
          }
     }
 
-    KernelType kernelType = KERNEL_TYPE_LEGACY;
-    if (!android_pathProbeKernelType(hw->kernel_path, &kernelType)) {
-        D("WARNING: Could not determine kernel device naming scheme. Assuming legacy\n"
-            "If this AVD doesn't boot, and uses a recent kernel (3.10 or above) try setting\n"
-            "'kernel.newDeviceNaming' to 'yes' in its configuration.\n");
+    char versionString[256];
+    if (!android_pathProbeKernelVersionString(hw->kernel_path,
+                                              versionString,
+                                              sizeof(versionString))) {
+        derror("Can't find 'Linux version ' string in kernel image file: %s",
+               hw->kernel_path);
+        exit(2);
+    }
+
+    KernelVersion kernelVersion = 0;
+    if (!android_parseLinuxVersionString(versionString, &kernelVersion)) {
+        derror("Can't parse 'Linux version ' string in kernel image file: '%s'",
+               versionString);
+        exit(2);
     }
 
     // Auto-detect kernel device naming scheme if needed.
     if (androidHwConfig_getKernelDeviceNaming(hw) < 0) {
         const char* newDeviceNaming = "no";
-        if (kernelType == KERNEL_TYPE_3_10_OR_ABOVE) {
+        if (kernelVersion >= KERNEL_VERSION_3_10_0) {
             D("Auto-detect: Kernel image requires new device naming scheme.");
             newDeviceNaming = "yes";
         } else {
diff --git a/android/qemu-launcher/emulator-qemu.cpp b/android/qemu-launcher/emulator-qemu.cpp
index 899cc9d..280bd58 100644
--- a/android/qemu-launcher/emulator-qemu.cpp
+++ b/android/qemu-launcher/emulator-qemu.cpp
@@ -299,17 +299,26 @@
         hw->kernel_path = kernelFile;
     }
 
-    KernelType kernelType = KERNEL_TYPE_LEGACY;
-    if (!android_pathProbeKernelType(hw->kernel_path, &kernelType)) {
-        D("WARNING: Could not determine kernel device naming scheme. Assuming legacy\n"
-            "If this AVD doesn't boot, and uses a recent kernel (3.10 or above) try setting\n"
-            "'kernel.newDeviceNaming' to 'yes' in its configuration.\n");
+    char versionString[256];
+    if (!android_pathProbeKernelVersionString(hw->kernel_path,
+                                              versionString,
+                                              sizeof(versionString))) {
+        derror("Can't find 'Linux version ' string in kernel image file: %s",
+               hw->kernel_path);
+        exit(2);
+    }
+
+    KernelVersion kernelVersion;
+    if (!android_parseLinuxVersionString(versionString, &kernelVersion)) {
+        derror("Can't parse 'Linux version ' string in kernel image file: '%s'",
+               versionString);
+        exit(2);
     }
 
     // Auto-detect kernel device naming scheme if needed.
     if (androidHwConfig_getKernelDeviceNaming(hw) < 0) {
         const char* newDeviceNaming = "no";
-        if (kernelType == KERNEL_TYPE_3_10_OR_ABOVE) {
+        if (kernelVersion >= KERNEL_VERSION_3_10_0) {
             D("Auto-detect: Kernel image requires new device naming scheme.");
             newDeviceNaming = "yes";
         } else {
diff --git a/android/utils/uncompress.cpp b/android/utils/uncompress.cpp
new file mode 100755
index 0000000..3a3a939
--- /dev/null
+++ b/android/utils/uncompress.cpp
@@ -0,0 +1,43 @@
+// Copyright 2014 The Android Open Source Project
+//
+// This software is licensed under the terms of the GNU General Public
+// License version 2, as published by the Free Software Foundation, and
+// may be copied, distributed, and modified under those terms.
+//
+// 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.
+
+#include "android/utils/uncompress.h"
+#include "zlib.h"
+
+bool uncompress_gzipStream(uint8_t* dst, size_t* dstLen, const uint8_t* src,
+                   size_t srcLen) {
+    z_stream stream;
+    stream.next_in = (Bytef*)src;
+    stream.avail_in = srcLen;
+    stream.next_out = dst;
+    stream.avail_out = *dstLen;
+    stream.zalloc = (alloc_func)0;
+    stream.zfree = (free_func)0;
+
+    // magic number from gz_read
+    const int GZIP_WINDOW_BITS = 15 + 16;
+
+    int result = inflateInit2(&stream, GZIP_WINDOW_BITS);
+    if (result != Z_OK) {
+        return result;
+    }
+
+    result = inflate(&stream, Z_FINISH);
+    *dstLen = stream.total_out;
+    if (result == Z_STREAM_END) {
+        result = inflateEnd(&stream);
+    }
+    else {
+        // preserve error code
+        inflateEnd(&stream);
+    }
+    return result == Z_OK;
+}
diff --git a/android/utils/uncompress.h b/android/utils/uncompress.h
new file mode 100755
index 0000000..8ba8968
--- /dev/null
+++ b/android/utils/uncompress.h
@@ -0,0 +1,39 @@
+/* Copyright (C) 2009 The Android Open Source Project
+**
+** This software is licensed under the terms of the GNU General Public
+** License version 2, as published by the Free Software Foundation, and
+** may be copied, distributed, and modified under those terms.
+**
+** 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.
+*/
+#ifndef ANDROID_UTILS_UNCOMPRESS_H
+#define ANDROID_UTILS_UNCOMPRESS_H
+
+#include "android/utils/compiler.h"
+
+#include <stdint.h>
+#include <stddef.h>
+
+ANDROID_BEGIN_HEADER
+
+// uncompress a gzip file in memory into memory in one function call
+// the dstLen must be large enough to hold all the decompressed data
+//
+// src - pointer to the beginning of the gzip file data
+// srcLen - total number of bytes in the gzip file
+// dst - pointer that receives the decompressed bytes
+// dstLen - number of bytes available for decompressed data
+//
+// return values 
+// true - all data decompressed correctly
+// false - dst buffer too small or corrupt zstream or out of memory
+// |dstLen| hold the number of bytes written to dst
+bool uncompress_gzipStream(uint8_t* dst, size_t* dstLen, const uint8_t* src,
+                           size_t srcLen);
+
+ANDROID_END_HEADER
+
+#endif /* ANDROID_UTILS_UNCOMPRESS_H */