int PyCode_Addr2Line(PyCodeObject *co, int addrq)
{
    int size = PyString_Size(co->co_lnotab) / 2;  
    unsigned char *p = (unsigned char*)PyString_AsString(co->co_lnotab);  // CPython将行号表当作字符串来处理
    int line = co->co_firstlineno;  // 当前块在源码中的其实行号
    int addr = 0;
    while (--size >= 0) {
        addr += *p++;   // 这里是字节码偏移的累加，下面还有行号偏移的累加
        if (addr > addrq)   // 若字节码的地址大于请求的地址，则上一次计算的行号就是请求地址对应的行号
            break;
        line += *p++;
    }
    return line;
}

import sys
def tracer(frame, event, arg = None):
    """
    :param frame 当前中断发生的上下文(FrameObject的封装)，通过它可以获取所有运行时信息
    :param event 中断的原因，如函数进入/退出，发生异常，执行了一条字节码/一行源码等，可通过对它做判断选出感兴趣的事件
    :param arg   根据event而定，如异常信息等
    """
    code = frame.f_code
    func_name = code.co_name
    line_no = frame.f_lineno
    print(f"A {event} encountered in {func_name}() at line number {line_no} ")

    return tracer # 注意这里返回了函数自身，这能实现持续追踪，否则该回调执行一次后就不再执行

sys.settrace(my_tracer)  # 注册最终函数，默认不追踪字节码，这太耗性能了

static PyObject *sys_settrace(PyObject *self, PyObject *args) // 这里的args就是回调函数
{
    if (args == Py_None)
        PyEval_SetTrace(NULL, NULL);
    else
        PyEval_SetTrace(trace_trampoline, args);  // trace_trampoline是C函数，它作为蹦床去执行python回调
    Py_RETURN_NONE;
}
void PyEval_SetTrace(Py_tracefunc func, PyObject *arg)
{
    PyThreadState *tstate = PyThreadState_GET();  // 注意这里是获取当前线程，即settrace只会在本线程生效，若跟踪每个线程需要各自注册
    PyObject *temp = tstate->c_traceobj;
    _Py_TracingPossible += (func != NULL) - (tstate->c_tracefunc != NULL);
    Py_XINCREF(arg);
    tstate->c_tracefunc = NULL;  
    tstate->c_traceobj = NULL;  
    tstate->use_tracing = tstate->c_profilefunc != NULL;
    Py_XDECREF(temp);
    tstate->c_tracefunc = func;  // 蹦床
    tstate->c_traceobj = arg;    // python实现的trace callback被存储到这里
    /* Flag that tracing or profiling is turned on */
    tstate->use_tracing = ((func != NULL) || (tstate->c_profilefunc != NULL));  // 是否使用trace的标志
}

static int trace_trampoline(PyObject *self, PyFrameObject *frame, int what, PyObject *arg)
{
    ...
    if (what == PyTrace_CALL)
        callback = self;            // CALL是一个新帧，此时调的函数是从外部(ThreadState的c_tracefunc)传来的
    else
        callback = frame->f_trace;  // 在其他事件时使用的是frame里的f_trace
    if (callback == NULL)
        return 0;
    result = call_trampoline(callback, frame, what, arg);  // 调用trace callback
    if (result == NULL) {  // 如果tracer的返回为空那么就取消trace
        PyEval_SetTrace(NULL, NULL);
        Py_CLEAR(frame->f_trace);
        return -1;
    }
    if (result != Py_None) {
        Py_XSETREF(frame->f_trace, result);  // 否则把返回值作为新的trace callback
    }
    ...
}

PyObject* _Py_HOT_FUNCTION _PyEval_EvalFrameDefault(PyFrameObject *f, int throwflag)
{
    // 这个函数就是解释字节码的位置，可见它传入的参数是FrameObject
    ...
    tstate->frame = f;  // 把新帧给ThreadState
    // 这里是函数刚开始，若之前注册了追踪就在此调用回调
    if (tstate->use_tracing) {
        if (tstate->c_tracefunc != NULL) {
            if (call_trace_protected(tstate->c_tracefunc, // 可见这里传入的类型为PyTrace_CALL，而使用的回调函数
                                     tstate->c_traceobj,  // 是tstate->c_tracefunc，它是蹦床，它会调用tstate->c_traceobj，这
                                     tstate, f, PyTrace_CALL, Py_None)) {  // 才是真正注册的trace_callback
                /* Trace function raised an error */
                goto exit_eval_frame;
            }
        }
    }
    ...
    // 正式开始解释执行字节码，这就是一个大循环，里面用switch根据指令操作数解释
    for (;;) {
        // 在每次循环时判断，做字节码/行号追踪
        if (_Py_TracingPossible && tstate->c_tracefunc != NULL && !tstate->tracing) {
            f->f_stacktop = stack_pointer;
            err = maybe_call_line_trace(tstate->c_tracefunc,
                                        tstate->c_traceobj,
                                        tstate, f,
                                        &instr_lb, &instr_ub, &instr_prev);
            ...
        }
        // 解释字节码，这里面一些关键点也会进行追踪，如出现异常...
        switch (opcode) {
            TARGET(NOP) ...
            TARGET(LOAD_FAST) ...
            ...
        }
    }
    // 跳出解释循环后，还会继续根据退出原因做跟踪
error:  // 这是个异常的退出点
        ...
        if (tstate->c_tracefunc != NULL)
            call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj, // 触发trace_callback(f, PyTrace_EXCEPTION, exception)
                           tstate, f);
fast_yield:  // 这是个退出点
        if (tstate->use_tracing) {
        if (tstate->c_tracefunc) {
            if (why == WHY_RETURN || why == WHY_YIELD) {  // 退出原因是正常返回
                if (call_trace(tstate->c_tracefunc, tstate->c_traceobj,
                               tstate, f,
                               PyTrace_RETURN, retval)) {  // 触发trace_callback(f, PyTrace_RETURN, retval)
                    Py_CLEAR(retval);
                    why = WHY_EXCEPTION;
                }
            }
        }
    }
...
}

ps jaux |grep gui # 获取父进程得知它是由heimdall启动的，后者是由init启动的
ps wwweaux |grep gui # 获取执行的环境变量

sys.path.append('/tmp/pydevd-pycharm-191.4212.43')  # 直接下载解压，它没有依赖第三方库
sys.path.append('/data/links/lib/python2.6_10_amd64_thr/') # 需要包含其他标准库
import pydevd_pycharm
print('import runpy, the argv is ', str(sys.argv))  
if 'gui' in str(sys.argv):
    print('starting trace...')
    pydevd_pycharm.settrace('192.168.199.189', port=8080, stdoutToServer=True, stderrToServer=True)
    print('trace continue...')
else:
    print('dont care...')

PYTHONPATH=/data/lib/python2.6_10_amd64_nothr/site-packages/  # 这里指定site目录，它里面的easy_install.pth导入了ipoe
COMPRESS_CONFIG=1 HEIMDALL_SOCK=/tmp/heimdall.sock 
... 
python -O __main__.py gui --debug  # -O 支持导入pyo，默认支持pyc

./app_site_packages-1.0.0_000-py2.6_10_amd64_nothr.ipoe
./aquarium-2.2.1-py2.6_10_amd64_nothr.ipoe
./common_packages-1.0.0_000-py2.6_10_amd64_nothr.ipoe
./report_packages-1.0.0_000-py2.6_10_amd64_nothr.ipoe
./reporting_ui_esa-1.0.0_000-py2.6_10_amd64_nothr.ipoe
./tracking_ui_esa-1.0.0_000-py2.6_10_amd64_nothr.ipoe