Export the kernel partition's UniqueGuid to the kernel command line.

bootstub.c

 // Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 //
 // This program is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
@@ skipping 26 matching lines @@
 
 
 // Find where the preloaded params struct is located in RAM. At the moment
 // we're assuming that it immediately precedes the start of the bootstub,
 // aligned to a 4K boundary, because that's where our build system puts it.
 struct hacked_params *find_params_struct(UINTN bootstub_location)
 {
     return (struct hacked_params *)(bootstub_location - 0x1000);
 }
 
+// Copy a string to the right within a buffer.
+static void shove_over(char *src, char *dst)
+{
+    int i = 0;
+    for (i=0; src[i]; i++)
+        ;                               // find strlen(src)
+    dst += i;
+    src += i;
+    i++;                                // also terminating '\0';
+    while (i--)
+        *dst-- = *src--;
+}
+
+// sprintf(dst,"%02x",val)
+static void one_byte(char *dst, uint8_t val)
+{
+    dst[0] = "0123456789abcdef"[(val >> 4) & 0x0F];
+    dst[1] = "0123456789abcdef"[val & 0x0F];
+}
+
+// Display a GUID in canonical form
+static void emit_guid(char *dst, uint8_t *guid)
+{
+    one_byte(dst, guid[3]); dst += 2;
+    one_byte(dst, guid[2]); dst += 2;
+    one_byte(dst, guid[1]); dst += 2;
+    one_byte(dst, guid[0]); dst += 2;
+    *dst++ = '-';
+    one_byte(dst, guid[5]); dst += 2;
+    one_byte(dst, guid[4]); dst += 2;
+    *dst++ = '-';
+    one_byte(dst, guid[7]); dst += 2;
+    one_byte(dst, guid[6]); dst += 2;
+    *dst++ = '-';
+    one_byte(dst, guid[8]); dst += 2;
+    one_byte(dst, guid[9]); dst += 2;
+    *dst++ = '-';
+    one_byte(dst, guid[10]); dst += 2;
+    one_byte(dst, guid[11]); dst += 2;
+    one_byte(dst, guid[12]); dst += 2;
+    one_byte(dst, guid[13]); dst += 2;
+    one_byte(dst, guid[14]); dst += 2;
+    one_byte(dst, guid[15]); dst += 2;
+}
+
+
 // Replace any %D with the device letter, and replace any %P with the partition
-// number. For example, ("root=/dev/sd%D%P",2,3) gives "root=/dev/sdc3". The
-// input string must be mutable and end with a trailing '\0'.
-void update_cmdline_inplace(char *src, int devnum, int partnum)
+// number. For example, ("root=/dev/sd%D%P",2,3) gives "root=/dev/sdc3".
+// Replace any %U with the human-readable form of the GUID (if provided). The
+// input string must be mutable and end with a trailing '\0', and have enough
+// room for all the expansion.
+static void update_cmdline_inplace(char *src, int devnum, int partnum,
+                                   uint8_t *guid)
 {
     char *dst;
 
     // Use sane values (sda3) for ridiculous inputs.
     if (devnum < 0 || devnum > 25 || partnum < 1 || partnum > 99)
     {
         devnum = 0;
         partnum = 3;
     }
 
     for( dst = src; *src; src++, dst++ )
     {
         if ( src[0] == '%' )
         {
             switch (src[1])
             {
             case 'P':
                 if (partnum > 9)
                     *dst++ = '0' + (partnum / 10);
                 *dst = '0' + partnum % 10;
                 src++;
                 break;
             case 'D':
                 *dst = 'a' + devnum;
                 src++;
                 break;
+            case 'U':
+                if (guid) {
+                    shove_over(src+2, dst+36);
+                    emit_guid(dst, guid);
+                    src = dst+35;
+                    dst += 35;
+                }
             default:
                 *dst = *src;
             }
         }
         else if (dst != src)
             *dst = *src;
     }
     *dst = '\0';
 }
 
 // This is handy to write status codes to the LEDs for debugging.
 static __inline void port80w (unsigned short int value)
 {
     __asm__ __volatile__ ("outw %w0,$0x80": :"a" (value));
 }
 
 
 // The code to switch to 32-bit mode and start the kernel.
 extern void trampoline(unsigned long, void *);
 
 
-// Reserve some space for the EFI memory map. 
+// Reserve some space for the EFI memory map.
 // Danger Will Robinson: this is just a guess at the size and alignment. If
 // it's too small, the EFI GetMemoryMap() call will fail.
 // FIXME: Make the size dynamic? Retry with larger size on failure?
 static unsigned char mmap_buf[0x2000] __attribute__ ((aligned(0x200)));
 
 // Parameters that we're given by the BIOS
 typedef struct cros_boot_info {
     UINTN drive_number;                 // 0 - 25
     UINTN partition_number;             // 1 - 99
     UINTN original_address;             // our RAM address prior to execution
+    // The guid stuff was added later, so we need to consider it optional, at
+    // least for testing.
+    uint8_t partition_guid[16];         // kernel partition GUID
 } cros_boot_info_t;
 
 
 // Here's the entry point. It will be loaded by the BIOS as a standard EFI
 // application, which means it will be relocated.
 EFI_STATUS efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
 {
     UINTN mmap_size = sizeof(mmap_buf);
     UINTN mmap_key = 0;
     UINTN desc_size = 0;
     UINT32 desc_version = 0;
     EFI_LOADED_IMAGE *loaded_image;
     EFI_GUID loaded_image_protocol = LOADED_IMAGE_PROTOCOL;
+    EFI_GUID zero_guid = {0, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0}};
+    void *guid_ptr;
 
     // I'm here.
     port80w(0xc0de);
 
     // Find the parameters that the BIOS has passed to us.
     if (uefi_call_wrapper(systab->BootServices->HandleProtocol, 3,
                           image,
                           &loaded_image_protocol,
                           &loaded_image) != 0)
     {
         uefi_call_wrapper(systab->ConOut->OutputString, 3, systab->ConOut,
                           L"Can't locate protocol\r\n");
         goto fail;
     }
     cros_boot_info_t *booting = loaded_image->LoadOptions;
+    if (loaded_image->LoadOptionsSize < 40) // DWR: min size including guid
+        guid_ptr = &zero_guid;
+    else
+        guid_ptr = booting->partition_guid;
 
     // Find the parameters that we're passing to the kernel.
     struct hacked_params *params = find_params_struct(booting->original_address);
 
     // Update the kernel command-line string with the correct rootfs device
     update_cmdline_inplace((char *)(unsigned long)(params->cmd_line_ptr),
                            booting->drive_number,
-                           booting->partition_number + 1);
+                           booting->partition_number + 1,
+                           guid_ptr);
 
     // Obtain the EFI memory map.
     if (uefi_call_wrapper(systab->BootServices->GetMemoryMap, 5,
                           &mmap_size, mmap_buf, &mmap_key,
                           &desc_size, &desc_version) != 0)
     {
         uefi_call_wrapper(systab->ConOut->OutputString, 2, systab->ConOut,
                           L"Can't get memory map\r\n");
         goto fail;
     }
@@ skipping 22 matching lines @@
     // Trampoline to 32-bit entry point. Should never return.
     trampoline(params->code32_start, params);
 
 fail:
 
     // Bad Things happened.
     port80w(0xdead);
 
     return EFI_LOAD_ERROR;
 }