274 lines
6.8 KiB
C++
274 lines
6.8 KiB
C++
#include <errno.h>
|
||
#include <fcntl.h>
|
||
#include <fstream>
|
||
#include <stdio.h>
|
||
#include <sys/ioctl.h>
|
||
#include <unistd.h>
|
||
|
||
#include <assert.h>
|
||
#include <ctype.h>
|
||
#include <stdio_ext.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
|
||
#include "symbol.h"
|
||
#include "ucli.h"
|
||
#include "unwind.h"
|
||
|
||
#define BUF_LEN 4096
|
||
#define WHITESPACE " \t\n\r"
|
||
#define strneq(a, b, n) (strncmp((a), (b), (n)) == 0)
|
||
#define streq(a, b) (strcmp((a), (b)) == 0)
|
||
|
||
using namespace std;
|
||
|
||
class pid_cmdline {
|
||
private:
|
||
std::map<int, std::string> cmdlines;
|
||
|
||
public:
|
||
void clear(void);
|
||
std::string &get_pid_cmdline(int pid);
|
||
};
|
||
|
||
class pid_cmdline pid_cmdline;
|
||
|
||
static string unknow_symbol("UNKNOWN");
|
||
|
||
void pid_cmdline::clear(void) { cmdlines.clear(); }
|
||
|
||
std::string &pid_cmdline::get_pid_cmdline(int pid) {
|
||
if (cmdlines.count(pid) == 0) {
|
||
int i;
|
||
char buf[255];
|
||
char file[255];
|
||
std::fstream ifs;
|
||
|
||
snprintf(file, sizeof(file), "/proc/%d/cmdline", pid);
|
||
ifs.open(file, ios::binary | ios::in);
|
||
ifs.getline(buf, 255);
|
||
for (i = 0; i < ifs.gcount() && i < 255; i++) {
|
||
if (buf[i] < ' ') {
|
||
buf[i] = ' ';
|
||
}
|
||
}
|
||
|
||
cmdlines[pid] = buf;
|
||
}
|
||
|
||
return cmdlines[pid];
|
||
}
|
||
|
||
// 根据 sys_task 取值返回对应的字符串
|
||
static const char *sys_task_str(int sys_task) {
|
||
switch (sys_task) {
|
||
case 0:
|
||
return "USER_TASK";
|
||
case 1:
|
||
return "SYSTEM_TASK";
|
||
case 2:
|
||
return "IDLE_TASK";
|
||
default:
|
||
return "UNKNOWN_TASK";
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief call ioctl
|
||
*/
|
||
long diag_call_ioctl(unsigned long request, unsigned long arg) {
|
||
long ret = 0;
|
||
int fd;
|
||
|
||
fd = open(DEVICE, O_RDWR, 0);
|
||
if (fd < 0) {
|
||
printf("open %s error,try to open %s\n", DEVICE, DEVICE_BAK);
|
||
fd = open(DEVICE_BAK, O_RDWR, 0);
|
||
if (fd < 0) {
|
||
printf("open %s error!\n", DEVICE_BAK);
|
||
return EEXIST;
|
||
} else {
|
||
printf("open %s success!\n", DEVICE_BAK);
|
||
}
|
||
}
|
||
|
||
ret = ioctl(fd, request, arg);
|
||
if (ret < 0) {
|
||
printf("call cmd %lx fail, ret is %ld\n", request, ret);
|
||
goto err;
|
||
}
|
||
|
||
err:
|
||
close(fd);
|
||
return ret;
|
||
}
|
||
|
||
/**
|
||
* @brief unwind frame callback
|
||
*
|
||
* @param entry
|
||
* @param arg
|
||
* @return int
|
||
*/
|
||
static int unwind_frame_callback(struct unwind_entry *entry, void *arg) {
|
||
symbol sym;
|
||
std::string symbol; // Use std::string instead of string
|
||
elf_file file;
|
||
|
||
sym.reset(entry->ip);
|
||
|
||
if (g_symbol_parser.find_symbol_in_cache(entry->pid, entry->ip, symbol)) {
|
||
printf("#~ 0x%lx %s ([symbol])\n", entry->ip, symbol.c_str());
|
||
return 0;
|
||
}
|
||
// printf("#~ sym1 0x%lx\n", sym.ip);
|
||
if (g_symbol_parser.get_symbol_info(entry->pid, sym, file)) {
|
||
// printf("#~ sym2 0x%lx\n", sym.ip);
|
||
if (g_symbol_parser.find_elf_symbol(sym, file, entry->pid, entry->pid_ns)) {
|
||
printf("#~ 0x%lx %s ([symbol])\n", entry->ip, sym.name.c_str());
|
||
g_symbol_parser.putin_symbol_cache(entry->pid, entry->ip, sym.name);
|
||
} else {
|
||
printf("#~ 0x%lx %s ([symbol])\n", entry->ip, "(unknown)[symbol]");
|
||
g_symbol_parser.putin_symbol_cache(entry->pid, entry->ip, unknow_symbol);
|
||
}
|
||
} else {
|
||
printf("#~ 0x%lx %s ([symbol])\n", entry->ip, "(unknown)[vma,elf]");
|
||
g_symbol_parser.putin_symbol_cache(entry->pid, entry->ip, unknow_symbol);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/**
|
||
* @brief extract buffer with func
|
||
*
|
||
* @param buf
|
||
* @param len
|
||
* @param func
|
||
* @param arg
|
||
*/
|
||
void extract_variant_buffer(char *buf, unsigned int len,
|
||
int (*func)(void *, unsigned int, void *),
|
||
void *arg) {
|
||
unsigned int pos = 0;
|
||
struct diag_variant_buffer_head *head;
|
||
void *rec;
|
||
int rec_len;
|
||
char *ret;
|
||
char dir[1024] = {0};
|
||
|
||
ret = getcwd(dir, sizeof(dir));
|
||
|
||
while (pos < len) {
|
||
head = (struct diag_variant_buffer_head *)(buf + pos);
|
||
if (pos + sizeof(struct diag_variant_buffer_head) >= len)
|
||
break;
|
||
if (head->magic != DIAG_VARIANT_BUFFER_HEAD_MAGIC_SEALED)
|
||
break;
|
||
if (head->len < sizeof(struct diag_variant_buffer_head))
|
||
break;
|
||
|
||
rec = (void *)(buf + pos + sizeof(struct diag_variant_buffer_head));
|
||
rec_len = head->len - sizeof(struct diag_variant_buffer_head);
|
||
func(rec, rec_len, arg);
|
||
|
||
pos += head->len;
|
||
}
|
||
|
||
if (ret) {
|
||
(void)chdir(dir);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief printf user stack
|
||
*
|
||
* @param pid
|
||
* @param ns_pid
|
||
* @param comm
|
||
* @param raw_stack
|
||
*/
|
||
void diag_printf_raw_stack(int pid, int ns_pid, const char *comm,
|
||
raw_stack_detail *raw_stack) {
|
||
struct perf_sample stack_sample;
|
||
entry_cb_arg_t unwind_arg;
|
||
static u64 regs_buf[3];
|
||
|
||
printf(" USER STACK: SP:%lx, BP:%lx, IP:%lx\n", raw_stack->sp,
|
||
raw_stack->bp, raw_stack->ip);
|
||
stack_sample.user_stack.offset = 0;
|
||
stack_sample.user_stack.size = raw_stack->stack_size;
|
||
stack_sample.user_stack.data = (char *)&raw_stack->stack[0];
|
||
stack_sample.user_regs.regs = regs_buf;
|
||
stack_sample.user_regs.regs[PERF_REG_IP] = raw_stack->ip;
|
||
stack_sample.user_regs.regs[PERF_REG_SP] = raw_stack->sp;
|
||
stack_sample.user_regs.regs[PERF_REG_BP] = raw_stack->bp;
|
||
unwind__get_entries(unwind_frame_callback, &unwind_arg, &g_symbol_parser, pid,
|
||
ns_pid, &stack_sample);
|
||
fflush(stdout);
|
||
}
|
||
|
||
/**
|
||
* @brief printf task brief
|
||
*
|
||
* @param detail
|
||
*/
|
||
void printk_task_brief(task_detail *detail) {
|
||
printf(" TASK INFO: %s [%s / %s], PID: %d / %d\n",
|
||
sys_task_str(detail->sys_task), detail->cgroup_buf, detail->comm,
|
||
detail->tgid, detail->pid);
|
||
// printf(" TASK STATE: type: %s, state: %s, state %d\n",
|
||
// sys_task_str(detail->sys_task), state_str(detail->state).c_str(),
|
||
// detail->state);
|
||
}
|
||
|
||
/**
|
||
* @brief print kernel stack
|
||
*
|
||
* @param kern_stack
|
||
*/
|
||
void diag_printf_kern_stack(kern_stack_detail *kern_stack) {
|
||
int i;
|
||
symbol sym;
|
||
|
||
printf(" KERNEL STACK：\n");
|
||
for (i = 0; i < BACKTRACE_DEPTH; i++) {
|
||
if (kern_stack->stack[i] == (size_t)-1 || kern_stack->stack[i] == 0) {
|
||
break;
|
||
}
|
||
sym.reset(kern_stack->stack[i]);
|
||
if (g_symbol_parser.find_kernel_symbol(sym)) {
|
||
printf("#@ 0x%lx %s ([kernel.kallsyms])\n", kern_stack->stack[i],
|
||
sym.name.c_str());
|
||
} else {
|
||
printf("#@ 0x%lx %s\n", kern_stack->stack[i], "UNKNOWN");
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief print proc chains
|
||
*
|
||
* @param proc_chains
|
||
*/
|
||
void diag_printf_proc_chains(proc_chains_detail *proc_chains) {
|
||
int detail = 1;
|
||
int i;
|
||
|
||
printf(" PROC CHAINS:\n");
|
||
for (i = 0; i < PROCESS_CHAINS_COUNT; i++) {
|
||
if (proc_chains->chains[i][0] == 0)
|
||
break;
|
||
if (proc_chains->full_argv[i] == 0 && detail) {
|
||
string cmdline = pid_cmdline.get_pid_cmdline(proc_chains->tgid[i]);
|
||
if (cmdline.length() > 0)
|
||
printf("#^ 0xffffffffffffff %s (UNKNOWN)\n", cmdline.c_str());
|
||
else
|
||
printf("#^ 0xffffffffffffff %s (UNKNOWN)\n",
|
||
proc_chains->chains[i]);
|
||
} else {
|
||
printf("#^ 0xffffffffffffff %s (UNKNOWN)\n",
|
||
proc_chains->chains[i]);
|
||
}
|
||
}
|
||
} |