Fill in sys_info->csd_version_rva on Linux.

breakpad/linux/minidump_writer.cc

 // Copyright (c) 2009, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 33 matching lines @@
 //     new form to allocate objects and we don't delete them.
 
 #include "breakpad/linux/minidump_writer.h"
 #include "client/minidump_file_writer-inl.h"
 
 #include <unistd.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <sys/ucontext.h>
 #include <sys/user.h>
+#include <sys/utsname.h>
 
 #include "client/minidump_file_writer.h"
 #include "google_breakpad/common/minidump_format.h"
 #include "google_breakpad/common/minidump_cpu_amd64.h"
 #include "google_breakpad/common/minidump_cpu_x86.h"
 
 #include "breakpad/linux/exception_handler.h"
 #include "breakpad/linux/linux_dumper.h"
 #include "breakpad/linux/linux_libc_support.h"
 #include "breakpad/linux/linux_syscall_support.h"
@@ skipping 528 matching lines @@
   bool WriteSystemInfoStream(MDRawDirectory* dirent) {
     TypedMDRVA<MDRawSystemInfo> si(&minidump_writer_);
     if (!si.Allocate())
       return false;
     my_memset(si.get(), 0, sizeof(MDRawSystemInfo));
 
     dirent->stream_type = MD_SYSTEM_INFO_STREAM;
     dirent->location = si.location();
 
     WriteCPUInformation(si.get());
+    WriteOSInformation(si.get());
 
     return true;
   }
 
  private:
 #if defined(__i386)
   uintptr_t GetStackPointer() {
     return ucontext_->uc_mcontext.gregs[REG_ESP];
   }
 #elif defined(__x86_64)
@@ skipping 151 matching lines @@
       return false;
 
     UntypedMDRVA memory(&minidump_writer_);
     if (!memory.Allocate(done))
       return false;
     memory.Copy(data, done);
     *result = memory.location();
     return true;
   }
 
+  bool WriteOSInformation(MDRawSystemInfo* sys_info) {
+    sys_info->platform_id = MD_OS_LINUX;
+
+    struct utsname uts;
+    if (uname(&uts))
+      return false;
+
+    static const size_t buf_len = 512;
+    char buf[buf_len] = {0};
+    size_t space_left = buf_len - 1;
+    const char* info_table[] = {
+      uts.sysname,
+      uts.release,
+      uts.version,
+      uts.machine,
+      NULL
+    };
+    bool first_item = true;
+    for (const char** cur_info = info_table; *cur_info; cur_info++) {
+      static const char* separator = " ";
+      size_t separator_len = strlen(separator);
+      size_t info_len = strlen(*cur_info);
+      if (info_len == 0)
+        continue;
+
+      if (space_left < info_len + (first_item ? 0 : separator_len))
+        break;
+
+      if (!first_item) {
+        strcat(buf, separator);
+        space_left -= separator_len;
+      }
+
+      first_item = false;
+      strcat(buf, *cur_info);
+      space_left -= info_len;
+    }
+
+    MDLocationDescriptor location;
+    if (!minidump_writer_.WriteString(buf, 0, &location))
+      return false;
+    sys_info->csd_version_rva = location.rva;
+
+    return true;
+  }
+
   bool WriteProcFile(MDLocationDescriptor* result, pid_t pid,
                      const char* filename) {
     char buf[80];
     memcpy(buf, "/proc/", 6);
     const unsigned pid_len = my_int_len(pid);
     my_itos(buf + 6, pid, pid_len);
     buf[6 + pid_len] = '/';
     memcpy(buf + 6 + pid_len + 1, filename, my_strlen(filename) + 1);
     return WriteFile(result, buf);
   }
@@ skipping 14 matching lines @@
     return false;
   const ExceptionHandler::CrashContext* context =
       reinterpret_cast<const ExceptionHandler::CrashContext*>(blob);
   MinidumpWriter writer(filename, crashing_process, context);
   if (!writer.Init())
     return false;
   return writer.Dump();
 }
 
 }  // namespace google_breakpad