X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Flttng-elf.c;h=cb01f7bb7d38195ed9e214ea784bd578379677c4;hp=779beee012929c5fa3a927f78a5a15cb0b527b3e;hb=512df0460fc4c7a4492c8feadf45bb8da6b4c166;hpb=d0927b411543c173c4fb83abf785fd71a9d29ed1

diff --git a/src/common/lttng-elf.c b/src/common/lttng-elf.c
index 779beee01..cb01f7bb7 100644
--- a/src/common/lttng-elf.c
+++ b/src/common/lttng-elf.c
@@ -38,6 +38,8 @@
 #define TEXT_SECTION_NAME 	".text"
 #define SYMBOL_TAB_SECTION_NAME ".symtab"
 #define STRING_TAB_SECTION_NAME ".strtab"
+#define DYNAMIC_SYMBOL_TAB_SECTION_NAME ".dynsym"
+#define DYNAMIC_STRING_TAB_SECTION_NAME ".dynstr"
 #define NOTE_STAPSDT_SECTION_NAME ".note.stapsdt"
 #define NOTE_STAPSDT_NAME "stapsdt"
 #define NOTE_STAPSDT_TYPE 3
@@ -48,6 +50,8 @@
 #define NATIVE_ELF_ENDIANNESS ELFDATA2MSB
 #endif
 
+#define next_4bytes_boundary(x) (typeof(x)) ((((uint64_t)x) + 3) & ~0x03)
+
 #define bswap(x)				\
 	do {					\
 		switch (sizeof(x)) {		\
@@ -329,7 +333,6 @@ struct lttng_elf_shdr *lttng_elf_get_section_hdr(struct lttng_elf *elf,
 
 	ret = populate_section_header(elf, section_header, index);
 	if (ret) {
-		ret = LTTNG_ERR_ELF_PARSING;
 		DBG("Error populating section header.");
 		goto error;
 	}
@@ -735,6 +738,7 @@ int lttng_elf_get_symbol_offset(int fd, char *symbol, uint64_t *offset)
 	char *curr_sym_str = NULL;
 	char *symbol_table_data = NULL;
 	char *string_table_data = NULL;
+	char *string_table_name = NULL;
 	struct lttng_elf_shdr *symtab_hdr = NULL;
 	struct lttng_elf_shdr *strtab_hdr = NULL;
 	struct lttng_elf *elf = NULL;
@@ -750,14 +754,29 @@ int lttng_elf_get_symbol_offset(int fd, char *symbol, uint64_t *offset)
 		goto end;
 	}
 
-	/* Get the symbol table section header. */
+	/*
+	 * The .symtab section might not exist on stripped binaries.
+	 * Try to get the symbol table section header first. If it's absent,
+	 * try to get the dynamic symbol table. All symbols in the dynamic
+	 * symbol tab are in the (normal) symbol table if it exists.
+	 */
 	ret = lttng_elf_get_section_hdr_by_name(elf, SYMBOL_TAB_SECTION_NAME,
 			&symtab_hdr);
 	if (ret) {
-		DBG("Cannot get ELF Symbol Table section.");
-		ret = LTTNG_ERR_ELF_PARSING;
-		goto destroy_elf;
+		DBG("Cannot get ELF Symbol Table section. Trying to get ELF Dynamic Symbol Table section.");
+		/* Get the dynamic symbol table section header. */
+		ret = lttng_elf_get_section_hdr_by_name(elf, DYNAMIC_SYMBOL_TAB_SECTION_NAME,
+				&symtab_hdr);
+		if (ret) {
+			DBG("Cannot get ELF Symbol Table nor Dynamic Symbol Table sections.");
+			ret = LTTNG_ERR_ELF_PARSING;
+			goto destroy_elf;
+		}
+		string_table_name = DYNAMIC_STRING_TAB_SECTION_NAME;
+	} else {
+		string_table_name = STRING_TAB_SECTION_NAME;
 	}
+
 	/* Get the data associated with the symbol table section. */
 	symbol_table_data = lttng_elf_get_section_data(elf, symtab_hdr);
 	if (symbol_table_data == NULL) {
@@ -767,7 +786,7 @@ int lttng_elf_get_symbol_offset(int fd, char *symbol, uint64_t *offset)
 	}
 
 	/* Get the string table section header. */
-	ret = lttng_elf_get_section_hdr_by_name(elf, STRING_TAB_SECTION_NAME,
+	ret = lttng_elf_get_section_hdr_by_name(elf, string_table_name,
 			&strtab_hdr);
 	if (ret) {
 		DBG("Cannot get ELF string table section.");
@@ -842,7 +861,7 @@ int lttng_elf_get_symbol_offset(int fd, char *symbol, uint64_t *offset)
 	 */
 	ret = lttng_elf_convert_addr_in_text_to_offset(elf, addr, offset);
 	if (ret) {
-		DBG("Cannot convet addr to offset.");
+		DBG("Cannot convert addr to offset.");
 		goto free_string_table_data;
 	}
 
@@ -856,3 +875,182 @@ destroy_elf:
 end:
 	return ret;
 }
+
+/*
+ * Compute the offsets of SDT probes from the begining of the ELF binary.
+ *
+ * On success, returns 0 and the nb_probes parameter is set to the number of
+ * offsets found and the offsets parameter points to an array of offsets where
+ * the SDT probes are.
+ * On failure, returns -1.
+ */
+int lttng_elf_get_sdt_probe_offsets(int fd, const char *provider_name,
+		const char *probe_name, uint64_t **offsets, uint32_t *nb_probes)
+{
+	int ret = 0, nb_match = 0;
+	struct lttng_elf_shdr *stap_note_section_hdr = NULL;
+	struct lttng_elf *elf = NULL;
+	char *stap_note_section_data = NULL;
+	char *curr_note_section_begin, *curr_data_ptr, *curr_probe, *curr_provider;
+	char *next_note_ptr;
+	uint32_t name_size, desc_size, note_type;
+	uint64_t curr_probe_location, curr_probe_offset, curr_semaphore_location;
+	uint64_t *probe_locs = NULL, *new_probe_locs = NULL;
+
+	if (!provider_name || !probe_name || !nb_probes || !offsets) {
+		DBG("Invalid arguments.");
+		ret = LTTNG_ERR_ELF_PARSING;
+		goto error;
+	}
+
+	elf = lttng_elf_create(fd);
+	if (!elf) {
+		DBG("Error allocation ELF.");
+		ret = LTTNG_ERR_ELF_PARSING;
+		goto error;
+	}
+
+	/* Get the stap note section header. */
+	ret = lttng_elf_get_section_hdr_by_name(elf, NOTE_STAPSDT_SECTION_NAME,
+			&stap_note_section_hdr);
+	if (ret) {
+		DBG("Cannot get ELF stap note section.");
+		goto destroy_elf_error;
+	}
+
+	/* Get the data associated with the stap note section. */
+	stap_note_section_data = lttng_elf_get_section_data(elf, stap_note_section_hdr);
+	if (stap_note_section_data == NULL) {
+		DBG("Cannot get ELF stap note section data.");
+		ret = LTTNG_ERR_ELF_PARSING;
+		goto destroy_elf_error;
+	}
+
+	next_note_ptr = stap_note_section_data;
+	curr_note_section_begin = stap_note_section_data;
+
+	*offsets = NULL;
+	while (1) {
+		curr_data_ptr = next_note_ptr;
+		/* Check if we have reached the end of the note section. */
+		if (curr_data_ptr >=
+				curr_note_section_begin + stap_note_section_hdr->sh_size) {
+			*nb_probes = nb_match;
+			*offsets = probe_locs;
+			ret = 0;
+			break;
+		}
+		/* Get name size field. */
+		name_size = next_4bytes_boundary(*(uint32_t*) curr_data_ptr);
+		curr_data_ptr += sizeof(uint32_t);
+
+		/* Sanity check; a zero name_size is reserved. */
+		if (name_size == 0) {
+			DBG("Invalid name size field in SDT probe descriptions"
+				"section.");
+			ret = -1;
+			goto realloc_error;
+		}
+
+		/* Get description size field. */
+		desc_size = next_4bytes_boundary(*(uint32_t*) curr_data_ptr);
+		curr_data_ptr += sizeof(uint32_t);
+
+		/* Get type field. */
+		note_type = *(uint32_t *) curr_data_ptr;
+		curr_data_ptr += sizeof(uint32_t);
+
+		/*
+		 * Move the pointer to the next note to be ready for the next
+		 * iteration. The current note is made of 3 unsigned 32bit
+		 * integers (name size, descriptor size and note type), the
+		 * name and the descriptor. To move to the next note, we move
+		 * the pointer according to those values.
+		 */
+		next_note_ptr = next_note_ptr +
+			(3 * sizeof(uint32_t)) + desc_size + name_size;
+
+		/*
+		 * Move ptr to the end of the name string (we don't need it)
+		 * and go to the next 4 byte alignement.
+		 */
+		if (note_type != NOTE_STAPSDT_TYPE ||
+			strncmp(curr_data_ptr, NOTE_STAPSDT_NAME, name_size) != 0) {
+			continue;
+		}
+
+		curr_data_ptr += name_size;
+
+		/* Get probe location.  */
+		curr_probe_location = *(uint64_t *) curr_data_ptr;
+		curr_data_ptr += sizeof(uint64_t);
+
+		/* Pass over the base. Not needed. */
+		curr_data_ptr += sizeof(uint64_t);
+
+		/* Get semaphore location. */
+		curr_semaphore_location = *(uint64_t *) curr_data_ptr;
+		curr_data_ptr += sizeof(uint64_t);
+		/* Get provider name. */
+		curr_provider = curr_data_ptr;
+		curr_data_ptr += strlen(curr_provider) + 1;
+
+		/* Get probe name. */
+		curr_probe = curr_data_ptr;
+
+		/* Check if the provider and probe name match */
+		if (strcmp(provider_name, curr_provider) == 0 &&
+				strcmp(probe_name, curr_probe) == 0) {
+			int new_size;
+
+			/*
+			 * We currently don't support SDT probes with semaphores. Return
+			 * success as we found a matching probe but it's guarded by a
+			 * semaphore.
+			 */
+			if (curr_semaphore_location != 0) {
+				ret = LTTNG_ERR_SDT_PROBE_SEMAPHORE;
+				goto realloc_error;
+			}
+
+			new_size = (++nb_match) * sizeof(uint64_t);
+
+			/*
+			 * Found a match with not semaphore, we need to copy the
+			 * probe_location to the output parameter.
+			 */
+			new_probe_locs = realloc(probe_locs, new_size);
+			if (!new_probe_locs) {
+				/* Error allocating a larger buffer */
+				DBG("Allocation error in SDT.");
+				ret = LTTNG_ERR_NOMEM;
+				goto realloc_error;
+			}
+			probe_locs = new_probe_locs;
+			new_probe_locs = NULL;
+
+			/*
+			 * Use the virtual address of the probe to compute the offset of
+			 * this probe from the beginning of the executable file.
+			 */
+			ret = lttng_elf_convert_addr_in_text_to_offset(elf,
+					curr_probe_location, &curr_probe_offset);
+			if (ret) {
+				DBG("Conversion error in SDT.");
+				goto realloc_error;
+			}
+
+			probe_locs[nb_match - 1] = curr_probe_offset;
+		}
+	}
+
+end:
+	free(stap_note_section_data);
+destroy_elf_error:
+	lttng_elf_destroy(elf);
+error:
+	return ret;
+realloc_error:
+	free(probe_locs);
+	goto end;
+}