mirror of
https://github.com/python/cpython
synced 2026-11-19 13:54:45 +03:00
Store samples in independently decodable columnar blocks so binary replay can process a profile without decompressing the complete sample stream. Use per-stream timestamp and stack deltas, status bitmaps, and compact frame IDs within each block.
1882 lines
65 KiB
C
1882 lines
65 KiB
C
/******************************************************************************
|
|
* Python Remote Debugging Module - Binary Reader Implementation
|
|
*
|
|
* High-performance binary file reader for profiling data with optional zstd
|
|
* decompression.
|
|
******************************************************************************/
|
|
|
|
#ifndef Py_BUILD_CORE_MODULE
|
|
# define Py_BUILD_CORE_MODULE
|
|
#endif
|
|
|
|
#include "binary_io.h"
|
|
#include "_remote_debugging.h"
|
|
#include "pycore_bitutils.h" /* _Py_bswap32, _Py_bswap64 for cross-endian reading */
|
|
#include <math.h>
|
|
#include <string.h>
|
|
|
|
#ifdef HAVE_ZSTD
|
|
#include <zstd.h>
|
|
#endif
|
|
|
|
#ifdef _Py_MEMORY_SANITIZER
|
|
# include <sanitizer/msan_interface.h>
|
|
#endif
|
|
|
|
/* ============================================================================
|
|
* CONSTANTS FOR BINARY FORMAT SIZES
|
|
* ============================================================================ */
|
|
|
|
/* Progress callback frequency */
|
|
#define PROGRESS_CALLBACK_INTERVAL 1000
|
|
|
|
/* Cap per-batch RLE samples to bound the timestamp list (gh-151378) */
|
|
#define MAX_RLE_BATCH_SAMPLES 8192
|
|
|
|
#define FRAME_INFO_CACHE_SIZE 1024
|
|
|
|
/* ============================================================================
|
|
* BINARY READER IMPLEMENTATION
|
|
* ============================================================================ */
|
|
|
|
static inline int
|
|
reader_parse_header(BinaryReader *reader, const uint8_t *data, size_t file_size)
|
|
{
|
|
if (file_size < FILE_HEADER_PLACEHOLDER_SIZE) {
|
|
PyErr_SetString(PyExc_ValueError, "File too small for header");
|
|
return -1;
|
|
}
|
|
|
|
/* Use memcpy to avoid strict aliasing violations and unaligned access */
|
|
uint32_t magic;
|
|
uint32_t version;
|
|
memcpy(&magic, &data[HDR_OFF_MAGIC], HDR_SIZE_MAGIC);
|
|
memcpy(&version, &data[HDR_OFF_VERSION], HDR_SIZE_VERSION);
|
|
|
|
/* Detect endianness from magic number */
|
|
if (magic == BINARY_FORMAT_MAGIC) {
|
|
reader->needs_swap = 0;
|
|
} else if (magic == BINARY_FORMAT_MAGIC_SWAPPED) {
|
|
reader->needs_swap = 1;
|
|
version = _Py_bswap32(version);
|
|
} else {
|
|
PyErr_Format(PyExc_ValueError, "Invalid magic number: 0x%08x", magic);
|
|
return -1;
|
|
}
|
|
|
|
if (version != BINARY_FORMAT_VERSION) {
|
|
if (version > BINARY_FORMAT_VERSION && file_size >= HDR_OFF_PY_MICRO + 1) {
|
|
/* Newer format - try to read Python version for better error */
|
|
uint8_t py_major = data[HDR_OFF_PY_MAJOR];
|
|
uint8_t py_minor = data[HDR_OFF_PY_MINOR];
|
|
uint8_t py_micro = data[HDR_OFF_PY_MICRO];
|
|
PyErr_Format(PyExc_ValueError,
|
|
"Binary file was created with Python %u.%u.%u (format version %u), "
|
|
"but this is Python %d.%d.%d (format version %d)",
|
|
py_major, py_minor, py_micro, version,
|
|
PY_MAJOR_VERSION, PY_MINOR_VERSION, PY_MICRO_VERSION,
|
|
BINARY_FORMAT_VERSION);
|
|
} else {
|
|
PyErr_Format(PyExc_ValueError,
|
|
"Unsupported format version %u (this reader supports version %d)",
|
|
version, BINARY_FORMAT_VERSION);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
reader->py_major = data[HDR_OFF_PY_MAJOR];
|
|
reader->py_minor = data[HDR_OFF_PY_MINOR];
|
|
reader->py_micro = data[HDR_OFF_PY_MICRO];
|
|
|
|
/* Read header fields with byte-swapping if needed */
|
|
uint64_t start_time_us, sample_interval_us, string_table_offset, frame_table_offset;
|
|
uint64_t sample_count;
|
|
uint32_t thread_count, compression_type, profiling_config;
|
|
|
|
memcpy(&start_time_us, &data[HDR_OFF_START_TIME], HDR_SIZE_START_TIME);
|
|
memcpy(&sample_interval_us, &data[HDR_OFF_INTERVAL], HDR_SIZE_INTERVAL);
|
|
memcpy(&sample_count, &data[HDR_OFF_SAMPLES], HDR_SIZE_SAMPLES);
|
|
memcpy(&thread_count, &data[HDR_OFF_THREADS], HDR_SIZE_THREADS);
|
|
memcpy(&string_table_offset, &data[HDR_OFF_STR_TABLE], HDR_SIZE_STR_TABLE);
|
|
memcpy(&frame_table_offset, &data[HDR_OFF_FRAME_TABLE], HDR_SIZE_FRAME_TABLE);
|
|
memcpy(&compression_type, &data[HDR_OFF_COMPRESSION], HDR_SIZE_COMPRESSION);
|
|
memcpy(&profiling_config, &data[HDR_OFF_CONFIG], HDR_SIZE_CONFIG);
|
|
|
|
reader->start_time_us = SWAP64_IF(reader->needs_swap, start_time_us);
|
|
reader->sample_interval_us = SWAP64_IF(reader->needs_swap, sample_interval_us);
|
|
reader->sample_count = SWAP64_IF(reader->needs_swap, sample_count);
|
|
reader->thread_count = SWAP32_IF(reader->needs_swap, thread_count);
|
|
reader->string_table_offset = SWAP64_IF(reader->needs_swap, string_table_offset);
|
|
reader->frame_table_offset = SWAP64_IF(reader->needs_swap, frame_table_offset);
|
|
reader->compression_type = (int)SWAP32_IF(reader->needs_swap, compression_type);
|
|
profiling_config = SWAP32_IF(reader->needs_swap, profiling_config);
|
|
uint32_t profiling_mode =
|
|
profiling_config & PROFILING_CONFIG_MODE_MASK;
|
|
if (profiling_mode > PROFILING_MODE_EXCEPTION + 1) {
|
|
PyErr_Format(PyExc_ValueError,
|
|
"Invalid profiling mode in header: %u", profiling_mode);
|
|
return -1;
|
|
}
|
|
reader->profiling_mode = (int)profiling_mode - 1;
|
|
reader->capture_features =
|
|
profiling_config & PROFILING_CONFIG_FEATURES_KNOWN
|
|
? (int)((profiling_config >> PROFILING_CONFIG_FEATURES_SHIFT) &
|
|
PROFILING_FEATURE_MASK)
|
|
: -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline int
|
|
reader_parse_footer(BinaryReader *reader, const uint8_t *data, size_t file_size)
|
|
{
|
|
if (file_size < FILE_FOOTER_SIZE) {
|
|
PyErr_SetString(PyExc_ValueError, "File too small for footer");
|
|
return -1;
|
|
}
|
|
|
|
const uint8_t *footer = data + file_size - FILE_FOOTER_SIZE;
|
|
/* Use memcpy to avoid strict aliasing violations */
|
|
uint32_t strings_count, frames_count;
|
|
memcpy(&strings_count, &footer[FTR_OFF_STRINGS], FTR_SIZE_STRINGS);
|
|
memcpy(&frames_count, &footer[FTR_OFF_FRAMES], FTR_SIZE_FRAMES);
|
|
|
|
reader->strings_count = SWAP32_IF(reader->needs_swap, strings_count);
|
|
reader->frames_count = SWAP32_IF(reader->needs_swap, frames_count);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline int
|
|
reader_parse_profile_stats(BinaryReader *reader, const uint8_t *data,
|
|
size_t file_size)
|
|
{
|
|
size_t minimum_size = FILE_FOOTER_SIZE + PROFILE_STATS_V1_SIZE;
|
|
if (file_size < minimum_size) {
|
|
return 0;
|
|
}
|
|
|
|
const uint8_t *stats_end = data + file_size - FILE_FOOTER_SIZE;
|
|
const uint8_t *stats_tail = stats_end - PROFILE_STATS_MAGIC_SIZE -
|
|
PST_SIZE_VERSION - PST_SIZE_SIZE;
|
|
if (memcmp(stats_tail,
|
|
PROFILE_STATS_MAGIC, PROFILE_STATS_MAGIC_SIZE) != 0) {
|
|
return 0;
|
|
}
|
|
|
|
uint32_t version, size;
|
|
memcpy(&version, stats_tail + PROFILE_STATS_MAGIC_SIZE,
|
|
PST_SIZE_VERSION);
|
|
memcpy(&size, stats_tail + PROFILE_STATS_MAGIC_SIZE + PST_SIZE_VERSION,
|
|
PST_SIZE_SIZE);
|
|
version = SWAP32_IF(reader->needs_swap, version);
|
|
size = SWAP32_IF(reader->needs_swap, size);
|
|
|
|
if (size < PROFILE_STATS_V1_SIZE ||
|
|
size > file_size - FILE_FOOTER_SIZE) {
|
|
PyErr_SetString(PyExc_ValueError,
|
|
"Invalid profiling statistics size");
|
|
return -1;
|
|
}
|
|
if (version != PROFILE_STATS_VERSION) {
|
|
return 0;
|
|
}
|
|
|
|
const uint8_t *trailer = stats_end - size;
|
|
uint64_t duration_bits, sample_rate_bits;
|
|
memcpy(&duration_bits, trailer + PST_OFF_DURATION, PST_SIZE_DURATION);
|
|
memcpy(&sample_rate_bits, trailer + PST_OFF_SAMPLE_RATE,
|
|
PST_SIZE_SAMPLE_RATE);
|
|
duration_bits = SWAP64_IF(reader->needs_swap, duration_bits);
|
|
sample_rate_bits = SWAP64_IF(reader->needs_swap, sample_rate_bits);
|
|
memcpy(&reader->duration_sec, &duration_bits, sizeof(duration_bits));
|
|
memcpy(&reader->sample_rate, &sample_rate_bits, sizeof(sample_rate_bits));
|
|
|
|
if (!isfinite(reader->duration_sec) || reader->duration_sec < 0.0 ||
|
|
!isfinite(reader->sample_rate) || reader->sample_rate < 0.0) {
|
|
PyErr_SetString(PyExc_ValueError,
|
|
"Invalid profiling statistics values");
|
|
return -1;
|
|
}
|
|
reader->has_profile_stats = 1;
|
|
|
|
if (size >= PROFILE_STATS_SIZE) {
|
|
uint64_t error_rate_bits, missed_samples_bits;
|
|
uint32_t present;
|
|
memcpy(&error_rate_bits, trailer + PST_OFF_ERROR_RATE,
|
|
PST_SIZE_ERROR_RATE);
|
|
memcpy(&missed_samples_bits, trailer + PST_OFF_MISSED_SAMPLES,
|
|
PST_SIZE_MISSED_SAMPLES);
|
|
memcpy(&present, trailer + PST_OFF_PRESENT, PST_SIZE_PRESENT);
|
|
error_rate_bits = SWAP64_IF(reader->needs_swap, error_rate_bits);
|
|
missed_samples_bits = SWAP64_IF(reader->needs_swap,
|
|
missed_samples_bits);
|
|
present = SWAP32_IF(reader->needs_swap, present);
|
|
memcpy(&reader->error_rate, &error_rate_bits,
|
|
sizeof(error_rate_bits));
|
|
memcpy(&reader->missed_samples, &missed_samples_bits,
|
|
sizeof(missed_samples_bits));
|
|
if (((present & PROFILE_STATS_ERROR_RATE) &&
|
|
(!isfinite(reader->error_rate) || reader->error_rate < 0.0)) ||
|
|
((present & PROFILE_STATS_MISSED) &&
|
|
!isfinite(reader->missed_samples))) {
|
|
PyErr_SetString(PyExc_ValueError,
|
|
"Invalid profiling statistics values");
|
|
return -1;
|
|
}
|
|
reader->profile_stats_present = present;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
reader_decompress(BinaryReader *reader, const uint8_t *compressed_data,
|
|
size_t compressed_size, ByteBuffer *output,
|
|
size_t decoded_size)
|
|
{
|
|
#ifdef HAVE_ZSTD
|
|
/* The data must be exactly one zstd frame */
|
|
size_t frame_size = ZSTD_findFrameCompressedSize(compressed_data,
|
|
compressed_size);
|
|
if (ZSTD_isError(frame_size) || frame_size != compressed_size) {
|
|
PyErr_SetString(PyExc_ValueError, "Corrupted zstd frame header");
|
|
return -1;
|
|
}
|
|
|
|
/* Check the decompressed size recorded in the frame header before
|
|
* allocating for it */
|
|
unsigned long long frame_content_size = ZSTD_getFrameContentSize(compressed_data, compressed_size);
|
|
if (frame_content_size == ZSTD_CONTENTSIZE_ERROR) {
|
|
/* Corrupted frame header - fail early */
|
|
PyErr_SetString(PyExc_ValueError, "Corrupted zstd frame header");
|
|
return -1;
|
|
}
|
|
if (frame_content_size != decoded_size) {
|
|
PyErr_SetString(PyExc_ValueError,
|
|
"zstd frame size does not match the decoded size");
|
|
return -1;
|
|
}
|
|
|
|
/* Append the decoded data to the output buffer */
|
|
if (buffer_reserve(output, output->size + decoded_size) < 0) {
|
|
return -1;
|
|
}
|
|
uint8_t *decoded = output->data + output->size;
|
|
size_t result = ZSTD_decompressDCtx(reader->dctx, decoded, decoded_size,
|
|
compressed_data, compressed_size);
|
|
if (ZSTD_isError(result)) {
|
|
PyErr_Format(PyExc_ValueError, "zstd decompression error: %s",
|
|
ZSTD_getErrorName(result));
|
|
return -1;
|
|
}
|
|
|
|
/* Verify decompression is complete */
|
|
if (result != decoded_size) {
|
|
PyErr_SetString(PyExc_ValueError, "Incomplete zstd frame: data may be truncated");
|
|
return -1;
|
|
}
|
|
|
|
_Py_MSAN_UNPOISON(decoded, decoded_size);
|
|
output->size += decoded_size;
|
|
return 0;
|
|
#else
|
|
PyErr_SetString(PyExc_RuntimeError,
|
|
"File uses zstd compression but zstd support not compiled in");
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
/* Reject a table/run count whose entries cannot fit in the bytes still
|
|
* available; a malicious file could otherwise drive a huge allocation.
|
|
* Each entry occupies at least min_entry_size bytes. */
|
|
static int
|
|
reader_validate_count(const char *what, uint32_t count,
|
|
size_t available_bytes, size_t min_entry_size)
|
|
{
|
|
size_t max_possible = available_bytes / min_entry_size;
|
|
if (count > max_possible) {
|
|
PyErr_Format(PyExc_ValueError,
|
|
"Invalid %s count %u exceeds maximum possible %zu",
|
|
what, count, max_possible);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static inline int
|
|
reader_parse_string_table(BinaryReader *reader, const uint8_t *data, size_t file_size)
|
|
{
|
|
if (reader_validate_count("string", reader->strings_count,
|
|
file_size - (size_t)reader->string_table_offset,
|
|
MIN_STRING_ENTRY_SIZE) < 0) {
|
|
return -1;
|
|
}
|
|
|
|
reader->strings = PyMem_Calloc(reader->strings_count, sizeof(PyObject *));
|
|
if (!reader->strings && reader->strings_count > 0) {
|
|
PyErr_NoMemory();
|
|
return -1;
|
|
}
|
|
|
|
size_t offset = (size_t)reader->string_table_offset;
|
|
for (uint32_t i = 0; i < reader->strings_count; i++) {
|
|
size_t prev_offset = offset;
|
|
uint32_t str_len = decode_varint_u32(data, &offset, file_size);
|
|
if (offset == prev_offset) {
|
|
PyErr_SetString(PyExc_ValueError, "Malformed varint in string table");
|
|
return -1;
|
|
}
|
|
if (offset > file_size || str_len > file_size - offset) {
|
|
PyErr_SetString(PyExc_ValueError, "String table overflow");
|
|
return -1;
|
|
}
|
|
|
|
reader->strings[i] = PyUnicode_DecodeUTF8((char *)&data[offset], str_len, "replace");
|
|
if (!reader->strings[i]) {
|
|
return -1;
|
|
}
|
|
offset += str_len;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline int
|
|
reader_parse_frame_table(BinaryReader *reader, const uint8_t *data, size_t file_size)
|
|
{
|
|
/* Check for integer overflow in allocation size calculation. */
|
|
#if SIZEOF_SIZE_T < 8
|
|
if (reader->frames_count > SIZE_MAX / sizeof(FrameEntry)) {
|
|
PyErr_SetString(PyExc_OverflowError, "Frame count too large for allocation");
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
if (reader_validate_count("frame", reader->frames_count,
|
|
file_size - (size_t)reader->frame_table_offset,
|
|
MIN_FRAME_ENTRY_SIZE) < 0) {
|
|
return -1;
|
|
}
|
|
|
|
size_t alloc_size = (size_t)reader->frames_count * sizeof(FrameEntry);
|
|
reader->frames = PyMem_Malloc(alloc_size);
|
|
if (!reader->frames && reader->frames_count > 0) {
|
|
PyErr_NoMemory();
|
|
return -1;
|
|
}
|
|
|
|
size_t offset = (size_t)reader->frame_table_offset;
|
|
for (uint32_t i = 0; i < reader->frames_count; i++) {
|
|
FrameEntry *frame = &reader->frames[i];
|
|
size_t prev_offset;
|
|
|
|
prev_offset = offset;
|
|
frame->filename_idx = decode_varint_u32(data, &offset, file_size);
|
|
if (offset == prev_offset) {
|
|
PyErr_SetString(PyExc_ValueError, "Malformed varint in frame table (filename)");
|
|
return -1;
|
|
}
|
|
|
|
prev_offset = offset;
|
|
frame->funcname_idx = decode_varint_u32(data, &offset, file_size);
|
|
if (offset == prev_offset) {
|
|
PyErr_SetString(PyExc_ValueError, "Malformed varint in frame table (funcname)");
|
|
return -1;
|
|
}
|
|
|
|
prev_offset = offset;
|
|
frame->lineno = decode_varint_i32(data, &offset, file_size);
|
|
if (offset == prev_offset) {
|
|
PyErr_SetString(PyExc_ValueError, "Malformed varint in frame table (lineno)");
|
|
return -1;
|
|
}
|
|
|
|
prev_offset = offset;
|
|
int32_t end_lineno_delta = decode_varint_i32(data, &offset, file_size);
|
|
if (offset == prev_offset) {
|
|
PyErr_SetString(PyExc_ValueError, "Malformed varint in frame table (end_lineno_delta)");
|
|
return -1;
|
|
}
|
|
/* Reconstruct end_lineno from delta. If lineno is -1, result is -1. */
|
|
if (frame->lineno == LOCATION_NOT_AVAILABLE) {
|
|
frame->end_lineno = LOCATION_NOT_AVAILABLE;
|
|
} else {
|
|
frame->end_lineno = frame->lineno + end_lineno_delta;
|
|
}
|
|
|
|
prev_offset = offset;
|
|
frame->column = decode_varint_i32(data, &offset, file_size);
|
|
if (offset == prev_offset) {
|
|
PyErr_SetString(PyExc_ValueError, "Malformed varint in frame table (column)");
|
|
return -1;
|
|
}
|
|
|
|
prev_offset = offset;
|
|
int32_t end_column_delta = decode_varint_i32(data, &offset, file_size);
|
|
if (offset == prev_offset) {
|
|
PyErr_SetString(PyExc_ValueError, "Malformed varint in frame table (end_column_delta)");
|
|
return -1;
|
|
}
|
|
/* Reconstruct end_column from delta. If column is -1, result is -1. */
|
|
if (frame->column == LOCATION_NOT_AVAILABLE) {
|
|
frame->end_column = LOCATION_NOT_AVAILABLE;
|
|
} else {
|
|
frame->end_column = frame->column + end_column_delta;
|
|
}
|
|
|
|
/* Read opcode byte */
|
|
if (offset >= file_size) {
|
|
PyErr_SetString(PyExc_ValueError, "Unexpected end of frame table (opcode)");
|
|
return -1;
|
|
}
|
|
frame->opcode = data[offset++];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
BinaryReader *
|
|
binary_reader_open(PyObject *path)
|
|
{
|
|
BinaryReader *reader = PyMem_Calloc(1, sizeof(BinaryReader));
|
|
if (!reader) {
|
|
PyErr_NoMemory();
|
|
return NULL;
|
|
}
|
|
|
|
#if USE_MMAP
|
|
/* Open with mmap on Unix */
|
|
FILE *fp = Py_fopen(path, "rb");
|
|
if (!fp) {
|
|
goto error;
|
|
}
|
|
int fd = fileno(fp);
|
|
|
|
struct stat st;
|
|
if (fstat(fd, &st) < 0) {
|
|
PyErr_SetFromErrno(PyExc_IOError);
|
|
Py_fclose(fp);
|
|
goto error;
|
|
}
|
|
if (st.st_size < 0) {
|
|
PyErr_SetString(PyExc_IOError, "Invalid negative file size");
|
|
Py_fclose(fp);
|
|
goto error;
|
|
}
|
|
if ((uintmax_t)st.st_size > SIZE_MAX) {
|
|
PyErr_SetString(PyExc_OverflowError, "File is too large to map");
|
|
Py_fclose(fp);
|
|
goto error;
|
|
}
|
|
reader->mapped_size = st.st_size;
|
|
if (reader->mapped_size == 0) {
|
|
PyErr_SetString(PyExc_ValueError, "File too small for header");
|
|
Py_fclose(fp);
|
|
goto error;
|
|
}
|
|
|
|
/* Map the file into memory.
|
|
* MAP_POPULATE (Linux-only) pre-faults all pages at mmap time, which:
|
|
* - Catches issues (e.g., file truncation) immediately rather than as SIGBUS during reads
|
|
* - Eliminates page faults during subsequent reads for better performance
|
|
*/
|
|
#ifdef __linux__
|
|
reader->mapped_data = mmap(NULL, reader->mapped_size, PROT_READ,
|
|
MAP_PRIVATE | MAP_POPULATE, fd, 0);
|
|
#else
|
|
reader->mapped_data = mmap(NULL, reader->mapped_size, PROT_READ,
|
|
MAP_PRIVATE, fd, 0);
|
|
#endif
|
|
if (reader->mapped_data == MAP_FAILED) {
|
|
reader->mapped_data = NULL;
|
|
PyErr_SetFromErrno(PyExc_IOError);
|
|
Py_fclose(fp);
|
|
goto error;
|
|
}
|
|
|
|
/* Hint sequential access pattern - failures are non-fatal */
|
|
(void)madvise(reader->mapped_data, reader->mapped_size, MADV_SEQUENTIAL);
|
|
|
|
/* Pre-fetch pages into memory - failures are non-fatal.
|
|
* Complements MAP_POPULATE on Linux, provides benefit on macOS. */
|
|
(void)madvise(reader->mapped_data, reader->mapped_size, MADV_WILLNEED);
|
|
|
|
/* Use transparent huge pages for large files to reduce TLB misses.
|
|
* Only beneficial for files >= 32MB where TLB pressure matters. */
|
|
#ifdef MADV_HUGEPAGE
|
|
if (reader->mapped_size >= (32 * 1024 * 1024)) {
|
|
(void)madvise(reader->mapped_data, reader->mapped_size, MADV_HUGEPAGE);
|
|
}
|
|
#endif
|
|
|
|
/* Add file descriptor-level hints for better kernel I/O scheduling */
|
|
#if defined(__linux__) && defined(POSIX_FADV_SEQUENTIAL)
|
|
(void)posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL);
|
|
if (reader->mapped_size > (64 * 1024 * 1024)) {
|
|
(void)posix_fadvise(fd, 0, 0, POSIX_FADV_WILLNEED);
|
|
}
|
|
#endif
|
|
|
|
if (Py_fclose(fp) != 0) {
|
|
PyErr_SetFromErrno(PyExc_IOError);
|
|
goto error;
|
|
}
|
|
|
|
uint8_t *data = reader->mapped_data;
|
|
size_t file_size = reader->mapped_size;
|
|
#else
|
|
/* Use stdio on Windows */
|
|
reader->fp = Py_fopen(path, "rb");
|
|
if (!reader->fp) {
|
|
goto error;
|
|
}
|
|
|
|
if (FSEEK64(reader->fp, 0, SEEK_END) != 0) {
|
|
PyErr_SetFromErrno(PyExc_IOError);
|
|
goto error;
|
|
}
|
|
file_offset_t file_size_off = FTELL64(reader->fp);
|
|
if (file_size_off < 0) {
|
|
PyErr_SetFromErrno(PyExc_IOError);
|
|
goto error;
|
|
}
|
|
if ((uint64_t)file_size_off > SIZE_MAX) {
|
|
PyErr_SetString(PyExc_OverflowError, "File is too large to read");
|
|
goto error;
|
|
}
|
|
reader->file_size = (size_t)file_size_off;
|
|
if (reader->file_size == 0) {
|
|
PyErr_SetString(PyExc_ValueError, "File too small for header");
|
|
goto error;
|
|
}
|
|
if (FSEEK64(reader->fp, 0, SEEK_SET) != 0) {
|
|
PyErr_SetFromErrno(PyExc_IOError);
|
|
goto error;
|
|
}
|
|
|
|
reader->file_data = PyMem_Malloc(reader->file_size);
|
|
if (!reader->file_data) {
|
|
PyErr_NoMemory();
|
|
goto error;
|
|
}
|
|
|
|
size_t nread = fread(reader->file_data, 1, reader->file_size, reader->fp);
|
|
if (nread != reader->file_size) {
|
|
int err = errno;
|
|
if (ferror(reader->fp) && err != 0) {
|
|
errno = err;
|
|
PyErr_SetFromErrno(PyExc_IOError);
|
|
}
|
|
else {
|
|
PyErr_Format(PyExc_ValueError,
|
|
"Unexpected end of file: read %zu of %zu bytes",
|
|
nread, reader->file_size);
|
|
}
|
|
goto error;
|
|
}
|
|
|
|
uint8_t *data = reader->file_data;
|
|
size_t file_size = reader->file_size;
|
|
#endif
|
|
|
|
/* Parse header and footer */
|
|
if (reader_parse_header(reader, data, file_size) < 0) {
|
|
goto error;
|
|
}
|
|
if (reader_parse_footer(reader, data, file_size) < 0) {
|
|
goto error;
|
|
}
|
|
if (reader_parse_profile_stats(reader, data, file_size) < 0) {
|
|
goto error;
|
|
}
|
|
|
|
/* Validate table offsets are within file bounds */
|
|
if (reader->string_table_offset > file_size) {
|
|
PyErr_Format(PyExc_ValueError,
|
|
"Invalid string table offset: %llu exceeds file size %zu",
|
|
(unsigned long long)reader->string_table_offset, file_size);
|
|
goto error;
|
|
}
|
|
if (reader->frame_table_offset > file_size) {
|
|
PyErr_Format(PyExc_ValueError,
|
|
"Invalid frame table offset: %llu exceeds file size %zu",
|
|
(unsigned long long)reader->frame_table_offset, file_size);
|
|
goto error;
|
|
}
|
|
if (reader->string_table_offset < FILE_HEADER_PLACEHOLDER_SIZE) {
|
|
PyErr_Format(PyExc_ValueError,
|
|
"Invalid string table offset: %llu is before data section",
|
|
(unsigned long long)reader->string_table_offset);
|
|
goto error;
|
|
}
|
|
if (reader->frame_table_offset < FILE_HEADER_PLACEHOLDER_SIZE) {
|
|
PyErr_Format(PyExc_ValueError,
|
|
"Invalid frame table offset: %llu is before data section",
|
|
(unsigned long long)reader->frame_table_offset);
|
|
goto error;
|
|
}
|
|
if (reader->string_table_offset > reader->frame_table_offset) {
|
|
PyErr_Format(PyExc_ValueError,
|
|
"Invalid table offsets: string table (%llu) is after frame table (%llu)",
|
|
(unsigned long long)reader->string_table_offset,
|
|
(unsigned long long)reader->frame_table_offset);
|
|
goto error;
|
|
}
|
|
|
|
if (reader->compression_type == COMPRESSION_ZSTD) {
|
|
#ifdef HAVE_ZSTD
|
|
reader->dctx = ZSTD_createDCtx();
|
|
if (!reader->dctx) {
|
|
PyErr_SetString(PyExc_MemoryError, "Failed to create zstd decompression context");
|
|
goto error;
|
|
}
|
|
#else
|
|
PyErr_SetString(PyExc_RuntimeError,
|
|
"File uses zstd compression but zstd support not compiled in");
|
|
goto error;
|
|
#endif
|
|
}
|
|
reader->sample_data = data + FILE_HEADER_PLACEHOLDER_SIZE;
|
|
reader->sample_data_size =
|
|
(size_t)reader->string_table_offset - FILE_HEADER_PLACEHOLDER_SIZE;
|
|
|
|
/* Parse string and frame tables */
|
|
if (reader_parse_string_table(reader, data, file_size) < 0) {
|
|
goto error;
|
|
}
|
|
if (reader_parse_frame_table(reader, data, file_size) < 0) {
|
|
goto error;
|
|
}
|
|
|
|
return reader;
|
|
|
|
error:
|
|
binary_reader_close(reader);
|
|
return NULL;
|
|
}
|
|
|
|
/* Get or create reader thread state for stack reconstruction */
|
|
static ThreadEntry *
|
|
reader_get_or_create_thread_state(BinaryReader *reader, uint64_t thread_id,
|
|
uint32_t interpreter_id)
|
|
{
|
|
/* Search existing threads (key is thread_id + interpreter_id) */
|
|
for (size_t i = 0; i < reader->thread_state_count; i++) {
|
|
if (reader->thread_states[i].thread_id == thread_id &&
|
|
reader->thread_states[i].interpreter_id == interpreter_id) {
|
|
return &reader->thread_states[i];
|
|
}
|
|
}
|
|
|
|
if (reader->thread_state_count >= reader->thread_count) {
|
|
PyErr_Format(PyExc_ValueError,
|
|
"Invalid thread count: sample data contains more unique threads than declared in header "
|
|
"(declared %u, found at least %zu)",
|
|
reader->thread_count, reader->thread_state_count + 1);
|
|
return NULL;
|
|
}
|
|
|
|
if (!reader->thread_states) {
|
|
reader->thread_state_capacity = 16;
|
|
reader->thread_states = PyMem_Calloc(reader->thread_state_capacity, sizeof(ThreadEntry));
|
|
if (!reader->thread_states) {
|
|
PyErr_NoMemory();
|
|
return NULL;
|
|
}
|
|
}
|
|
else if (GROW_ARRAY(reader->thread_states, reader->thread_state_count,
|
|
reader->thread_state_capacity, ThreadEntry) < 0) {
|
|
return NULL;
|
|
}
|
|
|
|
ThreadEntry *ts = &reader->thread_states[reader->thread_state_count];
|
|
memset(ts, 0, sizeof(ThreadEntry));
|
|
ts->thread_id = thread_id;
|
|
ts->interpreter_id = interpreter_id;
|
|
reader->thread_state_count++;
|
|
return ts;
|
|
}
|
|
|
|
static PyObject *
|
|
reader_get_frame_info(RemoteDebuggingState *state, BinaryReader *reader,
|
|
uint32_t frame_index)
|
|
{
|
|
if (frame_index >= reader->frames_count) {
|
|
PyErr_Format(PyExc_ValueError, "Invalid frame index: %u", frame_index);
|
|
return NULL;
|
|
}
|
|
if (reader->frame_info_cache == NULL) {
|
|
size_t cache_size = Py_MIN(reader->frames_count,
|
|
(uint32_t)FRAME_INFO_CACHE_SIZE);
|
|
reader->frame_info_cache = PyMem_Calloc(
|
|
cache_size, sizeof(*reader->frame_info_cache));
|
|
if (reader->frame_info_cache == NULL) {
|
|
PyErr_NoMemory();
|
|
return NULL;
|
|
}
|
|
reader->frame_info_cache_size = cache_size;
|
|
}
|
|
ReaderFrameCacheEntry *entry = &reader->frame_info_cache[
|
|
frame_index % reader->frame_info_cache_size];
|
|
if (entry->frame_info != NULL && entry->frame_index == frame_index) {
|
|
return Py_NewRef(entry->frame_info);
|
|
}
|
|
|
|
FrameEntry *frame = &reader->frames[frame_index];
|
|
if (frame->filename_idx >= reader->strings_count ||
|
|
frame->funcname_idx >= reader->strings_count) {
|
|
PyErr_SetString(PyExc_ValueError, "Invalid string index in frame");
|
|
return NULL;
|
|
}
|
|
|
|
PyObject *frame_info = PyStructSequence_New(state->FrameInfo_Type);
|
|
if (!frame_info) {
|
|
return NULL;
|
|
}
|
|
|
|
/* Build location tuple with full position info */
|
|
PyObject *location;
|
|
if (frame->lineno != LOCATION_NOT_AVAILABLE) {
|
|
location = Py_BuildValue("(iiii)",
|
|
frame->lineno,
|
|
frame->end_lineno,
|
|
frame->column,
|
|
frame->end_column);
|
|
if (!location) {
|
|
Py_DECREF(frame_info);
|
|
return NULL;
|
|
}
|
|
}
|
|
else {
|
|
location = Py_NewRef(Py_None);
|
|
}
|
|
|
|
/* Build opcode object */
|
|
PyObject *opcode_obj;
|
|
if (frame->opcode != OPCODE_NONE) {
|
|
opcode_obj = PyLong_FromLong(frame->opcode);
|
|
if (!opcode_obj) {
|
|
Py_DECREF(location);
|
|
Py_DECREF(frame_info);
|
|
return NULL;
|
|
}
|
|
}
|
|
else {
|
|
opcode_obj = Py_NewRef(Py_None);
|
|
}
|
|
|
|
PyStructSequence_SetItem(frame_info, 0, Py_NewRef(reader->strings[frame->filename_idx]));
|
|
PyStructSequence_SetItem(frame_info, 1, location);
|
|
PyStructSequence_SetItem(frame_info, 2, Py_NewRef(reader->strings[frame->funcname_idx]));
|
|
PyStructSequence_SetItem(frame_info, 3, opcode_obj);
|
|
Py_XSETREF(entry->frame_info, Py_NewRef(frame_info));
|
|
entry->frame_index = frame_index;
|
|
return frame_info;
|
|
}
|
|
|
|
/* Build a Python list of FrameInfo objects from frame indices. Stacks are
|
|
* kept outermost first, but collectors expect innermost first. */
|
|
static PyObject *
|
|
build_frame_list(RemoteDebuggingState *state, BinaryReader *reader,
|
|
const uint32_t *frame_indices, size_t stack_depth)
|
|
{
|
|
PyObject *frame_list = PyList_New(stack_depth);
|
|
if (!frame_list) {
|
|
return NULL;
|
|
}
|
|
|
|
for (size_t k = 0; k < stack_depth; k++) {
|
|
PyObject *frame_info = reader_get_frame_info(
|
|
state, reader, frame_indices[stack_depth - 1 - k]);
|
|
if (frame_info == NULL) {
|
|
goto error;
|
|
}
|
|
PyList_SET_ITEM(frame_list, k, frame_info);
|
|
}
|
|
|
|
return frame_list;
|
|
|
|
error:
|
|
Py_DECREF(frame_list);
|
|
return NULL;
|
|
}
|
|
|
|
/* Helper to build sample_list from frame indices (shared by emit functions) */
|
|
static PyObject *
|
|
build_sample_list(RemoteDebuggingState *state, BinaryReader *reader,
|
|
uint64_t thread_id, uint32_t interpreter_id, uint8_t status,
|
|
const uint32_t *frame_indices, size_t stack_depth)
|
|
{
|
|
PyObject *frame_list = NULL, *thread_info = NULL, *thread_list = NULL;
|
|
PyObject *interp_info = NULL, *sample_list = NULL;
|
|
|
|
frame_list = build_frame_list(state, reader, frame_indices, stack_depth);
|
|
if (!frame_list) {
|
|
goto error;
|
|
}
|
|
|
|
thread_info = PyStructSequence_New(state->ThreadInfo_Type);
|
|
if (!thread_info) {
|
|
goto error;
|
|
}
|
|
PyObject *tid = PyLong_FromUnsignedLongLong(thread_id);
|
|
if (!tid) {
|
|
goto error;
|
|
}
|
|
PyObject *st = PyLong_FromLong(status);
|
|
if (!st) {
|
|
Py_DECREF(tid);
|
|
goto error;
|
|
}
|
|
PyStructSequence_SetItem(thread_info, 0, tid);
|
|
PyStructSequence_SetItem(thread_info, 1, st);
|
|
PyStructSequence_SetItem(thread_info, 2, frame_list);
|
|
frame_list = NULL; /* ownership transferred */
|
|
|
|
thread_list = PyList_New(1);
|
|
if (!thread_list) {
|
|
goto error;
|
|
}
|
|
PyList_SET_ITEM(thread_list, 0, thread_info);
|
|
thread_info = NULL;
|
|
|
|
interp_info = PyStructSequence_New(state->InterpreterInfo_Type);
|
|
if (!interp_info) {
|
|
goto error;
|
|
}
|
|
PyObject *iid = PyLong_FromUnsignedLong(interpreter_id);
|
|
if (!iid) {
|
|
goto error;
|
|
}
|
|
PyStructSequence_SetItem(interp_info, 0, iid);
|
|
PyStructSequence_SetItem(interp_info, 1, thread_list);
|
|
thread_list = NULL;
|
|
|
|
sample_list = PyList_New(1);
|
|
if (!sample_list) {
|
|
goto error;
|
|
}
|
|
PyList_SET_ITEM(sample_list, 0, interp_info);
|
|
return sample_list;
|
|
|
|
error:
|
|
Py_XDECREF(sample_list);
|
|
Py_XDECREF(interp_info);
|
|
Py_XDECREF(thread_list);
|
|
Py_XDECREF(thread_info);
|
|
Py_XDECREF(frame_list);
|
|
return NULL;
|
|
}
|
|
|
|
/* Helper to emit a sample to the collector. timestamps_list is borrowed. */
|
|
static int
|
|
emit_sample(RemoteDebuggingState *state, PyObject *collector,
|
|
uint64_t thread_id, uint32_t interpreter_id, uint8_t status,
|
|
const uint32_t *frame_indices, size_t stack_depth,
|
|
BinaryReader *reader, PyObject *timestamps_list)
|
|
{
|
|
PyObject *sample_list = build_sample_list(state, reader, thread_id,
|
|
interpreter_id, status,
|
|
frame_indices, stack_depth);
|
|
if (!sample_list) {
|
|
return -1;
|
|
}
|
|
|
|
PyObject *result = PyObject_CallMethod(collector, "collect", "OO", sample_list, timestamps_list);
|
|
Py_DECREF(sample_list);
|
|
|
|
if (!result) {
|
|
return -1;
|
|
}
|
|
Py_DECREF(result);
|
|
return 0;
|
|
}
|
|
|
|
/* Helper to invoke progress callback, returns -1 on error */
|
|
static inline int
|
|
invoke_progress_callback(PyObject *callback, Py_ssize_t current, uint64_t total)
|
|
{
|
|
if (callback && callback != Py_None) {
|
|
PyObject *result = PyObject_CallFunction(callback, "nK", current, (unsigned long long)total);
|
|
if (result) {
|
|
Py_DECREF(result);
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* ============================================================================
|
|
* SAMPLE BLOCKS
|
|
* ============================================================================ */
|
|
|
|
static int
|
|
block_error(const char *message)
|
|
{
|
|
PyErr_Format(PyExc_ValueError, "Invalid sample block: %s", message);
|
|
return -1;
|
|
}
|
|
|
|
static inline int
|
|
block_read_varint(const ByteBuffer *column, size_t *offset, uint64_t *value)
|
|
{
|
|
size_t prev_offset = *offset;
|
|
*value = decode_varint_u64(column->data, offset, column->size);
|
|
return *offset == prev_offset ? -1 : 0;
|
|
}
|
|
|
|
static int
|
|
block_read_varint_u32(const ByteBuffer *column, size_t *offset,
|
|
uint32_t *value)
|
|
{
|
|
size_t prev_offset = *offset;
|
|
*value = decode_varint_u32(column->data, offset, column->size);
|
|
return *offset == prev_offset ? -1 : 0;
|
|
}
|
|
|
|
static int
|
|
reader_parse_block_header(BinaryReader *reader, const ByteBuffer *section,
|
|
size_t *offset, BlockHeader *header)
|
|
{
|
|
/* Block magic "TBLK" */
|
|
if (section->size - *offset < BLOCK_MAGIC_SIZE) {
|
|
return block_error("truncated header");
|
|
}
|
|
if (memcmp(section->data + *offset, BLOCK_MAGIC, BLOCK_MAGIC_SIZE) != 0) {
|
|
return block_error("wrong magic");
|
|
}
|
|
*offset += BLOCK_MAGIC_SIZE;
|
|
|
|
/* Sample count and base timestamp (varints) */
|
|
if (block_read_varint_u32(section, offset, &header->sample_count) < 0 ||
|
|
block_read_varint(section, offset, &header->base_timestamp) < 0) {
|
|
return -1;
|
|
}
|
|
|
|
/* Frame ID width and the two status flag masks (1 byte each) */
|
|
if (section->size - *offset < 3) {
|
|
return block_error("truncated header");
|
|
}
|
|
header->frame_width = section->data[(*offset)++];
|
|
header->common_status_flags = section->data[(*offset)++];
|
|
header->status_bitmap_flags = section->data[(*offset)++];
|
|
if (header->sample_count == 0) {
|
|
return block_error("no samples");
|
|
}
|
|
if (header->frame_width < 1 || header->frame_width > sizeof(uint32_t)) {
|
|
return block_error("frame ID width out of range");
|
|
}
|
|
if (header->common_status_flags & header->status_bitmap_flags) {
|
|
return block_error("common and varying status flags overlap");
|
|
}
|
|
|
|
size_t decoded_total = 0;
|
|
for (unsigned column = 0; column < COLUMN_COUNT; column++) {
|
|
ColumnDescriptor *descriptor = &header->columns[column];
|
|
/* Decoded size (varint) and encoding (1 byte) */
|
|
if (block_read_varint_u32(section, offset,
|
|
&descriptor->decoded_size) < 0) {
|
|
return -1;
|
|
}
|
|
if (*offset >= section->size) {
|
|
return block_error("truncated column descriptor");
|
|
}
|
|
descriptor->encoding = section->data[(*offset)++];
|
|
|
|
/* Stored size: implied for raw and constant, a varint for zstd */
|
|
switch (descriptor->encoding) {
|
|
case COMPRESSION_NONE:
|
|
descriptor->stored_size = descriptor->decoded_size;
|
|
break;
|
|
case COLUMN_CONSTANT:
|
|
descriptor->stored_size = 1;
|
|
break;
|
|
case COMPRESSION_ZSTD:
|
|
if (reader->compression_type != COMPRESSION_ZSTD) {
|
|
return block_error("zstd column in an uncompressed file");
|
|
}
|
|
if (block_read_varint_u32(section, offset,
|
|
&descriptor->stored_size) < 0) {
|
|
return -1;
|
|
}
|
|
break;
|
|
default:
|
|
return block_error("unknown column encoding");
|
|
}
|
|
|
|
if (descriptor->encoding != COMPRESSION_NONE &&
|
|
descriptor->decoded_size == 0) {
|
|
return block_error("encoded column is empty");
|
|
}
|
|
if (descriptor->decoded_size > MAX_BLOCK_SIZE - decoded_total) {
|
|
return block_error("decoded columns exceed the block limit");
|
|
}
|
|
decoded_total += descriptor->decoded_size;
|
|
}
|
|
|
|
/* Each sample needs at least one byte of stream index and residual */
|
|
if (header->sample_count >
|
|
header->columns[COLUMN_SAMPLE_STREAM_IDS].decoded_size ||
|
|
header->sample_count >
|
|
header->columns[COLUMN_TIMESTAMP_RESIDUALS].decoded_size) {
|
|
return block_error("more samples than stored stream indices");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* A constant stream index or residual column that holds the same one-byte
|
|
* varint for every sample is read from its stored byte, not expanded. */
|
|
static int
|
|
constant_varint_column(const DecodedBlock *block, unsigned column,
|
|
uint8_t value)
|
|
{
|
|
const ColumnDescriptor *descriptor = &block->header.columns[column];
|
|
return (column == COLUMN_SAMPLE_STREAM_IDS ||
|
|
column == COLUMN_TIMESTAMP_RESIDUALS) &&
|
|
descriptor->encoding == COLUMN_CONSTANT &&
|
|
descriptor->decoded_size == block->header.sample_count &&
|
|
value < 0x80;
|
|
}
|
|
|
|
static int
|
|
decode_block_columns(BinaryReader *reader, const ByteBuffer *section,
|
|
size_t *offset, DecodedBlock *block)
|
|
{
|
|
const ColumnDescriptor *descriptors = block->header.columns;
|
|
/* Find where each column is stored and how much of the shared buffer
|
|
* the expanded and decompressed columns need. The buffer is reused
|
|
* across blocks and reserved up front so decoded columns never move. */
|
|
uint8_t *stored[COLUMN_COUNT];
|
|
size_t buffered_total = 0;
|
|
for (unsigned column = 0; column < COLUMN_COUNT; column++) {
|
|
const ColumnDescriptor *descriptor = &descriptors[column];
|
|
if (descriptor->stored_size > section->size - *offset) {
|
|
return block_error("column extends past the sample section");
|
|
}
|
|
stored[column] = section->data + *offset;
|
|
*offset += descriptor->stored_size;
|
|
if (descriptor->encoding == COMPRESSION_ZSTD ||
|
|
(descriptor->encoding == COLUMN_CONSTANT &&
|
|
!constant_varint_column(block, column, stored[column][0]))) {
|
|
buffered_total += descriptor->decoded_size;
|
|
}
|
|
}
|
|
ByteBuffer *buffer = &reader->block_data;
|
|
if (buffer_reserve(buffer, buffered_total) < 0) {
|
|
return -1;
|
|
}
|
|
|
|
buffer->size = 0;
|
|
for (unsigned column = 0; column < COLUMN_COUNT; column++) {
|
|
const ColumnDescriptor *descriptor = &descriptors[column];
|
|
uint8_t *stored_data = stored[column];
|
|
ByteBuffer *decoded = &block->columns[column];
|
|
decoded->size = descriptor->decoded_size;
|
|
switch (descriptor->encoding) {
|
|
case COMPRESSION_NONE:
|
|
/* Raw columns point into the file data */
|
|
decoded->data = stored_data;
|
|
break;
|
|
case COLUMN_CONSTANT:
|
|
if (constant_varint_column(block, column, stored_data[0])) {
|
|
decoded->data = stored_data;
|
|
decoded->size = 1;
|
|
break;
|
|
}
|
|
decoded->data = buffer->data + buffer->size;
|
|
memset(decoded->data, stored_data[0], decoded->size);
|
|
buffer->size += decoded->size;
|
|
break;
|
|
case COMPRESSION_ZSTD:
|
|
decoded->data = buffer->data + buffer->size;
|
|
if (reader_decompress(reader, stored_data,
|
|
descriptor->stored_size, buffer,
|
|
decoded->size) < 0) {
|
|
return -1;
|
|
}
|
|
break;
|
|
default:
|
|
return block_error("unknown column encoding");
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
validate_block_columns(DecodedBlock *block)
|
|
{
|
|
size_t stream_table_size = block->columns[COLUMN_STREAM_TABLE].size;
|
|
if (stream_table_size % STREAM_ENTRY_SIZE != 0) {
|
|
return block_error("stream table has a partial entry");
|
|
}
|
|
size_t stream_count = stream_table_size / STREAM_ENTRY_SIZE;
|
|
if (stream_count == 0 || stream_count > MAX_BLOCK_STREAMS) {
|
|
return block_error("stream count out of range");
|
|
}
|
|
block->stream_count = (uint32_t)stream_count;
|
|
|
|
size_t frame_ids_size = block->columns[COLUMN_FRAME_IDS].size;
|
|
if (frame_ids_size % block->header.frame_width != 0) {
|
|
return block_error("frame ID column has a partial value");
|
|
}
|
|
block->frame_count =
|
|
(uint32_t)(frame_ids_size / block->header.frame_width);
|
|
|
|
size_t plane_size = status_bitmap_size(block->header.sample_count);
|
|
size_t plane_count =
|
|
(size_t)_Py_popcount32(block->header.status_bitmap_flags);
|
|
const ByteBuffer *statuses = &block->columns[COLUMN_STATUS_BITMAPS];
|
|
if (statuses->size != plane_size * plane_count) {
|
|
return block_error("status bitmaps have the wrong size");
|
|
}
|
|
unsigned used_bits = block->header.sample_count % CHAR_BIT;
|
|
for (size_t plane = 0; used_bits && plane < plane_count; plane++) {
|
|
if (statuses->data[(plane + 1) * plane_size - 1] >> used_bits) {
|
|
return block_error("status bitmap padding is not zero");
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
reserve_block_streams(BinaryReader *reader, uint32_t stream_count)
|
|
{
|
|
if (stream_count <= reader->block_stream_capacity) {
|
|
return 0;
|
|
}
|
|
ReaderBlockStream *streams = PyMem_Realloc(
|
|
reader->block_streams, stream_count * sizeof(ReaderBlockStream));
|
|
if (streams == NULL) {
|
|
PyErr_NoMemory();
|
|
return -1;
|
|
}
|
|
reader->block_streams = streams;
|
|
reader->block_stream_capacity = stream_count;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
reader_parse_stream_table(BinaryReader *reader, const DecodedBlock *block)
|
|
{
|
|
const uint8_t *stream_table = block->columns[COLUMN_STREAM_TABLE].data;
|
|
uint64_t initial_prev_timestamp =
|
|
block->header.base_timestamp - reader->sample_interval_us;
|
|
memset(reader->block_streams, 0,
|
|
block->stream_count * sizeof(ReaderBlockStream));
|
|
for (uint32_t i = 0; i < block->stream_count; i++) {
|
|
/* Read thread_id (8 bytes) + interpreter_id (4 bytes) */
|
|
const uint8_t *entry = stream_table + (size_t)i * STREAM_ENTRY_SIZE;
|
|
uint64_t thread_id;
|
|
uint32_t interpreter_id;
|
|
memcpy(&thread_id, entry + STM_OFF_THREAD_ID, STM_SIZE_THREAD_ID);
|
|
memcpy(&interpreter_id, entry + STM_OFF_INTERPRETER_ID,
|
|
STM_SIZE_INTERPRETER_ID);
|
|
ThreadEntry *thread = reader_get_or_create_thread_state(
|
|
reader, SWAP64_IF(reader->needs_swap, thread_id),
|
|
SWAP32_IF(reader->needs_swap, interpreter_id));
|
|
if (thread == NULL) {
|
|
return -1;
|
|
}
|
|
/* Each thread may appear only once in a block. An index left over
|
|
* from an earlier block points at a different thread here. */
|
|
uint32_t previous_index = thread->block_stream_index;
|
|
if (previous_index < i &&
|
|
reader->block_streams[previous_index].thread_id ==
|
|
thread->thread_id &&
|
|
reader->block_streams[previous_index].interpreter_id ==
|
|
thread->interpreter_id) {
|
|
return block_error("stream table repeats a thread");
|
|
}
|
|
thread->block_stream_index = i;
|
|
|
|
/* Each stream's first expected timestamp is the base timestamp */
|
|
ReaderBlockStream *stream = &reader->block_streams[i];
|
|
stream->thread_id = thread->thread_id;
|
|
stream->interpreter_id = thread->interpreter_id;
|
|
stream->prev_timestamp = initial_prev_timestamp;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
decode_samples(BinaryReader *reader, DecodedBlock *block)
|
|
{
|
|
size_t sample_count = block->header.sample_count;
|
|
if (buffer_reserve(&reader->block_stream_ids,
|
|
sample_count * sizeof(uint32_t)) < 0 ||
|
|
buffer_reserve(&reader->block_timestamps,
|
|
sample_count * sizeof(uint64_t)) < 0) {
|
|
return -1;
|
|
}
|
|
uint32_t *stream_ids = (uint32_t *)reader->block_stream_ids.data;
|
|
uint64_t *timestamps = (uint64_t *)reader->block_timestamps.data;
|
|
const ByteBuffer *stream_id_column =
|
|
&block->columns[COLUMN_SAMPLE_STREAM_IDS];
|
|
const ByteBuffer *residual_column =
|
|
&block->columns[COLUMN_TIMESTAMP_RESIDUALS];
|
|
int constant_stream_ids = constant_varint_column(
|
|
block, COLUMN_SAMPLE_STREAM_IDS, stream_id_column->data[0]);
|
|
int constant_residuals = constant_varint_column(
|
|
block, COLUMN_TIMESTAMP_RESIDUALS, residual_column->data[0]);
|
|
size_t stream_id_offset = 0;
|
|
size_t residual_offset = 0;
|
|
int64_t constant_residual = 0;
|
|
if (constant_residuals) {
|
|
constant_residual = decode_varint_i64(residual_column->data,
|
|
&residual_offset, 1);
|
|
}
|
|
for (uint32_t sample = 0; sample < block->header.sample_count; sample++) {
|
|
uint64_t stream_id;
|
|
if (constant_stream_ids) {
|
|
stream_id = stream_id_column->data[0];
|
|
}
|
|
else if (block_read_varint(stream_id_column, &stream_id_offset,
|
|
&stream_id) < 0) {
|
|
return -1;
|
|
}
|
|
if (stream_id >= block->stream_count) {
|
|
return block_error("sample refers to an unknown stream");
|
|
}
|
|
int64_t residual = constant_residual;
|
|
if (!constant_residuals) {
|
|
size_t prev_offset = residual_offset;
|
|
residual = decode_varint_i64(residual_column->data,
|
|
&residual_offset,
|
|
residual_column->size);
|
|
if (residual_offset == prev_offset) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/* Timestamp is the expected time plus the stored residual */
|
|
ReaderBlockStream *stream = &reader->block_streams[stream_id];
|
|
stream->prev_timestamp +=
|
|
reader->sample_interval_us + (uint64_t)residual;
|
|
|
|
stream_ids[sample] = (uint32_t)stream_id;
|
|
timestamps[sample] = stream->prev_timestamp;
|
|
}
|
|
if (!constant_stream_ids && stream_id_offset != stream_id_column->size) {
|
|
return block_error("stream index column has trailing data");
|
|
}
|
|
if (residual_offset != residual_column->size) {
|
|
return block_error("timestamp column has trailing data");
|
|
}
|
|
block->stream_ids = stream_ids;
|
|
block->timestamps = timestamps;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
decode_statuses(BinaryReader *reader, DecodedBlock *block)
|
|
{
|
|
if (buffer_reserve(&reader->block_statuses,
|
|
block->header.sample_count) < 0) {
|
|
return -1;
|
|
}
|
|
/* Start from the common flags, then add each varying flag's bitmap */
|
|
uint8_t *statuses = reader->block_statuses.data;
|
|
memset(statuses, block->header.common_status_flags,
|
|
block->header.sample_count);
|
|
const uint8_t *plane = block->columns[COLUMN_STATUS_BITMAPS].data;
|
|
size_t plane_size = status_bitmap_size(block->header.sample_count);
|
|
for (unsigned bit = 0; bit < CHAR_BIT; bit++) {
|
|
if (!(block->header.status_bitmap_flags & (1U << bit))) {
|
|
continue;
|
|
}
|
|
for (uint32_t i = 0; i < block->header.sample_count; i++) {
|
|
statuses[i] |= ((plane[i / CHAR_BIT] >> (i % CHAR_BIT)) & 1U)
|
|
<< bit;
|
|
}
|
|
plane += plane_size;
|
|
}
|
|
block->statuses = statuses;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
decode_frame_ids(BinaryReader *reader, DecodedBlock *block)
|
|
{
|
|
size_t frame_count = block->frame_count;
|
|
size_t frames_size = frame_count * sizeof(uint32_t);
|
|
if (buffer_reserve(&reader->block_frames, frames_size) < 0) {
|
|
return -1;
|
|
}
|
|
uint32_t *frames = (uint32_t *)reader->block_frames.data;
|
|
block->frames = frames;
|
|
if (frame_count == 0) {
|
|
return 0;
|
|
}
|
|
|
|
/* Combine byte b of every frame index from plane b, low byte first */
|
|
memset(frames, 0, frames_size);
|
|
const uint8_t *plane = block->columns[COLUMN_FRAME_IDS].data;
|
|
for (unsigned byte = 0; byte < block->header.frame_width; byte++) {
|
|
for (size_t i = 0; i < frame_count; i++) {
|
|
frames[i] |= (uint32_t)plane[i] << (byte * CHAR_BIT);
|
|
}
|
|
plane += frame_count;
|
|
}
|
|
for (size_t i = 0; i < frame_count; i++) {
|
|
if (frames[i] >= reader->frames_count) {
|
|
return block_error("frame index out of range");
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
decode_block(BinaryReader *reader, const ByteBuffer *section,
|
|
size_t *offset, DecodedBlock *block)
|
|
{
|
|
block->instruction_offset = 0;
|
|
block->frame_offset = 0;
|
|
if (reader_parse_block_header(reader, section, offset,
|
|
&block->header) < 0 ||
|
|
decode_block_columns(reader, section, offset, block) < 0 ||
|
|
validate_block_columns(block) < 0 ||
|
|
reserve_block_streams(reader, block->stream_count) < 0 ||
|
|
reader_parse_stream_table(reader, block) < 0 ||
|
|
decode_samples(reader, block) < 0 ||
|
|
decode_statuses(reader, block) < 0 ||
|
|
decode_frame_ids(reader, block) < 0) {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
flush_stream_batch(BinaryReader *reader, RemoteDebuggingState *state,
|
|
PyObject *collector, ReaderBlockStream *stream)
|
|
{
|
|
if (stream->batch == NULL) {
|
|
return 0;
|
|
}
|
|
int result = emit_sample(state, collector, stream->thread_id,
|
|
stream->interpreter_id, stream->batch_status,
|
|
stream->current_stack,
|
|
stream->current_stack_depth, reader,
|
|
stream->batch);
|
|
Py_CLEAR(stream->batch);
|
|
return result;
|
|
}
|
|
|
|
static int
|
|
decode_stack_repeat(BinaryReader *reader, DecodedBlock *block,
|
|
ReaderBlockStream *stream)
|
|
{
|
|
const ByteBuffer *instructions =
|
|
&block->columns[COLUMN_STACK_INSTRUCTIONS];
|
|
size_t *offset = &block->instruction_offset;
|
|
uint64_t count;
|
|
if (block_read_varint(instructions, offset, &count) < 0) {
|
|
return -1;
|
|
}
|
|
if (!stream->has_stack) {
|
|
return block_error("first stack of a stream cannot repeat");
|
|
}
|
|
if (count == 0 || count > block->header.sample_count) {
|
|
return block_error("repeat count out of range");
|
|
}
|
|
stream->pending_repeats = (uint32_t)(count - 1);
|
|
reader->stats.repeat_records++;
|
|
reader->stats.repeat_samples++;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
decode_stack_replace_suffix(BinaryReader *reader, DecodedBlock *block,
|
|
ReaderBlockStream *stream)
|
|
{
|
|
const ByteBuffer *instructions =
|
|
&block->columns[COLUMN_STACK_INSTRUCTIONS];
|
|
size_t *offset = &block->instruction_offset;
|
|
uint64_t keep, count;
|
|
if (block_read_varint(instructions, offset, &keep) < 0 ||
|
|
block_read_varint(instructions, offset, &count) < 0) {
|
|
return -1;
|
|
}
|
|
if (keep > stream->current_stack_depth || count > MAX_STACK_DEPTH - keep) {
|
|
return block_error("stack prefix out of range");
|
|
}
|
|
if (count > block->frame_count - block->frame_offset) {
|
|
return block_error("stack uses more frame IDs than stored");
|
|
}
|
|
if (count > 0) {
|
|
memcpy(&stream->current_stack[keep],
|
|
&block->frames[block->frame_offset], count * sizeof(uint32_t));
|
|
}
|
|
block->frame_offset += (uint32_t)count;
|
|
stream->current_stack_depth = (size_t)(keep + count);
|
|
if (keep == 0) {
|
|
reader->stats.full_records++;
|
|
}
|
|
else {
|
|
reader->stats.suffix_records++;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
decode_stack_reuse(BinaryReader *reader, DecodedBlock *block,
|
|
ReaderBlockStream *stream)
|
|
{
|
|
const ByteBuffer *instructions =
|
|
&block->columns[COLUMN_STACK_INSTRUCTIONS];
|
|
size_t *offset = &block->instruction_offset;
|
|
uint64_t start, count;
|
|
if (block_read_varint(instructions, offset, &start) < 0 ||
|
|
block_read_varint(instructions, offset, &count) < 0) {
|
|
return -1;
|
|
}
|
|
if (count > MAX_STACK_DEPTH) {
|
|
return block_error("stack is too deep");
|
|
}
|
|
if (start > block->frame_offset || count > block->frame_offset - start) {
|
|
return block_error("reused stack is not stored earlier");
|
|
}
|
|
if (count > 0) {
|
|
memcpy(stream->current_stack, &block->frames[start],
|
|
count * sizeof(uint32_t));
|
|
}
|
|
stream->current_stack_depth = (size_t)count;
|
|
reader->stats.reuse_records++;
|
|
return 0;
|
|
}
|
|
|
|
/* Return 1 if a new stack was decoded, 0 if the stack repeats, -1 on error. */
|
|
static int
|
|
decode_stack(BinaryReader *reader, RemoteDebuggingState *state,
|
|
PyObject *collector, DecodedBlock *block,
|
|
ReaderBlockStream *stream)
|
|
{
|
|
/* An earlier REPEAT still covers this sample */
|
|
if (stream->pending_repeats > 0) {
|
|
stream->pending_repeats--;
|
|
reader->stats.repeat_samples++;
|
|
return 0;
|
|
}
|
|
uint64_t encoding;
|
|
if (block_read_varint(&block->columns[COLUMN_STACK_INSTRUCTIONS],
|
|
&block->instruction_offset, &encoding) < 0) {
|
|
return -1;
|
|
}
|
|
if (encoding == STACK_REPEAT) {
|
|
return decode_stack_repeat(reader, block, stream);
|
|
}
|
|
|
|
/* The pending batch was collected with the stack being replaced. */
|
|
if (flush_stream_batch(reader, state, collector, stream) < 0) {
|
|
return -1;
|
|
}
|
|
int result;
|
|
switch (encoding) {
|
|
case STACK_REPLACE_SUFFIX:
|
|
result = decode_stack_replace_suffix(reader, block, stream);
|
|
break;
|
|
case STACK_REUSE:
|
|
result = decode_stack_reuse(reader, block, stream);
|
|
break;
|
|
default:
|
|
return block_error("unknown stack instruction");
|
|
}
|
|
if (result < 0) {
|
|
return -1;
|
|
}
|
|
stream->has_stack = 1;
|
|
reader->stats.stack_reconstructions++;
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
replay_sample(BinaryReader *reader, RemoteDebuggingState *state,
|
|
PyObject *collector, DecodedBlock *block, uint32_t sample)
|
|
{
|
|
ReaderBlockStream *stream =
|
|
&reader->block_streams[block->stream_ids[sample]];
|
|
uint8_t status = block->statuses[sample];
|
|
int new_stack = decode_stack(reader, state, collector, block, stream);
|
|
if (new_stack < 0) {
|
|
return -1;
|
|
}
|
|
|
|
/* Start a new batch when the status changes or the batch is full */
|
|
if (stream->batch == NULL || status != stream->batch_status ||
|
|
PyList_GET_SIZE(stream->batch) >= MAX_RLE_BATCH_SAMPLES) {
|
|
if (flush_stream_batch(reader, state, collector, stream) < 0) {
|
|
return -1;
|
|
}
|
|
stream->batch = PyList_New(0);
|
|
if (stream->batch == NULL) {
|
|
return -1;
|
|
}
|
|
stream->batch_status = status;
|
|
}
|
|
PyObject *timestamp =
|
|
PyLong_FromUnsignedLongLong(block->timestamps[sample]);
|
|
if (timestamp == NULL) {
|
|
return -1;
|
|
}
|
|
int result = PyList_Append(stream->batch, timestamp);
|
|
Py_DECREF(timestamp);
|
|
if (result < 0) {
|
|
return -1;
|
|
}
|
|
/* Send a new stack's sample immediately so a stream's first sample is
|
|
* not held back behind samples from other streams. */
|
|
if (new_stack) {
|
|
return flush_stream_batch(reader, state, collector, stream);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
validate_block_consumed(BinaryReader *reader, const DecodedBlock *block)
|
|
{
|
|
if (block->instruction_offset !=
|
|
block->columns[COLUMN_STACK_INSTRUCTIONS].size) {
|
|
return block_error("stack instruction column has trailing data");
|
|
}
|
|
if (block->frame_offset != block->frame_count) {
|
|
return block_error("frame ID column has unused values");
|
|
}
|
|
for (uint32_t i = 0; i < block->stream_count; i++) {
|
|
if (!reader->block_streams[i].has_stack) {
|
|
return block_error("stream table has an unused entry");
|
|
}
|
|
if (reader->block_streams[i].pending_repeats != 0) {
|
|
return block_error("repeat count extends past the block");
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
replay_block(BinaryReader *reader, RemoteDebuggingState *state,
|
|
PyObject *collector, PyObject *progress_callback,
|
|
DecodedBlock *block, Py_ssize_t *replayed)
|
|
{
|
|
if ((uint64_t)block->header.sample_count >
|
|
reader->sample_count - (uint64_t)*replayed) {
|
|
return block_error("more samples than the file header declares");
|
|
}
|
|
int result = 0;
|
|
for (uint32_t sample = 0; sample < block->header.sample_count; sample++) {
|
|
if (replay_sample(reader, state, collector, block, sample) < 0) {
|
|
result = -1;
|
|
break;
|
|
}
|
|
(*replayed)++;
|
|
reader->stats.total_samples++;
|
|
if (*replayed % PROGRESS_CALLBACK_INTERVAL == 0 &&
|
|
invoke_progress_callback(progress_callback, *replayed,
|
|
reader->sample_count) < 0) {
|
|
result = -1;
|
|
break;
|
|
}
|
|
}
|
|
if (result == 0) {
|
|
result = validate_block_consumed(reader, block);
|
|
}
|
|
|
|
/* Send the remaining batches, or drop them after an error. */
|
|
for (uint32_t i = 0; i < block->stream_count; i++) {
|
|
ReaderBlockStream *stream = &reader->block_streams[i];
|
|
if (result == 0 &&
|
|
flush_stream_batch(reader, state, collector, stream) < 0) {
|
|
result = -1;
|
|
}
|
|
Py_CLEAR(stream->batch);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static int
|
|
replay_blocks(BinaryReader *reader, RemoteDebuggingState *state,
|
|
PyObject *collector, PyObject *progress_callback,
|
|
Py_ssize_t *replayed)
|
|
{
|
|
ByteBuffer section = {reader->sample_data, reader->sample_data_size, 0};
|
|
size_t offset = 0;
|
|
while (offset < section.size) {
|
|
DecodedBlock block;
|
|
if (decode_block(reader, §ion, &offset, &block) < 0 ||
|
|
replay_block(reader, state, collector, progress_callback,
|
|
&block, replayed) < 0) {
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static Py_ssize_t
|
|
replay_all_samples(BinaryReader *reader, PyObject *collector,
|
|
PyObject *progress_callback)
|
|
{
|
|
PyObject *collect_method;
|
|
int has_collect = PyObject_GetOptionalAttrString(collector, "collect", &collect_method);
|
|
if (has_collect < 0) {
|
|
return -1;
|
|
}
|
|
if (has_collect == 0) {
|
|
PyErr_SetString(PyExc_TypeError, "Collector must have a collect() method");
|
|
return -1;
|
|
}
|
|
Py_DECREF(collect_method);
|
|
|
|
/* Get module state for struct sequence types */
|
|
PyObject *module = PyImport_ImportModule("_remote_debugging");
|
|
if (!module) {
|
|
return -1;
|
|
}
|
|
RemoteDebuggingState *state = RemoteDebugging_GetState(module);
|
|
Py_DECREF(module);
|
|
|
|
if (!state) {
|
|
PyErr_SetString(PyExc_RuntimeError, "Failed to get module state");
|
|
return -1;
|
|
}
|
|
if (reader->sample_count > (uint64_t)PY_SSIZE_T_MAX) {
|
|
PyErr_SetString(PyExc_OverflowError,
|
|
"Sample count exceeds Py_ssize_t maximum");
|
|
return -1;
|
|
}
|
|
|
|
/* Initial progress callback at 0% */
|
|
if (invoke_progress_callback(progress_callback, 0, reader->sample_count) < 0) {
|
|
return -1;
|
|
}
|
|
|
|
memset(&reader->stats, 0, sizeof(reader->stats));
|
|
Py_ssize_t replayed = 0;
|
|
if (replay_blocks(reader, state, collector, progress_callback,
|
|
&replayed) < 0) {
|
|
return -1;
|
|
}
|
|
|
|
if ((uint64_t)replayed != reader->sample_count) {
|
|
PyErr_Format(PyExc_ValueError,
|
|
"Sample count mismatch: header declares %llu samples but replay decoded %zd",
|
|
(unsigned long long)reader->sample_count, replayed);
|
|
return -1;
|
|
}
|
|
return replayed;
|
|
}
|
|
|
|
Py_ssize_t
|
|
binary_reader_replay(BinaryReader *reader, PyObject *collector, PyObject *progress_callback)
|
|
{
|
|
if (reader->replaying) {
|
|
PyErr_SetString(PyExc_RuntimeError, "Reader is already replaying");
|
|
return -1;
|
|
}
|
|
reader->replaying = 1;
|
|
Py_ssize_t replayed = replay_all_samples(reader, collector,
|
|
progress_callback);
|
|
reader->replaying = 0;
|
|
if (replayed < 0) {
|
|
return -1;
|
|
}
|
|
|
|
/* Final progress callback at 100%; it may close the reader */
|
|
if (invoke_progress_callback(progress_callback, replayed, reader->sample_count) < 0) {
|
|
return -1;
|
|
}
|
|
|
|
return replayed;
|
|
}
|
|
|
|
PyObject *
|
|
binary_reader_get_info(BinaryReader *reader)
|
|
{
|
|
PyObject *py_version = Py_BuildValue("(B,B,B)",
|
|
reader->py_major, reader->py_minor, reader->py_micro);
|
|
if (py_version == NULL) {
|
|
return NULL;
|
|
}
|
|
PyObject *duration = reader->has_profile_stats
|
|
? PyFloat_FromDouble(reader->duration_sec) : Py_NewRef(Py_None);
|
|
if (duration == NULL) {
|
|
Py_DECREF(py_version);
|
|
return NULL;
|
|
}
|
|
PyObject *sample_rate = reader->has_profile_stats
|
|
? PyFloat_FromDouble(reader->sample_rate) : Py_NewRef(Py_None);
|
|
if (sample_rate == NULL) {
|
|
Py_DECREF(py_version);
|
|
Py_DECREF(duration);
|
|
return NULL;
|
|
}
|
|
PyObject *error_rate =
|
|
reader->profile_stats_present & PROFILE_STATS_ERROR_RATE
|
|
? PyFloat_FromDouble(reader->error_rate) : Py_NewRef(Py_None);
|
|
if (error_rate == NULL) {
|
|
Py_DECREF(py_version);
|
|
Py_DECREF(duration);
|
|
Py_DECREF(sample_rate);
|
|
return NULL;
|
|
}
|
|
PyObject *missed_samples =
|
|
reader->profile_stats_present & PROFILE_STATS_MISSED
|
|
? PyFloat_FromDouble(reader->missed_samples) : Py_NewRef(Py_None);
|
|
if (missed_samples == NULL) {
|
|
Py_DECREF(py_version);
|
|
Py_DECREF(duration);
|
|
Py_DECREF(sample_rate);
|
|
Py_DECREF(error_rate);
|
|
return NULL;
|
|
}
|
|
PyObject *profiling_mode = reader->profiling_mode < 0
|
|
? Py_NewRef(Py_None)
|
|
: PyLong_FromLong(reader->profiling_mode);
|
|
if (profiling_mode == NULL) {
|
|
Py_DECREF(py_version);
|
|
Py_DECREF(duration);
|
|
Py_DECREF(sample_rate);
|
|
Py_DECREF(error_rate);
|
|
Py_DECREF(missed_samples);
|
|
return NULL;
|
|
}
|
|
PyObject *capture_features = reader->capture_features < 0
|
|
? Py_NewRef(Py_None)
|
|
: PyLong_FromLong(reader->capture_features);
|
|
if (capture_features == NULL) {
|
|
Py_DECREF(py_version);
|
|
Py_DECREF(profiling_mode);
|
|
Py_DECREF(duration);
|
|
Py_DECREF(sample_rate);
|
|
Py_DECREF(error_rate);
|
|
Py_DECREF(missed_samples);
|
|
return NULL;
|
|
}
|
|
return Py_BuildValue(
|
|
"{s:I, s:N, s:K, s:K, s:K, s:I, s:I, s:I, s:i, s:N, s:N, s:N, s:N, s:N, s:N}",
|
|
"version", BINARY_FORMAT_VERSION,
|
|
"python_version", py_version,
|
|
"start_time_us", reader->start_time_us,
|
|
"sample_interval_us", reader->sample_interval_us,
|
|
"sample_count", reader->sample_count,
|
|
"thread_count", reader->thread_count,
|
|
"string_count", reader->strings_count,
|
|
"frame_count", reader->frames_count,
|
|
"compression_type", reader->compression_type,
|
|
"duration_sec", duration,
|
|
"sample_rate", sample_rate,
|
|
"error_rate", error_rate,
|
|
"missed_samples", missed_samples,
|
|
"mode", profiling_mode,
|
|
"capture_features", capture_features
|
|
);
|
|
}
|
|
|
|
PyObject *
|
|
binary_writer_get_stats(BinaryWriter *writer)
|
|
{
|
|
BinaryWriterStats *s = &writer->stats;
|
|
|
|
/* Calculate derived stats */
|
|
uint64_t total_records = s->repeat_records + s->full_records +
|
|
s->suffix_records + s->reuse_records;
|
|
uint64_t total_samples = writer->total_samples;
|
|
uint64_t bytes_written = s->bytes_written + binary_writer_buffered_size(writer);
|
|
uint64_t potential_frames = s->total_frames_written + s->frames_saved;
|
|
double compression_ratio = (potential_frames > 0) ?
|
|
(double)s->frames_saved / potential_frames * 100.0 : 0.0;
|
|
|
|
return Py_BuildValue(
|
|
"{s:K, s:K, s:K, s:K, s:K, s:K, s:K, s:K, s:K, s:K, s:d}",
|
|
"repeat_records", s->repeat_records,
|
|
"repeat_samples", s->repeat_samples,
|
|
"full_records", s->full_records,
|
|
"suffix_records", s->suffix_records,
|
|
"reuse_records", s->reuse_records,
|
|
"total_records", total_records,
|
|
"total_samples", total_samples,
|
|
"total_frames_written", s->total_frames_written,
|
|
"frames_saved", s->frames_saved,
|
|
"bytes_written", bytes_written,
|
|
"frame_compression_pct", compression_ratio
|
|
);
|
|
}
|
|
|
|
PyObject *
|
|
binary_reader_get_stats(BinaryReader *reader)
|
|
{
|
|
BinaryReaderStats *s = &reader->stats;
|
|
|
|
uint64_t total_records = s->repeat_records + s->full_records +
|
|
s->suffix_records + s->reuse_records;
|
|
|
|
return Py_BuildValue(
|
|
"{s:K, s:K, s:K, s:K, s:K, s:K, s:K, s:K}",
|
|
"repeat_records", s->repeat_records,
|
|
"repeat_samples", s->repeat_samples,
|
|
"full_records", s->full_records,
|
|
"suffix_records", s->suffix_records,
|
|
"reuse_records", s->reuse_records,
|
|
"total_records", total_records,
|
|
"total_samples", s->total_samples,
|
|
"stack_reconstructions", s->stack_reconstructions
|
|
);
|
|
}
|
|
|
|
void
|
|
binary_reader_close(BinaryReader *reader)
|
|
{
|
|
if (!reader) {
|
|
return;
|
|
}
|
|
|
|
#if USE_MMAP
|
|
if (reader->mapped_data) {
|
|
munmap(reader->mapped_data, reader->mapped_size);
|
|
reader->mapped_data = NULL; /* Prevent use-after-free */
|
|
reader->mapped_size = 0;
|
|
}
|
|
/* Clear sample_data which may point into the now-unmapped region */
|
|
reader->sample_data = NULL;
|
|
reader->sample_data_size = 0;
|
|
#else
|
|
if (reader->fp) {
|
|
Py_fclose(reader->fp);
|
|
reader->fp = NULL;
|
|
}
|
|
if (reader->file_data) {
|
|
PyMem_Free(reader->file_data);
|
|
reader->file_data = NULL;
|
|
reader->file_size = 0;
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_ZSTD
|
|
ZSTD_freeDCtx(reader->dctx);
|
|
#endif
|
|
buffer_clear(&reader->block_data);
|
|
buffer_clear(&reader->block_stream_ids);
|
|
buffer_clear(&reader->block_timestamps);
|
|
buffer_clear(&reader->block_statuses);
|
|
buffer_clear(&reader->block_frames);
|
|
PyMem_Free(reader->block_streams);
|
|
|
|
if (reader->frame_info_cache != NULL) {
|
|
for (size_t i = 0; i < reader->frame_info_cache_size; i++) {
|
|
Py_XDECREF(reader->frame_info_cache[i].frame_info);
|
|
}
|
|
PyMem_Free(reader->frame_info_cache);
|
|
}
|
|
|
|
if (reader->strings) {
|
|
for (uint32_t i = 0; i < reader->strings_count; i++) {
|
|
Py_XDECREF(reader->strings[i]);
|
|
}
|
|
PyMem_Free(reader->strings);
|
|
}
|
|
|
|
PyMem_Free(reader->frames);
|
|
|
|
PyMem_Free(reader->thread_states);
|
|
|
|
PyMem_Free(reader);
|
|
}
|