add test to ensure the size of prof_stacktrace_s is correct,

do not write to buffer if the size exceeds the buffer

Author: planrich

src/_vmprof.c

@@ -378,7 +378,7 @@ sample_stack_now(PyObject *module, PyObject * args)
         vmprof_ignore_signals(0);
         return NULL;
     }
-    entry_count = vmp_walk_and_record_stack(tstate->frame, m, MAX_STACK_DEPTH-1, skip, 0);
+    entry_count = vmp_walk_and_record_stack(tstate->frame, m, SINGLE_BUF_SIZE/sizeof(void*)-1, skip, 0);
 
     for (i = 0; i < entry_count; i++) {
         routine_ip = m[i];

src/vmp_stack.c

@@ -44,6 +44,19 @@ static int (*unw_getcontext)(unw_context_t *) = NULL;
 #include <dlfcn.h>
 #endif
 
+int _per_loop(void) {
+    // how many void* are written to the stack trace per loop iterations?
+#ifdef RPYTHON_VMPROF
+    return 2;
+#else
+    if (vmp_profiles_python_lines()) {
+        return 2;
+    }
+    return 1;
+#endif
+}
+
+
 #ifdef PY_TEST
 // for testing only!
 PY_EVAL_RETURN_T * vmprof_eval(PY_STACK_FRAME_T *f, int throwflag) { return NULL; }
@@ -130,19 +143,27 @@ static PY_STACK_FRAME_T * _write_python_stack_entry(PY_STACK_FRAME_T * frame, vo
 int vmp_walk_and_record_python_stack_only(PY_STACK_FRAME_T *frame, void ** result,
                                           int max_depth, int depth, intptr_t pc)
 {
-    while (depth < max_depth && frame) {
+    while ((depth + _per_loop()) <= max_depth && frame) {
         frame = _write_python_stack_entry(frame, result, &depth, max_depth);
     }
     return depth;
 }
 
 #ifdef VMP_SUPPORTS_NATIVE_PROFILING
-int _write_native_stack(void* addr, void ** result, int depth) {
+int _write_native_stack(void* addr, void ** result, int depth, int max_depth) {
 #ifdef RPYTHON_VMPROF
+    if (depth + 2 >= max_depth) {
+        // bail, do not write to unknown memory
+        return depth;
+    }
     result[depth++] = (void*)VMPROF_NATIVE_TAG;
 #else
     if (vmp_profiles_python_lines()) {
-        // even if we do not log a python stack frame,
+        if (depth + 2 >= max_depth) {
+            // bail, do not write to unknown memory
+            return depth;
+        }
+        // even if we do not log a python line number,
         // we must keep the profile readable
         result[depth++] = 0;
     }
@@ -227,7 +248,7 @@ int vmp_walk_and_record_stack(PY_STACK_FRAME_T *frame, void ** result,
 
     int depth = 0;
     PY_STACK_FRAME_T * top_most_frame = frame;
-    while (depth < max_depth) {
+    while ((depth + _per_loop()) <= max_depth) {
         unw_get_proc_info(&cursor, &pip);
 
         func_addr = pip.start_ip;
@@ -269,7 +290,7 @@ int vmp_walk_and_record_stack(PY_STACK_FRAME_T *frame, void ** result,
             // this is possible because compiler align to 8 bytes.
             //
             if (func_addr != 0x0) {
-                depth = _write_native_stack((void*)(func_addr | 0x1), result, depth);
+                depth = _write_native_stack((void*)(func_addr | 0x1), result, depth, max_depth);
             }
         }
 

vmprof/test/test_c_source.py

@@ -18,12 +18,17 @@ def setup_class(cls):
         void vmp_set_ignore_symbols(ptr_t * symbols, int count);
         int vmp_read_vmaps(const char * fname);
         void vmp_native_disable();
+        int sizeof_prof_stacktrace_s(void);
         """)
         with open("src/vmp_stack.c", "rb") as fd:
             source = fd.read().decode()
             libs = [] #['unwind', 'unwind-x86_64']
             if sys.platform.startswith('linux'):
                 libs = ['unwind', 'unwind-x86_64']
+            source += """
+            #include "vmprof_common.h"
+            int sizeof_prof_stacktrace_s(void) { return sizeof(prof_stacktrace_s); }
+            """
             # trick: compile with _CFFI_USE_EMBEDDING=1 which will not define Py_LIMITED_API
             stack_ffi.set_source("vmprof.test._test_stack", source, include_dirs=['src'],
                                  define_macros=[('_CFFI_USE_EMBEDDING',1), ('PY_TEST',1),
@@ -126,3 +131,9 @@ def test_overflow_vmaps(self, tmpdir):
             assert self.lib.vmp_ignore_ip(l) == 1
         assert self.lib.vmp_ignore_ip(10001) == 0
 
+    def test_sizes(self):
+        if sys.maxsize == 2**63-1:
+            word_size = 8
+        else:
+            word_size = 4
+        assert self.lib.sizeof_prof_stacktrace_s() == 3*word_size