lib/ObjectYAML/MinidumpYAML.cpp

   1 //===- MinidumpYAML.cpp - Minidump YAMLIO implementation ------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/ObjectYAML/MinidumpYAML.h"
  10 #include "llvm/Support/Allocator.h"
  11
  12 using namespace llvm;
  13 using namespace llvm::MinidumpYAML;
  14 using namespace llvm::minidump;
  15
  16 /// Perform an optional yaml-mapping of an endian-aware type EndianType. The
  17 /// only purpose of this function is to avoid casting the Default value to the
  18 /// endian type;
  19 template <typename EndianType>
  20 static inline void mapOptional(yaml::IO &IO, const char *Key, EndianType &Val,
  21                                typename EndianType::value_type Default) {
  22   IO.mapOptional(Key, Val, EndianType(Default));
  23 }
  24
  25 /// Yaml-map an endian-aware type EndianType as some other type MapType.
  26 template <typename MapType, typename EndianType>
  27 static inline void mapRequiredAs(yaml::IO &IO, const char *Key,
  28                                  EndianType &Val) {
  29   MapType Mapped = static_cast<typename EndianType::value_type>(Val);
  30   IO.mapRequired(Key, Mapped);
  31   Val = static_cast<typename EndianType::value_type>(Mapped);
  32 }
  33
  34 /// Perform an optional yaml-mapping of an endian-aware type EndianType as some
  35 /// other type MapType.
  36 template <typename MapType, typename EndianType>
  37 static inline void mapOptionalAs(yaml::IO &IO, const char *Key, EndianType &Val,
  38                                  MapType Default) {
  39   MapType Mapped = static_cast<typename EndianType::value_type>(Val);
  40   IO.mapOptional(Key, Mapped, Default);
  41   Val = static_cast<typename EndianType::value_type>(Mapped);
  42 }
  43
  44 namespace {
  45 /// Return the appropriate yaml Hex type for a given endian-aware type.
  46 template <typename EndianType> struct HexType;
  47 template <> struct HexType<support::ulittle16_t> { using type = yaml::Hex16; };
  48 template <> struct HexType<support::ulittle32_t> { using type = yaml::Hex32; };
  49 template <> struct HexType<support::ulittle64_t> { using type = yaml::Hex64; };
  50 } // namespace
  51
  52 /// Yaml-map an endian-aware type as an appropriately-sized hex value.
  53 template <typename EndianType>
  54 static inline void mapRequiredHex(yaml::IO &IO, const char *Key,
  55                                   EndianType &Val) {
  56   mapRequiredAs<typename HexType<EndianType>::type>(IO, Key, Val);
  57 }
  58
  59 /// Perform an optional yaml-mapping of an endian-aware type as an
  60 /// appropriately-sized hex value.
  61 template <typename EndianType>
  62 static inline void mapOptionalHex(yaml::IO &IO, const char *Key,
  63                                   EndianType &Val,
  64                                   typename EndianType::value_type Default) {
  65   mapOptionalAs<typename HexType<EndianType>::type>(IO, Key, Val, Default);
  66 }
  67
  68 Stream::~Stream() = default;
  69
  70 Stream::StreamKind Stream::getKind(StreamType Type) {
  71   switch (Type) {
  72   case StreamType::MemoryList:
  73     return StreamKind::MemoryList;
  74   case StreamType::ModuleList:
  75     return StreamKind::ModuleList;
  76   case StreamType::SystemInfo:
  77     return StreamKind::SystemInfo;
  78   case StreamType::LinuxCPUInfo:
  79   case StreamType::LinuxProcStatus:
  80   case StreamType::LinuxLSBRelease:
  81   case StreamType::LinuxCMDLine:
  82   case StreamType::LinuxMaps:
  83   case StreamType::LinuxProcStat:
  84   case StreamType::LinuxProcUptime:
  85     return StreamKind::TextContent;
  86   case StreamType::ThreadList:
  87     return StreamKind::ThreadList;
  88   default:
  89     return StreamKind::RawContent;
  90   }
  91 }
  92
  93 std::unique_ptr<Stream> Stream::create(StreamType Type) {
  94   StreamKind Kind = getKind(Type);
  95   switch (Kind) {
  96   case StreamKind::MemoryList:
  97     return std::make_unique<MemoryListStream>();
  98   case StreamKind::ModuleList:
  99     return std::make_unique<ModuleListStream>();
 100   case StreamKind::RawContent:
 101     return std::make_unique<RawContentStream>(Type);
 102   case StreamKind::SystemInfo:
 103     return std::make_unique<SystemInfoStream>();
 104   case StreamKind::TextContent:
 105     return std::make_unique<TextContentStream>(Type);
 106   case StreamKind::ThreadList:
 107     return std::make_unique<ThreadListStream>();
 108   }
 109   llvm_unreachable("Unhandled stream kind!");
 110 }
 111
 112 void yaml::ScalarEnumerationTraits<ProcessorArchitecture>::enumeration(
 113     IO &IO, ProcessorArchitecture &Arch) {
 114 #define HANDLE_MDMP_ARCH(CODE, NAME)                                           \
 115   IO.enumCase(Arch, #NAME, ProcessorArchitecture::NAME);
 116 #include "llvm/BinaryFormat/MinidumpConstants.def"
 117   IO.enumFallback<Hex16>(Arch);
 118 }
 119
 120 void yaml::ScalarEnumerationTraits<OSPlatform>::enumeration(IO &IO,
 121                                                             OSPlatform &Plat) {
 122 #define HANDLE_MDMP_PLATFORM(CODE, NAME)                                       \
 123   IO.enumCase(Plat, #NAME, OSPlatform::NAME);
 124 #include "llvm/BinaryFormat/MinidumpConstants.def"
 125   IO.enumFallback<Hex32>(Plat);
 126 }
 127
 128 void yaml::ScalarEnumerationTraits<StreamType>::enumeration(IO &IO,
 129                                                             StreamType &Type) {
 130 #define HANDLE_MDMP_STREAM_TYPE(CODE, NAME)                                    \
 131   IO.enumCase(Type, #NAME, StreamType::NAME);
 132 #include "llvm/BinaryFormat/MinidumpConstants.def"
 133   IO.enumFallback<Hex32>(Type);
 134 }
 135
 136 void yaml::MappingTraits<CPUInfo::ArmInfo>::mapping(IO &IO,
 137                                                     CPUInfo::ArmInfo &Info) {
 138   mapRequiredHex(IO, "CPUID", Info.CPUID);
 139   mapOptionalHex(IO, "ELF hwcaps", Info.ElfHWCaps, 0);
 140 }
 141
 142 namespace {
 143 template <std::size_t N> struct FixedSizeHex {
 144   FixedSizeHex(uint8_t (&Storage)[N]) : Storage(Storage) {}
 145
 146   uint8_t (&Storage)[N];
 147 };
 148 } // namespace
 149
 150 namespace llvm {
 151 namespace yaml {
 152 template <std::size_t N> struct ScalarTraits<FixedSizeHex<N>> {
 153   static void output(const FixedSizeHex<N> &Fixed, void *, raw_ostream &OS) {
 154     OS << toHex(makeArrayRef(Fixed.Storage));
 155   }
 156
 157   static StringRef input(StringRef Scalar, void *, FixedSizeHex<N> &Fixed) {
 158     if (!all_of(Scalar, isHexDigit))
 159       return "Invalid hex digit in input";
 160     if (Scalar.size() < 2 * N)
 161       return "String too short";
 162     if (Scalar.size() > 2 * N)
 163       return "String too long";
 164     copy(fromHex(Scalar), Fixed.Storage);
 165     return "";
 166   }
 167
 168   static QuotingType mustQuote(StringRef S) { return QuotingType::None; }
 169 };
 170 } // namespace yaml
 171 } // namespace llvm
 172 void yaml::MappingTraits<CPUInfo::OtherInfo>::mapping(
 173     IO &IO, CPUInfo::OtherInfo &Info) {
 174   FixedSizeHex<sizeof(Info.ProcessorFeatures)> Features(Info.ProcessorFeatures);
 175   IO.mapRequired("Features", Features);
 176 }
 177
 178 namespace {
 179 /// A type which only accepts strings of a fixed size for yaml conversion.
 180 template <std::size_t N> struct FixedSizeString {
 181   FixedSizeString(char (&Storage)[N]) : Storage(Storage) {}
 182
 183   char (&Storage)[N];
 184 };
 185 } // namespace
 186
 187 namespace llvm {
 188 namespace yaml {
 189 template <std::size_t N> struct ScalarTraits<FixedSizeString<N>> {
 190   static void output(const FixedSizeString<N> &Fixed, void *, raw_ostream &OS) {
 191     OS << StringRef(Fixed.Storage, N);
 192   }
 193
 194   static StringRef input(StringRef Scalar, void *, FixedSizeString<N> &Fixed) {
 195     if (Scalar.size() < N)
 196       return "String too short";
 197     if (Scalar.size() > N)
 198       return "String too long";
 199     copy(Scalar, Fixed.Storage);
 200     return "";
 201   }
 202
 203   static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
 204 };
 205 } // namespace yaml
 206 } // namespace llvm
 207
 208 void yaml::MappingTraits<CPUInfo::X86Info>::mapping(IO &IO,
 209                                                     CPUInfo::X86Info &Info) {
 210   FixedSizeString<sizeof(Info.VendorID)> VendorID(Info.VendorID);
 211   IO.mapRequired("Vendor ID", VendorID);
 212
 213   mapRequiredHex(IO, "Version Info", Info.VersionInfo);
 214   mapRequiredHex(IO, "Feature Info", Info.FeatureInfo);
 215   mapOptionalHex(IO, "AMD Extended Features", Info.AMDExtendedFeatures, 0);
 216 }
 217
 218 void yaml::MappingTraits<VSFixedFileInfo>::mapping(IO &IO,
 219                                                    VSFixedFileInfo &Info) {
 220   mapOptionalHex(IO, "Signature", Info.Signature, 0);
 221   mapOptionalHex(IO, "Struct Version", Info.StructVersion, 0);
 222   mapOptionalHex(IO, "File Version High", Info.FileVersionHigh, 0);
 223   mapOptionalHex(IO, "File Version Low", Info.FileVersionLow, 0);
 224   mapOptionalHex(IO, "Product Version High", Info.ProductVersionHigh, 0);
 225   mapOptionalHex(IO, "Product Version Low", Info.ProductVersionLow, 0);
 226   mapOptionalHex(IO, "File Flags Mask", Info.FileFlagsMask, 0);
 227   mapOptionalHex(IO, "File Flags", Info.FileFlags, 0);
 228   mapOptionalHex(IO, "File OS", Info.FileOS, 0);
 229   mapOptionalHex(IO, "File Type", Info.FileType, 0);
 230   mapOptionalHex(IO, "File Subtype", Info.FileSubtype, 0);
 231   mapOptionalHex(IO, "File Date High", Info.FileDateHigh, 0);
 232   mapOptionalHex(IO, "File Date Low", Info.FileDateLow, 0);
 233 }
 234
 235 void yaml::MappingTraits<ModuleListStream::entry_type>::mapping(
 236     IO &IO, ModuleListStream::entry_type &M) {
 237   mapRequiredHex(IO, "Base of Image", M.Entry.BaseOfImage);
 238   mapRequiredHex(IO, "Size of Image", M.Entry.SizeOfImage);
 239   mapOptionalHex(IO, "Checksum", M.Entry.Checksum, 0);
 240   IO.mapOptional("Time Date Stamp", M.Entry.TimeDateStamp,
 241                  support::ulittle32_t(0));
 242   IO.mapRequired("Module Name", M.Name);
 243   IO.mapOptional("Version Info", M.Entry.VersionInfo, VSFixedFileInfo());
 244   IO.mapRequired("CodeView Record", M.CvRecord);
 245   IO.mapOptional("Misc Record", M.MiscRecord, yaml::BinaryRef());
 246   mapOptionalHex(IO, "Reserved0", M.Entry.Reserved0, 0);
 247   mapOptionalHex(IO, "Reserved1", M.Entry.Reserved1, 0);
 248 }
 249
 250 static void streamMapping(yaml::IO &IO, RawContentStream &Stream) {
 251   IO.mapOptional("Content", Stream.Content);
 252   IO.mapOptional("Size", Stream.Size, Stream.Content.binary_size());
 253 }
 254
 255 static StringRef streamValidate(RawContentStream &Stream) {
 256   if (Stream.Size.value < Stream.Content.binary_size())
 257     return "Stream size must be greater or equal to the content size";
 258   return "";
 259 }
 260
 261 void yaml::MappingTraits<MemoryListStream::entry_type>::mapping(
 262     IO &IO, MemoryListStream::entry_type &Range) {
 263   MappingContextTraits<MemoryDescriptor, yaml::BinaryRef>::mapping(
 264       IO, Range.Entry, Range.Content);
 265 }
 266
 267 static void streamMapping(yaml::IO &IO, MemoryListStream &Stream) {
 268   IO.mapRequired("Memory Ranges", Stream.Entries);
 269 }
 270
 271 static void streamMapping(yaml::IO &IO, ModuleListStream &Stream) {
 272   IO.mapRequired("Modules", Stream.Entries);
 273 }
 274
 275 static void streamMapping(yaml::IO &IO, SystemInfoStream &Stream) {
 276   SystemInfo &Info = Stream.Info;
 277   IO.mapRequired("Processor Arch", Info.ProcessorArch);
 278   mapOptional(IO, "Processor Level", Info.ProcessorLevel, 0);
 279   mapOptional(IO, "Processor Revision", Info.ProcessorRevision, 0);
 280   IO.mapOptional("Number of Processors", Info.NumberOfProcessors, 0);
 281   IO.mapOptional("Product type", Info.ProductType, 0);
 282   mapOptional(IO, "Major Version", Info.MajorVersion, 0);
 283   mapOptional(IO, "Minor Version", Info.MinorVersion, 0);
 284   mapOptional(IO, "Build Number", Info.BuildNumber, 0);
 285   IO.mapRequired("Platform ID", Info.PlatformId);
 286   IO.mapOptional("CSD Version", Stream.CSDVersion, "");
 287   mapOptionalHex(IO, "Suite Mask", Info.SuiteMask, 0);
 288   mapOptionalHex(IO, "Reserved", Info.Reserved, 0);
 289   switch (static_cast<ProcessorArchitecture>(Info.ProcessorArch)) {
 290   case ProcessorArchitecture::X86:
 291   case ProcessorArchitecture::AMD64:
 292     IO.mapOptional("CPU", Info.CPU.X86);
 293     break;
 294   case ProcessorArchitecture::ARM:
 295   case ProcessorArchitecture::ARM64:
 296     IO.mapOptional("CPU", Info.CPU.Arm);
 297     break;
 298   default:
 299     IO.mapOptional("CPU", Info.CPU.Other);
 300     break;
 301   }
 302 }
 303
 304 static void streamMapping(yaml::IO &IO, TextContentStream &Stream) {
 305   IO.mapOptional("Text", Stream.Text);
 306 }
 307
 308 void yaml::MappingContextTraits<MemoryDescriptor, yaml::BinaryRef>::mapping(
 309     IO &IO, MemoryDescriptor &Memory, BinaryRef &Content) {
 310   mapRequiredHex(IO, "Start of Memory Range", Memory.StartOfMemoryRange);
 311   IO.mapRequired("Content", Content);
 312 }
 313
 314 void yaml::MappingTraits<ThreadListStream::entry_type>::mapping(
 315     IO &IO, ThreadListStream::entry_type &T) {
 316   mapRequiredHex(IO, "Thread Id", T.Entry.ThreadId);
 317   mapOptionalHex(IO, "Suspend Count", T.Entry.SuspendCount, 0);
 318   mapOptionalHex(IO, "Priority Class", T.Entry.PriorityClass, 0);
 319   mapOptionalHex(IO, "Priority", T.Entry.Priority, 0);
 320   mapOptionalHex(IO, "Environment Block", T.Entry.EnvironmentBlock, 0);
 321   IO.mapRequired("Context", T.Context);
 322   IO.mapRequired("Stack", T.Entry.Stack, T.Stack);
 323 }
 324
 325 static void streamMapping(yaml::IO &IO, ThreadListStream &Stream) {
 326   IO.mapRequired("Threads", Stream.Entries);
 327 }
 328
 329 void yaml::MappingTraits<std::unique_ptr<Stream>>::mapping(
 330     yaml::IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S) {
 331   StreamType Type;
 332   if (IO.outputting())
 333     Type = S->Type;
 334   IO.mapRequired("Type", Type);
 335
 336   if (!IO.outputting())
 337     S = MinidumpYAML::Stream::create(Type);
 338   switch (S->Kind) {
 339   case MinidumpYAML::Stream::StreamKind::MemoryList:
 340     streamMapping(IO, llvm::cast<MemoryListStream>(*S));
 341     break;
 342   case MinidumpYAML::Stream::StreamKind::ModuleList:
 343     streamMapping(IO, llvm::cast<ModuleListStream>(*S));
 344     break;
 345   case MinidumpYAML::Stream::StreamKind::RawContent:
 346     streamMapping(IO, llvm::cast<RawContentStream>(*S));
 347     break;
 348   case MinidumpYAML::Stream::StreamKind::SystemInfo:
 349     streamMapping(IO, llvm::cast<SystemInfoStream>(*S));
 350     break;
 351   case MinidumpYAML::Stream::StreamKind::TextContent:
 352     streamMapping(IO, llvm::cast<TextContentStream>(*S));
 353     break;
 354   case MinidumpYAML::Stream::StreamKind::ThreadList:
 355     streamMapping(IO, llvm::cast<ThreadListStream>(*S));
 356     break;
 357   }
 358 }
 359
 360 StringRef yaml::MappingTraits<std::unique_ptr<Stream>>::validate(
 361     yaml::IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S) {
 362   switch (S->Kind) {
 363   case MinidumpYAML::Stream::StreamKind::RawContent:
 364     return streamValidate(cast<RawContentStream>(*S));
 365   case MinidumpYAML::Stream::StreamKind::MemoryList:
 366   case MinidumpYAML::Stream::StreamKind::ModuleList:
 367   case MinidumpYAML::Stream::StreamKind::SystemInfo:
 368   case MinidumpYAML::Stream::StreamKind::TextContent:
 369   case MinidumpYAML::Stream::StreamKind::ThreadList:
 370     return "";
 371   }
 372   llvm_unreachable("Fully covered switch above!");
 373 }
 374
 375 void yaml::MappingTraits<Object>::mapping(IO &IO, Object &O) {
 376   IO.mapTag("!minidump", true);
 377   mapOptionalHex(IO, "Signature", O.Header.Signature, Header::MagicSignature);
 378   mapOptionalHex(IO, "Version", O.Header.Version, Header::MagicVersion);
 379   mapOptionalHex(IO, "Flags", O.Header.Flags, 0);
 380   IO.mapRequired("Streams", O.Streams);
 381 }
 382
 383 Expected<std::unique_ptr<Stream>>
 384 Stream::create(const Directory &StreamDesc, const object::MinidumpFile &File) {
 385   StreamKind Kind = getKind(StreamDesc.Type);
 386   switch (Kind) {
 387   case StreamKind::MemoryList: {
 388     auto ExpectedList = File.getMemoryList();
 389     if (!ExpectedList)
 390       return ExpectedList.takeError();
 391     std::vector<MemoryListStream::entry_type> Ranges;
 392     for (const MemoryDescriptor &MD : *ExpectedList) {
 393       auto ExpectedContent = File.getRawData(MD.Memory);
 394       if (!ExpectedContent)
 395         return ExpectedContent.takeError();
 396       Ranges.push_back({MD, *ExpectedContent});
 397     }
 398     return std::make_unique<MemoryListStream>(std::move(Ranges));
 399   }
 400   case StreamKind::ModuleList: {
 401     auto ExpectedList = File.getModuleList();
 402     if (!ExpectedList)
 403       return ExpectedList.takeError();
 404     std::vector<ModuleListStream::entry_type> Modules;
 405     for (const Module &M : *ExpectedList) {
 406       auto ExpectedName = File.getString(M.ModuleNameRVA);
 407       if (!ExpectedName)
 408         return ExpectedName.takeError();
 409       auto ExpectedCv = File.getRawData(M.CvRecord);
 410       if (!ExpectedCv)
 411         return ExpectedCv.takeError();
 412       auto ExpectedMisc = File.getRawData(M.MiscRecord);
 413       if (!ExpectedMisc)
 414         return ExpectedMisc.takeError();
 415       Modules.push_back(
 416           {M, std::move(*ExpectedName), *ExpectedCv, *ExpectedMisc});
 417     }
 418     return std::make_unique<ModuleListStream>(std::move(Modules));
 419   }
 420   case StreamKind::RawContent:
 421     return std::make_unique<RawContentStream>(StreamDesc.Type,
 422                                                File.getRawStream(StreamDesc));
 423   case StreamKind::SystemInfo: {
 424     auto ExpectedInfo = File.getSystemInfo();
 425     if (!ExpectedInfo)
 426       return ExpectedInfo.takeError();
 427     auto ExpectedCSDVersion = File.getString(ExpectedInfo->CSDVersionRVA);
 428     if (!ExpectedCSDVersion)
 429       return ExpectedInfo.takeError();
 430     return std::make_unique<SystemInfoStream>(*ExpectedInfo,
 431                                                std::move(*ExpectedCSDVersion));
 432   }
 433   case StreamKind::TextContent:
 434     return std::make_unique<TextContentStream>(
 435         StreamDesc.Type, toStringRef(File.getRawStream(StreamDesc)));
 436   case StreamKind::ThreadList: {
 437     auto ExpectedList = File.getThreadList();
 438     if (!ExpectedList)
 439       return ExpectedList.takeError();
 440     std::vector<ThreadListStream::entry_type> Threads;
 441     for (const Thread &T : *ExpectedList) {
 442       auto ExpectedStack = File.getRawData(T.Stack.Memory);
 443       if (!ExpectedStack)
 444         return ExpectedStack.takeError();
 445       auto ExpectedContext = File.getRawData(T.Context);
 446       if (!ExpectedContext)
 447         return ExpectedContext.takeError();
 448       Threads.push_back({T, *ExpectedStack, *ExpectedContext});
 449     }
 450     return std::make_unique<ThreadListStream>(std::move(Threads));
 451   }
 452   }
 453   llvm_unreachable("Unhandled stream kind!");
 454 }
 455
 456 Expected<Object> Object::create(const object::MinidumpFile &File) {
 457   std::vector<std::unique_ptr<Stream>> Streams;
 458   Streams.reserve(File.streams().size());
 459   for (const Directory &StreamDesc : File.streams()) {
 460     auto ExpectedStream = Stream::create(StreamDesc, File);
 461     if (!ExpectedStream)
 462       return ExpectedStream.takeError();
 463     Streams.push_back(std::move(*ExpectedStream));
 464   }
 465   return Object(File.header(), std::move(Streams));
 466 }