程序员经验分享-hwhale

使用injectso 技术注入mtrace，对进程进行内存检测

2023-10-29
使用injectso 技术注入mtrace，对进程进行内存检测。
来源: ChinaUnix博客 　日期： 2007.04.13 17:28　(共有条评论) 我要评论
 
在开发过程中，我们可以在程序中调用mtrace函数，来对内存管理进行跟踪。可如果已经编译好的程序，我们该如何进行跟踪呢？

这里，我们可以采用injectso技术，在程序外面使被跟踪的程序调用mtrace，来实现。
因为mtrace属于libc最基本的库，所以不必采用_dl_open来载入相应的库。


主要参考
http://blog.chinaunix.net/u/30686/showart_272157.html

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define IMAGE_ADDR 0x08048000
void ptrace_readreg(int pid, struct user_regs_struct *regs);
void ptrace_writereg(int pid, struct user_regs_struct *regs);
struct user_regs_struct oldregs;
void ptrace_attach(int pid)
{
    if(ptrace(PTRACE_ATTACH, pid, NULL, NULL) 
    waitpid(pid, NULL, WUNTRACED);   
   
    ptrace_readreg(pid, &oldregs);
}
void ptrace_cont(int pid)
{
    int stat;
    if(ptrace(PTRACE_CONT, pid, NULL, NULL) 
    while(!WIFSTOPPED(stat))
        waitpid(pid, &stat, WNOHANG);
}
void ptrace_detach(int pid)
{
    ptrace_writereg(pid, &oldregs);
    if(ptrace(PTRACE_DETACH, pid, NULL, NULL) 
void ptrace_write(int pid, unsigned long addr, void *vptr, int len)
{
    int count;
    long word;
    count = 0;
    while(count 
        if(errno != 0)
            printf("ptrace_write failed\t %ld\n", addr + count);
    }
}
void ptrace_read(int pid, unsigned long addr, void *vptr, int len)
{
    int i,count;
    long word;
    unsigned long *ptr = (unsigned long *)vptr;
    i = count = 0;
    while (count 
char * ptrace_readstr(int pid, unsigned long addr)
{
    char *str = (char *) malloc(64);
    int i,count;
    long word;
    char *pa;
    i = count = 0;
    pa = (char *)&word;
    while(i 
        if (pa[0] == '\0') {
            str = '\0';
        break;
        }
        else
            str[i++] = pa[0];
        if (pa[1] == '\0') {
            str = '\0';
            break;
        }
        else
            str[i++] = pa[1];
        if (pa[2] == '\0') {
            str = '\0';
            break;
        }
        else
            str[i++] = pa[2];
        if (pa[3] == '\0') {
            str = '\0';
            break;
        }
        else
            str[i++] = pa[3];
    }
   
    return str;
}
void ptrace_readreg(int pid, struct user_regs_struct *regs)
{
    if(ptrace(PTRACE_GETREGS, pid, NULL, regs))
        printf("*** ptrace_readreg error ***\n");
    
    return ;
}
void ptrace_writereg(int pid, struct user_regs_struct *regs)
{
    if(ptrace(PTRACE_SETREGS, pid, NULL, regs))
        printf("*** ptrace_writereg error ***\n");
    
    return ;
}
void * ptrace_push(int pid, void *paddr, int size)
{
    unsigned long esp;
    struct user_regs_struct regs;
    ptrace_readreg(pid, &regs);
    esp = regs.esp;
    esp -= size;
    esp = esp - esp % 4;
    regs.esp = esp;
    ptrace_writereg(pid, &regs);
    ptrace_write(pid, esp, paddr, size);
    return (void *)esp;
}
void ptrace_call(int pid, unsigned long addr)
{
    void *pc;
    struct user_regs_struct regs;
    int stat;
    void *pra;
    pc = (void *) 0x41414140;
    pra = ptrace_push(pid, &pc, sizeof(pc));
    ptrace_readreg(pid, &regs);
//    ptrace_readreg(pid, &oldregs);
    regs.eip = addr;
    ptrace_writereg(pid, &regs);
    ptrace_cont(pid);
    while(!WIFSIGNALED(stat))
        waitpid(pid, &stat, WNOHANG);
    
//    ptrace_writereg(pid,&oldregs);
//    ptrace_cont(pid);
}
int nchains;
unsigned long symtab,strtab,jmprel,totalrelsize,relsize,nrels,dyn_addr;
struct link_map * get_linkmap(int pid)
{
    Elf32_Ehdr *ehdr = (Elf32_Ehdr *) malloc(sizeof(Elf32_Ehdr));       
    Elf32_Phdr *phdr = (Elf32_Phdr *) malloc(sizeof(Elf32_Phdr));
    Elf32_Dyn  *dyn =  (Elf32_Dyn *) malloc(sizeof(Elf32_Dyn));
    Elf32_Word got;
    struct link_map *map = (struct link_map *)malloc(sizeof(struct link_map));
    int i = 0;
    ptrace_read(pid, IMAGE_ADDR, ehdr, sizeof(Elf32_Ehdr));
    long phdr_addr;
    phdr_addr = IMAGE_ADDR + ehdr->e_phoff;
    printf("phdr_addr\t %p\n", phdr_addr);
    ptrace_read(pid, phdr_addr, phdr, sizeof(Elf32_Phdr));
    while(phdr->p_type != PT_DYNAMIC)
        ptrace_read(pid, phdr_addr += sizeof(Elf32_Phdr), phdr,
                                                      sizeof(Elf32_Phdr));
    long dyn_addr = phdr->p_vaddr;
    printf("dyn_addr\t %p\n", dyn_addr);
    ptrace_read(pid, dyn_addr, dyn, sizeof(Elf32_Dyn));
    while(dyn->d_tag != DT_PLTGOT) {
        ptrace_read(pid, dyn_addr + i * sizeof(Elf32_Dyn), dyn, sizeof(Elf32_Dyn));
        i++;
    }
    got = (Elf32_Word)dyn->d_un.d_ptr;
    got += 4;
    printf("GOT\t\t %p\n", got);
    unsigned long map_addr;
    ptrace_read(pid,(unsigned long)(got), &map_addr, 4);
    printf("map_addr\t %p\n", map_addr);
    ptrace_read(pid, map_addr, map, sizeof(struct link_map));
    
    free(ehdr);
    free(phdr);
    free(dyn);
    return map;
}
void get_sym_info(int pid, struct link_map *lm)
{
    Elf32_Dyn *dyn = (Elf32_Dyn *) malloc(sizeof(Elf32_Dyn));
    unsigned long dyn_addr;
    int ret;
    dyn_addr = (unsigned long)lm->l_ld;
   
    ptrace_read(pid, dyn_addr, dyn, sizeof(Elf32_Dyn));
    while(dyn->d_tag != DT_NULL){
        switch(dyn->d_tag)
        {
        case DT_SYMTAB:
            symtab = dyn->d_un.d_ptr;
            //puts("DT_SYMTAB");
            break;
        case DT_STRTAB:
            strtab = dyn->d_un.d_ptr;
            //puts("DT_STRTAB");
            break;
        case DT_HASH:
            nchains = 0;
//            ptrace_read(pid, dyn->d_un.d_ptr + lm->l_addr + 4,&nchains, sizeof(nchains));
            ptrace_read(pid, dyn->d_un.d_ptr + 4,&nchains, sizeof(nchains));
            //puts("DT_HASH");
            break;
        case DT_JMPREL:
            jmprel = dyn->d_un.d_ptr;
            //puts("DT_JMPREL");
            break;
        case DT_PLTRELSZ:
            //puts("DT_PLTRELSZ");
            totalrelsize = dyn->d_un.d_val;
            break;
        case DT_RELAENT:
            relsize = dyn->d_un.d_val;
            //puts("DT_RELAENT");
            break;
        case DT_RELENT:
            relsize = dyn->d_un.d_val;
            //puts("DT_RELENT");
            break;
        }
        ptrace_read(pid, dyn_addr += sizeof(Elf32_Dyn), dyn, sizeof(Elf32_Dyn));
    }
    nrels = totalrelsize / relsize;
    free(dyn);
}
unsigned long  find_symbol_in_linkmap(int pid, struct link_map *lm, char *sym_name)
{
    Elf32_Sym *sym = (Elf32_Sym *) malloc(sizeof(Elf32_Sym));
    int i;
    char *str;
    unsigned long ret;
    get_sym_info(pid, lm);
    if(nchains
        if (!sym->st_name || !sym->st_size || !sym->st_value)
            continue;
        str = (char *) ptrace_readstr(pid, strtab + sym->st_name);
        if (strcmp(str, sym_name) == 0) {
            free(str);
            str = ptrace_readstr(pid, (unsigned long)lm->l_name);
            printf("lib name [%s]\n", str);
            free(str);
            break;
        }
        free(str);
    }
    if (i == nchains)
        ret = 0;
    else
        ret =  lm->l_addr + sym->st_value;
    free(sym);
    return ret;
}
unsigned long  find_symbol(int pid, struct link_map *map, char *sym_name)
{
    struct link_map *lm = (struct link_map *) malloc(sizeof(struct link_map));
    unsigned long sym_addr;
    char *str;
   
    sym_addr = find_symbol_in_linkmap(pid, map, sym_name);
    if (sym_addr)
        return sym_addr;
    if (!map->l_next) return 0;
    ptrace_read(pid, (unsigned long)map->l_next, lm, sizeof(struct link_map));
    sym_addr = find_symbol_in_linkmap(pid, lm, sym_name);
    while(!sym_addr && lm->l_next) {
        ptrace_read(pid, (unsigned long)lm->l_next, lm, sizeof(struct link_map));
        str = ptrace_readstr(pid, (unsigned long)lm->l_name);
        if(str[0] == '\0')
            continue;
        printf("[%s]\n", str);
        free(str);
        if ((sym_addr = find_symbol_in_linkmap(pid, lm, sym_name)))
            break;
    }
    return sym_addr;
}
void get_dyn_info(int pid);
unsigned long  find_sym_in_rel(int pid, char *sym_name)
{
    Elf32_Rel *rel = (Elf32_Rel *) malloc(sizeof(Elf32_Rel));
    Elf32_Sym *sym = (Elf32_Sym *) malloc(sizeof(Elf32_Sym));
    int i;
    char *str;
    unsigned long ret;
    get_dyn_info(pid);
    for(i = 0; ir_info)) {
            ptrace_read(pid, symtab + ELF32_R_SYM(rel->r_info) *
                                               sizeof(Elf32_Sym), sym, sizeof(Elf32_Sym));
            str = ptrace_readstr(pid, strtab + sym->st_name);
            if (strcmp(str, sym_name) == 0) {
                free(str);
                break;
            }
            free(str);
        }
    }
    if (i == nrels)
        ret = 0;
    else
        ret =  rel->r_offset;
    free(rel);
    return ret;
}
void get_dyn_info(int pid)
{
    Elf32_Dyn *dyn = (Elf32_Dyn *) malloc(sizeof(Elf32_Dyn));
    int i = 0;
    ptrace_read(pid, dyn_addr + i * sizeof(Elf32_Dyn), dyn, sizeof(Elf32_Dyn));
    i++;
    while(dyn->d_tag){
        switch(dyn->d_tag)
        {
        case DT_SYMTAB:
            puts("DT_SYMTAB");
            symtab = dyn->d_un.d_ptr;
            break;
        case DT_STRTAB:
            strtab = dyn->d_un.d_ptr;
            //puts("DT_STRTAB");
            break;
        case DT_JMPREL:
            jmprel = dyn->d_un.d_ptr;
            //puts("DT_JMPREL");
            printf("jmprel\t %p\n", jmprel);
            break;
        case DT_PLTRELSZ:
            totalrelsize = dyn->d_un.d_val;
            //puts("DT_PLTRELSZ");
            break;
        case DT_RELAENT:
            relsize = dyn->d_un.d_val;
            //puts("DT_RELAENT");
            break;
        case DT_RELENT:
            relsize = dyn->d_un.d_val;
            //puts("DT_RELENT");
            break;
        }
        ptrace_read(pid, dyn_addr + i * sizeof(Elf32_Dyn), dyn, sizeof(Elf32_Dyn));
        i++;
    }
    nrels = totalrelsize / relsize;
    free(dyn);
}
void call_dl_open(int pid, unsigned long addr, char *libname)
{
    void *pRLibName;
    struct user_regs_struct regs;
    pRLibName = ptrace_push(pid, libname, strlen(libname) + 1);
    ptrace_readreg(pid, &regs);
    regs.eax = (unsigned long) pRLibName;
    regs.ecx = 0x0;
    regs.edx = RTLD_LAZY;
    ptrace_writereg(pid, &regs);
    ptrace_call(pid, addr);
    puts("call _dl_open ok");
}
void call_mtrace(int pid,unsigned long addr)
{
    ptrace_call(pid, addr);
    puts("call mtrace ok");
}
int main(int argc, char *argv[])
{
    int pid;
    struct link_map *map;
    char sym_name[256];
    unsigned long sym_addr;
    unsigned long new_addr,old_addr,rel_addr;
/*    if((pid = fork())
    /* ??????? */
    ptrace_attach(pid);
    map = get_linkmap(pid);                    
//    sym_addr = find_symbol(pid, map, "_dl_open");        /* call _dl_open */
//    printf("found _dl_open at addr %p\n", sym_addr);   
//    call_dl_open(pid, sym_addr, "/lib/i686/libc-2.3.2.so");    /* ???????? */   
   
    strcpy(sym_name, "mtrace");                /* intercept */
    sym_addr = find_symbol(pid, map, sym_name);
    printf("%s addr\t %p\n", sym_name, sym_addr);
    call_mtrace(pid,sym_addr);
    ptrace_detach(pid);
    exit(0);
}

测试程序
#include 
#include 
#include 
#include 
int main(void)
{
    pid_t pid=getpid();
    printf("pid=%d\n",pid);
    sleep(200);
    
    printf("asdfasdfsdf\n");
    char *p=(char*)malloc(10);
    malloc(20);
    free(p);
    
    return 0;
}
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

hook

使用injectso 技术注入mtrace，对进程进行内存检测 的相关文章

  • Visual Studio 调试模式下显示奇怪的内存内容

    我正在编写一些多线程C 程序 我尝试修改函数体开头的几条指令 以将执行重定向到其他地方 但我注意到 在 Visual Studio 2015 中调试时 某些内存位置似乎是不可更改的 如Memory window 例如 下图中有一个函数ApS

  • 我怎样才能连接到 Perl 的打印？

    这是一个场景 您有大量遗留脚本 全部使用通用库 所述脚本使用 print 语句进行诊断输出 不允许对脚本进行任何更改 它们范围广泛 得到了批准 并且早已离开了监督和控制的富有成效的山谷 现在出现了新的需求 现在必须将日志记录添加到库中 这必

  • Detours - 挂钩类成员函数 - 设置目标函数偏移量的语法？

    对于非类函数 我可以简单地声明要绕行的函数的偏移量 如下所示 typedef int cdecl SomeFunc char pBuffer int size SomeFunc Real SomeFunc SomeFunc 0xCAFEBA

  • 数据库中自定义字段的值在哪里[重复]

    这个问题在这里已经有答案了 我可以在常规选项卡的编辑页面产品中创建自定义字段 并在主题的functions php中使用以下代码 Display Fields add action woocommerce product options g

  • 如何添加在所有 cron 作业之前运行的 pre-hook 和 post-hook 脚本？

    假设我有以下 cron 条目 bin date 现在假设我想要在 cron 作业运行之前和之后运行的脚本 我可以将 cron 条目修改为如下所示 bin prehook bin date bin posthook 或者 如果我想要 preh

  • gitolite hooks - 接收后似乎不起作用

    我在我的仓库中配置了 gitolite 我看到了 gitolite 文献中记录的 2 个钩子副本 我希望服务器端挂钩 post receive 在有人推送到存储库时发送电子邮件 我正在使用 git notifier 但是 当我推动时什么也没

  • 低级键盘挂钩

    我刚刚买了一个新键盘 我有兴趣准确跟踪键盘整个使用寿命期间我按下 敲击的次数 我只想记录 keyUp 因为我不关心重复 我一直在搜索最好的方法来做到这一点 但我什至不知道该采取什么方法 所以我在智能搜索方面遇到了困难 另外 我真正使用过的唯

  • 在 Codeigniter 中手动调用/调用挂钩

    我搜索了手动调用 调用钩子以及网上类似的东西 但找不到任何东西 codeigniter中有这样的东西吗 我下面有一个钩子 它会按预期触发 但以防万一没有触发 那么我想在代码中手动调用它 Thanks hook post controller

  • 从注入的 DLL 中挂钩 DirectX EndScene

    我想绕道EndScene从任意 DirectX 9 应用程序创建一个小的覆盖层 例如 您可以使用 FRAPS 的帧计数器叠加层 该叠加层在激活时会显示在游戏中 我知道以下方法可以做到这一点 创建一个新的d3d9 dll 然后将其复制到游戏路

  • pthread_create 的钩子

    是否有 在 glibc 2 5 及更新版本中 为 pthread create 定义钩子的方法 有很多二进制应用程序 我想编写一个动态库通过 LD PRELOAD 加载 我可以在 main 属性构造函数 的入口处添加钩子 但是如何强制我的代

  • 如何连接 Windows 中的其他程序？

    谁能解释一个程序如何挂钩并修改 Windows 中其他程序的行为 这怎么可能呢 Windows 程序是否不会保护自己免受其他程序进入其内存等的影响 我不知道它的内部结构是如何工作的 所以我只是说 进入他们的记忆 我敢打赌它比这更复杂 另外

  • 调用 GetPointerFrameTouchInfo 时出现错误 998（对内存位置的访问无效）[重复]

    这个问题在这里已经有答案了 我正在尝试致电GetPointerFrameTouchInfo函数来获取指针计数 但该函数似乎失败了 错误 998 对内存位置的访问无效 知道为什么会发生这种情况以及如何解决它吗 我试图在钩子过程中调用相同的方法

  • pre_controller 钩子不会加载像 docs state 这样的基类？

    根据此处的 Codeigniter 文档 http ellislab com codeigniter user guide general hooks html http ellislab com codeigniter user guid

  • LD_PRELOAD 和 strace 有什么区别？

    这两种方法都用于收集系统调用及其参数和返回值 当我们更愿意LD PRELOAD为什么 也许我们可以说我们只能通过以下方式收集系统调用strace但我们可以收集图书馆的电话LD PRELOAD诡计 然而 还有另一个库的跟踪器 其名称是ltra

  • 从活动顶点数组生成平滑法线

    我正在尝试通过挂钩 OpenGl 调用来破解和修改旧版 opengl 固定管道游戏的多个渲染功能 而我当前的任务是实现着色器照明 我已经创建了一个适当的着色器程序 可以正确照亮大部分对象 但该游戏的地形是在没有提供正常数据的情况下绘制的 游

  • 用于阻止大于 20MB 的提交的预提交挂钩

    是否可以为 SVN 1 8 编写 prcommit 挂钩以避免提交大于 20MB 的文件 任何建议 将不胜感激 谢谢 我尝试过 但这不适用于二进制文件或其他文件扩展名 filesize SVNLOOK cat t TXN REPOS f w

  • Mercurial hook 的操作类似于“changegroup”，但仅在推送时？

    我们已经构建了一个变更集传播机制 但它依赖于捆绑和解除捆绑新变更集 如果我们要使用changegroup钩子 那么它会导致循环行为 因为钩子是运行的在拉 推或解绑期间 http mercurial selenic com wiki Hook

  • 全局键盘挂钩的合法用途是什么？

    除了仅应由操作系统提供的应用程序启动快捷方式之外 Windows 键盘挂钩等东西的合法用途是什么 在我看来 我们只在键盘记录器之类的事情上遇到问题 因为操作系统提供了钩子来执行除操作系统内核本身之外的任何情况下任何人都不允许执行的操作 编辑

  • Android应用程序：java / JNI调用挂钩策略

    我的目标是检测 AOSP 以便动态记录来自目标应用程序的所有 java 或 JNI 调用 带或不带参数和返回值 我不想修改应用程序 这就是我想要修改 Android 源代码的原因 我对 AOSP 及其众多库和框架不是很有经验 所以我正在寻求

  • 低级挂钩/SetWindowsHookEx lParam 自动重复？

    在这里阅读 Windows PC 上如何实现键盘自动重复 https stackoverflow com questions 876852 how is keyboard auto repeat implemented on a windo

随机推荐

  • 网络基础——TCP与UDP的区别

    Web基础 COOKIE与SESSION的区别 如上表格 区别总结如下 1 连接性质不同 TCP是面向有连接 而UDP是面向无连接的 所谓的面向有连接 通俗讲是指传输数据时 是否需要先建立通讯 确认对方在 并且有空接收数据 面向无连接 是不

  • 探索loss.backward() 和optimizer.step()的关系并灵活运用

    loss backward 和optimizer step 的关系及灵活运用 在deep learning的模型训练中 我们经常看到如下的代码片段 loss backward optimizer step 那么 这两个函数到底是怎么联系在一

  • layui数据可视化_利用ggplot2进行数据可视化

    2020 04 25 1 1 first step 意识到ggplot绘制其实是由一层层图层组成 一个命令即可增加一层 ggplot data mpg geom point mapping aes x displ y hwy ggplot

  • TensorFlow 2.0教程05：跨多个节点的分布式培训

    分布式训练允许扩大深度学习任务 因此可以学习更大的models或以更快的速度进行训练 在之前的教程中 我们讨论了如何MirroredStrategy在单个节点 物理机器 内实现多GPU训练 在本教程中 我们将解释如何在多个节点之间进行分布式

  • 永磁同步电机矢量控制（五）——波形记录及其分析

    恰饭一下 已经过了工作的年纪 在这里稍微出一下自己做的一套永磁同步电机的教程 为了解决电机控制入门难的问题 我将自己从一知半解到现在的学习记录整理成十个部分学习教程 从基础的矢量控制 到应用性较强的MTPA 弱磁控制等 最后深入到无速度传感

  • [1024]python sqlalchemy中create_engine用法

    用法 engine create engine dialect driver username password host port database dialect 数据库类型 driver 数据库驱动选择 username 数据库用户名

  • 论文笔记-深度估计(7)-CNN-SLAM Real-time dense monocular SLAM with learned depth prediction

    CVPR2017 CNN SLAM Real time dense monocular SLAM with learned depth prediction 关键词 基于CNN的单张图深度估计 语义SLAM 半稠密的直接法SLAM 作者提出

  • Unity 3D游戏十一：坦克大战

    前言 中山大学数据科学与计算机学院3D游戏课程学习记录博客 游戏代码 gitee 参考师兄的博客 师兄博客 游戏视频 bilibili 游戏要求 从商店下载游戏 Kawaii Tank 或 其他坦克模型 构建 AI 对战坦克 具体要求如下

  • vue替换url中的#为指定字符串

    url符号 处理 替换 号为asqm function replaceUrlJINtoAAB console log 123366 测试全局方法 添加时间 2022 7 21 15 05 43 url符号 处理 替换 号为asqm cons

  • HTML 快速入门

    目录 概念 快速入门 语法 基本标签 1 文件标签 2 文本标签 3 图片标签 4 列表标签 5 链接标签 6 div和span 7 语义化标签 8 表格标签 案例 旅游网站首页 表单标签 form标签 表单项标签 1 input 2 se

  • RocketMQ（一）—— 基本使用

    目录 1 RocketMQ基本使用 1 启动 2 测试 3 关闭 2 集群简介 特点 集群模式 工作流程 3 双主双从集群搭建 关闭防火墙 环境变量配置 创建消息存储路径 broker配置文件 启动 集群监控平台搭建 4 消息发送 1 基本

  • centos7安装mysql8.0.17初始化错误

    2019 08 22T13 21 17 518044Z 0 System MY 013169 Server root soft app mysql bin mysqld mysqld 8 0 17 initializing of serve

  • 免费下载正版office（仅限笔记本用户）

    买笔记本的时候 一般都会赠送正版office 但是由于重装系统等等某些原因 office找不到 面对这种情况 不用去网上找免登录的下载方法 详情请看下面方法 一 登录微软官网 注 一定要登录你买电脑时注册微软的账户 一般是qq邮箱 网址如下

  • 如何在前端完美控制浏览器兼容性问题

    分享一些好玩的代码 看看哈 function t n e var a 0 r isVisible function t var n t getBoundingClientRect e n width n right 0 n left 0 a

  • OpenGL 4.0的Tessellation Shader（细分曲面着色器）

    OpenGL 4 0的Tessellation Shader 细分曲面着色器 细分曲面着色器 Tessellation Shader 处于顶点着色器阶段的下一个阶段 我们可以看以下链接的OpenGL渲染流水线的图 https www ope

  • import pandas as pd 报错_chapter5-1 数据处理常见bug报错整理1

    本篇文章中 笔者把之前自己码代码的过程中出现的一些已解决的常见bug和解决方法进行了整理 还在不断更新中 主要内容有 一 与读取CSV文件有关的报错 1 1 utf 8 codec can t decode 1 2 pandas read

  • C语言中缀表达式求值(综合)

    题前需要了解的 中缀 后缀表达式是什么 不知道你们知不知道 反正我当时不知道 搜的百度 基本思路 先把输入的中缀表达式 后缀表达式 进行计算得出结果 栈 先进先出 先进后出 中缀转后缀 先把转换后的后缀表达式存入字符数组 从左至右依次读取

  • Mac 成功安装启动mysql，workbench连接不了

    首先启动并且成功登陆mysql 查看mysql占用端口号 执行命令 open Library LaunchDaemons com oracle oss mysql mysqld plist 我现在显示的是正常的端口号 如果你们显示的valu

  • 搭建部署svn服务器

    环境说明 环境 linux centos7 关闭防火墙和selinux systemctl stop firewalld setenforce 0 Ip 192 168 244 134 Svn服务器的搭建 安装svn yum install

  • 使用injectso 技术注入mtrace，对进程进行内存检测

    使用injectso 技术注入mtrace 对进程进行内存检测 来源 ChinaUnix博客 日期 2007 04 13 17 28 共有条评论 我要评论 在开发过程中 我们可以在程序中调用mtrace函数 来对内存管理进行跟踪 可如果已经

热门标签