FD.io VPP  v20.01-48-g3e0dafb74
Vector Packet Processing
elf_clib.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 Cisco and/or its affiliates.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include <vppinfra/elf_clib.h>
16 
17 #include <stdlib.h>
18 #include <fcntl.h>
19 #include <sys/stat.h>
20 
21 typedef struct
22 {
23  char **path;
25 
26 always_inline void
28 {
29  uword i;
30  for (i = 0; i < vec_len (p->path); i++)
31  vec_free (p->path[i]);
32  vec_free (p->path);
33 }
34 
35 static char **
36 split_string (char *string, u8 delimiter)
37 {
38  char **result = 0;
39  char *p, *start, *s;
40 
41  p = string;
42  while (1)
43  {
44  start = p;
45  while (*p != 0 && *p != delimiter)
46  p++;
47  s = 0;
48  vec_add (s, start, p - start);
49  vec_add1 (s, 0);
50  vec_add1 (result, s);
51  if (*p == 0)
52  break;
53  p++;
54  }
55 
56  return result;
57 }
58 
59 static int
60 file_exists_and_is_executable (char *dir, char *file)
61 {
62  char *path = (char *) format (0, "%s/%s%c", dir, file, 0);
63  struct stat s;
64  uword yes;
65 
66  yes = (stat (path, &s) >= 0
67  && S_ISREG (s.st_mode)
68  && 0 != (s.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)));
69 
70  vec_free (path);
71 
72  return yes;
73 }
74 
75 static char *
76 path_search (char *file)
77 {
78  path_search_t ps;
79  uword i;
80  char *result;
81 
82  /* Relative or absolute path. */
83  if (file[0] == '.' || file[0] == '/')
84  return file;
85 
86  if (getenv ("PATH") == 0)
87  return file;
88 
89  ps.path = split_string (getenv ("PATH"), ':');
90 
91  for (i = 0; i < vec_len (ps.path); i++)
92  if (file_exists_and_is_executable (ps.path[i], file))
93  break;
94 
95  result = 0;
96  if (i < vec_len (ps.path))
97  result = (char *) format (0, "%s/%s%c", ps.path[i], file);
98 
99  path_search_free (&ps);
100 
101  return result;
102 }
103 
104 static clib_error_t *
106  char *file_name, void *link_address)
107 {
108  elf_main_t *em;
109  elf_section_t *s;
110  int fd;
111  struct stat fd_stat;
112  uword mmap_length = 0;
113  void *data = 0;
114  clib_error_t *error = 0;
115 
116  vec_add2 (cem->elf_mains, em, 1);
117 
118  fd = open (file_name, 0);
119  if (fd < 0)
120  {
121  error = clib_error_return_unix (0, "open `%s'", file_name);
122  goto done;
123  }
124 
125  if (fstat (fd, &fd_stat) < 0)
126  {
127  error = clib_error_return_unix (0, "fstat `%s'", file_name);
128  goto done;
129  }
130  mmap_length = fd_stat.st_size;
131 
132  data = mmap (0, mmap_length, PROT_READ, MAP_SHARED, fd, /* offset */ 0);
133  if (~pointer_to_uword (data) == 0)
134  {
135  error = clib_error_return_unix (0, "mmap `%s'", file_name);
136  goto done;
137  }
138 
139  error = elf_parse (em, data, mmap_length);
140  if (error)
141  goto done;
142 
143  /* Look for CLIB special sections. */
144  {
145  char *section_name_start = CLIB_ELF_SECTION_ADD_PREFIX ();
146  uword section_name_start_len = strlen (section_name_start);
147 
148  vec_foreach (s, em->sections)
149  {
150  u8 *name = elf_section_name (em, s);
151  uword *p;
152  clib_elf_section_t *vs;
154 
155  /* Section name must begin with CLIB_ELF_SECTION key. */
156  if (strcmp ((char *) name, section_name_start))
157  continue;
158 
159  name += section_name_start_len;
160  p = hash_get_mem (cem->section_by_name, name);
161  if (p)
162  vs = vec_elt_at_index (cem->sections, p[0]);
163  else
164  {
165  name = format (0, "%s%c", name, 0);
166  if (!cem->section_by_name)
167  cem->section_by_name = hash_create_string (0, sizeof (uword));
168  hash_set_mem (cem->section_by_name, name, vec_len (cem->sections));
169  vec_add2 (cem->sections, vs, 1);
170  vs->name = name;
171  }
172 
173  vec_add2 (vs->bounds, b, 1);
174  b->lo = link_address + s->header.exec_address;
175  b->hi = b->lo + s->header.file_size;
176  }
177  }
178 
179  /* Parse symbols for this file. */
180  {
182  elf64_symbol_t *s;
183 
184  elf_parse_symbols (em);
185  vec_foreach (t, em->symbol_tables)
186  {
187  vec_foreach (s, t->symbols)
188  {
189  s->value += pointer_to_uword (link_address);
190  }
191  }
192  }
193 
194  /* No need to keep section contents around. */
195  {
196  elf_section_t *s;
197  vec_foreach (s, em->sections)
198  {
199  if (s->header.type != ELF_SECTION_STRING_TABLE)
200  vec_free (s->contents);
201  }
202  }
203 
204 done:
205  if (error)
206  elf_main_free (em);
207  if (fd >= 0)
208  close (fd);
209  if (data)
210  munmap (data, mmap_length);
211  return error;
212 }
213 
214 #define __USE_GNU
215 #include <link.h>
216 
217 static int
218 add_section (struct dl_phdr_info *info, size_t size, void *opaque)
219 {
220  clib_elf_main_t *cem = opaque;
221  clib_error_t *error;
222  char *name = (char *) info->dlpi_name;
223  void *addr = (void *) info->dlpi_addr;
224  uword is_main;
225 
226  is_main = strlen (name) == 0;
227  if (is_main)
228  {
229  static int done;
230 
231  /* Only do main program once. */
232  if (done++)
233  return 0;
234 
235  name = path_search (cem->exec_path);
236  if (!name)
237  {
238  clib_error ("failed to find %s on PATH", cem->exec_path);
239  return 0;
240  }
241  addr = 0;
242  }
243 
244  error = clib_elf_parse_file (cem, name, addr);
245  if (error)
246  clib_error_report (error);
247 
248  if (is_main && name != cem->exec_path)
249  vec_free (name);
250 
251  return 0;
252 }
253 
255 
256 void
257 clib_elf_main_init (char *exec_path)
258 {
260 
261  cem->exec_path = exec_path;
262 
263  dl_iterate_phdr (add_section, cem);
264 }
265 
268 {
270  uword *p = hash_get (em->section_by_name, name);
271  return p ? vec_elt_at_index (em->sections, p[0])->bounds : 0;
272 }
273 
274 static uword
276  uword by_address, clib_elf_symbol_t * s)
277 {
279  elf_main_t *em;
280 
281  vec_foreach (em, cem->elf_mains)
282  {
284  s->elf_main_index = em - cem->elf_mains;
285  vec_foreach (t, em->symbol_tables)
286  {
287  s->symbol_table_index = t - em->symbol_tables;
288  if (by_name)
289  {
290  uword *p = hash_get (t->symbol_by_name, by_name);
291  if (p)
292  {
293  s->symbol = vec_elt (t->symbols, p[0]);
294  return 1;
295  }
296  }
297  else
298  {
299  elf64_symbol_t *x;
300  /* FIXME linear search. */
301  vec_foreach (x, t->symbols)
302  {
303  if (by_address >= x->value && by_address < x->value + x->size)
304  {
305  s->symbol = x[0];
306  return 1;
307  }
308  }
309  }
310  }
311  }
312 
313  return 0;
314 }
315 
316 uword
318 {
319  return symbol_by_address_or_name (by_name, /* by_address */ 0, s);
320 }
321 
322 uword
324 {
325  return symbol_by_address_or_name ( /* by_name */ 0, by_address, s);
326 }
327 
328 u8 *
329 format_clib_elf_symbol (u8 * s, va_list * args)
330 {
332  clib_elf_symbol_t *sym = va_arg (*args, clib_elf_symbol_t *);
333  elf_main_t *em;
335 
336  if (!sym)
337  /* Just print table headings. */
338  return format (s, "%U", format_elf_symbol, 0, 0, 0);
339 
340  else
341  {
342  em = vec_elt_at_index (cem->elf_mains, sym->elf_main_index);
344  return format (s, "%U", format_elf_symbol, em, t, &sym->symbol);
345  }
346 }
347 
348 u8 *
350 {
351  uword address = va_arg (*args, uword);
353  clib_elf_symbol_t sym;
354  elf_main_t *em;
356 
357  if (clib_elf_symbol_by_address (address, &sym))
358  {
359  em = vec_elt_at_index (cem->elf_mains, sym.elf_main_index);
361  s = format (s, "%s + 0x%wx",
362  elf_symbol_name (t, &sym.symbol),
363  address - sym.symbol.value);
364  }
365  else
366  s = format (s, "0x%wx", address);
367 
368  return s;
369 }
370 
371 /*
372  * fd.io coding-style-patch-verification: ON
373  *
374  * Local Variables:
375  * eval: (c-set-style "gnu")
376  * End:
377  */
clib_elf_section_t * sections
Definition: elf_clib.h:80
static void elf_main_free(elf_main_t *em)
Definition: elf.h:926
static u8 * elf_section_name(elf_main_t *em, elf_section_t *s)
Definition: elf.h:994
char ** path
Definition: elf_clib.c:23
static void path_search_free(path_search_t *p)
Definition: elf_clib.c:27
static int file_exists_and_is_executable(char *dir, char *file)
Definition: elf_clib.c:60
#define clib_error(format, args...)
Definition: error.h:62
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:523
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:561
int i
#define CLIB_ELF_SECTION_ADD_PREFIX(n)
Definition: elf_clib.h:46
#define hash_set_mem(h, key, value)
Definition: hash.h:275
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
vl_api_fib_path_t path
Definition: mfib_types.api:34
void elf_parse_symbols(elf_main_t *em)
Definition: elf.c:869
vhost_vring_addr_t addr
Definition: vhost_user.h:147
unsigned char u8
Definition: types.h:56
uword clib_elf_symbol_by_address(uword by_address, clib_elf_symbol_t *s)
Definition: elf_clib.c:323
#define vec_add(V, E, N)
Add N elements to end of vector V (no header, unspecified alignment)
Definition: vec.h:599
clib_elf_section_bounds_t * bounds
Definition: elf_clib.h:71
u8 * contents
Definition: elf.h:868
static clib_error_t * clib_elf_parse_file(clib_elf_main_t *cem, char *file_name, void *link_address)
Definition: elf_clib.c:105
elf64_symbol_t symbol
Definition: elf_clib.h:121
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
char * exec_path
Definition: elf_clib.h:86
static char ** split_string(char *string, u8 delimiter)
Definition: elf_clib.c:36
elf_symbol_table_t * symbol_tables
Definition: elf.h:902
#define hash_create_string(elts, value_bytes)
Definition: hash.h:690
#define hash_get(h, key)
Definition: hash.h:249
#define clib_error_return_unix(e, args...)
Definition: error.h:102
u64 size
Definition: vhost_user.h:140
#define always_inline
Definition: ipsec.h:28
uword * section_by_name
Definition: elf_clib.h:83
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:342
void clib_elf_main_init(char *exec_path)
Definition: elf_clib.c:257
elf64_symbol_t * symbols
Definition: elf.h:818
string name[64]
Definition: ip.api:44
elf_main_t * elf_mains
Definition: elf_clib.h:88
u8 value
Definition: qos.api:54
manual_print typedef address
Definition: ip_types.api:84
uword clib_elf_symbol_by_name(char *by_name, clib_elf_symbol_t *s)
Definition: elf_clib.c:317
u8 data[128]
Definition: ipsec_types.api:87
#define clib_error_report(e)
Definition: error.h:113
elf_section_t * sections
Definition: elf.h:897
static char * path_search(char *file)
Definition: elf_clib.c:76
clib_elf_section_bounds_t * clib_elf_get_section_bounds(char *name)
Definition: elf_clib.c:267
static uword pointer_to_uword(const void *p)
Definition: types.h:131
static uword symbol_by_address_or_name(char *by_name, uword by_address, clib_elf_symbol_t *s)
Definition: elf_clib.c:275
#define vec_elt(v, i)
Get vector value at index i.
u8 * format_clib_elf_symbol(u8 *s, va_list *args)
Definition: elf_clib.c:329
static u8 * elf_symbol_name(elf_symbol_table_t *t, elf64_symbol_t *sym)
Definition: elf.h:835
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
clib_error_t * elf_parse(elf_main_t *em, void *data, uword data_bytes)
Definition: elf.c:978
uword * symbol_by_name
Definition: elf.h:824
u64 uword
Definition: types.h:112
format_function_t format_elf_symbol
Definition: elf.h:1031
#define hash_get_mem(h, key)
Definition: hash.h:269
u8 * format_clib_elf_symbol_with_address(u8 *s, va_list *args)
Definition: elf_clib.c:349
elf64_section_header_t header
Definition: elf.h:855
#define vec_foreach(var, vec)
Vector iterator.
static int add_section(struct dl_phdr_info *info, size_t size, void *opaque)
Definition: elf_clib.c:218
u32 symbol_table_index
Definition: elf_clib.h:127
static clib_elf_main_t clib_elf_main
Definition: elf_clib.c:254