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 : 2038 : free_chunk (void *n) 45 : : { 46 : 2038 : Elf_Data_Chunk *rawchunk = (Elf_Data_Chunk *)n; 47 [ + + ]: 2038 : if (rawchunk->dummy_scn.flags & ELF_F_MALLOCED) 48 : 1144 : free (rawchunk->data.d.d_buf); 49 : 2038 : free (rawchunk); 50 : 2038 : } 51 : : 52 : : int 53 : 34514 : elf_end (Elf *elf) 54 : : { 55 : 34520 : Elf *parent; 56 : : 57 [ + + ]: 34520 : if (elf == NULL) 58 : : /* This is allowed and is a no-op. */ 59 : : return 0; 60 : : 61 : : /* Make sure we are alone. */ 62 : 33816 : rwlock_wrlock (elf->lock); 63 : : 64 [ + + + - ]: 33816 : 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 [ + + ]: 33816 : 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 [ + - ]: 320 : if (elf->state.ar.ar_sym != (Elf_Arsym *) -1l) 81 : 320 : free (elf->state.ar.ar_sym); 82 : 320 : elf->state.ar.ar_sym = NULL; 83 : : 84 [ + + ]: 320 : if (elf->state.ar.children != NULL) 85 : : return 0; 86 : : } 87 : : 88 : : /* Remove this structure from the children list. */ 89 : 33810 : parent = elf->parent; 90 [ + + ]: 33810 : if (parent != NULL) 91 : : { 92 : : /* This is tricky. Lock must be acquire from the father to 93 : : the child but here we already have the child lock. We 94 : : solve this problem by giving free the child lock. The 95 : : state of REF_COUNT==0 is handled all over the library, so 96 : : this should be ok. */ 97 : 14528 : rwlock_unlock (elf->lock); 98 : 14528 : rwlock_rdlock (parent->lock); 99 : 14528 : rwlock_wrlock (elf->lock); 100 : : 101 [ + + ]: 14528 : if (parent->state.ar.children == elf) 102 : 14524 : parent->state.ar.children = elf->next; 103 : : else 104 : : { 105 : : struct Elf *child = parent->state.ar.children; 106 : : 107 [ + + ]: 6 : while (child->next != elf) 108 : : child = child->next; 109 : : 110 : 4 : child->next = elf->next; 111 : : } 112 : : 113 : 33810 : rwlock_unlock (parent->lock); 114 : : } 115 : : 116 : : /* This was the last activation. Free all resources. */ 117 [ + + + ]: 33810 : switch (elf->kind) 118 : : { 119 : 314 : case ELF_K_AR: 120 [ + + ]: 314 : if (elf->state.ar.long_names != NULL) 121 : 204 : free (elf->state.ar.long_names); 122 : : break; 123 : : 124 : 32326 : case ELF_K_ELF: 125 : : { 126 : 32326 : void *rawchunks 127 : : = (elf->class == ELFCLASS32 128 : : || (offsetof (struct Elf, state.elf32.rawchunks) 129 : : == offsetof (struct Elf, state.elf64.rawchunks)) 130 : : ? elf->state.elf32.rawchunks 131 : : : elf->state.elf64.rawchunks); 132 : 32326 : tdestroy (rawchunks, free_chunk); 133 : : 134 : 32326 : Elf_ScnList *list = (elf->class == ELFCLASS32 135 : : || (offsetof (struct Elf, state.elf32.scns) 136 : : == offsetof (struct Elf, state.elf64.scns)) 137 : : ? &elf->state.elf32.scns 138 : : : &elf->state.elf64.scns); 139 : : 140 : 34296 : do 141 : : { 142 : : /* Free all separately allocated section headers. */ 143 : 34296 : size_t cnt = list->max; 144 : : 145 [ + + ]: 13147128 : while (cnt-- > 0) 146 : : { 147 : : /* These pointers can be NULL; it's safe to use 148 : : 'free' since it will check for this. */ 149 : 13112832 : Elf_Scn *scn = &list->data[cnt]; 150 : 13112832 : Elf_Data_List *runp; 151 : : 152 [ + + ]: 13112832 : if ((scn->shdr_flags & ELF_F_MALLOCED) != 0) 153 : : /* It doesn't matter which pointer. */ 154 : 3305834 : free (scn->shdr.e32); 155 : : 156 : : /* Free zdata if uncompressed, but not yet used as 157 : : rawdata_base. If it is already used it will be 158 : : freed below. */ 159 [ + + ]: 13112832 : if (scn->zdata_base != scn->rawdata_base) 160 : : { 161 : 3714602 : free (scn->zdata_base); 162 : 3714602 : scn->zdata_base = NULL; 163 : : } 164 : : 165 : : /* If the file has the same byte order and the 166 : : architecture doesn't require overly stringent 167 : : alignment the raw data buffer is the same as the 168 : : one used for presenting to the caller. */ 169 [ + + ]: 13112832 : if (scn->data_base != scn->rawdata_base) 170 : 538936 : free (scn->data_base); 171 : : 172 : : /* The section data is allocated if we couldn't mmap 173 : : the file. Or if we had to decompress. */ 174 [ + + ]: 13112832 : if (elf->map_address == NULL 175 [ + + ]: 8031354 : || scn->rawdata_base == scn->zdata_base 176 [ - + ]: 2250538 : || (scn->flags & ELF_F_MALLOCED) != 0) 177 : 10862294 : free (scn->rawdata_base); 178 : : 179 : : /* Free the list of data buffers for the section. 180 : : We don't free the buffers themselves since this 181 : : is the users job. */ 182 : 13112832 : runp = scn->data_list.next; 183 [ + + ]: 13113020 : while (runp != NULL) 184 : : { 185 : 188 : Elf_Data_List *oldp = runp; 186 : 188 : runp = runp->next; 187 [ + - ]: 188 : if ((oldp->flags & ELF_F_MALLOCED) != 0) 188 : 188 : free (oldp); 189 : : } 190 : : } 191 : : 192 : : /* Free the memory for the array. */ 193 : 34296 : Elf_ScnList *oldp = list; 194 : 34296 : list = list->next; 195 [ + + - + ]: 34296 : assert (list == NULL || oldp->cnt == oldp->max); 196 [ + + ]: 34296 : if (oldp != (elf->class == ELFCLASS32 197 : : || (offsetof (struct Elf, state.elf32.scns) 198 : : == offsetof (struct Elf, state.elf64.scns)) 199 : : ? &elf->state.elf32.scns 200 : : : &elf->state.elf64.scns)) 201 : 1970 : free (oldp); 202 : : } 203 [ + + ]: 34296 : while (list != NULL); 204 : : } 205 : : 206 : : /* Free the section header. */ 207 [ + + ]: 32326 : if (elf->state.elf.shdr_malloced != 0) 208 : 4702 : free (elf->class == ELFCLASS32 209 : : || (offsetof (struct Elf, state.elf32.shdr) 210 : : == offsetof (struct Elf, state.elf64.shdr)) 211 : 4702 : ? (void *) elf->state.elf32.shdr 212 : : : (void *) elf->state.elf64.shdr); 213 : : 214 : : /* Free the program header. */ 215 [ + + ]: 32326 : if ((elf->state.elf.phdr_flags & ELF_F_MALLOCED) != 0) 216 : 2942 : free (elf->class == ELFCLASS32 217 : : || (offsetof (struct Elf, state.elf32.phdr) 218 : : == offsetof (struct Elf, state.elf64.phdr)) 219 : 2942 : ? (void *) elf->state.elf32.phdr 220 : : : (void *) elf->state.elf64.phdr); 221 : : break; 222 : : 223 : : default: 224 : : break; 225 : : } 226 : : 227 [ + + + + ]: 33810 : if (elf->map_address != NULL && parent == NULL) 228 : : { 229 : : /* The file was read or mapped for this descriptor. */ 230 [ + + ]: 15716 : if ((elf->flags & ELF_F_MALLOCED) != 0) 231 : 128 : free (elf->map_address); 232 [ + + ]: 15588 : else if ((elf->flags & ELF_F_MMAPPED) != 0) 233 : 15516 : munmap (elf->map_address, elf->maximum_size); 234 : : } 235 : : 236 : 33810 : rwlock_unlock (elf->lock); 237 : 33810 : rwlock_fini (elf->lock); 238 : : 239 : : /* Finally the descriptor itself. */ 240 : 33810 : free (elf); 241 : : 242 [ + + ]: 14528 : return (parent != NULL && parent->ref_count == 0 243 [ + + ]: 33810 : ? INTUSE(elf_end) (parent) : 0); 244 : : } 245 : : INTDEF(elf_end)