memcheck/memcheck_util.c - platform/external/qemu.git - Git at Google

 /* Copyright (C) 2007-2010 The Android Open Source Project
 **
 ** This software is licensed under the terms of the GNU General Public
 ** License version 2, as published by the Free Software Foundation, and
 ** may be copied, distributed, and modified under those terms.
 **
 ** This program is distributed in the hope that it will be useful,
 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ** GNU General Public License for more details.
 */

 /*
  * Contains implementation of utility routines for memchecker framework.
  */

 #include "stdio.h"
 #include "qemu-common.h"
 #include "android/utils/path.h"
 #include "cpu.h"
 #include "memcheck_util.h"
 #include "memcheck_proc_management.h"
 #include "memcheck_logging.h"
 //#include "softmmu_outside_jit.h"

 /* Gets symblos file path for the given module.
  * Param:
  *  module_path - Path to the module to get sympath for.
  *  sym_path - Buffer, where to save path to the symbols file path for the givem
  *      module. NOTE: This buffer must be big enough to contain the largest
  *      path possible.
  *  max_char - Character size of the buffer addressed by sym_path parameter.
  * Return:
  *  0 on success, or -1 if symbols file has not been found, or sym_path buffer
  *  was too small to contain entire path.
  */
 static int
 get_sym_path(const char* module_path, char* sym_path, size_t max_char)
 {
     const char* sym_path_root = getenv("ANDROID_PROJECT_OUT");
     if (sym_path_root == NULL || strlen(sym_path_root) >= max_char) {
         return -1;
     }

     strcpy(sym_path, sym_path_root);
     max_char -= strlen(sym_path_root);
     if (sym_path[strlen(sym_path)-1] != PATH_SEP_C) {
         strcat(sym_path, PATH_SEP);
         max_char--;
     }
     if (strlen("symbols") >= max_char) {
         return -1;
     }
     strcat(sym_path, "symbols");
     max_char -= strlen("symbols");
     if (strlen(module_path) >= max_char) {
         return -1;
     }
     strcat(sym_path, module_path);

     /* Sometimes symbol file for a module is placed into a parent symbols
      * directory. Lets iterate through all parent sym dirs, until we find
      * sym file, or reached symbols root. */
     while (!path_exists(sym_path)) {
         /* Select module name. */
         char* name = strrchr(sym_path, PATH_SEP_C);
         assert(name != NULL);
         *name = '\0';
         /* Parent directory. */
         char* parent = strrchr(sym_path, PATH_SEP_C);
         assert(parent != NULL);
         *parent = '\0';
         if (strcmp(sym_path, sym_path_root) == 0) {
             return -1;
         }
         *parent = PATH_SEP_C;
         memmove(parent+1, name + 1, strlen(name + 1) + 1);
     }

     return 0;
 }

 // =============================================================================
 // Transfering data between guest and emulator address spaces.
 // =============================================================================

 void
 memcheck_get_guest_buffer(void* qemu_address,
                           target_ulong guest_address,
                           size_t buffer_size)
 {
     /* Byte-by-byte copying back and forth between guest's and emulator's memory
      * appears to be efficient enough (at least on small blocks used in
      * memchecker), so there is no real need to optimize it by aligning guest
      * buffer to 32 bits and use ld/stl_user instead of ld/stub_user to
      * read / write guest's memory. */
     while (buffer_size) {
         *(uint8_t*)qemu_address = ldub_user(guest_address);
         qemu_address = (uint8_t*)qemu_address + 1;
         guest_address++;
         buffer_size--;
     }
 }

 void
 memcheck_set_guest_buffer(target_ulong guest_address,
                           const void* qemu_address,
                           size_t buffer_size)
 {
     while (buffer_size) {
         stb_user(guest_address, *(uint8_t*)qemu_address);
         guest_address++;
         qemu_address = (uint8_t*)qemu_address + 1;
         buffer_size--;
     }
 }

 size_t
 memcheck_get_guest_string(char* qemu_str,
                           target_ulong guest_str,
                           size_t qemu_buffer_size)
 {
     size_t copied = 0;

     if (qemu_buffer_size > 1) {
         for (copied = 0; copied < qemu_buffer_size - 1; copied++) {
             qemu_str[copied] = ldub_user(guest_str + copied);
             if (qemu_str[copied] == '\0') {
                 return copied;
             }
         }
     }
     qemu_str[copied] = '\0';
     return copied;
 }

 size_t
 memcheck_get_guest_kernel_string(char* qemu_str,
                                  target_ulong guest_str,
                                  size_t qemu_buffer_size)
 {
     size_t copied = 0;

     if (qemu_buffer_size > 1) {
         for (copied = 0; copied < qemu_buffer_size - 1; copied++) {
             qemu_str[copied] = ldub_kernel(guest_str + copied);
             if (qemu_str[copied] == '\0') {
                 return copied;
             }
         }
     }
     qemu_str[copied] = '\0';
     return copied;
 }

 // =============================================================================
 // Helpers for transfering memory allocation information.
 // =============================================================================

 void
 memcheck_fail_alloc(target_ulong guest_address)
 {
     stl_user(ALLOC_RES_ADDRESS(guest_address), 0);
 }

 void
 memcheck_fail_free(target_ulong guest_address)
 {
     stl_user(FREE_RES_ADDRESS(guest_address), 0);
 }

 void
 memcheck_fail_query(target_ulong guest_address)
 {
     stl_user(QUERY_RES_ADDRESS(guest_address), 0);
 }

 // =============================================================================
 // Misc. utility routines.
 // =============================================================================

 void
 invalidate_tlb_cache(target_ulong start, target_ulong end)
 {
     target_ulong index = (start >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
     const target_ulong to = ((end - 1) >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE-1);
     for (; index <= to; index++, start += TARGET_PAGE_SIZE) {
         target_ulong tlb_addr = cpu_single_env->tlb_table[1][index].addr_write;
         if ((start & TARGET_PAGE_MASK) ==
             (tlb_addr & (TARGET_PAGE_MASK | TLB_INVALID_MASK))) {
             cpu_single_env->tlb_table[1][index].addr_write ^= TARGET_PAGE_MASK;
         }
         tlb_addr = cpu_single_env->tlb_table[1][index].addr_read;
         if ((start & TARGET_PAGE_MASK) ==
             (tlb_addr & (TARGET_PAGE_MASK | TLB_INVALID_MASK))) {
             cpu_single_env->tlb_table[1][index].addr_read ^= TARGET_PAGE_MASK;
         }
     }
 }

 void
 memcheck_dump_malloc_desc(const MallocDescEx* desc_ex,
                           int print_flags,
                           int print_proc_info)
 {
     const MallocDesc* desc = &desc_ex->malloc_desc;
     printf("            User range:             0x%08X - 0x%08X, %u bytes\n",
            (uint32_t)mallocdesc_get_user_ptr(desc),
             (uint32_t)mallocdesc_get_user_ptr(desc) + desc->requested_bytes,
            desc->requested_bytes);
     printf("            Prefix guarding area:   0x%08X - 0x%08X, %u bytes\n",
            desc->ptr, desc->ptr + desc->prefix_size, desc->prefix_size);
     printf("            Suffix guarding area:   0x%08X - 0x%08X, %u bytes\n",
            mallocdesc_get_user_alloc_end(desc),
            mallocdesc_get_user_alloc_end(desc) + desc->suffix_size,
            desc->suffix_size);
     if (print_proc_info) {
         ProcDesc* proc = get_process_from_pid(desc->allocator_pid);
         if (proc != NULL) {
             printf("            Allocated by:           %s[pid=%u]\n",
                    proc->image_path, proc->pid);
         }
     }
     if (print_flags) {
         printf("            Flags:                  0x%08X\n", desc_ex->flags);
     }
 }

 int
 memcheck_get_address_info(target_ulong abs_pc,
                           const MMRangeDesc* rdesc,
                           Elf_AddressInfo* info,
                           ELFF_HANDLE* elff_handle)
 {
     char sym_path[MAX_PATH];
     ELFF_HANDLE handle;

     if (get_sym_path(rdesc->path, sym_path, MAX_PATH)) {
         return 1;
     }

     handle = elff_init(sym_path);
     if (handle == NULL) {
         return -1;
     }

     if (!elff_is_exec(handle)) {
         /* Debug info for shared library is created for the relative address. */
         target_ulong rel_pc = mmrangedesc_get_module_offset(rdesc, abs_pc);
         if (elff_get_pc_address_info(handle, rel_pc, info)) {
             elff_close(handle);
             return -1;
         }
     } else {
         /* Debug info for executables is created for the absoulte address. */
         if (elff_get_pc_address_info(handle, abs_pc, info)) {
             elff_close(handle);
             return -1;
         }
     }

     *elff_handle = handle;
     return 0;
 }
	/* Copyright (C) 2007-2010 The Android Open Source Project
	**
	** This software is licensed under the terms of the GNU General Public
	** License version 2, as published by the Free Software Foundation, and
	** may be copied, distributed, and modified under those terms.
	**
	** This program is distributed in the hope that it will be useful,
	** but WITHOUT ANY WARRANTY; without even the implied warranty of
	** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	** GNU General Public License for more details.
	*/

	/*
	* Contains implementation of utility routines for memchecker framework.
	*/

	#include "stdio.h"
	#include "qemu-common.h"
	#include "android/utils/path.h"
	#include "cpu.h"
	#include "memcheck_util.h"
	#include "memcheck_proc_management.h"
	#include "memcheck_logging.h"
	//#include "softmmu_outside_jit.h"

	/* Gets symblos file path for the given module.
	* Param:
	* module_path - Path to the module to get sympath for.
	* sym_path - Buffer, where to save path to the symbols file path for the givem
	* module. NOTE: This buffer must be big enough to contain the largest
	* path possible.
	* max_char - Character size of the buffer addressed by sym_path parameter.
	* Return:
	* 0 on success, or -1 if symbols file has not been found, or sym_path buffer
	* was too small to contain entire path.
	*/
	static int
	get_sym_path(const char* module_path, char* sym_path, size_t max_char)
	{
	const char* sym_path_root = getenv("ANDROID_PROJECT_OUT");
	if (sym_path_root == NULL \|\| strlen(sym_path_root) >= max_char) {
	return -1;
	}

	strcpy(sym_path, sym_path_root);
	max_char -= strlen(sym_path_root);
	if (sym_path[strlen(sym_path)-1] != PATH_SEP_C) {
	strcat(sym_path, PATH_SEP);
	max_char--;
	}
	if (strlen("symbols") >= max_char) {
	return -1;
	}
	strcat(sym_path, "symbols");
	max_char -= strlen("symbols");
	if (strlen(module_path) >= max_char) {
	return -1;
	}
	strcat(sym_path, module_path);

	/* Sometimes symbol file for a module is placed into a parent symbols
	* directory. Lets iterate through all parent sym dirs, until we find
	* sym file, or reached symbols root. */
	while (!path_exists(sym_path)) {
	/* Select module name. */
	char* name = strrchr(sym_path, PATH_SEP_C);
	assert(name != NULL);
	*name = '\0';
	/* Parent directory. */
	char* parent = strrchr(sym_path, PATH_SEP_C);
	assert(parent != NULL);
	*parent = '\0';
	if (strcmp(sym_path, sym_path_root) == 0) {
	return -1;
	}
	*parent = PATH_SEP_C;
	memmove(parent+1, name + 1, strlen(name + 1) + 1);
	}

	return 0;
	}

	// =============================================================================
	// Transfering data between guest and emulator address spaces.
	// =============================================================================

	void
	memcheck_get_guest_buffer(void* qemu_address,
	target_ulong guest_address,
	size_t buffer_size)
	{
	/* Byte-by-byte copying back and forth between guest's and emulator's memory
	* appears to be efficient enough (at least on small blocks used in
	* memchecker), so there is no real need to optimize it by aligning guest
	* buffer to 32 bits and use ld/stl_user instead of ld/stub_user to
	* read / write guest's memory. */
	while (buffer_size) {
	(uint8_t)qemu_address = ldub_user(guest_address);
	qemu_address = (uint8_t*)qemu_address + 1;
	guest_address++;
	buffer_size--;
	}
	}

	void
	memcheck_set_guest_buffer(target_ulong guest_address,
	const void* qemu_address,
	size_t buffer_size)
	{
	while (buffer_size) {
	stb_user(guest_address, (uint8_t)qemu_address);
	guest_address++;
	qemu_address = (uint8_t*)qemu_address + 1;
	buffer_size--;
	}
	}

	size_t
	memcheck_get_guest_string(char* qemu_str,
	target_ulong guest_str,
	size_t qemu_buffer_size)
	{
	size_t copied = 0;

	if (qemu_buffer_size > 1) {
	for (copied = 0; copied < qemu_buffer_size - 1; copied++) {
	qemu_str[copied] = ldub_user(guest_str + copied);
	if (qemu_str[copied] == '\0') {
	return copied;
	}
	}
	}
	qemu_str[copied] = '\0';
	return copied;
	}

	size_t
	memcheck_get_guest_kernel_string(char* qemu_str,
	target_ulong guest_str,
	size_t qemu_buffer_size)
	{
	size_t copied = 0;

	if (qemu_buffer_size > 1) {
	for (copied = 0; copied < qemu_buffer_size - 1; copied++) {
	qemu_str[copied] = ldub_kernel(guest_str + copied);
	if (qemu_str[copied] == '\0') {
	return copied;
	}
	}
	}
	qemu_str[copied] = '\0';
	return copied;
	}

	// =============================================================================
	// Helpers for transfering memory allocation information.
	// =============================================================================

	void
	memcheck_fail_alloc(target_ulong guest_address)
	{
	stl_user(ALLOC_RES_ADDRESS(guest_address), 0);
	}

	void
	memcheck_fail_free(target_ulong guest_address)
	{
	stl_user(FREE_RES_ADDRESS(guest_address), 0);
	}

	void
	memcheck_fail_query(target_ulong guest_address)
	{
	stl_user(QUERY_RES_ADDRESS(guest_address), 0);
	}

	// =============================================================================
	// Misc. utility routines.
	// =============================================================================

	void
	invalidate_tlb_cache(target_ulong start, target_ulong end)
	{
	target_ulong index = (start >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
	const target_ulong to = ((end - 1) >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE-1);
	for (; index <= to; index++, start += TARGET_PAGE_SIZE) {
	target_ulong tlb_addr = cpu_single_env->tlb_table[1][index].addr_write;
	if ((start & TARGET_PAGE_MASK) ==
	(tlb_addr & (TARGET_PAGE_MASK \| TLB_INVALID_MASK))) {
	cpu_single_env->tlb_table[1][index].addr_write ^= TARGET_PAGE_MASK;
	}
	tlb_addr = cpu_single_env->tlb_table[1][index].addr_read;
	if ((start & TARGET_PAGE_MASK) ==
	(tlb_addr & (TARGET_PAGE_MASK \| TLB_INVALID_MASK))) {
	cpu_single_env->tlb_table[1][index].addr_read ^= TARGET_PAGE_MASK;
	}
	}
	}

	void
	memcheck_dump_malloc_desc(const MallocDescEx* desc_ex,
	int print_flags,
	int print_proc_info)
	{
	const MallocDesc* desc = &desc_ex->malloc_desc;
	printf(" User range: 0x%08X - 0x%08X, %u bytes\n",
	(uint32_t)mallocdesc_get_user_ptr(desc),
	(uint32_t)mallocdesc_get_user_ptr(desc) + desc->requested_bytes,
	desc->requested_bytes);
	printf(" Prefix guarding area: 0x%08X - 0x%08X, %u bytes\n",
	desc->ptr, desc->ptr + desc->prefix_size, desc->prefix_size);
	printf(" Suffix guarding area: 0x%08X - 0x%08X, %u bytes\n",
	mallocdesc_get_user_alloc_end(desc),
	mallocdesc_get_user_alloc_end(desc) + desc->suffix_size,
	desc->suffix_size);
	if (print_proc_info) {
	ProcDesc* proc = get_process_from_pid(desc->allocator_pid);
	if (proc != NULL) {
	printf(" Allocated by: %s[pid=%u]\n",
	proc->image_path, proc->pid);
	}
	}
	if (print_flags) {
	printf(" Flags: 0x%08X\n", desc_ex->flags);
	}
	}

	int
	memcheck_get_address_info(target_ulong abs_pc,
	const MMRangeDesc* rdesc,
	Elf_AddressInfo* info,
	ELFF_HANDLE* elff_handle)
	{
	char sym_path[MAX_PATH];
	ELFF_HANDLE handle;

	if (get_sym_path(rdesc->path, sym_path, MAX_PATH)) {
	return 1;
	}

	handle = elff_init(sym_path);
	if (handle == NULL) {
	return -1;
	}

	if (!elff_is_exec(handle)) {
	/* Debug info for shared library is created for the relative address. */
	target_ulong rel_pc = mmrangedesc_get_module_offset(rdesc, abs_pc);
	if (elff_get_pc_address_info(handle, rel_pc, info)) {
	elff_close(handle);
	return -1;
	}
	} else {
	/* Debug info for executables is created for the absoulte address. */
	if (elff_get_pc_address_info(handle, abs_pc, info)) {
	elff_close(handle);
	return -1;
	}
	}

	*elff_handle = handle;
	return 0;
	}