1 //===- FDRRecordProducer.cpp - XRay FDR Mode Record Producer --------------===//
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 #include "llvm/XRay/FDRRecords.h"
9 
10 namespace llvm {
11 namespace xray {
12 
13 Error RecordInitializer::visit(BufferExtents &R) {
14   if (!E.isValidOffsetForDataOfSize(OffsetPtr, sizeof(uint64_t)))
15     return createStringError(
16         std::make_error_code(std::errc::bad_address),
17         "Invalid offset for a buffer extent (%" PRId64 ").", OffsetPtr);
18 
19   auto PreReadOffset = OffsetPtr;
20   R.Size = E.getU64(&OffsetPtr);
21   if (PreReadOffset == OffsetPtr)
22     return createStringError(std::make_error_code(std::errc::invalid_argument),
23                              "Cannot read buffer extent at offset %" PRId64 ".",
24                              OffsetPtr);
25 
26   OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - PreReadOffset);
27   return Error::success();
28 }
29 
30 Error RecordInitializer::visit(WallclockRecord &R) {
31   if (!E.isValidOffsetForDataOfSize(OffsetPtr,
32                                     MetadataRecord::kMetadataBodySize))
33     return createStringError(
34         std::make_error_code(std::errc::bad_address),
35         "Invalid offset for a wallclock record (%" PRId64 ").", OffsetPtr);
36   auto BeginOffset = OffsetPtr;
37   auto PreReadOffset = OffsetPtr;
38   R.Seconds = E.getU64(&OffsetPtr);
39   if (OffsetPtr == PreReadOffset)
40     return createStringError(
41         std::make_error_code(std::errc::invalid_argument),
42         "Cannot read wall clock 'seconds' field at offset %" PRId64 ".",
43         OffsetPtr);
44 
45   PreReadOffset = OffsetPtr;
46   R.Nanos = E.getU32(&OffsetPtr);
47   if (OffsetPtr == PreReadOffset)
48     return createStringError(
49         std::make_error_code(std::errc::invalid_argument),
50         "Cannot read wall clock 'nanos' field at offset %" PRId64 ".",
51         OffsetPtr);
52 
53   // Align to metadata record size boundary.
54   assert(OffsetPtr - BeginOffset <= MetadataRecord::kMetadataBodySize);
55   OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - BeginOffset);
56   return Error::success();
57 }
58 
59 Error RecordInitializer::visit(NewCPUIDRecord &R) {
60   if (!E.isValidOffsetForDataOfSize(OffsetPtr,
61                                     MetadataRecord::kMetadataBodySize))
62     return createStringError(
63         std::make_error_code(std::errc::bad_address),
64         "Invalid offset for a new cpu id record (%" PRId64 ").", OffsetPtr);
65   auto BeginOffset = OffsetPtr;
66   auto PreReadOffset = OffsetPtr;
67   R.CPUId = E.getU16(&OffsetPtr);
68   if (OffsetPtr == PreReadOffset)
69     return createStringError(std::make_error_code(std::errc::invalid_argument),
70                              "Cannot read CPU id at offset %" PRId64 ".",
71                              OffsetPtr);
72 
73   PreReadOffset = OffsetPtr;
74   R.TSC = E.getU64(&OffsetPtr);
75   if (OffsetPtr == PreReadOffset)
76     return createStringError(std::make_error_code(std::errc::invalid_argument),
77                              "Cannot read CPU TSC at offset %" PRId64 ".",
78                              OffsetPtr);
79 
80   OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - BeginOffset);
81   return Error::success();
82 }
83 
84 Error RecordInitializer::visit(TSCWrapRecord &R) {
85   if (!E.isValidOffsetForDataOfSize(OffsetPtr,
86                                     MetadataRecord::kMetadataBodySize))
87     return createStringError(
88         std::make_error_code(std::errc::bad_address),
89         "Invalid offset for a new TSC wrap record (%" PRId64 ").", OffsetPtr);
90 
91   auto PreReadOffset = OffsetPtr;
92   R.BaseTSC = E.getU64(&OffsetPtr);
93   if (PreReadOffset == OffsetPtr)
94     return createStringError(
95         std::make_error_code(std::errc::invalid_argument),
96         "Cannot read TSC wrap record at offset %" PRId64 ".", OffsetPtr);
97 
98   OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - PreReadOffset);
99   return Error::success();
100 }
101 
102 Error RecordInitializer::visit(CustomEventRecord &R) {
103   if (!E.isValidOffsetForDataOfSize(OffsetPtr,
104                                     MetadataRecord::kMetadataBodySize))
105     return createStringError(
106         std::make_error_code(std::errc::bad_address),
107         "Invalid offset for a custom event record (%" PRId64 ").", OffsetPtr);
108 
109   auto BeginOffset = OffsetPtr;
110   auto PreReadOffset = OffsetPtr;
111   R.Size = E.getSigned(&OffsetPtr, sizeof(int32_t));
112   if (PreReadOffset == OffsetPtr)
113     return createStringError(
114         std::make_error_code(std::errc::invalid_argument),
115         "Cannot read a custom event record size field offset %" PRId64 ".",
116         OffsetPtr);
117 
118   if (R.Size <= 0)
119     return createStringError(
120         std::make_error_code(std::errc::bad_address),
121         "Invalid size for custom event (size = %d) at offset %" PRId64 ".",
122         R.Size, OffsetPtr);
123 
124   PreReadOffset = OffsetPtr;
125   R.TSC = E.getU64(&OffsetPtr);
126   if (PreReadOffset == OffsetPtr)
127     return createStringError(
128         std::make_error_code(std::errc::invalid_argument),
129         "Cannot read a custom event TSC field at offset %" PRId64 ".",
130         OffsetPtr);
131 
132   // For version 4 onwards, of the FDR log, we want to also capture the CPU ID
133   // of the custom event.
134   if (Version >= 4) {
135     PreReadOffset = OffsetPtr;
136     R.CPU = E.getU16(&OffsetPtr);
137     if (PreReadOffset == OffsetPtr)
138       return createStringError(
139           std::make_error_code(std::errc::invalid_argument),
140           "Missing CPU field at offset %" PRId64 ".", OffsetPtr);
141   }
142 
143   assert(OffsetPtr > BeginOffset &&
144          OffsetPtr - BeginOffset <= MetadataRecord::kMetadataBodySize);
145   OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - BeginOffset);
146 
147   // Next we read in a fixed chunk of data from the given offset.
148   if (!E.isValidOffsetForDataOfSize(OffsetPtr, R.Size))
149     return createStringError(
150         std::make_error_code(std::errc::bad_address),
151         "Cannot read %d bytes of custom event data from offset %" PRId64 ".",
152         R.Size, OffsetPtr);
153 
154   std::vector<uint8_t> Buffer;
155   Buffer.resize(R.Size);
156   PreReadOffset = OffsetPtr;
157   if (E.getU8(&OffsetPtr, Buffer.data(), R.Size) != Buffer.data())
158     return createStringError(
159         std::make_error_code(std::errc::invalid_argument),
160         "Failed reading data into buffer of size %d at offset %" PRId64 ".",
161         R.Size, OffsetPtr);
162 
163   assert(OffsetPtr >= PreReadOffset);
164   if (OffsetPtr - PreReadOffset != static_cast<uint32_t>(R.Size))
165     return createStringError(
166         std::make_error_code(std::errc::invalid_argument),
167         "Failed reading enough bytes for the custom event payload -- read "
168         "%" PRId64 " expecting %d bytes at offset %" PRId64 ".",
169         OffsetPtr - PreReadOffset, R.Size, PreReadOffset);
170 
171   R.Data.assign(Buffer.begin(), Buffer.end());
172   return Error::success();
173 }
174 
175 Error RecordInitializer::visit(CustomEventRecordV5 &R) {
176   if (!E.isValidOffsetForDataOfSize(OffsetPtr,
177                                     MetadataRecord::kMetadataBodySize))
178     return createStringError(
179         std::make_error_code(std::errc::bad_address),
180         "Invalid offset for a custom event record (%" PRId64 ").", OffsetPtr);
181 
182   auto BeginOffset = OffsetPtr;
183   auto PreReadOffset = OffsetPtr;
184 
185   R.Size = E.getSigned(&OffsetPtr, sizeof(int32_t));
186   if (PreReadOffset == OffsetPtr)
187     return createStringError(
188         std::make_error_code(std::errc::invalid_argument),
189         "Cannot read a custom event record size field offset %" PRId64 ".",
190         OffsetPtr);
191 
192   if (R.Size <= 0)
193     return createStringError(
194         std::make_error_code(std::errc::bad_address),
195         "Invalid size for custom event (size = %d) at offset %" PRId64 ".",
196         R.Size, OffsetPtr);
197 
198   PreReadOffset = OffsetPtr;
199   R.Delta = E.getSigned(&OffsetPtr, sizeof(int32_t));
200   if (PreReadOffset == OffsetPtr)
201     return createStringError(
202         std::make_error_code(std::errc::invalid_argument),
203         "Cannot read a custom event record TSC delta field at offset "
204         "%" PRId64 ".",
205         OffsetPtr);
206 
207   assert(OffsetPtr > BeginOffset &&
208          OffsetPtr - BeginOffset <= MetadataRecord::kMetadataBodySize);
209   OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - BeginOffset);
210 
211   // Next we read in a fixed chunk of data from the given offset.
212   if (!E.isValidOffsetForDataOfSize(OffsetPtr, R.Size))
213     return createStringError(
214         std::make_error_code(std::errc::bad_address),
215         "Cannot read %d bytes of custom event data from offset %" PRId64 ".",
216         R.Size, OffsetPtr);
217 
218   std::vector<uint8_t> Buffer;
219   Buffer.resize(R.Size);
220   PreReadOffset = OffsetPtr;
221   if (E.getU8(&OffsetPtr, Buffer.data(), R.Size) != Buffer.data())
222     return createStringError(
223         std::make_error_code(std::errc::invalid_argument),
224         "Failed reading data into buffer of size %d at offset %" PRId64 ".",
225         R.Size, OffsetPtr);
226 
227   assert(OffsetPtr >= PreReadOffset);
228   if (OffsetPtr - PreReadOffset != static_cast<uint32_t>(R.Size))
229     return createStringError(
230         std::make_error_code(std::errc::invalid_argument),
231         "Failed reading enough bytes for the custom event payload -- read "
232         "%" PRId64 " expecting %d bytes at offset %" PRId64 ".",
233         OffsetPtr - PreReadOffset, R.Size, PreReadOffset);
234 
235   R.Data.assign(Buffer.begin(), Buffer.end());
236   return Error::success();
237 }
238 
239 Error RecordInitializer::visit(TypedEventRecord &R) {
240   if (!E.isValidOffsetForDataOfSize(OffsetPtr,
241                                     MetadataRecord::kMetadataBodySize))
242     return createStringError(
243         std::make_error_code(std::errc::bad_address),
244         "Invalid offset for a typed event record (%" PRId64 ").", OffsetPtr);
245 
246   auto BeginOffset = OffsetPtr;
247   auto PreReadOffset = OffsetPtr;
248 
249   R.Size = E.getSigned(&OffsetPtr, sizeof(int32_t));
250   if (PreReadOffset == OffsetPtr)
251     return createStringError(
252         std::make_error_code(std::errc::invalid_argument),
253         "Cannot read a typed event record size field offset %" PRId64 ".",
254         OffsetPtr);
255 
256   if (R.Size <= 0)
257     return createStringError(
258         std::make_error_code(std::errc::bad_address),
259         "Invalid size for typed event (size = %d) at offset %" PRId64 ".",
260         R.Size, OffsetPtr);
261 
262   PreReadOffset = OffsetPtr;
263   R.Delta = E.getSigned(&OffsetPtr, sizeof(int32_t));
264   if (PreReadOffset == OffsetPtr)
265     return createStringError(
266         std::make_error_code(std::errc::invalid_argument),
267         "Cannot read a typed event record TSC delta field at offset "
268         "%" PRId64 ".",
269         OffsetPtr);
270 
271   PreReadOffset = OffsetPtr;
272   R.EventType = E.getU16(&OffsetPtr);
273   if (PreReadOffset == OffsetPtr)
274     return createStringError(
275         std::make_error_code(std::errc::invalid_argument),
276         "Cannot read a typed event record type field at offset %" PRId64 ".",
277         OffsetPtr);
278 
279   assert(OffsetPtr > BeginOffset &&
280          OffsetPtr - BeginOffset <= MetadataRecord::kMetadataBodySize);
281   OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - BeginOffset);
282 
283   // Next we read in a fixed chunk of data from the given offset.
284   if (!E.isValidOffsetForDataOfSize(OffsetPtr, R.Size))
285     return createStringError(
286         std::make_error_code(std::errc::bad_address),
287         "Cannot read %d bytes of custom event data from offset %" PRId64 ".",
288         R.Size, OffsetPtr);
289 
290   std::vector<uint8_t> Buffer;
291   Buffer.resize(R.Size);
292   PreReadOffset = OffsetPtr;
293   if (E.getU8(&OffsetPtr, Buffer.data(), R.Size) != Buffer.data())
294     return createStringError(
295         std::make_error_code(std::errc::invalid_argument),
296         "Failed reading data into buffer of size %d at offset %" PRId64 ".",
297         R.Size, OffsetPtr);
298 
299   assert(OffsetPtr >= PreReadOffset);
300   if (OffsetPtr - PreReadOffset != static_cast<uint32_t>(R.Size))
301     return createStringError(
302         std::make_error_code(std::errc::invalid_argument),
303         "Failed reading enough bytes for the typed event payload -- read "
304         "%" PRId64 " expecting %d bytes at offset %" PRId64 ".",
305         OffsetPtr - PreReadOffset, R.Size, PreReadOffset);
306 
307   R.Data.assign(Buffer.begin(), Buffer.end());
308   return Error::success();
309 }
310 
311 Error RecordInitializer::visit(CallArgRecord &R) {
312   if (!E.isValidOffsetForDataOfSize(OffsetPtr,
313                                     MetadataRecord::kMetadataBodySize))
314     return createStringError(
315         std::make_error_code(std::errc::bad_address),
316         "Invalid offset for a call argument record (%" PRId64 ").",
317         OffsetPtr);
318 
319   auto PreReadOffset = OffsetPtr;
320   R.Arg = E.getU64(&OffsetPtr);
321   if (PreReadOffset == OffsetPtr)
322     return createStringError(
323         std::make_error_code(std::errc::invalid_argument),
324         "Cannot read a call arg record at offset %" PRId64 ".", OffsetPtr);
325 
326   OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - PreReadOffset);
327   return Error::success();
328 }
329 
330 Error RecordInitializer::visit(PIDRecord &R) {
331   if (!E.isValidOffsetForDataOfSize(OffsetPtr,
332                                     MetadataRecord::kMetadataBodySize))
333     return createStringError(
334         std::make_error_code(std::errc::bad_address),
335         "Invalid offset for a process ID record (%" PRId64 ").", OffsetPtr);
336 
337   auto PreReadOffset = OffsetPtr;
338   R.PID = E.getSigned(&OffsetPtr, 4);
339   if (PreReadOffset == OffsetPtr)
340     return createStringError(
341         std::make_error_code(std::errc::invalid_argument),
342         "Cannot read a process ID record at offset %" PRId64 ".", OffsetPtr);
343 
344   OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - PreReadOffset);
345   return Error::success();
346 }
347 
348 Error RecordInitializer::visit(NewBufferRecord &R) {
349   if (!E.isValidOffsetForDataOfSize(OffsetPtr,
350                                     MetadataRecord::kMetadataBodySize))
351     return createStringError(
352         std::make_error_code(std::errc::bad_address),
353         "Invalid offset for a new buffer record (%" PRId64 ").", OffsetPtr);
354 
355   auto PreReadOffset = OffsetPtr;
356   R.TID = E.getSigned(&OffsetPtr, sizeof(int32_t));
357   if (PreReadOffset == OffsetPtr)
358     return createStringError(
359         std::make_error_code(std::errc::invalid_argument),
360         "Cannot read a new buffer record at offset %" PRId64 ".", OffsetPtr);
361 
362   OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - PreReadOffset);
363   return Error::success();
364 }
365 
366 Error RecordInitializer::visit(EndBufferRecord &R) {
367   if (!E.isValidOffsetForDataOfSize(OffsetPtr,
368                                     MetadataRecord::kMetadataBodySize))
369     return createStringError(
370         std::make_error_code(std::errc::bad_address),
371         "Invalid offset for an end-of-buffer record (%" PRId64 ").",
372         OffsetPtr);
373 
374   OffsetPtr += MetadataRecord::kMetadataBodySize;
375   return Error::success();
376 }
377 
378 Error RecordInitializer::visit(FunctionRecord &R) {
379   // For function records, we need to retreat one byte back to read a full
380   // unsigned 32-bit value. The first four bytes will have the following
381   // layout:
382   //
383   //   bit  0     : function record indicator (must be 0)
384   //   bits 1..3  : function record type
385   //   bits 4..32 : function id
386   //
387   if (OffsetPtr == 0 || !E.isValidOffsetForDataOfSize(
388                             --OffsetPtr, FunctionRecord::kFunctionRecordSize))
389     return createStringError(
390         std::make_error_code(std::errc::bad_address),
391         "Invalid offset for a function record (%" PRId64 ").", OffsetPtr);
392 
393   auto BeginOffset = OffsetPtr;
394   auto PreReadOffset = BeginOffset;
395   uint32_t Buffer = E.getU32(&OffsetPtr);
396   if (PreReadOffset == OffsetPtr)
397     return createStringError(
398         std::make_error_code(std::errc::bad_address),
399         "Cannot read function id field from offset %" PRId64 ".", OffsetPtr);
400 
401   // To get the function record type, we shift the buffer one to the right
402   // (truncating the function record indicator) then take the three bits
403   // (0b0111) to get the record type as an unsigned value.
404   unsigned FunctionType = (Buffer >> 1) & 0x07u;
405   switch (FunctionType) {
406   case static_cast<unsigned>(RecordTypes::ENTER):
407   case static_cast<unsigned>(RecordTypes::ENTER_ARG):
408   case static_cast<unsigned>(RecordTypes::EXIT):
409   case static_cast<unsigned>(RecordTypes::TAIL_EXIT):
410     R.Kind = static_cast<RecordTypes>(FunctionType);
411     break;
412   default:
413     return createStringError(
414         std::make_error_code(std::errc::invalid_argument),
415         "Unknown function record type '%d' at offset %" PRId64 ".",
416         FunctionType, BeginOffset);
417   }
418 
419   R.FuncId = Buffer >> 4;
420   PreReadOffset = OffsetPtr;
421   R.Delta = E.getU32(&OffsetPtr);
422   if (OffsetPtr == PreReadOffset)
423     return createStringError(
424         std::make_error_code(std::errc::invalid_argument),
425         "Failed reading TSC delta from offset %" PRId64 ".", OffsetPtr);
426   assert(FunctionRecord::kFunctionRecordSize == (OffsetPtr - BeginOffset));
427   return Error::success();
428 }
429 
430 } // namespace xray
431 } // namespace llvm
432