glibc 版本（version `GLIBC_2.14' not found）问题

目录

• 简述
• 解决这个问题的程序
  • 1、 glibc_hack 脚本
  • 2、修改高版本依赖到低版本的小程序
• 参考资料

简述#

很多时候，没法使用高版本系统，或者升级 glibc 版本，导致很多兼容性问题。这类的答案网上有很多，给出的解决方案也不少，这里做个简单的记录，方便参考。

大致来说，有这么几种方式：

1. 在低版本环境下编译，在高版本环境下使用。（比如在 centos 6 上使用 gcc 编译的程序，可以跑在 ubuntu 18.04）
2. 使用静态链接 libc （libstd++ ）的方式。（依赖库太多的时候，蛮麻烦的，也要考虑glibc对内核版本的要求）
3. 符号替换，使用低版本符号替换编译环境下的高版本符号，或使用链接器的wrap选项实现 libc 函数的包装。
4. 发布程序自带 libc.so 等，链接时指定-Wl,-rpath 或添加环境变量 LD_LIBRARY_PATH 来使用自带的动态库。

解决这个问题的程序#

1、 glibc_hack 脚本#

这是一个可以修改二进制文件，将 GLIBC_版本符号 替换为 弱引用（weak）的脚本。 使用弱引用版本的程序，任会输出错误消息，但在运行时不会直接终止该程序。《在旧的glibc上运行新的应用程序》 这里阐述了这个脚本的处理过程，使用这个脚本并非很优的做法。

这个脚本的处理是比较简单的，处理的情况也有限（2.14），适用情况有限。

Copy Highlighter-hljs
#Programatically do the steps outlined at
# http://www.lightofdawn.org/wiki/wiki.cgi/NewAppsOnOldGlibc
# - sets GLIBC 2_14 to weak to run targets on older libcs.
 
set -e
if [ ! -x $1 ]; then
    exit -1
fi
 
SECTION_OFFSET=$(printf "%d" $(readelf -V $1    |grep '.gnu.version_r' -A1 | grep 'Offset'    | awk '{print $4}'))
GLIB_2_14_OFFSET=$(printf "%d" $(readelf -V $1 | grep 'Name: GLIBC_2.14'   | awk '{print $1}' | tr -d :         ))
 
INDEX=$(( SECTION_OFFSET + GLIB_2_14_OFFSET + 4 + 1 ))
 
echo "Going to patch $1: "
echo ".gnu_version_r table (@ $(printf '%0X' $SECTION_OFFSET))"
echo "----> GLIBC_2.14 (@ $(printf '%0X' $GLIB_2_14_OFFSET))"
echo "Offset $(printf '%0X' $INDEX)"
 
xxd -c 1 -p $1 | awk "{if (NR==$INDEX)\$0=\"02\"; print;}" | xxd -r -c 1 -p  > $1.patched

脚本的地址在这里：https://github.com/mathew-hall/glibc_hack

2、修改高版本依赖到低版本的小程序#

下面代码是对网上一个程序的修改，用于将 ELF64 （如果要处理32位程序，将其中的一些结构体类型的64改为32即可）文件中的对 libc.so.6 依赖的符号，对其依赖的高 GLIBC_xxx 版本（2.12及以上）替换为低版本（2.2.5）。

Copy Highlighter-hljs
 
/* (c) 2012 Andrei Nigmatulin */
/* Modifiers solym(ymwh@foxmail.com) */
/* 用于去除对 GLIBC 的高版本依赖，将高版本符号替换到低版本 */
 
#include <elf.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
 
//  ELF文件解析（二）：ELF header详解
// https://www.cnblogs.com/jiqingwu/p/elf_explore_2.html
// ELF文件格式
// https://www.cntofu.com/book/114/Theory/ELF.md
// ELF文件格式解析(完)
// https://www.52pojie.cn/thread-591986-1-1.html
 
struct glibc_version_index {
  const char *version_str; // 标识版本的字符串
  unsigned version_idx;    // 记录这个版本的版本索引值
};
 
int process_elf(void *elf, size_t elf_sz) {
  // 获取 ELF文件头，在文件的开始，保存了路线图，描述了该文件的组织情况
  Elf64_Ehdr *elf_hdr = elf;
  // 获取 节头表(Section header table)
  Elf64_Shdr *sh = (Elf64_Shdr *)((char *)elf + elf_hdr->e_shoff);
  // 获取 节头字符串表
  Elf64_Shdr *sh_str = sh + elf_hdr->e_shstrndx;
  char *strtab = (char *)elf + sh_str->sh_offset;
 
  // 指向 .dynsym 表位置
  Elf64_Shdr *sh_dynsym = 0;
  Elf64_Sym *dynsym = 0;    // 指向符号信息表
  // 指向 .dynstr 表位置
  Elf64_Shdr *sh_dynstr = 0;
  char *dynstr = 0;
  // 指向 .gnu.version 表位置
  Elf64_Shdr *sh_version = 0;
  unsigned short *versions = 0; // 版本索引值列表
// 指向 .gnu.version_r 表位置
  Elf64_Shdr *sh_version_r = 0;
  Elf64_Verneed *verneed = 0; // 用于遍历版本依赖节表
 
  unsigned i;
  // 遍历 节头 每一个 表
  for (i = 1; i < elf_hdr->e_shnum; i++) {
    // 获取指针
    Elf64_Shdr *this = sh + i;
    // 获取当前节名称
    char *name = strtab + this->sh_name;
 
    // 判断是否是 .dynsym 表
    // .dynsym表包含有关动态链接所需的所有符号的信息
    //  该表中的某个位置隐藏了依赖于该新glibc的函数的名称
    if (this->sh_type == SHT_DYNSYM && 0 == strcmp(name, ".dynsym")) {
      sh_dynsym = this;
      dynsym = (typeof(dynsym))((char *)elf + this->sh_offset);
      printf("找打 .dynsym section\n");
    }
    // 判断是否是 .dynstr 表
    // .dynstr 表包含实际版本的实际字符串（.gnu.version_r 仅是记录值）
    else if (this->sh_type == SHT_STRTAB && !strcmp(name, ".dynstr")) {
      sh_dynstr = this;
      dynstr = (typeof(dynstr))((char *)elf + this->sh_offset);
      printf("找到 .dynstr section\n");
    }
    // 判断是否是 .gnu.version 表
    // .gnu.version表它包含所有动态符号的版本信息
    // .dynsym中列出的每个符号都会在此处有一个对应的条目
    else if (this->sh_type == SHT_GNU_versym && !strcmp(name, ".gnu.version")) {
      sh_version = this;
      versions = (typeof(versions))((char *)elf + this->sh_offset);
      printf("找到 .gnu.version section\n");
    }
    // 判断是否是 .gnu.version_r 表
    // .gnu.version_r 表包含二进制文件所需的库版本（因此带有_r后缀）
    // 每个条目都显示版本名称（GLIBC_2.2.5，GLIBC_2.14等），并在其末尾显示“版本号”
    //“版本”号用词不准确，实际上是其他表可以用来引用它的索引。
    else if (this->sh_type == SHT_GNU_verneed &&
             !strcmp(name, ".gnu.version_r")) {
      sh_version_r = this;
      verneed = (typeof(verneed))((char *)elf + this->sh_offset);
      printf("找到 .gnu.version_r section\n");
    }
  }
 
  if (!sh_dynsym || !sh_dynstr || !sh_version || !sh_version_r) {
    fprintf(stderr, "没有找到有效表节\n");
    return -1;
  }
 
  /* 记录 GLIBC_2.2.5 版本索引 */
  struct glibc_version_index glibc_2_2_5 = {"GLIBC_2.2.5", -1U};
  // 记录 高版本 在版本索引的位置
  struct glibc_version_index glibc_highver_arr[] = {
      /*{"GLIBC_2.3", -1U},   {"GLIBC_2.3.2", -1U}, {"GLIBC_2.3.3", -1U},
      {"GLIBC_2.3.4", -1U}, {"GLIBC_2.4", -1U},   {"GLIBC_2.5", -1U},
      {"GLIBC_2.6", -1U},   {"GLIBC_2.7", -1U},   {"GLIBC_2.8", -1U},
      {"GLIBC_2.9", -1U},   {"GLIBC_2.10", -1U},  {"GLIBC_2.11", -1U},*/
      {"GLIBC_2.12", -1U}, {"GLIBC_2.13", -1U}, {"GLIBC_2.14", -1U},
      {"GLIBC_2.15", -1U}, {"GLIBC_2.16", -1U}, {"GLIBC_2.17", -1U},
      {"GLIBC_2.18", -1U}, {"GLIBC_2.22", -1U}, {"GLIBC_2.23", -1U},
      {"GLIBC_2.24", -1U}, {"GLIBC_2.25", -1U}, {"GLIBC_2.26", -1U},
      {"GLIBC_2.27", -1U}, {"GLIBC_2.28", -1U}, {"GLIBC_2.29", -1U},
      {"GLIBC_2.30", -1U}, {"GLIBC_2.31", -1U}, {"GLIBC_2.32", -1U},
      {"GLIBC_2.32", -1U}, {"GLIBC_2.34", -1U}, {"GLIBC_2.35", -1U}};
    unsigned glibc_highver_count = sizeof(glibc_highver_arr)/sizeof(glibc_highver_arr[0]);
 
    /**
    * typedef struct {
    *         Elf64_Half      vn_version; // 此成员标识该结构的版本(0表示无效版本)
    *         Elf64_Half      vn_cnt;     // Elf64_Vernaux 数组中的元素数目
    *         Elf64_Word      vn_file;    // 以空字符结尾的字符串的字符串表偏移，用于提供版本依赖性的文件名。
    *                                     // 此名称与文件中找到的 .dynamic 依赖项之一匹配。
    *         Elf64_Word      vn_aux;     // 字节偏移，范围从此 Elf64_Verneed 项的开头到关联文件依赖项所需的版本定义的 Elf64_Vernaux 
    *                                     // 数组。必须存在至少一种版本依赖性。也可以存在其他版本依赖性，具体数目由 vn_cnt 值表示。
    *         Elf64_Word      vn_next;    // 从此 Elf64_Verneed 项的开头到下一个 Elf64_Verneed 项的字节偏移
    * } Elf64_Verneed;
    */
 
  Elf64_Verneed *next_verneed;
  int last = 0;
  // 遍历 .gnu.version_r 表
  for (; !last; verneed = next_verneed) {
    // 获取依赖的文件名
    char *filename = dynstr + verneed->vn_file;
    // 获取下一个 表项
    next_verneed = (typeof(next_verneed))((char *)verneed + verneed->vn_next);
    // 判断当前是否是最后一个表项了
    last = verneed->vn_next == 0;
    // 依赖文件不是 libc.so.6，就跳过
    if (strcmp(filename, "libc.so.6") && strcmp(filename, "libm.so.6")) {
      continue;
    }
 
    // 获取 Elf64_Vernaux 数组的结尾
    char *end_of_naux = (char *)next_verneed;
    if (last) {
      end_of_naux = (char *)elf + sh_version_r->sh_offset + sh_version_r->sh_size;
    }
 
    /**
    * typedef struct {
    *         Elf64_Word      vna_hash;    // 版本依赖性名称的散列值
    *         Elf64_Half      vna_flags;   // 版本依赖性特定信息(VER_FLG_WEAK[0x2]弱版本标识符)
    *         Elf64_Half      vna_other;   // 目前未使用
    *         Elf64_Word      vna_name;    // 以空字符结尾的字符串的字符串表偏移，用于提供版本依赖性的名称。
    *         Elf64_Word      vna_next;    // 从此 Elf64_Vernaux 项的开头到下一个 Elf64_Vernaux 项的字节偏移
    * } Elf64_Vernaux;
    */
    // 获取 Elf64_Vernaux 数组的元素数，首个元素
    unsigned cnt = verneed->vn_cnt;
    Elf64_Vernaux *naux = (typeof(naux))((char *)verneed + verneed->vn_aux);
    Elf64_Vernaux *next_naux;
    // 遍历 Elf64_Vernaux 数组（记录每一个依赖版本的信息）
    for (; cnt--; naux = next_naux) {
      char *name = dynstr + naux->vna_name; // GLIBC_xxx 字符串
      // 指向下一个元素
      next_naux = (typeof(next_naux))((char *)naux + naux->vna_next);
      printf("检查 %p %s %u\n", naux, name, naux->vna_next);
      // 如果是 GLIBC_2.2.5 记录下索引值
      if (strcmp(name, glibc_2_2_5.version_str) == 0) {
        glibc_2_2_5.version_idx = naux->vna_other;
        continue;
      }
      // 判断是否在高版本列表里面
      unsigned hveridx = 0;
      for (; hveridx < glibc_highver_count; ++hveridx) {
        if (strcmp(name, glibc_highver_arr[hveridx].version_str) == 0) {
          break;
        }
      }
      // 如果属于高版本中的一个
      if (hveridx != glibc_highver_count) {
          // 记录下索引值
        glibc_highver_arr[hveridx].version_idx = naux->vna_other;
        // 将整个 Elf64_Vernaux 数组当前项后面元素向前移动
        // 也就是将当前项从数组中移除掉
        if (cnt > 0 /*剩余未处理元素必须大于0，才需要*/ ) {
          memmove(naux, next_naux, end_of_naux - (char *)next_naux);
        }
        // 下一个指向当前，也就是前移一个元素（因为这个元素已经被覆盖了，或者就是最后一个）
        next_naux = naux;
      }
    }
    // 处理完 libc.so.6 就跳出
    break;
  }
 
  if (glibc_2_2_5.version_idx == -1U) {
    fprintf(stderr, "无法找到 GLIBC_2.2.5 索引值\n");
    return -1;
  }
  for (i = 0; i < glibc_highver_count; ++i) {
    if (glibc_highver_arr[i].version_idx != -1U) {
      printf("%s 索引值: %d\n", glibc_highver_arr[i].version_str,
             glibc_highver_arr[i].version_idx);
    }
  }
 
  // 找到并修补所有依赖 GLIBC_2.xx 高版本号的符号
  for (i = 1; i < sh_version->sh_size / sizeof(unsigned short); i++) {
    unsigned short v = versions[i];
    // 判断版本是否为高版本
    unsigned hveridx = 0;
    for (; hveridx < glibc_highver_count; ++hveridx) {
      if (v == glibc_highver_arr[hveridx].version_idx) {
        break;
      }
    }
    // 不是就跳过
    if (hveridx == glibc_highver_count) {
      continue;
    }
    // 修改版本到 2.2.5
    printf("  修改 '%s': %s(%u) -> %s(%u)\n", dynstr + dynsym[i].st_name,
           glibc_highver_arr[hveridx].version_str,glibc_highver_arr[hveridx].version_idx,
            glibc_2_2_5.version_str,glibc_2_2_5.version_idx);
    // 修改高版本的到低版本
    versions[i] = glibc_2_2_5.version_idx; // 这里也可以写成 =0 (local defualt)
  }
  return 0;
}
 
int main(int argc, char **argv) {
  if (argc < 2) {
    fprintf(stderr, "用法: %s <filename>\n", argv[0]);
    return 1;
  }
// 打开输入文件
  int fd = open(argv[1], O_RDWR);
 
  if (0 > fd) {
    perror("打开文件失败");
    return 1;
  }
 
  // 获取文件状态信息，主要是获取文件大小
  struct stat st;
  if (0 > fstat(fd, &st)) {
    perror("获取文件状态失败");
    close(fd);
    return 1;
  }
  // 进行内存映射文件，便于后面处理的时候直接操作
  void *mem = mmap(0, st.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 
  if (mem == MAP_FAILED) {
    perror("内存映射文件失败");
    close(fd);
    return 1;
  }
  close(fd);
  // 处理文件
  process_elf(mem, st.st_size);
  // 将修改同步到文件
  if (0 > msync(mem, st.st_size, MS_SYNC)) {
    perror("msync() failed");
    return 1;
  }
  // 解除内存映射
  munmap(mem, st.st_size);
  return 0;
}

修改前代码在在 https://github.com/anight/patch-memcpy 里面，这里主要将原本仅仅对 GLIBC_2.14 的处理，修改为对更多版本的处理。

参考资料#

• linux 修改 elf 文件的dynamic linker 和 rpath
• Linux修改ELF解决glibc兼容性问题
• Linux下符号版本原理及实现
• glibc和Symbol Versioning和如何链接出低版本glibc可运行的程序
• GLIBC_2.14 兼容问题 version `GLIBC_2.14′ not found
• Linux下安装glibc-2.14，解决“`GLIBC_2.14' not found”问题
• linux系统各发行版本出厂时glibc的版本列表
• https://github.com/anight/patch-memcpy
• [ 链接程序和库指南 > 第 7 章 目标文件格式 > 文件格式 > 版本控制节 > 版本依赖性节]
• Linux下符号版本原理及实现
• 从gcc静态链接开始的讨论，学了好几手
• gcc/g++静态链接和动态链接解决glibc版本不兼容的问题
• ELF文件格式
• 谈谈Linux应用程序 ABI兼容性
• Linux compatibility matrix
• Multiple glibc libraries on a single host
• 同时使用多种版本的libc && 编译libc
• Linux C++ 应用二进制兼容实践
• 更改引用高版本glibc的程序到引用低版本的glibc