src/livedumper/helpers.hpp

   1 /*
   2  * Copyright (c) 2019 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #ifndef HELPERS_HPP__
  19 #define HELPERS_HPP__
  20
  21 #include <elf.h>
  22 #include <sys/stat.h>
  23 #include <sys/types.h>
  24 #include <asm/ptrace.h>
  25
  26 #include <functional>
  27 #include <string>
  28 #include <unistd.h>
  29
  30 #include "shared/telf.h"
  31
  32 #pragma pack(push, 1)
  33
  34 struct Notefile32 {
  35         uint32_t start;
  36         uint32_t end;
  37         uint32_t file_ofs;
  38 };
  39
  40 struct Notefile64 {
  41         uint64_t start;
  42         uint64_t end;
  43         uint64_t file_ofs;
  44 };
  45
  46 struct ProgramTableHeader32 {
  47         uint32_t p_type;
  48         Elf32_Off p_offset;
  49         Elf32_Addr p_vaddr;
  50         Elf32_Addr p_paddr;
  51         uint32_t p_filesz;
  52         uint32_t p_memsz;
  53         uint32_t p_flags;
  54         uint32_t p_align;
  55 };
  56
  57 struct ProgramTableHeader64 {
  58         uint32_t p_type;
  59         uint32_t p_flags;
  60         Elf64_Off p_offset;
  61         Elf64_Addr p_vaddr;
  62         Elf64_Addr p_paddr;
  63         uint64_t p_filesz;
  64         uint64_t p_memsz;
  65         uint64_t p_align;
  66 };
  67
  68 struct SymData {
  69         unsigned long start;
  70         Elf *elf;
  71         Elf64_Shdr shdr;
  72         void *data;
  73         int fd;
  74         int count;
  75         struct SymData *next;
  76 };
  77
  78 #pragma pack(pop)
  79
  80 struct Elf32 {
  81         typedef Elf32_Ehdr Ehdr;
  82         typedef Elf32_Phdr Phdr;
  83         typedef Elf32_Addr Addr;
  84         typedef Elf32_Shdr Shdr;
  85         typedef Elf32_Off Off;
  86         typedef Elf32_Section Section;
  87         typedef Elf32_Versym Versym;
  88         typedef Elf32_Half Half;
  89         typedef Elf32_Sword Sword;
  90         typedef Elf32_Word Word;
  91         typedef Elf32_Sxword Sxword;
  92         typedef Elf32_Xword Xword;
  93         typedef ProgramTableHeader32 ProgramTableHeader;
  94         typedef Notefile32 Notefile;
  95         typedef Elf32_auxv_t auxv_t;
  96         typedef Elf32_Dyn Dyn;
  97         typedef uint32_t uint;
  98         static const char ELFCLASS = ELFCLASS32;
  99 };
 100
 101 struct Elf64 {
 102         typedef Elf64_Ehdr Ehdr;
 103         typedef Elf64_Phdr Phdr;
 104         typedef Elf64_Addr Addr;
 105         typedef Elf64_Shdr Shdr;
 106         typedef Elf64_Off Off;
 107         typedef Elf64_Section Section;
 108         typedef Elf64_Versym Versym;
 109         typedef Elf64_Half Half;
 110         typedef Elf64_Sword Sword;
 111         typedef Elf64_Word Word;
 112         typedef Elf64_Sxword Sxword;
 113         typedef Elf64_Xword Xword;
 114         typedef ProgramTableHeader64 ProgramTableHeader;
 115         typedef Notefile64 Notefile;
 116         typedef Elf64_auxv_t auxv_t;
 117         typedef Elf64_Dyn Dyn;
 118         typedef uint64_t uint;
 119         static const char ELFCLASS = ELFCLASS64;
 120 };
 121
 122 class Guardian {
 123  private:
 124         const std::function<void()> m_start;
 125         const std::function<void()> m_end;
 126  public:
 127         Guardian(const std::function<void()> &start, const std::function<void()> &end)
 128                                                                 : m_start(start), m_end(end) { m_start(); }
 129         ~Guardian() { m_end(); }
 130 };
 131
 132 bool fileExists(const std::string &path) {
 133         struct stat buf;
 134         return stat(path.c_str(), &buf) == 0;
 135 }
 136
 137 #endif  // HELPERS_HPP__