Method validateDebugOffsets

src/pystack/_pystack/process.cpp:1061–1181

}

bool
AbstractProcessManager::validateDebugOffsets(
        const Structure<py_runtime_v>& py_runtime,
        python_v& debug_offsets) const
{
    // Simple sanity checks on the decoded offsets:
    // - No structure is larger than 1 MB
    // - Every field falls within its structure's size
#define check_size(pystack_struct, size_offset)                                                         \
    do {                                                                                                \
        if (debug_offsets.pystack_struct.size > 1024 * 1024) {                                          \
            LOG(WARNING) << "Ignoring debug offsets because " #pystack_struct ".size ("                 \
                         << debug_offsets.pystack_struct.size << ") reported at byte offset "           \
                         << (d_py_v->py_runtime.*size_offset).offset                                    \
                         << " in detected _Py_DebugOffsets structure at " << std::hex << std::showbase  \
                         << py_runtime.getFieldRemoteAddress(&py_runtime_v::o_dbg_off_cookie)           \
                         << " is implausibly large";                                                    \
            return {};                                                                                  \
        }                                                                                               \
    } while (0)

#define check_field_bounds(structure, field)                                                            \
    do {                                                                                                \
        if (debug_offsets.structure.size < 0                                                            \
            || (size_t)debug_offsets.structure.size < debug_offsets.structure.field.offset              \
            || debug_offsets.structure.size - debug_offsets.structure.field.offset                      \
                       < sizeof(decltype(debug_offsets.structure.field)::Type))                         \
        {                                                                                               \
            LOG(WARNING) << "Ignoring debug offsets because " #structure ".size ("                      \
                         << debug_offsets.structure.size << ") - " #structure "." #field ".offset ("    \
                         << debug_offsets.structure.field.offset << ") < the field's size ("            \
                         << sizeof(decltype(debug_offsets.structure.field)::Type) << ")";               \
            return {};                                                                                  \
        }                                                                                               \
    } while (0)

    check_size(py_runtime, &py_runtime_v::o_dbg_off_runtime_state_struct_size);
    check_field_bounds(py_runtime, o_finalizing);
    check_field_bounds(py_runtime, o_interp_head);

    check_size(py_is, &py_runtime_v::o_dbg_off_interpreter_state_struct_size);
    check_field_bounds(py_is, o_next);
    check_field_bounds(py_is, o_tstate_head);
    check_field_bounds(py_is, o_gc);
    check_field_bounds(py_is, o_modules);
    check_field_bounds(py_is, o_sysdict);
    check_field_bounds(py_is, o_builtins);
    check_field_bounds(py_is, o_gil_runtime_state);

    check_size(py_thread, &py_runtime_v::o_dbg_off_thread_state_struct_size);
    check_field_bounds(py_thread, o_prev);
    check_field_bounds(py_thread, o_next);
    check_field_bounds(py_thread, o_interp);
    check_field_bounds(py_thread, o_frame);
    check_field_bounds(py_thread, o_thread_id);
    check_field_bounds(py_thread, o_native_thread_id);

    check_size(py_frame, &py_runtime_v::o_dbg_off_interpreter_frame_struct_size);