blob: 403c02b42685eb64de83007c05ededf867f21f8e [file] [log] [blame]
Zachary Turnerbac69d32016-07-22 19:56:05 +00001//===- MappedBlockStream.cpp - Reads stream data from an MSF file ---------===//
Zachary Turner6ba65de2016-04-29 17:22:58 +00002//
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
Zachary Turnera3225b02016-07-29 20:56:36 +000010#include "llvm/DebugInfo/MSF/MappedBlockStream.h"
Zachary Turner199f48a2016-07-28 19:11:09 +000011
Zachary Turnera3225b02016-07-29 20:56:36 +000012#include "llvm/DebugInfo/MSF/IMSFFile.h"
13#include "llvm/DebugInfo/MSF/MSFCommon.h"
14#include "llvm/DebugInfo/MSF/MSFError.h"
15#include "llvm/DebugInfo/MSF/MSFStreamLayout.h"
Zachary Turner6ba65de2016-04-29 17:22:58 +000016
17using namespace llvm;
Zachary Turnerbac69d32016-07-22 19:56:05 +000018using namespace llvm::msf;
Zachary Turner6ba65de2016-04-29 17:22:58 +000019
Zachary Turnera1657a92016-06-08 17:26:39 +000020namespace {
Zachary Turnerd66889c2016-07-28 19:12:28 +000021template <typename Base> class MappedBlockStreamImpl : public Base {
Zachary Turnera1657a92016-06-08 17:26:39 +000022public:
Zachary Turnerd66889c2016-07-28 19:12:28 +000023 template <typename... Args>
24 MappedBlockStreamImpl(Args &&... Params)
25 : Base(std::forward<Args>(Params)...) {}
Zachary Turnera1657a92016-06-08 17:26:39 +000026};
27}
28
Zachary Turner8cf51c32016-08-03 16:53:21 +000029static void initializeFpmStreamLayout(const MSFLayout &Layout,
30 MSFStreamLayout &FpmLayout) {
31 uint32_t NumFpmIntervals = msf::getNumFpmIntervals(Layout);
32 support::ulittle32_t FpmBlock = Layout.SB->FreeBlockMapBlock;
33 assert(FpmBlock == 1 || FpmBlock == 2);
34 while (NumFpmIntervals > 0) {
35 FpmLayout.Blocks.push_back(FpmBlock);
36 FpmBlock += msf::getFpmIntervalLength(Layout);
37 --NumFpmIntervals;
38 }
39 FpmLayout.Length = msf::getFullFpmByteSize(Layout);
40}
41
Zachary Turner5acb4ac2016-06-10 05:09:12 +000042typedef std::pair<uint32_t, uint32_t> Interval;
43static Interval intersect(const Interval &I1, const Interval &I2) {
44 return std::make_pair(std::max(I1.first, I2.first),
45 std::min(I1.second, I2.second));
46}
47
Zachary Turnerd66889c2016-07-28 19:12:28 +000048MappedBlockStream::MappedBlockStream(uint32_t BlockSize, uint32_t NumBlocks,
Zachary Turnera3225b02016-07-29 20:56:36 +000049 const MSFStreamLayout &Layout,
Zachary Turnerd66889c2016-07-28 19:12:28 +000050 const ReadableStream &MsfData)
51 : BlockSize(BlockSize), NumBlocks(NumBlocks), StreamLayout(Layout),
52 MsfData(MsfData) {}
53
54std::unique_ptr<MappedBlockStream>
55MappedBlockStream::createStream(uint32_t BlockSize, uint32_t NumBlocks,
Zachary Turnera3225b02016-07-29 20:56:36 +000056 const MSFStreamLayout &Layout,
Zachary Turnerd66889c2016-07-28 19:12:28 +000057 const ReadableStream &MsfData) {
58 return llvm::make_unique<MappedBlockStreamImpl<MappedBlockStream>>(
59 BlockSize, NumBlocks, Layout, MsfData);
60}
61
62std::unique_ptr<MappedBlockStream>
Zachary Turnera3225b02016-07-29 20:56:36 +000063MappedBlockStream::createIndexedStream(const MSFLayout &Layout,
Zachary Turnerd66889c2016-07-28 19:12:28 +000064 const ReadableStream &MsfData,
65 uint32_t StreamIndex) {
Zachary Turnera3225b02016-07-29 20:56:36 +000066 MSFStreamLayout SL;
Zachary Turnerd66889c2016-07-28 19:12:28 +000067 SL.Blocks = Layout.StreamMap[StreamIndex];
68 SL.Length = Layout.StreamSizes[StreamIndex];
69 return llvm::make_unique<MappedBlockStreamImpl<MappedBlockStream>>(
70 Layout.SB->BlockSize, Layout.SB->NumBlocks, SL, MsfData);
71}
72
73std::unique_ptr<MappedBlockStream>
Zachary Turnera3225b02016-07-29 20:56:36 +000074MappedBlockStream::createDirectoryStream(const MSFLayout &Layout,
Zachary Turnerd66889c2016-07-28 19:12:28 +000075 const ReadableStream &MsfData) {
Zachary Turnera3225b02016-07-29 20:56:36 +000076 MSFStreamLayout SL;
Zachary Turnerd66889c2016-07-28 19:12:28 +000077 SL.Blocks = Layout.DirectoryBlocks;
78 SL.Length = Layout.SB->NumDirectoryBytes;
79 return createStream(Layout.SB->BlockSize, Layout.SB->NumBlocks, SL, MsfData);
80}
Zachary Turner6ba65de2016-04-29 17:22:58 +000081
Zachary Turner8cf51c32016-08-03 16:53:21 +000082std::unique_ptr<MappedBlockStream>
83MappedBlockStream::createFpmStream(const MSFLayout &Layout,
84 const ReadableStream &MsfData) {
85 MSFStreamLayout SL;
86 initializeFpmStreamLayout(Layout, SL);
87 return createStream(Layout.SB->BlockSize, Layout.SB->NumBlocks, SL, MsfData);
88}
89
Zachary Turner8dbe3622016-05-27 01:54:44 +000090Error MappedBlockStream::readBytes(uint32_t Offset, uint32_t Size,
91 ArrayRef<uint8_t> &Buffer) const {
92 // Make sure we aren't trying to read beyond the end of the stream.
Zachary Turnerd66889c2016-07-28 19:12:28 +000093 if (Size > StreamLayout.Length)
Zachary Turnera3225b02016-07-29 20:56:36 +000094 return make_error<MSFError>(msf_error_code::insufficient_buffer);
Zachary Turnerd66889c2016-07-28 19:12:28 +000095 if (Offset > StreamLayout.Length - Size)
Zachary Turnera3225b02016-07-29 20:56:36 +000096 return make_error<MSFError>(msf_error_code::insufficient_buffer);
Zachary Turner8dbe3622016-05-27 01:54:44 +000097
98 if (tryReadContiguously(Offset, Size, Buffer))
99 return Error::success();
100
101 auto CacheIter = CacheMap.find(Offset);
102 if (CacheIter != CacheMap.end()) {
Zachary Turner5acb4ac2016-06-10 05:09:12 +0000103 // Try to find an alloc that was large enough for this request.
104 for (auto &Entry : CacheIter->second) {
105 if (Entry.size() >= Size) {
106 Buffer = Entry.slice(0, Size);
107 return Error::success();
108 }
109 }
110 }
111
112 // We couldn't find a buffer that started at the correct offset (the most
113 // common scenario). Try to see if there is a buffer that starts at some
114 // other offset but overlaps the desired range.
115 for (auto &CacheItem : CacheMap) {
116 Interval RequestExtent = std::make_pair(Offset, Offset + Size);
117
118 // We already checked this one on the fast path above.
119 if (CacheItem.first == Offset)
120 continue;
121 // If the initial extent of the cached item is beyond the ending extent
122 // of the request, there is no overlap.
123 if (CacheItem.first >= Offset + Size)
124 continue;
125
126 // We really only have to check the last item in the list, since we append
127 // in order of increasing length.
128 if (CacheItem.second.empty())
129 continue;
130
131 auto CachedAlloc = CacheItem.second.back();
132 // If the initial extent of the request is beyond the ending extent of
133 // the cached item, there is no overlap.
134 Interval CachedExtent =
135 std::make_pair(CacheItem.first, CacheItem.first + CachedAlloc.size());
136 if (RequestExtent.first >= CachedExtent.first + CachedExtent.second)
137 continue;
138
139 Interval Intersection = intersect(CachedExtent, RequestExtent);
140 // Only use this if the entire request extent is contained in the cached
141 // extent.
142 if (Intersection != RequestExtent)
143 continue;
144
145 uint32_t CacheRangeOffset =
146 AbsoluteDifference(CachedExtent.first, Intersection.first);
147 Buffer = CachedAlloc.slice(CacheRangeOffset, Size);
Zachary Turner8dbe3622016-05-27 01:54:44 +0000148 return Error::success();
149 }
150
151 // Otherwise allocate a large enough buffer in the pool, memcpy the data
Zachary Turner5acb4ac2016-06-10 05:09:12 +0000152 // into it, and return an ArrayRef to that. Do not touch existing pool
153 // allocations, as existing clients may be holding a pointer which must
154 // not be invalidated.
Zachary Turner97609bb2016-06-10 21:47:26 +0000155 uint8_t *WriteBuffer = static_cast<uint8_t *>(Pool.Allocate(Size, 8));
Zachary Turner8dbe3622016-05-27 01:54:44 +0000156 if (auto EC = readBytes(Offset, MutableArrayRef<uint8_t>(WriteBuffer, Size)))
157 return EC;
Zachary Turner5acb4ac2016-06-10 05:09:12 +0000158
159 if (CacheIter != CacheMap.end()) {
160 CacheIter->second.emplace_back(WriteBuffer, Size);
161 } else {
162 std::vector<CacheEntry> List;
163 List.emplace_back(WriteBuffer, Size);
164 CacheMap.insert(std::make_pair(Offset, List));
165 }
Zachary Turner8dbe3622016-05-27 01:54:44 +0000166 Buffer = ArrayRef<uint8_t>(WriteBuffer, Size);
167 return Error::success();
168}
169
Zachary Turner5acb4ac2016-06-10 05:09:12 +0000170Error MappedBlockStream::readLongestContiguousChunk(
171 uint32_t Offset, ArrayRef<uint8_t> &Buffer) const {
172 // Make sure we aren't trying to read beyond the end of the stream.
Zachary Turnerd66889c2016-07-28 19:12:28 +0000173 if (Offset >= StreamLayout.Length)
Zachary Turnera3225b02016-07-29 20:56:36 +0000174 return make_error<MSFError>(msf_error_code::insufficient_buffer);
Zachary Turnerd66889c2016-07-28 19:12:28 +0000175 uint32_t First = Offset / BlockSize;
Zachary Turner5acb4ac2016-06-10 05:09:12 +0000176 uint32_t Last = First;
177
Zachary Turnerd66889c2016-07-28 19:12:28 +0000178 while (Last < NumBlocks - 1) {
179 if (StreamLayout.Blocks[Last] != StreamLayout.Blocks[Last + 1] - 1)
Zachary Turner5acb4ac2016-06-10 05:09:12 +0000180 break;
181 ++Last;
182 }
183
Zachary Turnerd66889c2016-07-28 19:12:28 +0000184 uint32_t OffsetInFirstBlock = Offset % BlockSize;
185 uint32_t BytesFromFirstBlock = BlockSize - OffsetInFirstBlock;
Zachary Turner5acb4ac2016-06-10 05:09:12 +0000186 uint32_t BlockSpan = Last - First + 1;
Zachary Turnerd66889c2016-07-28 19:12:28 +0000187 uint32_t ByteSpan = BytesFromFirstBlock + (BlockSpan - 1) * BlockSize;
188
189 ArrayRef<uint8_t> BlockData;
190 uint32_t MsfOffset = blockToOffset(StreamLayout.Blocks[First], BlockSize);
191 if (auto EC = MsfData.readBytes(MsfOffset, BlockSize, BlockData))
192 return EC;
193
194 BlockData = BlockData.drop_front(OffsetInFirstBlock);
195 Buffer = ArrayRef<uint8_t>(BlockData.data(), ByteSpan);
Zachary Turner5acb4ac2016-06-10 05:09:12 +0000196 return Error::success();
197}
198
Zachary Turnerd66889c2016-07-28 19:12:28 +0000199uint32_t MappedBlockStream::getLength() const { return StreamLayout.Length; }
Zachary Turnerab58ae82016-06-30 17:43:00 +0000200
Zachary Turner8dbe3622016-05-27 01:54:44 +0000201bool MappedBlockStream::tryReadContiguously(uint32_t Offset, uint32_t Size,
202 ArrayRef<uint8_t> &Buffer) const {
Zachary Turner36efbfa2016-09-09 19:00:49 +0000203 if (Size == 0) {
204 Buffer = ArrayRef<uint8_t>();
205 return true;
206 }
Zachary Turner8dbe3622016-05-27 01:54:44 +0000207 // Attempt to fulfill the request with a reference directly into the stream.
208 // This can work even if the request crosses a block boundary, provided that
209 // all subsequent blocks are contiguous. For example, a 10k read with a 4k
210 // block size can be filled with a reference if, from the starting offset,
211 // 3 blocks in a row are contiguous.
Zachary Turnerd66889c2016-07-28 19:12:28 +0000212 uint32_t BlockNum = Offset / BlockSize;
213 uint32_t OffsetInBlock = Offset % BlockSize;
214 uint32_t BytesFromFirstBlock = std::min(Size, BlockSize - OffsetInBlock);
Zachary Turner8dbe3622016-05-27 01:54:44 +0000215 uint32_t NumAdditionalBlocks =
Zachary Turnerd66889c2016-07-28 19:12:28 +0000216 llvm::alignTo(Size - BytesFromFirstBlock, BlockSize) / BlockSize;
Zachary Turner8dbe3622016-05-27 01:54:44 +0000217
218 uint32_t RequiredContiguousBlocks = NumAdditionalBlocks + 1;
Zachary Turnerd66889c2016-07-28 19:12:28 +0000219 uint32_t E = StreamLayout.Blocks[BlockNum];
Zachary Turner8dbe3622016-05-27 01:54:44 +0000220 for (uint32_t I = 0; I < RequiredContiguousBlocks; ++I, ++E) {
Zachary Turnerd66889c2016-07-28 19:12:28 +0000221 if (StreamLayout.Blocks[I + BlockNum] != E)
Zachary Turner8dbe3622016-05-27 01:54:44 +0000222 return false;
223 }
224
Zachary Turnerd66889c2016-07-28 19:12:28 +0000225 // Read out the entire block where the requested offset starts. Then drop
226 // bytes from the beginning so that the actual starting byte lines up with
227 // the requested starting byte. Then, since we know this is a contiguous
228 // cross-block span, explicitly resize the ArrayRef to cover the entire
229 // request length.
230 ArrayRef<uint8_t> BlockData;
231 uint32_t FirstBlockAddr = StreamLayout.Blocks[BlockNum];
232 uint32_t MsfOffset = blockToOffset(FirstBlockAddr, BlockSize);
233 if (auto EC = MsfData.readBytes(MsfOffset, BlockSize, BlockData)) {
234 consumeError(std::move(EC));
David Majnemer6211b1f2016-07-10 03:34:47 +0000235 return false;
236 }
Zachary Turnerd66889c2016-07-28 19:12:28 +0000237 BlockData = BlockData.drop_front(OffsetInBlock);
238 Buffer = ArrayRef<uint8_t>(BlockData.data(), Size);
Zachary Turner8dbe3622016-05-27 01:54:44 +0000239 return true;
240}
241
Zachary Turner819e77d2016-05-06 20:51:57 +0000242Error MappedBlockStream::readBytes(uint32_t Offset,
243 MutableArrayRef<uint8_t> Buffer) const {
Zachary Turnerd66889c2016-07-28 19:12:28 +0000244 uint32_t BlockNum = Offset / BlockSize;
245 uint32_t OffsetInBlock = Offset % BlockSize;
Zachary Turner6ba65de2016-04-29 17:22:58 +0000246
247 // Make sure we aren't trying to read beyond the end of the stream.
Zachary Turnerd66889c2016-07-28 19:12:28 +0000248 if (Buffer.size() > StreamLayout.Length)
Zachary Turnera3225b02016-07-29 20:56:36 +0000249 return make_error<MSFError>(msf_error_code::insufficient_buffer);
Zachary Turnerd66889c2016-07-28 19:12:28 +0000250 if (Offset > StreamLayout.Length - Buffer.size())
Zachary Turnera3225b02016-07-29 20:56:36 +0000251 return make_error<MSFError>(msf_error_code::insufficient_buffer);
Zachary Turner6ba65de2016-04-29 17:22:58 +0000252
253 uint32_t BytesLeft = Buffer.size();
254 uint32_t BytesWritten = 0;
255 uint8_t *WriteBuffer = Buffer.data();
256 while (BytesLeft > 0) {
Zachary Turnerd66889c2016-07-28 19:12:28 +0000257 uint32_t StreamBlockAddr = StreamLayout.Blocks[BlockNum];
Zachary Turner6ba65de2016-04-29 17:22:58 +0000258
Zachary Turnerd66889c2016-07-28 19:12:28 +0000259 ArrayRef<uint8_t> BlockData;
260 uint32_t Offset = blockToOffset(StreamBlockAddr, BlockSize);
261 if (auto EC = MsfData.readBytes(Offset, BlockSize, BlockData))
262 return EC;
Zachary Turner6ba65de2016-04-29 17:22:58 +0000263
Zachary Turnerd66889c2016-07-28 19:12:28 +0000264 const uint8_t *ChunkStart = BlockData.data() + OffsetInBlock;
265 uint32_t BytesInChunk = std::min(BytesLeft, BlockSize - OffsetInBlock);
Zachary Turner6ba65de2016-04-29 17:22:58 +0000266 ::memcpy(WriteBuffer + BytesWritten, ChunkStart, BytesInChunk);
267
268 BytesWritten += BytesInChunk;
269 BytesLeft -= BytesInChunk;
270 ++BlockNum;
271 OffsetInBlock = 0;
272 }
273
Zachary Turner819e77d2016-05-06 20:51:57 +0000274 return Error::success();
Zachary Turner5acb4ac2016-06-10 05:09:12 +0000275}
Zachary Turnerf5c59652016-05-03 00:28:21 +0000276
Zachary Turnerd66889c2016-07-28 19:12:28 +0000277uint32_t MappedBlockStream::getNumBytesCopied() const {
278 return static_cast<uint32_t>(Pool.getBytesAllocated());
279}
Zachary Turner5acb4ac2016-06-10 05:09:12 +0000280
Zachary Turnerd66889c2016-07-28 19:12:28 +0000281void MappedBlockStream::invalidateCache() { CacheMap.shrink_and_clear(); }
Zachary Turner5acb4ac2016-06-10 05:09:12 +0000282
Zachary Turnerd66889c2016-07-28 19:12:28 +0000283void MappedBlockStream::fixCacheAfterWrite(uint32_t Offset,
284 ArrayRef<uint8_t> Data) const {
Zachary Turner5acb4ac2016-06-10 05:09:12 +0000285 // If this write overlapped a read which previously came from the pool,
286 // someone may still be holding a pointer to that alloc which is now invalid.
287 // Compute the overlapping range and update the cache entry, so any
288 // outstanding buffers are automatically updated.
289 for (const auto &MapEntry : CacheMap) {
290 // If the end of the written extent precedes the beginning of the cached
291 // extent, ignore this map entry.
Zachary Turnerd66889c2016-07-28 19:12:28 +0000292 if (Offset + Data.size() < MapEntry.first)
Zachary Turner5acb4ac2016-06-10 05:09:12 +0000293 continue;
294 for (const auto &Alloc : MapEntry.second) {
295 // If the end of the cached extent precedes the beginning of the written
296 // extent, ignore this alloc.
297 if (MapEntry.first + Alloc.size() < Offset)
298 continue;
299
300 // If we get here, they are guaranteed to overlap.
Zachary Turnerd66889c2016-07-28 19:12:28 +0000301 Interval WriteInterval = std::make_pair(Offset, Offset + Data.size());
Zachary Turner5acb4ac2016-06-10 05:09:12 +0000302 Interval CachedInterval =
303 std::make_pair(MapEntry.first, MapEntry.first + Alloc.size());
304 // If they overlap, we need to write the new data into the overlapping
305 // range.
306 auto Intersection = intersect(WriteInterval, CachedInterval);
307 assert(Intersection.first <= Intersection.second);
308
309 uint32_t Length = Intersection.second - Intersection.first;
310 uint32_t SrcOffset =
311 AbsoluteDifference(WriteInterval.first, Intersection.first);
312 uint32_t DestOffset =
313 AbsoluteDifference(CachedInterval.first, Intersection.first);
Zachary Turnerd66889c2016-07-28 19:12:28 +0000314 ::memcpy(Alloc.data() + DestOffset, Data.data() + SrcOffset, Length);
Zachary Turner5acb4ac2016-06-10 05:09:12 +0000315 }
316 }
Zachary Turnerd66889c2016-07-28 19:12:28 +0000317}
318
319WritableMappedBlockStream::WritableMappedBlockStream(
Zachary Turnera3225b02016-07-29 20:56:36 +0000320 uint32_t BlockSize, uint32_t NumBlocks, const MSFStreamLayout &Layout,
Zachary Turnerd66889c2016-07-28 19:12:28 +0000321 const WritableStream &MsfData)
322 : ReadInterface(BlockSize, NumBlocks, Layout, MsfData),
323 WriteInterface(MsfData) {}
324
325std::unique_ptr<WritableMappedBlockStream>
326WritableMappedBlockStream::createStream(uint32_t BlockSize, uint32_t NumBlocks,
Zachary Turnera3225b02016-07-29 20:56:36 +0000327 const MSFStreamLayout &Layout,
Zachary Turnerd66889c2016-07-28 19:12:28 +0000328 const WritableStream &MsfData) {
329 return llvm::make_unique<MappedBlockStreamImpl<WritableMappedBlockStream>>(
330 BlockSize, NumBlocks, Layout, MsfData);
331}
332
333std::unique_ptr<WritableMappedBlockStream>
Zachary Turnera3225b02016-07-29 20:56:36 +0000334WritableMappedBlockStream::createIndexedStream(const MSFLayout &Layout,
Zachary Turnerd66889c2016-07-28 19:12:28 +0000335 const WritableStream &MsfData,
336 uint32_t StreamIndex) {
Zachary Turnera3225b02016-07-29 20:56:36 +0000337 MSFStreamLayout SL;
Zachary Turnerd66889c2016-07-28 19:12:28 +0000338 SL.Blocks = Layout.StreamMap[StreamIndex];
339 SL.Length = Layout.StreamSizes[StreamIndex];
340 return createStream(Layout.SB->BlockSize, Layout.SB->NumBlocks, SL, MsfData);
341}
342
343std::unique_ptr<WritableMappedBlockStream>
344WritableMappedBlockStream::createDirectoryStream(
Zachary Turnera3225b02016-07-29 20:56:36 +0000345 const MSFLayout &Layout, const WritableStream &MsfData) {
346 MSFStreamLayout SL;
Zachary Turnerd66889c2016-07-28 19:12:28 +0000347 SL.Blocks = Layout.DirectoryBlocks;
348 SL.Length = Layout.SB->NumDirectoryBytes;
349 return createStream(Layout.SB->BlockSize, Layout.SB->NumBlocks, SL, MsfData);
350}
351
Zachary Turner8cf51c32016-08-03 16:53:21 +0000352std::unique_ptr<WritableMappedBlockStream>
353WritableMappedBlockStream::createFpmStream(const MSFLayout &Layout,
354 const WritableStream &MsfData) {
355 MSFStreamLayout SL;
356 initializeFpmStreamLayout(Layout, SL);
357 return createStream(Layout.SB->BlockSize, Layout.SB->NumBlocks, SL, MsfData);
358}
359
Zachary Turnerd66889c2016-07-28 19:12:28 +0000360Error WritableMappedBlockStream::readBytes(uint32_t Offset, uint32_t Size,
361 ArrayRef<uint8_t> &Buffer) const {
362 return ReadInterface.readBytes(Offset, Size, Buffer);
363}
364
365Error WritableMappedBlockStream::readLongestContiguousChunk(
366 uint32_t Offset, ArrayRef<uint8_t> &Buffer) const {
367 return ReadInterface.readLongestContiguousChunk(Offset, Buffer);
368}
369
370uint32_t WritableMappedBlockStream::getLength() const {
371 return ReadInterface.getLength();
372}
373
374Error WritableMappedBlockStream::writeBytes(uint32_t Offset,
375 ArrayRef<uint8_t> Buffer) const {
376 // Make sure we aren't trying to write beyond the end of the stream.
377 if (Buffer.size() > getStreamLength())
Zachary Turnera3225b02016-07-29 20:56:36 +0000378 return make_error<MSFError>(msf_error_code::insufficient_buffer);
Zachary Turnerd66889c2016-07-28 19:12:28 +0000379
380 if (Offset > getStreamLayout().Length - Buffer.size())
Zachary Turnera3225b02016-07-29 20:56:36 +0000381 return make_error<MSFError>(msf_error_code::insufficient_buffer);
Zachary Turnerd66889c2016-07-28 19:12:28 +0000382
383 uint32_t BlockNum = Offset / getBlockSize();
384 uint32_t OffsetInBlock = Offset % getBlockSize();
385
386 uint32_t BytesLeft = Buffer.size();
387 uint32_t BytesWritten = 0;
388 while (BytesLeft > 0) {
389 uint32_t StreamBlockAddr = getStreamLayout().Blocks[BlockNum];
390 uint32_t BytesToWriteInChunk =
391 std::min(BytesLeft, getBlockSize() - OffsetInBlock);
392
393 const uint8_t *Chunk = Buffer.data() + BytesWritten;
394 ArrayRef<uint8_t> ChunkData(Chunk, BytesToWriteInChunk);
395 uint32_t MsfOffset = blockToOffset(StreamBlockAddr, getBlockSize());
396 MsfOffset += OffsetInBlock;
397 if (auto EC = WriteInterface.writeBytes(MsfOffset, ChunkData))
398 return EC;
399
400 BytesLeft -= BytesToWriteInChunk;
401 BytesWritten += BytesToWriteInChunk;
402 ++BlockNum;
403 OffsetInBlock = 0;
404 }
405
406 ReadInterface.fixCacheAfterWrite(Offset, Buffer);
Zachary Turner5acb4ac2016-06-10 05:09:12 +0000407
408 return Error::success();
Zachary Turnerf5c59652016-05-03 00:28:21 +0000409}
Zachary Turner90b8b8d2016-05-31 22:41:52 +0000410
Zachary Turnerd66889c2016-07-28 19:12:28 +0000411Error WritableMappedBlockStream::commit() const {
412 return WriteInterface.commit();
Zachary Turnera1657a92016-06-08 17:26:39 +0000413}