Home | History | Annotate | Download | only in libelf
      1 /* Common definitions for handling files in memory or only on disk.
      2    Copyright (C) 1998, 1999, 2000, 2002, 2005, 2008 Red Hat, Inc.
      3    This file is part of elfutils.
      4    Written by Ulrich Drepper <drepper (at) redhat.com>, 1998.
      5 
      6    This file is free software; you can redistribute it and/or modify
      7    it under the terms of either
      8 
      9      * the GNU Lesser General Public License as published by the Free
     10        Software Foundation; either version 3 of the License, or (at
     11        your option) any later version
     12 
     13    or
     14 
     15      * the GNU General Public License as published by the Free
     16        Software Foundation; either version 2 of the License, or (at
     17        your option) any later version
     18 
     19    or both in parallel, as here.
     20 
     21    elfutils is distributed in the hope that it will be useful, but
     22    WITHOUT ANY WARRANTY; without even the implied warranty of
     23    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     24    General Public License for more details.
     25 
     26    You should have received copies of the GNU General Public License and
     27    the GNU Lesser General Public License along with this program.  If
     28    not, see <http://www.gnu.org/licenses/>.  */
     29 
     30 #ifndef _COMMON_H
     31 #define _COMMON_H       1
     32 
     33 #include <ar.h>
     34 #include <byteswap.h>
     35 #include <endian.h>
     36 #include <stdlib.h>
     37 #include <string.h>
     38 
     39 #include "libelfP.h"
     40 
     41 static inline Elf_Kind
     42 __attribute__ ((unused))
     43 determine_kind (void *buf, size_t len)
     44 {
     45   /* First test for an archive.  */
     46   if (len >= SARMAG && memcmp (buf, ARMAG, SARMAG) == 0)
     47     return ELF_K_AR;
     48 
     49   /* Next try ELF files.  */
     50   if (len >= EI_NIDENT && memcmp (buf, ELFMAG, SELFMAG) == 0)
     51     {
     52       /* Could be an ELF file.  */
     53       int eclass = (int) ((unsigned char *) buf)[EI_CLASS];
     54       int data = (int) ((unsigned char *) buf)[EI_DATA];
     55       int version = (int) ((unsigned char *) buf)[EI_VERSION];
     56 
     57       if (eclass > ELFCLASSNONE && eclass < ELFCLASSNUM
     58 	  && data > ELFDATANONE && data < ELFDATANUM
     59 	  && version > EV_NONE && version < EV_NUM)
     60 	return ELF_K_ELF;
     61     }
     62 
     63   /* We do not know this file type.  */
     64   return ELF_K_NONE;
     65 }
     66 
     67 
     68 /* Allocate an Elf descriptor and fill in the generic information.  */
     69 static inline Elf *
     70 __attribute__ ((unused))
     71 allocate_elf (int fildes, void *map_address, off_t offset, size_t maxsize,
     72               Elf_Cmd cmd, Elf *parent, Elf_Kind kind, size_t extra)
     73 {
     74   Elf *result = (Elf *) calloc (1, sizeof (Elf) + extra);
     75   if (result == NULL)
     76     __libelf_seterrno (ELF_E_NOMEM);
     77   else
     78     {
     79       result->kind = kind;
     80       result->ref_count = 1;
     81       result->cmd = cmd;
     82       result->fildes = fildes;
     83       result->start_offset = offset;
     84       result->maximum_size = maxsize;
     85       result->map_address = map_address;
     86       result->parent = parent;
     87 
     88       rwlock_init (result->lock);
     89     }
     90 
     91   return result;
     92 }
     93 
     94 
     95 /* Acquire lock for the descriptor and all children.  */
     96 static void
     97 __attribute__ ((unused))
     98 libelf_acquire_all (Elf *elf)
     99 {
    100   rwlock_wrlock (elf->lock);
    101 
    102   if (elf->kind == ELF_K_AR)
    103     {
    104       Elf *child = elf->state.ar.children;
    105 
    106       while (child != NULL)
    107 	{
    108 	  if (child->ref_count != 0)
    109 	    libelf_acquire_all (child);
    110 	  child = child->next;
    111 	}
    112     }
    113 }
    114 
    115 /* Release own lock and those of the children.  */
    116 static void
    117 __attribute__ ((unused))
    118 libelf_release_all (Elf *elf)
    119 {
    120   if (elf->kind == ELF_K_AR)
    121     {
    122       Elf *child = elf->state.ar.children;
    123 
    124       while (child != NULL)
    125 	{
    126 	  if (child->ref_count != 0)
    127 	    libelf_release_all (child);
    128 	  child = child->next;
    129 	}
    130     }
    131 
    132   rwlock_unlock (elf->lock);
    133 }
    134 
    135 
    136 /* Macro to convert endianess in place.  It determines the function it
    137    has to use itself.  */
    138 #define CONVERT(Var) \
    139   (Var) = (sizeof (Var) == 1						      \
    140 	   ? (unsigned char) (Var)					      \
    141 	   : (sizeof (Var) == 2						      \
    142 	      ? bswap_16 (Var)						      \
    143 	      : (sizeof (Var) == 4					      \
    144 		 ? bswap_32 (Var)					      \
    145 		 : bswap_64 (Var))))
    146 
    147 #define CONVERT_TO(Dst, Var) \
    148   (Dst) = (sizeof (Var) == 1						      \
    149 	   ? (unsigned char) (Var)					      \
    150 	   : (sizeof (Var) == 2						      \
    151 	      ? bswap_16 (Var)						      \
    152 	      : (sizeof (Var) == 4					      \
    153 		 ? bswap_32 (Var)					      \
    154 		 : bswap_64 (Var))))
    155 
    156 
    157 #if __BYTE_ORDER == __LITTLE_ENDIAN
    158 # define MY_ELFDATA	ELFDATA2LSB
    159 #else
    160 # define MY_ELFDATA	ELFDATA2MSB
    161 #endif
    162 
    163 #endif	/* common.h */
    164