_testexternalinspection.c

#define_GNU_SOURCE

#include<errno.h>
#include<fcntl.h>
#include<stddef.h>
#include<stdint.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#ifndefPy_BUILD_CORE_BUILTIN
# definePy_BUILD_CORE_MODULE 1
#endif
#include"Python.h"
#include<internal/pycore_debug_offsets.h>// _Py_DebugOffsets
#include<internal/pycore_frame.h>// FRAME_SUSPENDED_YIELD_FROM
#include<internal/pycore_interpframe.h>// FRAME_OWNED_BY_CSTACK
#include<internal/pycore_llist.h>// struct llist_node
#include<internal/pycore_stackref.h>// Py_TAG_BITS
#include"../Python/remote_debug.h"

#ifndefHAVE_PROCESS_VM_READV
# defineHAVE_PROCESS_VM_READV 0
#endif

struct_Py_AsyncioModuleDebugOffsets {
struct_asyncio_task_object {
uint64_tsize;
uint64_ttask_name;
uint64_ttask_awaited_by;
uint64_ttask_is_task;
uint64_ttask_awaited_by_is_set;
uint64_ttask_coro;
uint64_ttask_node;
 } asyncio_task_object;
struct_asyncio_interpreter_state {
uint64_tsize;
uint64_tasyncio_tasks_head;
 } asyncio_interpreter_state;
struct_asyncio_thread_state {
uint64_tsize;
uint64_tasyncio_running_loop;
uint64_tasyncio_running_task;
uint64_tasyncio_tasks_head;
 } asyncio_thread_state;
};

// Get the PyAsyncioDebug section address for any platform
staticuintptr_t
_Py_RemoteDebug_GetAsyncioDebugAddress(proc_handle_t*handle)
{
uintptr_taddress;

#ifdefMS_WINDOWS
// On Windows, search for asyncio debug in executable or DLL
address=search_windows_map_for_section(handle, "AsyncioD", L"_asyncio");
#elif defined(__linux__)
// On Linux, search for asyncio debug in executable or DLL
address=search_linux_map_for_section(handle, "AsyncioDebug", "_asyncio.cpython");
#elif defined(__APPLE__) &&TARGET_OS_OSX
// On macOS, try libpython first, then fall back to python
address=search_map_for_section(handle, "AsyncioDebug", "_asyncio.cpython");
if (address==0) {
PyErr_Clear();
address=search_map_for_section(handle, "AsyncioDebug", "_asyncio.cpython");
 }
#else
address=0;
#endif

returnaddress;
}

staticint
read_string(
proc_handle_t*handle,
_Py_DebugOffsets*debug_offsets,
uintptr_taddress,
char*buffer,
Py_ssize_tsize
) {
Py_ssize_tlen;
intresult=_Py_RemoteDebug_ReadRemoteMemory(
handle,
address+debug_offsets->unicode_object.length,
sizeof(Py_ssize_t),
&len
 );
if (result<0) {
return-1;
 }
if (len >= size) {
PyErr_SetString(PyExc_RuntimeError, "Buffer too small");
return-1;
 }
size_toffset=debug_offsets->unicode_object.asciiobject_size;
result=_Py_RemoteDebug_ReadRemoteMemory(handle, address+offset, len, buffer);
if (result<0) {
return-1;
 }
buffer[len] ='\0';
return0;
}

staticinlineint
read_ptr(proc_handle_t*handle, uintptr_taddress, uintptr_t*ptr_addr)
{
intresult=_Py_RemoteDebug_ReadRemoteMemory(handle, address, sizeof(void*), ptr_addr);
if (result<0) {
return-1;
 }
return0;
}

staticinlineint
read_Py_ssize_t(proc_handle_t*handle, uintptr_taddress, Py_ssize_t*size)
{
intresult=_Py_RemoteDebug_ReadRemoteMemory(handle, address, sizeof(Py_ssize_t), size);
if (result<0) {
return-1;
 }
return0;
}

staticint
read_py_ptr(proc_handle_t*handle, uintptr_taddress, uintptr_t*ptr_addr)
{
if (read_ptr(handle, address, ptr_addr)) {
return-1;
 }
*ptr_addr &= ~Py_TAG_BITS;
return0;
}

staticint
read_char(proc_handle_t*handle, uintptr_taddress, char*result)
{
intres=_Py_RemoteDebug_ReadRemoteMemory(handle, address, sizeof(char), result);
if (res<0) {
return-1;
 }
return0;
}

staticint
read_int(proc_handle_t*handle, uintptr_taddress, int*result)
{
intres=_Py_RemoteDebug_ReadRemoteMemory(handle, address, sizeof(int), result);
if (res<0) {
return-1;
 }
return0;
}

staticint
read_unsigned_long(proc_handle_t*handle, uintptr_taddress, unsigned long*result)
{
intres=_Py_RemoteDebug_ReadRemoteMemory(handle, address, sizeof(unsigned long), result);
if (res<0) {
return-1;
 }
return0;
}

staticint
read_pyobj(proc_handle_t*handle, uintptr_taddress, PyObject*ptr_addr)
{
intres=_Py_RemoteDebug_ReadRemoteMemory(handle, address, sizeof(PyObject), ptr_addr);
if (res<0) {
return-1;
 }
return0;
}

staticPyObject*
read_py_str(
proc_handle_t*handle,
_Py_DebugOffsets*debug_offsets,
uintptr_taddress,
Py_ssize_tmax_len
) {
assert(max_len>0);

PyObject*result=NULL;

char*buf= (char*)PyMem_RawMalloc(max_len);
if (buf==NULL) {
PyErr_NoMemory();
returnNULL;
 }
if (read_string(handle, debug_offsets, address, buf, max_len)) {
 goto err;
 }

result=PyUnicode_FromString(buf);
if (result==NULL) {
 goto err;
 }

PyMem_RawFree(buf);
assert(result!=NULL);
returnresult;

err:
PyMem_RawFree(buf);
returnNULL;
}

staticlong
read_py_long(proc_handle_t*handle, _Py_DebugOffsets*offsets, uintptr_taddress)
{
unsigned intshift=PYLONG_BITS_IN_DIGIT;

Py_ssize_tsize;
uintptr_tlv_tag;

intbytes_read=_Py_RemoteDebug_ReadRemoteMemory(
handle, address+offsets->long_object.lv_tag,
sizeof(uintptr_t),
&lv_tag);
if (bytes_read<0) {
return-1;
 }

intnegative= (lv_tag&3) ==2;
size=lv_tag >> 3;

if (size==0) {
return0;
 }

digit*digits= (digit*)PyMem_RawMalloc(size*sizeof(digit));
if (!digits) {
PyErr_NoMemory();
return-1;
 }

bytes_read=_Py_RemoteDebug_ReadRemoteMemory(
handle,
address+offsets->long_object.ob_digit,
sizeof(digit) *size,
digits
 );
if (bytes_read<0) {
 goto error;
 }

long longvalue=0;

// In theory this can overflow, but because of llvm/llvm-project#16778
// we can't use __builtin_mul_overflow because it fails to link with
// __muloti4 on aarch64. In practice this is fine because all we're
// testing here are task numbers that would fit in a single byte.
for (Py_ssize_ti=0; i<size; ++i) {
long longfactor=digits[i] * (1UL << (Py_ssize_t)(shift*i));
value+=factor;
 }
PyMem_RawFree(digits);
if (negative) {
value *= -1;
 }
return (long)value;
error:
PyMem_RawFree(digits);
return-1;
}

staticPyObject*
parse_task_name(
proc_handle_t*handle,
_Py_DebugOffsets*offsets,
struct_Py_AsyncioModuleDebugOffsets*async_offsets,
uintptr_ttask_address
) {
uintptr_ttask_name_addr;
interr=read_py_ptr(
handle,
task_address+async_offsets->asyncio_task_object.task_name,
&task_name_addr);
if (err) {
returnNULL;
 }

// The task name can be a long or a string so we need to check the type

PyObjecttask_name_obj;
err=read_pyobj(
handle,
task_name_addr,
&task_name_obj);
if (err) {
returnNULL;
 }

unsigned longflags;
err=read_unsigned_long(
handle,
 (uintptr_t)task_name_obj.ob_type+offsets->type_object.tp_flags,
&flags);
if (err) {
returnNULL;
 }

if ((flags&Py_TPFLAGS_LONG_SUBCLASS)) {
longres=read_py_long(handle, offsets, task_name_addr);
if (res==-1) {
PyErr_SetString(PyExc_RuntimeError, "Failed to get task name");
returnNULL;
 }
returnPyUnicode_FromFormat("Task-%d", res);
 }

if(!(flags&Py_TPFLAGS_UNICODE_SUBCLASS)) {
PyErr_SetString(PyExc_RuntimeError, "Invalid task name object");
returnNULL;
 }

returnread_py_str(
handle,
offsets,
task_name_addr,
255
 );
}

staticint
parse_coro_chain(
proc_handle_t*handle,
struct_Py_DebugOffsets*offsets,
struct_Py_AsyncioModuleDebugOffsets*async_offsets,
uintptr_tcoro_address,
PyObject*render_to
) {
assert((void*)coro_address!=NULL);

uintptr_tgen_type_addr;
interr=read_ptr(
handle,
coro_address+sizeof(void*),
&gen_type_addr);
if (err) {
return-1;
 }

uintptr_tgen_name_addr;
err=read_py_ptr(
handle,
coro_address+offsets->gen_object.gi_name,
&gen_name_addr);
if (err) {
return-1;
 }

PyObject*name=read_py_str(
handle,
offsets,
gen_name_addr,
255
 );
if (name==NULL) {
return-1;
 }

if (PyList_Append(render_to, name)) {
Py_DECREF(name);
return-1;
 }
Py_DECREF(name);

intgi_frame_state;
err=read_int(
handle,
coro_address+offsets->gen_object.gi_frame_state,
&gi_frame_state);
if (err) {
return-1;
 }

if (gi_frame_state==FRAME_SUSPENDED_YIELD_FROM) {
charowner;
err=read_char(
handle,
coro_address+offsets->gen_object.gi_iframe+
offsets->interpreter_frame.owner,
&owner
 );
if (err) {
return-1;
 }
if (owner!=FRAME_OWNED_BY_GENERATOR) {
PyErr_SetString(
PyExc_RuntimeError,
"generator doesn't own its frame \\_o_/");
return-1;
 }

uintptr_tstackpointer_addr;
err=read_py_ptr(
handle,
coro_address+offsets->gen_object.gi_iframe+
offsets->interpreter_frame.stackpointer,
&stackpointer_addr);
if (err) {
return-1;
 }

if ((void*)stackpointer_addr!=NULL) {
uintptr_tgi_await_addr;
err=read_py_ptr(
handle,
stackpointer_addr-sizeof(void*),
&gi_await_addr);
if (err) {
return-1;
 }

if ((void*)gi_await_addr!=NULL) {
uintptr_tgi_await_addr_type_addr;
interr=read_ptr(
handle,
gi_await_addr+sizeof(void*),
&gi_await_addr_type_addr);
if (err) {
return-1;
 }

if (gen_type_addr==gi_await_addr_type_addr) {
/* This needs an explanation. We always start with parsing
 native coroutine / generator frames. Ultimately they
 are awaiting on something. That something can be
 a native coroutine frame or... an iterator.
 If it's the latter -- we can't continue building
 our chain. So the condition to bail out of this is
 to do that when the type of the current coroutine
 doesn't match the type of whatever it points to
 in its cr_await.
 */
err=parse_coro_chain(
handle,
offsets,
async_offsets,
gi_await_addr,
render_to
 );
if (err) {
return-1;
 }
 }
 }
 }

 }

return0;
}


staticint
parse_task_awaited_by(
proc_handle_t*handle,
struct_Py_DebugOffsets*offsets,
struct_Py_AsyncioModuleDebugOffsets*async_offsets,
uintptr_ttask_address,
PyObject*awaited_by
);


staticint
parse_task(
proc_handle_t*handle,
struct_Py_DebugOffsets*offsets,
struct_Py_AsyncioModuleDebugOffsets*async_offsets,
uintptr_ttask_address,
PyObject*render_to
) {
charis_task;
interr=read_char(
handle,
task_address+async_offsets->asyncio_task_object.task_is_task,
&is_task);
if (err) {
return-1;
 }

uintptr_trefcnt;
read_ptr(handle, task_address+sizeof(Py_ssize_t), &refcnt);

PyObject*result=PyList_New(0);
if (result==NULL) {
return-1;
 }

PyObject*call_stack=PyList_New(0);
if (call_stack==NULL) {
 goto err;
 }
if (PyList_Append(result, call_stack)) {
Py_DECREF(call_stack);
 goto err;
 }
/* we can operate on a borrowed one to simplify cleanup */
Py_DECREF(call_stack);

if (is_task) {
PyObject*tn=parse_task_name(
handle, offsets, async_offsets, task_address);
if (tn==NULL) {
 goto err;
 }
if (PyList_Append(result, tn)) {
Py_DECREF(tn);
 goto err;
 }
Py_DECREF(tn);

uintptr_tcoro_addr;
err=read_py_ptr(
handle,
task_address+async_offsets->asyncio_task_object.task_coro,
&coro_addr);
if (err) {
 goto err;
 }

if ((void*)coro_addr!=NULL) {
err=parse_coro_chain(
handle,
offsets,
async_offsets,
coro_addr,
call_stack
 );
if (err) {
 goto err;
 }

if (PyList_Reverse(call_stack)) {
 goto err;
 }
 }
 }

if (PyList_Append(render_to, result)) {
 goto err;
 }

PyObject*awaited_by=PyList_New(0);
if (awaited_by==NULL) {
 goto err;
 }
if (PyList_Append(result, awaited_by)) {
Py_DECREF(awaited_by);
 goto err;
 }
/* we can operate on a borrowed one to simplify cleanup */
Py_DECREF(awaited_by);

if (parse_task_awaited_by(handle, offsets, async_offsets,
task_address, awaited_by)
 ) {
 goto err;
 }
Py_DECREF(result);

return0;

err:
Py_DECREF(result);
return-1;
}

staticint
parse_tasks_in_set(
proc_handle_t*handle,
struct_Py_DebugOffsets*offsets,
struct_Py_AsyncioModuleDebugOffsets*async_offsets,
uintptr_tset_addr,
PyObject*awaited_by
) {
uintptr_tset_obj;
if (read_py_ptr(
handle,
set_addr,
&set_obj)
 ) {
return-1;
 }

Py_ssize_tnum_els;
if (read_Py_ssize_t(
handle,
set_obj+offsets->set_object.used,
&num_els)
 ) {
return-1;
 }

Py_ssize_tset_len;
if (read_Py_ssize_t(
handle,
set_obj+offsets->set_object.mask,
&set_len)
 ) {
return-1;
 }
set_len++; // The set contains the `mask+1` element slots.

uintptr_ttable_ptr;
if (read_ptr(
handle,
set_obj+offsets->set_object.table,
&table_ptr)
 ) {
return-1;
 }

Py_ssize_ti=0;
Py_ssize_tels=0;
while (i<set_len) {
uintptr_tkey_addr;
if (read_py_ptr(handle, table_ptr, &key_addr)) {
return-1;
 }

if ((void*)key_addr!=NULL) {
Py_ssize_tref_cnt;
if (read_Py_ssize_t(handle, table_ptr, &ref_cnt)) {
return-1;
 }

if (ref_cnt) {
// if 'ref_cnt=0' it's a set dummy marker

if (parse_task(
handle,
offsets,
async_offsets,
key_addr,
awaited_by)
 ) {
return-1;
 }

if (++els==num_els) {
break;
 }
 }
 }

table_ptr+=sizeof(void*) *2;
i++;
 }
return0;
}


staticint
parse_task_awaited_by(
proc_handle_t*handle,
struct_Py_DebugOffsets*offsets,
struct_Py_AsyncioModuleDebugOffsets*async_offsets,
uintptr_ttask_address,
PyObject*awaited_by
) {
uintptr_ttask_ab_addr;
interr=read_py_ptr(
handle,
task_address+async_offsets->asyncio_task_object.task_awaited_by,
&task_ab_addr);
if (err) {
return-1;
 }

if ((void*)task_ab_addr==NULL) {
return0;
 }

charawaited_by_is_a_set;
err=read_char(
handle,
task_address+async_offsets->asyncio_task_object.task_awaited_by_is_set,
&awaited_by_is_a_set);
if (err) {
return-1;
 }

if (awaited_by_is_a_set) {
if (parse_tasks_in_set(
handle,
offsets,
async_offsets,
task_address+async_offsets->asyncio_task_object.task_awaited_by,
awaited_by)
 ) {
return-1;
 }
 } else {
uintptr_tsub_task;
if (read_py_ptr(
handle,
task_address+async_offsets->asyncio_task_object.task_awaited_by,
&sub_task)
 ) {
return-1;
 }

if (parse_task(
handle,
offsets,
async_offsets,
sub_task,
awaited_by)
 ) {
return-1;
 }
 }

return0;
}

staticint
parse_code_object(
proc_handle_t*handle,
PyObject*result,
struct_Py_DebugOffsets*offsets,
uintptr_taddress,
uintptr_t*previous_frame
) {
uintptr_taddress_of_function_name;
intbytes_read=_Py_RemoteDebug_ReadRemoteMemory(
handle,
address+offsets->code_object.name,
sizeof(void*),
&address_of_function_name
 );
if (bytes_read<0) {
return-1;
 }

if ((void*)address_of_function_name==NULL) {
PyErr_SetString(PyExc_RuntimeError, "No function name found");
return-1;
 }

PyObject*py_function_name=read_py_str(
handle, offsets, address_of_function_name, 256);
if (py_function_name==NULL) {
return-1;
 }

if (PyList_Append(result, py_function_name) ==-1) {
Py_DECREF(py_function_name);
return-1;
 }
Py_DECREF(py_function_name);

return0;
}

staticint
parse_frame_object(
proc_handle_t*handle,
PyObject*result,
struct_Py_DebugOffsets*offsets,
uintptr_taddress,
uintptr_t*previous_frame
) {
interr;

Py_ssize_tbytes_read=_Py_RemoteDebug_ReadRemoteMemory(
handle,
address+offsets->interpreter_frame.previous,
sizeof(void*),
previous_frame
 );
if (bytes_read<0) {
return-1;
 }

charowner;
if (read_char(handle, address+offsets->interpreter_frame.owner, &owner)) {
return-1;
 }

if (owner >= FRAME_OWNED_BY_INTERPRETER) {
return0;
 }

uintptr_taddress_of_code_object;
err=read_py_ptr(
handle,
address+offsets->interpreter_frame.executable,
&address_of_code_object
 );
if (err) {
return-1;
 }

if ((void*)address_of_code_object==NULL) {
return0;
 }

returnparse_code_object(
handle, result, offsets, address_of_code_object, previous_frame);
}

staticint
parse_async_frame_object(
proc_handle_t*handle,
PyObject*result,
struct_Py_DebugOffsets*offsets,
uintptr_taddress,
uintptr_t*previous_frame,
uintptr_t*code_object
) {
interr;

Py_ssize_tbytes_read=_Py_RemoteDebug_ReadRemoteMemory(
handle,
address+offsets->interpreter_frame.previous,
sizeof(void*),
previous_frame
 );
if (bytes_read<0) {
return-1;
 }

charowner;
bytes_read=_Py_RemoteDebug_ReadRemoteMemory(
handle, address+offsets->interpreter_frame.owner, sizeof(char), &owner);
if (bytes_read<0) {
return-1;
 }

if (owner==FRAME_OWNED_BY_CSTACK||owner==FRAME_OWNED_BY_INTERPRETER) {
return0; // C frame
 }

if (owner!=FRAME_OWNED_BY_GENERATOR
&&owner!=FRAME_OWNED_BY_THREAD) {
PyErr_Format(PyExc_RuntimeError, "Unhandled frame owner %d.\n", owner);
return-1;
 }

err=read_py_ptr(
handle,
address+offsets->interpreter_frame.executable,
code_object
 );
if (err) {
return-1;
 }

assert(code_object!=NULL);
if ((void*)*code_object==NULL) {
return0;
 }

if (parse_code_object(
handle, result, offsets, *code_object, previous_frame)) {
return-1;
 }

return1;
}

staticint
read_async_debug(
proc_handle_t*handle,
struct_Py_AsyncioModuleDebugOffsets*async_debug
) {
uintptr_tasync_debug_addr=_Py_RemoteDebug_GetAsyncioDebugAddress(handle);
if (!async_debug_addr) {
return-1;
 }

size_tsize=sizeof(struct_Py_AsyncioModuleDebugOffsets);
intresult=_Py_RemoteDebug_ReadRemoteMemory(handle, async_debug_addr, size, async_debug);
returnresult;
}

staticint
find_running_frame(
proc_handle_t*handle,
uintptr_truntime_start_address,
_Py_DebugOffsets*local_debug_offsets,
uintptr_t*frame
) {
uint64_tinterpreter_state_list_head=
local_debug_offsets->runtime_state.interpreters_head;

uintptr_taddress_of_interpreter_state;
intbytes_read=_Py_RemoteDebug_ReadRemoteMemory(
handle,
runtime_start_address+interpreter_state_list_head,
sizeof(void*),
&address_of_interpreter_state);
if (bytes_read<0) {
return-1;
 }

if (address_of_interpreter_state==0) {
PyErr_SetString(PyExc_RuntimeError, "No interpreter state found");
return-1;
 }

uintptr_taddress_of_thread;
bytes_read=_Py_RemoteDebug_ReadRemoteMemory(
handle,
address_of_interpreter_state+
local_debug_offsets->interpreter_state.threads_main,
sizeof(void*),
&address_of_thread);
if (bytes_read<0) {
return-1;
 }

// No Python frames are available for us (can happen at tear-down).
if ((void*)address_of_thread!=NULL) {
interr=read_ptr(
handle,
address_of_thread+local_debug_offsets->thread_state.current_frame,
frame);
if (err) {
return-1;
 }
return0;
 }

*frame= (uintptr_t)NULL;
return0;
}

staticint
find_running_task(
proc_handle_t*handle,
uintptr_truntime_start_address,
_Py_DebugOffsets*local_debug_offsets,
struct_Py_AsyncioModuleDebugOffsets*async_offsets,
uintptr_t*running_task_addr
) {
*running_task_addr= (uintptr_t)NULL;

uint64_tinterpreter_state_list_head=
local_debug_offsets->runtime_state.interpreters_head;

uintptr_taddress_of_interpreter_state;
intbytes_read=_Py_RemoteDebug_ReadRemoteMemory(
handle,
runtime_start_address+interpreter_state_list_head,
sizeof(void*),
&address_of_interpreter_state);
if (bytes_read<0) {
return-1;
 }

if (address_of_interpreter_state==0) {
PyErr_SetString(PyExc_RuntimeError, "No interpreter state found");
return-1;
 }

uintptr_taddress_of_thread;
bytes_read=_Py_RemoteDebug_ReadRemoteMemory(
handle,
address_of_interpreter_state+
local_debug_offsets->interpreter_state.threads_head,
sizeof(void*),
&address_of_thread);
if (bytes_read<0) {
return-1;
 }

uintptr_taddress_of_running_loop;
// No Python frames are available for us (can happen at tear-down).
if ((void*)address_of_thread==NULL) {
return0;
 }

bytes_read=read_py_ptr(
handle,
address_of_thread
+async_offsets->asyncio_thread_state.asyncio_running_loop,
&address_of_running_loop);
if (bytes_read==-1) {
return-1;
 }

// no asyncio loop is now running
if ((void*)address_of_running_loop==NULL) {
return0;
 }

interr=read_ptr(
handle,
address_of_thread
+async_offsets->asyncio_thread_state.asyncio_running_task,
running_task_addr);
if (err) {
return-1;
 }