LLVM  6.0.0svn
MappedBlockStream.cpp
Go to the documentation of this file.
1 //===- MappedBlockStream.cpp - Reads stream data from an MSF file ---------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
11 #include "llvm/ADT/ArrayRef.h"
12 #include "llvm/ADT/STLExtras.h"
15 #include "llvm/Support/Endian.h"
16 #include "llvm/Support/Error.h"
18 #include <algorithm>
19 #include <cassert>
20 #include <cstdint>
21 #include <cstring>
22 #include <utility>
23 #include <vector>
24 
25 using namespace llvm;
26 using namespace llvm::msf;
27 
28 namespace {
29 
30 template <typename Base> class MappedBlockStreamImpl : public Base {
31 public:
32  template <typename... Args>
33  MappedBlockStreamImpl(Args &&... Params)
34  : Base(std::forward<Args>(Params)...) {}
35 };
36 
37 } // end anonymous namespace
38 
39 using Interval = std::pair<uint32_t, uint32_t>;
40 
41 static Interval intersect(const Interval &I1, const Interval &I2) {
42  return std::make_pair(std::max(I1.first, I2.first),
43  std::min(I1.second, I2.second));
44 }
45 
47  const MSFStreamLayout &Layout,
48  BinaryStreamRef MsfData,
50  : BlockSize(BlockSize), StreamLayout(Layout), MsfData(MsfData),
51  Allocator(Allocator) {}
52 
53 std::unique_ptr<MappedBlockStream> MappedBlockStream::createStream(
54  uint32_t BlockSize, const MSFStreamLayout &Layout, BinaryStreamRef MsfData,
55  BumpPtrAllocator &Allocator) {
56  return llvm::make_unique<MappedBlockStreamImpl<MappedBlockStream>>(
57  BlockSize, Layout, MsfData, Allocator);
58 }
59 
60 std::unique_ptr<MappedBlockStream> MappedBlockStream::createIndexedStream(
61  const MSFLayout &Layout, BinaryStreamRef MsfData, uint32_t StreamIndex,
62  BumpPtrAllocator &Allocator) {
63  assert(StreamIndex < Layout.StreamMap.size() && "Invalid stream index");
64  MSFStreamLayout SL;
65  SL.Blocks = Layout.StreamMap[StreamIndex];
66  SL.Length = Layout.StreamSizes[StreamIndex];
67  return llvm::make_unique<MappedBlockStreamImpl<MappedBlockStream>>(
68  Layout.SB->BlockSize, SL, MsfData, Allocator);
69 }
70 
71 std::unique_ptr<MappedBlockStream>
73  BinaryStreamRef MsfData,
74  BumpPtrAllocator &Allocator) {
75  MSFStreamLayout SL;
76  SL.Blocks = Layout.DirectoryBlocks;
77  SL.Length = Layout.SB->NumDirectoryBytes;
78  return createStream(Layout.SB->BlockSize, SL, MsfData, Allocator);
79 }
80 
81 std::unique_ptr<MappedBlockStream>
83  BinaryStreamRef MsfData,
84  BumpPtrAllocator &Allocator) {
86  return createStream(Layout.SB->BlockSize, SL, MsfData, Allocator);
87 }
88 
90  ArrayRef<uint8_t> &Buffer) {
91  // Make sure we aren't trying to read beyond the end of the stream.
92  if (auto EC = checkOffset(Offset, Size))
93  return EC;
94 
95  if (tryReadContiguously(Offset, Size, Buffer))
96  return Error::success();
97 
98  auto CacheIter = CacheMap.find(Offset);
99  if (CacheIter != CacheMap.end()) {
100  // Try to find an alloc that was large enough for this request.
101  for (auto &Entry : CacheIter->second) {
102  if (Entry.size() >= Size) {
103  Buffer = Entry.slice(0, Size);
104  return Error::success();
105  }
106  }
107  }
108 
109  // We couldn't find a buffer that started at the correct offset (the most
110  // common scenario). Try to see if there is a buffer that starts at some
111  // other offset but overlaps the desired range.
112  for (auto &CacheItem : CacheMap) {
113  Interval RequestExtent = std::make_pair(Offset, Offset + Size);
114 
115  // We already checked this one on the fast path above.
116  if (CacheItem.first == Offset)
117  continue;
118  // If the initial extent of the cached item is beyond the ending extent
119  // of the request, there is no overlap.
120  if (CacheItem.first >= Offset + Size)
121  continue;
122 
123  // We really only have to check the last item in the list, since we append
124  // in order of increasing length.
125  if (CacheItem.second.empty())
126  continue;
127 
128  auto CachedAlloc = CacheItem.second.back();
129  // If the initial extent of the request is beyond the ending extent of
130  // the cached item, there is no overlap.
131  Interval CachedExtent =
132  std::make_pair(CacheItem.first, CacheItem.first + CachedAlloc.size());
133  if (RequestExtent.first >= CachedExtent.first + CachedExtent.second)
134  continue;
135 
136  Interval Intersection = intersect(CachedExtent, RequestExtent);
137  // Only use this if the entire request extent is contained in the cached
138  // extent.
139  if (Intersection != RequestExtent)
140  continue;
141 
142  uint32_t CacheRangeOffset =
143  AbsoluteDifference(CachedExtent.first, Intersection.first);
144  Buffer = CachedAlloc.slice(CacheRangeOffset, Size);
145  return Error::success();
146  }
147 
148  // Otherwise allocate a large enough buffer in the pool, memcpy the data
149  // into it, and return an ArrayRef to that. Do not touch existing pool
150  // allocations, as existing clients may be holding a pointer which must
151  // not be invalidated.
152  uint8_t *WriteBuffer = static_cast<uint8_t *>(Allocator.Allocate(Size, 8));
153  if (auto EC = readBytes(Offset, MutableArrayRef<uint8_t>(WriteBuffer, Size)))
154  return EC;
155 
156  if (CacheIter != CacheMap.end()) {
157  CacheIter->second.emplace_back(WriteBuffer, Size);
158  } else {
159  std::vector<CacheEntry> List;
160  List.emplace_back(WriteBuffer, Size);
161  CacheMap.insert(std::make_pair(Offset, List));
162  }
163  Buffer = ArrayRef<uint8_t>(WriteBuffer, Size);
164  return Error::success();
165 }
166 
168  ArrayRef<uint8_t> &Buffer) {
169  // Make sure we aren't trying to read beyond the end of the stream.
170  if (auto EC = checkOffset(Offset, 1))
171  return EC;
172 
173  uint32_t First = Offset / BlockSize;
174  uint32_t Last = First;
175 
176  while (Last < getNumBlocks() - 1) {
177  if (StreamLayout.Blocks[Last] != StreamLayout.Blocks[Last + 1] - 1)
178  break;
179  ++Last;
180  }
181 
182  uint32_t OffsetInFirstBlock = Offset % BlockSize;
183  uint32_t BytesFromFirstBlock = BlockSize - OffsetInFirstBlock;
184  uint32_t BlockSpan = Last - First + 1;
185  uint32_t ByteSpan = BytesFromFirstBlock + (BlockSpan - 1) * BlockSize;
186 
187  ArrayRef<uint8_t> BlockData;
188  uint32_t MsfOffset = blockToOffset(StreamLayout.Blocks[First], BlockSize);
189  if (auto EC = MsfData.readBytes(MsfOffset, BlockSize, BlockData))
190  return EC;
191 
192  BlockData = BlockData.drop_front(OffsetInFirstBlock);
193  Buffer = ArrayRef<uint8_t>(BlockData.data(), ByteSpan);
194  return Error::success();
195 }
196 
197 uint32_t MappedBlockStream::getLength() { return StreamLayout.Length; }
198 
199 bool MappedBlockStream::tryReadContiguously(uint32_t Offset, uint32_t Size,
200  ArrayRef<uint8_t> &Buffer) {
201  if (Size == 0) {
202  Buffer = ArrayRef<uint8_t>();
203  return true;
204  }
205  // Attempt to fulfill the request with a reference directly into the stream.
206  // This can work even if the request crosses a block boundary, provided that
207  // all subsequent blocks are contiguous. For example, a 10k read with a 4k
208  // block size can be filled with a reference if, from the starting offset,
209  // 3 blocks in a row are contiguous.
210  uint32_t BlockNum = Offset / BlockSize;
211  uint32_t OffsetInBlock = Offset % BlockSize;
212  uint32_t BytesFromFirstBlock = std::min(Size, BlockSize - OffsetInBlock);
213  uint32_t NumAdditionalBlocks =
214  alignTo(Size - BytesFromFirstBlock, BlockSize) / BlockSize;
215 
216  uint32_t RequiredContiguousBlocks = NumAdditionalBlocks + 1;
217  uint32_t E = StreamLayout.Blocks[BlockNum];
218  for (uint32_t I = 0; I < RequiredContiguousBlocks; ++I, ++E) {
219  if (StreamLayout.Blocks[I + BlockNum] != E)
220  return false;
221  }
222 
223  // Read out the entire block where the requested offset starts. Then drop
224  // bytes from the beginning so that the actual starting byte lines up with
225  // the requested starting byte. Then, since we know this is a contiguous
226  // cross-block span, explicitly resize the ArrayRef to cover the entire
227  // request length.
228  ArrayRef<uint8_t> BlockData;
229  uint32_t FirstBlockAddr = StreamLayout.Blocks[BlockNum];
230  uint32_t MsfOffset = blockToOffset(FirstBlockAddr, BlockSize);
231  if (auto EC = MsfData.readBytes(MsfOffset, BlockSize, BlockData)) {
232  consumeError(std::move(EC));
233  return false;
234  }
235  BlockData = BlockData.drop_front(OffsetInBlock);
236  Buffer = ArrayRef<uint8_t>(BlockData.data(), Size);
237  return true;
238 }
239 
241  MutableArrayRef<uint8_t> Buffer) {
242  uint32_t BlockNum = Offset / BlockSize;
243  uint32_t OffsetInBlock = Offset % BlockSize;
244 
245  // Make sure we aren't trying to read beyond the end of the stream.
246  if (auto EC = checkOffset(Offset, Buffer.size()))
247  return EC;
248 
249  uint32_t BytesLeft = Buffer.size();
250  uint32_t BytesWritten = 0;
251  uint8_t *WriteBuffer = Buffer.data();
252  while (BytesLeft > 0) {
253  uint32_t StreamBlockAddr = StreamLayout.Blocks[BlockNum];
254 
255  ArrayRef<uint8_t> BlockData;
256  uint32_t Offset = blockToOffset(StreamBlockAddr, BlockSize);
257  if (auto EC = MsfData.readBytes(Offset, BlockSize, BlockData))
258  return EC;
259 
260  const uint8_t *ChunkStart = BlockData.data() + OffsetInBlock;
261  uint32_t BytesInChunk = std::min(BytesLeft, BlockSize - OffsetInBlock);
262  ::memcpy(WriteBuffer + BytesWritten, ChunkStart, BytesInChunk);
263 
264  BytesWritten += BytesInChunk;
265  BytesLeft -= BytesInChunk;
266  ++BlockNum;
267  OffsetInBlock = 0;
268  }
269 
270  return Error::success();
271 }
272 
273 void MappedBlockStream::invalidateCache() { CacheMap.shrink_and_clear(); }
274 
275 void MappedBlockStream::fixCacheAfterWrite(uint32_t Offset,
276  ArrayRef<uint8_t> Data) const {
277  // If this write overlapped a read which previously came from the pool,
278  // someone may still be holding a pointer to that alloc which is now invalid.
279  // Compute the overlapping range and update the cache entry, so any
280  // outstanding buffers are automatically updated.
281  for (const auto &MapEntry : CacheMap) {
282  // If the end of the written extent precedes the beginning of the cached
283  // extent, ignore this map entry.
284  if (Offset + Data.size() < MapEntry.first)
285  continue;
286  for (const auto &Alloc : MapEntry.second) {
287  // If the end of the cached extent precedes the beginning of the written
288  // extent, ignore this alloc.
289  if (MapEntry.first + Alloc.size() < Offset)
290  continue;
291 
292  // If we get here, they are guaranteed to overlap.
293  Interval WriteInterval = std::make_pair(Offset, Offset + Data.size());
294  Interval CachedInterval =
295  std::make_pair(MapEntry.first, MapEntry.first + Alloc.size());
296  // If they overlap, we need to write the new data into the overlapping
297  // range.
298  auto Intersection = intersect(WriteInterval, CachedInterval);
299  assert(Intersection.first <= Intersection.second);
300 
301  uint32_t Length = Intersection.second - Intersection.first;
302  uint32_t SrcOffset =
303  AbsoluteDifference(WriteInterval.first, Intersection.first);
304  uint32_t DestOffset =
305  AbsoluteDifference(CachedInterval.first, Intersection.first);
306  ::memcpy(Alloc.data() + DestOffset, Data.data() + SrcOffset, Length);
307  }
308  }
309 }
310 
312  uint32_t BlockSize, const MSFStreamLayout &Layout,
313  WritableBinaryStreamRef MsfData, BumpPtrAllocator &Allocator)
314  : ReadInterface(BlockSize, Layout, MsfData, Allocator),
315  WriteInterface(MsfData) {}
316 
317 std::unique_ptr<WritableMappedBlockStream>
319  const MSFStreamLayout &Layout,
320  WritableBinaryStreamRef MsfData,
322  return llvm::make_unique<MappedBlockStreamImpl<WritableMappedBlockStream>>(
323  BlockSize, Layout, MsfData, Allocator);
324 }
325 
326 std::unique_ptr<WritableMappedBlockStream>
328  WritableBinaryStreamRef MsfData,
329  uint32_t StreamIndex,
331  assert(StreamIndex < Layout.StreamMap.size() && "Invalid stream index");
332  MSFStreamLayout SL;
333  SL.Blocks = Layout.StreamMap[StreamIndex];
334  SL.Length = Layout.StreamSizes[StreamIndex];
335  return createStream(Layout.SB->BlockSize, SL, MsfData, Allocator);
336 }
337 
338 std::unique_ptr<WritableMappedBlockStream>
340  const MSFLayout &Layout, WritableBinaryStreamRef MsfData,
342  MSFStreamLayout SL;
343  SL.Blocks = Layout.DirectoryBlocks;
344  SL.Length = Layout.SB->NumDirectoryBytes;
345  return createStream(Layout.SB->BlockSize, SL, MsfData, Allocator);
346 }
347 
348 std::unique_ptr<WritableMappedBlockStream>
350  WritableBinaryStreamRef MsfData,
352  bool AltFpm) {
353  // We only want to give the user a stream containing the bytes of the FPM that
354  // are actually valid, but we want to initialize all of the bytes, even those
355  // that come from reserved FPM blocks where the entire block is unused. To do
356  // this, we first create the full layout, which gives us a stream with all
357  // bytes and all blocks, and initialize everything to 0xFF (all blocks in the
358  // file are unused). Then we create the minimal layout (which contains only a
359  // subset of the bytes previously initialized), and return that to the user.
360  MSFStreamLayout MinLayout(getFpmStreamLayout(Layout, false, AltFpm));
361 
362  MSFStreamLayout FullLayout(getFpmStreamLayout(Layout, true, AltFpm));
363  auto Result =
364  createStream(Layout.SB->BlockSize, FullLayout, MsfData, Allocator);
365  if (!Result)
366  return Result;
367  std::vector<uint8_t> InitData(Layout.SB->BlockSize, 0xFF);
368  BinaryStreamWriter Initializer(*Result);
369  while (Initializer.bytesRemaining() > 0)
370  cantFail(Initializer.writeBytes(InitData));
371  return createStream(Layout.SB->BlockSize, MinLayout, MsfData, Allocator);
372 }
373 
375  ArrayRef<uint8_t> &Buffer) {
376  return ReadInterface.readBytes(Offset, Size, Buffer);
377 }
378 
380  uint32_t Offset, ArrayRef<uint8_t> &Buffer) {
381  return ReadInterface.readLongestContiguousChunk(Offset, Buffer);
382 }
383 
385  return ReadInterface.getLength();
386 }
387 
389  ArrayRef<uint8_t> Buffer) {
390  // Make sure we aren't trying to write beyond the end of the stream.
391  if (auto EC = checkOffset(Offset, Buffer.size()))
392  return EC;
393 
394  uint32_t BlockNum = Offset / getBlockSize();
395  uint32_t OffsetInBlock = Offset % getBlockSize();
396 
397  uint32_t BytesLeft = Buffer.size();
398  uint32_t BytesWritten = 0;
399  while (BytesLeft > 0) {
400  uint32_t StreamBlockAddr = getStreamLayout().Blocks[BlockNum];
401  uint32_t BytesToWriteInChunk =
402  std::min(BytesLeft, getBlockSize() - OffsetInBlock);
403 
404  const uint8_t *Chunk = Buffer.data() + BytesWritten;
405  ArrayRef<uint8_t> ChunkData(Chunk, BytesToWriteInChunk);
406  uint32_t MsfOffset = blockToOffset(StreamBlockAddr, getBlockSize());
407  MsfOffset += OffsetInBlock;
408  if (auto EC = WriteInterface.writeBytes(MsfOffset, ChunkData))
409  return EC;
410 
411  BytesLeft -= BytesToWriteInChunk;
412  BytesWritten += BytesToWriteInChunk;
413  ++BlockNum;
414  OffsetInBlock = 0;
415  }
416 
417  ReadInterface.fixCacheAfterWrite(Offset, Buffer);
418 
419  return Error::success();
420 }
421 
422 Error WritableMappedBlockStream::commit() { return WriteInterface.commit(); }
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
Definition: Error.h:688
uint32_t getLength() override
Return the number of bytes of data in this stream.
Error writeBytes(ArrayRef< uint8_t > Buffer)
Write the bytes specified in Buffer to the underlying stream.
static std::unique_ptr< WritableMappedBlockStream > createDirectoryStream(const MSFLayout &Layout, WritableBinaryStreamRef MsfData, BumpPtrAllocator &Allocator)
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
Error checkOffset(uint32_t Offset, uint32_t DataSize)
Definition: BinaryStream.h:49
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
Interval Class - An Interval is a set of nodes defined such that every node in the interval has all o...
Definition: Interval.h:37
static std::unique_ptr< WritableMappedBlockStream > createStream(uint32_t BlockSize, const MSFStreamLayout &Layout, WritableBinaryStreamRef MsfData, BumpPtrAllocator &Allocator)
uint64_t blockToOffset(uint64_t BlockNumber, uint64_t BlockSize)
Definition: MSFCommon.h:103
Error readBytes(uint32_t Offset, uint32_t Size, ArrayRef< uint8_t > &Buffer) override
Given an offset into the stream and a number of bytes, attempt to read the bytes and set the output A...
uint32_t getLength() override
Return the number of bytes of data in this stream.
Error commit() override
For buffered streams, commits changes to the backing store.
static Interval intersect(const Interval &I1, const Interval &I2)
uint64_t alignTo(uint64_t Value, uint64_t Align, uint64_t Skew=0)
Returns the next integer (mod 2**64) that is greater than or equal to Value and is a multiple of Alig...
Definition: MathExtras.h:677
Error writeBytes(uint32_t Offset, ArrayRef< uint8_t > Buffer) override
Attempt to write the given bytes into the stream at the desired offset.
Error readLongestContiguousChunk(uint32_t Offset, ArrayRef< uint8_t > &Buffer) override
Given an offset into the stream, read as much as possible without copying any data.
Definition: BitVector.h:920
Describes the layout of a stream in an MSF layout.
Definition: MSFCommon.h:68
MSFStreamLayout getFpmStreamLayout(const MSFLayout &Msf, bool IncludeUnusedFpmData=false, bool AltFpm=false)
Determine the layout of the FPM stream, given the MSF layout.
Definition: MSFCommon.cpp:63
static std::unique_ptr< MappedBlockStream > createIndexedStream(const MSFLayout &Layout, BinaryStreamRef MsfData, uint32_t StreamIndex, BumpPtrAllocator &Allocator)
const MSFStreamLayout & getStreamLayout() const
Error readLongestContiguousChunk(uint32_t Offset, ArrayRef< uint8_t > &Buffer) override
Given an offset into the stream, read as much as possible without copying any data.
std::vector< support::ulittle32_t > Blocks
Definition: MSFCommon.h:71
support::ulittle32_t BlockSize
Definition: MSFCommon.h:37
static std::unique_ptr< MappedBlockStream > createDirectoryStream(const MSFLayout &Layout, BinaryStreamRef MsfData, BumpPtrAllocator &Allocator)
Error readBytes(uint32_t Offset, uint32_t Size, ArrayRef< uint8_t > &Buffer) const
Given an Offset into this StreamRef and a Size, return a reference to a buffer owned by the stream...
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:138
static std::unique_ptr< MappedBlockStream > createFpmStream(const MSFLayout &Layout, BinaryStreamRef MsfData, BumpPtrAllocator &Allocator)
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:149
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void * Allocate(size_t Size, size_t Alignment)
Allocate space at the specified alignment.
Definition: Allocator.h:212
static std::unique_ptr< MappedBlockStream > createStream(uint32_t BlockSize, const MSFStreamLayout &Layout, BinaryStreamRef MsfData, BumpPtrAllocator &Allocator)
Provides write only access to a subclass of WritableBinaryStream.
Error readBytes(uint32_t Offset, uint32_t Size, ArrayRef< uint8_t > &Buffer) override
Given an offset into the stream and a number of bytes, attempt to read the bytes and set the output A...
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:962
const T * data() const
Definition: ArrayRef.h:146
uint32_t bytesRemaining() const
static const int BlockSize
Definition: TarWriter.cpp:34
Basic Register Allocator
Error commit()
For buffered streams, commits changes to the backing store.
static ErrorSuccess success()
Create a success value.
Definition: Error.h:313
ArrayRef< support::ulittle32_t > DirectoryBlocks
Definition: MSFCommon.h:57
BinaryStreamRef is to BinaryStream what ArrayRef is to an Array.
static std::unique_ptr< WritableMappedBlockStream > createFpmStream(const MSFLayout &Layout, WritableBinaryStreamRef MsfData, BumpPtrAllocator &Allocator, bool AltFpm=false)
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array...
Definition: ArrayRef.h:179
MappedBlockStream(uint32_t BlockSize, const MSFStreamLayout &StreamLayout, BinaryStreamRef MsfData, BumpPtrAllocator &Allocator)
static std::unique_ptr< WritableMappedBlockStream > createIndexedStream(const MSFLayout &Layout, WritableBinaryStreamRef MsfData, uint32_t StreamIndex, BumpPtrAllocator &Allocator)
ArrayRef< T > drop_front(size_t N=1) const
Drop the first N elements of the array.
Definition: ArrayRef.h:188
const NodeList & List
Definition: RDFGraph.cpp:210
WritableMappedBlockStream(uint32_t BlockSize, const MSFStreamLayout &StreamLayout, WritableBinaryStreamRef MsfData, BumpPtrAllocator &Allocator)
#define I(x, y, z)
Definition: MD5.cpp:58
std::enable_if< std::is_unsigned< T >::value, T >::type AbsoluteDifference(T X, T Y)
Subtract two unsigned integers, X and Y, of type T and return the absolute value of the result...
Definition: MathExtras.h:759
std::vector< ArrayRef< support::ulittle32_t > > StreamMap
Definition: MSFCommon.h:59
T * data() const
Definition: ArrayRef.h:329
ArrayRef< support::ulittle32_t > StreamSizes
Definition: MSFCommon.h:58
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Error writeBytes(uint32_t Offset, ArrayRef< uint8_t > Data) const
Given an Offset into this WritableBinaryStreamRef and some input data, writes the data to the underly...
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
const SuperBlock * SB
Definition: MSFCommon.h:55
support::ulittle32_t NumDirectoryBytes
Definition: MSFCommon.h:45
constexpr char Args[]
Key for Kernel::Metadata::mArgs.