从《gdb调试方法(2)-ptrace》可以看到，ptrace会频繁的下发PTRACE_GETREGS 和 PTRACE_SETREGS ,通过修改pc寄存器，从而使得进程能够被gdb接管，在trace处运行gdb的相关命令。

本文基于简单的程序，使用gdb完成简单的调试工作

# 调试什么
根据ptrace的理解，我们可以大概总结gdb能够获取哪些内容
1. 当前寄存器
2. DWARF调试信息
3. 函数调用栈
4. 变量
5. 函数当前栈
6. 内存内容
7. 线程状态
8. 函数汇编指令

# 示例代码
为了简单的实现gdb的调试，这里提供一个简易的示例代码如下
```
#include <stdio.h>

static char hello[] = "hello";
int y = 2;

void mem()
{
    void *p = malloc(sizeof(char)*10);
    memcpy(p, hello, strlen(hello) + 1);
    free(p);
}

int sum(int x)
{
    int s = x + y;
    printf("sum=%d\n", s);
    return s;
}

int main()
{
    int x = 1;
    sum(x);
    mem();
}
```
# 实践
为了编译可调试并带有DWARF调试信息，只需要编译时增加g选项即可
```
gcc example.c -g -o example
```
然后gdb直接调试即可
```
# gdb ./example
```
## 设置断点
```
(gdb) b sum
Breakpoint 1 at 0x780: file example.c, line 8.
(gdb) r
Starting program: /root/gdb/example

Breakpoint 1, sum (x=1) at example.c:8
8           int s = x + y;
```
## 查看寄存器
因为sum的形参是x，所以我们可以看到x0的值就是1 
```
(gdb) i r
x0             0x1                 1
x1             0xfffffffff498      281474976707736
x2             0xfffffffff4a8      281474976707752
x3             0xaaaaaaaaa7b4      187649984473012
x4             0x0                 0
x5             0xc56a615efa85d69   889080589597564265
x6             0xfffff7f87ad8      281474842000088
x7             0x4040100000000000  4629718009122914304
x8             0xffffffffffffffff  -1
x9             0xffff              65535
x10            0x800000008000      140737488388096
x11            0x0                 0
x12            0xfffff7e1be48      281474840510024
x13            0x0                 0
x14            0x0                 0
x15            0x6fffff47          1879048007
x16            0xaaaaaaabafa0      187649984540576
x17            0xfffff7e38c68      281474840628328
x18            0x73516240          1934713408
x19            0xaaaaaaaaa7d8      187649984473048
x20            0x0                 0
x21            0xaaaaaaaaa660      187649984472672
x22            0x0                 0
x23            0x0                 0
x24            0x0                 0
x25            0x0                 0
x26            0x0                 0
x27            0x0                 0
x28            0x0                 0
x29            0xfffffffff2f0      281474976707312
x30            0xaaaaaaaaa7cc      187649984473036
sp             0xfffffffff2f0      0xfffffffff2f0
pc             0xaaaaaaaaa780      0xaaaaaaaaa780 <sum+12>
cpsr           0x60000000          [ EL=0 C Z ]
fpsr           0x0                 0
fpcr           0x0                 0
```
## 查看堆栈
因为能够获得寄存器，所以可以从x30和x29推算堆栈，然后结合DWARF的信息可以打印如下。
```
(gdb) bt
#0  sum (x=1) at example.c:8
#1  0x0000aaaaaaaaa7cc in main () at example.c:16
```
## 查看源码
因为代码存在DWARF信息，所以能够借助DWARF信息查看代码行，如下
```
(gdb) l
13      int main()
14      {
15          int x = 1;
16          sum(x);
17      }
18
```
## 查看变量
DWARF提供了局部变量的偏移值，以及全局变量和静态的固定加载地址。所以借助DAWRF的信息，可以在gdb中查看变量
```
(gdb) p x
$3 = 1
(gdb) p y
$4 = 2
(gdb) p hello
$5 = "hello"
(gdb) p s
$6 = 0
```
## 查看内存
因为DWARF会帮我们计算好p的值，所以我们可以轻松的通过x打印内存，如下
```
(gdb) u 12
mem () at example.c:12
12          free(p);
(gdb) x/10c p
0xaaaaaaabc6b0: 104 'h' 101 'e' 108 'l' 108 'l' 111 'o' 0 '\000'        0 '\000'        0 '\000'
0xaaaaaaabc6b8: 0 '\000'        0 '\000'
```
同样的，也可以使用dump直接打印区域的内存，只要我们自行计算好变量起始地址和结束即可。  
首先我们对mem函数反汇编
```
(gdb) disassemble/m
Dump of assembler code for function mem:
9       {
   0x0000aaaaaaaaa894 <+0>:     stp     x29, x30, [sp, #-32]!
   0x0000aaaaaaaaa898 <+4>:     mov     x29, sp

10          void *p = malloc(sizeof(char)*10);
=> 0x0000aaaaaaaaa89c <+8>:     mov     x0, #0xa                        // #10
   0x0000aaaaaaaaa8a0 <+12>:    bl      0xaaaaaaaaa720 <malloc@plt>
   0x0000aaaaaaaaa8a4 <+16>:    str     x0, [sp, #24]

11          memcpy(p, hello, strlen(hello) + 1);
   0x0000aaaaaaaaa8a8 <+20>:    adrp    x0, 0xaaaaaaabb000
   0x0000aaaaaaaaa8ac <+24>:    add     x0, x0, #0x10
   0x0000aaaaaaaaa8b0 <+28>:    bl      0xaaaaaaaaa700 <strlen@plt>
   0x0000aaaaaaaaa8b4 <+32>:    add     x0, x0, #0x1
   0x0000aaaaaaaaa8b8 <+36>:    mov     x2, x0
   0x0000aaaaaaaaa8bc <+40>:    adrp    x0, 0xaaaaaaabb000
   0x0000aaaaaaaaa8c0 <+44>:    add     x1, x0, #0x10
   0x0000aaaaaaaaa8c4 <+48>:    ldr     x0, [sp, #24]
   0x0000aaaaaaaaa8c8 <+52>:    bl      0xaaaaaaaaa6f0 <memcpy@plt>

12          free(p);
   0x0000aaaaaaaaa8cc <+56>:    ldr     x0, [sp, #24]
   0x0000aaaaaaaaa8d0 <+60>:    bl      0xaaaaaaaaa760 <free@plt>

13      }
   0x0000aaaaaaaaa8d4 <+64>:    nop
   0x0000aaaaaaaaa8d8 <+68>:    ldp     x29, x30, [sp], #32
   0x0000aaaaaaaaa8dc <+72>:    ret

End of assembler dump.
```
如果我们想取出`void* p`的内存，可以看到sp+24存放了malloc的地址，而传入malloc的参数是0xa，如下
```
10          void *p = malloc(sizeof(char)*10);
=> 0x0000aaaaaaaaa89c <+8>:     mov     x0, #0xa                        // #10
   0x0000aaaaaaaaa8a0 <+12>:    bl      0xaaaaaaaaa720 <malloc@plt>
   0x0000aaaaaaaaa8a4 <+16>:    str     x0, [sp, #24]
```
然后解析malloc返回地址，如下
```
(gdb) x/gx $sp + 24
0xfffffffff2e8: 0x0000aaaaaaabc6b0
```
所以可以直接将其dump出来，如下
```
(gdb) u 12
mem () at example.c:12
12          free(p);
(gdb) dump binary memory test.bin 0x0000aaaaaaabc6b0 0x0000aaaaaaabc6b0+10
```
此时可以看到test.bin就是我想要查看的内存内容 hello
```
# hexdump -C test.bin
00000000  68 65 6c 6c 6f 00 00 00  00 00                    |hello.....|
0000000a
```
## 打印类型
打印类型也是非常常用的命令，借助DWARF可以帮我们默认解析好变量的类型，所以可以直接打印，如下
```
(gdb) ptype y
type = int
```
## 打印线程
多线程程序调试时，可以通过threads来切换线程，并单独控制某个线程，打印线程的命令如下
```
(gdb) i threads
  Id   Target Id                Frame
* 1    process 392716 "example" mem () at example.c:12
```
# 总结
到这里，gdb的基本简单调试的方法已经说明了，可以发现，gdb调试绝大部分情况下还是依赖DWARF调试信息，如果有这个信息，那么调试会变得非常简单，如果没有这个信息，那么就得人为的计算，如果不辅助一下插桩的技巧，或者标记点，那么调试计算会变得很麻烦，但是总而言之，调试的时候，尽可能得需要保证二进制包含DWARF调试信息。



gdb调试方法(3)-简单调试

gdb默认是通过ptrace系统调用实现功能，本文简单了解ptrace。
# ptrace
ptrace的系统调用
```
/* kernel/ptrace.c */
#define __NR_ptrace 117
__SYSCALL(__NR_ptrace, sys_ptrace)
```
在使用ptrace时需要包含`/sys/ptrace.h` ，调用ptrace系统调用的时候，需要根据不同的request来发送请求，request的种类如下
```
enum __ptrace_request
{
  /* Indicate that the process making this request should be traced.
     All signals received by this process can be intercepted by its
     parent, and its parent can use the other `ptrace' requests.  */
  PTRACE_TRACEME = 0,
#define PT_TRACE_ME PTRACE_TRACEME

  /* Return the word in the process's text space at address ADDR.  */
  PTRACE_PEEKTEXT = 1,
#define PT_READ_I PTRACE_PEEKTEXT

  /* Return the word in the process's data space at address ADDR.  */
  PTRACE_PEEKDATA = 2,
#define PT_READ_D PTRACE_PEEKDATA

  /* Return the word in the process's user area at offset ADDR.  */
  PTRACE_PEEKUSER = 3,
#define PT_READ_U PTRACE_PEEKUSER

  /* Write the word DATA into the process's text space at address ADDR.  */
  PTRACE_POKETEXT = 4,
#define PT_WRITE_I PTRACE_POKETEXT

  /* Write the word DATA into the process's data space at address ADDR.  */
  PTRACE_POKEDATA = 5,
#define PT_WRITE_D PTRACE_POKEDATA

  /* Write the word DATA into the process's user area at offset ADDR.  */
  PTRACE_POKEUSER = 6,
#define PT_WRITE_U PTRACE_POKEUSER

  /* Continue the process.  */
  PTRACE_CONT = 7,
#define PT_CONTINUE PTRACE_CONT

  /* Kill the process.  */
  PTRACE_KILL = 8,
#define PT_KILL PTRACE_KILL

  /* Single step the process.  */
  PTRACE_SINGLESTEP = 9,
#define PT_STEP PTRACE_SINGLESTEP

  /* Get all general purpose registers used by a processes.  */
  PTRACE_GETREGS = 12,
#define PT_GETREGS PTRACE_GETREGS

  /* Set all general purpose registers used by a processes.  */
  PTRACE_SETREGS = 13,
#define PT_SETREGS PTRACE_SETREGS
  /* Get all floating point registers used by a processes.  */
  PTRACE_GETFPREGS = 14,
#define PT_GETFPREGS PTRACE_GETFPREGS

  /* Set all floating point registers used by a processes.  */
  PTRACE_SETFPREGS = 15,
#define PT_SETFPREGS PTRACE_SETFPREGS

  /* Attach to a process that is already running. */
  PTRACE_ATTACH = 16,
#define PT_ATTACH PTRACE_ATTACH

  /* Detach from a process attached to with PTRACE_ATTACH.  */
  PTRACE_DETACH = 17,
#define PT_DETACH PTRACE_DETACH

  /* Get all extended floating point registers used by a processes.  */
  PTRACE_GETFPXREGS = 18,
#define PT_GETFPXREGS PTRACE_GETFPXREGS

  /* Set all extended floating point registers used by a processes.  */
  PTRACE_SETFPXREGS = 19,
#define PT_SETFPXREGS PTRACE_SETFPXREGS

  /* Continue and stop at the next entry to or return from syscall.  */
  PTRACE_SYSCALL = 24,
#define PT_SYSCALL PTRACE_SYSCALL

  /* Get a TLS entry in the GDT.  */
  PTRACE_GET_THREAD_AREA = 25,
#define PT_GET_THREAD_AREA PTRACE_GET_THREAD_AREA

  /* Change a TLS entry in the GDT.  */
  PTRACE_SET_THREAD_AREA = 26,
#define PT_SET_THREAD_AREA PTRACE_SET_THREAD_AREA

  /* Continue and stop at the next syscall, it will not be executed.  */
  PTRACE_SYSEMU = 31,
#define PT_SYSEMU PTRACE_SYSEMU

  /* Single step the process, the next syscall will not be executed.  */
  PTRACE_SYSEMU_SINGLESTEP = 32,
#define PT_SYSEMU_SINGLESTEP PTRACE_SYSEMU_SINGLESTEP

  /* Execute process until next taken branch.  */
  PTRACE_SINGLEBLOCK = 33,
#define PT_STEPBLOCK PTRACE_SINGLEBLOCK

  /* Set ptrace filter options.  */
  PTRACE_SETOPTIONS = 0x4200,
#define PT_SETOPTIONS PTRACE_SETOPTIONS
  /* Get last ptrace message.  */
  PTRACE_GETEVENTMSG = 0x4201,
#define PT_GETEVENTMSG PTRACE_GETEVENTMSG

  /* Get siginfo for process.  */
  PTRACE_GETSIGINFO = 0x4202,
#define PT_GETSIGINFO PTRACE_GETSIGINFO

  /* Set new siginfo for process.  */
  PTRACE_SETSIGINFO = 0x4203,
#define PT_SETSIGINFO PTRACE_SETSIGINFO

  /* Get register content.  */
  PTRACE_GETREGSET = 0x4204,
#define PTRACE_GETREGSET PTRACE_GETREGSET

  /* Set register content.  */
  PTRACE_SETREGSET = 0x4205,
#define PTRACE_SETREGSET PTRACE_SETREGSET

  /* Like PTRACE_ATTACH, but do not force tracee to trap and do not affect
     signal or group stop state.  */
  PTRACE_SEIZE = 0x4206,
#define PTRACE_SEIZE PTRACE_SEIZE

  /* Trap seized tracee.  */
  PTRACE_INTERRUPT = 0x4207,
#define PTRACE_INTERRUPT PTRACE_INTERRUPT

  /* Wait for next group event.  */
  PTRACE_LISTEN = 0x4208,
#define PTRACE_LISTEN PTRACE_LISTEN

  /* Retrieve siginfo_t structures without removing signals from a queue.  */
  PTRACE_PEEKSIGINFO = 0x4209,
#define PTRACE_PEEKSIGINFO PTRACE_PEEKSIGINFO

  /* Get the mask of blocked signals.  */
  PTRACE_GETSIGMASK = 0x420a,
#define PTRACE_GETSIGMASK PTRACE_GETSIGMASK

  /* Change the mask of blocked signals.  */
  PTRACE_SETSIGMASK = 0x420b,
#define PTRACE_SETSIGMASK PTRACE_SETSIGMASK

  /* Get seccomp BPF filters.  */
  PTRACE_SECCOMP_GET_FILTER = 0x420c,
#define PTRACE_SECCOMP_GET_FILTER PTRACE_SECCOMP_GET_FILTER

  /* Get seccomp BPF filter metadata.  */
  PTRACE_SECCOMP_GET_METADATA = 0x420d,
#define PTRACE_SECCOMP_GET_METADATA PTRACE_SECCOMP_GET_METADATA

  /* Get information about system call.  */
  PTRACE_GET_SYSCALL_INFO = 0x420e,
#define PTRACE_GET_SYSCALL_INFO PTRACE_GET_SYSCALL_INFO

  /* Get rseq configuration information.  */
  PTRACE_GET_RSEQ_CONFIGURATION = 0x420f
#define PTRACE_GET_RSEQ_CONFIGURATION PTRACE_GET_RSEQ_CONFIGURATION
};
```
不同的ptrace请求上面其实存在简要的注释，如果需要详细了解，可以man-page链接查看
> https://man7.org/linux/man-pages/man2/ptrace.2.html

# gdb如何调用ptrace
针对gdb，我们可以准备一个简单的hello world程序，然后使用gdb进行调试。查看一个简单的hello world是如何进行ptrace调用的。简单的程序如下
```
int main() { printf("hello \n");}
```
因为ptrace是系统调用，可以直接使用`perf trace -e`抓取，如下
```
gcc test.c -o test
perf trace -e ptrace -p $(pidof gdb)
```
运行日志如下
```
     0.000 ( 0.007 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401603456)                 = 0
     0.010 ( 0.001 ms): gdb/6228 ptrace(request: 16898, pid: 6249, data: 140731401607008)              = 0
     0.049 ( 0.002 ms): gdb/6228 ptrace(request: 7, pid: 6249, addr: 0x1)                              = 0
     0.836 ( 0.002 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401603456)                 = 0
     0.840 ( 0.001 ms): gdb/6228 ptrace(request: 16898, pid: 6249, data: 140731401607008)              = 0
     0.854 ( 0.001 ms): gdb/6228 ptrace(request: 16896, pid: 6249, data: 1048639)                      = 0
     0.886 ( 0.001 ms): gdb/6228 ptrace(request: 3, pid: 6249, addr: 0x88, data: 140731401607416)      = 0
     0.888 ( 0.001 ms): gdb/6228 ptrace(request: 3, pid: 6249, addr: 0xb8, data: 140731401607416)      = 0
     0.901 ( 0.001 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401604736)                 = 0
    10.369 ( 0.005 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401604352)                 = 0
    10.375 ( 0.002 ms): gdb/6228 ptrace(request: 13, pid: 6249, data: 140731401604352)                 = 0
    10.396 ( 0.001 ms): gdb/6228 ptrace(request: 7, pid: 6249, addr: 0x1)                              = 0
    10.560 ( 0.002 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401604064)                 = 0
    10.564 ( 0.001 ms): gdb/6228 ptrace(request: 16898, pid: 6249, data: 140731401607616)              = 0
    10.566 ( 0.001 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401604096)                 = 0
    10.568 ( 0.001 ms): gdb/6228 ptrace(request: 13, pid: 6249, data: 140731401604096)                 = 0
    10.666 ( 0.002 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401603440)                 = 0
    10.670 ( 0.001 ms): gdb/6228 ptrace(request: 13, pid: 6249, data: 140731401603440)                 = 0
    10.675 ( 0.002 ms): gdb/6228 ptrace(request: 9, pid: 6249, addr: 0x1)                              = 0
    10.687 ( 0.001 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401604064)                 = 0
    10.690 ( 0.001 ms): gdb/6228 ptrace(request: 16898, pid: 6249, data: 140731401607616)              = 0
    10.692 ( 0.001 ms): gdb/6228 ptrace(request: 3, pid: 6249, addr: 0x380, data: 140731401607256)     = 0
    10.709 ( 0.001 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401604272)                 = 0
    10.711 ( 0.001 ms): gdb/6228 ptrace(request: 13, pid: 6249, data: 140731401604272)                 = 0
    10.716 ( 0.001 ms): gdb/6228 ptrace(request: 3, pid: 6249, addr: 0x380, data: 140731401607768)     = 0
    10.721 ( 0.002 ms): gdb/6228 ptrace(request: 7, pid: 6249, addr: 0x1)                              = 0
    10.860 ( 0.002 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401604064)                 = 0
    10.864 ( 0.001 ms): gdb/6228 ptrace(request: 16898, pid: 6249, data: 140731401607616)              = 0
    10.866 ( 0.001 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401604096)                 = 0
    10.869 ( 0.002 ms): gdb/6228 ptrace(request: 13, pid: 6249, data: 140731401604096)                 = 0
    92.068 ( 0.006 ms): gdb/6228 ptrace(request: 3, pid: 6249, addr: 0xa8, data: 140731401605624)      = 0
    92.244 ( 0.003 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401603440)                 = 0
    92.249 ( 0.002 ms): gdb/6228 ptrace(request: 13, pid: 6249, data: 140731401603440)                 = 0
    92.257 ( 0.003 ms): gdb/6228 ptrace(request: 9, pid: 6249, addr: 0x1)                              = 0
    92.393 ( 0.002 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401603936)                 = 0
    92.397 ( 0.001 ms): gdb/6228 ptrace(request: 16898, pid: 6249, data: 140731401607488)              = 0
    92.400 ( 0.001 ms): gdb/6228 ptrace(request: 3, pid: 6249, addr: 0x380, data: 140731401607128)     = 0
    92.459 ( 0.001 ms): gdb/6228 ptrace(request: 3, pid: 6249, addr: 0xa8, data: 140731401607128)      = 0
    92.469 ( 0.001 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401604272)                 = 0
    92.471 ( 0.001 ms): gdb/6228 ptrace(request: 13, pid: 6249, data: 140731401604272)                 = 0
    92.477 ( 0.001 ms): gdb/6228 ptrace(request: 3, pid: 6249, addr: 0x380, data: 140731401607768)     = 0
    92.482 ( 0.001 ms): gdb/6228 ptrace(request: 7, pid: 6249, addr: 0x1)                              = 0
```
可以看到，gdb频繁的调用ptrace来获取寄存器并修改指针寄存器的值。
# 如何防止程序被调试
根据man-page的文档，可以知道，ptrace只能被一个人去attach，所以防止程序被调试的方法很简单，那就是主动调用TRACEME让父进程来调试自己， 如下
```
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/prctl.h>
#include <sys/ptrace.h>

int main()
{
    if (ptrace(PTRACE_TRACEME, 0, 0, 0) < 0 ) {
        exit(42);
    }
    while(1) {
        printf("hello \n");
        sleep(1);
    }
    return 0;
}
```
这里使用PTRACE_TRACEME来让父进程调试自己，那么可以从程序运行后看到如下信息
```
# cat /proc/$(pidof hello)/status | grep TracerPid
TracerPid:      5071
```
这里可以看到自己被attach的pid是5071，而5071是自己程序运行的父进程bash。此时因为ptrace只能被一个人trace，所有其他的程序无法调试它。此时可以尝试gdb调试此程序
```
# gdb attach 6526
Attaching to process 6526
Could not attach to process.  If your uid matches the uid of the target
process, check the setting of /proc/sys/kernel/yama/ptrace_scope, or try
again as the root user.  For more details, see /etc/sysctl.d/10-ptrace.conf
warning: process 6526 is already traced by process 5071
```
可以看到其他程序无法调试此程序。

同样的程序也无法在运行时被调试，如下
```
# gdb ./hello
(gdb) r
Starting program: /root/gdb/hello
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
[Inferior 1 (process 6578) exited with code 052]
```
# 总结
到了这里，可以知道了gdb本身是ptrace的封装，其利用内核实现的ptrace机制来完成程序的调试，从而获取当前代码运行时刻的寄存器，内存，栈等相关信息。

那么我有一个问题，如何尝试让TracerPid为0，从而伪装自身并未已被参与调试。

gdb调试方法(2)-ptrace

gdb是工作中常用的调试工具，朋友说要介绍一下gdb的使用方法，思考了一下，遂打算整理自己的gdb经验，总结出来作为一个系列，一方面用作巩固自己的基础知识，另一方面用来分享自己的一些经验和技巧。

# 参考资料
我使用gdb的所有技巧来源于两个链接，如果想一手资料学习理解，可以进如下链接学习

## gdb文档
> https://sourceware.org/gdb

这里是gdb的官方文档位置，会每日构建文档查看，链接如下

> https://sourceware.org/gdb/current/onlinedocs/gdb.html

pdf版本
> https://sourceware.org/gdb/current/onlinedocs/gdb.pdf

## 100个gdb技巧
> https://github.com/hellogcc/100-gdb-tips

这是整理的关于gdb的中文文档

# 总结
如果需要了解gdb的使用，上述文档完全能够达成目的。接下来主要针对自己的gdb经验做一个总结，和上述内容仅技术相关。

gdb调试方法(1)-介绍

经常在不同的设备上进行调试，所以不断的attach，但是因为笔记本，台式机，linux，windows来回切换，导致tmux的窗口有时发生变化。

本来这事情很简单，没什么必要记下来，但这种事情又发生很多次了，但每次隔一段时间就忘，此时为了加强记忆，遂记录一下。

下面说明出现窗口大小问题后的处理。

# 处理办法
这个问题处理办法很简单，就是经常容易忘而已，如下
```
ctrl + b 后加上 shift + d
```
值得注意的是，这样会把原来机器的tmux挤走，所以回到原来机器上时，再attach回来即可。

tmux窗口大小问题

frp是非常热门的高性能反代应用，可以轻松的做到内网穿透，我们在开发过程中，经常需要将一些机器的调试口短暂暴露出来，这样就可以随时随地的开发了，本文基于frp介绍一下如何配置，提高开发效率
# 下载
直接上github找最近的release即可
```
https://github.com/fatedier/frp/
```
当前是0.64.0。

![image.png](/static/img/c650bb8b513e081ad31089cc3998e750.image.webp)

下载frp主要分主机和调试机器，主机在amd64上，所以如下下载，而其他架构则是自己的调试机器，我的机器比较多，所以下面几个机器我都配好了。
* jetson orin
* 3a6000
* rk3588
* ft2000
* hi616
* h6
* intel nuc

上述机器根据不同的架构下载不同的linux二进制即可。
```
wget https://github.com/fatedier/frp/releases/download/v0.64.0/frp_0.64.0_linux_xxx.tar.gz
```

下载之后解压，里面有服务端配置和客户端配置，下面介绍配置

# 服务端
服务端是需要公网ip的，默认简单配置如下
```
# frps.toml
bindPort = 1111                                  
auth.token = "********"            
```
运行如下
```
./frps -c frps.toml
```
然后编写一个简单的systemd service即可。
```
[Unit]
Description=FRP Server

[Service]
Type = simple
ExecStart = /pathtofrp/run.sh

[Install]
WantedBy=multi-user.target
```
然后安装激活服务即可
```
cp frps.service /usr/lib/systemd/system/
systemctl enable frps
systemctl start frps
```
# 客户端
客户端是自己的设备机器，默认22端口最多，其他情况下vnc 5900端口或者其他web端口都可以，自行配置即可，我以22为例介绍，配置如下
```
# frpc.toml
serverAddr = "***********"
serverPort = 2222                  

auth.token = "********"        

[[proxies]]
name = "ssh"
type = "tcp"
localIP = "127.0.0.1"
localPort = 22
remotePort = 3333
```
同样运行如下
```
./frpc -c frpc.toml
```
编写成服务如下
```
[Unit]
Description=FRP Client

[Service]
Type = simple
ExecStart = /pathtofrp/run.sh

[Install]
WantedBy=multi-user.target
```
激活服务如下
```
cp frpc.service /usr/lib/systemd/system/
systemctl enable frpc
systemctl start frpc
```

# 提醒
服务端暴露的端口1111是服务主机端口，而客户端链接端口2222是公网端口，这里代理设置端口3333是公网给localPort的连接的端口。

# 总结
frp作为免费开源的反代程序，其配置和使用也非常轻松易用。非常方便软件开发者进行远程开发。
