ruby-oci8 2.2.12 → 2.2.14

data/ext/oci8/plthook_elf.c

@@ -1,12 +1,12 @@
 /* -*- indent-tabs-mode: nil -*-
  *
- * plthook_elf.c -- implemention of plthook for ELF format
+ * plthook_elf.c -- implementation of plthook for ELF format
  *
  * URL: https://github.com/kubo/plthook
  *
  * ------------------------------------------------------
  *
- * Copyright 2013-2016 Kubo Takehiro <kubo@jiubao.org>
+ * Copyright 2013-2019 Kubo Takehiro <kubo@jiubao.org>
  *
  * Redistribution and use in source and binary forms, with or without modification, are
  * permitted provided that the following conditions are met:
@@ -50,6 +50,7 @@
 #include <dlfcn.h>
 #ifdef __sun
 #include <sys/auxv.h>
+#include <procfs.h>
 #define ELF_TARGET_ALL
 #endif /* __sun */
 #ifdef __FreeBSD__
@@ -61,6 +62,10 @@
 #include <link.h>
 #include "plthook.h"
 
+#if defined __UCLIBC__ && !defined RTLD_NOLOAD
+#define RTLD_NOLOAD 0
+#endif
+
 #ifndef __GNUC__
 #define __attribute__(arg)
 #endif
@@ -75,46 +80,66 @@
 
 #if defined __x86_64__ || defined __x86_64
 #define R_JUMP_SLOT   R_X86_64_JUMP_SLOT
-#define Elf_Plt_Rel   Elf_Rela
-#define PLT_DT_REL    DT_RELA
 #define R_GLOBAL_DATA R_X86_64_GLOB_DAT
 #elif defined __i386__ || defined __i386
 #define R_JUMP_SLOT   R_386_JMP_SLOT
-#define Elf_Plt_Rel   Elf_Rel
-#define PLT_DT_REL    DT_REL
 #define R_GLOBAL_DATA R_386_GLOB_DAT
+#define USE_REL
 #elif defined __arm__ || defined __arm
 #define R_JUMP_SLOT   R_ARM_JUMP_SLOT
-#define Elf_Plt_Rel   Elf_Rel
+#define R_GLOBAL_DATA R_ARM_GLOB_DAT
+#define USE_REL
 #elif defined __aarch64__ || defined __aarch64 /* ARM64 */
 #define R_JUMP_SLOT   R_AARCH64_JUMP_SLOT
-#define Elf_Plt_Rel   Elf_Rela
+#define R_GLOBAL_DATA R_AARCH64_GLOB_DAT
 #elif defined __powerpc64__
 #define R_JUMP_SLOT   R_PPC64_JMP_SLOT
-#define Elf_Plt_Rel   Elf_Rela
+#define R_GLOBAL_DATA R_PPC64_GLOB_DAT
 #elif defined __powerpc__
 #define R_JUMP_SLOT   R_PPC_JMP_SLOT
-#define Elf_Plt_Rel   Elf_Rela
+#define R_GLOBAL_DATA R_PPC_GLOB_DAT
+#elif defined __riscv
+#define R_JUMP_SLOT   R_RISCV_JUMP_SLOT
+#if __riscv_xlen == 32
+#define R_GLOBAL_DATA R_RISCV_32
+#elif __riscv_xlen == 64
+#define R_GLOBAL_DATA R_RISCV_64
+#else
+#error unsupported RISCV implementation
+#endif
 #elif 0 /* disabled because not tested */ && (defined __sparcv9 || defined __sparc_v9__)
 #define R_JUMP_SLOT   R_SPARC_JMP_SLOT
-#define Elf_Plt_Rel   Elf_Rela
 #elif 0 /* disabled because not tested */ && (defined __sparc || defined __sparc__)
 #define R_JUMP_SLOT   R_SPARC_JMP_SLOT
-#define Elf_Plt_Rel   Elf_Rela
 #elif 0 /* disabled because not tested */ && (defined __ia64 || defined __ia64__)
 #define R_JUMP_SLOT   R_IA64_IPLTMSB
-#define Elf_Plt_Rel   Elf_Rela
 #else
 #error unsupported OS
 #endif
 
+#ifdef USE_REL
+#define Elf_Plt_Rel   Elf_Rel
+#define PLT_DT_REL    DT_REL
+#define PLT_DT_RELSZ  DT_RELSZ
+#define PLT_DT_RELENT DT_RELENT
+#else
+#define Elf_Plt_Rel   Elf_Rela
+#define PLT_DT_REL    DT_RELA
+#define PLT_DT_RELSZ  DT_RELASZ
+#define PLT_DT_RELENT DT_RELAENT
+#endif
+
 #if defined __LP64__
 #ifndef ELF_CLASS
 #define ELF_CLASS     ELFCLASS64
 #endif
 #define SIZE_T_FMT "lu"
 #define ELF_WORD_FMT "u"
+#ifdef __ANDROID__
+#define ELF_XWORD_FMT "llu"
+#else
 #define ELF_XWORD_FMT "lu"
+#endif
 #define ELF_SXWORD_FMT "ld"
 #define Elf_Half Elf64_Half
 #define Elf_Xword Elf64_Xword
@@ -162,43 +187,82 @@
 #endif
 #endif /* __LP64__ */
 
-#if defined(PT_GNU_RELRO) && !defined(__sun)
-#define SUPPORT_RELRO /* RELRO (RELocation Read-Only) */
-#if !defined(DF_1_NOW) && defined(DF_1_BIND_NOW)
-#define DF_1_NOW DF_1_BIND_NOW
-#endif
-#endif
+typedef struct mem_prot {
+    size_t start;
+    size_t end;
+    int prot;
+} mem_prot_t;
+
+#define NUM_MEM_PROT 20
 
 struct plthook {
     const Elf_Sym *dynsym;
     const char *dynstr;
     size_t dynstr_size;
     const char *plt_addr_base;
-    const Elf_Plt_Rel *plt;
-    size_t plt_cnt;
-    Elf_Xword r_type;
-#ifdef SUPPORT_RELRO
-    const char *relro_start;
-    const char *relro_end;
+    const Elf_Plt_Rel *rela_plt;
+    size_t rela_plt_cnt;
+#ifdef R_GLOBAL_DATA
+    const Elf_Plt_Rel *rela_dyn;
+    size_t rela_dyn_cnt;
 #endif
+    mem_prot_t mem_prot[NUM_MEM_PROT];
 };
 
 static char errmsg[512];
-
-#ifdef SUPPORT_RELRO
 static size_t page_size;
-#endif
+#define ALIGN_ADDR(addr) ((void*)((size_t)(addr) & ~(page_size - 1)))
 
 static int plthook_open_executable(plthook_t **plthook_out);
 static int plthook_open_shared_library(plthook_t **plthook_out, const char *filename);
 static const Elf_Dyn *find_dyn_by_tag(const Elf_Dyn *dyn, Elf_Sxword tag);
-#ifdef SUPPORT_RELRO
-static int set_relro_members(plthook_t *plthook, struct link_map *lmap);
-#endif
+
+typedef struct mem_prot_iter mem_prot_iter_t;
+static int mem_prot_begin(mem_prot_iter_t *iter);
+static int mem_prot_next(mem_prot_iter_t *iter, mem_prot_t *mem_prot);
+static void mem_prot_end(mem_prot_iter_t *iter);
+
 static int plthook_open_real(plthook_t **plthook_out, struct link_map *lmap);
+static int plthook_set_mem_prot(plthook_t *plthook);
+static int plthook_get_mem_prot(plthook_t *plthook, void *addr);
+#if defined __FreeBSD__ || defined __sun
 static int check_elf_header(const Elf_Ehdr *ehdr);
+#endif
 static void set_errmsg(const char *fmt, ...) __attribute__((__format__ (__printf__, 1, 2)));
 
+#if defined __ANDROID__ || defined __UCLIBC__
+struct dl_iterate_data {
+    char* addr;
+    struct link_map lmap;
+};
+
+static int dl_iterate_cb(struct dl_phdr_info *info, size_t size, void *cb_data)
+{
+    struct dl_iterate_data *data = (struct dl_iterate_data*)cb_data;
+    Elf_Half idx = 0;
+
+    for (idx = 0; idx < info->dlpi_phnum; ++idx) {
+        const Elf_Phdr *phdr = &info->dlpi_phdr[idx];
+        char* base = (char*)info->dlpi_addr + phdr->p_vaddr;
+        if (base <= data->addr && data->addr < base + phdr->p_memsz) {
+            break;
+        }
+    }
+    if (idx == info->dlpi_phnum) {
+        return 0;
+    }
+    for (idx = 0; idx < info->dlpi_phnum; ++idx) {
+        const Elf_Phdr *phdr = &info->dlpi_phdr[idx];
+        if (phdr->p_type == PT_DYNAMIC) {
+            data->lmap.l_addr = info->dlpi_addr;
+            data->lmap.l_ld = (Elf_Dyn*)(info->dlpi_addr + phdr->p_vaddr);
+            return 1;
+        }
+    }
+    return 0;
+}
+#endif
+
 int plthook_open(plthook_t **plthook_out, const char *filename)
 {
     *plthook_out = NULL;
@@ -211,6 +275,27 @@ int plthook_open(plthook_t **plthook_out, const char *filename)
 
 int plthook_open_by_handle(plthook_t **plthook_out, void *hndl)
 {
+#if defined __ANDROID__ || defined __UCLIBC__
+    const static char *symbols[] = {
+        "__INIT_ARRAY__",
+        "_end",
+        "_start"
+    };
+    size_t i;
+
+    if (hndl == NULL) {
+        set_errmsg("NULL handle");
+        return PLTHOOK_FILE_NOT_FOUND;
+    }
+    for (i = 0; i < sizeof(symbols)/sizeof(symbols[0]); i++) {
+        char *addr = dlsym(hndl, symbols[i]);
+        if (addr != NULL) {
+            return plthook_open_by_address(plthook_out, addr - 1);
+        }
+    }
+    set_errmsg("Could not find an address in the specified handle.");
+    return PLTHOOK_INTERNAL_ERROR;
+#else
     struct link_map *lmap = NULL;
 
     if (hndl == NULL) {
@@ -222,12 +307,22 @@ int plthook_open_by_handle(plthook_t **plthook_out, void *hndl)
         return PLTHOOK_FILE_NOT_FOUND;
     }
     return plthook_open_real(plthook_out, lmap);
+#endif
 }
 
 int plthook_open_by_address(plthook_t **plthook_out, void *address)
 {
 #if defined __FreeBSD__
     return PLTHOOK_NOT_IMPLEMENTED;
+#elif defined __ANDROID__ || defined __UCLIBC__
+    struct dl_iterate_data data = {0,};
+    data.addr = address;
+    dl_iterate_phdr(dl_iterate_cb, &data);
+    if (data.lmap.l_ld == NULL) {
+        set_errmsg("Could not find memory region containing address %p", address);
+        return PLTHOOK_INTERNAL_ERROR;
+    }
+    return plthook_open_real(plthook_out, &data.lmap);
 #else
     Dl_info info;
     struct link_map *lmap = NULL;
@@ -243,7 +338,9 @@ int plthook_open_by_address(plthook_t **plthook_out, void *address)
 
 static int plthook_open_executable(plthook_t **plthook_out)
 {
-#if defined __linux__
+#if defined __ANDROID__ || defined __UCLIBC__
+    return plthook_open_shared_library(plthook_out, NULL);
+#elif defined __linux__
     return plthook_open_real(plthook_out, _r_debug.r_map);
 #elif defined __sun
     const char *auxv_file = "/proc/self/auxv";
@@ -280,12 +377,21 @@ static int plthook_open_executable(plthook_t **plthook_out)
 static int plthook_open_shared_library(plthook_t **plthook_out, const char *filename)
 {
     void *hndl = dlopen(filename, RTLD_LAZY | RTLD_NOLOAD);
+#if defined __ANDROID__ || defined __UCLIBC__
+    int rv;
+#else
     struct link_map *lmap = NULL;
+#endif
 
     if (hndl == NULL) {
         set_errmsg("dlopen error: %s", dlerror());
         return PLTHOOK_FILE_NOT_FOUND;
     }
+#if defined __ANDROID__ || defined __UCLIBC__
+    rv = plthook_open_by_handle(plthook_out, hndl);
+    dlclose(hndl);
+    return rv;
+#else
     if (dlinfo(hndl, RTLD_DI_LINKMAP, &lmap) != 0) {
         set_errmsg("dlinfo error");
         dlclose(hndl);
@@ -293,6 +399,7 @@ static int plthook_open_shared_library(plthook_t **plthook_out, const char *file
     }
     dlclose(hndl);
     return plthook_open_real(plthook_out, lmap);
+#endif
 }
 
 static const Elf_Dyn *find_dyn_by_tag(const Elf_Dyn *dyn, Elf_Sxword tag)
@@ -306,135 +413,170 @@ static const Elf_Dyn *find_dyn_by_tag(const Elf_Dyn *dyn, Elf_Sxword tag)
     return NULL;
 }
 
-#ifdef SUPPORT_RELRO
-#if defined __linux__
-static const char *get_mapped_file(const void *address, char *buf, int *err)
-{
-    unsigned long addr = (unsigned long)address;
+#ifdef __linux__
+struct mem_prot_iter {
     FILE *fp;
+};
 
-    fp = fopen("/proc/self/maps", "r");
-    if (fp == NULL) {
+static int mem_prot_begin(mem_prot_iter_t *iter)
+{
+    iter->fp = fopen("/proc/self/maps", "r");
+    if (iter->fp == NULL) {
         set_errmsg("failed to open /proc/self/maps");
-        *err = PLTHOOK_INTERNAL_ERROR;
-        return NULL;
+        return -1;
     }
-    while (fgets(buf, PATH_MAX, fp) != NULL) {
+    return 0;
+}
+
+static int mem_prot_next(mem_prot_iter_t *iter, mem_prot_t *mem_prot)
+{
+    char buf[PATH_MAX];
+    char perms[5];
+    int bol = 1; /* beginnng of line */
+
+    while (fgets(buf, PATH_MAX, iter->fp) != NULL) {
         unsigned long start, end;
-        int offset = 0;
+        int eol = (strchr(buf, '\n') != NULL); /* end of line */
+        if (bol) {
+            /* The fgets reads from the beginning of a line. */
+            if (!eol) {
+                /* The next fgets reads from the middle of the same line. */
+                bol = 0;
+            }
+        } else {
+            /* The fgets reads from the middle of a line. */
+            if (eol) {
+                /* The next fgets reads from the beginning of a line. */
+                bol = 1;
+            }
+            continue;
+        }
 
-        sscanf(buf, "%lx-%lx %*s %*x %*x:%*x %*u %n", &start, &end, &offset);
-        if (offset == 0) {
+        if (sscanf(buf, "%lx-%lx %4s", &start, &end, perms) != 3) {
             continue;
         }
-        if (start < addr && addr < end) {
-            char *p = buf + offset;
-            while (*p == ' ') {
-                p++;
-            }
-            if (*p != '/') {
-                continue;
-            }
-            p[strlen(p) - 1] = '\0'; /* remove '\n' */
-            fclose(fp);
-            return p;
+        mem_prot->start = start;
+        mem_prot->end = end;
+        mem_prot->prot = 0;
+        if (perms[0] == 'r') {
+            mem_prot->prot |= PROT_READ;
+        }
+        if (perms[1] == 'w') {
+            mem_prot->prot |= PROT_WRITE;
+        }
+        if (perms[2] == 'x') {
+            mem_prot->prot |= PROT_EXEC;
         }
+        return 0;
+    }
+    return -1;
+}
+
+static void mem_prot_end(mem_prot_iter_t *iter)
+{
+    if (iter->fp != NULL) {
+        fclose(iter->fp);
     }
-    fclose(fp);
-    set_errmsg("Could not find a mapped file reagion containing %p", address);
-    *err = PLTHOOK_INTERNAL_ERROR;
-    return NULL;
 }
 #elif defined __FreeBSD__
-static const char *get_mapped_file(const void *address, char *buf, int *err)
+struct mem_prot_iter {
+    struct kinfo_vmentry *kve;
+    int idx;
+    int num;
+};
+
+static int mem_prot_begin(mem_prot_iter_t *iter)
 {
-    uint64_t addr = (uint64_t)address;
-    struct kinfo_vmentry *top;
-    int i, cnt;
-
-    top = kinfo_getvmmap(getpid(), &cnt);
-    if (top == NULL) {
-        fprintf(stderr, "failed to call kinfo_getvmmap()\n");
-        *err = PLTHOOK_INTERNAL_ERROR;
-        return NULL;
-    }
-    for (i = 0; i < cnt; i++) {
-        struct kinfo_vmentry *kve = top + i;
-
-        if (kve->kve_start < addr && addr < kve->kve_end) {
-            strncpy(buf, kve->kve_path, PATH_MAX);
-            free(top);
-            return buf;
-        }
+    iter->kve = kinfo_getvmmap(getpid(), &iter->num);
+    if (iter->kve == NULL) {
+         set_errmsg("failed to call kinfo_getvmmap()\n");
+         return -1;
     }
-    free(top);
-    set_errmsg("Could not find a mapped file reagion containing %p", address);
-    *err = PLTHOOK_INTERNAL_ERROR;
-    return NULL;
+    iter->idx = 0;
+    return 0;
 }
-#else
-static const char *get_mapped_file(const void *address, char *buf, int *err)
+
+static int mem_prot_next(mem_prot_iter_t *iter, mem_prot_t *mem_prot)
 {
-    set_errmsg("Could not find a mapped file reagion containing %p", address);
-    *err = PLTHOOK_INTERNAL_ERROR;
-    return NULL;
+    if (iter->idx >= iter->num) {
+        return -1;
+    }
+    struct kinfo_vmentry *kve = &iter->kve[iter->idx++];
+    mem_prot->start = kve->kve_start;
+    mem_prot->end = kve->kve_end;
+    mem_prot->prot = 0;
+    if (kve->kve_protection & KVME_PROT_READ) {
+        mem_prot->prot |= PROT_READ;
+    }
+    if (kve->kve_protection & KVME_PROT_WRITE) {
+        mem_prot->prot |= PROT_WRITE;
+    }
+    if (kve->kve_protection & KVME_PROT_EXEC) {
+        mem_prot->prot |= PROT_EXEC;
+    }
+    return 0;
 }
-#endif
 
-static int set_relro_members(plthook_t *plthook, struct link_map *lmap)
+static void mem_prot_end(mem_prot_iter_t *iter)
 {
-    char fnamebuf[PATH_MAX];
-    const char *fname;
+    if (iter->kve != NULL) {
+        free(iter->kve);
+    }
+}
+#elif defined(__sun)
+struct mem_prot_iter {
     FILE *fp;
-    Elf_Ehdr ehdr;
-    Elf_Half idx;
-    int rv;
+    prmap_t maps[20];
+    size_t idx;
+    size_t num;
+};
 
-    if (lmap->l_name[0] == '/') {
-        fname = lmap->l_name;
-    } else {
-        int err;
+static int mem_prot_begin(mem_prot_iter_t *iter)
+{
+    iter->fp = fopen("/proc/self/map", "r");
+    if (iter->fp == NULL) {
+        set_errmsg("failed to open /proc/self/map");
+        return -1;
+    }
+    iter->idx = iter->num = 0;
+    return 0;
+}
+
+static int mem_prot_next(mem_prot_iter_t *iter, mem_prot_t *mem_prot)
+{
+    prmap_t *map;
 
-        fname = get_mapped_file(plthook->dynstr, fnamebuf, &err);
-        if (fname == NULL) {
-            return err;
+    if (iter->idx == iter->num) {
+        iter->num = fread(iter->maps, sizeof(iter->maps[0]), sizeof(iter->maps) / sizeof(iter->maps[0]), iter->fp);
+        if (iter->num == 0) {
+            return -1;
         }
+        iter->idx = 0;
     }
-    fp = fopen(fname, "r");
-    if (fp == NULL) {
-        set_errmsg("failed to open %s", fname);
-        return PLTHOOK_INTERNAL_ERROR;
+    map = &iter->maps[iter->idx++];
+    mem_prot->start = map->pr_vaddr;
+    mem_prot->end = map->pr_vaddr + map->pr_size;
+    mem_prot->prot = 0;
+    if (map->pr_mflags & MA_READ) {
+        mem_prot->prot |= PROT_READ;
     }
-    if (fread(&ehdr, sizeof(ehdr), 1, fp) != 1) {
-        set_errmsg("failed to read the ELF header.");
-        fclose(fp);
-        return PLTHOOK_INVALID_FILE_FORMAT;
+    if (map->pr_mflags & MA_WRITE) {
+        mem_prot->prot |= PROT_WRITE;
     }
-    rv = check_elf_header(&ehdr);
-    if (rv != 0) {
-        fclose(fp);
-        return rv;
+    if (map->pr_mflags & MA_EXEC) {
+        mem_prot->prot |= PROT_EXEC;
     }
+    return 0;
+}
 
-    fseek(fp, ehdr.e_phoff, SEEK_SET);
-
-    for (idx = 0; idx < ehdr.e_phnum; idx++) {
-        Elf_Phdr phdr;
-
-        if (fread(&phdr, sizeof(phdr), 1, fp) != 1) {
-            set_errmsg("failed to read the program header table.");
-            fclose(fp);
-            return PLTHOOK_INVALID_FILE_FORMAT;
-        }
-        if (phdr.p_type == PT_GNU_RELRO) {
-            plthook->relro_start = plthook->plt_addr_base + phdr.p_vaddr;
-            plthook->relro_end = plthook->relro_start + phdr.p_memsz;
-            break;
-        }
+static void mem_prot_end(mem_prot_iter_t *iter)
+{
+    if (iter->fp != NULL) {
+        fclose(iter->fp);
     }
-    fclose(fp);
-    return 0;
 }
+#else
+#error Unsupported platform
 #endif
 
 static int plthook_open_real(plthook_t **plthook_out, struct link_map *lmap)
@@ -443,13 +585,30 @@ static int plthook_open_real(plthook_t **plthook_out, struct link_map *lmap)
     const Elf_Dyn *dyn;
     const char *dyn_addr_base = NULL;
 
+    if (page_size == 0) {
+        page_size = sysconf(_SC_PAGESIZE);
+    }
+
 #if defined __linux__
     plthook.plt_addr_base = (char*)lmap->l_addr;
+#if defined __riscv
+    const Elf_Ehdr *ehdr = (const Elf_Ehdr*)lmap->l_addr;
+    if (ehdr->e_type == ET_DYN) {
+        dyn_addr_base = (const char*)lmap->l_addr;
+    }
+#endif
+#if defined __ANDROID__ || defined __UCLIBC__
+    dyn_addr_base = (const char*)lmap->l_addr;
+#endif
 #elif defined __FreeBSD__ || defined __sun
+#if __FreeBSD__ >= 13
+    const Elf_Ehdr *ehdr = (const Elf_Ehdr*)lmap->l_base;
+#else
     const Elf_Ehdr *ehdr = (const Elf_Ehdr*)lmap->l_addr;
-    int rv = check_elf_header(ehdr);
-    if (rv != 0) {
-        return rv;
+#endif
+    int rv_ = check_elf_header(ehdr);
+    if (rv_ != 0) {
+        return rv_;
     }
     if (ehdr->e_type == ET_DYN) {
         dyn_addr_base = (const char*)lmap->l_addr;
@@ -496,64 +655,53 @@ static int plthook_open_real(plthook_t **plthook_out, struct link_map *lmap)
 
     /* get .rela.plt or .rel.plt section */
     dyn = find_dyn_by_tag(lmap->l_ld, DT_JMPREL);
-    plthook.r_type = R_JUMP_SLOT;
-#ifdef PLT_DT_REL
-    if (dyn == NULL) {
-        /* get .rela.dyn or .rel.dyn section */
-        dyn = find_dyn_by_tag(lmap->l_ld, PLT_DT_REL);
-        plthook.r_type = R_GLOBAL_DATA;
-    }
-#endif
-    if (dyn == NULL) {
-        set_errmsg("failed to find DT_JMPREL");
-        return PLTHOOK_INTERNAL_ERROR;
-    }
-    plthook.plt = (const Elf_Plt_Rel *)(dyn_addr_base + dyn->d_un.d_ptr);
-
-    if (plthook.r_type == R_JUMP_SLOT) {
-        /* get total size of .rela.plt or .rel.plt */
+    if (dyn != NULL) {
+        plthook.rela_plt = (const Elf_Plt_Rel *)(dyn_addr_base + dyn->d_un.d_ptr);
         dyn = find_dyn_by_tag(lmap->l_ld, DT_PLTRELSZ);
         if (dyn == NULL) {
             set_errmsg("failed to find DT_PLTRELSZ");
             return PLTHOOK_INTERNAL_ERROR;
         }
-
-        plthook.plt_cnt = dyn->d_un.d_val / sizeof(Elf_Plt_Rel);
-#ifdef PLT_DT_REL
-    } else {
-        int total_size_tag = PLT_DT_REL == DT_RELA ? DT_RELASZ : DT_RELSZ;
-        int elem_size_tag = PLT_DT_REL == DT_RELA ? DT_RELAENT : DT_RELENT;
+        plthook.rela_plt_cnt = dyn->d_un.d_val / sizeof(Elf_Plt_Rel);
+    }
+#ifdef R_GLOBAL_DATA
+    /* get .rela.dyn or .rel.dyn section */
+    dyn = find_dyn_by_tag(lmap->l_ld, PLT_DT_REL);
+    if (dyn != NULL) {
         size_t total_size, elem_size;
 
-        dyn = find_dyn_by_tag(lmap->l_ld, total_size_tag);
+        plthook.rela_dyn = (const Elf_Plt_Rel *)(dyn_addr_base + dyn->d_un.d_ptr);
+        dyn = find_dyn_by_tag(lmap->l_ld, PLT_DT_RELSZ);
         if (dyn == NULL) {
-            set_errmsg("failed to find 0x%x", total_size_tag);
+            set_errmsg("failed to find PLT_DT_RELSZ");
             return PLTHOOK_INTERNAL_ERROR;
         }
         total_size = dyn->d_un.d_ptr;
 
-        dyn = find_dyn_by_tag(lmap->l_ld, elem_size_tag);
+        dyn = find_dyn_by_tag(lmap->l_ld, PLT_DT_RELENT);
         if (dyn == NULL) {
-            set_errmsg("failed to find 0x%x", elem_size_tag);
+            set_errmsg("failed to find PLT_DT_RELENT");
             return PLTHOOK_INTERNAL_ERROR;
         }
         elem_size = dyn->d_un.d_ptr;
-        plthook.plt_cnt = total_size / elem_size;
-#endif
+        plthook.rela_dyn_cnt = total_size / elem_size;
     }
+#endif
 
-#ifdef SUPPORT_RELRO
-    dyn = find_dyn_by_tag(lmap->l_ld, DT_FLAGS_1);
-    if (dyn != NULL && (dyn->d_un.d_val & DF_1_NOW)) {
-        int rv = set_relro_members(&plthook, lmap);
-        if (rv != 0) {
-            return rv;
-        }
-        if (page_size == 0) {
-            page_size = sysconf(_SC_PAGESIZE);
-        }
+#ifdef R_GLOBAL_DATA
+    if (plthook.rela_plt == NULL && plthook.rela_dyn == NULL) {
+        set_errmsg("failed to find either of DT_JMPREL and DT_REL");
+        return PLTHOOK_INTERNAL_ERROR;
+    }
+#else
+    if (plthook.rela_plt == NULL) {
+        set_errmsg("failed to find DT_JMPREL");
+        return PLTHOOK_INTERNAL_ERROR;
     }
 #endif
+    if (plthook_set_mem_prot(&plthook)) {
+        return PLTHOOK_INTERNAL_ERROR;
+    }
 
     *plthook_out = malloc(sizeof(plthook_t));
     if (*plthook_out == NULL) {
@@ -564,6 +712,54 @@ static int plthook_open_real(plthook_t **plthook_out, struct link_map *lmap)
     return 0;
 }
 
+static int plthook_set_mem_prot(plthook_t *plthook)
+{
+    unsigned int pos = 0;
+    const char *name;
+    void **addr;
+    size_t start = (size_t)-1;
+    size_t end = 0;
+    mem_prot_iter_t iter;
+    mem_prot_t mem_prot;
+    int idx = 0;
+
+    while (plthook_enum(plthook, &pos, &name, &addr) == 0) {
+        if (start > (size_t)addr) {
+            start = (size_t)addr;
+        }
+        if (end < (size_t)addr) {
+            end = (size_t)addr;
+        }
+    }
+    end++;
+
+    if (mem_prot_begin(&iter) != 0) {
+        return PLTHOOK_INTERNAL_ERROR;
+    }
+    while (mem_prot_next(&iter, &mem_prot) == 0 && idx < NUM_MEM_PROT) {
+        if (mem_prot.prot != 0 && mem_prot.start < end && start < mem_prot.end) {
+            plthook->mem_prot[idx++] = mem_prot;
+        }
+    }
+    mem_prot_end(&iter);
+    return 0;
+}
+
+static int plthook_get_mem_prot(plthook_t *plthook, void *addr)
+{
+    mem_prot_t *ptr = plthook->mem_prot;
+    mem_prot_t *end = ptr + NUM_MEM_PROT;
+
+    while (ptr < end && ptr->prot != 0) {
+        if (ptr->start <= (size_t)addr && (size_t)addr < ptr->end) {
+            return ptr->prot;
+        }
+        ++ptr;
+    }
+    return 0;
+}
+
+#if defined __FreeBSD__ || defined __sun
 static int check_elf_header(const Elf_Ehdr *ehdr)
 {
     static const unsigned short s = 1;
@@ -610,26 +806,55 @@ static int check_elf_header(const Elf_Ehdr *ehdr)
     }
     return 0;
 }
+#endif
+
+static int check_rel(const plthook_t *plthook, const Elf_Plt_Rel *plt, Elf_Xword r_type, const char **name_out, void ***addr_out)
+{
+    if (ELF_R_TYPE(plt->r_info) == r_type) {
+        size_t idx = ELF_R_SYM(plt->r_info);
+        idx = plthook->dynsym[idx].st_name;
+        if (idx + 1 > plthook->dynstr_size) {
+            set_errmsg("too big section header string table index: %" SIZE_T_FMT, idx);
+            return PLTHOOK_INVALID_FILE_FORMAT;
+        }
+        *name_out = plthook->dynstr + idx;
+        *addr_out = (void**)(plthook->plt_addr_base + plt->r_offset);
+        return 0;
+    }
+    return -1;
+}
 
 int plthook_enum(plthook_t *plthook, unsigned int *pos, const char **name_out, void ***addr_out)
 {
-    while (*pos < plthook->plt_cnt) {
-        const Elf_Plt_Rel *plt = plthook->plt + *pos;
-        if (ELF_R_TYPE(plt->r_info) == plthook->r_type) {
-            size_t idx = ELF_R_SYM(plt->r_info);
-
-            idx = plthook->dynsym[idx].st_name;
-            if (idx + 1 > plthook->dynstr_size) {
-                set_errmsg("too big section header string table index: %" SIZE_T_FMT, idx);
-                return PLTHOOK_INVALID_FILE_FORMAT;
+    return plthook_enum_with_prot(plthook, pos, name_out, addr_out, NULL);
+}
+
+int plthook_enum_with_prot(plthook_t *plthook, unsigned int *pos, const char **name_out, void ***addr_out, int *prot)
+{
+    while (*pos < plthook->rela_plt_cnt) {
+        const Elf_Plt_Rel *plt = plthook->rela_plt + *pos;
+        int rv = check_rel(plthook, plt, R_JUMP_SLOT, name_out, addr_out);
+        (*pos)++;
+        if (rv >= 0) {
+            if (rv == 0 && prot != NULL) {
+                *prot = plthook_get_mem_prot(plthook, *addr_out);
             }
-            *name_out = plthook->dynstr + idx;
-            *addr_out = (void**)(plthook->plt_addr_base + plt->r_offset);
-            (*pos)++;
-            return 0;
+            return rv;
         }
+    }
+#ifdef R_GLOBAL_DATA
+    while (*pos < plthook->rela_plt_cnt + plthook->rela_dyn_cnt) {
+        const Elf_Plt_Rel *plt = plthook->rela_dyn + (*pos - plthook->rela_plt_cnt);
+        int rv = check_rel(plthook, plt, R_GLOBAL_DATA, name_out, addr_out);
         (*pos)++;
+        if (rv >= 0) {
+            if (rv == 0 && prot != NULL) {
+                *prot = plthook_get_mem_prot(plthook, *addr_out);
+            }
+            return rv;
+        }
     }
+#endif
     *name_out = NULL;
     *addr_out = NULL;
     return EOF;
@@ -650,26 +875,26 @@ int plthook_replace(plthook_t *plthook, const char *funcname, void *funcaddr, vo
     while ((rv = plthook_enum(plthook, &pos, &name, &addr)) == 0) {
         if (strncmp(name, funcname, funcnamelen) == 0) {
             if (name[funcnamelen] == '\0' || name[funcnamelen] == '@') {
-#ifdef SUPPORT_RELRO
-                void *maddr = NULL;
-                if (plthook->relro_start <= (char*)addr && (char*)addr < plthook->relro_end) {
-                    maddr = (void*)((size_t)addr & ~(page_size - 1));
-                    if (mprotect(maddr, page_size, PROT_READ | PROT_WRITE) != 0) {
-                        set_errmsg("Could not change the process memory protection at %p: %s",
-                                   maddr, strerror(errno));
+                int prot = plthook_get_mem_prot(plthook, addr);
+                if (prot == 0) {
+                    set_errmsg("Could not get the process memory permission at %p",
+                             ALIGN_ADDR(addr));
+                    return PLTHOOK_INTERNAL_ERROR;
+                }
+                if (!(prot & PROT_WRITE)) {
+                    if (mprotect(ALIGN_ADDR(addr), page_size, PROT_READ | PROT_WRITE) != 0) {
+                        set_errmsg("Could not change the process memory permission at %p: %s",
+                                   ALIGN_ADDR(addr), strerror(errno));
                         return PLTHOOK_INTERNAL_ERROR;
                     }
                 }
-#endif
                 if (oldfunc) {
                     *oldfunc = *addr;
                 }
                 *addr = funcaddr;
-#ifdef SUPPORT_RELRO
-                if (maddr != NULL) {
-                    mprotect(maddr, page_size, PROT_READ);
+                if (!(prot & PROT_WRITE)) {
+                    mprotect(ALIGN_ADDR(addr), page_size, prot);
                 }
-#endif
                 return 0;
             }
         }