gdbtool Unify offset struct

1. Single GDBOffsets struct
   - All offsets now accessed via gdb_offsets.thread_* and gdb_offsets.vcpu_*
   - Cleaner symbol export with single struct instance

2. Add version field inside GDBOffsets struct
   - Version is independent of struct size
   - Allows detection of field reordering/semantic changes
   - Increment when adding/removing/modifying/reordering fields

gdb: Remove unused gdb_pointer_size export

Author: Coldwings

common/stream.h

@@ -20,6 +20,7 @@ limitations under the License.
 #include <stdlib.h>
 #include <sys/types.h>
 
+#include <cstdint>
 #include <memory>
 
 struct iovec;

thread/thread.cpp

@@ -2241,38 +2241,68 @@ R"(
 // =========================================================================
 // GDB Offset Export - Global Symbols
 // These symbols are directly readable by GDB, no separate tool needed.
-// GDB Python script reads: gdb.parse_and_eval("gdb_thread_offset_vcpu")
+// GDB Python script reads: gdb.parse_and_eval("gdb_offsets")
 // =========================================================================
 
-// Export as C symbols to avoid name mangling
-extern "C" {
-
-// Thread structure offsets
-[[gnu::used]] const size_t gdb_thread_size = sizeof(photon::thread);
-[[gnu::used]] const size_t gdb_thread_offset_prev = 0;
-[[gnu::used]] const size_t gdb_thread_offset_next = sizeof(void*);
-[[gnu::used]] const size_t gdb_thread_offset_vcpu = offsetof(photon::thread, vcpu);
-[[gnu::used]] const size_t gdb_thread_offset_stack_ptr = offsetof(photon::thread, stack);
-[[gnu::used]] const size_t gdb_thread_offset_idx = offsetof(photon::thread, idx);
-[[gnu::used]] const size_t gdb_thread_offset_error_number = offsetof(photon::thread, error_number);
-[[gnu::used]] const size_t gdb_thread_offset_waitq = offsetof(photon::thread, waitq);
-[[gnu::used]] const size_t gdb_thread_offset_flags = offsetof(photon::thread, flags);
-[[gnu::used]] const size_t gdb_thread_offset_state = offsetof(photon::thread, state);
-[[gnu::used]] const size_t gdb_thread_offset_ts_wakeup = offsetof(photon::thread, ts_wakeup);
-[[gnu::used]] const size_t gdb_thread_offset_tls = offsetof(photon::thread, tls);
-[[gnu::used]] const size_t gdb_thread_offset_buf = offsetof(photon::thread, buf);
-[[gnu::used]] const size_t gdb_thread_offset_stack_size = offsetof(photon::thread, stack_size);
-
-// vCPU structure offsets
-[[gnu::used]] const size_t gdb_vcpu_size = sizeof(photon::vcpu_t);
-[[gnu::used]] const size_t gdb_vcpu_offset_sleepq = offsetof(photon::vcpu_t, sleepq);
-[[gnu::used]] const size_t gdb_vcpu_offset_nthreads = offsetof(photon::vcpu_t, nthreads);
-[[gnu::used]] const size_t gdb_vcpu_offset_idle_worker = offsetof(photon::vcpu_t, idle_worker);
-[[gnu::used]] const size_t gdb_vcpu_offset_standbyq = offsetof(photon::vcpu_t, standbyq);
-[[gnu::used]] const size_t gdb_vcpu_offset_list_node_prev = offsetof(photon::vcpu_t, __prev_ptr);
-[[gnu::used]] const size_t gdb_vcpu_offset_list_node_next = offsetof(photon::vcpu_t, __next_ptr);
-
-// Pointer size for architecture detection
-[[gnu::used]] const size_t gdb_pointer_size = sizeof(void*);
-
-}  // extern "C"
+// All offsets in a single struct for easy access
+struct GDBOffsets {
+    // Version number for compatibility checking
+    // Increment when adding/removing/modifying/reordering offset fields
+    uint32_t version;
+    uint32_t _reserved;  // Padding for alignment
+    
+    // Thread structure
+    size_t thread_size;
+    size_t thread_offset_prev;
+    size_t thread_offset_next;
+    size_t thread_offset_vcpu;
+    size_t thread_offset_stack_ptr;
+    size_t thread_offset_idx;
+    size_t thread_offset_error_number;
+    size_t thread_offset_waitq;
+    size_t thread_offset_flags;
+    size_t thread_offset_state;
+    size_t thread_offset_ts_wakeup;
+    size_t thread_offset_tls;
+    size_t thread_offset_buf;
+    size_t thread_offset_stack_size;
+    
+    // vCPU structure
+    size_t vcpu_size;
+    size_t vcpu_offset_sleepq;
+    size_t vcpu_offset_nthreads;
+    size_t vcpu_offset_idle_worker;
+    size_t vcpu_offset_standbyq;
+    size_t vcpu_offset_list_node_prev;
+    size_t vcpu_offset_list_node_next;
+};
+
+extern "C" const GDBOffsets gdb_offsets = {
+    .version = 1,
+    ._reserved = 0,
+    
+    // Thread structure
+    .thread_size = sizeof(photon::thread),
+    .thread_offset_prev = 0,
+    .thread_offset_next = sizeof(void*),
+    .thread_offset_vcpu = offsetof(photon::thread, vcpu),
+    .thread_offset_stack_ptr = offsetof(photon::thread, stack),
+    .thread_offset_idx = offsetof(photon::thread, idx),
+    .thread_offset_error_number = offsetof(photon::thread, error_number),
+    .thread_offset_waitq = offsetof(photon::thread, waitq),
+    .thread_offset_flags = offsetof(photon::thread, flags),
+    .thread_offset_state = offsetof(photon::thread, state),
+    .thread_offset_ts_wakeup = offsetof(photon::thread, ts_wakeup),
+    .thread_offset_tls = offsetof(photon::thread, tls),
+    .thread_offset_buf = offsetof(photon::thread, buf),
+    .thread_offset_stack_size = offsetof(photon::thread, stack_size),
+    
+    // vCPU structure
+    .vcpu_size = sizeof(photon::vcpu_t),
+    .vcpu_offset_sleepq = offsetof(photon::vcpu_t, sleepq),
+    .vcpu_offset_nthreads = offsetof(photon::vcpu_t, nthreads),
+    .vcpu_offset_idle_worker = offsetof(photon::vcpu_t, idle_worker),
+    .vcpu_offset_standbyq = offsetof(photon::vcpu_t, standbyq),
+    .vcpu_offset_list_node_prev = offsetof(photon::vcpu_t, __prev_ptr),
+    .vcpu_offset_list_node_next = offsetof(photon::vcpu_t, __next_ptr),
+};

tools/photongdb.py

@@ -173,47 +173,54 @@ def _load_offsets_from_symbols():
     thread_offsets = {}
     vcpu_offsets = {}
 
-    # Thread offsets
-    thread_symbols = [
-        ('_size', 'gdb_thread_size'),
-        ('prev', 'gdb_thread_offset_prev'),
-        ('next', 'gdb_thread_offset_next'),
-        ('vcpu', 'gdb_thread_offset_vcpu'),
-        ('stack_ptr', 'gdb_thread_offset_stack_ptr'),
-        ('idx', 'gdb_thread_offset_idx'),
-        ('error_number', 'gdb_thread_offset_error_number'),
-        ('waitq', 'gdb_thread_offset_waitq'),
-        ('flags', 'gdb_thread_offset_flags'),
-        ('state', 'gdb_thread_offset_state'),
-        ('ts_wakeup', 'gdb_thread_offset_ts_wakeup'),
-        ('tls', 'gdb_thread_offset_tls'),
-        ('buf', 'gdb_thread_offset_buf'),
-        ('stack_size', 'gdb_thread_offset_stack_size'),
+    # Check version for compatibility (now inside struct)
+    version = _read_gdb_symbol('gdb_offsets.version')
+    if version is not None:
+        cprint('INFO', f"GDB offsets version: {version}")
+    
+    # Thread offsets (from unified struct GDBOffsets)
+    thread_fields = [
+        ('_size', 'thread_size'),
+        ('prev', 'thread_offset_prev'),
+        ('next', 'thread_offset_next'),
+        ('vcpu', 'thread_offset_vcpu'),
+        ('stack_ptr', 'thread_offset_stack_ptr'),
+        ('idx', 'thread_offset_idx'),
+        ('error_number', 'thread_offset_error_number'),
+        ('waitq', 'thread_offset_waitq'),
+        ('flags', 'thread_offset_flags'),
+        ('state', 'thread_offset_state'),
+        ('ts_wakeup', 'thread_offset_ts_wakeup'),
+        ('tls', 'thread_offset_tls'),
+        ('buf', 'thread_offset_buf'),
+        ('stack_size', 'thread_offset_stack_size'),
     ]
 
-    # vCPU offsets
-    vcpu_symbols = [
-        ('_size', 'gdb_vcpu_size'),
-        ('sleepq', 'gdb_vcpu_offset_sleepq'),
-        ('nthreads', 'gdb_vcpu_offset_nthreads'),
-        ('idle_worker', 'gdb_vcpu_offset_idle_worker'),
-        ('standbyq', 'gdb_vcpu_offset_standbyq'),
-        ('list_node_prev', 'gdb_vcpu_offset_list_node_prev'),
-        ('list_node_next', 'gdb_vcpu_offset_list_node_next'),
+    # vCPU offsets (from unified struct GDBOffsets)
+    vcpu_fields = [
+        ('_size', 'vcpu_size'),
+        ('sleepq', 'vcpu_offset_sleepq'),
+        ('nthreads', 'vcpu_offset_nthreads'),
+        ('idle_worker', 'vcpu_offset_idle_worker'),
+        ('standbyq', 'vcpu_offset_standbyq'),
+        ('list_node_prev', 'vcpu_offset_list_node_prev'),
+        ('list_node_next', 'vcpu_offset_list_node_next'),
     ]
 
     success = True
 
-    for name, symbol in thread_symbols:
-        val = _read_gdb_symbol(symbol)
+    # Read thread offsets from unified struct
+    for name, field in thread_fields:
+        val = _read_gdb_symbol(f'gdb_offsets.{field}')
         if val is not None:
             thread_offsets[name] = val
         else:
             thread_offsets[name] = _DEFAULT_THREAD_OFFSETS.get(name, 0)
             success = False
 
-    for name, symbol in vcpu_symbols:
-        val = _read_gdb_symbol(symbol)
+    # Read vCPU offsets from unified struct
+    for name, field in vcpu_fields:
+        val = _read_gdb_symbol(f'gdb_offsets.{field}')
         if val is not None:
             vcpu_offsets[name] = val
         else:

tools/ppstack

@@ -51,16 +51,32 @@ if test ! -f "$PHOTONDB"; then
     exit 1
 fi
 
+# Detect libphoton.so location for solib-search-path
+PHOTON_LIB_PATH="${PHOTON_LIB_PATH:-}"
+if test -z "$PHOTON_LIB_PATH"; then
+    # Try relative to script directory
+    SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+    if test -f "$SCRIPT_DIR/../build/output/libphoton.so"; then
+        PHOTON_LIB_PATH="$SCRIPT_DIR/../build/output"
+    fi
+fi
+
 GDB=${GDB:-gdb}
 
-# Run GDB, strip out unwanted noise.
-$GDB --quiet -nx $GDBARGS /proc/$1/exe $1 <<EOF 2>&1 | 
-set width 0
+# Build GDB commands
+GDB_CMDS="set width 0
 set height 0
-set pagination no
+set pagination no"
+if test -n "$PHOTON_LIB_PATH"; then
+    GDB_CMDS="$GDB_CMDS
+set solib-search-path $PHOTON_LIB_PATH"
+fi
+GDB_CMDS="$GDB_CMDS
 source $PHOTONDB
-photon_ps
-EOF
+photon_ps"
+
+# Run GDB, strip out unwanted noise.
+echo "$GDB_CMDS" | $GDB --quiet -nx $GDBARGS /proc/$1/exe $1 2>&1 |
 /bin/sed -n \
     -e 's/^\((gdb) \)*//' \
     -e '/^Thread [0-9]/p' \