Branch data Line data Source code
1 : : /* Free resources associated with Elf descriptor. 2 : : Copyright (C) 1998,1999,2000,2001,2002,2004,2005,2007,2015,2016 Red Hat, Inc. 3 : : Copyright (C) 2023 Mark J. Wielaard <mark@klomp.org> 4 : : This file is part of elfutils. 5 : : Written by Ulrich Drepper <drepper@redhat.com>, 1998. 6 : : 7 : : This file is free software; you can redistribute it and/or modify 8 : : it under the terms of either 9 : : 10 : : * the GNU Lesser General Public License as published by the Free 11 : : Software Foundation; either version 3 of the License, or (at 12 : : your option) any later version 13 : : 14 : : or 15 : : 16 : : * the GNU General Public License as published by the Free 17 : : Software Foundation; either version 2 of the License, or (at 18 : : your option) any later version 19 : : 20 : : or both in parallel, as here. 21 : : 22 : : elfutils is distributed in the hope that it will be useful, but 23 : : WITHOUT ANY WARRANTY; without even the implied warranty of 24 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 25 : : General Public License for more details. 26 : : 27 : : You should have received copies of the GNU General Public License and 28 : : the GNU Lesser General Public License along with this program. If 29 : : not, see <http://www.gnu.org/licenses/>. */ 30 : : 31 : : #ifdef HAVE_CONFIG_H 32 : : # include <config.h> 33 : : #endif 34 : : 35 : : #include <assert.h> 36 : : #include <search.h> 37 : : #include <stddef.h> 38 : : #include <stdlib.h> 39 : : 40 : : #include "libelfP.h" 41 : : 42 : : 43 : : static void 44 : 2130 : free_chunk (void *n) 45 : : { 46 : 2130 : Elf_Data_Chunk *rawchunk = (Elf_Data_Chunk *)n; 47 [ + + ]: 2130 : if (rawchunk->dummy_scn.flags & ELF_F_MALLOCED) 48 : 1144 : free (rawchunk->data.d.d_buf); 49 : 2130 : free (rawchunk); 50 : 2130 : } 51 : : 52 : : int 53 : 35330 : elf_end (Elf *elf) 54 : : { 55 : 35338 : Elf *parent; 56 : : 57 [ + + ]: 35338 : if (elf == NULL) 58 : : /* This is allowed and is a no-op. */ 59 : : return 0; 60 : : 61 : : /* Make sure we are alone. */ 62 : 34582 : rwlock_wrlock (elf->lock); 63 : : 64 [ + + + - ]: 34582 : if (elf->ref_count != 0 && --elf->ref_count != 0) 65 : : { 66 : : /* Not yet the last activation. */ 67 : : int result = elf->ref_count; 68 : : rwlock_unlock (elf->lock); 69 : : return result; 70 : : } 71 : : 72 [ + + ]: 34582 : if (elf->kind == ELF_K_AR) 73 : : { 74 : : /* We cannot remove the descriptor now since we still have some 75 : : descriptors which depend on it. But we can free the archive 76 : : symbol table since this is only available via the archive ELF 77 : : descriptor. The long name table cannot be freed yet since 78 : : the archive headers for the ELF files in the archive point 79 : : into this array. */ 80 [ + - ]: 324 : if (elf->state.ar.ar_sym != (Elf_Arsym *) -1l) 81 : 324 : free (elf->state.ar.ar_sym); 82 : 324 : elf->state.ar.ar_sym = NULL; 83 : : 84 [ + + ]: 324 : if (elf->state.ar.children != NULL) 85 : : { 86 : : rwlock_unlock(elf->lock); 87 : : return 0; 88 : : } 89 : : } 90 : : 91 : : /* Remove this structure from the children list. */ 92 : 34574 : parent = elf->parent; 93 [ + + ]: 34574 : if (parent != NULL) 94 : : { 95 : : /* This is tricky. Lock must be acquire from the father to 96 : : the child but here we already have the child lock. We 97 : : solve this problem by giving free the child lock. The 98 : : state of REF_COUNT==0 is handled all over the library, so 99 : : this should be ok. */ 100 : 14546 : rwlock_unlock (elf->lock); 101 : 14546 : rwlock_rdlock (parent->lock); 102 : 14546 : rwlock_wrlock (elf->lock); 103 : : 104 [ + + ]: 14546 : if (parent->state.ar.children == elf) 105 : 14538 : parent->state.ar.children = elf->next; 106 : : else 107 : : { 108 : : struct Elf *child = parent->state.ar.children; 109 : : 110 [ + + ]: 10 : while (child->next != elf) 111 : : child = child->next; 112 : : 113 : 8 : child->next = elf->next; 114 : : } 115 : : 116 : 34574 : rwlock_unlock (parent->lock); 117 : : } 118 : : 119 : : /* This was the last activation. Free all resources. */ 120 [ + + + ]: 34574 : switch (elf->kind) 121 : : { 122 : 316 : case ELF_K_AR: 123 [ + + ]: 316 : if (elf->state.ar.long_names != NULL) 124 : 204 : free (elf->state.ar.long_names); 125 : : break; 126 : : 127 : 32998 : case ELF_K_ELF: 128 : : { 129 : 32998 : search_tree *rawchunk_tree 130 : : = (elf->class == ELFCLASS32 131 : : || (offsetof (struct Elf, state.elf32.rawchunk_tree) 132 : : == offsetof (struct Elf, state.elf64.rawchunk_tree)) 133 : : ? &elf->state.elf32.rawchunk_tree 134 : : : &elf->state.elf64.rawchunk_tree); 135 : : 136 : 32998 : eu_search_tree_fini (rawchunk_tree, free_chunk); 137 : : 138 : 32998 : Elf_ScnList *list = (elf->class == ELFCLASS32 139 : : || (offsetof (struct Elf, state.elf32.scns) 140 : : == offsetof (struct Elf, state.elf64.scns)) 141 : : ? &elf->state.elf32.scns 142 : : : &elf->state.elf64.scns); 143 : : 144 : 34964 : do 145 : : { 146 : : /* Free all separately allocated section headers. */ 147 : 34964 : size_t cnt = list->max; 148 : : 149 [ + + ]: 13165612 : while (cnt-- > 0) 150 : : { 151 : : /* These pointers can be NULL; it's safe to use 152 : : 'free' since it will check for this. */ 153 : 13130648 : Elf_Scn *scn = &list->data[cnt]; 154 : 13130648 : Elf_Data_List *runp; 155 : : 156 [ + + ]: 13130648 : if ((scn->shdr_flags & ELF_F_MALLOCED) != 0) 157 : : /* It doesn't matter which pointer. */ 158 : 3305890 : free (scn->shdr.e32); 159 : : 160 : : /* Free zdata if uncompressed, but not yet used as 161 : : rawdata_base. If it is already used it will be 162 : : freed below. */ 163 [ + + ]: 13130648 : if (scn->zdata_base != scn->rawdata_base) 164 : : { 165 : 3725958 : free (scn->zdata_base); 166 : 3725958 : scn->zdata_base = NULL; 167 : : } 168 : : 169 : : /* If the file has the same byte order and the 170 : : architecture doesn't require overly stringent 171 : : alignment the raw data buffer is the same as the 172 : : one used for presenting to the caller. */ 173 [ + + ]: 13130648 : if (scn->data_base != scn->rawdata_base) 174 : 540514 : free (scn->data_base); 175 : : 176 : : /* The section data is allocated if we couldn't mmap 177 : : the file. Or if we had to decompress. */ 178 [ + + ]: 13130648 : if (elf->map_address == NULL 179 [ + + ]: 8048372 : || scn->rawdata_base == scn->zdata_base 180 [ - + ]: 2261868 : || (scn->flags & ELF_F_MALLOCED) != 0) 181 : 10868780 : free (scn->rawdata_base); 182 : : 183 : : /* Free the list of data buffers for the section. 184 : : We don't free the buffers themselves since this 185 : : is the users job. */ 186 : 13130648 : runp = scn->data_list.next; 187 [ + + ]: 13130836 : while (runp != NULL) 188 : : { 189 : 188 : Elf_Data_List *oldp = runp; 190 : 188 : runp = runp->next; 191 [ + - ]: 188 : if ((oldp->flags & ELF_F_MALLOCED) != 0) 192 : 188 : free (oldp); 193 : : } 194 : : } 195 : : 196 : : /* Free the memory for the array. */ 197 : 34964 : Elf_ScnList *oldp = list; 198 : 34964 : list = list->next; 199 [ + + - + ]: 34964 : assert (list == NULL || oldp->cnt == oldp->max); 200 [ + + ]: 34964 : if (oldp != (elf->class == ELFCLASS32 201 : : || (offsetof (struct Elf, state.elf32.scns) 202 : : == offsetof (struct Elf, state.elf64.scns)) 203 : : ? &elf->state.elf32.scns 204 : : : &elf->state.elf64.scns)) 205 : 1966 : free (oldp); 206 : : } 207 [ + + ]: 34964 : while (list != NULL); 208 : : } 209 : : 210 : : /* Free the section header. */ 211 [ + + ]: 32998 : if (elf->state.elf.shdr_malloced != 0) 212 : 5068 : free (elf->class == ELFCLASS32 213 : : || (offsetof (struct Elf, state.elf32.shdr) 214 : : == offsetof (struct Elf, state.elf64.shdr)) 215 : 5068 : ? (void *) elf->state.elf32.shdr 216 : : : (void *) elf->state.elf64.shdr); 217 : : 218 : : /* Free the program header. */ 219 [ + + ]: 32998 : if ((elf->state.elf.phdr_flags & ELF_F_MALLOCED) != 0) 220 : 2922 : free (elf->class == ELFCLASS32 221 : : || (offsetof (struct Elf, state.elf32.phdr) 222 : : == offsetof (struct Elf, state.elf64.phdr)) 223 : 2922 : ? (void *) elf->state.elf32.phdr 224 : : : (void *) elf->state.elf64.phdr); 225 : : break; 226 : : 227 : : default: 228 : : break; 229 : : } 230 : : 231 [ + + + + ]: 34574 : if (elf->map_address != NULL && parent == NULL) 232 : : { 233 : : /* The file was read or mapped for this descriptor. */ 234 [ + + ]: 16450 : if ((elf->flags & ELF_F_MALLOCED) != 0) 235 : 118 : free (elf->map_address); 236 [ + + ]: 16332 : else if ((elf->flags & ELF_F_MMAPPED) != 0) 237 : 16232 : munmap (elf->map_address, elf->maximum_size); 238 : : } 239 : : 240 : 34574 : rwlock_unlock (elf->lock); 241 : 34574 : rwlock_fini (elf->lock); 242 : : 243 : : /* Finally the descriptor itself. */ 244 : 34574 : free (elf); 245 : : 246 [ + + ]: 14546 : return (parent != NULL && parent->ref_count == 0 247 [ + + ]: 34574 : ? INTUSE(elf_end) (parent) : 0); 248 : : } 249 : : INTDEF(elf_end)