python运行gdb

# -*- coding: utf-8 -*-
import gdbutils
import ngxlua
import luajit21
import gdb
import nginx
import json
from collections import Counter

globalvar = gdbutils.globalvar
typ = gdbutils.typ

def convert_bytes(size):
    """Convert bytes to human readable format"""
    for unit in ['B', 'KB', 'MB', 'GB']:
        if size < 1024:
            return "%.2f%s" % (size, unit)
        size /= 1024
    return "%.2f%s" % (size, 'TB')

class NgxMemAnalyzer(gdb.Command):
    """Analyze OpenResty memory usage including LuaJIT, shared memory and other components.
Usage: ngx_mem_analyzer [all]"""

    def __init__(self):
        super(NgxMemAnalyzer, self).__init__("ngx_mem_analyzer", gdb.COMMAND_USER)

    def invoke(self, args, from_tty):
        print("Analyzing OpenResty memory usage...")
        argv = gdb.string_to_argv(args)
        
        # Get memory statistics
        result = self._analyze_memory()
        
        # Print results
        if len(argv) > 0 and argv[0] == 'all':
            print(json.dumps(result, indent=2))
        else:
            print(json.dumps(result['summary'], indent=2))

    def _analyze_memory(self):
        """Analyze different memory components"""
        result = {
            'summary': {},
            'details': {}
        }

        # Analyze LuaJIT memory
        lua_mem = self._analyze_luajit_memory()
        result['summary']['luajit'] = lua_mem['summary']
        result['details']['luajit'] = lua_mem['details']

        # Analyze shared memory
        shm_mem = self._analyze_ngx_shared_memory()
        result['summary']['ngx_shared'] = shm_mem['summary']

        # Analyze glibc memory
        glibc_mem = self._analyze_glibc_memory()
        result['summary']['glibc_mmap'] = glibc_mem['summary']['mmap']
        result['summary']['glibc_marea'] = glibc_mem['summary']['marea']
        result['details']['glibc'] = glibc_mem['details']

        # Analyze shared objects memory
        so_mem = self._analyze_shared_objects()
        result['summary']['shared_objects'] = so_mem['summary']
        result['details']['shared_objects'] = so_mem['details']

        # Calculate total memory
        total_mem = sum(result['summary'].values())
        result['summary']['total'] = convert_bytes(total_mem)

        # Convert all summary values to MB
        for key in result['summary']:
            if key != 'total':  # Skip total as it's already in MB
                result['summary'][key] = convert_bytes(result['summary'][key])

        return result

    def _analyze_luajit_memory(self):
        """Analyze LuaJIT memory usage"""
        lua_mem = {
            'summary': 0,
            'details': {}
        }

        try:
            # 获取 Lua 状态
            L = luajit21.get_global_L()
            if not L:
                return lua_mem

            # 获取 GC 状态
            g = luajit21.G(L)
            gc = g['gc']

            # 计算总内存使用
            total = int(gc['total'])
            lua_mem['summary'] = total

            # 获取详细内存信息
            lua_mem['details'] = {
                'total': convert_bytes(total),
                'threshold': convert_bytes(int(gc['threshold'])),
                'debt': convert_bytes(int(gc['debt'])),
                'estimate': convert_bytes(int(gc['estimate']))
            }

        except Exception as e:
            print("Error analyzing LuaJIT memory: %s" % str(e))

        return lua_mem

    def _analyze_ngx_shared_memory(self):
        """Analyze shared memory usage"""
        shm_mem = {
            'summary': 0,
            'details': []
        }

        try:
            # Get shared memory zones
            ngx_cycle = nginx.get_ngx_cycle()
            shared_memory = ngx_cycle['shared_memory']
            part = shared_memory['part']
            shm_zones = part['elts'].cast(typ("ngx_shm_zone_t*"))

            total_size = 0
            while part:
                for idx in xrange(0, part['nelts']):
                    item = shm_zones[idx]
                    size = int(item['shm']['size'])
                    total_size += size
                    
                    # 获取共享内存区域名称
                    name = ""
                    try:
                        # 从 shm_zone 的 shm_name 字段获取名称
                        shm_name = item['shm_name']
                        if shm_name:
                            name = str(shm_name['data'])
                    except:
                        # 如果无法获取名称，使用地址作为标识
                        name = "shm_zone_%s" % gdbutils.gdb_val_to_hex_str(item['shm']['addr'])
                    
                    shm_mem['details'].append({
                        'name': name,
                        'size': convert_bytes(size),
                        'address': gdbutils.gdb_val_to_hex_str(item['shm']['addr'])
                    })

                part = part['next']
                if part == 0:
                    break
                shm_zones = part['elts'].cast(typ("ngx_shm_zone_t*"))

            shm_mem['summary'] = total_size

        except Exception, e:
            print("Error analyzing shared memory: %s" % str(e))

        return shm_mem

    def _analyze_glibc_memory(self):
        """Analyze glibc memory usage"""
        glibc_mem = {
            'summary': {
                'mmap': 0,
                'marea': 0,
                'total': 0
            },
            'details': {
                'mmap': {
                    'total': 0,
                    'max': 0,
                    'chunks': []
                },
                'marea': {
                    'total': 0,
                    'max': 0,
                    'free_chunks': [],
                    'used_chunks': []
                }
            }
        }

        try:
            # 从全局变量获取 main_arena
            main_arena = gdb.parse_and_eval("main_arena")
            
            # Get marea stats
            marea_total = int(main_arena['system_mem'])
            marea_max = int(main_arena['max_system_mem'])
            glibc_mem['details']['marea']['total'] = convert_bytes(marea_total)
            glibc_mem['details']['marea']['max'] = convert_bytes(marea_max)
            glibc_mem['summary']['marea'] = marea_total

            # Get mmap stats
            try:
                mp_ = gdb.parse_and_eval("mp_")
            
                mmap_total = int(mp_['mmapped_mem'])
                mmap_max = int(mp_['max_mmapped_mem'])
                glibc_mem['details']['mmap']['total'] = convert_bytes(mmap_total)
                glibc_mem['details']['mmap']['max'] = convert_bytes(mmap_max)
                glibc_mem['summary']['mmap'] = mmap_total
            except Exception as e:
                print("Error retrieving mmap stats: %s" % str(e))
                glibc_mem['summary']['mmap'] = 0  # Set to 0 if there's an error

            # Calculate total
            total_mem = marea_total + mmap_total
            glibc_mem['summary']['total'] = total_mem

        except Exception as e:
            print("Error analyzing glibc memory: %s" % str(e))

        return glibc_mem

    def _analyze_shared_objects(self):
        """Analyze shared objects memory usage"""
        so_mem = {
            'summary': 0,
            'details': []
        }

        try:
            # 获取所有加载的共享库
            libs = gdb.execute("info shared", to_string=True)
            for line in libs.split('\n'):
                if not line.strip():
                    continue
                    
                # 解析共享库信息
                parts = line.split()
                if len(parts) < 4:
                    continue
                    
                try:
                    # 获取共享库的基地址
                    base_addr = int(parts[0], 16)
                    # 获取共享库的路径
                    lib_path = parts[-1]
                    
                    # 获取共享库的内存映射信息
                    maps = gdb.execute("info proc mappings", to_string=True)
                    lib_size = 0
                    
                    for map_line in maps.split('\n'):
                        if not map_line.strip():
                            continue
                            
                        map_parts = map_line.split()
                        if len(map_parts) < 3:
                            continue
                            
                        try:
                            start_addr = int(map_parts[0], 16)
                            end_addr = int(map_parts[1], 16)
                            size = end_addr - start_addr
                            
                            # 检查是否属于当前共享库
                            if start_addr >= base_addr and start_addr < base_addr + 0x1000000:  # 假设最大偏移为16MB
                                lib_size += size
                                        
                        except ValueError:
                            continue
                    
                    if lib_size > 0:
                        so_mem['summary'] += lib_size
                        so_mem['details'].append({
                            'name': lib_path,
                            'address': hex(base_addr),
                            'size': convert_bytes(lib_size)
                        })
                        
                except (ValueError, IndexError):
                    continue

        except Exception, e:
            print("Error analyzing shared objects memory: %s" % str(e))

        return so_mem


# Register the command
NgxMemAnalyzer()