1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 // ELF shared object file updates handler.
6 //
7 // Provides functions to pack relocations in the .rel.dyn or .rela.dyn
8 // sections, and unpack to return the file to its pre-packed state.
9 //
10 // SetPadding() causes PackRelocations() to pad .rel.dyn or .rela.dyn with
11 // NONE-type entries rather than cutting a hole out of the shared object
12 // file.  This keeps all load addresses and offsets constant, and enables
13 // easier debugging and testing.
14 //
15 // A packed shared object file is shorter than its non-packed original.
16 // Unpacking a packed file restores the file to its non-packed state.
17 
18 #ifndef TOOLS_RELOCATION_PACKER_SRC_ELF_FILE_H_
19 #define TOOLS_RELOCATION_PACKER_SRC_ELF_FILE_H_
20 
21 #include <string.h>
22 #include <vector>
23 
24 #include "elf.h"
25 #include "libelf.h"
26 #include "packer.h"
27 
28 namespace relocation_packer {
29 
30 // An ElfFile reads shared objects, and shuttles relative relocations
31 // between .rel.dyn or .rela.dyn and .android.rel.dyn or .android.rela.dyn
32 // sections.
33 template <typename ELF>
34 class ElfFile {
35  public:
ElfFile(int fd)36   explicit ElfFile(int fd)
37       : fd_(fd), is_padding_relocations_(false), elf_(NULL),
38         relocations_section_(NULL), dynamic_section_(NULL),
39         relocations_type_(NONE), has_android_relocations_(false) {}
~ElfFile()40   ~ElfFile() {}
41 
42   // Set padding mode.  When padding, PackRelocations() will not shrink
43   // the .rel.dyn or .rela.dyn section, but instead replace relative with
44   // NONE-type entries.
45   // |flag| is true to pad .rel.dyn or .rela.dyn, false to shrink it.
SetPadding(bool flag)46   inline void SetPadding(bool flag) { is_padding_relocations_ = flag; }
47 
48   // Transfer relative relocations from .rel.dyn or .rela.dyn to a packed
49   // representation in .android.rel.dyn or .android.rela.dyn.  Returns true
50   // on success.
51   bool PackRelocations();
52 
53   // Transfer relative relocations from a packed representation in
54   // .android.rel.dyn or .android.rela.dyn to .rel.dyn or .rela.dyn.  Returns
55   // true on success.
56   bool UnpackRelocations();
57 
58  private:
59   enum relocations_type_t {
60     NONE = 0, REL, RELA
61   };
62 
63   // Load a new ElfFile from a filedescriptor.  If flushing, the file must
64   // be open for read/write.  Returns true on successful ELF file load.
65   // |fd| is an open file descriptor for the shared object.
66   bool Load();
67 
68   // Templated packer, helper for PackRelocations().  Rel type is one of
69   // ELF::Rel or ELF::Rela.
70   bool PackTypedRelocations(std::vector<typename ELF::Rela>* relocations);
71 
72   // Templated unpacker, helper for UnpackRelocations().  Rel type is one of
73   // ELF::Rel or ELF::Rela.
74   bool UnpackTypedRelocations(const std::vector<uint8_t>& packed);
75 
76   // Write ELF file changes.
77   void Flush();
78 
79   void AdjustRelativeRelocationTargets(typename ELF::Off hole_start,
80                                        ssize_t hole_size,
81                                        std::vector<typename ELF::Rela>* relocations);
82 
83   static void ResizeSection(Elf* elf, Elf_Scn* section, size_t new_size,
84                             typename ELF::Word new_sh_type, relocations_type_t relocations_type);
85 
86   static void AdjustDynamicSectionForHole(Elf_Scn* dynamic_section,
87                                           typename ELF::Off hole_start,
88                                           ssize_t hole_size,
89                                           relocations_type_t relocations_type);
90 
91   static void ConvertRelArrayToRelaVector(const typename ELF::Rel* rel_array, size_t rel_array_size,
92                                           std::vector<typename ELF::Rela>* rela_vector);
93 
94   static void ConvertRelaVectorToRelVector(const std::vector<typename ELF::Rela>& rela_vector,
95                                            std::vector<typename ELF::Rel>* rel_vector);
96 
97 
98   // File descriptor opened on the shared object.
99   int fd_;
100 
101   // If set, pad rather than shrink .rel.dyn or .rela.dyn.  Primarily for
102   // debugging, allows packing to be checked without affecting load addresses.
103   bool is_padding_relocations_;
104 
105   // Libelf handle, assigned by Load().
106   Elf* elf_;
107 
108   // Sections that we manipulate, assigned by Load().
109   Elf_Scn* relocations_section_;
110   Elf_Scn* dynamic_section_;
111 
112   // Relocation type found, assigned by Load().
113   relocations_type_t relocations_type_;
114 
115   // Elf-file has android relocations section
116   bool has_android_relocations_;
117 };
118 
119 }  // namespace relocation_packer
120 
121 #endif  // TOOLS_RELOCATION_PACKER_SRC_ELF_FILE_H_
122